Context Navigation

← Previous Change
Next Change →

Changeset 223 for pyyaml/trunk

Timestamp:

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

Author:

Message:

Completely rewrite the libyaml bindings.

Location:

pyyaml/trunk

Files:

: 1 added
: 6 modified
: 1 moved

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

Legend:

: Unmodified
: Added
: Removed

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	event.data.scalar.length, 'strict')
423		plain_implicit = (event.data.scalar.plain_implicit == 1)
424		quoted_implicit = (event.data.scalar.quoted_implicit == 1)
	560	plain_implicit = False
	561	if event.data.scalar.plain_implicit == 1:
	562	plain_implicit = True
	563	quoted_implicit = False
	564	if event.data.scalar.quoted_implicit == 1:
	565	quoted_implicit = True
425	566	style = None
426	567	if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
…	…
434	575	elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
435	576	style = '>'
436		return ~~self.cached_~~ScalarEvent(anchor, tag,
	577	return ScalarEvent(anchor, tag,
437	578	(plain_implicit, quoted_implicit),
438	579	value, start_mark, end_mark, style)
…	…
446	587	tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag,
447	588	strlen(event.data.sequence_start.tag), 'strict')
448		implicit = (event.data.sequence_start.implicit == 1)
	589	implicit = False
	590	if event.data.sequence_start.implicit == 1:
	591	implicit = True
449	592	flow_style = None
450	593	if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE:
…	…
452	595	elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE:
453	596	flow_style = False
454		return ~~self.cached_~~SequenceStartEvent(anchor, tag, implicit,
	597	return SequenceStartEvent(anchor, tag, implicit,
455	598	start_mark, end_mark, flow_style)
456	599	elif event.type == YAML_MAPPING_START_EVENT:
…	…
463	606	tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag,
464	607	strlen(event.data.mapping_start.tag), 'strict')
465		implicit = (event.data.mapping_start.implicit == 1)
	608	implicit = False
	609	if event.data.mapping_start.implicit == 1:
	610	implicit = True
