Ignore:
Timestamp:
12/30/08 08:30:52 (5 years ago)
Author:
xi
Message:

Fixed str/bytes issues with Python 3 in _yaml.pyx.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/ext/_yaml.pyx

    r333 r334  
    33 
    44def get_version_string(): 
    5     return yaml_get_version_string() 
     5    cdef char *value 
     6    value = yaml_get_version_string() 
     7    if PY_MAJOR_VERSION < 3: 
     8        return value 
     9    else: 
     10        return PyUnicode_FromString(value) 
    611 
    712def get_version(): 
     
    1015    return (major, minor, patch) 
    1116 
    12 #Mark = yaml.error.Mark 
     17Mark = yaml.error.Mark 
    1318YAMLError = yaml.error.YAMLError 
    1419ReaderError = yaml.reader.ReaderError 
     
    5762MappingNode = yaml.nodes.MappingNode 
    5863 
    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  
     64#cdef class Mark: 
     65#    cdef readonly object name 
     66#    cdef readonly int index 
     67#    cdef readonly int line 
     68#    cdef readonly int column 
     69#    cdef readonly buffer 
     70#    cdef readonly pointer 
     71# 
     72#    def __init__(self, object name, int index, int line, int column, 
     73#            object buffer, object pointer): 
     74#        self.name = name 
     75#        self.index = index 
     76#        self.line = line 
     77#        self.column = column 
     78#        self.buffer = buffer 
     79#        self.pointer = pointer 
     80# 
     81#    def get_snippet(self): 
     82#        return None 
     83# 
     84#    def __str__(self): 
     85#        where = "  in \"%s\", line %d, column %d"   \ 
     86#                % (self.name, self.line+1, self.column+1) 
     87#        return where 
     88# 
    8489#class YAMLError(Exception): 
    8590#    pass 
     
    271276                self.stream_name = stream.name 
    272277            except AttributeError: 
    273                 self.stream_name = '<file>' 
     278                if PY_MAJOR_VERSION < 3: 
     279                    self.stream_name = '<file>' 
     280                else: 
     281                    self.stream_name = u'<file>' 
    274282            self.stream_cache = None 
    275283            self.stream_cache_len = 0 
     
    279287            if PyUnicode_CheckExact(stream) != 0: 
    280288                stream = PyUnicode_AsUTF8String(stream) 
    281                 self.stream_name = '<unicode string>' 
     289                if PY_MAJOR_VERSION < 3: 
     290                    self.stream_name = '<unicode string>' 
     291                else: 
     292                    self.stream_name = u'<unicode string>' 
    282293                self.unicode_source = 1 
    283294            else: 
    284                 self.stream_name = '<byte string>' 
     295                if PY_MAJOR_VERSION < 3: 
     296                    self.stream_name = '<byte string>' 
     297                else: 
     298                    self.stream_name = u'<byte string>' 
    285299            if PyString_CheckExact(stream) == 0: 
    286                 raise TypeError("a string or stream input is required") 
     300                if PY_MAJOR_VERSION < 3: 
     301                    raise TypeError("a string or stream input is required") 
     302                else: 
     303                    raise TypeError(u"a string or stream input is required") 
    287304            self.stream = stream 
    288305            yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) 
     
    299316            return MemoryError 
    300317        elif self.parser.error == YAML_READER_ERROR: 
    301             return ReaderError(self.stream_name, self.parser.problem_offset, 
    302                     self.parser.problem_value, '?', self.parser.problem) 
     318            if PY_MAJOR_VERSION < 3: 
     319                return ReaderError(self.stream_name, self.parser.problem_offset, 
     320                        self.parser.problem_value, '?', self.parser.problem) 
     321            else: 
     322                return ReaderError(self.stream_name, self.parser.problem_offset, 
     323                        self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) 
    303324        elif self.parser.error == YAML_SCANNER_ERROR    \ 
    304325                or self.parser.error == YAML_PARSER_ERROR: 
     
    315336                        self.parser.problem_mark.line, 
    316337                        self.parser.problem_mark.column, None, None) 
     338            context = None 
     339            if self.parser.context != NULL: 
     340                if PY_MAJOR_VERSION < 3: 
     341                    context = self.parser.context 
     342                else: 
     343                    context = PyUnicode_FromString(self.parser.context) 
     344            if PY_MAJOR_VERSION < 3: 
     345                problem = self.parser.problem 
     346            else: 
     347                problem = PyUnicode_FromString(self.parser.problem) 
    317348            if self.parser.error == YAML_SCANNER_ERROR: 
    318                 if self.parser.context != NULL: 
    319                     return ScannerError(self.parser.context, context_mark, 
    320                             self.parser.problem, problem_mark) 
    321                 else: 
    322                     return ScannerError(None, None, 
    323                             self.parser.problem, problem_mark) 
    324             else: 
    325                 if self.parser.context != NULL: 
    326                     return ParserError(self.parser.context, context_mark, 
    327                             self.parser.problem, problem_mark) 
    328                 else: 
    329                     return ParserError(None, None, 
    330                             self.parser.problem, problem_mark) 
    331         raise ValueError("no parser error") 
     349                return ScannerError(context, context_mark, problem, problem_mark) 
     350            else: 
     351                return ParserError(context, context_mark, problem, problem_mark) 
     352        if PY_MAJOR_VERSION < 3: 
     353            raise ValueError("no parser error") 
     354        else: 
     355            raise ValueError(u"no parser error") 
    332356 
    333357    def raw_scan(self): 
     
    388412                    start_mark, end_mark) 
    389413        elif token.type == YAML_TAG_DIRECTIVE_TOKEN: 
    390             handle = PyUnicode_DecodeUTF8(token.data.tag_directive.handle, 
    391                     strlen(token.data.tag_directive.handle), 'strict') 
    392             prefix = PyUnicode_DecodeUTF8(token.data.tag_directive.prefix, 
    393                     strlen(token.data.tag_directive.prefix), 'strict') 
     414            handle = PyUnicode_FromString(token.data.tag_directive.handle) 
     415            prefix = PyUnicode_FromString(token.data.tag_directive.prefix) 
    394416            return DirectiveToken(u"TAG", (handle, prefix), 
    395417                    start_mark, end_mark) 
     
    421443            return ValueToken(start_mark, end_mark) 
    422444        elif token.type == YAML_ALIAS_TOKEN: 
    423             value = PyUnicode_DecodeUTF8(token.data.alias.value, 
    424                     strlen(token.data.alias.value), 'strict') 
     445            value = PyUnicode_FromString(token.data.alias.value) 
    425446            return AliasToken(value, start_mark, end_mark) 
    426447        elif token.type == YAML_ANCHOR_TOKEN: 
    427             value = PyUnicode_DecodeUTF8(token.data.anchor.value, 
    428                     strlen(token.data.anchor.value), 'strict') 
     448            value = PyUnicode_FromString(token.data.anchor.value) 
    429449            return AnchorToken(value, start_mark, end_mark) 
    430450        elif token.type == YAML_TAG_TOKEN: 
    431             handle = PyUnicode_DecodeUTF8(token.data.tag.handle, 
    432                     strlen(token.data.tag.handle), 'strict') 
    433             suffix = PyUnicode_DecodeUTF8(token.data.tag.suffix, 
    434                     strlen(token.data.tag.suffix), 'strict') 
     451            handle = PyUnicode_FromString(token.data.tag.handle) 
     452            suffix = PyUnicode_FromString(token.data.tag.suffix) 
    435453            if not handle: 
    436454                handle = None 
     
    443461            if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
    444462                plain = True 
    445                 style = '' 
     463                style = u'' 
    446464            elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
    447                 style = '\'' 
     465                style = u'\'' 
    448466            elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
    449                 style = '"' 
     467                style = u'"' 
    450468            elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
    451                 style = '|' 
     469                style = u'|' 
    452470            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
    453                 style = '>' 
     471                style = u'>' 
    454472            return ScalarToken(value, plain, 
    455473                    start_mark, end_mark, style) 
    456474        else: 
    457             raise ValueError("unknown token type") 
     475            if PY_MAJOR_VERSION < 3: 
     476                raise ValueError("unknown token type") 
     477            else: 
     478                raise ValueError(u"unknown token type") 
    458479 
    459480    def get_token(self): 
     
    527548            if event.data.stream_start.encoding == YAML_UTF8_ENCODING: 
    528549                if self.unicode_source == 0: 
    529                     encoding = "utf-8" 
     550                    encoding = u"utf-8" 
    530551            elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: 
    531                 encoding = "utf-16-le" 
     552                encoding = u"utf-16-le" 
    532553            elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: 
    533                 encoding = "utf-16-be" 
     554                encoding = u"utf-16-be" 
    534555            return StreamStartEvent(start_mark, end_mark, encoding) 
    535556        elif event.type == YAML_STREAM_END_EVENT: 
    536557            return StreamEndEvent(start_mark, end_mark) 
    537  
    538558        elif event.type == YAML_DOCUMENT_START_EVENT: 
    539559            explicit = False 
     
    549569                tag_directive = event.data.document_start.tag_directives.start 
    550570                while tag_directive != event.data.document_start.tag_directives.end: 
    551                     handle = PyUnicode_DecodeUTF8(tag_directive.handle, 
    552                             strlen(tag_directive.handle), 'strict') 
    553                     prefix = PyUnicode_DecodeUTF8(tag_directive.prefix, 
    554                             strlen(tag_directive.prefix), 'strict') 
     571                    handle = PyUnicode_FromString(tag_directive.handle) 
     572                    prefix = PyUnicode_FromString(tag_directive.prefix) 
    555573                    tags[handle] = prefix 
    556574                    tag_directive = tag_directive+1 
     
    563581            return DocumentEndEvent(start_mark, end_mark, explicit) 
    564582        elif event.type == YAML_ALIAS_EVENT: 
    565             anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor, 
    566                     strlen(event.data.alias.anchor), 'strict') 
     583            anchor = PyUnicode_FromString(event.data.alias.anchor) 
    567584            return AliasEvent(anchor, start_mark, end_mark) 
    568585        elif event.type == YAML_SCALAR_EVENT: 
    569586            anchor = None 
    570587            if event.data.scalar.anchor != NULL: 
    571                 anchor = PyUnicode_DecodeUTF8(event.data.scalar.anchor, 
    572                         strlen(event.data.scalar.anchor), 'strict') 
     588                anchor = PyUnicode_FromString(event.data.scalar.anchor) 
    573589            tag = None 
    574590            if event.data.scalar.tag != NULL: 
    575                 tag = PyUnicode_DecodeUTF8(event.data.scalar.tag, 
    576                         strlen(event.data.scalar.tag), 'strict') 
     591                tag = PyUnicode_FromString(event.data.scalar.tag) 
    577592            value = PyUnicode_DecodeUTF8(event.data.scalar.value, 
    578593                    event.data.scalar.length, 'strict') 
     
    585600            style = None 
    586601            if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
    587                 style = '' 
     602                style = u'' 
    588603            elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
    589                 style = '\'' 
     604                style = u'\'' 
    590605            elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
    591                 style = '"' 
     606                style = u'"' 
    592607            elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
    593                 style = '|' 
     608                style = u'|' 
    594609            elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
    595                 style = '>' 
     610                style = u'>' 
    596611            return ScalarEvent(anchor, tag, 
    597612                    (plain_implicit, quoted_implicit), 
     
    600615            anchor = None 
    601616            if event.data.sequence_start.anchor != NULL: 
    602                 anchor = PyUnicode_DecodeUTF8(event.data.sequence_start.anchor, 
    603                         strlen(event.data.sequence_start.anchor), 'strict') 
     617                anchor = PyUnicode_FromString(event.data.sequence_start.anchor) 
    604618            tag = None 
    605619            if event.data.sequence_start.tag != NULL: 
    606                 tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag, 
    607                         strlen(event.data.sequence_start.tag), 'strict') 
     620                tag = PyUnicode_FromString(event.data.sequence_start.tag) 
    608621            implicit = False 
    609622            if event.data.sequence_start.implicit == 1: 
     
    619632            anchor = None 
    620633            if event.data.mapping_start.anchor != NULL: 
    621                 anchor = PyUnicode_DecodeUTF8(event.data.mapping_start.anchor, 
    622                         strlen(event.data.mapping_start.anchor), 'strict') 
     634                anchor = PyUnicode_FromString(event.data.mapping_start.anchor) 
    623635            tag = None 
    624636            if event.data.mapping_start.tag != NULL: 
    625                 tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag, 
    626                         strlen(event.data.mapping_start.tag), 'strict') 
     637                tag = PyUnicode_FromString(event.data.mapping_start.tag) 
    627638            implicit = False 
    628639            if event.data.mapping_start.implicit == 1: 
     
    639650        elif event.type == YAML_MAPPING_END_EVENT: 
    640651            return MappingEndEvent(start_mark, end_mark) 
    641  
    642652        else: 
    643             raise ValueError("unknown token type") 
     653            if PY_MAJOR_VERSION < 3: 
     654                raise ValueError("unknown event type") 
     655            else: 
     656                raise ValueError(u"unknown event type") 
    644657 
    645658    def get_event(self): 
     
    697710                    self.parsed_event.start_mark.column, 
    698711                    None, None) 
    699             raise ComposerError("expected a single document in the stream", 
    700                     document.start_mark, "but found another document", mark) 
     712            if PY_MAJOR_VERSION < 3: 
     713                raise ComposerError("expected a single document in the stream", 
     714                        document.start_mark, "but found another document", mark) 
     715            else: 
     716                raise ComposerError(u"expected a single document in the stream", 
     717                        document.start_mark, u"but found another document", mark) 
    701718        return document 
    702719 
     
    712729        self._parse_next_event() 
    713730        if self.parsed_event.type == YAML_ALIAS_EVENT: 
    714             anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.alias.anchor, 
    715                     strlen(self.parsed_event.data.alias.anchor), 'strict') 
     731            anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) 
    716732            if anchor not in self.anchors: 
    717733                mark = Mark(self.stream_name, 
     
    720736                        self.parsed_event.start_mark.column, 
    721737                        None, None) 
    722                 raise ComposerError(None, None, "found undefined alias", mark) 
     738                if PY_MAJOR_VERSION < 3: 
     739                    raise ComposerError(None, None, "found undefined alias", mark) 
     740                else: 
     741                    raise ComposerError(None, None, u"found undefined alias", mark) 
    723742            yaml_event_delete(&self.parsed_event) 
    724743            return self.anchors[anchor] 
     
    726745        if self.parsed_event.type == YAML_SCALAR_EVENT  \ 
    727746                and self.parsed_event.data.scalar.anchor != NULL: 
    728             anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.anchor, 
    729                     strlen(self.parsed_event.data.scalar.anchor), 'strict') 
     747            anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) 
    730748        elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT    \ 
    731749                and self.parsed_event.data.sequence_start.anchor != NULL: 
    732             anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.anchor, 
    733                     strlen(self.parsed_event.data.sequence_start.anchor), 'strict') 
     750            anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) 
    734751        elif self.parsed_event.type == YAML_MAPPING_START_EVENT    \ 
    735752                and self.parsed_event.data.mapping_start.anchor != NULL: 
    736             anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.anchor, 
    737                     strlen(self.parsed_event.data.mapping_start.anchor), 'strict') 
     753            anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) 
    738754        if anchor is not None: 
    739755            if anchor in self.anchors: 
     
    743759                        self.parsed_event.start_mark.column, 
    744760                        None, None) 
    745                 raise ComposerError("found duplicate anchor; first occurence", 
    746                         self.anchors[anchor].start_mark, "second occurence", mark) 
     761                if PY_MAJOR_VERSION < 3: 
     762                    raise ComposerError("found duplicate anchor; first occurence", 
     763                            self.anchors[anchor].start_mark, "second occurence", mark) 
     764                else: 
     765                    raise ComposerError(u"found duplicate anchor; first occurence", 
     766                            self.anchors[anchor].start_mark, u"second occurence", mark) 
    747767        self.descend_resolver(parent, index) 
    748768        if self.parsed_event.type == YAML_SCALAR_EVENT: 
     
    779799            tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) 
    780800        else: 
    781             tag = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.tag, 
    782                     strlen(self.parsed_event.data.scalar.tag), 'strict') 
     801            tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) 
    783802        style = None 
    784803        if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
    785             style = '' 
     804            style = u'' 
    786805        elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
    787             style = '\'' 
     806            style = u'\'' 
    788807        elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
    789             style = '"' 
     808            style = u'"' 
    790809        elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
    791             style = '|' 
     810            style = u'|' 
    792811        elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
    793             style = '>' 
     812            style = u'>' 
    794813        node = ScalarNode(tag, value, start_mark, end_mark, style) 
    795814        if anchor is not None: 
     
    813832            tag = self.resolve(SequenceNode, None, implicit) 
    814833        else: 
    815             tag = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.tag, 
    816                     strlen(self.parsed_event.data.sequence_start.tag), 'strict') 
     834            tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) 
    817835        flow_style = None 
    818836        if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: 
     
    853871            tag = self.resolve(MappingNode, None, implicit) 
    854872        else: 
    855             tag = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.tag, 
    856                     strlen(self.parsed_event.data.mapping_start.tag), 'strict') 
     873            tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) 
    857874        flow_style = None 
    858875        if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: 
     
    895912            parser.unicode_source = 1 
    896913        if PyString_CheckExact(value) == 0: 
    897             raise TypeError("a string value is expected") 
     914            if PY_MAJOR_VERSION < 3: 
     915                raise TypeError("a string value is expected") 
     916            else: 
     917                raise TypeError(u"a string value is expected") 
    898918        parser.stream_cache = value 
    899919        parser.stream_cache_pos = 0 
     
    977997            return MemoryError 
    978998        elif self.emitter.error == YAML_EMITTER_ERROR: 
    979             return EmitterError(self.emitter.problem) 
    980         raise ValueError("no emitter error") 
     999            if PY_MAJOR_VERSION < 3: 
     1000                problem = self.emitter.problem 
     1001            else: 
     1002                problem = PyUnicode_FromString(self.emitter.problem) 
     1003            return EmitterError(problem) 
     1004        if PY_MAJOR_VERSION < 3: 
     1005            raise ValueError("no emitter error") 
     1006        else: 
     1007            raise ValueError(u"no emitter error") 
    9811008 
    9821009    cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: 
     
    10001027        if event_class is StreamStartEvent: 
    10011028            encoding = YAML_UTF8_ENCODING 
    1002             if event_object.encoding == 'utf-16-le': 
     1029            if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': 
    10031030                encoding = YAML_UTF16LE_ENCODING 
    1004             elif event_object.encoding == 'utf-16-be': 
     1031            elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': 
    10051032                encoding = YAML_UTF16BE_ENCODING 
    10061033            if event_object.encoding is None: 
     
    10211048            if event_object.tags: 
    10221049                if len(event_object.tags) > 128: 
    1023                     raise ValueError("too many tags") 
     1050                    if PY_MAJOR_VERSION < 3: 
     1051                        raise ValueError("too many tags") 
     1052                    else: 
     1053                        raise ValueError(u"too many tags") 
    10241054                tag_directives_start = tag_directives_value 
    10251055                tag_directives_end = tag_directives_value 
     
    10311061                        cache.append(handle) 
    10321062                    if not PyString_CheckExact(handle): 
    1033                         raise TypeError("tag handle must be a string") 
     1063                        if PY_MAJOR_VERSION < 3: 
     1064                            raise TypeError("tag handle must be a string") 
     1065                        else: 
     1066                            raise TypeError(u"tag handle must be a string") 
    10341067                    tag_directives_end.handle = PyString_AS_STRING(handle) 
    10351068                    if PyUnicode_CheckExact(prefix): 
     
    10371070                        cache.append(prefix) 
    10381071                    if not PyString_CheckExact(prefix): 
    1039                         raise TypeError("tag prefix must be a string") 
     1072                        if PY_MAJOR_VERSION < 3: 
     1073                            raise TypeError("tag prefix must be a string") 
     1074                        else: 
     1075                            raise TypeError(u"tag prefix must be a string") 
    10401076                    tag_directives_end.prefix = PyString_AS_STRING(prefix) 
    10411077                    tag_directives_end = tag_directives_end+1 
     
    10571093                anchor_object = PyUnicode_AsUTF8String(anchor_object) 
    10581094            if not PyString_CheckExact(anchor_object): 
    1059                 raise TypeError("anchor must be a string") 
     1095                if PY_MAJOR_VERSION < 3: 
     1096                    raise TypeError("anchor must be a string") 
     1097                else: 
     1098                    raise TypeError(u"anchor must be a string") 
    10601099            anchor = PyString_AS_STRING(anchor_object) 
    10611100            if yaml_alias_event_initialize(event, anchor) == 0: 
     
    10681107                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
    10691108                if not PyString_CheckExact(anchor_object): 
    1070                     raise TypeError("anchor must be a string") 
     1109                    if PY_MAJOR_VERSION < 3: 
     1110                        raise TypeError("anchor must be a string") 
     1111                    else: 
     1112                        raise TypeError(u"anchor must be a string") 
    10711113                anchor = PyString_AS_STRING(anchor_object) 
    10721114            tag = NULL 
     
    10761118                    tag_object = PyUnicode_AsUTF8String(tag_object) 
    10771119                if not PyString_CheckExact(tag_object): 
    1078                     raise TypeError("tag must be a string") 
     1120                    if PY_MAJOR_VERSION < 3: 
     1121                        raise TypeError("tag must be a string") 
     1122                    else: 
     1123                        raise TypeError(u"tag must be a string") 
    10791124                tag = PyString_AS_STRING(tag_object) 
    10801125            value_object = event_object.value 
     
    10821127                value_object = PyUnicode_AsUTF8String(value_object) 
    10831128            if not PyString_CheckExact(value_object): 
    1084                 raise TypeError("value must be a string") 
     1129                if PY_MAJOR_VERSION < 3: 
     1130                    raise TypeError("value must be a string") 
     1131                else: 
     1132                    raise TypeError(u"value must be a string") 
    10851133            value = PyString_AS_STRING(value_object) 
    10861134            length = PyString_GET_SIZE(value_object) 
     
    10921140            style_object = event_object.style 
    10931141            scalar_style = YAML_PLAIN_SCALAR_STYLE 
    1094             if style_object == "'": 
     1142            if style_object == "'" or style_object == u"'": 
    10951143                scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE 
    1096             elif style_object == "\"": 
     1144            elif style_object == "\"" or style_object == u"\"": 
    10971145                scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE 
    1098             elif style_object == "|": 
     1146            elif style_object == "|" or style_object == u"|": 
    10991147                scalar_style = YAML_LITERAL_SCALAR_STYLE 
    1100             elif style_object == ">": 
     1148            elif style_object == ">" or style_object == u">": 
    11011149                scalar_style = YAML_FOLDED_SCALAR_STYLE 
    11021150            if yaml_scalar_event_initialize(event, anchor, tag, value, length, 
     
    11101158                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
    11111159                if not PyString_CheckExact(anchor_object): 
    1112                     raise TypeError("anchor must be a string") 
     1160                    if PY_MAJOR_VERSION < 3: 
     1161                        raise TypeError("anchor must be a string") 
     1162                    else: 
     1163                        raise TypeError(u"anchor must be a string") 
    11131164                anchor = PyString_AS_STRING(anchor_object) 
    11141165            tag = NULL 
     
    11181169                    tag_object = PyUnicode_AsUTF8String(tag_object) 
    11191170                if not PyString_CheckExact(tag_object): 
    1120                     raise TypeError("tag must be a string") 
     1171                    if PY_MAJOR_VERSION < 3: 
     1172                        raise TypeError("tag must be a string") 
     1173                    else: 
     1174                        raise TypeError(u"tag must be a string") 
    11211175                tag = PyString_AS_STRING(tag_object) 
    11221176            implicit = 0 
     
    11361190                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
    11371191                if not PyString_CheckExact(anchor_object): 
    1138                     raise TypeError("anchor must be a string") 
     1192                    if PY_MAJOR_VERSION < 3: 
     1193                        raise TypeError("anchor must be a string") 
     1194                    else: 
     1195                        raise TypeError(u"anchor must be a string") 
    11391196                anchor = PyString_AS_STRING(anchor_object) 
    11401197            tag = NULL 
     
    11441201                    tag_object = PyUnicode_AsUTF8String(tag_object) 
    11451202                if not PyString_CheckExact(tag_object): 
    1146                     raise TypeError("tag must be a string") 
     1203                    if PY_MAJOR_VERSION < 3: 
     1204                        raise TypeError("tag must be a string") 
     1205                    else: 
     1206                        raise TypeError(u"tag must be a string") 
    11471207                tag = PyString_AS_STRING(tag_object) 
    11481208            implicit = 0 
     
    11601220            yaml_mapping_end_event_initialize(event) 
    11611221        else: 
    1162             raise TypeError("invalid event %s" % event_object) 
     1222            if PY_MAJOR_VERSION < 3: 
     1223                raise TypeError("invalid event %s" % event_object) 
     1224            else: 
     1225                raise TypeError(u"invalid event %s" % event_object) 
    11631226        return 1 
    11641227 
     
    11741237        cdef yaml_encoding_t encoding 
    11751238        if self.closed == -1: 
    1176             if self.use_encoding == 'utf-16-le': 
     1239            if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': 
    11771240                encoding = YAML_UTF16LE_ENCODING 
    1178             elif self.use_encoding == 'utf-16-be': 
     1241            elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': 
    11791242                encoding = YAML_UTF16BE_ENCODING 
    11801243            else: 
     
    11901253            self.closed = 0 
    11911254        elif self.closed == 1: 
    1192             raise SerializerError("serializer is closed") 
     1255            if PY_MAJOR_VERSION < 3: 
     1256                raise SerializerError("serializer is closed") 
     1257            else: 
     1258                raise SerializerError(u"serializer is closed") 
    11931259        else: 
    1194             raise SerializerError("serializer is already opened") 
     1260            if PY_MAJOR_VERSION < 3: 
     1261                raise SerializerError("serializer is already opened") 
     1262            else: 
     1263                raise SerializerError(u"serializer is already opened") 
    11951264 
    11961265    def close(self): 
    11971266        cdef yaml_event_t event 
    11981267        if self.closed == -1: 
    1199             raise SerializerError("serializer is not opened") 
     1268            if PY_MAJOR_VERSION < 3: 
     1269                raise SerializerError("serializer is not opened") 
     1270            else: 
     1271                raise SerializerError(u"serializer is not opened") 
    12001272        elif self.closed == 0: 
    12011273            yaml_stream_end_event_initialize(&event) 
     
    12131285        cdef yaml_tag_directive_t *tag_directives_end 
    12141286        if self.closed == -1: 
    1215             raise SerializerError("serializer is not opened") 
     1287            if PY_MAJOR_VERSION < 3: 
     1288                raise SerializerError("serializer is not opened") 
     1289            else: 
     1290                raise SerializerError(u"serializer is not opened") 
    12161291        elif self.closed == 1: 
    1217             raise SerializerError("serializer is closed") 
     1292            if PY_MAJOR_VERSION < 3: 
     1293                raise SerializerError("serializer is closed") 
     1294            else: 
     1295                raise SerializerError(u"serializer is closed") 
    12181296        cache = [] 
    12191297        version_directive = NULL 
     
    12261304        if self.use_tags: 
    12271305            if len(self.use_tags) > 128: 
    1228                 raise ValueError("too many tags") 
     1306                if PY_MAJOR_VERSION < 3: 
     1307                    raise ValueError("too many tags") 
     1308                else: 
     1309                    raise ValueError(u"too many tags") 
    12291310            tag_directives_start = tag_directives_value 
    12301311            tag_directives_end = tag_directives_value 
     
    12351316                    cache.append(handle) 
    12361317                if not PyString_CheckExact(handle): 
    1237                     raise TypeError("tag handle must be a string") 
     1318                    if PY_MAJOR_VERSION < 3: 
     1319                        raise TypeError("tag handle must be a string") 
     1320                    else: 
     1321                        raise TypeError(u"tag handle must be a string") 
    12381322                tag_directives_end.handle = PyString_AS_STRING(handle) 
    12391323                if PyUnicode_CheckExact(prefix): 
     
    12411325                    cache.append(prefix) 
    12421326                if not PyString_CheckExact(prefix): 
    1243                     raise TypeError("tag prefix must be a string") 
     1327                    if PY_MAJOR_VERSION < 3: 
     1328                        raise TypeError("tag prefix must be a string") 
     1329                    else: 
     1330                        raise TypeError(u"tag prefix must be a string") 
    12441331                tag_directives_end.prefix = PyString_AS_STRING(prefix) 
    12451332                tag_directives_end = tag_directives_end+1 
     
    13181405                        tag_object = PyUnicode_AsUTF8String(tag_object) 
    13191406                    if not PyString_CheckExact(tag_object): 
    1320                         raise TypeError("tag must be a string") 
     1407                        if PY_MAJOR_VERSION < 3: 
     1408                            raise TypeError("tag must be a string") 
     1409                        else: 
     1410                            raise TypeError(u"tag must be a string") 
    13211411                    tag = PyString_AS_STRING(tag_object) 
    13221412                value_object = node.value 
     
    13241414                    value_object = PyUnicode_AsUTF8String(value_object) 
    13251415                if not PyString_CheckExact(value_object): 
    1326                     raise TypeError("value must be a string") 
     1416                    if PY_MAJOR_VERSION < 3: 
     1417                        raise TypeError("value must be a string") 
     1418                    else: 
     1419                        raise TypeError(u"value must be a string") 
    13271420                value = PyString_AS_STRING(value_object) 
    13281421                length = PyString_GET_SIZE(value_object) 
    13291422                style_object = node.style 
    13301423                scalar_style = YAML_PLAIN_SCALAR_STYLE 
    1331                 if style_object == "'": 
     1424                if style_object == "'" or style_object == u"'": 
    13321425                    scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE 
    1333                 elif style_object == "\"": 
     1426                elif style_object == "\"" or style_object == u"\"": 
    13341427                    scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE 
    1335                 elif style_object == "|": 
     1428                elif style_object == "|" or style_object == u"|": 
    13361429                    scalar_style = YAML_LITERAL_SCALAR_STYLE 
    1337                 elif style_object == ">": 
     1430                elif style_object == ">" or style_object == u">": 
    13381431                    scalar_style = YAML_FOLDED_SCALAR_STYLE 
    13391432                if yaml_scalar_event_initialize(&event, anchor, tag, value, length, 
     
    13531446                        tag_object = PyUnicode_AsUTF8String(tag_object) 
    13541447                    if not PyString_CheckExact(tag_object): 
    1355                         raise TypeError("tag must be a string") 
     1448                        if PY_MAJOR_VERSION < 3: 
     1449                            raise TypeError("tag must be a string") 
     1450                        else: 
     1451                            raise TypeError(u"tag must be a string") 
    13561452                    tag = PyString_AS_STRING(tag_object) 
    13571453                sequence_style = YAML_BLOCK_SEQUENCE_STYLE 
     
    13821478                        tag_object = PyUnicode_AsUTF8String(tag_object) 
    13831479                    if not PyString_CheckExact(tag_object): 
    1384                         raise TypeError("tag must be a string") 
     1480                        if PY_MAJOR_VERSION < 3: 
     1481                            raise TypeError("tag must be a string") 
     1482                        else: 
     1483                            raise TypeError(u"tag must be a string") 
    13851484                    tag = PyString_AS_STRING(tag_object) 
    13861485                mapping_style = YAML_BLOCK_MAPPING_STYLE 
Note: See TracChangeset for help on using the changeset viewer.