Ignore:
Timestamp:
04/15/06 19:54:52 (9 years ago)
Author:
xi
Message:

Major refactoring.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib/yaml/parser.py

    r132 r136  
    2525# stream ::= (BOM? implicit_document)? (BOM? explicit_document)* STREAM-END 
    2626 
    27 # Note that there is a slight deviation from the specification. We require a 
    28 # non-empty node content if ANCHOR or TAG is specified. This disallow such 
    29 # documents as 
    30 # 
    31 #   key:    !!str   # empty value 
    32 # 
    33 # This is done to prevent ambiguity in parsing tags and aliases: 
    34 # 
    35 #   {   !!perl/YAML::Parser:    value } 
    36 # 
    37 # What is it? Should it be interpreted as 
    38 #   {   ? !<tag:yaml.org,2002:perl/YAML::Parser> '' : value } 
    39 # or 
    40 #   {   ? !<tag:yaml.org,2002:perl/YAML::Parser:> value : '' } 
    41 # Since we disallow non-empty node content, tags are always followed by spaces 
    42 # or line breaks. 
    43  
    4427# FIRST sets: 
    4528# stream: { STREAM-START } 
     
    6750from tokens import * 
    6851from events import * 
     52from scanner import * 
    6953 
    7054class ParserError(MarkedYAMLError): 
     
    7256 
    7357class Parser: 
    74     # Since writing an LL(1) parser is a straightforward task, we do not give 
    75     # many comments here. 
     58    # Since writing a recursive-descendant parser is a straightforward task, we 
     59    # do not give many comments here. 
    7660    # Note that we use Python generators. If you rewrite the parser in another 
    7761    # language, you may replace all 'yield'-s with event handler calls. 
     
    8266    } 
    8367 
    84     def __init__(self, scanner): 
    85         self.scanner = scanner 
     68    def __init__(self): 
    8669        self.current_event = None 
    8770        self.yaml_version = None 
     
    8972        self.event_generator = self.parse_stream() 
    9073 
    91     def check(self, *choices): 
     74    def check_event(self, *choices): 
    9275        # Check the type of the next event. 
    9376        if self.current_event is None: 
     
    9780                pass 
    9881        if self.current_event is not None: 
     82            if not choices: 
     83                return True 
    9984            for choice in choices: 
    10085                if isinstance(self.current_event, choice): 
     
    10287        return False 
    10388 
    104     def peek(self): 
     89    def peek_event(self): 
    10590        # Get the next event. 
    10691        if self.current_event is None: 
     
    11196        return self.current_event 
    11297 
    113     def get(self): 
     98    def get_event(self): 
    11499        # Get the next event. 
    115100        if self.current_event is None: 
     
    130115 
    131116        # Parse start of stream. 
    132         token = self.scanner.get() 
     117        token = self.get_token() 
    133118        yield StreamStartEvent(token.start_mark, token.end_mark, 
    134119                encoding=token.encoding) 
    135120 
    136121        # Parse implicit document. 
    137         if not self.scanner.check(DirectiveToken, DocumentStartToken, 
     122        if not self.check_token(DirectiveToken, DocumentStartToken, 
    138123                StreamEndToken): 
    139124            self.tag_handles = self.DEFAULT_TAGS 
    140             token = self.scanner.peek() 
     125            token = self.peek_token() 
    141126            start_mark = end_mark = token.start_mark 
    142127            yield DocumentStartEvent(start_mark, end_mark, 
     
    144129            for event in self.parse_block_node(): 
    145130                yield event 
    146             token = self.scanner.peek() 
     131            token = self.peek_token() 
    147132            start_mark = end_mark = token.start_mark 
    148133            explicit = False 
    149             while self.scanner.check(DocumentEndToken): 
    150                 token = self.scanner.get() 
     134            while self.check_token(DocumentEndToken): 
     135                token = self.get_token() 
    151136                end_mark = token.end_mark 
    152137                explicit = True 
     
    155140 
    156141        # Parse explicit documents. 
    157         while not self.scanner.check(StreamEndToken): 
    158             token = self.scanner.peek() 
     142        while not self.check_token(StreamEndToken): 
     143            token = self.peek_token() 
    159144            start_mark = token.start_mark 
    160145            version, tags = self.process_directives() 
    161             if not self.scanner.check(DocumentStartToken): 
     146            if not self.check_token(DocumentStartToken): 
    162147                raise ParserError(None, None, 
    163148                        "expected '<document start>', but found %r" 
    164                         % self.scanner.peek().id, 
    165                         self.scanner.peek().start_mark) 
    166             token = self.scanner.get() 
     149                        % self.peek_token().id, 
     150                        self.peek_token().start_mark) 
     151            token = self.get_token() 
    167152            end_mark = token.end_mark 
    168153            yield DocumentStartEvent(start_mark, end_mark, 
    169154                    explicit=True, version=version, tags=tags) 
    170             if self.scanner.check(DirectiveToken, 
     155            if self.check_token(DirectiveToken, 
    171156                    DocumentStartToken, DocumentEndToken, StreamEndToken): 
    172157                yield self.process_empty_scalar(token.end_mark) 
     
    174159                for event in self.parse_block_node(): 
    175160                    yield event 
    176             token = self.scanner.peek() 
     161            token = self.peek_token() 
    177162            start_mark = end_mark = token.start_mark 
    178163            explicit = False 
    179             while self.scanner.check(DocumentEndToken): 
    180                 token = self.scanner.get() 
     164            while self.check_token(DocumentEndToken): 
     165                token = self.get_token() 
    181166                end_mark = token.end_mark 
    182167                explicit=True 
     
    185170 
    186171        # Parse end of stream. 
    187         token = self.scanner.get() 
     172        token = self.get_token() 
    188173        yield StreamEndEvent(token.start_mark, token.end_mark) 
    189174 
     
    192177        self.yaml_version = None 
    193178        self.tag_handles = {} 
    194         while self.scanner.check(DirectiveToken): 
    195             token = self.scanner.get() 
     179        while self.check_token(DirectiveToken): 
     180            token = self.get_token() 
    196181            if token.name == u'YAML': 
    197182                if self.yaml_version is not None: 
     
    238223        # block_node_or_indentless_sequence ::= ALIAS | properties? 
    239224        #                                       (block_content | indentless_block_sequence) 
    240         if self.scanner.check(AliasToken): 
    241             token = self.scanner.get() 
     225        if self.check_token(AliasToken): 
     226            token = self.get_token() 
    242227            yield AliasEvent(token.value, token.start_mark, token.end_mark) 
    243228        else: 
     
    245230            tag = None 
    246231            start_mark = end_mark = tag_mark = None 
    247             if self.scanner.check(AnchorToken): 
    248                 token = self.scanner.get() 
     232            if self.check_token(AnchorToken): 
     233                token = self.get_token() 
    249234                start_mark = token.start_mark 
    250235                end_mark = token.end_mark 
    251236                anchor = token.value 
    252                 if self.scanner.check(TagToken): 
    253                     token = self.scanner.get() 
     237                if self.check_token(TagToken): 
     238                    token = self.get_token() 
    254239                    tag_mark = token.start_mark 
    255240                    end_mark = token.end_mark 
    256241                    tag = token.value 
    257             elif self.scanner.check(TagToken): 
    258                 token = self.scanner.get() 
     242            elif self.check_token(TagToken): 
     243                token = self.get_token() 
    259244                start_mark = tag_mark = token.start_mark 
    260245                end_mark = token.end_mark 
    261246                tag = token.value 
    262                 if self.scanner.check(AnchorToken): 
    263                     token = self.scanner.get() 
     247                if self.check_token(AnchorToken): 
     248                    token = self.get_token() 
    264249                    end_mark = token.end_mark 
    265250                    anchor = token.value 
    266             if tag is not None: 
     251            if tag is not None and tag != u'!': 
    267252                handle, suffix = tag 
    268253                if handle is not None: 
     
    274259                else: 
    275260                    tag = suffix 
    276             #if tag is None: 
    277             #    if not (self.scanner.check(ScalarToken) and 
    278             #            self.scanner.peek().implicit): 
    279             #        tag = u'!' 
     261            #if tag == u'!': 
     262            #    raise ParserError("while parsing a node", start_mark, 
     263            #            "found non-specific tag '!'", tag_mark, 
     264            #            "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") 
    280265            if start_mark is None: 
    281                 start_mark = end_mark = self.scanner.peek().start_mark 
     266                start_mark = end_mark = self.peek_token().start_mark 
    282267            event = None 
    283268            collection_events = None 
    284             if indentless_sequence and self.scanner.check(BlockEntryToken): 
    285                 end_mark = self.scanner.peek().end_mark 
     269            if indentless_sequence and self.check_token(BlockEntryToken): 
     270                end_mark = self.peek_token().end_mark 
    286271                event = SequenceStartEvent(anchor, tag, start_mark, end_mark) 
    287272                collection_events = self.parse_indentless_sequence() 
    288273            else: 
    289                 if self.scanner.check(ScalarToken): 
    290                     token = self.scanner.get() 
     274                if self.check_token(ScalarToken): 
     275                    token = self.get_token() 
    291276                    end_mark = token.end_mark 
    292                     implicit = (tag is None and token.implicit) 
    293                     event = ScalarEvent(anchor, tag, token.value, 
    294                             start_mark, end_mark, 
    295                             implicit=implicit, style=token.style) 
    296                 elif self.scanner.check(FlowSequenceStartToken): 
    297                     end_mark = self.scanner.peek().end_mark 
     277                    implicit = ((tag is None or tag == u'!') and token.implicit) 
     278                    event = ScalarEvent(anchor, tag, implicit, token.value, 
     279                            start_mark, end_mark, style=token.style) 
     280                elif self.check_token(FlowSequenceStartToken): 
     281                    end_mark = self.peek_token().end_mark 
    298282                    event = SequenceStartEvent(anchor, tag, start_mark, end_mark, 
    299283                            flow_style=True) 
    300284                    collection_events = self.parse_flow_sequence() 
    301                 elif self.scanner.check(FlowMappingStartToken): 
    302                     end_mark = self.scanner.peek().end_mark 
     285                elif self.check_token(FlowMappingStartToken): 
     286                    end_mark = self.peek_token().end_mark 
    303287                    event = MappingStartEvent(anchor, tag, start_mark, end_mark, 
    304288                            flow_style=True) 
    305289                    collection_events = self.parse_flow_mapping() 
    306                 elif block and self.scanner.check(BlockSequenceStartToken): 
    307                     end_mark = self.scanner.peek().start_mark 
     290                elif block and self.check_token(BlockSequenceStartToken): 
     291                    end_mark = self.peek_token().start_mark 
    308292                    event = SequenceStartEvent(anchor, tag, start_mark, end_mark, 
    309293                            flow_style=False) 
    310294                    collection_events = self.parse_block_sequence() 
    311                 elif block and self.scanner.check(BlockMappingStartToken): 
    312                     end_mark = self.scanner.peek().start_mark 
     295                elif block and self.check_token(BlockMappingStartToken): 
     296                    end_mark = self.peek_token().start_mark 
    313297                    event = MappingStartEvent(anchor, tag, start_mark, end_mark, 
    314298                            flow_style=False) 
     
    317301                    # Empty scalars are allowed even if a tag or an anchor is 
    318302                    # specified. 
    319                     event = ScalarEvent(anchor, tag, u'', start_mark, end_mark, 
    320                             implicit=True) 
     303                    implicit = (tag is None or tag == u'!') 
     304                    event = ScalarEvent(anchor, tag, implicit, u'', 
     305                            start_mark, end_mark) 
    321306                else: 
    322307                    if block: 
     
    324309                    else: 
    325310                        node = 'flow' 
    326                     token = self.scanner.peek() 
     311                    token = self.peek_token() 
    327312                    raise ParserError("while scanning a %s node" % node, start_mark, 
    328313                            "expected the node content, but found %r" % token.id, 
     
    335320    def parse_block_sequence(self): 
    336321        # BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END 
    337         token = self.scanner.get() 
     322        token = self.get_token() 
    338323        start_mark = token.start_mark 
    339         while self.scanner.check(BlockEntryToken): 
    340             token = self.scanner.get() 
    341             if not self.scanner.check(BlockEntryToken, BlockEndToken): 
     324        while self.check_token(BlockEntryToken): 
     325            token = self.get_token() 
     326            if not self.check_token(BlockEntryToken, BlockEndToken): 
    342327                for event in self.parse_block_node(): 
    343328                    yield event 
    344329            else: 
    345330                yield self.process_empty_scalar(token.end_mark) 
    346         if not self.scanner.check(BlockEndToken): 
    347             token = self.scanner.peek() 
     331        if not self.check_token(BlockEndToken): 
     332            token = self.peek_token() 
    348333            raise ParserError("while scanning a block collection", start_mark, 
    349334                    "expected <block end>, but found %r" % token.id, token.start_mark) 
    350         token = self.scanner.get() 
     335        token = self.get_token() 
    351336        yield SequenceEndEvent(token.start_mark, token.end_mark) 
    352337 
    353338    def parse_indentless_sequence(self): 
    354339        # (BLOCK-ENTRY block_node?)+ 
    355         while self.scanner.check(BlockEntryToken): 
    356             token = self.scanner.get() 
    357             if not self.scanner.check(BlockEntryToken, 
     340        while self.check_token(BlockEntryToken): 
     341            token = self.get_token() 
     342            if not self.check_token(BlockEntryToken, 
    358343                    KeyToken, ValueToken, BlockEndToken): 
    359344                for event in self.parse_block_node(): 
     
    361346            else: 
    362347                yield self.process_empty_scalar(token.end_mark) 
    363         token = self.scanner.peek() 
     348        token = self.peek_token() 
    364349        yield SequenceEndEvent(token.start_mark, token.start_mark) 
    365350 
     
    369354        #   (VALUE block_node_or_indentless_sequence?)?)* 
    370355        # BLOCK-END 
    371         token = self.scanner.get() 
     356        token = self.get_token() 
    372357        start_mark = token.start_mark 
    373         while self.scanner.check(KeyToken, ValueToken): 
    374             if self.scanner.check(KeyToken): 
    375                 token = self.scanner.get() 
    376                 if not self.scanner.check(KeyToken, ValueToken, BlockEndToken): 
     358        while self.check_token(KeyToken, ValueToken): 
     359            if self.check_token(KeyToken): 
     360                token = self.get_token() 
     361                if not self.check_token(KeyToken, ValueToken, BlockEndToken): 
    377362                    for event in self.parse_block_node_or_indentless_sequence(): 
    378363                        yield event 
    379364                else: 
    380365                    yield self.process_empty_scalar(token.end_mark) 
    381             if self.scanner.check(ValueToken): 
    382                 token = self.scanner.get() 
    383                 if not self.scanner.check(KeyToken, ValueToken, BlockEndToken): 
     366            if self.check_token(ValueToken): 
     367                token = self.get_token() 
     368                if not self.check_token(KeyToken, ValueToken, BlockEndToken): 
    384369                    for event in self.parse_block_node_or_indentless_sequence(): 
    385370                        yield event 
     
    387372                    yield self.process_empty_scalar(token.end_mark) 
    388373            else: 
    389                 token = self.scanner.peek() 
     374                token = self.peek_token() 
    390375                yield self.process_empty_scalar(token.start_mark) 
    391         if not self.scanner.check(BlockEndToken): 
    392             token = self.scanner.peek() 
     376        if not self.check_token(BlockEndToken): 
     377            token = self.peek_token() 
    393378            raise ParserError("while scanning a block mapping", start_mark, 
    394379                    "expected <block end>, but found %r" % token.id, token.start_mark) 
    395         token = self.scanner.get() 
     380        token = self.get_token() 
    396381        yield MappingEndEvent(token.start_mark, token.end_mark) 
    397382 
     
    407392        # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` 
    408393        # generate an inline mapping (set syntax). 
    409         token = self.scanner.get() 
     394        token = self.get_token() 
    410395        start_mark = token.start_mark 
    411         while not self.scanner.check(FlowSequenceEndToken): 
    412             if self.scanner.check(KeyToken): 
    413                 token = self.scanner.get() 
     396        while not self.check_token(FlowSequenceEndToken): 
     397            if self.check_token(KeyToken): 
     398                token = self.get_token() 
    414399                yield MappingStartEvent(None, None, # u'!', 
    415400                        token.start_mark, token.end_mark, 
    416401                        flow_style=True) 
    417                 if not self.scanner.check(ValueToken, 
     402                if not self.check_token(ValueToken, 
    418403                        FlowEntryToken, FlowSequenceEndToken): 
    419404                    for event in self.parse_flow_node(): 
     
    421406                else: 
    422407                    yield self.process_empty_scalar(token.end_mark) 
    423                 if self.scanner.check(ValueToken): 
    424                     token = self.scanner.get() 
    425                     if not self.scanner.check(FlowEntryToken, FlowSequenceEndToken): 
     408                if self.check_token(ValueToken): 
     409                    token = self.get_token() 
     410                    if not self.check_token(FlowEntryToken, FlowSequenceEndToken): 
    426411                        for event in self.parse_flow_node(): 
    427412                            yield event 
     
    429414                        yield self.process_empty_scalar(token.end_mark) 
    430415                else: 
    431                     token = self.scanner.peek() 
     416                    token = self.peek_token() 
    432417                    yield self.process_empty_scalar(token.start_mark) 
    433                 token = self.scanner.peek() 
     418                token = self.peek_token() 
    434419                yield MappingEndEvent(token.start_mark, token.start_mark) 
    435420            else: 
    436421                for event in self.parse_flow_node(): 
    437422                    yield event 
    438             if not self.scanner.check(FlowEntryToken, FlowSequenceEndToken): 
    439                 token = self.scanner.peek() 
     423            if not self.check_token(FlowEntryToken, FlowSequenceEndToken): 
     424                token = self.peek_token() 
    440425                raise ParserError("while scanning a flow sequence", start_mark, 
    441426                        "expected ',' or ']', but got %r" % token.id, token.start_mark) 
    442             if self.scanner.check(FlowEntryToken): 
    443                 self.scanner.get() 
    444         token = self.scanner.get() 
     427            if self.check_token(FlowEntryToken): 
     428                self.get_token() 
     429        token = self.get_token() 
    445430        yield SequenceEndEvent(token.start_mark, token.end_mark) 
    446431 
     
    451436        #                       FLOW-MAPPING-END 
    452437        # flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
    453         token = self.scanner.get() 
     438        token = self.get_token() 
    454439        start_mark = token.start_mark 
    455         while not self.scanner.check(FlowMappingEndToken): 
    456             if self.scanner.check(KeyToken): 
    457                 token = self.scanner.get() 
    458                 if not self.scanner.check(ValueToken, 
     440        while not self.check_token(FlowMappingEndToken): 
     441            if self.check_token(KeyToken): 
     442                token = self.get_token() 
     443                if not self.check_token(ValueToken, 
    459444                        FlowEntryToken, FlowMappingEndToken): 
    460445                    for event in self.parse_flow_node(): 
     
    462447                else: 
    463448                    yield self.process_empty_scalar(token.end_mark) 
    464                 if self.scanner.check(ValueToken): 
    465                     token = self.scanner.get() 
    466                     if not self.scanner.check(FlowEntryToken, FlowMappingEndToken): 
     449                if self.check_token(ValueToken): 
     450                    token = self.get_token() 
     451                    if not self.check_token(FlowEntryToken, FlowMappingEndToken): 
    467452                        for event in self.parse_flow_node(): 
    468453                            yield event 
     
    470455                        yield self.process_empty_scalar(token.end_mark) 
    471456                else: 
    472                     token = self.scanner.peek() 
     457                    token = self.peek_token() 
    473458                    yield self.process_empty_scalar(token.start_mark) 
    474459            else: 
    475460                for event in self.parse_flow_node(): 
    476461                    yield event 
    477                 yield self.process_empty_scalar(self.scanner.peek().start_mark) 
    478             if not self.scanner.check(FlowEntryToken, FlowMappingEndToken): 
    479                 token = self.scanner.peek() 
     462                yield self.process_empty_scalar(self.peek_token().start_mark) 
     463            if not self.check_token(FlowEntryToken, FlowMappingEndToken): 
     464                token = self.peek_token() 
    480465                raise ParserError("while scanning a flow mapping", start_mark, 
    481466                        "expected ',' or '}', but got %r" % token.id, token.start_mark) 
    482             if self.scanner.check(FlowEntryToken): 
    483                 self.scanner.get() 
    484         if not self.scanner.check(FlowMappingEndToken): 
    485             token = self.scanner.peek() 
     467            if self.check_token(FlowEntryToken): 
     468                self.get_token() 
     469        if not self.check_token(FlowMappingEndToken): 
     470            token = self.peek_token() 
    486471            raise ParserError("while scanning a flow mapping", start_mark, 
    487472                    "expected '}', but found %r" % token.id, token.start_mark) 
    488         token = self.scanner.get() 
     473        token = self.get_token() 
    489474        yield MappingEndEvent(token.start_mark, token.end_mark) 
    490475 
    491476    def process_empty_scalar(self, mark): 
    492         return ScalarEvent(None, None, u'', mark, mark, 
    493                 implicit=True) 
    494  
     477        return ScalarEvent(None, None, True, u'', mark, mark) 
     478 
Note: See TracChangeset for help on using the changeset viewer.