Lines Matching refs:self
81 def __init__(self):
82 self.current_event = None
83 self.yaml_version = None
84 self.tag_handles = {}
85 self.states = []
86 self.marks = []
87 self.state = self.parse_stream_start
89 def dispose(self):
90 # Reset the state attributes (to clear self-references)
91 self.states = []
92 self.state = None
94 def check_event(self, *choices):
96 if self.current_event is None:
97 if self.state:
98 self.current_event = self.state()
99 if self.current_event is not None:
103 if isinstance(self.current_event, choice):
107 def peek_event(self):
109 if self.current_event is None:
110 if self.state:
111 self.current_event = self.state()
112 return self.current_event
114 def get_event(self):
116 if self.current_event is None:
117 if self.state:
118 self.current_event = self.state()
119 value = self.current_event
120 self.current_event = None
127 def parse_stream_start(self):
130 token = self.get_token()
135 self.state = self.parse_implicit_document_start
139 def parse_implicit_document_start(self):
142 if not self.check_token(DirectiveToken, DocumentStartToken,
144 self.tag_handles = self.DEFAULT_TAGS
145 token = self.peek_token()
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):
162 while self.check_token(DocumentEndToken):
163 self.get_token()
166 if not self.check_token(StreamEndToken):
167 token = self.peek_token()
169 version, tags = self.process_directives()
170 if not self.check_token(DocumentStartToken):
173 % self.peek_token().id,
174 self.peek_token().start_mark)
175 token = self.get_token()
179 self.states.append(self.parse_document_end)
180 self.state = self.parse_document_content
183 token = self.get_token()
185 assert not self.states
186 assert not self.marks
187 self.state = None
190 def parse_document_end(self):
193 token = self.peek_token()
196 if self.check_token(DocumentEndToken):
197 token = self.get_token()
204 self.state = self.parse_document_start
208 def parse_document_content(self):
209 if self.check_token(DirectiveToken,
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()
223 if self.yaml_version is not None:
231 self.yaml_version = token.value
234 if handle in self.tag_handles:
238 self.tag_handles[handle] = prefix
239 if self.tag_handles:
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]
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()
277 self.state = self.states.pop()
282 if self.check_token(AnchorToken):
283 token = self.get_token()
287 if self.check_token(TagToken):
288 token = self.get_token()
292 elif self.check_token(TagToken):
293 token = self.get_token()
297 if self.check_token(AnchorToken):
298 token = self.get_token()
304 if handle not in self.tag_handles:
308 tag = self.tag_handles[handle]+suffix
316 start_mark = end_mark = self.peek_token().start_mark
319 if indentless_sequence and self.check_token(BlockEntryToken):
320 end_mark = self.peek_token().end_mark
323 self.state = self.parse_indentless_sequence_entry
325 if self.check_token(ScalarToken):
326 token = self.get_token()
336 self.state = self.states.pop()
337 elif self.check_token(FlowSequenceStartToken):
338 end_mark = self.peek_token().end_mark
341 self.state = self.parse_flow_sequence_first_entry
342 elif self.check_token(FlowMappingStartToken):
343 end_mark = self.peek_token().end_mark
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
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
356 self.state = self.parse_block_mapping_first_key
362 self.state = self.states.pop()
368 token = self.peek_token()
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],
394 token = self.get_token()
396 self.state = self.states.pop()
397 self.marks.pop()
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,
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()
414 self.state = self.states.pop()
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],
440 token = self.get_token()
442 self.state = self.states.pop()
443 self.marks.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)
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):
480 self.get_token()
482 token = self.peek_token()
483 raise ParserError("while parsing a flow sequence", self.marks[-1],
486 if self.check_token(KeyToken):
487 token = self.peek_token()
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()
498 self.state = self.states.pop()
499 self.marks.pop()
502 def parse_flow_sequence_entry_mapping_key(self):
503 token = self.get_token()
504 if not self.check_token(ValueToken,
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()
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):
546 self.get_token()
548 token = self.peek_token()
549 raise ParserError("while parsing a flow mapping", self.marks[-1],
551 if self.check_token(KeyToken):
552 token = self.get_token()
553 if not self.check_token(ValueToken,
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()
565 self.state = self.states.pop()
566 self.marks.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):