466	611	flow_style = None
467	612	if event.data.mapping_start.style == YAML_FLOW_SEQUENCE_STYLE:
…	…
469	614	elif event.data.mapping_start.style == YAML_BLOCK_SEQUENCE_STYLE:
470	615	flow_style = False
471		return ~~self.cached_~~MappingStartEvent(anchor, tag, implicit,
	616	return MappingStartEvent(anchor, tag, implicit,
472	617	start_mark, end_mark, flow_style)
473	618	elif event.type == YAML_SEQUENCE_END_EVENT:
474		return ~~self.cached_~~SequenceEndEvent(start_mark, end_mark)
	619	return SequenceEndEvent(start_mark, end_mark)
475	620	elif event.type == YAML_MAPPING_END_EVENT:
476		return self.cached_MappingEndEvent(start_mark, end_mark)
	621	return MappingEndEvent(start_mark, end_mark)
	622
477	623	else:
478		raise RuntimeError("unknown event type")
	624	raise ValueError("unknown token type")
	625
	626	def get_event(self):
	627	if self.current_event is not None:
	628	value = self.current_event
	629	self.current_event = None
	630	else:
	631	value = self._parse()
	632	return value
	633
	634	def peek_event(self):
	635	if self.current_event is None:
	636	self.current_event = self._parse()
	637	return self.current_event
	638
	639	def check_event(self, *choices):
	640	if self.current_event is None:
	641	self.current_event = self._parse()
	642	if self.current_event is None:
	643	return False
	644	if not choices:
	645	return True
	646	event_class = self.current_event.__class__
	647	for choice in choices:
	648	if event_class is choice:
	649	return True
	650	return False
	651
	652	def check_node(self):
	653	self._parse_next_event()
	654	if self.parsed_event.type != YAML_STREAM_END_EVENT:
	655	return True
	656	return False
	657
	658	def get_node(self):
	659	self._parse_next_event()
	660	if self.parsed_event.type != YAML_STREAM_END_EVENT:
	661	return self._compose_document()
	662
	663	cdef object _compose_document(self):
	664	if self.parsed_event.type == YAML_STREAM_START_EVENT:
	665	yaml_event_delete(&self.parsed_event)
	666	self._parse_next_event()
	667	yaml_event_delete(&self.parsed_event)
	668	node = self._compose_node(None, None)
	669	self._parse_next_event()
	670	yaml_event_delete(&self.parsed_event)
	671	self.anchors = {}
	672	return node
	673
	674	cdef object _compose_node(self, object parent, object index):
	675	self._parse_next_event()
	676	if self.parsed_event.type == YAML_ALIAS_EVENT:
	677	anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.alias.anchor,
	678	strlen(self.parsed_event.data.alias.anchor), 'strict')
	679	if anchor not in self.anchors:
	680	mark = Mark(self.stream_name,
	681	self.parsed_event.start_mark.index,
	682	self.parsed_event.start_mark.line,
	683	self.parsed_event.start_mark.column,
	684	None, None)
	685	raise ComposerError(None, None, "found undefined alias", mark)
	686	yaml_event_delete(&self.parsed_event)
	687	return self.anchors[anchor]
	688	anchor = None
	689	if self.parsed_event.type == YAML_SCALAR_EVENT \
	690	and self.parsed_event.data.scalar.anchor != NULL:
	691	anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.anchor,
	692	strlen(self.parsed_event.data.scalar.anchor), 'strict')
	693	elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \
	694	and self.parsed_event.data.sequence_start.anchor != NULL:
	695	anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.anchor,
	696	strlen(self.parsed_event.data.sequence_start.anchor), 'strict')
	697	elif self.parsed_event.type == YAML_MAPPING_START_EVENT \
	698	and self.parsed_event.data.mapping_start.anchor != NULL:
	699	anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.anchor,
	700	strlen(self.parsed_event.data.mapping_start.anchor), 'strict')
	701	if anchor is not None:
	702	if anchor in self.anchors:
	703	mark = Mark(self.stream_name,
	704	self.parsed_event.start_mark.index,
	705	self.parsed_event.start_mark.line,
	706	self.parsed_event.start_mark.column,
	707	None, None)
	708	raise ComposerError("found duplicate anchor; first occurence",
	709	self.anchors[anchor].start_mark, "second occurence", mark)
	710	self.descend_resolver(parent, index)
	711	if self.parsed_event.type == YAML_SCALAR_EVENT:
	712	node = self._compose_scalar_node(anchor)
	713	elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT:
	714	node = self._compose_sequence_node(anchor)
	715	elif self.parsed_event.type == YAML_MAPPING_START_EVENT:
	716	node = self._compose_mapping_node(anchor)
	717	self.ascend_resolver()
	718	return node
	719
	720	cdef _compose_scalar_node(self, object anchor):
	721	start_mark = Mark(self.stream_name,
	722	self.parsed_event.start_mark.index,
	723	self.parsed_event.start_mark.line,
	724	self.parsed_event.start_mark.column,
	725	None, None)
	726	end_mark = Mark(self.stream_name,
	727	self.parsed_event.end_mark.index,
	728	self.parsed_event.end_mark.line,
	729	self.parsed_event.end_mark.column,
	730	None, None)
	731	value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value,
	732	self.parsed_event.data.scalar.length, 'strict')
	733	plain_implicit = False
	734	if self.parsed_event.data.scalar.plain_implicit == 1:
	735	plain_implicit = True
	736	quoted_implicit = False
	737	if self.parsed_event.data.scalar.quoted_implicit == 1:
	738	quoted_implicit = True
	739	if self.parsed_event.data.scalar.tag == NULL \
	740	or (self.parsed_event.data.scalar.tag[0] == c'!'
	741	and self.parsed_event.data.scalar.tag[1] == c'\0'):
	742	tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit))
	743	else:
	744	tag = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.tag,
	745	strlen(self.parsed_event.data.scalar.tag), 'strict')
	746	style = None
	747	if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
	748	style = ''
	749	elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:
	750	style = '\''
	751	elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:
	752	style = '"'
	753	elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:
	754	style = '\|'
	755	elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
	756	style = '>'
	757	node = ScalarNode(tag, value, start_mark, end_mark, style)
	758	if anchor is not None:
	759	self.anchors[anchor] = node
	760	yaml_event_delete(&self.parsed_event)
	761	return node
	762
	763	cdef _compose_sequence_node(self, object anchor):
	764	cdef int index
	765	start_mark = Mark(self.stream_name,
	766	self.parsed_event.start_mark.index,
	767	self.parsed_event.start_mark.line,
	768	self.parsed_event.start_mark.column,
	769	None, None)
	770	implicit = False
	771	if self.parsed_event.data.sequence_start.implicit == 1:
	772	implicit = True
	773	if self.parsed_event.data.sequence_start.tag == NULL \
	774	or (self.parsed_event.data.sequence_start.tag[0] == c'!'
	775	and self.parsed_event.data.sequence_start.tag[1] == c'\0'):
	776	tag = self.resolve(SequenceNode, None, implicit)
	777	else:
	778	tag = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.tag,
	779	strlen(self.parsed_event.data.sequence_start.tag), 'strict')
	780	flow_style = None
	781	if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE:
	782	flow_style = True
	783	elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE:
	784	flow_style = False
	785	value = []
	786	node = SequenceNode(tag, value, start_mark, None, flow_style)
	787	if anchor is not None:
	788	self.anchors[anchor] = node
	789	yaml_event_delete(&self.parsed_event)
	790	index = 0
	791	self._parse_next_event()
	792	while self.parsed_event.type != YAML_SEQUENCE_END_EVENT:
	793	value.append(self._compose_node(node, index))
	794	index = index+1
	795	self._parse_next_event()
	796	node.end_mark = Mark(self.stream_name,
	797	self.parsed_event.end_mark.index,
	798	self.parsed_event.end_mark.line,
	799	self.parsed_event.end_mark.column,
	800	None, None)
	801	yaml_event_delete(&self.parsed_event)
	802	return node
	803
	804	cdef _compose_mapping_node(self, object anchor):
	805	start_mark = Mark(self.stream_name,
	806	self.parsed_event.start_mark.index,
	807	self.parsed_event.start_mark.line,
	808	self.parsed_event.start_mark.column,
	809	None, None)
	810	implicit = False
	811	if self.parsed_event.data.mapping_start.implicit == 1:
	812	implicit = True
	813	if self.parsed_event.data.mapping_start.tag == NULL \
	814	or (self.parsed_event.data.mapping_start.tag[0] == c'!'
	815	and self.parsed_event.data.mapping_start.tag[1] == c'\0'):
	816	tag = self.resolve(MappingNode, None, implicit)
	817	else:
	818	tag = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.tag,
	819	strlen(self.parsed_event.data.mapping_start.tag), 'strict')
	820	flow_style = None
	821	if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE:
	822	flow_style = True
	823	elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE:
	824	flow_style = False
	825	value = []
	826	node = MappingNode(tag, value, start_mark, None, flow_style)
	827	if anchor is not None:
	828	self.anchors[anchor] = node
	829	yaml_event_delete(&self.parsed_event)
	830	self._parse_next_event()
	831	while self.parsed_event.type != YAML_MAPPING_END_EVENT:
	832	item_key = self._compose_node(node, None)
	833	item_value = self._compose_node(node, item_key)
	834	value.append((item_key, item_value))
	835	self._parse_next_event()
	836	node.end_mark = Mark(self.stream_name,
	837	self.parsed_event.end_mark.index,
	838	self.parsed_event.end_mark.line,
	839	self.parsed_event.end_mark.column,
	840	None, None)
	841	yaml_event_delete(&self.parsed_event)
	842	return node
	843
	844	cdef int _parse_next_event(self) except 0:
	845	if self.parsed_event.type == YAML_NO_EVENT:
	846	if yaml_parser_parse(&self.parser, &self.parsed_event) == 0:
	847	error = self._parser_error()
	848	raise error
	849	return 1
