Navigation

← Previous Changeset
Next Changeset →

Changeset 223

Timestamp:

08/13/06 09:46:20 (2 years ago)

Author:

Message:

Completely rewrite the libyaml bindings.

Files:

pyyaml/trunk/ext/_yaml.pxd (modified) (9 diffs)
pyyaml/trunk/ext/_yaml.pyx (modified) (13 diffs)
pyyaml/trunk/lib/yaml/__init__.py (modified) (1 diff)
pyyaml/trunk/lib/yaml/composer.py (modified) (1 diff)
pyyaml/trunk/lib/yaml/cyaml.py (added)
pyyaml/trunk/lib/yaml/resolver.py (modified) (3 diffs)
pyyaml/trunk/tests/data/recursive-list.recursive (moved) (moved from pyyaml/trunk/tests/data/recurive-list.recursive)
pyyaml/trunk/tests/test_yaml_ext.py (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

pyyaml/trunk/ext/_yaml.pxd

r209	r223
2	2	cdef extern from "_yaml.h":
3	3
	4	void malloc(int l)
4	5	void memcpy(char d, char s, int l)
5	6	int strlen(char *s)
…	…
12	13	object PyUnicode_AsUTF8String(object o)
13	14
14		cdef enum yaml_encoding_t:
	15	ctypedef enum:
	16	SIZEOF_VOID_P
	17	ctypedef enum yaml_encoding_t:
15	18	YAML_ANY_ENCODING
16	19	YAML_UTF8_ENCODING
17	20	YAML_UTF16LE_ENCODING
18	21	YAML_UTF16BE_ENCODING
19		cdef enum yaml_error_type_t:
	22	ctypedef enum yaml_break_t:
	23	YAML_ANY_BREAK
	24	YAML_CR_BREAK
	25	YAML_LN_BREAK
	26	YAML_CRLN_BREAK
	27	ctypedef enum yaml_error_type_t:
20	28	YAML_NO_ERROR
21	29	YAML_MEMORY_ERROR
…	…
25	33	YAML_WRITER_ERROR
26	34	YAML_EMITTER_ERROR
27		cdef enum yaml_scalar_style_t:
	35	ctypedef enum yaml_scalar_style_t:
28	36	YAML_ANY_SCALAR_STYLE
29	37	YAML_PLAIN_SCALAR_STYLE
…	…
32	40	YAML_LITERAL_SCALAR_STYLE
33	41	YAML_FOLDED_SCALAR_STYLE
34		cdef enum yaml_sequence_style_t:
	42	ctypedef enum yaml_sequence_style_t:
35	43	YAML_ANY_SEQUENCE_STYLE
36	44	YAML_BLOCK_SEQUENCE_STYLE
37	45	YAML_FLOW_SEQUENCE_STYLE
38		cdef enum yaml_mapping_style_t:
	46	ctypedef enum yaml_mapping_style_t:
39	47	YAML_ANY_MAPPING_STYLE
40	48	YAML_BLOCK_MAPPING_STYLE
41	49	YAML_FLOW_MAPPING_STYLE
42		cdef enum yaml_token_type_t:
	50	ctypedef enum yaml_token_type_t:
43	51	YAML_NO_TOKEN
44	52	YAML_STREAM_START_TOKEN
…	…
63	71	YAML_TAG_TOKEN
64	72	YAML_SCALAR_TOKEN
65		cdef enum yaml_event_type_t:
	73	ctypedef enum yaml_event_type_t:
66	74	YAML_NO_EVENT
67	75	YAML_STREAM_START_EVENT
…	…
78	86	ctypedef int yaml_read_handler_t(void data, char buffer,
79	87	int size, int *size_read) except 0
	88
	89	ctypedef int yaml_write_handler_t(void data, char buffer,
	90	int size) except 0
80	91
81	92	ctypedef struct yaml_mark_t:
…	…
125	136	ctypedef struct _yaml_event_stream_start_data_t:
126	137	yaml_encoding_t encoding
	138	ctypedef struct _yaml_event_document_start_data_tag_directives_t:
	139	yaml_tag_directive_t *start
	140	yaml_tag_directive_t *end
127	141	ctypedef struct _yaml_event_document_start_data_t:
128	142	yaml_version_directive_t *version_directive
129		yaml_tag_directive_t **tag_directives
	143	_yaml_event_document_start_data_tag_directives_t tag_directives
130	144	int implicit
131	145	ctypedef struct _yaml_event_document_end_data_t:
…	…
174	188	yaml_mark_t context_mark
175	189
	190	ctypedef struct yaml_emitter_t:
	191	yaml_error_type_t error
	192	char *problem
	193
176	194	char *yaml_get_version_string()
177	195	void yaml_get_version(int major, int minor, int *patch)
	196
178	197	void yaml_token_delete(yaml_token_t *token)
	198
	199	int yaml_stream_start_event_initialize(yaml_event_t *event,
	200	yaml_encoding_t encoding)
	201	int yaml_stream_end_event_initialize(yaml_event_t *event)
	202	int yaml_document_start_event_initialize(yaml_event_t *event,
	203	yaml_version_directive_t *version_directive,
	204	yaml_tag_directive_t *tag_directives_start,
	205	yaml_tag_directive_t *tag_directives_end,
	206	int implicit)
	207	int yaml_document_end_event_initialize(yaml_event_t *event,
	208	int implicit)
	209	int yaml_alias_event_initialize(yaml_event_t event, char anchor)
	210	int yaml_scalar_event_initialize(yaml_event_t *event,
	211	char anchor, char tag, char *value, int length,
	212	int plain_implicit, int quoted_implicit,
	213	yaml_scalar_style_t style)
	214	int yaml_sequence_start_event_initialize(yaml_event_t *event,
	215	char anchor, char tag, int implicit, yaml_sequence_style_t style)
	216	int yaml_sequence_end_event_initialize(yaml_event_t *event)
	217	int yaml_mapping_start_event_initialize(yaml_event_t *event,
	218	char anchor, char tag, int implicit, yaml_mapping_style_t style)
	219	int yaml_mapping_end_event_initialize(yaml_event_t *event)
179	220	void yaml_event_delete(yaml_event_t *event)
	221
180	222	int yaml_parser_initialize(yaml_parser_t *parser)
181	223	void yaml_parser_delete(yaml_parser_t *parser)
…	…
189	231	int yaml_parser_parse(yaml_parser_t parser, yaml_event_t event) except *
190	232
	233	int yaml_emitter_initialize(yaml_emitter_t *emitter)
	234	void yaml_emitter_delete(yaml_emitter_t *emitter)
	235	void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
	236	char output, int size, int size_written)
	237	void yaml_emitter_set_output(yaml_emitter_t *emitter,
	238	yaml_write_handler_t handler, void data)
	239	void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
	240	yaml_encoding_t encoding)
	241	void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
	242	void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
	243	void yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
	244	void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
	245	void yaml_emitter_set_break(yaml_emitter_t *emitter,
	246	yaml_break_t line_break)
	247	int yaml_emitter_emit(yaml_emitter_t emitter, yaml_event_t event) except *
	248	int yaml_emitter_flush(yaml_emitter_t *emitter)
	249

