Lines Matching refs:self
69 def __init__(self, object name, size_t index, size_t line, size_t column,
71 self.name = name
72 self.index = index
73 self.line = line
74 self.column = column
75 self.buffer = buffer
76 self.pointer = pointer
78 def get_snippet(self):
81 def __str__(self):
83 % (self.name, self.line+1, self.column+1)
91 # def __init__(self, context=None, context_mark=None,
93 # self.context = context
94 # self.context_mark = context_mark
95 # self.problem = problem
96 # self.problem_mark = problem_mark
97 # self.note = note
99 # def __str__(self):
101 # if self.context is not None:
102 # lines.append(self.context)
103 # if self.context_mark is not None \
104 # and (self.problem is None or self.problem_mark is None
105 # or self.context_mark.name != self.problem_mark.name
106 # or self.context_mark.line != self.problem_mark.line
107 # or self.context_mark.column != self.problem_mark.column):
108 # lines.append(str(self.context_mark))
109 # if self.problem is not None:
110 # lines.append(self.problem)
111 # if self.problem_mark is not None:
112 # lines.append(str(self.problem_mark))
113 # if self.note is not None:
114 # lines.append(self.note)
119 # def __init__(self, name, position, character, encoding, reason):
120 # self.name = name
121 # self.character = character
122 # self.position = position
123 # self.encoding = encoding
124 # self.reason = reason
126 # def __str__(self):
127 # if isinstance(self.character, str):
130 # % (self.encoding, ord(self.character), self.reason,
131 # self.name, self.position)
135 # % (ord(self.character), self.reason,
136 # self.name, self.position)
150 # def __init__(self, Mark start_mark, Mark end_mark):
151 # self.start_mark = start_mark
152 # self.end_mark = end_mark
156 # def __init__(self, Mark start_mark, Mark end_mark, encoding):
157 # self.start_mark = start_mark
158 # self.end_mark = end_mark
159 # self.encoding = encoding
167 # def __init__(self, name, value, Mark start_mark, Mark end_mark):
168 # self.name = name
169 # self.value = value
170 # self.start_mark = start_mark
171 # self.end_mark = end_mark
214 # def __init__(self, value, Mark start_mark, Mark end_mark):
215 # self.value = value
216 # self.start_mark = start_mark
217 # self.end_mark = end_mark
221 # def __init__(self, value, Mark start_mark, Mark end_mark):
222 # self.value = value
223 # self.start_mark = start_mark
224 # self.end_mark = end_mark
228 # def __init__(self, value, Mark start_mark, Mark end_mark):
229 # self.value = value
230 # self.start_mark = start_mark
231 # self.end_mark = end_mark
237 # def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None):
238 # self.value = value
239 # self.plain = plain
240 # self.start_mark = start_mark
241 # self.end_mark = end_mark
242 # self.style = style
259 def __init__(self, stream):
261 if yaml_parser_initialize(&self.parser) == 0:
263 self.parsed_event.type = YAML_NO_EVENT
269 self.unicode_source = 0
271 self.stream = stream
273 self.stream_name = stream.name
275 self.stream_name = u'<file>'
276 self.stream_cache = None
277 self.stream_cache_len = 0
278 self.stream_cache_pos = 0
279 yaml_parser_set_input(&self.parser, input_handler, <void *>self)
283 self.stream_name = u'<unicode string>'
284 self.unicode_source = 1
286 self.stream_name = u'<byte string>'
289 self.stream = stream
290 yaml_parser_set_input_string(&self.parser, PyBytes_AS_Yaml_STRING(stream), PyBytes_GET_SIZE(stream))
291 self.current_token = None
292 self.current_event = None
293 self.anchors = {}
295 def __dealloc__(self):
296 yaml_parser_delete(&self.parser)
297 yaml_event_delete(&self.parsed_event)
299 def dispose(self):
302 cdef object _parser_error(self):
303 if self.parser.error == YAML_MEMORY_ERROR:
305 elif self.parser.error == YAML_READER_ERROR:
306 return ReaderError(self.stream_name, self.parser.problem_offset,
307 self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem))
308 elif self.parser.error == YAML_SCANNER_ERROR \
309 or self.parser.error == YAML_PARSER_ERROR:
312 if self.parser.context != NULL:
313 context_mark = Mark(self.stream_name,
314 self.parser.context_mark.index,
315 self.parser.context_mark.line,
316 self.parser.context_mark.column, None, None)
317 if self.parser.problem != NULL:
318 problem_mark = Mark(self.stream_name,
319 self.parser.problem_mark.index,
320 self.parser.problem_mark.line,
321 self.parser.problem_mark.column, None, None)
323 if self.parser.context != NULL:
324 context = PyUnicode_FromString(self.parser.context)
325 problem = PyUnicode_FromString(self.parser.problem)
326 if self.parser.error == YAML_SCANNER_ERROR:
332 def raw_scan(self):
339 if yaml_parser_scan(&self.parser, &token) == 0:
340 error = self._parser_error()
349 cdef object _scan(self):
351 if yaml_parser_scan(&self.parser, &token) == 0:
352 error = self._parser_error()
354 token_object = self._token_to_object(&token)
358 cdef object _token_to_object(self, yaml_token_t *token):
359 start_mark = Mark(self.stream_name,
364 end_mark = Mark(self.stream_name,
374 if self.unicode_source == 0:
452 def get_token(self):
453 if self.current_token is not None:
454 value = self.current_token
455 self.current_token = None
457 value = self._scan()
460 def peek_token(self):
461 if self.current_token is None:
462 self.current_token = self._scan()
463 return self.current_token
465 def check_token(self, *choices):
466 if self.current_token is None:
467 self.current_token = self._scan()
468 if self.current_token is None:
472 token_class = self.current_token.__class__
478 def raw_parse(self):
485 if yaml_parser_parse(&self.parser, &event) == 0:
486 error = self._parser_error()
495 cdef object _parse(self):
497 if yaml_parser_parse(&self.parser, &event) == 0:
498 error = self._parser_error()
500 event_object = self._event_to_object(&event)
504 cdef object _event_to_object(self, yaml_event_t *event):
506 start_mark = Mark(self.stream_name,
511 end_mark = Mark(self.stream_name,
521 if self.unicode_source == 0:
627 def get_event(self):
628 if self.current_event is not None:
629 value = self.current_event
630 self.current_event = None
632 value = self._parse()
635 def peek_event(self):
636 if self.current_event is None:
637 self.current_event = self._parse()
638 return self.current_event
640 def check_event(self, *choices):
641 if self.current_event is None:
642 self.current_event = self._parse()
643 if self.current_event is None:
647 event_class = self.current_event.__class__
653 def check_node(self):
654 self._parse_next_event()
655 if self.parsed_event.type == YAML_STREAM_START_EVENT:
656 yaml_event_delete(&self.parsed_event)
657 self._parse_next_event()
658 if self.parsed_event.type != YAML_STREAM_END_EVENT:
662 def get_node(self):
663 self._parse_next_event()
664 if self.parsed_event.type != YAML_STREAM_END_EVENT:
665 return self._compose_document()
667 def get_single_node(self):
668 self._parse_next_event()
669 yaml_event_delete(&self.parsed_event)
670 self._parse_next_event()
672 if self.parsed_event.type != YAML_STREAM_END_EVENT:
673 document = self._compose_document()
674 self._parse_next_event()
675 if self.parsed_event.type != YAML_STREAM_END_EVENT:
676 mark = Mark(self.stream_name,
677 self.parsed_event.start_mark.index,
678 self.parsed_event.start_mark.line,
679 self.parsed_event.start_mark.column,
685 cdef object _compose_document(self):
686 yaml_event_delete(&self.parsed_event)
687 node = self._compose_node(None, None)
688 self._parse_next_event()
689 yaml_event_delete(&self.parsed_event)
690 self.anchors = {}
693 cdef object _compose_node(self, object parent, object index):
694 self._parse_next_event()
695 if self.parsed_event.type == YAML_ALIAS_EVENT:
696 anchor = PyUnicode_FromYamlString(self.parsed_event.data.alias.anchor)
697 if anchor not in self.anchors:
698 mark = Mark(self.stream_name,
699 self.parsed_event.start_mark.index,
700 self.parsed_event.start_mark.line,
701 self.parsed_event.start_mark.column,
704 yaml_event_delete(&self.parsed_event)
705 return self.anchors[anchor]
707 if self.parsed_event.type == YAML_SCALAR_EVENT \
708 and self.parsed_event.data.scalar.anchor != NULL:
709 anchor = PyUnicode_FromYamlString(self.parsed_event.data.scalar.anchor)
710 elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \
711 and self.parsed_event.data.sequence_start.anchor != NULL:
712 anchor = PyUnicode_FromYamlString(self.parsed_event.data.sequence_start.anchor)
713 elif self.parsed_event.type == YAML_MAPPING_START_EVENT \
714 and self.parsed_event.data.mapping_start.anchor != NULL:
715 anchor = PyUnicode_FromYamlString(self.parsed_event.data.mapping_start.anchor)
717 if anchor in self.anchors:
718 mark = Mark(self.stream_name,
719 self.parsed_event.start_mark.index,
720 self.parsed_event.start_mark.line,
721 self.parsed_event.start_mark.column,
724 self.anchors[anchor].start_mark, u"second occurrence", mark)
725 self.descend_resolver(parent, index)
726 if self.parsed_event.type == YAML_SCALAR_EVENT:
727 node = self._compose_scalar_node(anchor)
728 elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT:
729 node = self._compose_sequence_node(anchor)
730 elif self.parsed_event.type == YAML_MAPPING_START_EVENT:
731 node = self._compose_mapping_node(anchor)
732 self.ascend_resolver()
735 cdef _compose_scalar_node(self, object anchor):
736 start_mark = Mark(self.stream_name,
737 self.parsed_event.start_mark.index,
738 self.parsed_event.start_mark.line,
739 self.parsed_event.start_mark.column,
741 end_mark = Mark(self.stream_name,
742 self.parsed_event.end_mark.index,
743 self.parsed_event.end_mark.line,
744 self.parsed_event.end_mark.column,
746 value = PyUnicode_DecodeUTF8(<char *>self.parsed_event.data.scalar.value,
747 self.parsed_event.data.scalar.length, 'strict')
749 if self.parsed_event.data.scalar.plain_implicit == 1:
752 if self.parsed_event.data.scalar.quoted_implicit == 1:
754 if self.parsed_event.data.scalar.tag == NULL \
755 or (self.parsed_event.data.scalar.tag[0] == c'!'
756 and self.parsed_event.data.scalar.tag[1] == c'\0'):
757 tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit))
759 tag = PyUnicode_FromYamlString(self.parsed_event.data.scalar.tag)
761 if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
763 elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:
765 elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:
767 elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:
769 elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
773 self.anchors[anchor] = node
774 yaml_event_delete(&self.parsed_event)
777 cdef _compose_sequence_node(self, object anchor):
779 start_mark = Mark(self.stream_name,
780 self.parsed_event.start_mark.index,
781 self.parsed_event.start_mark.line,
782 self.parsed_event.start_mark.column,
785 if self.parsed_event.data.sequence_start.implicit == 1:
787 if self.parsed_event.data.sequence_start.tag == NULL \
788 or (self.parsed_event.data.sequence_start.tag[0] == c'!'
789 and self.parsed_event.data.sequence_start.tag[1] == c'\0'):
790 tag = self.resolve(SequenceNode, None, implicit)
792 tag = PyUnicode_FromYamlString(self.parsed_event.data.sequence_start.tag)
794 if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE:
796 elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE:
801 self.anchors[anchor] = node
802 yaml_event_delete(&self.parsed_event)
804 self._parse_next_event()
805 while self.parsed_event.type != YAML_SEQUENCE_END_EVENT:
806 value.append(self._compose_node(node, index))
808 self._parse_next_event()
809 node.end_mark = Mark(self.stream_name,
810 self.parsed_event.end_mark.index,
811 self.parsed_event.end_mark.line,
812 self.parsed_event.end_mark.column,
814 yaml_event_delete(&self.parsed_event)
817 cdef _compose_mapping_node(self, object anchor):
818 start_mark = Mark(self.stream_name,
819 self.parsed_event.start_mark.index,
820 self.parsed_event.start_mark.line,
821 self.parsed_event.start_mark.column,
824 if self.parsed_event.data.mapping_start.implicit == 1:
826 if self.parsed_event.data.mapping_start.tag == NULL \
827 or (self.parsed_event.data.mapping_start.tag[0] == c'!'
828 and self.parsed_event.data.mapping_start.tag[1] == c'\0'):
829 tag = self.resolve(MappingNode, None, implicit)
831 tag = PyUnicode_FromYamlString(self.parsed_event.data.mapping_start.tag)
833 if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE:
835 elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE:
840 self.anchors[anchor] = node
841 yaml_event_delete(&self.parsed_event)
842 self._parse_next_event()
843 while self.parsed_event.type != YAML_MAPPING_END_EVENT:
844 item_key = self._compose_node(node, None)
845 item_value = self._compose_node(node, item_key)
847 self._parse_next_event()
848 node.end_mark = Mark(self.stream_name,
849 self.parsed_event.end_mark.index,
850 self.parsed_event.end_mark.line,
851 self.parsed_event.end_mark.column,
853 yaml_event_delete(&self.parsed_event)
856 cdef int _parse_next_event(self) except 0:
857 if self.parsed_event.type == YAML_NO_EVENT:
858 if yaml_parser_parse(&self.parser, &self.parsed_event) == 0:
859 error = self._parser_error()
905 def __init__(self, stream, canonical=None, indent=None, width=None,
908 if yaml_emitter_initialize(&self.emitter) == 0:
910 self.stream = stream
911 self.dump_unicode = 0
913 self.dump_unicode = 1
914 self.use_encoding = encoding
915 yaml_emitter_set_output(&self.emitter, output_handler, <void *>self)
917 yaml_emitter_set_canonical(&self.emitter, 1)
919 yaml_emitter_set_indent(&self.emitter, indent)
921 yaml_emitter_set_width(&self.emitter, width)
923 yaml_emitter_set_unicode(&self.emitter, 1)
926 yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK)
928 yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK)
930 yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK)
931 self.document_start_implicit = 1
933 self.document_start_implicit = 0
934 self.document_end_implicit = 1
936 self.document_end_implicit = 0
937 self.use_version = version
938 self.use_tags = tags
939 self.serialized_nodes = {}
940 self.anchors = {}
941 self.last_alias_id = 0
942 self.closed = -1
944 def __dealloc__(self):
945 yaml_emitter_delete(&self.emitter)
947 def dispose(self):
950 cdef object _emitter_error(self):
951 if self.emitter.error == YAML_MEMORY_ERROR:
953 elif self.emitter.error == YAML_EMITTER_ERROR:
954 problem = PyUnicode_FromString(self.emitter.problem)
958 cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0:
983 self.dump_unicode = 1
984 if self.dump_unicode == 1:
1141 def emit(self, event_object):
1143 self._object_to_event(event_object, &event)
1144 if yaml_emitter_emit(&self.emitter, &event) == 0:
1145 error = self._emitter_error()
1148 def open(self):
1151 if self.closed == -1:
1152 if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le':
1154 elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be':
1158 if self.use_encoding is None:
1159 self.dump_unicode = 1
1160 if self.dump_unicode == 1:
1163 if yaml_emitter_emit(&self.emitter, &event) == 0:
1164 error = self._emitter_error()
1166 self.closed = 0
1167 elif self.closed == 1:
1172 def close(self):
1174 if self.closed == -1:
1176 elif self.closed == 0:
1178 if yaml_emitter_emit(&self.emitter, &event) == 0:
1179 error = self._emitter_error()
1181 self.closed = 1
1183 def serialize(self, node):
1190 if self.closed == -1:
1192 elif self.closed == 1:
1196 if self.use_version:
1197 version_directive_value.major = self.use_version[0]
1198 version_directive_value.minor = self.use_version[1]
1202 if self.use_tags:
1203 if len(self.use_tags) > 128:
1207 for handle in self.use_tags:
1208 prefix = self.use_tags[handle]
1224 self.document_start_implicit) == 0:
1226 if yaml_emitter_emit(&self.emitter, &event) == 0:
1227 error = self._emitter_error()
1229 self._anchor_node(node)
1230 self._serialize_node(node, None, None)
1231 yaml_document_end_event_initialize(&event, self.document_end_implicit)
1232 if yaml_emitter_emit(&self.emitter, &event) == 0:
1233 error = self._emitter_error()
1235 self.serialized_nodes = {}
1236 self.anchors = {}
1237 self.last_alias_id = 0
1239 cdef int _anchor_node(self, object node) except 0:
1240 if node in self.anchors:
1241 if self.anchors[node] is None:
1242 self.last_alias_id = self.last_alias_id+1
1243 self.anchors[node] = u"id%03d" % self.last_alias_id
1245 self.anchors[node] = None
1249 self._anchor_node(item)
1252 self._anchor_node(key)
1253 self._anchor_node(value)
1256 cdef int _serialize_node(self, object node, object parent, object index) except 0:
1269 anchor_object = self.anchors[node]
1277 if node in self.serialized_nodes:
1280 if yaml_emitter_emit(&self.emitter, &event) == 0:
1281 error = self._emitter_error()
1285 self.serialized_nodes[node] = True
1286 self.descend_resolver(parent, index)
1291 if self.resolve(ScalarNode, node.value, (True, False)) == tag_object:
1293 if self.resolve(ScalarNode, node.value, (False, True)) == tag_object:
1322 if yaml_emitter_emit(&self.emitter, &event) == 0:
1323 error = self._emitter_error()
1328 if self.resolve(SequenceNode, node.value, True) == tag_object:
1343 if yaml_emitter_emit(&self.emitter, &event) == 0:
1344 error = self._emitter_error()
1348 self._serialize_node(item, node, item_index)
1351 if yaml_emitter_emit(&self.emitter, &event) == 0:
1352 error = self._emitter_error()
1357 if self.resolve(MappingNode, node.value, True) == tag_object:
1372 if yaml_emitter_emit(&self.emitter, &event) == 0:
1373 error = self._emitter_error()
1376 self._serialize_node(item_key, node, None)
1377 self._serialize_node(item_value, node, item_key)
1379 if yaml_emitter_emit(&self.emitter, &event) == 0:
1380 error = self._emitter_error()
1382 self.ascend_resolver()