479	850
480	851	cdef int input_handler(void data, char buffer, int size, int *read) except 0:
481		cdef ~~ScannerAnd~~Parser parser
482		parser = <~~ScannerAnd~~Parser>data
	852	cdef CParser parser
	853	parser = <CParser>data
483	854	value = parser.stream.read(size)
484	855	if PyString_CheckExact(value) == 0:
…	…
490	861	return 1
491	862
492		class Loader(ScannerAndParser,
493		yaml.composer.Composer,
494		yaml.constructor.Constructor,
495		yaml.resolver.Resolver):
496
497		def __init__(self, stream):
498		ScannerAndParser.__init__(self, stream)
499		yaml.composer.Composer.__init__(self)
500		yaml.constructor.Constructor.__init__(self)
501		yaml.resolver.Resolver.__init__(self)
502
503		yaml.ExtLoader = Loader
504
	863	cdef class CEmitter:
	864
	865	cdef yaml_emitter_t emitter
	866
	867	cdef object stream
	868
	869	cdef yaml_encoding_t use_encoding
	870	cdef int document_start_implicit
	871	cdef int document_end_implicit
	872	cdef object use_version
	873	cdef object use_tags
	874
	875	cdef object serialized_nodes
	876	cdef object anchors
	877	cdef int last_alias_id
	878	cdef int closed
	879
	880	def __init__(self, stream, canonical=None, indent=None, width=None,
	881	allow_unicode=None, line_break=None, encoding=None,
	882	explicit_start=None, explicit_end=None, version=None, tags=None):
	883	if yaml_emitter_initialize(&self.emitter) == 0:
	884	raise MemoryError
	885	self.stream = stream
	886	yaml_emitter_set_output(&self.emitter, output_handler, <void *>self)
	887	if canonical is not None:
	888	yaml_emitter_set_canonical(&self.emitter, 1)
	889	if indent is not None:
	890	yaml_emitter_set_indent(&self.emitter, indent)
	891	if width is not None:
	892	yaml_emitter_set_width(&self.emitter, width)
	893	if allow_unicode is not None:
	894	yaml_emitter_set_unicode(&self.emitter, 1)
	895	if line_break is not None:
	896	if line_break == '\r':
	897	yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK)
	898	elif line_break == '\n':
	899	yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK)
	900	elif line_break == '\r\n':
	901	yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK)
	902	if encoding == 'utf-16-le':
	903	self.use_encoding = YAML_UTF16LE_ENCODING
	904	elif encoding == 'utf-16-be':
	905	self.use_encoding = YAML_UTF16BE_ENCODING
	906	else:
	907	self.use_encoding = YAML_UTF8_ENCODING
	908	self.document_start_implicit = 1
	909	if explicit_start:
	910	self.document_start_implicit = 0
	911	self.document_end_implicit = 1
	912	if explicit_end:
	913	self.document_end_implicit = 0
	914	self.use_version = version
	915	self.use_tags = tags
	916	self.serialized_nodes = {}
	917	self.anchors = {}
	918	self.last_alias_id = 0
	919	self.closed = -1
	920
	921	def __dealloc__(self):
	922	yaml_emitter_delete(&self.emitter)
	923
	924	cdef object _emitter_error(self):
	925	if self.emitter.error == YAML_MEMORY_ERROR:
	926	return MemoryError
	927	elif self.emitter.error == YAML_EMITTER_ERROR:
	928	return EmitterError(self.emitter.problem)
	929	raise ValueError("no emitter error")
	930
	931	cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0:
	932	cdef yaml_encoding_t encoding
	933	cdef yaml_version_directive_t version_directive_value
	934	cdef yaml_version_directive_t *version_directive
	935	cdef yaml_tag_directive_t tag_directives_value[128]
	936	cdef yaml_tag_directive_t *tag_directives_start
	937	cdef yaml_tag_directive_t *tag_directives_end
	938	cdef int implicit
	939	cdef int plain_implicit
	940	cdef int quoted_implicit
	941	cdef char *anchor
	942	cdef char *tag
	943	cdef char *value
	944	cdef int length
	945	cdef yaml_scalar_style_t scalar_style
	946	cdef yaml_sequence_style_t sequence_style
	947	cdef yaml_mapping_style_t mapping_style
	948	event_class = event_object.__class__
	949	if event_class is StreamStartEvent:
	950	encoding = YAML_UTF8_ENCODING
	951	if event_object.encoding == 'utf-16-le':
	952	encoding = YAML_UTF16LE_ENCODING
	953	elif event_object.encoding == 'utf-16-be':
	954	encoding = YAML_UTF16BE_ENCODING
	955	yaml_stream_start_event_initialize(event, encoding)
	956	elif event_class is StreamEndEvent:
	957	yaml_stream_end_event_initialize(event)
	958	elif event_class is DocumentStartEvent:
	959	version_directive = NULL
	960	if event_object.version:
	961	version_directive_value.major = event_object.version[0]
	962	version_directive_value.minor = event_object.version[1]
	963	version_directive = &version_directive_value
	964	tag_directives_start = NULL
	965	tag_directives_end = NULL
	966	if event_object.tags:
	967	if len(event_object.tags) > 128:
	968	raise ValueError("too many tags")
	969	tag_directives_start = tag_directives_value
	970	tag_directives_end = tag_directives_value
	971	cache = []
	972	for handle in event_object.tags:
	973	prefix = event_object.tags[handle]
	974	if PyUnicode_CheckExact(handle):
	975	handle = PyUnicode_AsUTF8String(handle)
	976	cache.append(handle)
	977	if not PyString_CheckExact(handle):
	978	raise TypeError("tag handle must be a string")
	979	tag_directives_end.handle = PyString_AS_STRING(handle)
	980	if PyUnicode_CheckExact(prefix):
	981	prefix = PyUnicode_AsUTF8String(prefix)
	982	cache.append(prefix)
	983	if not PyString_CheckExact(prefix):
	984	raise TypeError("tag prefix must be a string")
	985	tag_directives_end.prefix = PyString_AS_STRING(prefix)
	986	tag_directives_end = tag_directives_end+1
	987	implicit = 1
	988	if event_object.explicit:
	989	implicit = 0
	990	if yaml_document_start_event_initialize(event, version_directive,
	991	tag_directives_start, tag_directives_end, implicit) == 0:
	992	raise MemoryError
	993	elif event_class is DocumentEndEvent:
	994	implicit = 1
	995	if event_object.explicit:
	996	implicit = 0
	997	yaml_document_end_event_initialize(event, implicit)
	998	elif event_class is AliasEvent:
	999	anchor = NULL
	1000	anchor_object = event_object.anchor
	1001	if PyUnicode_CheckExact(anchor_object):
	1002	anchor_object = PyUnicode_AsUTF8String(anchor_object)
	1003	if not PyString_CheckExact(anchor_object):
	1004	raise TypeError("anchor must be a string")
	1005	anchor = PyString_AS_STRING(anchor_object)
	1006	if yaml_alias_event_initialize(event, anchor) == 0:
	1007	raise MemoryError
	1008	elif event_class is ScalarEvent:
	1009	anchor = NULL
	1010	anchor_object = event_object.anchor
	1011	if anchor_object is not None:
	1012	if PyUnicode_CheckExact(anchor_object):
	1013	anchor_object = PyUnicode_AsUTF8String(anchor_object)
	1014	if not PyString_CheckExact(anchor_object):
	1015	raise TypeError("anchor must be a string")
	1016	anchor = PyString_AS_STRING(anchor_object)
	1017	tag = NULL
	1018	tag_object = event_object.tag
	1019	if tag_object is not None:
	1020	if PyUnicode_CheckExact(tag_object):
	1021	tag_object = PyUnicode_AsUTF8String(tag_object)
	1022	if not PyString_CheckExact(tag_object):
	1023	raise TypeError("tag must be a string")
	1024	tag = PyString_AS_STRING(tag_object)
	1025	value_object = event_object.value
	1026	if PyUnicode_CheckExact(value_object):
	1027	value_object = PyUnicode_AsUTF8String(value_object)
	1028	if not PyString_CheckExact(value_object):
	1029	raise TypeError("value must be a string")
	1030	value = PyString_AS_STRING(value_object)
	1031	length = PyString_GET_SIZE(value_object)
	1032	plain_implicit = 0
	1033	quoted_implicit = 0
	1034	if event_object.implicit is not None:
	1035	plain_implicit = event_object.implicit[0]
	1036	quoted_implicit = event_object.implicit[1]
	1037	style_object = event_object.style
	1038	scalar_style = YAML_PLAIN_SCALAR_STYLE
	1039	if style_object == "'":
	1040	scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE
	1041	elif style_object == "\"":
	1042	scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE
	1043	elif style_object == "\|":
	1044	scalar_style = YAML_LITERAL_SCALAR_STYLE
	1045	elif style_object == ">":
	1046	scalar_style = YAML_FOLDED_SCALAR_STYLE
	1047	if yaml_scalar_event_initialize(event, anchor, tag, value, length,
	1048	plain_implicit, quoted_implicit, scalar_style) == 0:
	1049	raise MemoryError
	1050	elif event_class is SequenceStartEvent:
	1051	anchor = NULL
	1052	anchor_object = event_object.anchor
	1053	if anchor_object is not None:
	1054	if PyUnicode_CheckExact(anchor_object):
	1055	anchor_object = PyUnicode_AsUTF8String(anchor_object)
	1056	if not PyString_CheckExact(anchor_object):
	1057	raise TypeError("anchor must be a string")
	1058	anchor = PyString_AS_STRING(anchor_object)
	1059	tag = NULL
	1060	tag_object = event_object.tag
	1061	if tag_object is not None:
	1062	if PyUnicode_CheckExact(tag_object):
	1063	tag_object = PyUnicode_AsUTF8String(tag_object)
	1064	if not PyString_CheckExact(tag_object):
	1065	raise TypeError("tag must be a string")
	1066	tag = PyString_AS_STRING(tag_object)
	1067	implicit = 0
	1068	if event_object.implicit:
	1069	implicit = 1
	1070	sequence_style = YAML_BLOCK_SEQUENCE_STYLE
	1071	if event_object.flow_style:
	1072	sequence_style = YAML_FLOW_SEQUENCE_STYLE
	1073	if yaml_sequence_start_event_initialize(event, anchor, tag,
	1074	implicit, sequence_style) == 0:
	1075	raise MemoryError
	1076	elif event_class is MappingStartEvent:
	1077	anchor = NULL
	1078	anchor_object = event_object.anchor
	1079	if anchor_object is not None:
	1080	if PyUnicode_CheckExact(anchor_object):
	1081	anchor_object = PyUnicode_AsUTF8String(anchor_object)
	1082	if not PyString_CheckExact(anchor_object):
	1083	raise TypeError("anchor must be a string")
	1084	anchor = PyString_AS_STRING(anchor_object)
	1085	tag = NULL
	1086	tag_object = event_object.tag
	1087	if tag_object is not None:
	1088	if PyUnicode_CheckExact(tag_object):
	1089	tag_object = PyUnicode_AsUTF8String(tag_object)
	1090	if not PyString_CheckExact(tag_object):
	1091	raise TypeError("tag must be a string")
	1092	tag = PyString_AS_STRING(tag_object)
	1093	implicit = 0
	1094	if event_object.implicit:
	1095	implicit = 1
	1096	mapping_style = YAML_BLOCK_MAPPING_STYLE
	1097	if event_object.flow_style:
	1098	mapping_style = YAML_FLOW_MAPPING_STYLE
	1099	if yaml_mapping_start_event_initialize(event, anchor, tag,
	1100	implicit, mapping_style) == 0:
	1101	raise MemoryError
	1102	elif event_class is SequenceEndEvent:
	1103	yaml_sequence_end_event_initialize(event)
	1104	elif event_class is MappingEndEvent:
	1105	yaml_mapping_end_event_initialize(event)
	1106	else:
	1107	raise TypeError("invalid event %s" % event_object)
	1108	return 1
	1109
	1110	def emit(self, event_object):
	1111	cdef yaml_event_t event
	1112	self._object_to_event(event_object, &event)
	1113	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1114	error = self._emitter_error()
	1115	raise error
	1116
	1117	def open(self):
	1118	cdef yaml_event_t event
	1119	if self.closed == -1:
	1120	yaml_stream_start_event_initialize(&event, self.use_encoding)
	1121	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1122	error = self._emitter_error()
	1123	raise error
	1124	self.closed = 0
	1125	elif self.closed == 1:
	1126	raise SerializerError("serializer is closed")
	1127	else:
	1128	raise SerializerError("serializer is already opened")
	1129
	1130	def close(self):
	1131	cdef yaml_event_t event
	1132	if self.closed == -1:
	1133	raise SerializerError("serializer is not opened")
	1134	elif self.closed == 0:
	1135	yaml_stream_end_event_initialize(&event)
	1136	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1137	error = self._emitter_error()
	1138	raise error
	1139	self.closed = 1
	1140
	1141	def serialize(self, node):
	1142	cdef yaml_event_t event
	1143	cdef yaml_version_directive_t version_directive_value
	1144	cdef yaml_version_directive_t *version_directive
	1145	cdef yaml_tag_directive_t tag_directives_value[128]
	1146	cdef yaml_tag_directive_t *tag_directives_start
	1147	cdef yaml_tag_directive_t *tag_directives_end
	1148	if self.closed == -1:
	1149	raise SerializerError("serializer is not opened")
	1150	elif self.closed == 1:
	1151	raise SerializerError("serializer is closed")
	1152	cache = []
	1153	version_directive = NULL
	1154	if self.use_version:
	1155	version_directive_value.major = self.use_version[0]
	1156	version_directive_value.minor = self.use_version[1]
	1157	version_directive = &version_directive_value
	1158	tag_directives_start = NULL
	1159	tag_directives_end = NULL
	1160	if self.use_tags:
	1161	if len(self.use_tags) > 128:
	1162	raise ValueError("too many tags")
	1163	tag_directives_start = tag_directives_value
	1164	tag_directives_end = tag_directives_value
	1165	for handle in self.use_tags:
	1166	prefix = self.use_tags[handle]
	1167	if PyUnicode_CheckExact(handle):
	1168	handle = PyUnicode_AsUTF8String(handle)
	1169	cache.append(handle)
	1170	if not PyString_CheckExact(handle):
	1171	raise TypeError("tag handle must be a string")
	1172	tag_directives_end.handle = PyString_AS_STRING(handle)
	1173	if PyUnicode_CheckExact(prefix):
	1174	prefix = PyUnicode_AsUTF8String(prefix)
	1175	cache.append(prefix)
	1176	if not PyString_CheckExact(prefix):
	1177	raise TypeError("tag prefix must be a string")
	1178	tag_directives_end.prefix = PyString_AS_STRING(prefix)
	1179	tag_directives_end = tag_directives_end+1
	1180	if yaml_document_start_event_initialize(&event, version_directive,
	1181	tag_directives_start, tag_directives_end,
	1182	self.document_start_implicit) == 0:
	1183	raise MemoryError
	1184	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1185	error = self._emitter_error()
	1186	raise error
	1187	self._anchor_node(node)
	1188	self._serialize_node(node, None, None)
	1189	yaml_document_end_event_initialize(&event, self.document_end_implicit)
	1190	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1191	error = self._emitter_error()
	1192	raise error
	1193	self.serialized_nodes = {}
	1194	self.anchors = {}
	1195	self.last_alias_id = 0
	1196
	1197	cdef int _anchor_node(self, object node) except 0:
	1198	if node in self.anchors:
	1199	if self.anchors[node] is None:
	1200	self.last_alias_id = self.last_alias_id+1
	1201	self.anchors[node] = "id%03d" % self.last_alias_id
	1202	else:
	1203	self.anchors[node] = None
	1204	node_class = node.__class__
	1205	if node_class is SequenceNode:
	1206	for item in node.value:
	1207	self._anchor_node(item)
	1208	elif node_class is MappingNode:
	1209	for key, value in node.value:
	1210	self._anchor_node(key)
	1211	self._anchor_node(value)
	1212	return 1
	1213
	1214	cdef int _serialize_node(self, object node, object parent, object index) except 0:
	1215	cdef yaml_event_t event
	1216	cdef int implicit
	1217	cdef int plain_implicit
	1218	cdef int quoted_implicit
	1219	cdef char *anchor
	1220	cdef char *tag
	1221	cdef char *value
	1222	cdef int length
	1223	cdef int item_index
	1224	cdef yaml_scalar_style_t scalar_style
	1225	cdef yaml_sequence_style_t sequence_style
	1226	cdef yaml_mapping_style_t mapping_style
	1227	anchor_object = self.anchors[node]
	1228	anchor = NULL
	1229	if anchor_object is not None:
	1230	anchor = PyString_AS_STRING(anchor_object)
	1231	if node in self.serialized_nodes:
	1232	if yaml_alias_event_initialize(&event, anchor) == 0:
	1233	raise MemoryError
	1234	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1235	error = self._emitter_error()
	1236	raise error
	1237	else:
	1238	node_class = node.__class__
	1239	self.serialized_nodes[node] = True
	1240	self.descend_resolver(parent, index)
	1241	if node_class is ScalarNode:
	1242	plain_implicit = 0
	1243	quoted_implicit = 0
	1244	tag_object = node.tag
	1245	if self.resolve(ScalarNode, node.value, (True, False)) == tag_object:
	1246	plain_implicit = 1
	1247	if self.resolve(ScalarNode, node.value, (False, True)) == tag_object:
	1248	quoted_implicit = 1
	1249	tag = NULL
	1250	if tag_object is not None:
	1251	if PyUnicode_CheckExact(tag_object):
	1252	tag_object = PyUnicode_AsUTF8String(tag_object)
	1253	if not PyString_CheckExact(tag_object):
	1254	raise TypeError("tag must be a string")
	1255	tag = PyString_AS_STRING(tag_object)
	1256	value_object = node.value
	1257	if PyUnicode_CheckExact(value_object):
	1258	value_object = PyUnicode_AsUTF8String(value_object)
	1259	if not PyString_CheckExact(value_object):
	1260	raise TypeError("value must be a string")
	1261	value = PyString_AS_STRING(value_object)
	1262	length = PyString_GET_SIZE(value_object)
	1263	style_object = node.style
	1264	scalar_style = YAML_PLAIN_SCALAR_STYLE
	1265	if style_object == "'":
	1266	scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE
	1267	elif style_object == "\"":
	1268	scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE
	1269	elif style_object == "\|":
	1270	scalar_style = YAML_LITERAL_SCALAR_STYLE
	1271	elif style_object == ">":
	1272	scalar_style = YAML_FOLDED_SCALAR_STYLE
	1273	if yaml_scalar_event_initialize(&event, anchor, tag, value, length,
	1274	plain_implicit, quoted_implicit, scalar_style) == 0:
	1275	raise MemoryError
	1276	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1277	error = self._emitter_error()
	1278	raise error
	1279	elif node_class is SequenceNode:
	1280	implicit = 0
	1281	tag_object = node.tag
	1282	if self.resolve(SequenceNode, node.value, True) == tag_object:
	1283	implicit = 1
	1284	tag = NULL
	1285	if tag_object is not None:
	1286	if PyUnicode_CheckExact(tag_object):
	1287	tag_object = PyUnicode_AsUTF8String(tag_object)
	1288	if not PyString_CheckExact(tag_object):
	1289	raise TypeError("tag must be a string")
	1290	tag = PyString_AS_STRING(tag_object)
	1291	sequence_style = YAML_BLOCK_SEQUENCE_STYLE
	1292	if node.flow_style:
	1293	sequence_style = YAML_FLOW_SEQUENCE_STYLE
	1294	if yaml_sequence_start_event_initialize(&event, anchor, tag,
	1295	implicit, sequence_style) == 0:
	1296	raise MemoryError
	1297	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1298	error = self._emitter_error()
	1299	raise error
	1300	item_index = 0
	1301	for item in node.value:
	1302	self._serialize_node(item, node, item_index)
	1303	item_index = item_index+1
	1304	yaml_sequence_end_event_initialize(&event)
	1305	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1306	error = self._emitter_error()
	1307	raise error
	1308	elif node_class is MappingNode:
	1309	implicit = 0
	1310	tag_object = node.tag
	1311	if self.resolve(MappingNode, node.value, True) == tag_object:
	1312	implicit = 1
	1313	tag = NULL
	1314	if tag_object is not None:
	1315	if PyUnicode_CheckExact(tag_object):
	1316	tag_object = PyUnicode_AsUTF8String(tag_object)
	1317	if not PyString_CheckExact(tag_object):
	1318	raise TypeError("tag must be a string")
	1319	tag = PyString_AS_STRING(tag_object)
	1320	mapping_style = YAML_BLOCK_MAPPING_STYLE
	1321	if node.flow_style:
	1322	mapping_style = YAML_FLOW_MAPPING_STYLE
	1323	if yaml_mapping_start_event_initialize(&event, anchor, tag,
	1324	implicit, mapping_style) == 0:
	1325	raise MemoryError
	1326	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1327	error = self._emitter_error()
	1328	raise error
	1329	for item_key, item_value in node.value:
	1330	self._serialize_node(item_key, node, None)
	1331	self._serialize_node(item_value, node, item_key)
	1332	yaml_mapping_end_event_initialize(&event)
	1333	if yaml_emitter_emit(&self.emitter, &event) == 0:
	1334	error = self._emitter_error()
	1335	raise error
	1336	return 1
	1337
	1338	cdef int output_handler(void data, char buffer, int size) except 0:
	1339	cdef CEmitter emitter
	1340	emitter = <CEmitter>data
	1341	value = PyString_FromStringAndSize(buffer, size)
	1342	emitter.stream.write(value)
	1343	return 1
	1344