pyyaml/trunk/ext/_yaml.pyx

r209	r223
10	10	return (major, minor, patch)
11	11
12		def test_scanner(stream):
	12	#Mark = yaml.error.Mark
	13	YAMLError = yaml.error.YAMLError
	14	ReaderError = yaml.reader.ReaderError
	15	ScannerError = yaml.scanner.ScannerError
	16	ParserError = yaml.parser.ParserError
	17	ComposerError = yaml.composer.ComposerError
	18	ConstructorError = yaml.constructor.ConstructorError
	19	EmitterError = yaml.emitter.EmitterError
	20	SerializerError = yaml.serializer.SerializerError
	21	RepresenterError = yaml.representer.RepresenterError
	22
	23	StreamStartToken = yaml.tokens.StreamStartToken
	24	StreamEndToken = yaml.tokens.StreamEndToken
	25	DirectiveToken = yaml.tokens.DirectiveToken
	26	DocumentStartToken = yaml.tokens.DocumentStartToken
	27	DocumentEndToken = yaml.tokens.DocumentEndToken
	28	BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken
	29	BlockMappingStartToken = yaml.tokens.BlockMappingStartToken
	30	BlockEndToken = yaml.tokens.BlockEndToken
	31	FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken
	32	FlowMappingStartToken = yaml.tokens.FlowMappingStartToken
	33	FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken
	34	FlowMappingEndToken = yaml.tokens.FlowMappingEndToken
	35	KeyToken = yaml.tokens.KeyToken
	36	ValueToken = yaml.tokens.ValueToken
	37	BlockEntryToken = yaml.tokens.BlockEntryToken
	38	FlowEntryToken = yaml.tokens.FlowEntryToken
	39	AliasToken = yaml.tokens.AliasToken
	40	AnchorToken = yaml.tokens.AnchorToken
	41	TagToken = yaml.tokens.TagToken
	42	ScalarToken = yaml.tokens.ScalarToken
	43
	44	StreamStartEvent = yaml.events.StreamStartEvent
	45	StreamEndEvent = yaml.events.StreamEndEvent
	46	DocumentStartEvent = yaml.events.DocumentStartEvent
	47	DocumentEndEvent = yaml.events.DocumentEndEvent
	48	AliasEvent = yaml.events.AliasEvent
	49	ScalarEvent = yaml.events.ScalarEvent
	50	SequenceStartEvent = yaml.events.SequenceStartEvent
	51	SequenceEndEvent = yaml.events.SequenceEndEvent
	52	MappingStartEvent = yaml.events.MappingStartEvent
	53	MappingEndEvent = yaml.events.MappingEndEvent
	54
	55	ScalarNode = yaml.nodes.ScalarNode
	56	SequenceNode = yaml.nodes.SequenceNode
	57	MappingNode = yaml.nodes.MappingNode
	58
	59	cdef class Mark:
	60	cdef readonly object name
	61	cdef readonly int index
	62	cdef readonly int line
	63	cdef readonly int column
	64	cdef readonly buffer
	65	cdef readonly pointer
	66
	67	def __init__(self, object name, int index, int line, int column,
	68	object buffer, object pointer):
	69	self.name = name
	70	self.index = index
	71	self.line = line
	72	self.column = column
	73	self.buffer = buffer
	74	self.pointer = pointer
	75
	76	def get_snippet(self):
	77	return None
	78
	79	def __str__(self):
	80	where = " in \"%s\", line %d, column %d" \
	81	% (self.name, self.line+1, self.column+1)
	82	return where
	83
	84	#class YAMLError(Exception):
	85	# pass
	86	#
	87	#class MarkedYAMLError(YAMLError):
	88	#
	89	# def __init__(self, context=None, context_mark=None,
	90	# problem=None, problem_mark=None, note=None):
	91	# self.context = context
	92	# self.context_mark = context_mark
	93	# self.problem = problem
	94	# self.problem_mark = problem_mark
	95	# self.note = note
	96	#
	97	# def __str__(self):
	98	# lines = []
	99	# if self.context is not None:
	100	# lines.append(self.context)
	101	# if self.context_mark is not None \
	102	# and (self.problem is None or self.problem_mark is None
	103	# or self.context_mark.name != self.problem_mark.name
	104	# or self.context_mark.line != self.problem_mark.line
	105	# or self.context_mark.column != self.problem_mark.column):
	106	# lines.append(str(self.context_mark))
	107	# if self.problem is not None:
	108	# lines.append(self.problem)
	109	# if self.problem_mark is not None:
	110	# lines.append(str(self.problem_mark))
	111	# if self.note is not None:
	112	# lines.append(self.note)
	113	# return '\n'.join(lines)
	114	#
	115	#class ReaderError(YAMLError):
	116	#
	117	# def __init__(self, name, position, character, encoding, reason):
	118	# self.name = name
	119	# self.character = character
	120	# self.position = position
	121	# self.encoding = encoding
	122	# self.reason = reason
	123	#
	124	# def __str__(self):
	125	# if isinstance(self.character, str):
	126	# return "'%s' codec can't decode byte #x%02x: %s\n" \
	127	# " in \"%s\", position %d" \
	128	# % (self.encoding, ord(self.character), self.reason,
	129	# self.name, self.position)
	130	# else:
	131	# return "unacceptable character #x%04x: %s\n" \
	132	# " in \"%s\", position %d" \
	133	# % (ord(self.character), self.reason,
	134	# self.name, self.position)
	135	#
	136	#class ScannerError(MarkedYAMLError):
	137	# pass
	138	#
	139	#class ParserError(MarkedYAMLError):
	140	# pass
	141	#
	142	#class EmitterError(YAMLError):
	143	# pass
	144	#
	145	#cdef class Token:
	146	# cdef readonly Mark start_mark
	147	# cdef readonly Mark end_mark
	148	# def __init__(self, Mark start_mark, Mark end_mark):
	149	# self.start_mark = start_mark
	150	# self.end_mark = end_mark
	151	#
	152	#cdef class StreamStartToken(Token):
	153	# cdef readonly object encoding
	154	# def __init__(self, Mark start_mark, Mark end_mark, encoding):
	155	# self.start_mark = start_mark
	156	# self.end_mark = end_mark
	157	# self.encoding = encoding
	158	#
	159	#cdef class StreamEndToken(Token):
	160	# pass
	161	#
	162	#cdef class DirectiveToken(Token):
	163	# cdef readonly object name
	164	# cdef readonly object value
	165	# def __init__(self, name, value, Mark start_mark, Mark end_mark):
	166	# self.name = name
	167	# self.value = value
	168	# self.start_mark = start_mark
	169	# self.end_mark = end_mark
	170	#
	171	#cdef class DocumentStartToken(Token):
	172	# pass
	173	#
	174	#cdef class DocumentEndToken(Token):
	175	# pass
	176	#
	177	#cdef class BlockSequenceStartToken(Token):
	178	# pass
	179	#
	180	#cdef class BlockMappingStartToken(Token):
	181	# pass
	182	#
	183	#cdef class BlockEndToken(Token):
	184	# pass
	185	#
	186	#cdef class FlowSequenceStartToken(Token):
	187	# pass
	188	#
	189	#cdef class FlowMappingStartToken(Token):
	190	# pass
	191	#
	192	#cdef class FlowSequenceEndToken(Token):
	193	# pass
	194	#
	195	#cdef class FlowMappingEndToken(Token):
	196	# pass
	197	#
	198	#cdef class KeyToken(Token):
	199	# pass
	200	#
	201	#cdef class ValueToken(Token):
	202	# pass
	203	#
	204	#cdef class BlockEntryToken(Token):
	205	# pass
	206	#
	207	#cdef class FlowEntryToken(Token):
	208	# pass
	209	#
	210	#cdef class AliasToken(Token):
	211	# cdef readonly object value
	212	# def __init__(self, value, Mark start_mark, Mark end_mark):
	213	# self.value = value
	214	# self.start_mark = start_mark
	215	# self.end_mark = end_mark
	216	#
	217	#cdef class AnchorToken(Token):
	218	# cdef readonly object value
	219	# def __init__(self, value, Mark start_mark, Mark end_mark):
	220	# self.value = value
	221	# self.start_mark = start_mark
	222	# self.end_mark = end_mark
	223	#
	224	#cdef class TagToken(Token):
	225	# cdef readonly object value
	226	# def __init__(self, value, Mark start_mark, Mark end_mark):
	227	# self.value = value
	228	# self.start_mark = start_mark
	229	# self.end_mark = end_mark
	230	#
	231	#cdef class ScalarToken(Token):
	232	# cdef readonly object value
	233	# cdef readonly object plain
	234	# cdef readonly object style
	235	# def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None):
	236	# self.value = value
	237	# self.plain = plain
	238	# self.start_mark = start_mark
	239	# self.end_mark = end_mark
	240	# self.style = style
	241
	242	cdef class CParser:
	243
