Lines Matching refs:self
38 def __init__(self, token_number, required, index, line, column, mark): argument
39 self.token_number = token_number
40 self.required = required
41 self.index = index
42 self.line = line
43 self.column = column
44 self.mark = mark
48 def __init__(self): argument
60 self.done = False
64 self.flow_level = 0
67 self.tokens = []
70 self.fetch_stream_start()
73 self.tokens_taken = 0
76 self.indent = -1
79 self.indents = []
101 self.allow_simple_key = True
109 self.possible_simple_keys = {}
113 def check_token(self, *choices): argument
115 while self.need_more_tokens():
116 self.fetch_more_tokens()
117 if self.tokens:
121 if isinstance(self.tokens[0], choice):
125 def peek_token(self): argument
128 while self.need_more_tokens():
129 self.fetch_more_tokens()
130 if self.tokens:
131 return self.tokens[0]
135 def get_token(self): argument
137 while self.need_more_tokens():
138 self.fetch_more_tokens()
139 if self.tokens:
140 self.tokens_taken += 1
141 return self.tokens.pop(0)
145 def need_more_tokens(self): argument
146 if self.done:
148 if not self.tokens:
152 self.stale_possible_simple_keys()
153 if self.next_possible_simple_key() == self.tokens_taken:
156 def fetch_more_tokens(self): argument
159 self.scan_to_next_token()
162 self.stale_possible_simple_keys()
166 self.unwind_indent(self.column)
169 ch = self.peek()
173 return self.fetch_stream_end()
176 if ch == '%' and self.check_directive():
177 return self.fetch_directive()
180 if ch == '-' and self.check_document_start():
181 return self.fetch_document_start()
184 if ch == '.' and self.check_document_end():
185 return self.fetch_document_end()
195 return self.fetch_flow_sequence_start()
199 return self.fetch_flow_mapping_start()
203 return self.fetch_flow_sequence_end()
207 return self.fetch_flow_mapping_end()
211 return self.fetch_flow_entry()
214 if ch == '-' and self.check_block_entry():
215 return self.fetch_block_entry()
218 if ch == '?' and self.check_key():
219 return self.fetch_key()
222 if ch == ':' and self.check_value():
223 return self.fetch_value()
227 return self.fetch_alias()
231 return self.fetch_anchor()
235 return self.fetch_tag()
238 if ch == '|' and not self.flow_level:
239 return self.fetch_literal()
242 if ch == '>' and not self.flow_level:
243 return self.fetch_folded()
247 return self.fetch_single()
251 return self.fetch_double()
254 if self.check_plain():
255 return self.fetch_plain()
260 self.get_mark())
264 def next_possible_simple_key(self): argument
273 for level in self.possible_simple_keys:
274 key = self.possible_simple_keys[level]
279 def stale_possible_simple_keys(self): argument
286 for level in list(self.possible_simple_keys):
287 key = self.possible_simple_keys[level]
288 if key.line != self.line \
289 or self.index-key.index > 1024:
292 "could not find expected ':'", self.get_mark())
293 del self.possible_simple_keys[level]
295 def save_possible_simple_key(self): argument
301 required = not self.flow_level and self.indent == self.column
305 if self.allow_simple_key:
306 self.remove_possible_simple_key()
307 token_number = self.tokens_taken+len(self.tokens)
309 self.index, self.line, self.column, self.get_mark())
310 self.possible_simple_keys[self.flow_level] = key
312 def remove_possible_simple_key(self): argument
314 if self.flow_level in self.possible_simple_keys:
315 key = self.possible_simple_keys[self.flow_level]
319 "could not find expected ':'", self.get_mark())
321 del self.possible_simple_keys[self.flow_level]
325 def unwind_indent(self, column): argument
340 if self.flow_level:
344 while self.indent > column:
345 mark = self.get_mark()
346 self.indent = self.indents.pop()
347 self.tokens.append(BlockEndToken(mark, mark))
349 def add_indent(self, column): argument
351 if self.indent < column:
352 self.indents.append(self.indent)
353 self.indent = column
359 def fetch_stream_start(self): argument
364 mark = self.get_mark()
367 self.tokens.append(StreamStartToken(mark, mark,
368 encoding=self.encoding))
371 def fetch_stream_end(self): argument
374 self.unwind_indent(-1)
377 self.remove_possible_simple_key()
378 self.allow_simple_key = False
379 self.possible_simple_keys = {}
382 mark = self.get_mark()
385 self.tokens.append(StreamEndToken(mark, mark))
388 self.done = True
390 def fetch_directive(self): argument
393 self.unwind_indent(-1)
396 self.remove_possible_simple_key()
397 self.allow_simple_key = False
400 self.tokens.append(self.scan_directive())
402 def fetch_document_start(self): argument
403 self.fetch_document_indicator(DocumentStartToken)
405 def fetch_document_end(self): argument
406 self.fetch_document_indicator(DocumentEndToken)
408 def fetch_document_indicator(self, TokenClass): argument
411 self.unwind_indent(-1)
415 self.remove_possible_simple_key()
416 self.allow_simple_key = False
419 start_mark = self.get_mark()
420 self.forward(3)
421 end_mark = self.get_mark()
422 self.tokens.append(TokenClass(start_mark, end_mark))
424 def fetch_flow_sequence_start(self): argument
425 self.fetch_flow_collection_start(FlowSequenceStartToken)
427 def fetch_flow_mapping_start(self): argument
428 self.fetch_flow_collection_start(FlowMappingStartToken)
430 def fetch_flow_collection_start(self, TokenClass): argument
433 self.save_possible_simple_key()
436 self.flow_level += 1
439 self.allow_simple_key = True
442 start_mark = self.get_mark()
443 self.forward()
444 end_mark = self.get_mark()
445 self.tokens.append(TokenClass(start_mark, end_mark))
447 def fetch_flow_sequence_end(self): argument
448 self.fetch_flow_collection_end(FlowSequenceEndToken)
450 def fetch_flow_mapping_end(self): argument
451 self.fetch_flow_collection_end(FlowMappingEndToken)
453 def fetch_flow_collection_end(self, TokenClass): argument
456 self.remove_possible_simple_key()
459 self.flow_level -= 1
462 self.allow_simple_key = False
465 start_mark = self.get_mark()
466 self.forward()
467 end_mark = self.get_mark()
468 self.tokens.append(TokenClass(start_mark, end_mark))
470 def fetch_flow_entry(self): argument
473 self.allow_simple_key = True
476 self.remove_possible_simple_key()
479 start_mark = self.get_mark()
480 self.forward()
481 end_mark = self.get_mark()
482 self.tokens.append(FlowEntryToken(start_mark, end_mark))
484 def fetch_block_entry(self): argument
487 if not self.flow_level:
490 if not self.allow_simple_key:
493 self.get_mark())
496 if self.add_indent(self.column):
497 mark = self.get_mark()
498 self.tokens.append(BlockSequenceStartToken(mark, mark))
506 self.allow_simple_key = True
509 self.remove_possible_simple_key()
512 start_mark = self.get_mark()
513 self.forward()
514 end_mark = self.get_mark()
515 self.tokens.append(BlockEntryToken(start_mark, end_mark))
517 def fetch_key(self): argument
520 if not self.flow_level:
523 if not self.allow_simple_key:
526 self.get_mark())
529 if self.add_indent(self.column):
530 mark = self.get_mark()
531 self.tokens.append(BlockMappingStartToken(mark, mark))
534 self.allow_simple_key = not self.flow_level
537 self.remove_possible_simple_key()
540 start_mark = self.get_mark()
541 self.forward()
542 end_mark = self.get_mark()
543 self.tokens.append(KeyToken(start_mark, end_mark))
545 def fetch_value(self): argument
548 if self.flow_level in self.possible_simple_keys:
551 key = self.possible_simple_keys[self.flow_level]
552 del self.possible_simple_keys[self.flow_level]
553 self.tokens.insert(key.token_number-self.tokens_taken,
558 if not self.flow_level:
559 if self.add_indent(key.column):
560 self.tokens.insert(key.token_number-self.tokens_taken,
564 self.allow_simple_key = False
572 if not self.flow_level:
576 if not self.allow_simple_key:
579 self.get_mark())
584 if not self.flow_level:
585 if self.add_indent(self.column):
586 mark = self.get_mark()
587 self.tokens.append(BlockMappingStartToken(mark, mark))
590 self.allow_simple_key = not self.flow_level
593 self.remove_possible_simple_key()
596 start_mark = self.get_mark()
597 self.forward()
598 end_mark = self.get_mark()
599 self.tokens.append(ValueToken(start_mark, end_mark))
601 def fetch_alias(self): argument
604 self.save_possible_simple_key()
607 self.allow_simple_key = False
610 self.tokens.append(self.scan_anchor(AliasToken))
612 def fetch_anchor(self): argument
615 self.save_possible_simple_key()
618 self.allow_simple_key = False
621 self.tokens.append(self.scan_anchor(AnchorToken))
623 def fetch_tag(self): argument
626 self.save_possible_simple_key()
629 self.allow_simple_key = False
632 self.tokens.append(self.scan_tag())
634 def fetch_literal(self): argument
635 self.fetch_block_scalar(style='|')
637 def fetch_folded(self): argument
638 self.fetch_block_scalar(style='>')
640 def fetch_block_scalar(self, style): argument
643 self.allow_simple_key = True
646 self.remove_possible_simple_key()
649 self.tokens.append(self.scan_block_scalar(style))
651 def fetch_single(self): argument
652 self.fetch_flow_scalar(style='\'')
654 def fetch_double(self): argument
655 self.fetch_flow_scalar(style='"')
657 def fetch_flow_scalar(self, style): argument
660 self.save_possible_simple_key()
663 self.allow_simple_key = False
666 self.tokens.append(self.scan_flow_scalar(style))
668 def fetch_plain(self): argument
671 self.save_possible_simple_key()
676 self.allow_simple_key = False
679 self.tokens.append(self.scan_plain())
683 def check_directive(self): argument
687 if self.column == 0:
690 def check_document_start(self): argument
693 if self.column == 0:
694 if self.prefix(3) == '---' \
695 and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
698 def check_document_end(self): argument
701 if self.column == 0:
702 if self.prefix(3) == '...' \
703 and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
706 def check_block_entry(self): argument
709 return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
711 def check_key(self): argument
714 if self.flow_level:
719 return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
721 def check_value(self): argument
724 if self.flow_level:
729 return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
731 def check_plain(self): argument
745 ch = self.peek()
747 or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029'
748 and (ch == '-' or (not self.flow_level and ch in '?:')))
752 def scan_to_next_token(self): argument
772 if self.index == 0 and self.peek() == '\uFEFF':
773 self.forward()
776 while self.peek() == ' ':
777 self.forward()
778 if self.peek() == '#':
779 while self.peek() not in '\0\r\n\x85\u2028\u2029':
780 self.forward()
781 if self.scan_line_break():
782 if not self.flow_level:
783 self.allow_simple_key = True
787 def scan_directive(self): argument
789 start_mark = self.get_mark()
790 self.forward()
791 name = self.scan_directive_name(start_mark)
794 value = self.scan_yaml_directive_value(start_mark)
795 end_mark = self.get_mark()
797 value = self.scan_tag_directive_value(start_mark)
798 end_mark = self.get_mark()
800 end_mark = self.get_mark()
801 while self.peek() not in '\0\r\n\x85\u2028\u2029':
802 self.forward()
803 self.scan_directive_ignored_line(start_mark)
806 def scan_directive_name(self, start_mark): argument
809 ch = self.peek(length)
813 ch = self.peek(length)
817 % ch, self.get_mark())
818 value = self.prefix(length)
819 self.forward(length)
820 ch = self.peek()
824 % ch, self.get_mark())
827 def scan_yaml_directive_value(self, start_mark): argument
829 while self.peek() == ' ':
830 self.forward()
831 major = self.scan_yaml_directive_number(start_mark)
832 if self.peek() != '.':
834 "expected a digit or '.', but found %r" % self.peek(),
835 self.get_mark())
836 self.forward()
837 minor = self.scan_yaml_directive_number(start_mark)
838 if self.peek() not in '\0 \r\n\x85\u2028\u2029':
840 "expected a digit or ' ', but found %r" % self.peek(),
841 self.get_mark())
844 def scan_yaml_directive_number(self, start_mark): argument
846 ch = self.peek()
849 "expected a digit, but found %r" % ch, self.get_mark())
851 while '0' <= self.peek(length) <= '9':
853 value = int(self.prefix(length))
854 self.forward(length)
857 def scan_tag_directive_value(self, start_mark): argument
859 while self.peek() == ' ':
860 self.forward()
861 handle = self.scan_tag_directive_handle(start_mark)
862 while self.peek() == ' ':
863 self.forward()
864 prefix = self.scan_tag_directive_prefix(start_mark)
867 def scan_tag_directive_handle(self, start_mark): argument
869 value = self.scan_tag_handle('directive', start_mark)
870 ch = self.peek()
873 "expected ' ', but found %r" % ch, self.get_mark())
876 def scan_tag_directive_prefix(self, start_mark): argument
878 value = self.scan_tag_uri('directive', start_mark)
879 ch = self.peek()
882 "expected ' ', but found %r" % ch, self.get_mark())
885 def scan_directive_ignored_line(self, start_mark): argument
887 while self.peek() == ' ':
888 self.forward()
889 if self.peek() == '#':
890 while self.peek() not in '\0\r\n\x85\u2028\u2029':
891 self.forward()
892 ch = self.peek()
896 % ch, self.get_mark())
897 self.scan_line_break()
899 def scan_anchor(self, TokenClass): argument
908 start_mark = self.get_mark()
909 indicator = self.peek()
914 self.forward()
916 ch = self.peek(length)
920 ch = self.peek(length)
924 % ch, self.get_mark())
925 value = self.prefix(length)
926 self.forward(length)
927 ch = self.peek()
931 % ch, self.get_mark())
932 end_mark = self.get_mark()
935 def scan_tag(self): argument
937 start_mark = self.get_mark()
938 ch = self.peek(1)
941 self.forward(2)
942 suffix = self.scan_tag_uri('tag', start_mark)
943 if self.peek() != '>':
945 "expected '>', but found %r" % self.peek(),
946 self.get_mark())
947 self.forward()
951 self.forward()
960 ch = self.peek(length)
963 handle = self.scan_tag_handle('tag', start_mark)
966 self.forward()
967 suffix = self.scan_tag_uri('tag', start_mark)
968 ch = self.peek()
971 "expected ' ', but found %r" % ch, self.get_mark())
973 end_mark = self.get_mark()
976 def scan_block_scalar(self, style): argument
985 start_mark = self.get_mark()
988 self.forward()
989 chomping, increment = self.scan_block_scalar_indicators(start_mark)
990 self.scan_block_scalar_ignored_line(start_mark)
993 min_indent = self.indent+1
997 breaks, max_indent, end_mark = self.scan_block_scalar_indentation()
1001 breaks, end_mark = self.scan_block_scalar_breaks(indent)
1005 while self.column == indent and self.peek() != '\0':
1007 leading_non_space = self.peek() not in ' \t'
1009 while self.peek(length) not in '\0\r\n\x85\u2028\u2029':
1011 chunks.append(self.prefix(length))
1012 self.forward(length)
1013 line_break = self.scan_line_break()
1014 breaks, end_mark = self.scan_block_scalar_breaks(indent)
1015 if self.column == indent and self.peek() != '\0':
1022 and leading_non_space and self.peek() not in ' \t':
1052 def scan_block_scalar_indicators(self, start_mark): argument
1056 ch = self.peek()
1062 self.forward()
1063 ch = self.peek()
1069 self.get_mark())
1070 self.forward()
1076 self.get_mark())
1077 self.forward()
1078 ch = self.peek()
1084 self.forward()
1085 ch = self.peek()
1089 % ch, self.get_mark())
1092 def scan_block_scalar_ignored_line(self, start_mark): argument
1094 while self.peek() == ' ':
1095 self.forward()
1096 if self.peek() == '#':
1097 while self.peek() not in '\0\r\n\x85\u2028\u2029':
1098 self.forward()
1099 ch = self.peek()
1103 self.get_mark())
1104 self.scan_line_break()
1106 def scan_block_scalar_indentation(self): argument
1110 end_mark = self.get_mark()
1111 while self.peek() in ' \r\n\x85\u2028\u2029':
1112 if self.peek() != ' ':
1113 chunks.append(self.scan_line_break())
1114 end_mark = self.get_mark()
1116 self.forward()
1117 if self.column > max_indent:
1118 max_indent = self.column
1121 def scan_block_scalar_breaks(self, indent): argument
1124 end_mark = self.get_mark()
1125 while self.column < indent and self.peek() == ' ':
1126 self.forward()
1127 while self.peek() in '\r\n\x85\u2028\u2029':
1128 chunks.append(self.scan_line_break())
1129 end_mark = self.get_mark()
1130 while self.column < indent and self.peek() == ' ':
1131 self.forward()
1134 def scan_flow_scalar(self, style): argument
1146 start_mark = self.get_mark()
1147 quote = self.peek()
1148 self.forward()
1149 chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
1150 while self.peek() != quote:
1151 chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
1152 chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
1153 self.forward()
1154 end_mark = self.get_mark()
1185 def scan_flow_scalar_non_spaces(self, double, start_mark): argument
1190 while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029':
1193 chunks.append(self.prefix(length))
1194 self.forward(length)
1195 ch = self.peek()
1196 if not double and ch == '\'' and self.peek(1) == '\'':
1198 self.forward(2)
1201 self.forward()
1203 self.forward()
1204 ch = self.peek()
1205 if ch in self.ESCAPE_REPLACEMENTS:
1206 chunks.append(self.ESCAPE_REPLACEMENTS[ch])
1207 self.forward()
1208 elif ch in self.ESCAPE_CODES:
1209 length = self.ESCAPE_CODES[ch]
1210 self.forward()
1212 if self.peek(k) not in '0123456789ABCDEFabcdef':
1215 (length, self.peek(k)), self.get_mark())
1216 code = int(self.prefix(length), 16)
1218 self.forward(length)
1220 self.scan_line_break()
1221 chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
1224 "found unknown escape character %r" % ch, self.get_mark())
1228 def scan_flow_scalar_spaces(self, double, start_mark): argument
1232 while self.peek(length) in ' \t':
1234 whitespaces = self.prefix(length)
1235 self.forward(length)
1236 ch = self.peek()
1239 "found unexpected end of stream", self.get_mark())
1241 line_break = self.scan_line_break()
1242 breaks = self.scan_flow_scalar_breaks(double, start_mark)
1252 def scan_flow_scalar_breaks(self, double, start_mark): argument
1258 prefix = self.prefix(3)
1260 and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
1262 "found unexpected document separator", self.get_mark())
1263 while self.peek() in ' \t':
1264 self.forward()
1265 if self.peek() in '\r\n\x85\u2028\u2029':
1266 chunks.append(self.scan_line_break())
1270 def scan_plain(self): argument
1277 start_mark = self.get_mark()
1279 indent = self.indent+1
1287 if self.peek() == '#':
1290 ch = self.peek(length)
1293 self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029'
1294 + (u',[]{}' if self.flow_level else u''))\
1295 or (self.flow_level and ch in ',?[]{}'):
1300 self.allow_simple_key = False
1302 chunks.append(self.prefix(length))
1303 self.forward(length)
1304 end_mark = self.get_mark()
1305 spaces = self.scan_plain_spaces(indent, start_mark)
1306 if not spaces or self.peek() == '#' \
1307 or (not self.flow_level and self.column < indent):
1311 def scan_plain_spaces(self, indent, start_mark): argument
1317 while self.peek(length) in ' ':
1319 whitespaces = self.prefix(length)
1320 self.forward(length)
1321 ch = self.peek()
1323 line_break = self.scan_line_break()
1324 self.allow_simple_key = True
1325 prefix = self.prefix(3)
1327 and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
1330 while self.peek() in ' \r\n\x85\u2028\u2029':
1331 if self.peek() == ' ':
1332 self.forward()
1334 breaks.append(self.scan_line_break())
1335 prefix = self.prefix(3)
1337 and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
1348 def scan_tag_handle(self, name, start_mark): argument
1352 ch = self.peek()
1355 "expected '!', but found %r" % ch, self.get_mark())
1357 ch = self.peek(length)
1362 ch = self.peek(length)
1364 self.forward(length)
1366 "expected '!', but found %r" % ch, self.get_mark())
1368 value = self.prefix(length)
1369 self.forward(length)
1372 def scan_tag_uri(self, name, start_mark): argument
1377 ch = self.peek(length)
1381 chunks.append(self.prefix(length))
1382 self.forward(length)
1384 chunks.append(self.scan_uri_escapes(name, start_mark))
1387 ch = self.peek(length)
1389 chunks.append(self.prefix(length))
1390 self.forward(length)
1394 "expected URI, but found %r" % ch, self.get_mark())
1397 def scan_uri_escapes(self, name, start_mark): argument
1400 mark = self.get_mark()
1401 while self.peek() == '%':
1402 self.forward()
1404 if self.peek(k) not in '0123456789ABCDEFabcdef':
1407 % self.peek(k), self.get_mark())
1408 codes.append(int(self.prefix(2), 16))
1409 self.forward(2)
1416 def scan_line_break(self): argument
1425 ch = self.peek()
1427 if self.prefix(2) == '\r\n':
1428 self.forward(2)
1430 self.forward()
1433 self.forward()