pyyaml/trunk/lib/yaml/init.py

r153	r223
8	8	from loader import *
9	9	from dumper import *
	10
	11	try:
	12	from cyaml import *
	13	except ImportError:
	14	pass
10	15
11	16	def scan(stream, Loader=Loader):

pyyaml/trunk/lib/yaml/composer.py

r222	r223
38	38	self.get_event()
39	39
40		self.~~complete_~~anchors = {}
	40	self.anchors = {}
41	41	return node
42	42

pyyaml/trunk/lib/yaml/resolver.py

r222	r223
75	75
76	76	def descend_resolver(self, current_node, current_index):
	77	if not self.yaml_path_resolvers:
	78	return
77	79	exact_paths = {}
78	80	prefix_paths = []
…	…
96	98
97	99	def ascend_resolver(self):
	100	if not self.yaml_path_resolvers:
	101	return
98	102	self.resolver_exact_paths.pop()
99	103	self.resolver_prefix_paths.pop()
…	…
132	136	return tag
133	137	implicit = implicit[1]
134		exact_paths = self.resolver_exact_paths[-1]
135		if kind in exact_paths:
136		return exact_paths[kind]
137		if None in exact_paths:
138		return exact_paths[None]
	138	if self.yaml_path_resolvers:
	139	exact_paths = self.resolver_exact_paths[-1]
	140	if kind in exact_paths:
	141	return exact_paths[kind]
	142	if None in exact_paths:
	143	return exact_paths[None]