13	244	cdef yaml_parser_t parser
14		cdef yaml_token_t token
15		cdef int done
16		cdef int count
17		if hasattr(stream, 'read'):
18		stream = stream.read()
19		if PyUnicode_CheckExact(stream) != 0:
20		stream = stream.encode('utf-8')
21		if PyString_CheckExact(stream) == 0:
22		raise TypeError("a string or stream input is required")
23		if yaml_parser_initialize(&parser) == 0:
24		raise RuntimeError("cannot initialize parser")
25		yaml_parser_set_input_string(&parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream))
26		done = 0
27		count = 0
28		while done == 0:
29		if yaml_parser_scan(&parser, &token) == 0:
30		raise RuntimeError("cannot get next token: #%s" % count)
31		if token.type == YAML_NO_TOKEN:
32		done = 1
33		else:
34		count = count+1
35		yaml_token_delete(&token)
36		yaml_parser_delete(&parser)
37		dummy = len(stream)
38		return count
39
40		def test_parser(stream):
41		cdef yaml_parser_t parser
42		cdef yaml_event_t event
43		cdef int done
44		cdef int count
45		if hasattr(stream, 'read'):
46		stream = stream.read()
47		if PyUnicode_CheckExact(stream) != 0:
48		stream = stream.encode('utf-8')
49		if PyString_CheckExact(stream) == 0:
50		raise TypeError("a string or stream input is required")
51		if yaml_parser_initialize(&parser) == 0:
52		raise RuntimeError("cannot initialize parser")
53		yaml_parser_set_input_string(&parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream))
54		done = 0
55		count = 0
56		while done == 0:
57		if yaml_parser_parse(&parser, &event) == 0:
58		raise RuntimeError("cannot get next event: #%s" % count)
59		if event.type == YAML_NO_EVENT:
60		done = 1
61		else:
62		count = count+1
63		yaml_event_delete(&event)
64		yaml_parser_delete(&parser)
65		dummy = len(stream)
66		return count
67
68		cdef class ScannerAndParser:
69
70		cdef yaml_parser_t parser
	245	cdef yaml_event_t parsed_event
