Index: pyyaml/trunk/ext/_yaml.pyx =================================================================== --- pyyaml/trunk/ext/_yaml.pyx (revision 333) +++ pyyaml/trunk/ext/_yaml.pyx (revision 334) @@ -3,5 +3,10 @@ def get_version_string(): - return yaml_get_version_string() + cdef char *value + value = yaml_get_version_string() + if PY_MAJOR_VERSION < 3: + return value + else: + return PyUnicode_FromString(value) def get_version(): @@ -10,5 +15,5 @@ return (major, minor, patch) -#Mark = yaml.error.Mark +Mark = yaml.error.Mark YAMLError = yaml.error.YAMLError ReaderError = yaml.reader.ReaderError @@ -57,29 +62,29 @@ MappingNode = yaml.nodes.MappingNode -cdef class Mark: - cdef readonly object name - cdef readonly int index - cdef readonly int line - cdef readonly int column - cdef readonly buffer - cdef readonly pointer - - def __init__(self, object name, int index, int line, int column, - object buffer, object pointer): - self.name = name - self.index = index - self.line = line - self.column = column - self.buffer = buffer - self.pointer = pointer - - def get_snippet(self): - return None - - def __str__(self): - where = " in \"%s\", line %d, column %d" \ - % (self.name, self.line+1, self.column+1) - return where - +#cdef class Mark: +# cdef readonly object name +# cdef readonly int index +# cdef readonly int line +# cdef readonly int column +# cdef readonly buffer +# cdef readonly pointer +# +# def __init__(self, object name, int index, int line, int column, +# object buffer, object pointer): +# self.name = name +# self.index = index +# self.line = line +# self.column = column +# self.buffer = buffer +# self.pointer = pointer +# +# def get_snippet(self): +# return None +# +# def __str__(self): +# where = " in \"%s\", line %d, column %d" \ +# % (self.name, self.line+1, self.column+1) +# return where +# #class YAMLError(Exception): # pass @@ -271,5 +276,8 @@ self.stream_name = stream.name except AttributeError: - self.stream_name = '' + if PY_MAJOR_VERSION < 3: + self.stream_name = '' + else: + self.stream_name = u'' self.stream_cache = None self.stream_cache_len = 0 @@ -279,10 +287,19 @@ if PyUnicode_CheckExact(stream) != 0: stream = PyUnicode_AsUTF8String(stream) - self.stream_name = '' + if PY_MAJOR_VERSION < 3: + self.stream_name = '' + else: + self.stream_name = u'' self.unicode_source = 1 else: - self.stream_name = '' + if PY_MAJOR_VERSION < 3: + self.stream_name = '' + else: + self.stream_name = u'' if PyString_CheckExact(stream) == 0: - raise TypeError("a string or stream input is required") + if PY_MAJOR_VERSION < 3: + raise TypeError("a string or stream input is required") + else: + raise TypeError(u"a string or stream input is required") self.stream = stream yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) @@ -299,6 +316,10 @@ return MemoryError elif self.parser.error == YAML_READER_ERROR: - return ReaderError(self.stream_name, self.parser.problem_offset, - self.parser.problem_value, '?', self.parser.problem) + if PY_MAJOR_VERSION < 3: + return ReaderError(self.stream_name, self.parser.problem_offset, + self.parser.problem_value, '?', self.parser.problem) + else: + return ReaderError(self.stream_name, self.parser.problem_offset, + self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) elif self.parser.error == YAML_SCANNER_ERROR \ or self.parser.error == YAML_PARSER_ERROR: @@ -315,19 +336,22 @@ self.parser.problem_mark.line, self.parser.problem_mark.column, None, None) + context = None + if self.parser.context != NULL: + if PY_MAJOR_VERSION < 3: + context = self.parser.context + else: + context = PyUnicode_FromString(self.parser.context) + if PY_MAJOR_VERSION < 3: + problem = self.parser.problem + else: + problem = PyUnicode_FromString(self.parser.problem) if self.parser.error == YAML_SCANNER_ERROR: - if self.parser.context != NULL: - return ScannerError(self.parser.context, context_mark, - self.parser.problem, problem_mark) - else: - return ScannerError(None, None, - self.parser.problem, problem_mark) - else: - if self.parser.context != NULL: - return ParserError(self.parser.context, context_mark, - self.parser.problem, problem_mark) - else: - return ParserError(None, None, - self.parser.problem, problem_mark) - raise ValueError("no parser error") + return ScannerError(context, context_mark, problem, problem_mark) + else: + return ParserError(context, context_mark, problem, problem_mark) + if PY_MAJOR_VERSION < 3: + raise ValueError("no parser error") + else: + raise ValueError(u"no parser error") def raw_scan(self): @@ -388,8 +412,6 @@ start_mark, end_mark) elif token.type == YAML_TAG_DIRECTIVE_TOKEN: - handle = PyUnicode_DecodeUTF8(token.data.tag_directive.handle, - strlen(token.data.tag_directive.handle), 'strict') - prefix = PyUnicode_DecodeUTF8(token.data.tag_directive.prefix, - strlen(token.data.tag_directive.prefix), 'strict') + handle = PyUnicode_FromString(token.data.tag_directive.handle) + prefix = PyUnicode_FromString(token.data.tag_directive.prefix) return DirectiveToken(u"TAG", (handle, prefix), start_mark, end_mark) @@ -421,16 +443,12 @@ return ValueToken(start_mark, end_mark) elif token.type == YAML_ALIAS_TOKEN: - value = PyUnicode_DecodeUTF8(token.data.alias.value, - strlen(token.data.alias.value), 'strict') + value = PyUnicode_FromString(token.data.alias.value) return AliasToken(value, start_mark, end_mark) elif token.type == YAML_ANCHOR_TOKEN: - value = PyUnicode_DecodeUTF8(token.data.anchor.value, - strlen(token.data.anchor.value), 'strict') + value = PyUnicode_FromString(token.data.anchor.value) return AnchorToken(value, start_mark, end_mark) elif token.type == YAML_TAG_TOKEN: - handle = PyUnicode_DecodeUTF8(token.data.tag.handle, - strlen(token.data.tag.handle), 'strict') - suffix = PyUnicode_DecodeUTF8(token.data.tag.suffix, - strlen(token.data.tag.suffix), 'strict') + handle = PyUnicode_FromString(token.data.tag.handle) + suffix = PyUnicode_FromString(token.data.tag.suffix) if not handle: handle = None @@ -443,17 +461,20 @@ if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: plain = True - style = '' + style = u'' elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: - style = '\'' + style = u'\'' elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: - style = '"' + style = u'"' elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: - style = '|' + style = u'|' elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: - style = '>' + style = u'>' return ScalarToken(value, plain, start_mark, end_mark, style) else: - raise ValueError("unknown token type") + if PY_MAJOR_VERSION < 3: + raise ValueError("unknown token type") + else: + raise ValueError(u"unknown token type") def get_token(self): @@ -527,13 +548,12 @@ if event.data.stream_start.encoding == YAML_UTF8_ENCODING: if self.unicode_source == 0: - encoding = "utf-8" + encoding = u"utf-8" elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: - encoding = "utf-16-le" + encoding = u"utf-16-le" elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: - encoding = "utf-16-be" + encoding = u"utf-16-be" return StreamStartEvent(start_mark, end_mark, encoding) elif event.type == YAML_STREAM_END_EVENT: return StreamEndEvent(start_mark, end_mark) - elif event.type == YAML_DOCUMENT_START_EVENT: explicit = False @@ -549,8 +569,6 @@ tag_directive = event.data.document_start.tag_directives.start while tag_directive != event.data.document_start.tag_directives.end: - handle = PyUnicode_DecodeUTF8(tag_directive.handle, - strlen(tag_directive.handle), 'strict') - prefix = PyUnicode_DecodeUTF8(tag_directive.prefix, - strlen(tag_directive.prefix), 'strict') + handle = PyUnicode_FromString(tag_directive.handle) + prefix = PyUnicode_FromString(tag_directive.prefix) tags[handle] = prefix tag_directive = tag_directive+1 @@ -563,16 +581,13 @@ return DocumentEndEvent(start_mark, end_mark, explicit) elif event.type == YAML_ALIAS_EVENT: - anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor, - strlen(event.data.alias.anchor), 'strict') + anchor = PyUnicode_FromString(event.data.alias.anchor) return AliasEvent(anchor, start_mark, end_mark) elif event.type == YAML_SCALAR_EVENT: anchor = None if event.data.scalar.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(event.data.scalar.anchor, - strlen(event.data.scalar.anchor), 'strict') + anchor = PyUnicode_FromString(event.data.scalar.anchor) tag = None if event.data.scalar.tag != NULL: - tag = PyUnicode_DecodeUTF8(event.data.scalar.tag, - strlen(event.data.scalar.tag), 'strict') + tag = PyUnicode_FromString(event.data.scalar.tag) value = PyUnicode_DecodeUTF8(event.data.scalar.value, event.data.scalar.length, 'strict') @@ -585,13 +600,13 @@ style = None if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: - style = '' + style = u'' elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: - style = '\'' + style = u'\'' elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: - style = '"' + style = u'"' elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: - style = '|' + style = u'|' elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: - style = '>' + style = u'>' return ScalarEvent(anchor, tag, (plain_implicit, quoted_implicit), @@ -600,10 +615,8 @@ anchor = None if event.data.sequence_start.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(event.data.sequence_start.anchor, - strlen(event.data.sequence_start.anchor), 'strict') + anchor = PyUnicode_FromString(event.data.sequence_start.anchor) tag = None if event.data.sequence_start.tag != NULL: - tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag, - strlen(event.data.sequence_start.tag), 'strict') + tag = PyUnicode_FromString(event.data.sequence_start.tag) implicit = False if event.data.sequence_start.implicit == 1: @@ -619,10 +632,8 @@ anchor = None if event.data.mapping_start.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(event.data.mapping_start.anchor, - strlen(event.data.mapping_start.anchor), 'strict') + anchor = PyUnicode_FromString(event.data.mapping_start.anchor) tag = None if event.data.mapping_start.tag != NULL: - tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag, - strlen(event.data.mapping_start.tag), 'strict') + tag = PyUnicode_FromString(event.data.mapping_start.tag) implicit = False if event.data.mapping_start.implicit == 1: @@ -639,7 +650,9 @@ elif event.type == YAML_MAPPING_END_EVENT: return MappingEndEvent(start_mark, end_mark) - else: - raise ValueError("unknown token type") + if PY_MAJOR_VERSION < 3: + raise ValueError("unknown event type") + else: + raise ValueError(u"unknown event type") def get_event(self): @@ -697,6 +710,10 @@ self.parsed_event.start_mark.column, None, None) - raise ComposerError("expected a single document in the stream", - document.start_mark, "but found another document", mark) + if PY_MAJOR_VERSION < 3: + raise ComposerError("expected a single document in the stream", + document.start_mark, "but found another document", mark) + else: + raise ComposerError(u"expected a single document in the stream", + document.start_mark, u"but found another document", mark) return document @@ -712,6 +729,5 @@ self._parse_next_event() if self.parsed_event.type == YAML_ALIAS_EVENT: - anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.alias.anchor, - strlen(self.parsed_event.data.alias.anchor), 'strict') + anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) if anchor not in self.anchors: mark = Mark(self.stream_name, @@ -720,5 +736,8 @@ self.parsed_event.start_mark.column, None, None) - raise ComposerError(None, None, "found undefined alias", mark) + if PY_MAJOR_VERSION < 3: + raise ComposerError(None, None, "found undefined alias", mark) + else: + raise ComposerError(None, None, u"found undefined alias", mark) yaml_event_delete(&self.parsed_event) return self.anchors[anchor] @@ -726,14 +745,11 @@ if self.parsed_event.type == YAML_SCALAR_EVENT \ and self.parsed_event.data.scalar.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.anchor, - strlen(self.parsed_event.data.scalar.anchor), 'strict') + anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ and self.parsed_event.data.sequence_start.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.anchor, - strlen(self.parsed_event.data.sequence_start.anchor), 'strict') + anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ and self.parsed_event.data.mapping_start.anchor != NULL: - anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.anchor, - strlen(self.parsed_event.data.mapping_start.anchor), 'strict') + anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) if anchor is not None: if anchor in self.anchors: @@ -743,6 +759,10 @@ self.parsed_event.start_mark.column, None, None) - raise ComposerError("found duplicate anchor; first occurence", - self.anchors[anchor].start_mark, "second occurence", mark) + if PY_MAJOR_VERSION < 3: + raise ComposerError("found duplicate anchor; first occurence", + self.anchors[anchor].start_mark, "second occurence", mark) + else: + raise ComposerError(u"found duplicate anchor; first occurence", + self.anchors[anchor].start_mark, u"second occurence", mark) self.descend_resolver(parent, index) if self.parsed_event.type == YAML_SCALAR_EVENT: @@ -779,17 +799,16 @@ tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) else: - tag = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.tag, - strlen(self.parsed_event.data.scalar.tag), 'strict') + tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) style = None if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: - style = '' + style = u'' elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: - style = '\'' + style = u'\'' elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: - style = '"' + style = u'"' elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: - style = '|' + style = u'|' elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: - style = '>' + style = u'>' node = ScalarNode(tag, value, start_mark, end_mark, style) if anchor is not None: @@ -813,6 +832,5 @@ tag = self.resolve(SequenceNode, None, implicit) else: - tag = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.tag, - strlen(self.parsed_event.data.sequence_start.tag), 'strict') + tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) flow_style = None if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: @@ -853,6 +871,5 @@ tag = self.resolve(MappingNode, None, implicit) else: - tag = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.tag, - strlen(self.parsed_event.data.mapping_start.tag), 'strict') + tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) flow_style = None if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: @@ -895,5 +912,8 @@ parser.unicode_source = 1 if PyString_CheckExact(value) == 0: - raise TypeError("a string value is expected") + if PY_MAJOR_VERSION < 3: + raise TypeError("a string value is expected") + else: + raise TypeError(u"a string value is expected") parser.stream_cache = value parser.stream_cache_pos = 0 @@ -977,6 +997,13 @@ return MemoryError elif self.emitter.error == YAML_EMITTER_ERROR: - return EmitterError(self.emitter.problem) - raise ValueError("no emitter error") + if PY_MAJOR_VERSION < 3: + problem = self.emitter.problem + else: + problem = PyUnicode_FromString(self.emitter.problem) + return EmitterError(problem) + if PY_MAJOR_VERSION < 3: + raise ValueError("no emitter error") + else: + raise ValueError(u"no emitter error") cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: @@ -1000,7 +1027,7 @@ if event_class is StreamStartEvent: encoding = YAML_UTF8_ENCODING - if event_object.encoding == 'utf-16-le': + if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': encoding = YAML_UTF16LE_ENCODING - elif event_object.encoding == 'utf-16-be': + elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': encoding = YAML_UTF16BE_ENCODING if event_object.encoding is None: @@ -1021,5 +1048,8 @@ if event_object.tags: if len(event_object.tags) > 128: - raise ValueError("too many tags") + if PY_MAJOR_VERSION < 3: + raise ValueError("too many tags") + else: + raise ValueError(u"too many tags") tag_directives_start = tag_directives_value tag_directives_end = tag_directives_value @@ -1031,5 +1061,8 @@ cache.append(handle) if not PyString_CheckExact(handle): - raise TypeError("tag handle must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag handle must be a string") + else: + raise TypeError(u"tag handle must be a string") tag_directives_end.handle = PyString_AS_STRING(handle) if PyUnicode_CheckExact(prefix): @@ -1037,5 +1070,8 @@ cache.append(prefix) if not PyString_CheckExact(prefix): - raise TypeError("tag prefix must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag prefix must be a string") + else: + raise TypeError(u"tag prefix must be a string") tag_directives_end.prefix = PyString_AS_STRING(prefix) tag_directives_end = tag_directives_end+1 @@ -1057,5 +1093,8 @@ anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): - raise TypeError("anchor must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("anchor must be a string") + else: + raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) if yaml_alias_event_initialize(event, anchor) == 0: @@ -1068,5 +1107,8 @@ anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): - raise TypeError("anchor must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("anchor must be a string") + else: + raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL @@ -1076,5 +1118,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) value_object = event_object.value @@ -1082,5 +1127,8 @@ value_object = PyUnicode_AsUTF8String(value_object) if not PyString_CheckExact(value_object): - raise TypeError("value must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("value must be a string") + else: + raise TypeError(u"value must be a string") value = PyString_AS_STRING(value_object) length = PyString_GET_SIZE(value_object) @@ -1092,11 +1140,11 @@ style_object = event_object.style scalar_style = YAML_PLAIN_SCALAR_STYLE - if style_object == "'": + if style_object == "'" or style_object == u"'": scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE - elif style_object == "\"": + elif style_object == "\"" or style_object == u"\"": scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE - elif style_object == "|": + elif style_object == "|" or style_object == u"|": scalar_style = YAML_LITERAL_SCALAR_STYLE - elif style_object == ">": + elif style_object == ">" or style_object == u">": scalar_style = YAML_FOLDED_SCALAR_STYLE if yaml_scalar_event_initialize(event, anchor, tag, value, length, @@ -1110,5 +1158,8 @@ anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): - raise TypeError("anchor must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("anchor must be a string") + else: + raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL @@ -1118,5 +1169,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) implicit = 0 @@ -1136,5 +1190,8 @@ anchor_object = PyUnicode_AsUTF8String(anchor_object) if not PyString_CheckExact(anchor_object): - raise TypeError("anchor must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("anchor must be a string") + else: + raise TypeError(u"anchor must be a string") anchor = PyString_AS_STRING(anchor_object) tag = NULL @@ -1144,5 +1201,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) implicit = 0 @@ -1160,5 +1220,8 @@ yaml_mapping_end_event_initialize(event) else: - raise TypeError("invalid event %s" % event_object) + if PY_MAJOR_VERSION < 3: + raise TypeError("invalid event %s" % event_object) + else: + raise TypeError(u"invalid event %s" % event_object) return 1 @@ -1174,7 +1237,7 @@ cdef yaml_encoding_t encoding if self.closed == -1: - if self.use_encoding == 'utf-16-le': + if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': encoding = YAML_UTF16LE_ENCODING - elif self.use_encoding == 'utf-16-be': + elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': encoding = YAML_UTF16BE_ENCODING else: @@ -1190,12 +1253,21 @@ self.closed = 0 elif self.closed == 1: - raise SerializerError("serializer is closed") + if PY_MAJOR_VERSION < 3: + raise SerializerError("serializer is closed") + else: + raise SerializerError(u"serializer is closed") else: - raise SerializerError("serializer is already opened") + if PY_MAJOR_VERSION < 3: + raise SerializerError("serializer is already opened") + else: + raise SerializerError(u"serializer is already opened") def close(self): cdef yaml_event_t event if self.closed == -1: - raise SerializerError("serializer is not opened") + if PY_MAJOR_VERSION < 3: + raise SerializerError("serializer is not opened") + else: + raise SerializerError(u"serializer is not opened") elif self.closed == 0: yaml_stream_end_event_initialize(&event) @@ -1213,7 +1285,13 @@ cdef yaml_tag_directive_t *tag_directives_end if self.closed == -1: - raise SerializerError("serializer is not opened") + if PY_MAJOR_VERSION < 3: + raise SerializerError("serializer is not opened") + else: + raise SerializerError(u"serializer is not opened") elif self.closed == 1: - raise SerializerError("serializer is closed") + if PY_MAJOR_VERSION < 3: + raise SerializerError("serializer is closed") + else: + raise SerializerError(u"serializer is closed") cache = [] version_directive = NULL @@ -1226,5 +1304,8 @@ if self.use_tags: if len(self.use_tags) > 128: - raise ValueError("too many tags") + if PY_MAJOR_VERSION < 3: + raise ValueError("too many tags") + else: + raise ValueError(u"too many tags") tag_directives_start = tag_directives_value tag_directives_end = tag_directives_value @@ -1235,5 +1316,8 @@ cache.append(handle) if not PyString_CheckExact(handle): - raise TypeError("tag handle must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag handle must be a string") + else: + raise TypeError(u"tag handle must be a string") tag_directives_end.handle = PyString_AS_STRING(handle) if PyUnicode_CheckExact(prefix): @@ -1241,5 +1325,8 @@ cache.append(prefix) if not PyString_CheckExact(prefix): - raise TypeError("tag prefix must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag prefix must be a string") + else: + raise TypeError(u"tag prefix must be a string") tag_directives_end.prefix = PyString_AS_STRING(prefix) tag_directives_end = tag_directives_end+1 @@ -1318,5 +1405,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) value_object = node.value @@ -1324,16 +1414,19 @@ value_object = PyUnicode_AsUTF8String(value_object) if not PyString_CheckExact(value_object): - raise TypeError("value must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("value must be a string") + else: + raise TypeError(u"value must be a string") value = PyString_AS_STRING(value_object) length = PyString_GET_SIZE(value_object) style_object = node.style scalar_style = YAML_PLAIN_SCALAR_STYLE - if style_object == "'": + if style_object == "'" or style_object == u"'": scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE - elif style_object == "\"": + elif style_object == "\"" or style_object == u"\"": scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE - elif style_object == "|": + elif style_object == "|" or style_object == u"|": scalar_style = YAML_LITERAL_SCALAR_STYLE - elif style_object == ">": + elif style_object == ">" or style_object == u">": scalar_style = YAML_FOLDED_SCALAR_STYLE if yaml_scalar_event_initialize(&event, anchor, tag, value, length, @@ -1353,5 +1446,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) sequence_style = YAML_BLOCK_SEQUENCE_STYLE @@ -1382,5 +1478,8 @@ tag_object = PyUnicode_AsUTF8String(tag_object) if not PyString_CheckExact(tag_object): - raise TypeError("tag must be a string") + if PY_MAJOR_VERSION < 3: + raise TypeError("tag must be a string") + else: + raise TypeError(u"tag must be a string") tag = PyString_AS_STRING(tag_object) mapping_style = YAML_BLOCK_MAPPING_STYLE