139	144	if kind is ScalarNode:
140	145	return self.DEFAULT_SCALAR_TAG

pyyaml/trunk/tests/test_yaml_ext.py

r209	r223
4	4	import _yaml, yaml
5	5
6		class Test~~Ext~~Version(unittest.TestCase):
	6	class TestCVersion(unittest.TestCase):
7	7
8		def test~~Ext~~Version(self):
	8	def testCVersion(self):
9	9	self.failUnlessEqual("%s.%s.%s" % _yaml.get_version(), _yaml.get_version_string())
10	10
11		class Test~~Ext~~Loader(test_appliance.TestAppliance):
	11	class TestCLoader(test_appliance.TestAppliance):
12	12
13		def _test~~Ext~~ScannerFileInput(self, test_name, data_filename, canonical_filename):
14		self._test~~Ext~~Scanner(test_name, data_filename, canonical_filename, True)
	13	def _testCScannerFileInput(self, test_name, data_filename, canonical_filename):
	14	self._testCScanner(test_name, data_filename, canonical_filename, True)
15	15
16		def _test~~ExtScanner(self, test_name, data_filename, canonical_filename, file_input=False~~):
	16	def _testCScanner(self, test_name, data_filename, canonical_filename, file_input=False, Loader=yaml.Loader):
17	17	if file_input:
18	18	data = file(data_filename, 'r')
19	19	else:
20	20	data = file(data_filename, 'r').read()
21		tokens = list(yaml.scan(data))
	21	tokens = list(yaml.scan(data, Loader=Loader))
