osbzr
/
com
项目红包剩余9514，下一贡献奖励5%，即 476个红包
Watch 15
Star 7
Wiki 捐赠
本站源代码
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: gamification
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'gamification'
${ noResults }
com/vendor/gopkg.in/yaml.v2/apic.go

740 lines
21KB
Raw Permalink Blame History 

  1. package yaml

  2. 

  3. import (

  4. 	"io"

  5. )

  6. 

  7. func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {

  8. 	//fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))

  9. 

  10. 	// Check if we can move the queue at the beginning of the buffer.

  11. 	if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {

  12. 		if parser.tokens_head != len(parser.tokens) {

  13. 			copy(parser.tokens, parser.tokens[parser.tokens_head:])

  14. 		}

  15. 		parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]

  16. 		parser.tokens_head = 0

  17. 	}

  18. 	parser.tokens = append(parser.tokens, *token)

  19. 	if pos < 0 {

  20. 		return

  21. 	}

  22. 	copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])

  23. 	parser.tokens[parser.tokens_head+pos] = *token

  24. }

  25. 

  26. // Create a new parser object.

  27. func yaml_parser_initialize(parser *yaml_parser_t) bool {

  28. 	*parser = yaml_parser_t{

  29. 		raw_buffer: make([]byte, 0, input_raw_buffer_size),

  30. 		buffer:     make([]byte, 0, input_buffer_size),

  31. 	}

  32. 	return true

  33. }

  34. 

  35. // Destroy a parser object.

  36. func yaml_parser_delete(parser *yaml_parser_t) {

  37. 	*parser = yaml_parser_t{}

  38. }

  39. 

  40. // String read handler.

  41. func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {

  42. 	if parser.input_pos == len(parser.input) {

  43. 		return 0, io.EOF

  44. 	}

  45. 	n = copy(buffer, parser.input[parser.input_pos:])

  46. 	parser.input_pos += n

  47. 	return n, nil

  48. }

  49. 

  50. // Reader read handler.

  51. func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {

  52. 	return parser.input_reader.Read(buffer)

  53. }

  54. 

  55. // Set a string input.

  56. func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {

  57. 	if parser.read_handler != nil {

  58. 		panic("must set the input source only once")

  59. 	}

  60. 	parser.read_handler = yaml_string_read_handler

  61. 	parser.input = input

  62. 	parser.input_pos = 0

  63. }

  64. 

  65. // Set a file input.

  66. func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {

  67. 	if parser.read_handler != nil {

  68. 		panic("must set the input source only once")

  69. 	}

  70. 	parser.read_handler = yaml_reader_read_handler

  71. 	parser.input_reader = r

  72. }

  73. 

  74. // Set the source encoding.

  75. func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {

  76. 	if parser.encoding != yaml_ANY_ENCODING {

  77. 		panic("must set the encoding only once")

  78. 	}

  79. 	parser.encoding = encoding

  80. }

  81. 

  82. // Create a new emitter object.

  83. func yaml_emitter_initialize(emitter *yaml_emitter_t) {

  84. 	*emitter = yaml_emitter_t{

  85. 		buffer:     make([]byte, output_buffer_size),

  86. 		raw_buffer: make([]byte, 0, output_raw_buffer_size),

  87. 		states:     make([]yaml_emitter_state_t, 0, initial_stack_size),

  88. 		events:     make([]yaml_event_t, 0, initial_queue_size),

  89. 	}

  90. }

  91. 

  92. // Destroy an emitter object.

  93. func yaml_emitter_delete(emitter *yaml_emitter_t) {

  94. 	*emitter = yaml_emitter_t{}

  95. }

  96. 

  97. // String write handler.

  98. func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {

  99. 	*emitter.output_buffer = append(*emitter.output_buffer, buffer...)

  100. 	return nil

  101. }

  102. 

  103. // yaml_writer_write_handler uses emitter.output_writer to write the

  104. // emitted text.

  105. func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {

  106. 	_, err := emitter.output_writer.Write(buffer)

  107. 	return err

  108. }

  109. 

  110. // Set a string output.

  111. func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {

  112. 	if emitter.write_handler != nil {

  113. 		panic("must set the output target only once")

  114. 	}

  115. 	emitter.write_handler = yaml_string_write_handler

  116. 	emitter.output_buffer = output_buffer

  117. }

  118. 

  119. // Set a file output.

  120. func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {

  121. 	if emitter.write_handler != nil {

  122. 		panic("must set the output target only once")

  123. 	}

  124. 	emitter.write_handler = yaml_writer_write_handler

  125. 	emitter.output_writer = w

  126. }

  127. 

  128. // Set the output encoding.

  129. func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {

  130. 	if emitter.encoding != yaml_ANY_ENCODING {

  131. 		panic("must set the output encoding only once")

  132. 	}

  133. 	emitter.encoding = encoding

  134. }

  135. 

  136. // Set the canonical output style.

  137. func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {

  138. 	emitter.canonical = canonical

  139. }

  140. 

  141. //// Set the indentation increment.

  142. func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {

  143. 	if indent < 2 || indent > 9 {

  144. 		indent = 2

  145. 	}

  146. 	emitter.best_indent = indent

  147. }

  148. 

  149. // Set the preferred line width.

  150. func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {

  151. 	if width < 0 {

  152. 		width = -1

  153. 	}

  154. 	emitter.best_width = width

  155. }

  156. 

  157. // Set if unescaped non-ASCII characters are allowed.

  158. func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {

  159. 	emitter.unicode = unicode

  160. }

  161. 

  162. // Set the preferred line break character.

  163. func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {

  164. 	emitter.line_break = line_break

  165. }

  166. 

  167. ///*

  168. // * Destroy a token object.

  169. // */

  170. //

  171. //YAML_DECLARE(void)

  172. //yaml_token_delete(yaml_token_t *token)

  173. //{

  174. //    assert(token);  // Non-NULL token object expected.

  175. //

  176. //    switch (token.type)

  177. //    {

  178. //        case YAML_TAG_DIRECTIVE_TOKEN:

  179. //            yaml_free(token.data.tag_directive.handle);

  180. //            yaml_free(token.data.tag_directive.prefix);

  181. //            break;

  182. //

  183. //        case YAML_ALIAS_TOKEN:

  184. //            yaml_free(token.data.alias.value);

  185. //            break;

  186. //

  187. //        case YAML_ANCHOR_TOKEN:

  188. //            yaml_free(token.data.anchor.value);

  189. //            break;

  190. //

  191. //        case YAML_TAG_TOKEN:

  192. //            yaml_free(token.data.tag.handle);

  193. //            yaml_free(token.data.tag.suffix);

  194. //            break;

  195. //

  196. //        case YAML_SCALAR_TOKEN:

  197. //            yaml_free(token.data.scalar.value);

  198. //            break;

  199. //

  200. //        default:

  201. //            break;

  202. //    }

  203. //

  204. //    memset(token, 0, sizeof(yaml_token_t));

  205. //}

  206. //

  207. ///*

  208. // * Check if a string is a valid UTF-8 sequence.

  209. // *

  210. // * Check 'reader.c' for more details on UTF-8 encoding.

  211. // */

  212. //

  213. //static int

  214. //yaml_check_utf8(yaml_char_t *start, size_t length)

  215. //{

  216. //    yaml_char_t *end = start+length;

  217. //    yaml_char_t *pointer = start;

  218. //

  219. //    while (pointer < end) {

  220. //        unsigned char octet;

  221. //        unsigned int width;

  222. //        unsigned int value;

  223. //        size_t k;

  224. //

  225. //        octet = pointer[0];

  226. //        width = (octet & 0x80) == 0x00 ? 1 :

  227. //                (octet & 0xE0) == 0xC0 ? 2 :

  228. //                (octet & 0xF0) == 0xE0 ? 3 :

  229. //                (octet & 0xF8) == 0xF0 ? 4 : 0;

  230. //        value = (octet & 0x80) == 0x00 ? octet & 0x7F :

  231. //                (octet & 0xE0) == 0xC0 ? octet & 0x1F :

  232. //                (octet & 0xF0) == 0xE0 ? octet & 0x0F :

  233. //                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;

  234. //        if (!width) return 0;

  235. //        if (pointer+width > end) return 0;

  236. //        for (k = 1; k < width; k ++) {

  237. //            octet = pointer[k];

  238. //            if ((octet & 0xC0) != 0x80) return 0;

  239. //            value = (value << 6) + (octet & 0x3F);

  240. //        }

  241. //        if (!((width == 1) ||

  242. //            (width == 2 && value >= 0x80) ||

  243. //            (width == 3 && value >= 0x800) ||

  244. //            (width == 4 && value >= 0x10000))) return 0;

  245. //

  246. //        pointer += width;

  247. //    }

  248. //

  249. //    return 1;

  250. //}

  251. //

  252. 

  253. // Create STREAM-START.

  254. func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {

  255. 	*event = yaml_event_t{

  256. 		typ:      yaml_STREAM_START_EVENT,

  257. 		encoding: encoding,

  258. 	}

  259. }

  260. 

  261. // Create STREAM-END.

  262. func yaml_stream_end_event_initialize(event *yaml_event_t) {

  263. 	*event = yaml_event_t{

  264. 		typ: yaml_STREAM_END_EVENT,

  265. 	}

  266. }

  267. 

  268. // Create DOCUMENT-START.

  269. func yaml_document_start_event_initialize(

  270. 	event *yaml_event_t,

  271. 	version_directive *yaml_version_directive_t,

  272. 	tag_directives []yaml_tag_directive_t,

  273. 	implicit bool,

  274. ) {

  275. 	*event = yaml_event_t{

  276. 		typ:               yaml_DOCUMENT_START_EVENT,

  277. 		version_directive: version_directive,

  278. 		tag_directives:    tag_directives,

  279. 		implicit:          implicit,

  280. 	}

  281. }

  282. 

  283. // Create DOCUMENT-END.

  284. func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {

  285. 	*event = yaml_event_t{

  286. 		typ:      yaml_DOCUMENT_END_EVENT,

  287. 		implicit: implicit,

  288. 	}

  289. }

  290. 

  291. ///*

  292. // * Create ALIAS.

  293. // */

  294. //

  295. //YAML_DECLARE(int)

  296. //yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)

  297. //{

  298. //    mark yaml_mark_t = { 0, 0, 0 }

  299. //    anchor_copy *yaml_char_t = NULL

  300. //

  301. //    assert(event) // Non-NULL event object is expected.

  302. //    assert(anchor) // Non-NULL anchor is expected.

  303. //

  304. //    if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0

  305. //

  306. //    anchor_copy = yaml_strdup(anchor)

  307. //    if (!anchor_copy)

  308. //        return 0

  309. //

  310. //    ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)

  311. //

  312. //    return 1

  313. //}

  314. 

  315. // Create SCALAR.

  316. func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {

  317. 	*event = yaml_event_t{

  318. 		typ:             yaml_SCALAR_EVENT,

  319. 		anchor:          anchor,

  320. 		tag:             tag,

  321. 		value:           value,

  322. 		implicit:        plain_implicit,

  323. 		quoted_implicit: quoted_implicit,

  324. 		style:           yaml_style_t(style),

  325. 	}

  326. 	return true

  327. }

  328. 

  329. // Create SEQUENCE-START.

  330. func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {

  331. 	*event = yaml_event_t{

  332. 		typ:      yaml_SEQUENCE_START_EVENT,

  333. 		anchor:   anchor,

  334. 		tag:      tag,

  335. 		implicit: implicit,

  336. 		style:    yaml_style_t(style),

  337. 	}

  338. 	return true

  339. }

  340. 

  341. // Create SEQUENCE-END.

  342. func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {

  343. 	*event = yaml_event_t{

  344. 		typ: yaml_SEQUENCE_END_EVENT,

  345. 	}

  346. 	return true

  347. }

  348. 

  349. // Create MAPPING-START.

  350. func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {

  351. 	*event = yaml_event_t{

  352. 		typ:      yaml_MAPPING_START_EVENT,

  353. 		anchor:   anchor,

  354. 		tag:      tag,

  355. 		implicit: implicit,

  356. 		style:    yaml_style_t(style),

  357. 	}

  358. }

  359. 

  360. // Create MAPPING-END.

  361. func yaml_mapping_end_event_initialize(event *yaml_event_t) {

  362. 	*event = yaml_event_t{

  363. 		typ: yaml_MAPPING_END_EVENT,

  364. 	}

  365. }

  366. 

  367. // Destroy an event object.

  368. func yaml_event_delete(event *yaml_event_t) {

  369. 	*event = yaml_event_t{}

  370. }

  371. 

  372. ///*

  373. // * Create a document object.

  374. // */

  375. //

  376. //YAML_DECLARE(int)

  377. //yaml_document_initialize(document *yaml_document_t,

  378. //        version_directive *yaml_version_directive_t,

  379. //        tag_directives_start *yaml_tag_directive_t,

  380. //        tag_directives_end *yaml_tag_directive_t,

  381. //        start_implicit int, end_implicit int)

  382. //{

  383. //    struct {

  384. //        error yaml_error_type_t

  385. //    } context

  386. //    struct {

  387. //        start *yaml_node_t

  388. //        end *yaml_node_t

  389. //        top *yaml_node_t

  390. //    } nodes = { NULL, NULL, NULL }

  391. //    version_directive_copy *yaml_version_directive_t = NULL

  392. //    struct {

  393. //        start *yaml_tag_directive_t

  394. //        end *yaml_tag_directive_t

  395. //        top *yaml_tag_directive_t

  396. //    } tag_directives_copy = { NULL, NULL, NULL }

  397. //    value yaml_tag_directive_t = { NULL, NULL }

  398. //    mark yaml_mark_t = { 0, 0, 0 }

  399. //

  400. //    assert(document) // Non-NULL document object is expected.

  401. //    assert((tag_directives_start && tag_directives_end) ||

  402. //            (tag_directives_start == tag_directives_end))

  403. //                            // Valid tag directives are expected.

  404. //

  405. //    if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error

  406. //

  407. //    if (version_directive) {

  408. //        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))

  409. //        if (!version_directive_copy) goto error

  410. //        version_directive_copy.major = version_directive.major

  411. //        version_directive_copy.minor = version_directive.minor

  412. //    }

  413. //

  414. //    if (tag_directives_start != tag_directives_end) {

  415. //        tag_directive *yaml_tag_directive_t

  416. //        if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))

  417. //            goto error

  418. //        for (tag_directive = tag_directives_start

  419. //                tag_directive != tag_directives_end; tag_directive ++) {

  420. //            assert(tag_directive.handle)

  421. //            assert(tag_directive.prefix)

  422. //            if (!yaml_check_utf8(tag_directive.handle,

  423. //                        strlen((char *)tag_directive.handle)))

  424. //                goto error

  425. //            if (!yaml_check_utf8(tag_directive.prefix,

  426. //                        strlen((char *)tag_directive.prefix)))

  427. //                goto error

  428. //            value.handle = yaml_strdup(tag_directive.handle)

  429. //            value.prefix = yaml_strdup(tag_directive.prefix)

  430. //            if (!value.handle || !value.prefix) goto error

  431. //            if (!PUSH(&context, tag_directives_copy, value))

  432. //                goto error

  433. //            value.handle = NULL

  434. //            value.prefix = NULL

  435. //        }

  436. //    }

  437. //

  438. //    DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,

  439. //            tag_directives_copy.start, tag_directives_copy.top,

  440. //            start_implicit, end_implicit, mark, mark)

  441. //

  442. //    return 1

  443. //

  444. //error:

  445. //    STACK_DEL(&context, nodes)

  446. //    yaml_free(version_directive_copy)

  447. //    while (!STACK_EMPTY(&context, tag_directives_copy)) {

  448. //        value yaml_tag_directive_t = POP(&context, tag_directives_copy)

  449. //        yaml_free(value.handle)

  450. //        yaml_free(value.prefix)

  451. //    }

  452. //    STACK_DEL(&context, tag_directives_copy)

  453. //    yaml_free(value.handle)

  454. //    yaml_free(value.prefix)

  455. //

  456. //    return 0

  457. //}

  458. //

  459. ///*

  460. // * Destroy a document object.

  461. // */

  462. //

  463. //YAML_DECLARE(void)

  464. //yaml_document_delete(document *yaml_document_t)

  465. //{

  466. //    struct {

  467. //        error yaml_error_type_t

  468. //    } context

  469. //    tag_directive *yaml_tag_directive_t

  470. //

  471. //    context.error = YAML_NO_ERROR // Eliminate a compiler warning.

  472. //

  473. //    assert(document) // Non-NULL document object is expected.

  474. //

  475. //    while (!STACK_EMPTY(&context, document.nodes)) {

  476. //        node yaml_node_t = POP(&context, document.nodes)

  477. //        yaml_free(node.tag)

  478. //        switch (node.type) {

  479. //            case YAML_SCALAR_NODE:

  480. //                yaml_free(node.data.scalar.value)

  481. //                break

  482. //            case YAML_SEQUENCE_NODE:

  483. //                STACK_DEL(&context, node.data.sequence.items)

  484. //                break

  485. //            case YAML_MAPPING_NODE:

  486. //                STACK_DEL(&context, node.data.mapping.pairs)

  487. //                break

  488. //            default:

  489. //                assert(0) // Should not happen.

  490. //        }

  491. //    }

  492. //    STACK_DEL(&context, document.nodes)

  493. //

  494. //    yaml_free(document.version_directive)

  495. //    for (tag_directive = document.tag_directives.start

  496. //            tag_directive != document.tag_directives.end

  497. //            tag_directive++) {

  498. //        yaml_free(tag_directive.handle)

  499. //        yaml_free(tag_directive.prefix)

  500. //    }

  501. //    yaml_free(document.tag_directives.start)

  502. //

  503. //    memset(document, 0, sizeof(yaml_document_t))

  504. //}

  505. //

  506. ///**

  507. // * Get a document node.

  508. // */

  509. //

  510. //YAML_DECLARE(yaml_node_t *)

  511. //yaml_document_get_node(document *yaml_document_t, index int)

  512. //{

  513. //    assert(document) // Non-NULL document object is expected.

  514. //

  515. //    if (index > 0 && document.nodes.start + index <= document.nodes.top) {

  516. //        return document.nodes.start + index - 1

  517. //    }

  518. //    return NULL

  519. //}

  520. //

  521. ///**

  522. // * Get the root object.

  523. // */

  524. //

  525. //YAML_DECLARE(yaml_node_t *)

  526. //yaml_document_get_root_node(document *yaml_document_t)

  527. //{

  528. //    assert(document) // Non-NULL document object is expected.

  529. //

  530. //    if (document.nodes.top != document.nodes.start) {

  531. //        return document.nodes.start

  532. //    }

  533. //    return NULL

  534. //}

  535. //

  536. ///*

  537. // * Add a scalar node to a document.

  538. // */

  539. //

  540. //YAML_DECLARE(int)

  541. //yaml_document_add_scalar(document *yaml_document_t,

  542. //        tag *yaml_char_t, value *yaml_char_t, length int,

  543. //        style yaml_scalar_style_t)

  544. //{

  545. //    struct {

  546. //        error yaml_error_type_t

  547. //    } context

  548. //    mark yaml_mark_t = { 0, 0, 0 }

  549. //    tag_copy *yaml_char_t = NULL

  550. //    value_copy *yaml_char_t = NULL

  551. //    node yaml_node_t

  552. //

  553. //    assert(document) // Non-NULL document object is expected.

  554. //    assert(value) // Non-NULL value is expected.

  555. //

  556. //    if (!tag) {

  557. //        tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG

  558. //    }

  559. //

  560. //    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error

  561. //    tag_copy = yaml_strdup(tag)

  562. //    if (!tag_copy) goto error

  563. //

  564. //    if (length < 0) {

  565. //        length = strlen((char *)value)

  566. //    }

  567. //

  568. //    if (!yaml_check_utf8(value, length)) goto error

  569. //    value_copy = yaml_malloc(length+1)

  570. //    if (!value_copy) goto error

  571. //    memcpy(value_copy, value, length)

  572. //    value_copy[length] = '\0'

  573. //

  574. //    SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)

  575. //    if (!PUSH(&context, document.nodes, node)) goto error

  576. //

  577. //    return document.nodes.top - document.nodes.start

  578. //

  579. //error:

  580. //    yaml_free(tag_copy)

  581. //    yaml_free(value_copy)

  582. //

  583. //    return 0

  584. //}

  585. //

  586. ///*

  587. // * Add a sequence node to a document.

  588. // */

  589. //

  590. //YAML_DECLARE(int)

  591. //yaml_document_add_sequence(document *yaml_document_t,

  592. //        tag *yaml_char_t, style yaml_sequence_style_t)

  593. //{

  594. //    struct {

  595. //        error yaml_error_type_t

  596. //    } context

  597. //    mark yaml_mark_t = { 0, 0, 0 }

  598. //    tag_copy *yaml_char_t = NULL

  599. //    struct {

  600. //        start *yaml_node_item_t

  601. //        end *yaml_node_item_t

  602. //        top *yaml_node_item_t

  603. //    } items = { NULL, NULL, NULL }

  604. //    node yaml_node_t

  605. //

  606. //    assert(document) // Non-NULL document object is expected.

  607. //

  608. //    if (!tag) {

  609. //        tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG

  610. //    }

  611. //

  612. //    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error

  613. //    tag_copy = yaml_strdup(tag)

  614. //    if (!tag_copy) goto error

  615. //

  616. //    if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error

  617. //

  618. //    SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,

  619. //            style, mark, mark)

  620. //    if (!PUSH(&context, document.nodes, node)) goto error

  621. //

  622. //    return document.nodes.top - document.nodes.start

  623. //

  624. //error:

  625. //    STACK_DEL(&context, items)

  626. //    yaml_free(tag_copy)

  627. //

  628. //    return 0

  629. //}

  630. //

  631. ///*

  632. // * Add a mapping node to a document.

  633. // */

  634. //

  635. //YAML_DECLARE(int)

  636. //yaml_document_add_mapping(document *yaml_document_t,

  637. //        tag *yaml_char_t, style yaml_mapping_style_t)

  638. //{

  639. //    struct {

  640. //        error yaml_error_type_t

  641. //    } context

  642. //    mark yaml_mark_t = { 0, 0, 0 }

  643. //    tag_copy *yaml_char_t = NULL

  644. //    struct {

  645. //        start *yaml_node_pair_t

  646. //        end *yaml_node_pair_t

  647. //        top *yaml_node_pair_t

  648. //    } pairs = { NULL, NULL, NULL }

  649. //    node yaml_node_t

  650. //

  651. //    assert(document) // Non-NULL document object is expected.

  652. //

  653. //    if (!tag) {

  654. //        tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG

  655. //    }

  656. //

  657. //    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error

  658. //    tag_copy = yaml_strdup(tag)

  659. //    if (!tag_copy) goto error

  660. //

  661. //    if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error

  662. //

  663. //    MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,

  664. //            style, mark, mark)

  665. //    if (!PUSH(&context, document.nodes, node)) goto error

  666. //

  667. //    return document.nodes.top - document.nodes.start

  668. //

  669. //error:

  670. //    STACK_DEL(&context, pairs)

  671. //    yaml_free(tag_copy)

  672. //

  673. //    return 0

  674. //}

  675. //

  676. ///*

  677. // * Append an item to a sequence node.

  678. // */

  679. //

  680. //YAML_DECLARE(int)

  681. //yaml_document_append_sequence_item(document *yaml_document_t,

  682. //        sequence int, item int)

  683. //{

  684. //    struct {

  685. //        error yaml_error_type_t

  686. //    } context

  687. //

  688. //    assert(document) // Non-NULL document is required.

  689. //    assert(sequence > 0

  690. //            && document.nodes.start + sequence <= document.nodes.top)

  691. //                            // Valid sequence id is required.

  692. //    assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)

  693. //                            // A sequence node is required.

  694. //    assert(item > 0 && document.nodes.start + item <= document.nodes.top)

  695. //                            // Valid item id is required.

  696. //

  697. //    if (!PUSH(&context,

  698. //                document.nodes.start[sequence-1].data.sequence.items, item))

  699. //        return 0

  700. //

  701. //    return 1

  702. //}

  703. //

  704. ///*

  705. // * Append a pair of a key and a value to a mapping node.

  706. // */

  707. //

  708. //YAML_DECLARE(int)

  709. //yaml_document_append_mapping_pair(document *yaml_document_t,

  710. //        mapping int, key int, value int)

  711. //{

  712. //    struct {

  713. //        error yaml_error_type_t

  714. //    } context

  715. //

  716. //    pair yaml_node_pair_t

  717. //

  718. //    assert(document) // Non-NULL document is required.

  719. //    assert(mapping > 0

  720. //            && document.nodes.start + mapping <= document.nodes.top)

  721. //                            // Valid mapping id is required.

  722. //    assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)

  723. //                            // A mapping node is required.

  724. //    assert(key > 0 && document.nodes.start + key <= document.nodes.top)

  725. //                            // Valid key id is required.

  726. //    assert(value > 0 && document.nodes.start + value <= document.nodes.top)

  727. //                            // Valid value id is required.

  728. //

  729. //    pair.key = key

  730. //    pair.value = value

  731. //

  732. //    if (!PUSH(&context,

  733. //                document.nodes.start[mapping-1].data.mapping.pairs, pair))

  734. //        return 0

  735. //

  736. //    return 1

  737. //}

  738. //

  739. //
上海开阖软件有限公司 沪ICP备12045867号-1