2 # The following YAML grammar is LL(1) and is parsed by a recursive descent
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 ::=
10 # | properties (block_content | indentless_block_sequence)?
12 # | indentless_block_sequence
13 # block_node ::= ALIAS
14 # | properties block_content?
17 # | properties 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?)?)*
30 # flow_sequence ::= FLOW-SEQUENCE-START
31 # (flow_sequence_entry FLOW-ENTRY)*
32 # flow_sequence_entry?
34 # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
35 # flow_mapping ::= FLOW-MAPPING-START
36 # (flow_mapping_entry FLOW-ENTRY)*
39 # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
43 # stream: { STREAM-START }
44 # explicit_document: { DIRECTIVE DOCUMENT-START }
45 # implicit_document: FIRST(block_node)
46 # block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START }
47 # flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START }
48 # block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
49 # flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
50 # block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START }
51 # flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
52 # block_sequence: { BLOCK-SEQUENCE-START }
53 # block_mapping: { BLOCK-MAPPING-START }
54 # block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY }
55 # indentless_sequence: { ENTRY }
56 # flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
57 # flow_sequence: { FLOW-SEQUENCE-START }
58 # flow_mapping: { FLOW-MAPPING-START }
59 # flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
60 # flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
62 __all__ = ['Parser', 'ParserError']
64 from error import MarkedYAMLError
69 class ParserError(MarkedYAMLError):
73 # Since writing a recursive-descendant parser is a straightforward task, we
74 # do not give many comments here.
78 u'!!': u'tag:yaml.org,2002:',
82 self.current_event = None
83 self.yaml_version = None
87 self.state = self.parse_stream_start
90 # Reset the state attributes (to clear self-references)
94 def check_event(self, *choices):
95 # Check the type of the next event.
96 if self.current_event is None:
98 self.current_event = self.state()
99 if self.current_event is not None:
102 for choice in choices:
103 if isinstance(self.current_event, choice):
107 def peek_event(self):
108 # Get the next event.
109 if self.current_event is None:
111 self.current_event = self.state()
112 return self.current_event
115 # Get the next event and proceed further.
116 if self.current_event is None:
118 self.current_event = self.state()
119 value = self.current_event
120 self.current_event = None
123 # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
124 # implicit_document ::= block_node DOCUMENT-END*
125 # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
127 def parse_stream_start(self):
129 # Parse the stream start.
130 token = self.get_token()
131 event = StreamStartEvent(token.start_mark, token.end_mark,
132 encoding=token.encoding)
134 # Prepare the next state.
135 self.state = self.parse_implicit_document_start
139 def parse_implicit_document_start(self):
141 # Parse an implicit document.
142 if not self.check_token(DirectiveToken, DocumentStartToken,
144 self.tag_handles = self.DEFAULT_TAGS
145 token = self.peek_token()
146 start_mark = end_mark = token.start_mark
147 event = DocumentStartEvent(start_mark, end_mark,
150 # Prepare the next state.
151 self.states.append(self.parse_document_end)
152 self.state = self.parse_block_node
157 return self.parse_document_start()
159 def parse_document_start(self):
161 # Parse any extra document end indicators.
162 while self.check_token(DocumentEndToken):
165 # Parse an explicit document.
166 if not self.check_token(StreamEndToken):
167 token = self.peek_token()
168 start_mark = token.start_mark
169 version, tags = self.process_directives()
170 if not self.check_token(DocumentStartToken):
171 raise ParserError(None, None,
172 "expected '<document start>', but found %r"
173 % self.peek_token().id,
174 self.peek_token().start_mark)
175 token = self.get_token()
176 end_mark = token.end_mark
177 event = DocumentStartEvent(start_mark, end_mark,
178 explicit=True, version=version, tags=tags)
179 self.states.append(self.parse_document_end)
180 self.state = self.parse_document_content
182 # Parse the end of the stream.
183 token = self.get_token()
184 event = StreamEndEvent(token.start_mark, token.end_mark)
185 assert not self.states
186 assert not self.marks
190 def parse_document_end(self):
192 # Parse the document end.
193 token = self.peek_token()
194 start_mark = end_mark = token.start_mark
196 if self.check_token(DocumentEndToken):
197 token = self.get_token()
198 end_mark = token.end_mark
200 event = DocumentEndEvent(start_mark, end_mark,
203 # Prepare the next state.
204 self.state = self.parse_document_start
208 def parse_document_content(self):
209 if self.check_token(DirectiveToken,
210 DocumentStartToken, DocumentEndToken, StreamEndToken):
211 event = self.process_empty_scalar(self.peek_token().start_mark)
212 self.state = self.states.pop()
215 return self.parse_block_node()
217 def process_directives(self):
218 self.yaml_version = None
219 self.tag_handles = {}
220 while self.check_token(DirectiveToken):
221 token = self.get_token()
222 if token.name == u'YAML':
223 if self.yaml_version is not None:
224 raise ParserError(None, None,
225 "found duplicate YAML directive", token.start_mark)
226 major, minor = token.value
228 raise ParserError(None, None,
229 "found incompatible YAML document (version 1.* is required)",
231 self.yaml_version = token.value
232 elif token.name == u'TAG':
233 handle, prefix = token.value
234 if handle in self.tag_handles:
235 raise ParserError(None, None,
236 "duplicate tag handle %r" % handle.encode('utf-8'),
238 self.tag_handles[handle] = prefix
240 value = self.yaml_version, self.tag_handles.copy()
242 value = self.yaml_version, None
243 for key in self.DEFAULT_TAGS:
244 if key not in self.tag_handles:
245 self.tag_handles[key] = self.DEFAULT_TAGS[key]
248 # block_node_or_indentless_sequence ::= ALIAS
249 # | properties (block_content | indentless_block_sequence)?
251 # | indentless_block_sequence
252 # block_node ::= ALIAS
253 # | properties block_content?
255 # flow_node ::= ALIAS
256 # | properties flow_content?
258 # properties ::= TAG ANCHOR? | ANCHOR TAG?
259 # block_content ::= block_collection | flow_collection | SCALAR
260 # flow_content ::= flow_collection | SCALAR
261 # block_collection ::= block_sequence | block_mapping
262 # flow_collection ::= flow_sequence | flow_mapping
264 def parse_block_node(self):
265 return self.parse_node(block=True)
267 def parse_flow_node(self):
268 return self.parse_node()
270 def parse_block_node_or_indentless_sequence(self):
271 return self.parse_node(block=True, indentless_sequence=True)
273 def parse_node(self, block=False, indentless_sequence=False):
274 if self.check_token(AliasToken):
275 token = self.get_token()
276 event = AliasEvent(token.value, token.start_mark, token.end_mark)
277 self.state = self.states.pop()
281 start_mark = end_mark = tag_mark = None
282 if self.check_token(AnchorToken):
283 token = self.get_token()
284 start_mark = token.start_mark
285 end_mark = token.end_mark
287 if self.check_token(TagToken):
288 token = self.get_token()
289 tag_mark = token.start_mark
290 end_mark = token.end_mark
292 elif self.check_token(TagToken):
293 token = self.get_token()
294 start_mark = tag_mark = token.start_mark
295 end_mark = token.end_mark
297 if self.check_token(AnchorToken):
298 token = self.get_token()
299 end_mark = token.end_mark
303 if handle is not None:
304 if handle not in self.tag_handles:
305 raise ParserError("while parsing a node", start_mark,
306 "found undefined tag handle %r" % handle.encode('utf-8'),
308 tag = self.tag_handles[handle]+suffix
312 # raise ParserError("while parsing a node", start_mark,
313 # "found non-specific tag '!'", tag_mark,
314 # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
315 if start_mark is None:
316 start_mark = end_mark = self.peek_token().start_mark
318 implicit = (tag is None or tag == u'!')
319 if indentless_sequence and self.check_token(BlockEntryToken):
320 end_mark = self.peek_token().end_mark
321 event = SequenceStartEvent(anchor, tag, implicit,
322 start_mark, end_mark)
323 self.state = self.parse_indentless_sequence_entry
325 if self.check_token(ScalarToken):
326 token = self.get_token()
327 end_mark = token.end_mark
328 if (token.plain and tag is None) or tag == u'!':
329 implicit = (True, False)
331 implicit = (False, True)
333 implicit = (False, False)
334 event = ScalarEvent(anchor, tag, implicit, token.value,
335 start_mark, end_mark, style=token.style)
336 self.state = self.states.pop()
337 elif self.check_token(FlowSequenceStartToken):
338 end_mark = self.peek_token().end_mark
339 event = SequenceStartEvent(anchor, tag, implicit,
340 start_mark, end_mark, flow_style=True)
341 self.state = self.parse_flow_sequence_first_entry
342 elif self.check_token(FlowMappingStartToken):
343 end_mark = self.peek_token().end_mark
344 event = MappingStartEvent(anchor, tag, implicit,
345 start_mark, end_mark, flow_style=True)
346 self.state = self.parse_flow_mapping_first_key
347 elif block and self.check_token(BlockSequenceStartToken):
348 end_mark = self.peek_token().start_mark
349 event = SequenceStartEvent(anchor, tag, implicit,
350 start_mark, end_mark, flow_style=False)
351 self.state = self.parse_block_sequence_first_entry
352 elif block and self.check_token(BlockMappingStartToken):
353 end_mark = self.peek_token().start_mark
354 event = MappingStartEvent(anchor, tag, implicit,
355 start_mark, end_mark, flow_style=False)
356 self.state = self.parse_block_mapping_first_key
357 elif anchor is not None or tag is not None:
358 # Empty scalars are allowed even if a tag or an anchor is
360 event = ScalarEvent(anchor, tag, (implicit, False), u'',
361 start_mark, end_mark)
362 self.state = self.states.pop()
368 token = self.peek_token()
369 raise ParserError("while parsing a %s node" % node, start_mark,
370 "expected the node content, but found %r" % token.id,
374 # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
376 def parse_block_sequence_first_entry(self):
377 token = self.get_token()
378 self.marks.append(token.start_mark)
379 return self.parse_block_sequence_entry()
381 def parse_block_sequence_entry(self):
382 if self.check_token(BlockEntryToken):
383 token = self.get_token()
384 if not self.check_token(BlockEntryToken, BlockEndToken):
385 self.states.append(self.parse_block_sequence_entry)
386 return self.parse_block_node()
388 self.state = self.parse_block_sequence_entry
389 return self.process_empty_scalar(token.end_mark)
390 if not self.check_token(BlockEndToken):
391 token = self.peek_token()
392 raise ParserError("while parsing a block collection", self.marks[-1],
393 "expected <block end>, but found %r" % token.id, token.start_mark)
394 token = self.get_token()
395 event = SequenceEndEvent(token.start_mark, token.end_mark)
396 self.state = self.states.pop()
400 # indentless_sequence ::= (BLOCK-ENTRY block_node?)+
402 def parse_indentless_sequence_entry(self):
403 if self.check_token(BlockEntryToken):
404 token = self.get_token()
405 if not self.check_token(BlockEntryToken,
406 KeyToken, ValueToken, BlockEndToken):
407 self.states.append(self.parse_indentless_sequence_entry)
408 return self.parse_block_node()
410 self.state = self.parse_indentless_sequence_entry
411 return self.process_empty_scalar(token.end_mark)
412 token = self.peek_token()
413 event = SequenceEndEvent(token.start_mark, token.start_mark)
414 self.state = self.states.pop()
417 # block_mapping ::= BLOCK-MAPPING_START
418 # ((KEY block_node_or_indentless_sequence?)?
419 # (VALUE block_node_or_indentless_sequence?)?)*
422 def parse_block_mapping_first_key(self):
423 token = self.get_token()
424 self.marks.append(token.start_mark)
425 return self.parse_block_mapping_key()
427 def parse_block_mapping_key(self):
428 if self.check_token(KeyToken):
429 token = self.get_token()
430 if not self.check_token(KeyToken, ValueToken, BlockEndToken):
431 self.states.append(self.parse_block_mapping_value)
432 return self.parse_block_node_or_indentless_sequence()
434 self.state = self.parse_block_mapping_value
435 return self.process_empty_scalar(token.end_mark)
436 if not self.check_token(BlockEndToken):
437 token = self.peek_token()
438 raise ParserError("while parsing a block mapping", self.marks[-1],
439 "expected <block end>, but found %r" % token.id, token.start_mark)
440 token = self.get_token()
441 event = MappingEndEvent(token.start_mark, token.end_mark)
442 self.state = self.states.pop()
446 def parse_block_mapping_value(self):
447 if self.check_token(ValueToken):
448 token = self.get_token()
449 if not self.check_token(KeyToken, ValueToken, BlockEndToken):
450 self.states.append(self.parse_block_mapping_key)
451 return self.parse_block_node_or_indentless_sequence()
453 self.state = self.parse_block_mapping_key
454 return self.process_empty_scalar(token.end_mark)
456 self.state = self.parse_block_mapping_key
457 token = self.peek_token()
458 return self.process_empty_scalar(token.start_mark)
460 # flow_sequence ::= FLOW-SEQUENCE-START
461 # (flow_sequence_entry FLOW-ENTRY)*
462 # flow_sequence_entry?
464 # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
466 # Note that while production rules for both flow_sequence_entry and
467 # flow_mapping_entry are equal, their interpretations are different.
468 # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?`
469 # generate an inline mapping (set syntax).
471 def parse_flow_sequence_first_entry(self):
472 token = self.get_token()
473 self.marks.append(token.start_mark)
474 return self.parse_flow_sequence_entry(first=True)
476 def parse_flow_sequence_entry(self, first=False):
477 if not self.check_token(FlowSequenceEndToken):
479 if self.check_token(FlowEntryToken):
482 token = self.peek_token()
483 raise ParserError("while parsing a flow sequence", self.marks[-1],
484 "expected ',' or ']', but got %r" % token.id, token.start_mark)
486 if self.check_token(KeyToken):
487 token = self.peek_token()
488 event = MappingStartEvent(None, None, True,
489 token.start_mark, token.end_mark,
491 self.state = self.parse_flow_sequence_entry_mapping_key
493 elif not self.check_token(FlowSequenceEndToken):
494 self.states.append(self.parse_flow_sequence_entry)
495 return self.parse_flow_node()
496 token = self.get_token()
497 event = SequenceEndEvent(token.start_mark, token.end_mark)
498 self.state = self.states.pop()
502 def parse_flow_sequence_entry_mapping_key(self):
503 token = self.get_token()
504 if not self.check_token(ValueToken,
505 FlowEntryToken, FlowSequenceEndToken):
506 self.states.append(self.parse_flow_sequence_entry_mapping_value)
507 return self.parse_flow_node()
509 self.state = self.parse_flow_sequence_entry_mapping_value
510 return self.process_empty_scalar(token.end_mark)
512 def parse_flow_sequence_entry_mapping_value(self):
513 if self.check_token(ValueToken):
514 token = self.get_token()
515 if not self.check_token(FlowEntryToken, FlowSequenceEndToken):
516 self.states.append(self.parse_flow_sequence_entry_mapping_end)
517 return self.parse_flow_node()
519 self.state = self.parse_flow_sequence_entry_mapping_end
520 return self.process_empty_scalar(token.end_mark)
522 self.state = self.parse_flow_sequence_entry_mapping_end
523 token = self.peek_token()
524 return self.process_empty_scalar(token.start_mark)
526 def parse_flow_sequence_entry_mapping_end(self):
527 self.state = self.parse_flow_sequence_entry
528 token = self.peek_token()
529 return MappingEndEvent(token.start_mark, token.start_mark)
531 # flow_mapping ::= FLOW-MAPPING-START
532 # (flow_mapping_entry FLOW-ENTRY)*
533 # flow_mapping_entry?
535 # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
537 def parse_flow_mapping_first_key(self):
538 token = self.get_token()
539 self.marks.append(token.start_mark)
540 return self.parse_flow_mapping_key(first=True)
542 def parse_flow_mapping_key(self, first=False):
543 if not self.check_token(FlowMappingEndToken):
545 if self.check_token(FlowEntryToken):
548 token = self.peek_token()
549 raise ParserError("while parsing a flow mapping", self.marks[-1],
550 "expected ',' or '}', but got %r" % token.id, token.start_mark)
551 if self.check_token(KeyToken):
552 token = self.get_token()
553 if not self.check_token(ValueToken,
554 FlowEntryToken, FlowMappingEndToken):
555 self.states.append(self.parse_flow_mapping_value)
556 return self.parse_flow_node()
558 self.state = self.parse_flow_mapping_value
559 return self.process_empty_scalar(token.end_mark)
560 elif not self.check_token(FlowMappingEndToken):
561 self.states.append(self.parse_flow_mapping_empty_value)
562 return self.parse_flow_node()
563 token = self.get_token()
564 event = MappingEndEvent(token.start_mark, token.end_mark)
565 self.state = self.states.pop()
569 def parse_flow_mapping_value(self):
570 if self.check_token(ValueToken):
571 token = self.get_token()
572 if not self.check_token(FlowEntryToken, FlowMappingEndToken):
573 self.states.append(self.parse_flow_mapping_key)
574 return self.parse_flow_node()
576 self.state = self.parse_flow_mapping_key
577 return self.process_empty_scalar(token.end_mark)
579 self.state = self.parse_flow_mapping_key
580 token = self.peek_token()
581 return self.process_empty_scalar(token.start_mark)
583 def parse_flow_mapping_empty_value(self):
584 self.state = self.parse_flow_mapping_key
585 return self.process_empty_scalar(self.peek_token().start_mark)
587 def process_empty_scalar(self, mark):
588 return ScalarEvent(None, None, (True, False), u'', mark, mark)