22	22	ext_tokens = []
23	23	try:
24	24	if file_input:
25	25	data = file(data_filename, 'r')
26		for token in yaml.scan(data, Loader=yaml.~~Ext~~Loader):
	26	for token in yaml.scan(data, Loader=yaml.CLoader):
27	27	ext_tokens.append(token)
28	28	self.failUnlessEqual(len(tokens), len(ext_tokens))
…	…
43	43	raise
44	44
45		def _test~~ExtParser(self, test_name, data_filename, canonical_filename~~):
	45	def _testCParser(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader):
46	46	data = file(data_filename, 'r').read()
47		events = list(yaml.parse(data))
	47	events = list(yaml.parse(data, Loader=Loader))
48	48	ext_events = []
49	49	try:
50		for event in yaml.parse(data, Loader=yaml.~~Ext~~Loader):
	50	for event in yaml.parse(data, Loader=yaml.CLoader):
51	51	ext_events.append(event)
52	52	#print "EVENT:", event
…	…
62	62	if hasattr(event, 'value'):
63	63	self.failUnlessEqual(event.value, ext_event.value)
	64	if hasattr(event, 'explicit'):
	65	self.failUnlessEqual(event.explicit, ext_event.explicit)
	66	if hasattr(event, 'version'):
	67	self.failUnlessEqual(event.version, ext_event.version)
	68	if hasattr(event, 'tags'):
	69	self.failUnlessEqual(event.tags, ext_event.tags)
