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.

744 lines
21 KiB

  1. package yaml
  2. import (
  3. "io"
  4. )
  5. func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
  6. //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
  7. // Check if we can move the queue at the beginning of the buffer.
  8. if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
  9. if parser.tokens_head != len(parser.tokens) {
  10. copy(parser.tokens, parser.tokens[parser.tokens_head:])
  11. }
  12. parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
  13. parser.tokens_head = 0
  14. }
  15. parser.tokens = append(parser.tokens, *token)
  16. if pos < 0 {
  17. return
  18. }
  19. copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
  20. parser.tokens[parser.tokens_head+pos] = *token
  21. }
  22. // Create a new parser object.
  23. func yaml_parser_initialize(parser *yaml_parser_t) bool {
  24. *parser = yaml_parser_t{
  25. raw_buffer: make([]byte, 0, input_raw_buffer_size),
  26. buffer: make([]byte, 0, input_buffer_size),
  27. }
  28. return true
  29. }
  30. // Destroy a parser object.
  31. func yaml_parser_delete(parser *yaml_parser_t) {
  32. *parser = yaml_parser_t{}
  33. }
  34. // String read handler.
  35. func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
  36. if parser.input_pos == len(parser.input) {
  37. return 0, io.EOF
  38. }
  39. n = copy(buffer, parser.input[parser.input_pos:])
  40. parser.input_pos += n
  41. return n, nil
  42. }
  43. // Reader read handler.
  44. func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
  45. return parser.input_reader.Read(buffer)
  46. }
  47. // Set a string input.
  48. func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
  49. if parser.read_handler != nil {
  50. panic("must set the input source only once")
  51. }
  52. parser.read_handler = yaml_string_read_handler
  53. parser.input = input
  54. parser.input_pos = 0
  55. }
  56. // Set a file input.
  57. func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
  58. if parser.read_handler != nil {
  59. panic("must set the input source only once")
  60. }
  61. parser.read_handler = yaml_reader_read_handler
  62. parser.input_reader = r
  63. }
  64. // Set the source encoding.
  65. func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
  66. if parser.encoding != yaml_ANY_ENCODING {
  67. panic("must set the encoding only once")
  68. }
  69. parser.encoding = encoding
  70. }
  71. var disableLineWrapping = false
  72. // Create a new emitter object.
  73. func yaml_emitter_initialize(emitter *yaml_emitter_t) {
  74. *emitter = yaml_emitter_t{
  75. buffer: make([]byte, output_buffer_size),
  76. raw_buffer: make([]byte, 0, output_raw_buffer_size),
  77. states: make([]yaml_emitter_state_t, 0, initial_stack_size),
  78. events: make([]yaml_event_t, 0, initial_queue_size),
  79. }
  80. if disableLineWrapping {
  81. emitter.best_width = -1
  82. }
  83. }
  84. // Destroy an emitter object.
  85. func yaml_emitter_delete(emitter *yaml_emitter_t) {
  86. *emitter = yaml_emitter_t{}
  87. }
  88. // String write handler.
  89. func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
  90. *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
  91. return nil
  92. }
  93. // yaml_writer_write_handler uses emitter.output_writer to write the
  94. // emitted text.
  95. func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
  96. _, err := emitter.output_writer.Write(buffer)
  97. return err
  98. }
  99. // Set a string output.
  100. func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
  101. if emitter.write_handler != nil {
  102. panic("must set the output target only once")
  103. }
  104. emitter.write_handler = yaml_string_write_handler
  105. emitter.output_buffer = output_buffer
  106. }
  107. // Set a file output.
  108. func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
  109. if emitter.write_handler != nil {
  110. panic("must set the output target only once")
  111. }
  112. emitter.write_handler = yaml_writer_write_handler
  113. emitter.output_writer = w
  114. }
  115. // Set the output encoding.
  116. func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
  117. if emitter.encoding != yaml_ANY_ENCODING {
  118. panic("must set the output encoding only once")
  119. }
  120. emitter.encoding = encoding
  121. }
  122. // Set the canonical output style.
  123. func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
  124. emitter.canonical = canonical
  125. }
  126. //// Set the indentation increment.
  127. func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
  128. if indent < 2 || indent > 9 {
  129. indent = 2
  130. }
  131. emitter.best_indent = indent
  132. }
  133. // Set the preferred line width.
  134. func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
  135. if width < 0 {
  136. width = -1
  137. }
  138. emitter.best_width = width
  139. }
  140. // Set if unescaped non-ASCII characters are allowed.
  141. func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
  142. emitter.unicode = unicode
  143. }
  144. // Set the preferred line break character.
  145. func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
  146. emitter.line_break = line_break
  147. }
  148. ///*
  149. // * Destroy a token object.
  150. // */
  151. //
  152. //YAML_DECLARE(void)
  153. //yaml_token_delete(yaml_token_t *token)
  154. //{
  155. // assert(token); // Non-NULL token object expected.
  156. //
  157. // switch (token.type)
  158. // {
  159. // case YAML_TAG_DIRECTIVE_TOKEN:
  160. // yaml_free(token.data.tag_directive.handle);
  161. // yaml_free(token.data.tag_directive.prefix);
  162. // break;
  163. //
  164. // case YAML_ALIAS_TOKEN:
  165. // yaml_free(token.data.alias.value);
  166. // break;
  167. //
  168. // case YAML_ANCHOR_TOKEN:
  169. // yaml_free(token.data.anchor.value);
  170. // break;
  171. //
  172. // case YAML_TAG_TOKEN:
  173. // yaml_free(token.data.tag.handle);
  174. // yaml_free(token.data.tag.suffix);
  175. // break;
  176. //
  177. // case YAML_SCALAR_TOKEN:
  178. // yaml_free(token.data.scalar.value);
  179. // break;
  180. //
  181. // default:
  182. // break;
  183. // }
  184. //
  185. // memset(token, 0, sizeof(yaml_token_t));
  186. //}
  187. //
  188. ///*
  189. // * Check if a string is a valid UTF-8 sequence.
  190. // *
  191. // * Check 'reader.c' for more details on UTF-8 encoding.
  192. // */
  193. //
  194. //static int
  195. //yaml_check_utf8(yaml_char_t *start, size_t length)
  196. //{
  197. // yaml_char_t *end = start+length;
  198. // yaml_char_t *pointer = start;
  199. //
  200. // while (pointer < end) {
  201. // unsigned char octet;
  202. // unsigned int width;
  203. // unsigned int value;
  204. // size_t k;
  205. //
  206. // octet = pointer[0];
  207. // width = (octet & 0x80) == 0x00 ? 1 :
  208. // (octet & 0xE0) == 0xC0 ? 2 :
  209. // (octet & 0xF0) == 0xE0 ? 3 :
  210. // (octet & 0xF8) == 0xF0 ? 4 : 0;
  211. // value = (octet & 0x80) == 0x00 ? octet & 0x7F :
  212. // (octet & 0xE0) == 0xC0 ? octet & 0x1F :
  213. // (octet & 0xF0) == 0xE0 ? octet & 0x0F :
  214. // (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
  215. // if (!width) return 0;
  216. // if (pointer+width > end) return 0;
  217. // for (k = 1; k < width; k ++) {
  218. // octet = pointer[k];
  219. // if ((octet & 0xC0) != 0x80) return 0;
  220. // value = (value << 6) + (octet & 0x3F);
  221. // }
  222. // if (!((width == 1) ||
  223. // (width == 2 && value >= 0x80) ||
  224. // (width == 3 && value >= 0x800) ||
  225. // (width == 4 && value >= 0x10000))) return 0;
  226. //
  227. // pointer += width;
  228. // }
  229. //
  230. // return 1;
  231. //}
  232. //
  233. // Create STREAM-START.
  234. func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
  235. *event = yaml_event_t{
  236. typ: yaml_STREAM_START_EVENT,
  237. encoding: encoding,
  238. }
  239. }
  240. // Create STREAM-END.
  241. func yaml_stream_end_event_initialize(event *yaml_event_t) {
  242. *event = yaml_event_t{
  243. typ: yaml_STREAM_END_EVENT,
  244. }
  245. }
  246. // Create DOCUMENT-START.
  247. func yaml_document_start_event_initialize(
  248. event *yaml_event_t,
  249. version_directive *yaml_version_directive_t,
  250. tag_directives []yaml_tag_directive_t,
  251. implicit bool,
  252. ) {
  253. *event = yaml_event_t{
  254. typ: yaml_DOCUMENT_START_EVENT,
  255. version_directive: version_directive,
  256. tag_directives: tag_directives,
  257. implicit: implicit,
  258. }
  259. }
  260. // Create DOCUMENT-END.
  261. func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
  262. *event = yaml_event_t{
  263. typ: yaml_DOCUMENT_END_EVENT,
  264. implicit: implicit,
  265. }
  266. }
  267. ///*
  268. // * Create ALIAS.
  269. // */
  270. //
  271. //YAML_DECLARE(int)
  272. //yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
  273. //{
  274. // mark yaml_mark_t = { 0, 0, 0 }
  275. // anchor_copy *yaml_char_t = NULL
  276. //
  277. // assert(event) // Non-NULL event object is expected.
  278. // assert(anchor) // Non-NULL anchor is expected.
  279. //
  280. // if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
  281. //
  282. // anchor_copy = yaml_strdup(anchor)
  283. // if (!anchor_copy)
  284. // return 0
  285. //
  286. // ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
  287. //
  288. // return 1
  289. //}
  290. // Create SCALAR.
  291. func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
  292. *event = yaml_event_t{
  293. typ: yaml_SCALAR_EVENT,
  294. anchor: anchor,
  295. tag: tag,
  296. value: value,
  297. implicit: plain_implicit,
  298. quoted_implicit: quoted_implicit,
  299. style: yaml_style_t(style),
  300. }
  301. return true
  302. }
  303. // Create SEQUENCE-START.
  304. func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
  305. *event = yaml_event_t{
  306. typ: yaml_SEQUENCE_START_EVENT,
  307. anchor: anchor,
  308. tag: tag,
  309. implicit: implicit,
  310. style: yaml_style_t(style),
  311. }
  312. return true
  313. }
  314. // Create SEQUENCE-END.
  315. func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
  316. *event = yaml_event_t{
  317. typ: yaml_SEQUENCE_END_EVENT,
  318. }
  319. return true
  320. }
  321. // Create MAPPING-START.
  322. func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
  323. *event = yaml_event_t{
  324. typ: yaml_MAPPING_START_EVENT,
  325. anchor: anchor,
  326. tag: tag,
  327. implicit: implicit,
  328. style: yaml_style_t(style),
  329. }
  330. }
  331. // Create MAPPING-END.
  332. func yaml_mapping_end_event_initialize(event *yaml_event_t) {
  333. *event = yaml_event_t{
  334. typ: yaml_MAPPING_END_EVENT,
  335. }
  336. }
  337. // Destroy an event object.
  338. func yaml_event_delete(event *yaml_event_t) {
  339. *event = yaml_event_t{}
  340. }
  341. ///*
  342. // * Create a document object.
  343. // */
  344. //
  345. //YAML_DECLARE(int)
  346. //yaml_document_initialize(document *yaml_document_t,
  347. // version_directive *yaml_version_directive_t,
  348. // tag_directives_start *yaml_tag_directive_t,
  349. // tag_directives_end *yaml_tag_directive_t,
  350. // start_implicit int, end_implicit int)
  351. //{
  352. // struct {
  353. // error yaml_error_type_t
  354. // } context
  355. // struct {
  356. // start *yaml_node_t
  357. // end *yaml_node_t
  358. // top *yaml_node_t
  359. // } nodes = { NULL, NULL, NULL }
  360. // version_directive_copy *yaml_version_directive_t = NULL
  361. // struct {
  362. // start *yaml_tag_directive_t
  363. // end *yaml_tag_directive_t
  364. // top *yaml_tag_directive_t
  365. // } tag_directives_copy = { NULL, NULL, NULL }
  366. // value yaml_tag_directive_t = { NULL, NULL }
  367. // mark yaml_mark_t = { 0, 0, 0 }
  368. //
  369. // assert(document) // Non-NULL document object is expected.
  370. // assert((tag_directives_start && tag_directives_end) ||
  371. // (tag_directives_start == tag_directives_end))
  372. // // Valid tag directives are expected.
  373. //
  374. // if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
  375. //
  376. // if (version_directive) {
  377. // version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
  378. // if (!version_directive_copy) goto error
  379. // version_directive_copy.major = version_directive.major
  380. // version_directive_copy.minor = version_directive.minor
  381. // }
  382. //
  383. // if (tag_directives_start != tag_directives_end) {
  384. // tag_directive *yaml_tag_directive_t
  385. // if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
  386. // goto error
  387. // for (tag_directive = tag_directives_start
  388. // tag_directive != tag_directives_end; tag_directive ++) {
  389. // assert(tag_directive.handle)
  390. // assert(tag_directive.prefix)
  391. // if (!yaml_check_utf8(tag_directive.handle,
  392. // strlen((char *)tag_directive.handle)))
  393. // goto error
  394. // if (!yaml_check_utf8(tag_directive.prefix,
  395. // strlen((char *)tag_directive.prefix)))
  396. // goto error
  397. // value.handle = yaml_strdup(tag_directive.handle)
  398. // value.prefix = yaml_strdup(tag_directive.prefix)
  399. // if (!value.handle || !value.prefix) goto error
  400. // if (!PUSH(&context, tag_directives_copy, value))
  401. // goto error
  402. // value.handle = NULL
  403. // value.prefix = NULL
  404. // }
  405. // }
  406. //
  407. // DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
  408. // tag_directives_copy.start, tag_directives_copy.top,
  409. // start_implicit, end_implicit, mark, mark)
  410. //
  411. // return 1
  412. //
  413. //error:
  414. // STACK_DEL(&context, nodes)
  415. // yaml_free(version_directive_copy)
  416. // while (!STACK_EMPTY(&context, tag_directives_copy)) {
  417. // value yaml_tag_directive_t = POP(&context, tag_directives_copy)
  418. // yaml_free(value.handle)
  419. // yaml_free(value.prefix)
  420. // }
  421. // STACK_DEL(&context, tag_directives_copy)
  422. // yaml_free(value.handle)
  423. // yaml_free(value.prefix)
  424. //
  425. // return 0
  426. //}
  427. //
  428. ///*
  429. // * Destroy a document object.
  430. // */
  431. //
  432. //YAML_DECLARE(void)
  433. //yaml_document_delete(document *yaml_document_t)
  434. //{
  435. // struct {
  436. // error yaml_error_type_t
  437. // } context
  438. // tag_directive *yaml_tag_directive_t
  439. //
  440. // context.error = YAML_NO_ERROR // Eliminate a compiler warning.
  441. //
  442. // assert(document) // Non-NULL document object is expected.
  443. //
  444. // while (!STACK_EMPTY(&context, document.nodes)) {
  445. // node yaml_node_t = POP(&context, document.nodes)
  446. // yaml_free(node.tag)
  447. // switch (node.type) {
  448. // case YAML_SCALAR_NODE:
  449. // yaml_free(node.data.scalar.value)
  450. // break
  451. // case YAML_SEQUENCE_NODE:
  452. // STACK_DEL(&context, node.data.sequence.items)
  453. // break
  454. // case YAML_MAPPING_NODE:
  455. // STACK_DEL(&context, node.data.mapping.pairs)
  456. // break
  457. // default:
  458. // assert(0) // Should not happen.
  459. // }
  460. // }
  461. // STACK_DEL(&context, document.nodes)
  462. //
  463. // yaml_free(document.version_directive)
  464. // for (tag_directive = document.tag_directives.start
  465. // tag_directive != document.tag_directives.end
  466. // tag_directive++) {
  467. // yaml_free(tag_directive.handle)
  468. // yaml_free(tag_directive.prefix)
  469. // }
  470. // yaml_free(document.tag_directives.start)
  471. //
  472. // memset(document, 0, sizeof(yaml_document_t))
  473. //}
  474. //
  475. ///**
  476. // * Get a document node.
  477. // */
  478. //
  479. //YAML_DECLARE(yaml_node_t *)
  480. //yaml_document_get_node(document *yaml_document_t, index int)
  481. //{
  482. // assert(document) // Non-NULL document object is expected.
  483. //
  484. // if (index > 0 && document.nodes.start + index <= document.nodes.top) {
  485. // return document.nodes.start + index - 1
  486. // }
  487. // return NULL
  488. //}
  489. //
  490. ///**
  491. // * Get the root object.
  492. // */
  493. //
  494. //YAML_DECLARE(yaml_node_t *)
  495. //yaml_document_get_root_node(document *yaml_document_t)
  496. //{
  497. // assert(document) // Non-NULL document object is expected.
  498. //
  499. // if (document.nodes.top != document.nodes.start) {
  500. // return document.nodes.start
  501. // }
  502. // return NULL
  503. //}
  504. //
  505. ///*
  506. // * Add a scalar node to a document.
  507. // */
  508. //
  509. //YAML_DECLARE(int)
  510. //yaml_document_add_scalar(document *yaml_document_t,
  511. // tag *yaml_char_t, value *yaml_char_t, length int,
  512. // style yaml_scalar_style_t)
  513. //{
  514. // struct {
  515. // error yaml_error_type_t
  516. // } context
  517. // mark yaml_mark_t = { 0, 0, 0 }
  518. // tag_copy *yaml_char_t = NULL
  519. // value_copy *yaml_char_t = NULL
  520. // node yaml_node_t
  521. //
  522. // assert(document) // Non-NULL document object is expected.
  523. // assert(value) // Non-NULL value is expected.
  524. //
  525. // if (!tag) {
  526. // tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
  527. // }
  528. //
  529. // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
  530. // tag_copy = yaml_strdup(tag)
  531. // if (!tag_copy) goto error
  532. //
  533. // if (length < 0) {
  534. // length = strlen((char *)value)
  535. // }
  536. //
  537. // if (!yaml_check_utf8(value, length)) goto error
  538. // value_copy = yaml_malloc(length+1)
  539. // if (!value_copy) goto error
  540. // memcpy(value_copy, value, length)
  541. // value_copy[length] = '\0'
  542. //
  543. // SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
  544. // if (!PUSH(&context, document.nodes, node)) goto error
  545. //
  546. // return document.nodes.top - document.nodes.start
  547. //
  548. //error:
  549. // yaml_free(tag_copy)
  550. // yaml_free(value_copy)
  551. //
  552. // return 0
  553. //}
  554. //
  555. ///*
  556. // * Add a sequence node to a document.
  557. // */
  558. //
  559. //YAML_DECLARE(int)
  560. //yaml_document_add_sequence(document *yaml_document_t,
  561. // tag *yaml_char_t, style yaml_sequence_style_t)
  562. //{
  563. // struct {
  564. // error yaml_error_type_t
  565. // } context
  566. // mark yaml_mark_t = { 0, 0, 0 }
  567. // tag_copy *yaml_char_t = NULL
  568. // struct {
  569. // start *yaml_node_item_t
  570. // end *yaml_node_item_t
  571. // top *yaml_node_item_t
  572. // } items = { NULL, NULL, NULL }
  573. // node yaml_node_t
  574. //
  575. // assert(document) // Non-NULL document object is expected.
  576. //
  577. // if (!tag) {
  578. // tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
  579. // }
  580. //
  581. // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
  582. // tag_copy = yaml_strdup(tag)
  583. // if (!tag_copy) goto error
  584. //
  585. // if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
  586. //
  587. // SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
  588. // style, mark, mark)
  589. // if (!PUSH(&context, document.nodes, node)) goto error
  590. //
  591. // return document.nodes.top - document.nodes.start
  592. //
  593. //error:
  594. // STACK_DEL(&context, items)
  595. // yaml_free(tag_copy)
  596. //
  597. // return 0
  598. //}
  599. //
  600. ///*
  601. // * Add a mapping node to a document.
  602. // */
  603. //
  604. //YAML_DECLARE(int)
  605. //yaml_document_add_mapping(document *yaml_document_t,
  606. // tag *yaml_char_t, style yaml_mapping_style_t)
  607. //{
  608. // struct {
  609. // error yaml_error_type_t
  610. // } context
  611. // mark yaml_mark_t = { 0, 0, 0 }
  612. // tag_copy *yaml_char_t = NULL
  613. // struct {
  614. // start *yaml_node_pair_t
  615. // end *yaml_node_pair_t
  616. // top *yaml_node_pair_t
  617. // } pairs = { NULL, NULL, NULL }
  618. // node yaml_node_t
  619. //
  620. // assert(document) // Non-NULL document object is expected.
  621. //
  622. // if (!tag) {
  623. // tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
  624. // }
  625. //
  626. // if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
  627. // tag_copy = yaml_strdup(tag)
  628. // if (!tag_copy) goto error
  629. //
  630. // if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
  631. //
  632. // MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
  633. // style, mark, mark)
  634. // if (!PUSH(&context, document.nodes, node)) goto error
  635. //
  636. // return document.nodes.top - document.nodes.start
  637. //
  638. //error:
  639. // STACK_DEL(&context, pairs)
  640. // yaml_free(tag_copy)
  641. //
  642. // return 0
  643. //}
  644. //
  645. ///*
  646. // * Append an item to a sequence node.
  647. // */
  648. //
  649. //YAML_DECLARE(int)
  650. //yaml_document_append_sequence_item(document *yaml_document_t,
  651. // sequence int, item int)
  652. //{
  653. // struct {
  654. // error yaml_error_type_t
  655. // } context
  656. //
  657. // assert(document) // Non-NULL document is required.
  658. // assert(sequence > 0
  659. // && document.nodes.start + sequence <= document.nodes.top)
  660. // // Valid sequence id is required.
  661. // assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
  662. // // A sequence node is required.
  663. // assert(item > 0 && document.nodes.start + item <= document.nodes.top)
  664. // // Valid item id is required.
  665. //
  666. // if (!PUSH(&context,
  667. // document.nodes.start[sequence-1].data.sequence.items, item))
  668. // return 0
  669. //
  670. // return 1
  671. //}
  672. //
  673. ///*
  674. // * Append a pair of a key and a value to a mapping node.
  675. // */
  676. //
  677. //YAML_DECLARE(int)
  678. //yaml_document_append_mapping_pair(document *yaml_document_t,
  679. // mapping int, key int, value int)
  680. //{
  681. // struct {
  682. // error yaml_error_type_t
  683. // } context
  684. //
  685. // pair yaml_node_pair_t
  686. //
  687. // assert(document) // Non-NULL document is required.
  688. // assert(mapping > 0
  689. // && document.nodes.start + mapping <= document.nodes.top)
  690. // // Valid mapping id is required.
  691. // assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
  692. // // A mapping node is required.
  693. // assert(key > 0 && document.nodes.start + key <= document.nodes.top)
  694. // // Valid key id is required.
  695. // assert(value > 0 && document.nodes.start + value <= document.nodes.top)
  696. // // Valid value id is required.
  697. //
  698. // pair.key = key
  699. // pair.value = value
  700. //
  701. // if (!PUSH(&context,
  702. // document.nodes.start[mapping-1].data.mapping.pairs, pair))
  703. // return 0
  704. //
  705. // return 1
  706. //}
  707. //
  708. //