Changeset 209


Ignore:
Timestamp:
07/21/06 09:52:03 (8 years ago)
Author:
xi
Message:

Update libyaml bindings.

Location:
pyyaml/trunk
Files:
3 edited

Legend:

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

    r205 r209  
    22cdef extern from "_yaml.h": 
    33 
     4    void memcpy(char *d, char *s, int l) 
     5    int strlen(char *s) 
    46    int PyString_CheckExact(object o) 
    57    int PyUnicode_CheckExact(object o) 
     
    79    int PyString_GET_SIZE(object o) 
    810    object PyString_FromStringAndSize(char *v, int l) 
     11    object PyUnicode_DecodeUTF8(char *s, int s, char *e) 
     12    object PyUnicode_AsUTF8String(object o) 
    913 
    1014    cdef enum yaml_encoding_t: 
     
    3741        YAML_FLOW_MAPPING_STYLE 
    3842    cdef enum yaml_token_type_t: 
     43        YAML_NO_TOKEN 
    3944        YAML_STREAM_START_TOKEN 
    4045        YAML_STREAM_END_TOKEN 
     
    5964        YAML_SCALAR_TOKEN 
    6065    cdef enum yaml_event_type_t: 
     66        YAML_NO_EVENT 
    6167        YAML_STREAM_START_EVENT 
    6268        YAML_STREAM_END_EVENT 
     
    7177 
    7278    ctypedef int yaml_read_handler_t(void *data, char *buffer, 
    73             int size, int *size_read) 
     79            int size, int *size_read) except 0 
    7480 
    7581    ctypedef struct yaml_mark_t: 
     
    172178    void yaml_token_delete(yaml_token_t *token) 
    173179    void yaml_event_delete(yaml_event_t *event) 
    174     yaml_parser_t *yaml_parser_new() 
     180    int yaml_parser_initialize(yaml_parser_t *parser) 
    175181    void yaml_parser_delete(yaml_parser_t *parser) 
    176182    void yaml_parser_set_input_string(yaml_parser_t *parser, 
     
    180186    void yaml_parser_set_encoding(yaml_parser_t *parser, 
    181187            yaml_encoding_t encoding) 
    182     yaml_token_t *yaml_parser_get_token(yaml_parser_t *parser) 
    183     yaml_token_t *yaml_parser_peek_token(yaml_parser_t *parser) 
    184     yaml_event_t *yaml_parser_get_event(yaml_parser_t *parser) 
    185     yaml_event_t *yaml_parser_peek_event(yaml_parser_t *parser) 
     188    int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) except * 
     189    int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except * 
    186190 
  • pyyaml/trunk/ext/_yaml.pyx

    r205 r209  
    1010    return (major, minor, patch) 
    1111 
    12 def test_scanner(data): 
    13     cdef yaml_parser_t *parser 
    14     cdef yaml_token_t *token 
     12def test_scanner(stream): 
     13    cdef yaml_parser_t parser 
     14    cdef yaml_token_t token 
    1515    cdef int done 
    16     if PyString_CheckExact(data) == 0: 
    17         raise TypeError("string input required") 
    18     parser = yaml_parser_new() 
    19     if parser == NULL: 
    20         raise MemoryError 
    21     yaml_parser_set_input_string(parser, PyString_AS_STRING(data), PyString_GET_SIZE(data)) 
     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)) 
    2226    done = 0 
     27    count = 0 
    2328    while done == 0: 
    24         token = yaml_parser_get_token(parser) 
    25         if token == NULL: 
     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 
     40def 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 
     68cdef class ScannerAndParser: 
     69 
     70    cdef yaml_parser_t parser 
     71 
     72    cdef object stream 
     73    cdef object current_token 
     74    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 
     113 
     114    def __init__(self, stream): 
     115        if yaml_parser_initialize(&self.parser) == 0: 
    26116            raise MemoryError 
    27         if token.type == YAML_STREAM_END_TOKEN: 
    28             done = 1 
    29         yaml_token_delete(token) 
    30     yaml_parser_delete(parser) 
    31  
    32 def test_parser(data): 
    33     cdef yaml_parser_t *parser 
    34     cdef yaml_event_t *event 
    35     cdef int done 
    36     if PyString_CheckExact(data) == 0: 
    37         raise TypeError("string input required") 
    38     parser = yaml_parser_new() 
    39     if parser == NULL: 
    40         raise MemoryError 
    41     yaml_parser_set_input_string(parser, PyString_AS_STRING(data), PyString_GET_SIZE(data)) 
    42     done = 0 
    43     while done == 0: 
    44         event = yaml_parser_get_event(parser) 
    45         if event == NULL: 
    46             raise MemoryError 
    47         if event.type == YAML_STREAM_END_EVENT: 
    48             done = 1 
    49         yaml_event_delete(event) 
    50     yaml_parser_delete(parser) 
    51  
    52 cdef class ScannerAndParser: 
    53  
    54     cdef yaml_parser_t *parser 
    55     cdef int eof 
    56     cdef object stream 
    57     cdef yaml_token_t *cached_token 
    58     cdef yaml_event_t *cached_event 
    59     cdef object cached_obj 
    60  
    61     def __init__(self, stream): 
    62117        if hasattr(stream, 'read'): 
    63             stream = stream.read() 
    64         if PyUnicode_CheckExact(stream) != 0: 
    65             stream = stream.encode('utf-8') 
    66         if PyString_CheckExact(stream) == 0: 
    67             raise TypeError("a string or stream input is required") 
    68         self.parser = yaml_parser_new() 
    69         if self.parser == NULL: 
    70             raise MemoryError 
    71         yaml_parser_set_input_string(self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) 
    72         self.eof = 0 
    73         self.stream = stream 
    74         self.cached_token = NULL 
    75         self.cached_obj = None 
     118            self.stream = stream 
     119            yaml_parser_set_input(&self.parser, input_handler, <void *>self) 
     120        else: 
     121            if PyUnicode_CheckExact(stream) != 0: 
     122                stream = PyUnicode_AsUTF8String(stream) 
     123            if PyString_CheckExact(stream) == 0: 
     124                raise TypeError("a string or stream input is required") 
     125            self.stream = stream 
     126            yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) 
     127        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 
    76181 
    77182    def __dealloc__(self): 
    78         if self.parser != NULL: 
    79             yaml_parser_delete(self.parser) 
    80             self.parser = NULL 
    81  
    82     cdef object _convert_token(self, yaml_token_t *token): 
    83         if token == NULL: 
     183        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 
     224 
     225    cdef object _scan(self): 
     226        cdef yaml_token_t token 
     227        if yaml_parser_scan(&self.parser, &token) == 0: 
    84228            if self.parser.error == YAML_MEMORY_ERROR: 
    85229                raise MemoryError 
    86230            elif self.parser.error == YAML_READER_ERROR: 
    87                 raise yaml.reader.ReaderError("<input>", 
     231                raise self.cached_ReaderError(self.cached_input, 
    88232                        self.parser.problem_offset, 
    89233                        self.parser.problem_value, 
    90                         '?', self.parser.problem) 
     234                        self.cached_question, self.parser.problem) 
    91235            elif self.parser.error == YAML_SCANNER_ERROR: 
     236                context_mark = None 
     237                problem_mark = None 
    92238                if self.parser.context != NULL: 
    93                     raise yaml.scanner.ScannerError( 
    94                             self.parser.context, 
    95                             yaml.Mark("<input>", 
    96                                 self.parser.context_mark.index, 
    97                                 self.parser.context_mark.line, 
    98                                 self.parser.context_mark.column, 
    99                                 None, None), 
    100                             self.parser.problem, 
    101                             yaml.Mark("<input>", 
    102                                 self.parser.problem_mark.index, 
    103                                 self.parser.problem_mark.line, 
    104                                 self.parser.problem_mark.column, 
    105                                 None, None)) 
     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) 
    106254                else: 
    107255                    raise yaml.scanner.ScannerError(None, None, 
    108                             self.parser.problem, 
    109                             yaml.Mark("<input>", 
    110                                 self.parser.problem_mark.index, 
    111                                 self.parser.problem_mark.line, 
    112                                 self.parser.problem_mark.column, 
    113                                 None, None)) 
    114             else: 
    115                 raise RuntimeError("neither error nor token produced") 
    116         start_mark = yaml.Mark("<input>", 
     256                            self.parser.problem, problem_mark) 
     257        start_mark = yaml.Mark(self.cached_input, 
    117258                token.start_mark.index, 
    118259                token.start_mark.line, 
    119260                token.start_mark.column, 
    120261                None, None) 
    121         end_mark = yaml.Mark("<input>", 
     262        end_mark = yaml.Mark(self.cached_input, 
    122263                token.end_mark.index, 
    123264                token.end_mark.line, 
    124265                token.end_mark.column, 
    125266                None, None) 
    126         if token.type == YAML_STREAM_START_TOKEN: 
    127             return yaml.StreamStartToken(start_mark, end_mark) 
     267        if token.type == YAML_NO_TOKEN: 
     268            return None 
     269        elif token.type == YAML_STREAM_START_TOKEN: 
     270            return self.cached_StreamStartToken(start_mark, end_mark) 
    128271        elif token.type == YAML_STREAM_END_TOKEN: 
    129             return yaml.StreamEndToken(start_mark, end_mark) 
     272            return self.cached_StreamEndToken(start_mark, end_mark) 
    130273        elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: 
    131             return yaml.DirectiveToken('YAML', 
     274            return self.cached_DirectiveToken(self.cached_YAML, 
    132275                    (token.data.version_directive.major, 
    133276                        token.data.version_directive.minor), 
    134277                    start_mark, end_mark) 
    135278        elif token.type == YAML_TAG_DIRECTIVE_TOKEN: 
    136             return yaml.DirectiveToken('TAG', 
     279            return self.cached_DirectiveToken(self.cached_TAG, 
    137280                    (token.data.tag_directive.handle, 
    138281                        token.data.tag_directive.prefix), 
    139282                    start_mark, end_mark) 
    140283        elif token.type == YAML_DOCUMENT_START_TOKEN: 
    141             return yaml.DocumentStartToken(start_mark, end_mark) 
     284            return self.cached_DocumentStartToken(start_mark, end_mark) 
    142285        elif token.type == YAML_DOCUMENT_END_TOKEN: 
    143             return yaml.DocumentEndToken(start_mark, end_mark) 
     286            return self.cached_DocumentEndToken(start_mark, end_mark) 
    144287        elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: 
    145             return yaml.BlockSequenceStartToken(start_mark, end_mark) 
     288            return self.cached_BlockSequenceStartToken(start_mark, end_mark) 
    146289        elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: 
    147             return yaml.BlockMappingStartToken(start_mark, end_mark) 
     290            return self.cached_BlockMappingStartToken(start_mark, end_mark) 
    148291        elif token.type == YAML_BLOCK_END_TOKEN: 
    149             return yaml.BlockEndToken(start_mark, end_mark) 
     292            return self.cached_BlockEndToken(start_mark, end_mark) 
    150293        elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: 
    151             return yaml.FlowSequenceStartToken(start_mark, end_mark) 
     294            return self.cached_FlowSequenceStartToken(start_mark, end_mark) 
    152295        elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: 
    153             return yaml.FlowSequenceEndToken(start_mark, end_mark) 
     296            return self.cached_FlowSequenceEndToken(start_mark, end_mark) 
    154297        elif token.type == YAML_FLOW_MAPPING_START_TOKEN: 
    155             return yaml.FlowMappingStartToken(start_mark, end_mark) 
     298            return self.cached_FlowMappingStartToken(start_mark, end_mark) 
    156299        elif token.type == YAML_FLOW_MAPPING_END_TOKEN: 
    157             return yaml.FlowMappingEndToken(start_mark, end_mark) 
     300            return self.cached_FlowMappingEndToken(start_mark, end_mark) 
    158301        elif token.type == YAML_BLOCK_ENTRY_TOKEN: 
    159             return yaml.BlockEntryToken(start_mark, end_mark) 
     302            return self.cached_BlockEntryToken(start_mark, end_mark) 
    160303        elif token.type == YAML_FLOW_ENTRY_TOKEN: 
    161             return yaml.FlowEntryToken(start_mark, end_mark) 
     304            return self.cached_FlowEntryToken(start_mark, end_mark) 
    162305        elif token.type == YAML_KEY_TOKEN: 
    163             return yaml.KeyToken(start_mark, end_mark) 
     306            return self.cached_KeyToken(start_mark, end_mark) 
    164307        elif token.type == YAML_VALUE_TOKEN: 
    165             return yaml.ValueToken(start_mark, end_mark) 
     308            return self.cached_ValueToken(start_mark, end_mark) 
    166309        elif token.type == YAML_ALIAS_TOKEN: 
    167             return yaml.AliasToken(token.data.alias.value, 
    168                     start_mark, end_mark) 
     310            value = PyUnicode_DecodeUTF8(token.data.alias.value, 
     311                    strlen(token.data.alias.value), 'strict') 
     312            return self.cached_AliasToken(value, start_mark, end_mark) 
    169313        elif token.type == YAML_ANCHOR_TOKEN: 
    170             return yaml.AnchorToken(token.data.anchor.value, 
    171                     start_mark, end_mark) 
     314            value = PyUnicode_DecodeUTF8(token.data.anchor.value, 
     315                    strlen(token.data.anchor.value), 'strict') 
     316            return self.cached_AnchorToken(value, start_mark, end_mark) 
    172317        elif token.type == YAML_TAG_TOKEN: 
    173             handle = token.data.tag.handle 
    174             if handle == '': 
     318            handle = PyUnicode_DecodeUTF8(token.data.tag.handle, 
     319                    strlen(token.data.tag.handle), 'strict') 
     320            suffix = PyUnicode_DecodeUTF8(token.data.tag.suffix, 
     321                    strlen(token.data.tag.suffix), 'strict') 
     322            if not handle: 
    175323                handle = None 
    176             return yaml.TagToken((handle, token.data.tag.suffix), 
    177                     start_mark, end_mark) 
     324            return self.cached_TagToken((handle, suffix), start_mark, end_mark) 
    178325        elif token.type == YAML_SCALAR_TOKEN: 
    179             value = PyString_FromStringAndSize(token.data.scalar.value, token.data.scalar.length) 
    180             return yaml.ScalarToken(unicode(value, 'utf-8'), 
    181                     bool(token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE), 
    182                     start_mark, end_mark) 
     326            value = PyUnicode_DecodeUTF8(token.data.scalar.value, 
     327                    token.data.scalar.length, 'strict') 
     328            plain = False 
     329            style = None 
     330            if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
     331                plain = True 
     332                style = '' 
     333            elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
     334                style = '\'' 
     335            elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
     336                style = '"' 
     337            elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
     338                style = '|' 
     339            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
     340                style = '>' 
     341            return self.cached_ScalarToken(value, plain, 
     342                    start_mark, end_mark, style) 
    183343        else: 
    184344            raise RuntimeError("unknown token type") 
    185345 
    186     cdef object _convert_event(self, yaml_event_t *event): 
    187         if event == NULL: 
     346    cdef object _parse(self): 
     347        cdef yaml_event_t event 
     348        if yaml_parser_parse(&self.parser, &event) == 0: 
    188349            if self.parser.error == YAML_MEMORY_ERROR: 
    189350                raise MemoryError 
    190351            elif self.parser.error == YAML_READER_ERROR: 
    191                 raise yaml.reader.ReaderError("<input>", 
     352                raise self.cached_ReaderError(self.cached_input, 
    192353                        self.parser.problem_offset, 
    193354                        self.parser.problem_value, 
    194                         '?', self.parser.problem) 
    195             elif self.parser.error == YAML_SCANNER_ERROR: 
     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 
    196360                if self.parser.context != NULL: 
    197                     raise yaml.scanner.ScannerError( 
    198                             self.parser.context, 
    199                             yaml.Mark("<input>", 
    200                                 self.parser.context_mark.index, 
    201                                 self.parser.context_mark.line, 
    202                                 self.parser.context_mark.column, 
    203                                 None, None), 
    204                             self.parser.problem, 
    205                             yaml.Mark("<input>", 
    206                                 self.parser.problem_mark.index, 
    207                                 self.parser.problem_mark.line, 
    208                                 self.parser.problem_mark.column, 
    209                                 None, None)) 
     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) 
    210380                else: 
    211                     raise yaml.scanner.ScannerError(None, None, 
    212                             self.parser.problem, 
    213                             yaml.Mark("<input>", 
    214                                 self.parser.problem_mark.index, 
    215                                 self.parser.problem_mark.line, 
    216                                 self.parser.problem_mark.column, 
    217                                 None, None)) 
    218             elif self.parser.error == YAML_PARSER_ERROR: 
    219                 if self.parser.context != NULL: 
    220                     raise yaml.parser.ParserError( 
    221                             self.parser.context, 
    222                             yaml.Mark("<input>", 
    223                                 self.parser.context_mark.index, 
    224                                 self.parser.context_mark.line, 
    225                                 self.parser.context_mark.column, 
    226                                 None, None), 
    227                             self.parser.problem, 
    228                             yaml.Mark("<input>", 
    229                                 self.parser.problem_mark.index, 
    230                                 self.parser.problem_mark.line, 
    231                                 self.parser.problem_mark.column, 
    232                                 None, None)) 
    233                 else: 
    234                     raise yaml.parser.ParserError(None, None, 
    235                             self.parser.problem, 
    236                             yaml.Mark("<input>", 
    237                                 self.parser.problem_mark.index, 
    238                                 self.parser.problem_mark.line, 
    239                                 self.parser.problem_mark.column, 
    240                                 None, None)) 
    241             else: 
    242                 raise RuntimeError("neither error nor event produced") 
    243         start_mark = yaml.Mark("<input>", 
     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, 
    244389                event.start_mark.index, 
    245390                event.start_mark.line, 
    246391                event.start_mark.column, 
    247392                None, None) 
    248         end_mark = yaml.Mark("<input>", 
     393        end_mark = yaml.Mark(self.cached_input, 
    249394                event.end_mark.index, 
    250395                event.end_mark.line, 
    251396                event.end_mark.column, 
    252397                None, None) 
    253         if event.type == YAML_STREAM_START_EVENT: 
    254             return yaml.StreamStartEvent(start_mark, end_mark) 
     398        if event.type == YAML_NO_EVENT: 
     399            return None 
     400        elif event.type == YAML_STREAM_START_EVENT: 
     401            return self.cached_StreamStartEvent(start_mark, end_mark) 
    255402        elif event.type == YAML_STREAM_END_EVENT: 
    256             return yaml.StreamEndEvent(start_mark, end_mark) 
     403            return self.cached_StreamEndEvent(start_mark, end_mark) 
    257404        elif event.type == YAML_DOCUMENT_START_EVENT: 
    258             return yaml.DocumentStartEvent(start_mark, end_mark, 
    259                     (event.data.document_start.implicit == 0)) 
     405            return self.cached_DocumentStartEvent(start_mark, end_mark) 
    260406        elif event.type == YAML_DOCUMENT_END_EVENT: 
    261             return yaml.DocumentEndEvent(start_mark, end_mark, 
    262                     (event.data.document_end.implicit == 0)) 
     407            return self.cached_DocumentEndEvent(start_mark, end_mark) 
     408        elif event.type == YAML_ALIAS_EVENT: 
     409            anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor, 
     410                    strlen(event.data.alias.anchor), 'strict') 
     411            return self.cached_AliasEvent(anchor, start_mark, end_mark) 
    263412        elif event.type == YAML_SCALAR_EVENT: 
    264             if event.data.scalar.anchor == NULL: 
    265                 anchor = None 
    266             else: 
    267                 anchor = event.data.scalar.anchor 
    268             if event.data.scalar.tag == NULL: 
    269                 tag = None 
    270             else: 
    271                 tag = event.data.scalar.tag 
    272             implicit = (event.data.scalar.plain_implicit == 1, event.data.scalar.quoted_implicit == 1) 
    273             flow_style = (event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE) 
    274             value = PyString_FromStringAndSize(event.data.scalar.value, event.data.scalar.length) 
    275             return yaml.ScalarEvent(anchor, tag, implicit, unicode(value, 'utf-8'), 
    276                     start_mark, end_mark) 
    277         elif event.type == YAML_ALIAS_EVENT: 
    278             if event.data.alias.anchor == NULL: 
    279                 anchor = None 
    280             else: 
    281                 anchor = event.data.alias.anchor 
    282             return yaml.AliasEvent(anchor, start_mark, end_mark) 
     413            anchor = None 
     414            if event.data.scalar.anchor != NULL: 
     415                anchor = PyUnicode_DecodeUTF8(event.data.scalar.anchor, 
     416                        strlen(event.data.scalar.anchor), 'strict') 
     417            tag = None 
     418            if event.data.scalar.tag != NULL: 
     419                tag = PyUnicode_DecodeUTF8(event.data.scalar.tag, 
     420                        strlen(event.data.scalar.tag), 'strict') 
     421            value = PyUnicode_DecodeUTF8(event.data.scalar.value, 
     422                    event.data.scalar.length, 'strict') 
     423            plain_implicit = (event.data.scalar.plain_implicit == 1) 
     424            quoted_implicit = (event.data.scalar.quoted_implicit == 1) 
     425            style = None 
     426            if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
     427                style = '' 
     428            elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
     429                style = '\'' 
     430            elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
     431                style = '"' 
     432            elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
     433                style = '|' 
     434            elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
     435                style = '>' 
     436            return self.cached_ScalarEvent(anchor, tag, 
     437                    (plain_implicit, quoted_implicit), 
     438                    value, start_mark, end_mark, style) 
    283439        elif event.type == YAML_SEQUENCE_START_EVENT: 
    284             if event.data.sequence_start.anchor == NULL: 
    285                 anchor = None 
    286             else: 
    287                 anchor = event.data.sequence_start.anchor 
    288             if event.data.sequence_start.tag == NULL: 
    289                 tag = None 
    290             else: 
    291                 tag = event.data.sequence_start.tag 
     440            anchor = None 
     441            if event.data.sequence_start.anchor != NULL: 
     442                anchor = PyUnicode_DecodeUTF8(event.data.sequence_start.anchor, 
     443                        strlen(event.data.sequence_start.anchor), 'strict') 
     444            tag = None 
     445            if event.data.sequence_start.tag != NULL: 
     446                tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag, 
     447                        strlen(event.data.sequence_start.tag), 'strict') 
    292448            implicit = (event.data.sequence_start.implicit == 1) 
    293             flow_style = (event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE) 
    294             return yaml.SequenceStartEvent(anchor, tag, implicit, 
     449            flow_style = None 
     450            if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: 
     451                flow_style = True 
     452            elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
     453                flow_style = False 
     454            return self.cached_SequenceStartEvent(anchor, tag, implicit, 
    295455                    start_mark, end_mark, flow_style) 
    296456        elif event.type == YAML_MAPPING_START_EVENT: 
    297             if event.data.mapping_start.anchor == NULL: 
    298                 anchor = None 
    299             else: 
    300                 anchor = event.data.mapping_start.anchor 
    301             if event.data.mapping_start.tag == NULL: 
    302                 tag = None 
    303             else: 
    304                 tag = event.data.mapping_start.tag 
     457            anchor = None 
     458            if event.data.mapping_start.anchor != NULL: 
     459                anchor = PyUnicode_DecodeUTF8(event.data.mapping_start.anchor, 
     460                        strlen(event.data.mapping_start.anchor), 'strict') 
     461            tag = None 
     462            if event.data.mapping_start.tag != NULL: 
     463                tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag, 
     464                        strlen(event.data.mapping_start.tag), 'strict') 
    305465            implicit = (event.data.mapping_start.implicit == 1) 
    306             flow_style = (event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE) 
    307             return yaml.MappingStartEvent(anchor, tag, implicit, 
     466            flow_style = None 
     467            if event.data.mapping_start.style == YAML_FLOW_SEQUENCE_STYLE: 
     468                flow_style = True 
     469            elif event.data.mapping_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
     470                flow_style = False 
     471            return self.cached_MappingStartEvent(anchor, tag, implicit, 
    308472                    start_mark, end_mark, flow_style) 
    309473        elif event.type == YAML_SEQUENCE_END_EVENT: 
    310             return yaml.SequenceEndEvent(start_mark, end_mark) 
     474            return self.cached_SequenceEndEvent(start_mark, end_mark) 
    311475        elif event.type == YAML_MAPPING_END_EVENT: 
    312             return yaml.MappingEndEvent(start_mark, end_mark) 
     476            return self.cached_MappingEndEvent(start_mark, end_mark) 
    313477        else: 
    314478            raise RuntimeError("unknown event type") 
    315479 
    316     def get_token(self): 
    317         cdef yaml_token_t *token 
    318         if self.cached_token != NULL: 
    319             yaml_token_delete(yaml_parser_get_token(self.parser)) 
    320             obj = self.cached_obj 
    321             self.cached_token = NULL 
    322             self.cached_obj = None 
    323             return obj 
    324         if self.eof != 0: 
    325             return None 
    326         token = yaml_parser_get_token(self.parser) 
    327         obj = self._convert_token(token) 
    328         if token.type == YAML_STREAM_END_TOKEN: 
    329             self.eof = 1 
    330         yaml_token_delete(token) 
    331         return obj 
    332  
    333     def peek_token(self): 
    334         cdef yaml_token_t *token 
    335         if self.cached_token != NULL: 
    336             return self.cached_obj 
    337         if self.eof != 0: 
    338             return None 
    339         token = yaml_parser_peek_token(self.parser) 
    340         obj = self._convert_token(token) 
    341         if token.type == YAML_STREAM_END_TOKEN: 
    342             self.eof = 1 
    343         self.cached_token = token 
    344         self.cached_obj = obj 
    345         return obj 
    346  
    347     def check_token(self, *choices): 
    348         cdef yaml_token_t *token 
    349         if self.cached_token != NULL: 
    350             obj = self.cached_obj 
    351         elif self.eof != 0: 
    352             return False 
    353         else: 
    354             token = yaml_parser_peek_token(self.parser) 
    355             obj = self._convert_token(token) 
    356             if token.type == YAML_STREAM_END_TOKEN: 
    357                 self.eof = 1 
    358             self.cached_token = token 
    359             self.cached_obj = obj 
    360         if not choices: 
    361             return True 
    362         for choice in choices: 
    363             if isinstance(obj, choice): 
    364                 return True 
    365         return False 
    366  
    367     def get_event(self): 
    368         cdef yaml_event_t *event 
    369         if self.cached_event != NULL: 
    370             yaml_event_delete(yaml_parser_get_event(self.parser)) 
    371             obj = self.cached_obj 
    372             self.cached_event = NULL 
    373             self.cached_obj = None 
    374             return obj 
    375         if self.eof != 0: 
    376             return None 
    377         event = yaml_parser_get_event(self.parser) 
    378         obj = self._convert_event(event) 
    379         if event.type == YAML_STREAM_END_EVENT: 
    380             self.eof = 1 
    381         yaml_event_delete(event) 
    382         return obj 
    383  
    384     def peek_event(self): 
    385         cdef yaml_event_t *event 
    386         if self.cached_event != NULL: 
    387             return self.cached_obj 
    388         if self.eof != 0: 
    389             return None 
    390         event = yaml_parser_peek_event(self.parser) 
    391         obj = self._convert_event(event) 
    392         if event.type == YAML_STREAM_END_EVENT: 
    393             self.eof = 1 
    394         self.cached_event = event 
    395         self.cached_obj = obj 
    396         return obj 
    397  
    398     def check_event(self, *choices): 
    399         cdef yaml_event_t *event 
    400         if self.cached_event != NULL: 
    401             obj = self.cached_obj 
    402         elif self.eof != 0: 
    403             return False 
    404         else: 
    405             event = yaml_parser_peek_event(self.parser) 
    406             obj = self._convert_event(event) 
    407             if event.type == YAML_STREAM_END_EVENT: 
    408                 self.eof = 1 
    409             self.cached_event = event 
    410             self.cached_obj = obj 
    411         if not choices: 
    412             return True 
    413         for choice in choices: 
    414             if isinstance(obj, choice): 
    415                 return True 
    416         return False 
     480cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: 
     481    cdef ScannerAndParser parser 
     482    parser = <ScannerAndParser>data 
     483    value = parser.stream.read(size) 
     484    if PyString_CheckExact(value) == 0: 
     485        raise TypeError("a string value is expected") 
     486    if PyString_GET_SIZE(value) > size: 
     487        raise ValueError("a string value it too long") 
     488    memcpy(buffer, PyString_AS_STRING(value), PyString_GET_SIZE(value)) 
     489    read[0] = PyString_GET_SIZE(value) 
     490    return 1 
    417491 
    418492class Loader(ScannerAndParser, 
  • pyyaml/trunk/tests/test_yaml_ext.py

    r205 r209  
    1111class TestExtLoader(test_appliance.TestAppliance): 
    1212 
    13     def _testExtScanner(self, test_name, data_filename, canonical_filename): 
    14         data = file(data_filename, 'r').read() 
     13    def _testExtScannerFileInput(self, test_name, data_filename, canonical_filename): 
     14        self._testExtScanner(test_name, data_filename, canonical_filename, True) 
     15 
     16    def _testExtScanner(self, test_name, data_filename, canonical_filename, file_input=False): 
     17        if file_input: 
     18            data = file(data_filename, 'r') 
     19        else: 
     20            data = file(data_filename, 'r').read() 
    1521        tokens = list(yaml.scan(data)) 
    1622        ext_tokens = [] 
    1723        try: 
     24            if file_input: 
     25                data = file(data_filename, 'r') 
    1826            for token in yaml.scan(data, Loader=yaml.ExtLoader): 
    1927                ext_tokens.append(token) 
     
    6371 
    6472TestExtLoader.add_tests('testExtScanner', '.data', '.canonical') 
     73TestExtLoader.add_tests('testExtScannerFileInput', '.data', '.canonical') 
    6574TestExtLoader.add_tests('testExtParser', '.data', '.canonical') 
    6675 
Note: See TracChangeset for help on using the changeset viewer.