64	70	except:
65	71	print
…	…
70	76	raise
71	77
72		TestExtLoader.add_tests('testExtScanner', '.data', '.canonical')
73		TestExtLoader.add_tests('testExtScannerFileInput', '.data', '.canonical')
74		TestExtLoader.add_tests('testExtParser', '.data', '.canonical')
	78	TestCLoader.add_tests('testCScanner', '.data', '.canonical')
	79	TestCLoader.add_tests('testCScannerFileInput', '.data', '.canonical')
	80	TestCLoader.add_tests('testCParser', '.data', '.canonical')
	81
	82	class TestCEmitter(test_appliance.TestAppliance):
	83
	84	def _testCEmitter(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader):
	85	data1 = file(data_filename, 'r').read()
	86	events = list(yaml.parse(data1, Loader=Loader))
	87	data2 = yaml.emit(events, Dumper=yaml.CDumper)
	88	ext_events = []
	89	try:
	90	for event in yaml.parse(data2):
	91	ext_events.append(event)
	92	self.failUnlessEqual(len(events), len(ext_events))
	93	for event, ext_event in zip(events, ext_events):
	94	self.failUnlessEqual(event.__class__, ext_event.__class__)
	95	if hasattr(event, 'anchor'):
	96	self.failUnlessEqual(event.anchor, ext_event.anchor)
	97	if hasattr(event, 'tag'):
	98	if not (event.tag in ['!', None] and ext_event.tag in ['!', None]):
	99	self.failUnlessEqual(event.tag, ext_event.tag)
	100	if hasattr(event, 'implicit'):
	101	self.failUnlessEqual(event.implicit, ext_event.implicit)
	102	if hasattr(event, 'value'):
	103	self.failUnlessEqual(event.value, ext_event.value)
	104	if hasattr(event, 'explicit'):
	105	self.failUnlessEqual(event.explicit, ext_event.explicit)
	106	if hasattr(event, 'version'):
	107	self.failUnlessEqual(event.version, ext_event.version)
	108	if hasattr(event, 'tags'):
	109	self.failUnlessEqual(event.tags, ext_event.tags)
	110	except:
	111	print
	112	print "DATA1:"
	113	print data1
	114	print "DATA2:"
	115	print data2
	116	print "EVENTS:", events
	117	print "EXT_EVENTS:", ext_events
	118	raise
	119
	120	TestCEmitter.add_tests('testCEmitter', '.data', '.canonical')
	121
	122	yaml.BaseLoader = yaml.CBaseLoader
	123	yaml.SafeLoader = yaml.CSafeLoader
	124	yaml.Loader = yaml.CLoader
	125	yaml.BaseDumper = yaml.CBaseDumper
	126	yaml.SafeDumper = yaml.CSafeDumper
	127	yaml.Dumper = yaml.CDumper
	128	old_scan = yaml.scan
	129	def scan(stream, Loader=yaml.CLoader):
	130	return old_scan(stream, Loader)
	131	yaml.scan = scan
	132	old_parse = yaml.parse
	133	def parse(stream, Loader=yaml.CLoader):
	134	return old_parse(stream, Loader)
	135	yaml.parse = parse
	136	old_compose = yaml.compose
	137	def compose(stream, Loader=yaml.CLoader):
	138	return old_compose(stream, Loader)
	139	yaml.compose = compose
	140	old_compose_all = yaml.compose_all
	141	def compose_all(stream, Loader=yaml.CLoader):
	142	return old_compose_all(stream, Loader)
	143	yaml.compose_all = compose_all
	144	old_load_all = yaml.load_all
	145	def load_all(stream, Loader=yaml.CLoader):
	146	return old_load_all(stream, Loader)
	147	yaml.load_all = load_all
	148	old_load = yaml.load
	149	def load(stream, Loader=yaml.CLoader):
	150	return old_load(stream, Loader)
	151	yaml.load = load
	152	def safe_load_all(stream):
	153	return yaml.load_all(stream, yaml.CSafeLoader)
	154	yaml.safe_load_all = safe_load_all
	155	def safe_load(stream):
	156	return yaml.load(stream, yaml.CSafeLoader)
	157	yaml.safe_load = safe_load
	158	old_emit = yaml.emit
	159	def emit(events, stream=None, Dumper=yaml.CDumper, **kwds):
	160	return old_emit(events, stream, Dumper, **kwds)
	161	yaml.emit = emit
	162	old_serialize_all = yaml.serialize_all
	163	def serialize_all(nodes, stream=None, Dumper=yaml.CDumper, **kwds):
	164	return old_serialize_all(nodes, stream, Dumper, **kwds)
	165	yaml.serialize_all = serialize_all
	166	old_serialize = yaml.serialize
	167	def serialize(node, stream, Dumper=yaml.CDumper, **kwds):
	168	return old_serialize(node, stream, Dumper, **kwds)
	169	yaml.serialize = serialize
	170	old_dump_all = yaml.dump_all
	171	def dump_all(documents, stream=None, Dumper=yaml.CDumper, **kwds):
	172	return old_dump_all(documents, stream, Dumper, **kwds)
	173	yaml.dump_all = dump_all
	174	old_dump = yaml.dump
	175	def dump(data, stream=None, Dumper=yaml.CDumper, **kwds):
	176	return old_dump(data, stream, Dumper, **kwds)
	177	yaml.dump = dump
	178	def safe_dump_all(documents, stream=None, **kwds):
	179	return yaml.dump_all(documents, stream, yaml.CSafeDumper, **kwds)
	180	yaml.safe_dump_all = safe_dump_all
	181	def safe_dump(data, stream=None, **kwds):
	182	return yaml.dump(data, stream, yaml.CSafeDumper, **kwds)
	183	yaml.safe_dump = safe_dump
	184
	185	from test_yaml import *
75	186
76	187	def main(module='__main__'):

Context Navigation

Changeset 223 for pyyaml/trunk

Legend:

pyyaml/trunk/ext/_yaml.pxd

pyyaml/trunk/ext/_yaml.pyx

pyyaml/trunk/lib/yaml/__init__.py

pyyaml/trunk/lib/yaml/composer.py

pyyaml/trunk/lib/yaml/resolver.py

pyyaml/trunk/tests/test_yaml_ext.py

Download in other formats:

pyyaml/trunk/lib/yaml/init.py