Ignore:
Timestamp:
07/07/06 15:39:29 (8 years ago)
Author:
xi
Message:

Update PyRex? based bindings to libyaml to include Parser functions.

File:
1 edited

Legend:

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

    r196 r205  
    3030    yaml_parser_delete(parser) 
    3131 
    32 cdef class Scanner: 
     32def 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 
     52cdef class ScannerAndParser: 
    3353 
    3454    cdef yaml_parser_t *parser 
     
    3656    cdef object stream 
    3757    cdef yaml_token_t *cached_token 
     58    cdef yaml_event_t *cached_event 
    3859    cdef object cached_obj 
    3960 
     
    5980            self.parser = NULL 
    6081 
    61     cdef object _convert(self, yaml_token_t *token): 
     82    cdef object _convert_token(self, yaml_token_t *token): 
    6283        if token == NULL: 
    6384            if self.parser.error == YAML_MEMORY_ERROR: 
     
    144165            return yaml.ValueToken(start_mark, end_mark) 
    145166        elif token.type == YAML_ALIAS_TOKEN: 
    146             return yaml.AliasToken(token.data.anchor, 
     167            return yaml.AliasToken(token.data.alias.value, 
    147168                    start_mark, end_mark) 
    148169        elif token.type == YAML_ANCHOR_TOKEN: 
    149             return yaml.AnchorToken(token.data.anchor, 
     170            return yaml.AnchorToken(token.data.anchor.value, 
    150171                    start_mark, end_mark) 
    151172        elif token.type == YAML_TAG_TOKEN: 
     
    162183        else: 
    163184            raise RuntimeError("unknown token type") 
     185 
     186    cdef object _convert_event(self, yaml_event_t *event): 
     187        if event == NULL: 
     188            if self.parser.error == YAML_MEMORY_ERROR: 
     189                raise MemoryError 
     190            elif self.parser.error == YAML_READER_ERROR: 
     191                raise yaml.reader.ReaderError("<input>", 
     192                        self.parser.problem_offset, 
     193                        self.parser.problem_value, 
     194                        '?', self.parser.problem) 
     195            elif self.parser.error == YAML_SCANNER_ERROR: 
     196                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)) 
     210                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>", 
     244                event.start_mark.index, 
     245                event.start_mark.line, 
     246                event.start_mark.column, 
     247                None, None) 
     248        end_mark = yaml.Mark("<input>", 
     249                event.end_mark.index, 
     250                event.end_mark.line, 
     251                event.end_mark.column, 
     252                None, None) 
     253        if event.type == YAML_STREAM_START_EVENT: 
     254            return yaml.StreamStartEvent(start_mark, end_mark) 
     255        elif event.type == YAML_STREAM_END_EVENT: 
     256            return yaml.StreamEndEvent(start_mark, end_mark) 
     257        elif event.type == YAML_DOCUMENT_START_EVENT: 
     258            return yaml.DocumentStartEvent(start_mark, end_mark, 
     259                    (event.data.document_start.implicit == 0)) 
     260        elif event.type == YAML_DOCUMENT_END_EVENT: 
     261            return yaml.DocumentEndEvent(start_mark, end_mark, 
     262                    (event.data.document_end.implicit == 0)) 
     263        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) 
     283        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 
     292            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, 
     295                    start_mark, end_mark, flow_style) 
     296        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 
     305            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, 
     308                    start_mark, end_mark, flow_style) 
     309        elif event.type == YAML_SEQUENCE_END_EVENT: 
     310            return yaml.SequenceEndEvent(start_mark, end_mark) 
     311        elif event.type == YAML_MAPPING_END_EVENT: 
     312            return yaml.MappingEndEvent(start_mark, end_mark) 
     313        else: 
     314            raise RuntimeError("unknown event type") 
    164315 
    165316    def get_token(self): 
     
    174325            return None 
    175326        token = yaml_parser_get_token(self.parser) 
    176         obj = self._convert(token) 
     327        obj = self._convert_token(token) 
    177328        if token.type == YAML_STREAM_END_TOKEN: 
    178329            self.eof = 1 
     
    187338            return None 
    188339        token = yaml_parser_peek_token(self.parser) 
    189         obj = self._convert(token) 
     340        obj = self._convert_token(token) 
    190341        if token.type == YAML_STREAM_END_TOKEN: 
    191342            self.eof = 1 
     
    202353        else: 
    203354            token = yaml_parser_peek_token(self.parser) 
    204             obj = self._convert(token) 
     355            obj = self._convert_token(token) 
    205356            if token.type == YAML_STREAM_END_TOKEN: 
    206357                self.eof = 1 
     
    214365        return False 
    215366 
    216 class Loader(Scanner, 
    217         yaml.parser.Parser, 
     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 
     417 
     418class Loader(ScannerAndParser, 
    218419        yaml.composer.Composer, 
    219420        yaml.constructor.Constructor, 
     
    221422 
    222423    def __init__(self, stream): 
    223         Scanner.__init__(self, stream) 
    224         yaml.parser.Parser.__init__(self) 
     424        ScannerAndParser.__init__(self, stream) 
    225425        yaml.composer.Composer.__init__(self) 
    226426        yaml.constructor.Constructor.__init__(self) 
Note: See TracChangeset for help on using the changeset viewer.