71	246
72	247	cdef object stream
	248	cdef object stream_name
73	249	cdef object current_token
74	250	cdef object current_event
75
76		cdef object cached_input
77		cdef object cached_YAML
78		cdef object cached_TAG
79		cdef object cached_question
80		cdef object cached_Mark
81		cdef object cached_ReaderError
82		cdef object cached_ScannerError
83		cdef object cached_ParserError
84		cdef object cached_StreamStartToken
85		cdef object cached_StreamEndToken
86		cdef object cached_DirectiveToken
87		cdef object cached_DocumentStartToken
88		cdef object cached_DocumentEndToken
89		cdef object cached_BlockSequenceStartToken
90		cdef object cached_BlockMappingStartToken
91		cdef object cached_BlockEndToken
92		cdef object cached_FlowSequenceStartToken
93		cdef object cached_FlowMappingStartToken
94		cdef object cached_FlowSequenceEndToken
95		cdef object cached_FlowMappingEndToken
96		cdef object cached_BlockEntryToken
97		cdef object cached_FlowEntryToken
98		cdef object cached_KeyToken
99		cdef object cached_ValueToken
100		cdef object cached_AliasToken
101		cdef object cached_AnchorToken
102		cdef object cached_TagToken
103		cdef object cached_ScalarToken
104		cdef object cached_StreamStartEvent
105		cdef object cached_StreamEndEvent
106		cdef object cached_DocumentStartEvent
107		cdef object cached_DocumentEndEvent
108		cdef object cached_AliasEvent
109		cdef object cached_SequenceStartEvent
110		cdef object cached_SequenceEndEvent
111		cdef object cached_MappingStartEvent
112		cdef object cached_MappingEndEvent
	251	cdef object anchors
113	252
114	253	def __init__(self, stream):
115	254	if yaml_parser_initialize(&self.parser) == 0:
116	255	raise MemoryError
	256	self.parsed_event.type = YAML_NO_EVENT
117	257	if hasattr(stream, 'read'):
118	258	self.stream = stream
	259	try:
	260	self.stream_name = stream.name
	261	except AttributeError:
	262	self.stream_name = '<file>'
