Changeset 223


Ignore:
Timestamp:
08/13/06 09:46:20 (8 years ago)
Author:
xi
Message:

Completely rewrite the libyaml bindings.

Location:
pyyaml/trunk
Files:
1 added
6 edited
1 moved

Legend:

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

    r209 r223  
    22cdef extern from "_yaml.h": 
    33 
     4    void malloc(int l) 
    45    void memcpy(char *d, char *s, int l) 
    56    int strlen(char *s) 
     
    1213    object PyUnicode_AsUTF8String(object o) 
    1314 
    14     cdef enum yaml_encoding_t: 
     15    ctypedef enum: 
     16        SIZEOF_VOID_P 
     17    ctypedef enum yaml_encoding_t: 
    1518        YAML_ANY_ENCODING 
    1619        YAML_UTF8_ENCODING 
    1720        YAML_UTF16LE_ENCODING 
    1821        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: 
    2028        YAML_NO_ERROR 
    2129        YAML_MEMORY_ERROR 
     
    2533        YAML_WRITER_ERROR 
    2634        YAML_EMITTER_ERROR 
    27     cdef enum yaml_scalar_style_t: 
     35    ctypedef enum yaml_scalar_style_t: 
    2836        YAML_ANY_SCALAR_STYLE 
    2937        YAML_PLAIN_SCALAR_STYLE 
     
    3240        YAML_LITERAL_SCALAR_STYLE 
    3341        YAML_FOLDED_SCALAR_STYLE 
    34     cdef enum yaml_sequence_style_t: 
     42    ctypedef enum yaml_sequence_style_t: 
    3543        YAML_ANY_SEQUENCE_STYLE 
    3644        YAML_BLOCK_SEQUENCE_STYLE 
    3745        YAML_FLOW_SEQUENCE_STYLE 
    38     cdef enum yaml_mapping_style_t: 
     46    ctypedef enum yaml_mapping_style_t: 
    3947        YAML_ANY_MAPPING_STYLE 
    4048        YAML_BLOCK_MAPPING_STYLE 
    4149        YAML_FLOW_MAPPING_STYLE 
    42     cdef enum yaml_token_type_t: 
     50    ctypedef enum yaml_token_type_t: 
    4351        YAML_NO_TOKEN 
    4452        YAML_STREAM_START_TOKEN 
     
    6371        YAML_TAG_TOKEN 
    6472        YAML_SCALAR_TOKEN 
    65     cdef enum yaml_event_type_t: 
     73    ctypedef enum yaml_event_type_t: 
    6674        YAML_NO_EVENT 
    6775        YAML_STREAM_START_EVENT 
     
    7886    ctypedef int yaml_read_handler_t(void *data, char *buffer, 
    7987            int size, int *size_read) except 0 
     88 
     89    ctypedef int yaml_write_handler_t(void *data, char *buffer, 
     90            int size) except 0 
    8091 
    8192    ctypedef struct yaml_mark_t: 
     
    125136    ctypedef struct _yaml_event_stream_start_data_t: 
    126137        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 
    127141    ctypedef struct _yaml_event_document_start_data_t: 
    128142        yaml_version_directive_t *version_directive 
    129         yaml_tag_directive_t **tag_directives 
     143        _yaml_event_document_start_data_tag_directives_t tag_directives 
    130144        int implicit 
    131145    ctypedef struct _yaml_event_document_end_data_t: 
     
    174188        yaml_mark_t context_mark 
    175189 
     190    ctypedef struct yaml_emitter_t: 
     191        yaml_error_type_t error 
     192        char *problem 
     193 
    176194    char *yaml_get_version_string() 
    177195    void yaml_get_version(int *major, int *minor, int *patch) 
     196 
    178197    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) 
    179220    void yaml_event_delete(yaml_event_t *event) 
     221 
    180222    int yaml_parser_initialize(yaml_parser_t *parser) 
    181223    void yaml_parser_delete(yaml_parser_t *parser) 
     
    189231    int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except * 
    190232 
     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  
    1010    return (major, minor, patch) 
    1111 
    12 def test_scanner(stream): 
     12#Mark = yaml.error.Mark 
     13YAMLError = yaml.error.YAMLError 
     14ReaderError = yaml.reader.ReaderError 
     15ScannerError = yaml.scanner.ScannerError 
     16ParserError = yaml.parser.ParserError 
     17ComposerError = yaml.composer.ComposerError 
     18ConstructorError = yaml.constructor.ConstructorError 
     19EmitterError = yaml.emitter.EmitterError 
     20SerializerError = yaml.serializer.SerializerError 
     21RepresenterError = yaml.representer.RepresenterError 
     22 
     23StreamStartToken = yaml.tokens.StreamStartToken 
     24StreamEndToken = yaml.tokens.StreamEndToken 
     25DirectiveToken = yaml.tokens.DirectiveToken 
     26DocumentStartToken = yaml.tokens.DocumentStartToken 
     27DocumentEndToken = yaml.tokens.DocumentEndToken 
     28BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken 
     29BlockMappingStartToken = yaml.tokens.BlockMappingStartToken 
     30BlockEndToken = yaml.tokens.BlockEndToken 
     31FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken 
     32FlowMappingStartToken = yaml.tokens.FlowMappingStartToken 
     33FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken 
     34FlowMappingEndToken = yaml.tokens.FlowMappingEndToken 
     35KeyToken = yaml.tokens.KeyToken 
     36ValueToken = yaml.tokens.ValueToken 
     37BlockEntryToken = yaml.tokens.BlockEntryToken 
     38FlowEntryToken = yaml.tokens.FlowEntryToken 
     39AliasToken = yaml.tokens.AliasToken 
     40AnchorToken = yaml.tokens.AnchorToken 
     41TagToken = yaml.tokens.TagToken 
     42ScalarToken = yaml.tokens.ScalarToken 
     43 
     44StreamStartEvent = yaml.events.StreamStartEvent 
     45StreamEndEvent = yaml.events.StreamEndEvent 
     46DocumentStartEvent = yaml.events.DocumentStartEvent 
     47DocumentEndEvent = yaml.events.DocumentEndEvent 
     48AliasEvent = yaml.events.AliasEvent 
     49ScalarEvent = yaml.events.ScalarEvent 
     50SequenceStartEvent = yaml.events.SequenceStartEvent 
     51SequenceEndEvent = yaml.events.SequenceEndEvent 
     52MappingStartEvent = yaml.events.MappingStartEvent 
     53MappingEndEvent = yaml.events.MappingEndEvent 
     54 
     55ScalarNode = yaml.nodes.ScalarNode 
     56SequenceNode = yaml.nodes.SequenceNode 
     57MappingNode = yaml.nodes.MappingNode 
     58 
     59cdef 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 
     242cdef class CParser: 
     243 
    13244    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 
    71246 
    72247    cdef object stream 
     248    cdef object stream_name 
    73249    cdef object current_token 
    74250    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 
    113252 
    114253    def __init__(self, stream): 
    115254        if yaml_parser_initialize(&self.parser) == 0: 
    116255            raise MemoryError 
     256        self.parsed_event.type = YAML_NO_EVENT 
    117257        if hasattr(stream, 'read'): 
    118258            self.stream = stream 
     259            try: 
     260                self.stream_name = stream.name 
     261            except AttributeError: 
     262                self.stream_name = '<file>' 
    119263            yaml_parser_set_input(&self.parser, input_handler, <void *>self) 
    120264        else: 
    121265            if PyUnicode_CheckExact(stream) != 0: 
    122266                stream = PyUnicode_AsUTF8String(stream) 
     267                self.stream_name = '<unicode string>' 
     268            else: 
     269                self.stream_name = '<string>' 
    123270            if PyString_CheckExact(stream) == 0: 
    124271                raise TypeError("a string or stream input is required") 
     
    126273            yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) 
    127274        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 = {} 
    181277 
    182278    def __dealloc__(self): 
    183279        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 
    224334 
    225335    cdef object _scan(self): 
    226336        cdef yaml_token_t token 
    227337        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, 
    258346                token.start_mark.index, 
    259347                token.start_mark.line, 
    260348                token.start_mark.column, 
    261349                None, None) 
    262         end_mark = yaml.Mark(self.cached_input, 
     350        end_mark = Mark(self.stream_name, 
    263351                token.end_mark.index, 
    264352                token.end_mark.line, 
     
    268356            return None 
    269357        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) 
    271366        elif token.type == YAML_STREAM_END_TOKEN: 
    272             return self.cached_StreamEndToken(start_mark, end_mark) 
     367            return StreamEndToken(start_mark, end_mark) 
    273368        elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: 
    274             return self.cached_DirectiveToken(self.cached_YAML, 
     369            return DirectiveToken("YAML", 
    275370                    (token.data.version_directive.major, 
    276371                        token.data.version_directive.minor), 
    277372                    start_mark, end_mark) 
    278373        elif token.type == YAML_TAG_DIRECTIVE_TOKEN: 
    279             return self.cached_DirectiveToken(self.cached_TAG, 
     374            return DirectiveToken("TAG", 
    280375                    (token.data.tag_directive.handle, 
    281376                        token.data.tag_directive.prefix), 
    282377                    start_mark, end_mark) 
    283378        elif token.type == YAML_DOCUMENT_START_TOKEN: 
    284             return self.cached_DocumentStartToken(start_mark, end_mark) 
     379            return DocumentStartToken(start_mark, end_mark) 
    285380        elif token.type == YAML_DOCUMENT_END_TOKEN: 
    286             return self.cached_DocumentEndToken(start_mark, end_mark) 
     381            return DocumentEndToken(start_mark, end_mark) 
    287382        elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: 
    288             return self.cached_BlockSequenceStartToken(start_mark, end_mark) 
     383            return BlockSequenceStartToken(start_mark, end_mark) 
    289384        elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: 
    290             return self.cached_BlockMappingStartToken(start_mark, end_mark) 
     385            return BlockMappingStartToken(start_mark, end_mark) 
    291386        elif token.type == YAML_BLOCK_END_TOKEN: 
    292             return self.cached_BlockEndToken(start_mark, end_mark) 
     387            return BlockEndToken(start_mark, end_mark) 
    293388        elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: 
    294             return self.cached_FlowSequenceStartToken(start_mark, end_mark) 
     389            return FlowSequenceStartToken(start_mark, end_mark) 
    295390        elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: 
    296             return self.cached_FlowSequenceEndToken(start_mark, end_mark) 
     391            return FlowSequenceEndToken(start_mark, end_mark) 
    297392        elif token.type == YAML_FLOW_MAPPING_START_TOKEN: 
    298             return self.cached_FlowMappingStartToken(start_mark, end_mark) 
     393            return FlowMappingStartToken(start_mark, end_mark) 
    299394        elif token.type == YAML_FLOW_MAPPING_END_TOKEN: 
    300             return self.cached_FlowMappingEndToken(start_mark, end_mark) 
     395            return FlowMappingEndToken(start_mark, end_mark) 
    301396        elif token.type == YAML_BLOCK_ENTRY_TOKEN: 
    302             return self.cached_BlockEntryToken(start_mark, end_mark) 
     397            return BlockEntryToken(start_mark, end_mark) 
    303398        elif token.type == YAML_FLOW_ENTRY_TOKEN: 
    304             return self.cached_FlowEntryToken(start_mark, end_mark) 
     399            return FlowEntryToken(start_mark, end_mark) 
    305400        elif token.type == YAML_KEY_TOKEN: 
    306             return self.cached_KeyToken(start_mark, end_mark) 
     401            return KeyToken(start_mark, end_mark) 
    307402        elif token.type == YAML_VALUE_TOKEN: 
    308             return self.cached_ValueToken(start_mark, end_mark) 
     403            return ValueToken(start_mark, end_mark) 
    309404        elif token.type == YAML_ALIAS_TOKEN: 
    310405            value = PyUnicode_DecodeUTF8(token.data.alias.value, 
    311406                    strlen(token.data.alias.value), 'strict') 
    312             return self.cached_AliasToken(value, start_mark, end_mark) 
     407            return AliasToken(value, start_mark, end_mark) 
    313408        elif token.type == YAML_ANCHOR_TOKEN: 
    314409            value = PyUnicode_DecodeUTF8(token.data.anchor.value, 
    315410                    strlen(token.data.anchor.value), 'strict') 
    316             return self.cached_AnchorToken(value, start_mark, end_mark) 
     411            return AnchorToken(value, start_mark, end_mark) 
    317412        elif token.type == YAML_TAG_TOKEN: 
    318413            handle = PyUnicode_DecodeUTF8(token.data.tag.handle, 
     
    322417            if not handle: 
    323418                handle = None 
    324             return self.cached_TagToken((handle, suffix), start_mark, end_mark) 
     419            return TagToken((handle, suffix), start_mark, end_mark) 
    325420        elif token.type == YAML_SCALAR_TOKEN: 
    326421            value = PyUnicode_DecodeUTF8(token.data.scalar.value, 
     
    339434            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
    340435                style = '>' 
    341             return self.cached_ScalarToken(value, plain, 
     436            return ScalarToken(value, plain, 
    342437                    start_mark, end_mark, style) 
    343438        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 
    345483 
    346484    cdef object _parse(self): 
    347485        cdef yaml_event_t event 
    348486        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, 
    389496                event.start_mark.index, 
    390497                event.start_mark.line, 
    391498                event.start_mark.column, 
    392499                None, None) 
    393         end_mark = yaml.Mark(self.cached_input, 
     500        end_mark = Mark(self.stream_name, 
    394501                event.end_mark.index, 
    395502                event.end_mark.line, 
     
    399506            return None 
    400507        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) 
    402516        elif event.type == YAML_STREAM_END_EVENT: 
    403             return self.cached_StreamEndEvent(start_mark, end_mark) 
     517            return StreamEndEvent(start_mark, end_mark) 
     518 
    404519        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) 
    406540        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) 
    408545        elif event.type == YAML_ALIAS_EVENT: 
    409546            anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor, 
    410547                    strlen(event.data.alias.anchor), 'strict') 
    411             return self.cached_AliasEvent(anchor, start_mark, end_mark) 
     548            return AliasEvent(anchor, start_mark, end_mark) 
    412549        elif event.type == YAML_SCALAR_EVENT: 
    413550            anchor = None 
     
    421558            value = PyUnicode_DecodeUTF8(event.data.scalar.value, 
    422559                    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 
    425566            style = None 
    426567            if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
     
    434575            elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
    435576                style = '>' 
    436             return self.cached_ScalarEvent(anchor, tag, 
     577            return ScalarEvent(anchor, tag, 
    437578                    (plain_implicit, quoted_implicit), 
    438579                    value, start_mark, end_mark, style) 
     
    446587                tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag, 
    447588                        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 
    449592            flow_style = None 
    450593            if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: 
     
    452595            elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
    453596                flow_style = False 
    454             return self.cached_SequenceStartEvent(anchor, tag, implicit, 
     597            return SequenceStartEvent(anchor, tag, implicit, 
    455598                    start_mark, end_mark, flow_style) 
    456599        elif event.type == YAML_MAPPING_START_EVENT: 
     
    463606                tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag, 
    464607                        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 
    466611            flow_style = None 
    467612            if event.data.mapping_start.style == YAML_FLOW_SEQUENCE_STYLE: 
     
    469614            elif event.data.mapping_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
    470615                flow_style = False 
    471             return self.cached_MappingStartEvent(anchor, tag, implicit, 
     616            return MappingStartEvent(anchor, tag, implicit, 
    472617                    start_mark, end_mark, flow_style) 
    473618        elif event.type == YAML_SEQUENCE_END_EVENT: 
    474             return self.cached_SequenceEndEvent(start_mark, end_mark) 
     619            return SequenceEndEvent(start_mark, end_mark) 
    475620        elif event.type == YAML_MAPPING_END_EVENT: 
    476             return self.cached_MappingEndEvent(start_mark, end_mark) 
     621            return MappingEndEvent(start_mark, end_mark) 
     622 
    477623        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 
    479850 
    480851cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: 
    481     cdef ScannerAndParser parser 
    482     parser = <ScannerAndParser>data 
     852    cdef CParser parser 
     853    parser = <CParser>data 
    483854    value = parser.stream.read(size) 
    484855    if PyString_CheckExact(value) == 0: 
     
    490861    return 1 
    491862 
    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  
     863cdef 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 
     1338cdef 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  
    88from loader import * 
    99from dumper import * 
     10 
     11try: 
     12    from cyaml import * 
     13except ImportError: 
     14    pass 
    1015 
    1116def scan(stream, Loader=Loader): 
  • pyyaml/trunk/lib/yaml/composer.py

    r222 r223  
    3838        self.get_event() 
    3939 
    40         self.complete_anchors = {} 
     40        self.anchors = {} 
    4141        return node 
    4242 
  • pyyaml/trunk/lib/yaml/resolver.py

    r222 r223  
    7575 
    7676    def descend_resolver(self, current_node, current_index): 
     77        if not self.yaml_path_resolvers: 
     78            return 
    7779        exact_paths = {} 
    7880        prefix_paths = [] 
     
    9698 
    9799    def ascend_resolver(self): 
     100        if not self.yaml_path_resolvers: 
     101            return 
    98102        self.resolver_exact_paths.pop() 
    99103        self.resolver_prefix_paths.pop() 
     
    132136                    return tag 
    133137            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] 
    139144        if kind is ScalarNode: 
    140145            return self.DEFAULT_SCALAR_TAG 
  • pyyaml/trunk/tests/test_yaml_ext.py

    r209 r223  
    44import _yaml, yaml 
    55 
    6 class TestExtVersion(unittest.TestCase): 
     6class TestCVersion(unittest.TestCase): 
    77 
    8     def testExtVersion(self): 
     8    def testCVersion(self): 
    99        self.failUnlessEqual("%s.%s.%s" % _yaml.get_version(), _yaml.get_version_string()) 
    1010 
    11 class TestExtLoader(test_appliance.TestAppliance): 
     11class TestCLoader(test_appliance.TestAppliance): 
    1212 
    13     def _testExtScannerFileInput(self, test_name, data_filename, canonical_filename): 
    14         self._testExtScanner(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) 
    1515 
    16     def _testExtScanner(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): 
    1717        if file_input: 
    1818            data = file(data_filename, 'r') 
    1919        else: 
    2020            data = file(data_filename, 'r').read() 
    21         tokens = list(yaml.scan(data)) 
     21        tokens = list(yaml.scan(data, Loader=Loader)) 
    2222        ext_tokens = [] 
    2323        try: 
    2424            if file_input: 
    2525                data = file(data_filename, 'r') 
    26             for token in yaml.scan(data, Loader=yaml.ExtLoader): 
     26            for token in yaml.scan(data, Loader=yaml.CLoader): 
    2727                ext_tokens.append(token) 
    2828            self.failUnlessEqual(len(tokens), len(ext_tokens)) 
     
    4343            raise 
    4444 
    45     def _testExtParser(self, test_name, data_filename, canonical_filename): 
     45    def _testCParser(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader): 
    4646        data = file(data_filename, 'r').read() 
    47         events = list(yaml.parse(data)) 
     47        events = list(yaml.parse(data, Loader=Loader)) 
    4848        ext_events = [] 
    4949        try: 
    50             for event in yaml.parse(data, Loader=yaml.ExtLoader): 
     50            for event in yaml.parse(data, Loader=yaml.CLoader): 
    5151                ext_events.append(event) 
    5252                #print "EVENT:", event 
     
    6262                if hasattr(event, 'value'): 
    6363                    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) 
    6470        except: 
    6571            print 
     
    7076            raise 
    7177 
    72 TestExtLoader.add_tests('testExtScanner', '.data', '.canonical') 
    73 TestExtLoader.add_tests('testExtScannerFileInput', '.data', '.canonical') 
    74 TestExtLoader.add_tests('testExtParser', '.data', '.canonical') 
     78TestCLoader.add_tests('testCScanner', '.data', '.canonical') 
     79TestCLoader.add_tests('testCScannerFileInput', '.data', '.canonical') 
     80TestCLoader.add_tests('testCParser', '.data', '.canonical') 
     81 
     82class 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 
     120TestCEmitter.add_tests('testCEmitter', '.data', '.canonical') 
     121 
     122yaml.BaseLoader = yaml.CBaseLoader 
     123yaml.SafeLoader = yaml.CSafeLoader 
     124yaml.Loader = yaml.CLoader 
     125yaml.BaseDumper = yaml.CBaseDumper 
     126yaml.SafeDumper = yaml.CSafeDumper 
     127yaml.Dumper = yaml.CDumper 
     128old_scan = yaml.scan 
     129def scan(stream, Loader=yaml.CLoader): 
     130    return old_scan(stream, Loader) 
     131yaml.scan = scan 
     132old_parse = yaml.parse 
     133def parse(stream, Loader=yaml.CLoader): 
     134    return old_parse(stream, Loader) 
     135yaml.parse = parse 
     136old_compose = yaml.compose 
     137def compose(stream, Loader=yaml.CLoader): 
     138    return old_compose(stream, Loader) 
     139yaml.compose = compose 
     140old_compose_all = yaml.compose_all 
     141def compose_all(stream, Loader=yaml.CLoader): 
     142    return old_compose_all(stream, Loader) 
     143yaml.compose_all = compose_all 
     144old_load_all = yaml.load_all 
     145def load_all(stream, Loader=yaml.CLoader): 
     146    return old_load_all(stream, Loader) 
     147yaml.load_all = load_all 
     148old_load = yaml.load 
     149def load(stream, Loader=yaml.CLoader): 
     150    return old_load(stream, Loader) 
     151yaml.load = load 
     152def safe_load_all(stream): 
     153    return yaml.load_all(stream, yaml.CSafeLoader) 
     154yaml.safe_load_all = safe_load_all 
     155def safe_load(stream): 
     156    return yaml.load(stream, yaml.CSafeLoader) 
     157yaml.safe_load = safe_load 
     158old_emit = yaml.emit 
     159def emit(events, stream=None, Dumper=yaml.CDumper, **kwds): 
     160    return old_emit(events, stream, Dumper, **kwds) 
     161yaml.emit = emit 
     162old_serialize_all = yaml.serialize_all 
     163def serialize_all(nodes, stream=None, Dumper=yaml.CDumper, **kwds): 
     164    return old_serialize_all(nodes, stream, Dumper, **kwds) 
     165yaml.serialize_all = serialize_all 
     166old_serialize = yaml.serialize 
     167def serialize(node, stream, Dumper=yaml.CDumper, **kwds): 
     168    return old_serialize(node, stream, Dumper, **kwds) 
     169yaml.serialize = serialize 
     170old_dump_all = yaml.dump_all 
     171def dump_all(documents, stream=None, Dumper=yaml.CDumper, **kwds): 
     172    return old_dump_all(documents, stream, Dumper, **kwds) 
     173yaml.dump_all = dump_all 
     174old_dump = yaml.dump 
     175def dump(data, stream=None, Dumper=yaml.CDumper, **kwds): 
     176    return old_dump(data, stream, Dumper, **kwds) 
     177yaml.dump = dump 
     178def safe_dump_all(documents, stream=None, **kwds): 
     179    return yaml.dump_all(documents, stream, yaml.CSafeDumper, **kwds) 
     180yaml.safe_dump_all = safe_dump_all 
     181def safe_dump(data, stream=None, **kwds): 
     182    return yaml.dump(data, stream, yaml.CSafeDumper, **kwds) 
     183yaml.safe_dump = safe_dump 
     184 
     185from test_yaml import * 
    75186 
    76187def main(module='__main__'): 
Note: See TracChangeset for help on using the changeset viewer.