Ruby  2.0.0p353(2013-11-22revision43784)
parser.c
Go to the documentation of this file.
1 
2 /*
3  * The parser implements the following grammar:
4  *
5  * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
6  * implicit_document ::= block_node DOCUMENT-END*
7  * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
8  * block_node_or_indentless_sequence ::=
9  * ALIAS
10  * | properties (block_content | indentless_block_sequence)?
11  * | block_content
12  * | indentless_block_sequence
13  * block_node ::= ALIAS
14  * | properties block_content?
15  * | block_content
16  * flow_node ::= ALIAS
17  * | properties flow_content?
18  * | flow_content
19  * properties ::= TAG ANCHOR? | ANCHOR TAG?
20  * block_content ::= block_collection | flow_collection | SCALAR
21  * flow_content ::= flow_collection | SCALAR
22  * block_collection ::= block_sequence | block_mapping
23  * flow_collection ::= flow_sequence | flow_mapping
24  * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
25  * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
26  * block_mapping ::= BLOCK-MAPPING_START
27  * ((KEY block_node_or_indentless_sequence?)?
28  * (VALUE block_node_or_indentless_sequence?)?)*
29  * BLOCK-END
30  * flow_sequence ::= FLOW-SEQUENCE-START
31  * (flow_sequence_entry FLOW-ENTRY)*
32  * flow_sequence_entry?
33  * FLOW-SEQUENCE-END
34  * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
35  * flow_mapping ::= FLOW-MAPPING-START
36  * (flow_mapping_entry FLOW-ENTRY)*
37  * flow_mapping_entry?
38  * FLOW-MAPPING-END
39  * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
40  */
41 
42 #include "yaml_private.h"
43 
44 /*
45  * Peek the next token in the token queue.
46  */
47 
48 #define PEEK_TOKEN(parser) \
49  ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \
50  parser->tokens.head : NULL)
51 
52 /*
53  * Remove the next token from the queue (must be called after PEEK_TOKEN).
54  */
55 
56 #define SKIP_TOKEN(parser) \
57  (parser->token_available = 0, \
58  parser->tokens_parsed ++, \
59  parser->stream_end_produced = \
60  (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \
61  parser->tokens.head ++)
62 
63 /*
64  * Public API declarations.
65  */
66 
67 YAML_DECLARE(int)
69 
70 /*
71  * Error handling.
72  */
73 
74 static int
76  const char *problem, yaml_mark_t problem_mark);
77 
78 static int
80  const char *context, yaml_mark_t context_mark,
81  const char *problem, yaml_mark_t problem_mark);
82 
83 /*
84  * State functions.
85  */
86 
87 static int
89 
90 static int
92 
93 static int
95  int implicit);
96 
97 static int
99 
100 static int
102 
103 static int
105  int block, int indentless_sequence);
106 
107 static int
109  yaml_event_t *event, int first);
110 
111 static int
113  yaml_event_t *event);
114 
115 static int
117  yaml_event_t *event, int first);
118 
119 static int
121  yaml_event_t *event);
122 
123 static int
125  yaml_event_t *event, int first);
126 
127 static int
129  yaml_event_t *event);
130 
131 static int
133  yaml_event_t *event);
134 
135 static int
137  yaml_event_t *event);
138 
139 static int
141  yaml_event_t *event, int first);
142 
143 static int
145  yaml_event_t *event, int empty);
146 
147 /*
148  * Utility functions.
149  */
150 
151 static int
153  yaml_event_t *event, yaml_mark_t mark);
154 
155 static int
157  yaml_version_directive_t **version_directive_ref,
158  yaml_tag_directive_t **tag_directives_start_ref,
159  yaml_tag_directive_t **tag_directives_end_ref);
160 
161 static int
163  yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark);
164 
165 /*
166  * Get the next event.
167  */
168 
169 YAML_DECLARE(int)
171 {
172  assert(parser); /* Non-NULL parser object is expected. */
173  assert(event); /* Non-NULL event object is expected. */
174 
175  /* Erase the event object. */
176 
177  memset(event, 0, sizeof(yaml_event_t));
178 
179  /* No events after the end of the stream or error. */
180 
181  if (parser->stream_end_produced || parser->error ||
182  parser->state == YAML_PARSE_END_STATE) {
183  return 1;
184  }
185 
186  /* Generate the next event. */
187 
188  return yaml_parser_state_machine(parser, event);
189 }
190 
191 /*
192  * Set parser error.
193  */
194 
195 static int
197  const char *problem, yaml_mark_t problem_mark)
198 {
199  parser->error = YAML_PARSER_ERROR;
200  parser->problem = problem;
201  parser->problem_mark = problem_mark;
202 
203  return 0;
204 }
205 
206 static int
208  const char *context, yaml_mark_t context_mark,
209  const char *problem, yaml_mark_t problem_mark)
210 {
211  parser->error = YAML_PARSER_ERROR;
212  parser->context = context;
213  parser->context_mark = context_mark;
214  parser->problem = problem;
215  parser->problem_mark = problem_mark;
216 
217  return 0;
218 }
219 
220 
221 /*
222  * State dispatcher.
223  */
224 
225 static int
227 {
228  switch (parser->state)
229  {
231  return yaml_parser_parse_stream_start(parser, event);
232 
234  return yaml_parser_parse_document_start(parser, event, 1);
235 
237  return yaml_parser_parse_document_start(parser, event, 0);
238 
240  return yaml_parser_parse_document_content(parser, event);
241 
243  return yaml_parser_parse_document_end(parser, event);
244 
246  return yaml_parser_parse_node(parser, event, 1, 0);
247 
249  return yaml_parser_parse_node(parser, event, 1, 1);
250 
252  return yaml_parser_parse_node(parser, event, 0, 0);
253 
255  return yaml_parser_parse_block_sequence_entry(parser, event, 1);
256 
258  return yaml_parser_parse_block_sequence_entry(parser, event, 0);
259 
261  return yaml_parser_parse_indentless_sequence_entry(parser, event);
262 
264  return yaml_parser_parse_block_mapping_key(parser, event, 1);
265 
267  return yaml_parser_parse_block_mapping_key(parser, event, 0);
268 
270  return yaml_parser_parse_block_mapping_value(parser, event);
271 
273  return yaml_parser_parse_flow_sequence_entry(parser, event, 1);
274 
276  return yaml_parser_parse_flow_sequence_entry(parser, event, 0);
277 
280 
283 
286 
288  return yaml_parser_parse_flow_mapping_key(parser, event, 1);
289 
291  return yaml_parser_parse_flow_mapping_key(parser, event, 0);
292 
294  return yaml_parser_parse_flow_mapping_value(parser, event, 0);
295 
297  return yaml_parser_parse_flow_mapping_value(parser, event, 1);
298 
299  default:
300  assert(1); /* Invalid state. */
301  }
302 
303  return 0;
304 }
305 
306 /*
307  * Parse the production:
308  * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
309  * ************
310  */
311 
312 static int
314 {
316 
317  token = PEEK_TOKEN(parser);
318  if (!token) return 0;
319 
320  if (token->type != YAML_STREAM_START_TOKEN) {
321  return yaml_parser_set_parser_error(parser,
322  "did not find expected <stream-start>", token->start_mark);
323  }
324 
326  STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
327  token->start_mark, token->start_mark);
328  SKIP_TOKEN(parser);
329 
330  return 1;
331 }
332 
333 /*
334  * Parse the productions:
335  * implicit_document ::= block_node DOCUMENT-END*
336  * *
337  * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
338  * *************************
339  */
340 
341 static int
343  int implicit)
344 {
346  yaml_version_directive_t *version_directive = NULL;
347  struct {
348  yaml_tag_directive_t *start;
350  } tag_directives = { NULL, NULL };
351 
352  token = PEEK_TOKEN(parser);
353  if (!token) return 0;
354 
355  /* Parse extra document end indicators. */
356 
357  if (!implicit)
358  {
359  while (token->type == YAML_DOCUMENT_END_TOKEN) {
360  SKIP_TOKEN(parser);
361  token = PEEK_TOKEN(parser);
362  if (!token) return 0;
363  }
364  }
365 
366  /* Parse an implicit document. */
367 
368  if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
369  token->type != YAML_TAG_DIRECTIVE_TOKEN &&
370  token->type != YAML_DOCUMENT_START_TOKEN &&
371  token->type != YAML_STREAM_END_TOKEN)
372  {
374  return 0;
375  if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
376  return 0;
379  token->start_mark, token->start_mark);
380  return 1;
381  }
382 
383  /* Parse an explicit document. */
384 
385  else if (token->type != YAML_STREAM_END_TOKEN)
386  {
387  yaml_mark_t start_mark, end_mark;
388  start_mark = token->start_mark;
389  if (!yaml_parser_process_directives(parser, &version_directive,
390  &tag_directives.start, &tag_directives.end))
391  return 0;
392  token = PEEK_TOKEN(parser);
393  if (!token) goto error;
394  if (token->type != YAML_DOCUMENT_START_TOKEN) {
396  "did not find expected <document start>", token->start_mark);
397  goto error;
398  }
399  if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
400  goto error;
402  end_mark = token->end_mark;
403  DOCUMENT_START_EVENT_INIT(*event, version_directive,
404  tag_directives.start, tag_directives.end, 0,
405  start_mark, end_mark);
406  SKIP_TOKEN(parser);
407  version_directive = NULL;
408  tag_directives.start = tag_directives.end = NULL;
409  return 1;
410  }
411 
412  /* Parse the stream end. */
413 
414  else
415  {
416  parser->state = YAML_PARSE_END_STATE;
417  STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
418  SKIP_TOKEN(parser);
419  return 1;
420  }
421 
422 error:
423  yaml_free(version_directive);
424  while (tag_directives.start != tag_directives.end) {
425  yaml_free(tag_directives.end[-1].handle);
426  yaml_free(tag_directives.end[-1].prefix);
427  tag_directives.end --;
428  }
429  yaml_free(tag_directives.start);
430  return 0;
431 }
432 
433 /*
434  * Parse the productions:
435  * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
436  * ***********
437  */
438 
439 static int
441 {
443 
444  token = PEEK_TOKEN(parser);
445  if (!token) return 0;
446 
447  if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
448  token->type == YAML_TAG_DIRECTIVE_TOKEN ||
449  token->type == YAML_DOCUMENT_START_TOKEN ||
450  token->type == YAML_DOCUMENT_END_TOKEN ||
451  token->type == YAML_STREAM_END_TOKEN) {
452  parser->state = POP(parser, parser->states);
453  return yaml_parser_process_empty_scalar(parser, event,
454  token->start_mark);
455  }
456  else {
457  return yaml_parser_parse_node(parser, event, 1, 0);
458  }
459 }
460 
461 /*
462  * Parse the productions:
463  * implicit_document ::= block_node DOCUMENT-END*
464  * *************
465  * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
466  * *************
467  */
468 
469 static int
471 {
473  yaml_mark_t start_mark, end_mark;
474  int implicit = 1;
475 
476  token = PEEK_TOKEN(parser);
477  if (!token) return 0;
478 
479  start_mark = end_mark = token->start_mark;
480 
481  if (token->type == YAML_DOCUMENT_END_TOKEN) {
482  end_mark = token->end_mark;
483  SKIP_TOKEN(parser);
484  implicit = 0;
485  }
486 
487  while (!STACK_EMPTY(parser, parser->tag_directives)) {
488  yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
489  yaml_free(tag_directive.handle);
490  yaml_free(tag_directive.prefix);
491  }
492 
494  DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
495 
496  return 1;
497 }
498 
499 /*
500  * Parse the productions:
501  * block_node_or_indentless_sequence ::=
502  * ALIAS
503  * *****
504  * | properties (block_content | indentless_block_sequence)?
505  * ********** *
506  * | block_content | indentless_block_sequence
507  * *
508  * block_node ::= ALIAS
509  * *****
510  * | properties block_content?
511  * ********** *
512  * | block_content
513  * *
514  * flow_node ::= ALIAS
515  * *****
516  * | properties flow_content?
517  * ********** *
518  * | flow_content
519  * *
520  * properties ::= TAG ANCHOR? | ANCHOR TAG?
521  * *************************
522  * block_content ::= block_collection | flow_collection | SCALAR
523  * ******
524  * flow_content ::= flow_collection | SCALAR
525  * ******
526  */
527 
528 static int
530  int block, int indentless_sequence)
531 {
533  yaml_char_t *anchor = NULL;
534  yaml_char_t *tag_handle = NULL;
535  yaml_char_t *tag_suffix = NULL;
536  yaml_char_t *tag = NULL;
537  yaml_mark_t start_mark, end_mark, tag_mark;
538  int implicit;
539 
540  token = PEEK_TOKEN(parser);
541  if (!token) return 0;
542 
543  if (token->type == YAML_ALIAS_TOKEN)
544  {
545  parser->state = POP(parser, parser->states);
546  ALIAS_EVENT_INIT(*event, token->data.alias.value,
547  token->start_mark, token->end_mark);
548  SKIP_TOKEN(parser);
549  return 1;
550  }
551 
552  else
553  {
554  start_mark = end_mark = token->start_mark;
555 
556  if (token->type == YAML_ANCHOR_TOKEN)
557  {
558  anchor = token->data.anchor.value;
559  start_mark = token->start_mark;
560  end_mark = token->end_mark;
561  SKIP_TOKEN(parser);
562  token = PEEK_TOKEN(parser);
563  if (!token) goto error;
564  if (token->type == YAML_TAG_TOKEN)
565  {
566  tag_handle = token->data.tag.handle;
567  tag_suffix = token->data.tag.suffix;
568  tag_mark = token->start_mark;
569  end_mark = token->end_mark;
570  SKIP_TOKEN(parser);
571  token = PEEK_TOKEN(parser);
572  if (!token) goto error;
573  }
574  }
575  else if (token->type == YAML_TAG_TOKEN)
576  {
577  tag_handle = token->data.tag.handle;
578  tag_suffix = token->data.tag.suffix;
579  start_mark = tag_mark = token->start_mark;
580  end_mark = token->end_mark;
581  SKIP_TOKEN(parser);
582  token = PEEK_TOKEN(parser);
583  if (!token) goto error;
584  if (token->type == YAML_ANCHOR_TOKEN)
585  {
586  anchor = token->data.anchor.value;
587  end_mark = token->end_mark;
588  SKIP_TOKEN(parser);
589  token = PEEK_TOKEN(parser);
590  if (!token) goto error;
591  }
592  }
593 
594  if (tag_handle) {
595  if (!*tag_handle) {
596  tag = tag_suffix;
597  yaml_free(tag_handle);
598  tag_handle = tag_suffix = NULL;
599  }
600  else {
601  yaml_tag_directive_t *tag_directive;
602  for (tag_directive = parser->tag_directives.start;
603  tag_directive != parser->tag_directives.top;
604  tag_directive ++) {
605  if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
606  size_t prefix_len = strlen((char *)tag_directive->prefix);
607  size_t suffix_len = strlen((char *)tag_suffix);
608  tag = yaml_malloc(prefix_len+suffix_len+1);
609  if (!tag) {
610  parser->error = YAML_MEMORY_ERROR;
611  goto error;
612  }
613  memcpy(tag, tag_directive->prefix, prefix_len);
614  memcpy(tag+prefix_len, tag_suffix, suffix_len);
615  tag[prefix_len+suffix_len] = '\0';
616  yaml_free(tag_handle);
617  yaml_free(tag_suffix);
618  tag_handle = tag_suffix = NULL;
619  break;
620  }
621  }
622  if (!tag) {
624  "while parsing a node", start_mark,
625  "found undefined tag handle", tag_mark);
626  goto error;
627  }
628  }
629  }
630 
631  implicit = (!tag || !*tag);
632  if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
633  end_mark = token->end_mark;
635  SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
636  YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
637  return 1;
638  }
639  else {
640  if (token->type == YAML_SCALAR_TOKEN) {
641  int plain_implicit = 0;
642  int quoted_implicit = 0;
643  end_mark = token->end_mark;
644  if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
645  || (tag && strcmp((char *)tag, "!") == 0)) {
646  plain_implicit = 1;
647  }
648  else if (!tag) {
649  quoted_implicit = 1;
650  }
651  parser->state = POP(parser, parser->states);
652  SCALAR_EVENT_INIT(*event, anchor, tag,
653  token->data.scalar.value, token->data.scalar.length,
654  plain_implicit, quoted_implicit,
655  token->data.scalar.style, start_mark, end_mark);
656  SKIP_TOKEN(parser);
657  return 1;
658  }
659  else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
660  end_mark = token->end_mark;
662  SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
663  YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
664  return 1;
665  }
666  else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
667  end_mark = token->end_mark;
669  MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
670  YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
671  return 1;
672  }
673  else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
674  end_mark = token->end_mark;
676  SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
677  YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
678  return 1;
679  }
680  else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
681  end_mark = token->end_mark;
683  MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
684  YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
685  return 1;
686  }
687  else if (anchor || tag) {
688  yaml_char_t *value = yaml_malloc(1);
689  if (!value) {
690  parser->error = YAML_MEMORY_ERROR;
691  goto error;
692  }
693  value[0] = '\0';
694  parser->state = POP(parser, parser->states);
695  SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
696  implicit, 0, YAML_PLAIN_SCALAR_STYLE,
697  start_mark, end_mark);
698  return 1;
699  }
700  else {
702  (block ? "while parsing a block node"
703  : "while parsing a flow node"), start_mark,
704  "did not find expected node content", token->start_mark);
705  goto error;
706  }
707  }
708  }
709 
710 error:
711  yaml_free(anchor);
712  yaml_free(tag_handle);
713  yaml_free(tag_suffix);
714  yaml_free(tag);
715 
716  return 0;
717 }
718 
719 /*
720  * Parse the productions:
721  * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
722  * ******************** *********** * *********
723  */
724 
725 static int
727  yaml_event_t *event, int first)
728 {
730 
731  if (first) {
732  token = PEEK_TOKEN(parser);
733  if (!PUSH(parser, parser->marks, token->start_mark))
734  return 0;
735  SKIP_TOKEN(parser);
736  }
737 
738  token = PEEK_TOKEN(parser);
739  if (!token) return 0;
740 
741  if (token->type == YAML_BLOCK_ENTRY_TOKEN)
742  {
743  yaml_mark_t mark = token->end_mark;
744  SKIP_TOKEN(parser);
745  token = PEEK_TOKEN(parser);
746  if (!token) return 0;
747  if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
748  token->type != YAML_BLOCK_END_TOKEN) {
749  if (!PUSH(parser, parser->states,
751  return 0;
752  return yaml_parser_parse_node(parser, event, 1, 0);
753  }
754  else {
756  return yaml_parser_process_empty_scalar(parser, event, mark);
757  }
758  }
759 
760  else if (token->type == YAML_BLOCK_END_TOKEN)
761  {
762  yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
763  parser->state = POP(parser, parser->states);
764  dummy_mark = POP(parser, parser->marks);
765  SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
766  SKIP_TOKEN(parser);
767  return 1;
768  }
769 
770  else
771  {
773  "while parsing a block collection", POP(parser, parser->marks),
774  "did not find expected '-' indicator", token->start_mark);
775  }
776 }
777 
778 /*
779  * Parse the productions:
780  * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
781  * *********** *
782  */
783 
784 static int
786  yaml_event_t *event)
787 {
789 
790  token = PEEK_TOKEN(parser);
791  if (!token) return 0;
792 
793  if (token->type == YAML_BLOCK_ENTRY_TOKEN)
794  {
795  yaml_mark_t mark = token->end_mark;
796  SKIP_TOKEN(parser);
797  token = PEEK_TOKEN(parser);
798  if (!token) return 0;
799  if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
800  token->type != YAML_KEY_TOKEN &&
801  token->type != YAML_VALUE_TOKEN &&
802  token->type != YAML_BLOCK_END_TOKEN) {
803  if (!PUSH(parser, parser->states,
805  return 0;
806  return yaml_parser_parse_node(parser, event, 1, 0);
807  }
808  else {
810  return yaml_parser_process_empty_scalar(parser, event, mark);
811  }
812  }
813 
814  else
815  {
816  parser->state = POP(parser, parser->states);
817  SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
818  return 1;
819  }
820 }
821 
822 /*
823  * Parse the productions:
824  * block_mapping ::= BLOCK-MAPPING_START
825  * *******************
826  * ((KEY block_node_or_indentless_sequence?)?
827  * *** *
828  * (VALUE block_node_or_indentless_sequence?)?)*
829  *
830  * BLOCK-END
831  * *********
832  */
833 
834 static int
836  yaml_event_t *event, int first)
837 {
839 
840  if (first) {
841  token = PEEK_TOKEN(parser);
842  if (!PUSH(parser, parser->marks, token->start_mark))
843  return 0;
844  SKIP_TOKEN(parser);
845  }
846 
847  token = PEEK_TOKEN(parser);
848  if (!token) return 0;
849 
850  if (token->type == YAML_KEY_TOKEN)
851  {
852  yaml_mark_t mark = token->end_mark;
853  SKIP_TOKEN(parser);
854  token = PEEK_TOKEN(parser);
855  if (!token) return 0;
856  if (token->type != YAML_KEY_TOKEN &&
857  token->type != YAML_VALUE_TOKEN &&
858  token->type != YAML_BLOCK_END_TOKEN) {
859  if (!PUSH(parser, parser->states,
861  return 0;
862  return yaml_parser_parse_node(parser, event, 1, 1);
863  }
864  else {
866  return yaml_parser_process_empty_scalar(parser, event, mark);
867  }
868  }
869 
870  else if (token->type == YAML_BLOCK_END_TOKEN)
871  {
872  yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
873  parser->state = POP(parser, parser->states);
874  dummy_mark = POP(parser, parser->marks);
875  MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
876  SKIP_TOKEN(parser);
877  return 1;
878  }
879 
880  else
881  {
883  "while parsing a block mapping", POP(parser, parser->marks),
884  "did not find expected key", token->start_mark);
885  }
886 }
887 
888 /*
889  * Parse the productions:
890  * block_mapping ::= BLOCK-MAPPING_START
891  *
892  * ((KEY block_node_or_indentless_sequence?)?
893  *
894  * (VALUE block_node_or_indentless_sequence?)?)*
895  * ***** *
896  * BLOCK-END
897  *
898  */
899 
900 static int
902  yaml_event_t *event)
903 {
905 
906  token = PEEK_TOKEN(parser);
907  if (!token) return 0;
908 
909  if (token->type == YAML_VALUE_TOKEN)
910  {
911  yaml_mark_t mark = token->end_mark;
912  SKIP_TOKEN(parser);
913  token = PEEK_TOKEN(parser);
914  if (!token) return 0;
915  if (token->type != YAML_KEY_TOKEN &&
916  token->type != YAML_VALUE_TOKEN &&
917  token->type != YAML_BLOCK_END_TOKEN) {
918  if (!PUSH(parser, parser->states,
920  return 0;
921  return yaml_parser_parse_node(parser, event, 1, 1);
922  }
923  else {
925  return yaml_parser_process_empty_scalar(parser, event, mark);
926  }
927  }
928 
929  else
930  {
932  return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
933  }
934 }
935 
936 /*
937  * Parse the productions:
938  * flow_sequence ::= FLOW-SEQUENCE-START
939  * *******************
940  * (flow_sequence_entry FLOW-ENTRY)*
941  * * **********
942  * flow_sequence_entry?
943  * *
944  * FLOW-SEQUENCE-END
945  * *****************
946  * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
947  * *
948  */
949 
950 static int
952  yaml_event_t *event, int first)
953 {
955  yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
956 
957  if (first) {
958  token = PEEK_TOKEN(parser);
959  if (!PUSH(parser, parser->marks, token->start_mark))
960  return 0;
961  SKIP_TOKEN(parser);
962  }
963 
964  token = PEEK_TOKEN(parser);
965  if (!token) return 0;
966 
967  if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN)
968  {
969  if (!first) {
970  if (token->type == YAML_FLOW_ENTRY_TOKEN) {
971  SKIP_TOKEN(parser);
972  token = PEEK_TOKEN(parser);
973  if (!token) return 0;
974  }
975  else {
977  "while parsing a flow sequence", POP(parser, parser->marks),
978  "did not find expected ',' or ']'", token->start_mark);
979  }
980  }
981 
982  if (token->type == YAML_KEY_TOKEN) {
986  token->start_mark, token->end_mark);
987  SKIP_TOKEN(parser);
988  return 1;
989  }
990 
991  else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
992  if (!PUSH(parser, parser->states,
994  return 0;
995  return yaml_parser_parse_node(parser, event, 0, 0);
996  }
997  }
998 
999  parser->state = POP(parser, parser->states);
1000  dummy_mark = POP(parser, parser->marks);
1001  SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1002  SKIP_TOKEN(parser);
1003  return 1;
1004 }
1005 
1006 /*
1007  * Parse the productions:
1008  * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1009  * *** *
1010  */
1011 
1012 static int
1014  yaml_event_t *event)
1015 {
1017 
1018  token = PEEK_TOKEN(parser);
1019  if (!token) return 0;
1020 
1021  if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN
1022  && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1023  if (!PUSH(parser, parser->states,
1025  return 0;
1026  return yaml_parser_parse_node(parser, event, 0, 0);
1027  }
1028  else {
1029  yaml_mark_t mark = token->end_mark;
1030  SKIP_TOKEN(parser);
1032  return yaml_parser_process_empty_scalar(parser, event, mark);
1033  }
1034 }
1035 
1036 /*
1037  * Parse the productions:
1038  * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1039  * ***** *
1040  */
1041 
1042 static int
1044  yaml_event_t *event)
1045 {
1047 
1048  token = PEEK_TOKEN(parser);
1049  if (!token) return 0;
1050 
1051  if (token->type == YAML_VALUE_TOKEN) {
1052  SKIP_TOKEN(parser);
1053  token = PEEK_TOKEN(parser);
1054  if (!token) return 0;
1055  if (token->type != YAML_FLOW_ENTRY_TOKEN
1056  && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1057  if (!PUSH(parser, parser->states,
1059  return 0;
1060  return yaml_parser_parse_node(parser, event, 0, 0);
1061  }
1062  }
1064  return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1065 }
1066 
1067 /*
1068  * Parse the productions:
1069  * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1070  * *
1071  */
1072 
1073 static int
1075  yaml_event_t *event)
1076 {
1078 
1079  token = PEEK_TOKEN(parser);
1080  if (!token) return 0;
1081 
1083 
1084  MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
1085  return 1;
1086 }
1087 
1088 /*
1089  * Parse the productions:
1090  * flow_mapping ::= FLOW-MAPPING-START
1091  * ******************
1092  * (flow_mapping_entry FLOW-ENTRY)*
1093  * * **********
1094  * flow_mapping_entry?
1095  * ******************
1096  * FLOW-MAPPING-END
1097  * ****************
1098  * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1099  * * *** *
1100  */
1101 
1102 static int
1104  yaml_event_t *event, int first)
1105 {
1107  yaml_mark_t dummy_mark; /* Used to eliminate a compiler warning. */
1108 
1109  if (first) {
1110  token = PEEK_TOKEN(parser);
1111  if (!PUSH(parser, parser->marks, token->start_mark))
1112  return 0;
1113  SKIP_TOKEN(parser);
1114  }
1115 
1116  token = PEEK_TOKEN(parser);
1117  if (!token) return 0;
1118 
1119  if (token->type != YAML_FLOW_MAPPING_END_TOKEN)
1120  {
1121  if (!first) {
1122  if (token->type == YAML_FLOW_ENTRY_TOKEN) {
1123  SKIP_TOKEN(parser);
1124  token = PEEK_TOKEN(parser);
1125  if (!token) return 0;
1126  }
1127  else {
1129  "while parsing a flow mapping", POP(parser, parser->marks),
1130  "did not find expected ',' or '}'", token->start_mark);
1131  }
1132  }
1133 
1134  if (token->type == YAML_KEY_TOKEN) {
1135  SKIP_TOKEN(parser);
1136  token = PEEK_TOKEN(parser);
1137  if (!token) return 0;
1138  if (token->type != YAML_VALUE_TOKEN
1139  && token->type != YAML_FLOW_ENTRY_TOKEN
1140  && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1141  if (!PUSH(parser, parser->states,
1143  return 0;
1144  return yaml_parser_parse_node(parser, event, 0, 0);
1145  }
1146  else {
1148  return yaml_parser_process_empty_scalar(parser, event,
1149  token->start_mark);
1150  }
1151  }
1152  else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1153  if (!PUSH(parser, parser->states,
1155  return 0;
1156  return yaml_parser_parse_node(parser, event, 0, 0);
1157  }
1158  }
1159 
1160  parser->state = POP(parser, parser->states);
1161  dummy_mark = POP(parser, parser->marks);
1162  MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1163  SKIP_TOKEN(parser);
1164  return 1;
1165 }
1166 
1167 /*
1168  * Parse the productions:
1169  * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1170  * * ***** *
1171  */
1172 
1173 static int
1175  yaml_event_t *event, int empty)
1176 {
1178 
1179  token = PEEK_TOKEN(parser);
1180  if (!token) return 0;
1181 
1182  if (empty) {
1184  return yaml_parser_process_empty_scalar(parser, event,
1185  token->start_mark);
1186  }
1187 
1188  if (token->type == YAML_VALUE_TOKEN) {
1189  SKIP_TOKEN(parser);
1190  token = PEEK_TOKEN(parser);
1191  if (!token) return 0;
1192  if (token->type != YAML_FLOW_ENTRY_TOKEN
1193  && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1194  if (!PUSH(parser, parser->states,
1196  return 0;
1197  return yaml_parser_parse_node(parser, event, 0, 0);
1198  }
1199  }
1200 
1202  return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1203 }
1204 
1205 /*
1206  * Generate an empty scalar event.
1207  */
1208 
1209 static int
1211  yaml_mark_t mark)
1212 {
1213  yaml_char_t *value;
1214 
1215  value = yaml_malloc(1);
1216  if (!value) {
1217  parser->error = YAML_MEMORY_ERROR;
1218  return 0;
1219  }
1220  value[0] = '\0';
1221 
1222  SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
1223  1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
1224 
1225  return 1;
1226 }
1227 
1228 /*
1229  * Parse directives.
1230  */
1231 
1232 static int
1234  yaml_version_directive_t **version_directive_ref,
1235  yaml_tag_directive_t **tag_directives_start_ref,
1236  yaml_tag_directive_t **tag_directives_end_ref)
1237 {
1238  yaml_tag_directive_t default_tag_directives[] = {
1239  {(yaml_char_t *)"!", (yaml_char_t *)"!"},
1240  {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
1241  {NULL, NULL}
1242  };
1243  yaml_tag_directive_t *default_tag_directive;
1244  yaml_version_directive_t *version_directive = NULL;
1245  struct {
1246  yaml_tag_directive_t *start;
1247  yaml_tag_directive_t *end;
1249  } tag_directives = { NULL, NULL, NULL };
1251 
1252  if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
1253  goto error;
1254 
1255  token = PEEK_TOKEN(parser);
1256  if (!token) goto error;
1257 
1258  while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
1259  token->type == YAML_TAG_DIRECTIVE_TOKEN)
1260  {
1261  if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
1262  if (version_directive) {
1264  "found duplicate %YAML directive", token->start_mark);
1265  goto error;
1266  }
1267  if (token->data.version_directive.major != 1
1268  || token->data.version_directive.minor != 1) {
1270  "found incompatible YAML document", token->start_mark);
1271  goto error;
1272  }
1273  version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
1274  if (!version_directive) {
1275  parser->error = YAML_MEMORY_ERROR;
1276  goto error;
1277  }
1278  version_directive->major = token->data.version_directive.major;
1279  version_directive->minor = token->data.version_directive.minor;
1280  }
1281 
1282  else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
1283  yaml_tag_directive_t value;
1284  value.handle = token->data.tag_directive.handle;
1285  value.prefix = token->data.tag_directive.prefix;
1286 
1287  if (!yaml_parser_append_tag_directive(parser, value, 0,
1288  token->start_mark))
1289  goto error;
1290  if (!PUSH(parser, tag_directives, value))
1291  goto error;
1292  }
1293 
1294  SKIP_TOKEN(parser);
1295  token = PEEK_TOKEN(parser);
1296  if (!token) goto error;
1297  }
1298 
1299  for (default_tag_directive = default_tag_directives;
1300  default_tag_directive->handle; default_tag_directive++) {
1301  if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
1302  token->start_mark))
1303  goto error;
1304  }
1305 
1306  if (version_directive_ref) {
1307  *version_directive_ref = version_directive;
1308  }
1309  if (tag_directives_start_ref) {
1310  if (STACK_EMPTY(parser, tag_directives)) {
1311  *tag_directives_start_ref = *tag_directives_end_ref = NULL;
1312  STACK_DEL(parser, tag_directives);
1313  }
1314  else {
1315  *tag_directives_start_ref = tag_directives.start;
1316  *tag_directives_end_ref = tag_directives.top;
1317  }
1318  }
1319  else {
1320  STACK_DEL(parser, tag_directives);
1321  }
1322 
1323  return 1;
1324 
1325 error:
1326  yaml_free(version_directive);
1327  while (!STACK_EMPTY(parser, tag_directives)) {
1328  yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
1329  yaml_free(tag_directive.handle);
1330  yaml_free(tag_directive.prefix);
1331  }
1332  STACK_DEL(parser, tag_directives);
1333  return 0;
1334 }
1335 
1336 /*
1337  * Append a tag directive to the directives stack.
1338  */
1339 
1340 static int
1342  yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
1343 {
1344  yaml_tag_directive_t *tag_directive;
1345  yaml_tag_directive_t copy = { NULL, NULL };
1346 
1347  for (tag_directive = parser->tag_directives.start;
1348  tag_directive != parser->tag_directives.top; tag_directive ++) {
1349  if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
1350  if (allow_duplicates)
1351  return 1;
1352  return yaml_parser_set_parser_error(parser,
1353  "found duplicate %TAG directive", mark);
1354  }
1355  }
1356 
1357  copy.handle = yaml_strdup(value.handle);
1358  copy.prefix = yaml_strdup(value.prefix);
1359  if (!copy.handle || !copy.prefix) {
1360  parser->error = YAML_MEMORY_ERROR;
1361  goto error;
1362  }
1363 
1364  if (!PUSH(parser, parser->tag_directives, copy))
1365  goto error;
1366 
1367  return 1;
1368 
1369 error:
1370  yaml_free(copy.handle);
1371  yaml_free(copy.prefix);
1372  return 0;
1373 }
1374 
struct yaml_token_s::@12::@19 tag_directive
The tag directive (for YAML_TAG_DIRECTIVE_TOKEN).
yaml_strdup(const yaml_char_t *str)
Definition: api.c:61
struct yaml_token_s::@12::@15 anchor
The anchor (for YAML_ANCHOR_TOKEN).
Expect an entry of a flow sequence.
Definition: yaml.h:1042
#define PUSH(x)
Definition: bigdecimal.c:64
The block mapping style.
Definition: yaml.h:199
A BLOCK-SEQUENCE-START token.
Definition: yaml.h:232
yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
Parse the input stream and produce the next parsing event.
Definition: parser.c:170
The pointer position.
Definition: yaml.h:145
#define STREAM_END_EVENT_INIT(event, start_mark, end_mark)
Definition: yaml_private.h:538
The event structure.
Definition: yaml.h:384
Expect DOCUMENT-START.
Definition: yaml.h:1016
size_t strlen(const char *)
#define SCALAR_EVENT_INIT(event, event_anchor, event_tag, event_value, event_length,event_plain_implicit, event_quoted_implicit, event_style, start_mark, end_mark)
Definition: yaml_private.h:557
struct yaml_token_s::@12::@18 version_directive
The version directive (for YAML_VERSION_DIRECTIVE_TOKEN).
A FLOW-SEQUENCE-START token.
Definition: yaml.h:239
A VALUE token.
Definition: yaml.h:254
Expect the first key of a block mapping.
Definition: yaml.h:1034
Cannot allocate or reallocate a block of memory.
Definition: yaml.h:127
yaml_mark_t end_mark
The end of the token.
Definition: yaml.h:332
A BLOCK-END token.
Definition: yaml.h:236
static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, yaml_event_t *event, int empty)
Definition: parser.c:1174
static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:1043
The parser structure.
Definition: yaml.h:1081
A BLOCK-SEQUENCE-END token.
Definition: yaml.h:234
static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:1013
#define STREAM_START_EVENT_INIT(event, event_encoding, start_mark, end_mark)
Definition: yaml_private.h:534
yaml_parser_state_t state
The current parser state.
Definition: yaml.h:1255
#define PEEK_TOKEN(parser)
Definition: parser.c:48
A FLOW-ENTRY token.
Definition: yaml.h:250
#define SEQUENCE_START_EVENT_INIT(event, event_anchor, event_tag,event_implicit, event_style, start_mark, end_mark)
Definition: yaml_private.h:568
#define INITIAL_STACK_SIZE
Definition: yaml_private.h:76
unsigned char yaml_char_t
The character type (UTF-8 octet).
Definition: yaml.h:78
const unsigned char * start
The string start pointer.
Definition: yaml.h:1123
The version directive data.
Definition: yaml.h:81
const char * context
The error context.
Definition: yaml.h:1099
static int yaml_parser_append_tag_directive(yaml_parser_t *parser, yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
Definition: parser.c:1341
Expect a key of an ordered mapping.
Definition: yaml.h:1044
struct yaml_token_s::@12::@14 alias
The alias (for YAML_ALIAS_TOKEN).
yaml_char_t * prefix
The tag prefix.
Definition: yaml.h:93
union yaml_token_s::@12 data
The token data.
static int yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:313
#define MAPPING_START_EVENT_INIT(event, event_anchor, event_tag,event_implicit, event_style, start_mark, end_mark)
Definition: yaml_private.h:579
An ALIAS token.
Definition: yaml.h:257
#define SEQUENCE_END_EVENT_INIT(event, start_mark, end_mark)
Definition: yaml_private.h:576
Expect the beginning of an implicit document.
Definition: yaml.h:1014
A FLOW-SEQUENCE-END token.
Definition: yaml.h:241
#define STACK_EMPTY(context, stack)
Definition: yaml_private.h:424
Expect the content of a document.
Definition: yaml.h:1018
static int yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event, yaml_mark_t mark)
Definition: parser.c:1210
yaml_free(void *ptr)
Definition: api.c:51
static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:1074
static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first)
Definition: parser.c:726
int * top
The top of the stack.
Definition: yaml.h:1216
A VERSION-DIRECTIVE token.
Definition: yaml.h:223
static int yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:470
int major
The major version number.
Definition: yaml.h:83
A TAG token.
Definition: yaml.h:261
A STREAM-START token.
Definition: yaml.h:218
Expect an entry of a block sequence.
Definition: yaml.h:1030
static int yaml_parser_process_directives(yaml_parser_t *parser, yaml_version_directive_t **version_directive_ref, yaml_tag_directive_t **tag_directives_start_ref, yaml_tag_directive_t **tag_directives_end_ref)
Definition: parser.c:1233
#define ALIAS_EVENT_INIT(event, event_anchor, start_mark, end_mark)
Definition: yaml_private.h:553
static int yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event, int implicit)
Definition: parser.c:342
#define YAML_DECLARE(type)
The public API declaration.
Definition: yaml.h:38
ID token
Definition: ripper.c:16497
A FLOW-MAPPING-START token.
Definition: yaml.h:243
#define STACK_DEL(context, stack)
Definition: yaml_private.h:420
yaml_error_type_t error
Error type.
Definition: yaml.h:1089
#define DOCUMENT_END_EVENT_INIT(event, event_implicit, start_mark, end_mark)
Definition: yaml_private.h:549
#define MAPPING_END_EVENT_INIT(event, start_mark, end_mark)
Definition: yaml_private.h:587
static int yaml_parser_set_parser_error(yaml_parser_t *parser, const char *problem, yaml_mark_t problem_mark)
Definition: parser.c:196
struct yaml_parser_s::@43 states
The parser states stack.
yaml_char_t * handle
The tag handle.
Definition: yaml.h:91
static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:785
struct yaml_parser_s::@44 marks
The stack of marks.
#define const
Definition: strftime.c:102
Expect a block mapping value.
Definition: yaml.h:1038
static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event, int block, int indentless_sequence)
Definition: parser.c:529
A STREAM-END token.
Definition: yaml.h:220
The tag directive data.
Definition: yaml.h:89
An ANCHOR token.
Definition: yaml.h:259
yaml_token_type_t type
The token type.
Definition: yaml.h:270
Cannot parse the input stream.
Definition: yaml.h:134
Expect an empty value of a flow mapping.
Definition: yaml.h:1056
yaml_mark_t context_mark
The context position.
Definition: yaml.h:1101
static int yaml_parser_set_parser_error_context(yaml_parser_t *parser, const char *context, yaml_mark_t context_mark, const char *problem, yaml_mark_t problem_mark)
Definition: parser.c:207
A FLOW-MAPPING-END token.
Definition: yaml.h:245
static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:901
Expect a flow node.
Definition: yaml.h:1026
yaml_mark_t problem_mark
The problem position.
Definition: yaml.h:1097
static int yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:226
struct yaml_parser_s::@45 tag_directives
The list of TAG directives.
unsigned int top
Definition: nkf.c:4309
A DOCUMENT-START token.
Definition: yaml.h:227
#define DOCUMENT_START_EVENT_INIT(event, event_version_directive,event_tag_directives_start, event_tag_directives_end, event_implicit, start_mark, end_mark)
Definition: yaml_private.h:541
Expect the and of an ordered mapping entry.
Definition: yaml.h:1048
static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first)
Definition: parser.c:1103
Expect an entry of an indentless sequence.
Definition: yaml.h:1032
Expect a block node or indentless sequence.
Definition: yaml.h:1024
struct yaml_token_s::@12::@17 scalar
The scalar value (for YAML_SCALAR_TOKEN).
The plain scalar style.
Definition: yaml.h:169
struct yaml_token_s::@12::@16 tag
The tag (for YAML_TAG_TOKEN).
int minor
The minor version number.
Definition: yaml.h:85
Expect the first entry of a flow sequence.
Definition: yaml.h:1040
#define POP(context, stack)
Definition: yaml_private.h:436
A DOCUMENT-END token.
Definition: yaml.h:229
Expect the first entry of a block sequence.
Definition: yaml.h:1028
A TAG-DIRECTIVE token.
Definition: yaml.h:225
static VALUE mark(VALUE self)
Definition: psych_parser.c:523
Expect a value of a flow mapping.
Definition: yaml.h:1054
Expect DOCUMENT-END.
Definition: yaml.h:1020
Expect nothing.
Definition: yaml.h:1058
Expect a key of a flow mapping.
Definition: yaml.h:1052
A SCALAR token.
Definition: yaml.h:263
#define assert(condition)
Definition: ossl.h:45
Expect the first key of a flow mapping.
Definition: yaml.h:1050
yaml_malloc(size_t size)
Definition: api.c:31
const char * problem
Error description.
Definition: yaml.h:1091
#define SKIP_TOKEN(parser)
Definition: parser.c:56
#define STACK_INIT(context, stack, size)
Definition: yaml_private.h:412
The flow mapping style.
Definition: yaml.h:201
Expect a value of an ordered mapping.
Definition: yaml.h:1046
Expect a block node.
Definition: yaml.h:1022
A BLOCK-ENTRY token.
Definition: yaml.h:248
#define NULL
Definition: _sdbm.c:103
A KEY token.
Definition: yaml.h:252
struct yaml_token_s::@12::@13 stream_start
The stream start (for YAML_STREAM_START_TOKEN).
Expect a block mapping key.
Definition: yaml.h:1036
static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, yaml_event_t *event, int first)
Definition: parser.c:835
Expect STREAM-START.
Definition: yaml.h:1012
The token structure.
Definition: yaml.h:267
The flow sequence style.
Definition: yaml.h:190
static int yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
Definition: parser.c:440
The block sequence style.
Definition: yaml.h:188
static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, yaml_event_t *event, int first)
Definition: parser.c:951
yaml_mark_t start_mark
The beginning of the token.
Definition: yaml.h:330