119	263	yaml_parser_set_input(&self.parser, input_handler, <void *>self)
120	264	else:
121	265	if PyUnicode_CheckExact(stream) != 0:
122	266	stream = PyUnicode_AsUTF8String(stream)
	267	self.stream_name = '<unicode string>'
	268	else:
	269	self.stream_name = '<string>'
123	270	if PyString_CheckExact(stream) == 0:
124	271	raise TypeError("a string or stream input is required")
…	…
126	273	yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream))
127	274	self.current_token = None
128		self._cache_names()
129
130		def get_token(self):
131		if self.current_token is not None:
132		value = self.current_token
133		self.current_token = None
134		else:
135		value = self._scan()
136		return value
137
138		def peek_token(self):
139		if self.current_token is None:
140		self.current_token = self._scan()
141		return self.current_token
142
143		def check_token(self, *choices):
144		if self.current_token is None:
145		self.current_token = self._scan()
146		if self.current_token is None:
147		return False
148		if not choices:
149		return True
150		token_class = self.current_token.__class__
151		for choice in choices:
152		if token_class is choice:
153		return True
154		return False
155
156		def get_event(self):
157		if self.current_event is not None:
158		value = self.current_event
159		self.current_event = None
160		else:
161		value = self._parse()
162		return value
163
164		def peek_event(self):
165		if self.current_event is None:
166		self.current_event = self._parse()
167		return self.current_event
168
169		def check_event(self, *choices):
170		if self.current_event is None:
171		self.current_event = self._parse()
172		if self.current_event is None:
173		return False
174		if not choices:
175		return True
176		event_class = self.current_event.__class__
177		for choice in choices:
178		if event_class is choice:
179		return True
180		return False
	275	self.current_event = None
	276	self.anchors = {}
181	277
182	278	def __dealloc__(self):
183	279	yaml_parser_delete(&self.parser)
184
185		cdef object _cache_names(self):
186		self.cached_input = '<input>'
187		self.cached_YAML = 'YAML'
188		self.cached_TAG = 'TAG'
189		self.cached_question = '?'
190		self.cached_Mark = yaml.Mark
191		self.cached_ReaderError = yaml.reader.ReaderError
192		self.cached_ScannerError = yaml.scanner.ScannerError
193		self.cached_ParserError = yaml.parser.ParserError
194		self.cached_StreamStartToken = yaml.StreamStartToken
195		self.cached_StreamEndToken = yaml.StreamEndToken
196		self.cached_DirectiveToken = yaml.DirectiveToken
197		self.cached_DocumentStartToken = yaml.DocumentStartToken
198		self.cached_DocumentEndToken = yaml.DocumentEndToken
199		self.cached_BlockSequenceStartToken = yaml.BlockSequenceStartToken
200		self.cached_BlockMappingStartToken = yaml.BlockMappingStartToken
201		self.cached_BlockEndToken = yaml.BlockEndToken
202		self.cached_FlowSequenceStartToken = yaml.FlowSequenceStartToken
203		self.cached_FlowMappingStartToken = yaml.FlowMappingStartToken
204		self.cached_FlowSequenceEndToken = yaml.FlowSequenceEndToken
205		self.cached_FlowMappingEndToken = yaml.FlowMappingEndToken
206		self.cached_BlockEntryToken = yaml.BlockEntryToken
207		self.cached_FlowEntryToken = yaml.FlowEntryToken
208		self.cached_KeyToken = yaml.KeyToken
209		self.cached_ValueToken = yaml.ValueToken
210		self.cached_AliasToken = yaml.AliasToken
211		self.cached_AnchorToken = yaml.AnchorToken
212		self.cached_TagToken = yaml.TagToken
213		self.cached_ScalarToken = yaml.ScalarToken
214		self.cached_StreamStartEvent = yaml.StreamStartEvent
215		self.cached_StreamEndEvent = yaml.StreamEndEvent
216		self.cached_DocumentStartEvent = yaml.DocumentStartEvent
217		self.cached_DocumentEndEvent = yaml.DocumentEndEvent
218		self.cached_AliasEvent = yaml.AliasEvent
219		self.cached_ScalarEvent = yaml.ScalarEvent
220		self.cached_SequenceStartEvent = yaml.SequenceStartEvent
221		self.cached_SequenceEndEvent = yaml.SequenceEndEvent
222		self.cached_MappingStartEvent = yaml.MappingStartEvent
223		self.cached_MappingEndEvent = yaml.MappingEndEvent
	280	yaml_event_delete(&self.parsed_event)
	281
	282	cdef object _parser_error(self):
	283	if self.parser.error == YAML_MEMORY_ERROR:
	284	raise MemoryError
	285	elif self.parser.error == YAML_READER_ERROR:
	286	raise ReaderError(self.stream_name, self.parser.problem_offset,
	287	self.parser.problem_value, '?', self.parser.problem)
	288	elif self.parser.error == YAML_SCANNER_ERROR \
	289	or self.parser.error == YAML_PARSER_ERROR:
	290	context_mark = None
	291	problem_mark = None
	292	if self.parser.context != NULL:
	293	context_mark = Mark(self.stream_name,
	294	self.parser.context_mark.index,
	295	self.parser.context_mark.line,
	296	self.parser.context_mark.column, None, None)
	297	if self.parser.problem != NULL:
	298	problem_mark = Mark(self.stream_name,
	299	self.parser.problem_mark.index,
	300	self.parser.problem_mark.line,
	301	self.parser.problem_mark.column, None, None)
	302	if self.parser.error == YAML_SCANNER_ERROR:
	303	if self.parser.context != NULL:
	304	return ScannerError(self.parser.context, context_mark,
	305	self.parser.problem, problem_mark)
	306	else:
	307	return ScannerError(None, None,
	308	self.parser.problem, problem_mark)
	309	else:
	310	if self.parser.context != NULL:
	311	return ParserError(self.parser.context, context_mark,
	312	self.parser.problem, problem_mark)
	313	else:
	314	return ParserError(None, None,
	315	self.parser.problem, problem_mark)
	316	raise ValueError("no parser error")
	317
	318	def raw_scan(self):
	319	cdef yaml_token_t token
	320	cdef int done
	321	cdef int count
	322	count = 0
	323	done = 0
	324	while done == 0:
	325	if yaml_parser_scan(&self.parser, &token) == 0:
	326	error = self._parser_error()
	327	raise error
	328	if token.type == YAML_NO_TOKEN:
	329	done = 1
	330	else:
	331	count = count+1
	332	yaml_token_delete(&token)
	333	return count
224	334
225	335	cdef object _scan(self):
226	336	cdef yaml_token_t token
227	337	if yaml_parser_scan(&self.parser, &token) == 0:
228		if self.parser.error == YAML_MEMORY_ERROR:
229		raise MemoryError
230		elif self.parser.error == YAML_READER_ERROR:
231		raise self.cached_ReaderError(self.cached_input,
232		self.parser.problem_offset,
233		self.parser.problem_value,
234		self.cached_question, self.parser.problem)
235		elif self.parser.error == YAML_SCANNER_ERROR:
236		context_mark = None
237		problem_mark = None
238		if self.parser.context != NULL:
239		context_mark = self.cached_Mark(self.cached_input,
240		self.parser.context_mark.index,
241		self.parser.context_mark.line,
242		self.parser.context_mark.column,
243		None, None)
244		if self.parser.problem != NULL:
245		problem_mark = self.cached_Mark(self.cached_input,
246		self.parser.problem_mark.index,
247		self.parser.problem_mark.line,
248		self.parser.problem_mark.column,
249		None, None)
250		if self.parser.context != NULL:
251		raise self.cached_ScannerError(
252		self.parser.context, context_mark,
253		self.parser.problem, problem_mark)
254		else:
255		raise yaml.scanner.ScannerError(None, None,
256		self.parser.problem, problem_mark)
257		start_mark = yaml.Mark(self.cached_input,
	338	error = self._parser_error()
	339	raise error
	340	token_object = self._token_to_object(&token)
	341	yaml_token_delete(&token)
	342	return token_object
	343
	344	cdef object _token_to_object(self, yaml_token_t *token):
	345	start_mark = Mark(self.stream_name,
258	346	token.start_mark.index,
259	347	token.start_mark.line,
260	348	token.start_mark.column,
261	349	None, None)
262		end_mark = ~~yaml.Mark(self.cached_input~~,
	350	end_mark = Mark(self.stream_name,
263	351	token.end_mark.index,
264	352	token.end_mark.line,
…	…
268	356	return None
269	357	elif token.type == YAML_STREAM_START_TOKEN:
270		return self.cached_StreamStartToken(start_mark, end_mark)
	358	encoding = None
	359	if token.data.stream_start.encoding == YAML_UTF8_ENCODING:
	360	encoding = "utf-8"
	361	elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING:
	362	encoding = "utf-16-le"
	363	elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING:
	364	encoding = "utf-16-be"
	365	return StreamStartToken(start_mark, end_mark, encoding)
271	366	elif token.type == YAML_STREAM_END_TOKEN:
272		return ~~self.cached_~~StreamEndToken(start_mark, end_mark)
	367	return StreamEndToken(start_mark, end_mark)
273	368	elif token.type == YAML_VERSION_DIRECTIVE_TOKEN:
274		return ~~self.cached_DirectiveToken(self.cached_YAML~~,
	369	return DirectiveToken("YAML",
275	370	(token.data.version_directive.major,
276	371	token.data.version_directive.minor),
277	372	start_mark, end_mark)
278	373	elif token.type == YAML_TAG_DIRECTIVE_TOKEN:
279		return ~~self.cached_DirectiveToken(self.cached_TAG~~,
	374	return DirectiveToken("TAG",
280	375	(token.data.tag_directive.handle,
281	376	token.data.tag_directive.prefix),
282	377	start_mark, end_mark)
283	378	elif token.type == YAML_DOCUMENT_START_TOKEN:
284		return ~~self.cached_~~DocumentStartToken(start_mark, end_mark)
	379	return DocumentStartToken(start_mark, end_mark)
285	380	elif token.type == YAML_DOCUMENT_END_TOKEN:
286		return ~~self.cached_~~DocumentEndToken(start_mark, end_mark)
	381	return DocumentEndToken(start_mark, end_mark)
287	382	elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN:
288		return ~~self.cached_~~BlockSequenceStartToken(start_mark, end_mark)
	383	return BlockSequenceStartToken(start_mark, end_mark)
289	384	elif token.type == YAML_BLOCK_MAPPING_START_TOKEN:
290		return ~~self.cached_~~BlockMappingStartToken(start_mark, end_mark)
	385	return BlockMappingStartToken(start_mark, end_mark)
291	386	elif token.type == YAML_BLOCK_END_TOKEN:
292		return ~~self.cached_~~BlockEndToken(start_mark, end_mark)
	387	return BlockEndToken(start_mark, end_mark)
293	388	elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN:
294		return ~~self.cached_~~FlowSequenceStartToken(start_mark, end_mark)
	389	return FlowSequenceStartToken(start_mark, end_mark)
295	390	elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN:
296		return ~~self.cached_~~FlowSequenceEndToken(start_mark, end_mark)
	391	return FlowSequenceEndToken(start_mark, end_mark)
297	392	elif token.type == YAML_FLOW_MAPPING_START_TOKEN:
298		return ~~self.cached_~~FlowMappingStartToken(start_mark, end_mark)
	393	return FlowMappingStartToken(start_mark, end_mark)
299	394	elif token.type == YAML_FLOW_MAPPING_END_TOKEN:
300		return ~~self.cached_~~FlowMappingEndToken(start_mark, end_mark)
	395	return FlowMappingEndToken(start_mark, end_mark)
301	396	elif token.type == YAML_BLOCK_ENTRY_TOKEN:
302		return ~~self.cached_~~BlockEntryToken(start_mark, end_mark)
	397	return BlockEntryToken(start_mark, end_mark)
303	398	elif token.type == YAML_FLOW_ENTRY_TOKEN:
304		return ~~self.cached_~~FlowEntryToken(start_mark, end_mark)
	399	return FlowEntryToken(start_mark, end_mark)
305	400	elif token.type == YAML_KEY_TOKEN:
306		return ~~self.cached_~~KeyToken(start_mark, end_mark)
	401	return KeyToken(start_mark, end_mark)
307	402	elif token.type == YAML_VALUE_TOKEN:
308		return ~~self.cached_~~ValueToken(start_mark, end_mark)
	403	return ValueToken(start_mark, end_mark)
309	404	elif token.type == YAML_ALIAS_TOKEN:
310	405	value = PyUnicode_DecodeUTF8(token.data.alias.value,
311	406	strlen(token.data.alias.value), 'strict')
312		return ~~self.cached_~~AliasToken(value, start_mark, end_mark)
	407	return AliasToken(value, start_mark, end_mark)
313	408	elif token.type == YAML_ANCHOR_TOKEN:
314	409	value = PyUnicode_DecodeUTF8(token.data.anchor.value,
315	410	strlen(token.data.anchor.value), 'strict')
316		return ~~self.cached_~~AnchorToken(value, start_mark, end_mark)
	411	return AnchorToken(value, start_mark, end_mark)
317	412	elif token.type == YAML_TAG_TOKEN:
318	413	handle = PyUnicode_DecodeUTF8(token.data.tag.handle,
…	…
322	417	if not handle:
323	418	handle = None
324		return ~~self.cached_~~TagToken((handle, suffix), start_mark, end_mark)
	419	return TagToken((handle, suffix), start_mark, end_mark)
325	420	elif token.type == YAML_SCALAR_TOKEN:
326	421	value = PyUnicode_DecodeUTF8(token.data.scalar.value,
…	…
339	434	elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
340	435	style = '>'
341		return ~~self.cached_~~ScalarToken(value, plain,
	436	return ScalarToken(value, plain,
342	437	start_mark, end_mark, style)
343	438	else:
344		raise RuntimeError("unknown token type")
	439	raise ValueError("unknown token type")
	440
	441	def get_token(self):
	442	if self.current_token is not None:
	443	value = self.current_token
	444	self.current_token = None
	445	else:
	446	value = self._scan()
	447	return value
	448
	449	def peek_token(self):
	450	if self.current_token is None:
	451	self.current_token = self._scan()
	452	return self.current_token
	453
	454	def check_token(self, *choices):
	455	if self.current_token is None:
	456	self.current_token = self._scan()
	457	if self.current_token is None:
	458	return False
	459	if not choices:
	460	return True
	461	token_class = self.current_token.__class__
	462	for choice in choices:
	463	if token_class is choice:
	464	return True
	465	return False
	466
	467	def raw_parse(self):
	468	cdef yaml_event_t event
	469	cdef int done
	470	cdef int count
	471	count = 0
	472	done = 0
	473	while done == 0:
	474	if yaml_parser_parse(&self.parser, &event) == 0:
	475	error = self._parser_error()
	476	raise error
	477	if event.type == YAML_NO_EVENT:
	478	done = 1
	479	else:
	480	count = count+1
	481	yaml_event_delete(&event)
	482	return count
345	483
346	484	cdef object _parse(self):
347	485	cdef yaml_event_t event
348	486	if yaml_parser_parse(&self.parser, &event) == 0:
349		if self.parser.error == YAML_MEMORY_ERROR:
350		raise MemoryError
351		elif self.parser.error == YAML_READER_ERROR:
352		raise self.cached_ReaderError(self.cached_input,
353		self.parser.problem_offset,
354		self.parser.problem_value,
355		self.cached_question, self.parser.problem)
356		elif self.parser.error == YAML_SCANNER_ERROR \
357		or self.parser.error == YAML_PARSER_ERROR:
358		context_mark = None
359		problem_mark = None
360		if self.parser.context != NULL:
361		context_mark = self.cached_Mark(self.cached_input,
362		self.parser.context_mark.index,
363		self.parser.context_mark.line,
364		self.parser.context_mark.column,
365		None, None)
366		if self.parser.problem != NULL:
367		problem_mark = self.cached_Mark(self.cached_input,
368		self.parser.problem_mark.index,
369		self.parser.problem_mark.line,
370		self.parser.problem_mark.column,
371		None, None)
372		if self.parser.error == YAML_SCANNER_ERROR:
373		if self.parser.context != NULL:
374		raise self.cached_ScannerError(
375		self.parser.context, context_mark,
376		self.parser.problem, problem_mark)
377		else:
378		raise self.cached_ScannerError(None, None,
379		self.parser.problem, problem_mark)
380		else:
381		if self.parser.context != NULL:
382		raise self.cached_ParserError(
383		self.parser.context, context_mark,
384		self.parser.problem, problem_mark)
385		else:
386		raise self.cached_ParserError(None, None,
387		self.parser.problem, problem_mark)
388		start_mark = yaml.Mark(self.cached_input,
	487	error = self._parser_error()
	488	raise error
	489	event_object = self._event_to_object(&event)
	490	yaml_event_delete(&event)
	491	return event_object
	492
	493	cdef object _event_to_object(self, yaml_event_t *event):
	494	cdef yaml_tag_directive_t *tag_directive
	495	start_mark = Mark(self.stream_name,
389	496	event.start_mark.index,
390	497	event.start_mark.line,
391	498	event.start_mark.column,
392	499	None, None)
393		end_mark = ~~yaml.Mark(self.cached_input~~,
	500	end_mark = Mark(self.stream_name,
394	501	event.end_mark.index,
395	502	event.end_mark.line,
…	…
399	506	return None
400	507	elif event.type == YAML_STREAM_START_EVENT:
401		return self.cached_StreamStartEvent(start_mark, end_mark)
	508	encoding = None
	509	if event.data.stream_start.encoding == YAML_UTF8_ENCODING:
	510	encoding = "utf-8"
	511	elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING:
	512	encoding = "utf-16-le"
	513	elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING:
	514	encoding = "utf-16-be"
	515	return StreamStartEvent(start_mark, end_mark, encoding)
402	516	elif event.type == YAML_STREAM_END_EVENT:
403		return self.cached_StreamEndEvent(start_mark, end_mark)
	517	return StreamEndEvent(start_mark, end_mark)
	518
404	519	elif event.type == YAML_DOCUMENT_START_EVENT:
405		return self.cached_DocumentStartEvent(start_mark, end_mark)
	520	explicit = False
	521	if event.data.document_start.implicit == 0:
	522	explicit = True
	523	version = None
	524	if event.data.document_start.version_directive != NULL:
	525	version = (event.data.document_start.version_directive.major,
	526	event.data.document_start.version_directive.minor)
	527	tags = None
	528	if event.data.document_start.tag_directives.start != NULL:
	529	tags = {}
	530	tag_directive = event.data.document_start.tag_directives.start
	531	while tag_directive != event.data.document_start.tag_directives.end:
	532	handle = PyUnicode_DecodeUTF8(tag_directive.handle,
	533	strlen(tag_directive.handle), 'strict')
	534	prefix = PyUnicode_DecodeUTF8(tag_directive.prefix,
	535	strlen(tag_directive.prefix), 'strict')
	536	tags[handle] = prefix
	537	tag_directive = tag_directive+1
	538	return DocumentStartEvent(start_mark, end_mark,
	539	explicit, version, tags)
406	540	elif event.type == YAML_DOCUMENT_END_EVENT:
407		return self.cached_DocumentEndEvent(start_mark, end_mark)
	541	explicit = False
	542	if event.data.document_end.implicit == 0:
	543	explicit = True
	544	return DocumentEndEvent(start_mark, end_mark, explicit)
408	545	elif event.type == YAML_ALIAS_EVENT:
409	546	anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor,
410	547	strlen(event.data.alias.anchor), 'strict')
411		return ~~self.cached_~~AliasEvent(anchor, start_mark, end_mark)
	548	return AliasEvent(anchor, start_mark, end_mark)
412	549	elif event.type == YAML_SCALAR_EVENT:
413	550	anchor = None
…	…
421	558	value = PyUnicode_DecodeUTF8(event.data.scalar.value,
422	559