Ignore:
Timestamp:
03/18/06 08:37:09 (8 years ago)
Author:
xi
Message:

Back to work :). Rename markers to marks.

File:
1 edited

Legend:

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

    r57 r116  
    143143                        "expected '<document start>', but found %r" 
    144144                        % self.scanner.peek().id, 
    145                         self.scanner.peek().start_marker) 
     145                        self.scanner.peek().start_mark) 
    146146            token = self.scanner.get() 
    147147            if self.scanner.check(DirectiveToken, 
    148148                    DocumentStartToken, DocumentEndToken, StreamEndToken): 
    149                 yield self.process_empty_scalar(token.end_marker) 
     149                yield self.process_empty_scalar(token.end_mark) 
    150150            else: 
    151151                for event in self.parse_block_node(): 
     
    156156        # Parse end of stream. 
    157157        token = self.scanner.get() 
    158         yield StreamEndEvent(token.start_marker, token.end_marker) 
     158        yield StreamEndEvent(token.start_mark, token.end_mark) 
    159159 
    160160    def process_directives(self): 
     
    167167                if self.yaml_version is not None: 
    168168                    raise ParserError(None, None, 
    169                             "found duplicate YAML directive", token.start_marker) 
     169                            "found duplicate YAML directive", token.start_mark) 
    170170                major, minor = token.value 
    171171                if major != 1: 
    172172                    raise ParserError(None, None, 
    173173                            "found incompatible YAML document (version 1.* is required)", 
    174                             token.start_marker) 
     174                            token.start_mark) 
    175175                self.yaml_version = token.value 
    176176            elif token.name == u'TAG': 
     
    179179                    raise ParserError(None, None, 
    180180                            "duplicate tag handle %r" % handle.encode('utf-8'), 
    181                             token.start_marker) 
     181                            token.start_mark) 
    182182                self.tag_handles[handle] = prefix 
    183183        for key in self.DEFAULT_TAGS: 
     
    205205        if self.scanner.check(AliasToken): 
    206206            token = self.scanner.get() 
    207             yield AliasEvent(token.value, token.start_marker, token.end_marker) 
     207            yield AliasEvent(token.value, token.start_mark, token.end_mark) 
    208208        else: 
    209209            anchor = None 
    210210            tag = None 
    211             start_marker = end_marker = tag_marker = None 
     211            start_mark = end_mark = tag_mark = None 
    212212            if self.scanner.check(AnchorToken): 
    213213                token = self.scanner.get() 
    214                 start_marker = end_marker = token.start_marker 
     214                start_mark = end_mark = token.start_mark 
    215215                anchor = token.value 
    216216                if self.scanner.check(TagToken): 
    217217                    token = self.scanner.get() 
    218                     end_marker = tag_marker = token.start_marker 
     218                    end_mark = tag_mark = token.start_mark 
    219219                    tag = token.value 
    220220            elif self.scanner.check(TagToken): 
    221221                token = self.scanner.get() 
    222                 start_marker = end_marker = tag_marker = token.start_marker 
     222                start_mark = end_mark = tag_mark = token.start_mark 
    223223                tag = token.value 
    224224                if self.scanner.check(AnchorToken): 
    225225                    token = self.scanner.get() 
    226                     end_marker = token.start_marker 
     226                    end_mark = token.start_mark 
    227227                    anchor = token.value 
    228228            if tag is not None: 
     
    230230                if handle is not None: 
    231231                    if handle not in self.tag_handles: 
    232                         raise ParserError("while parsing a node", start_marker, 
     232                        raise ParserError("while parsing a node", start_mark, 
    233233                                "found undefined tag handle %r" % handle.encode('utf-8'), 
    234                                 tag_marker) 
     234                                tag_mark) 
    235235                    tag = self.tag_handles[handle]+suffix 
    236236                else: 
     
    240240                        self.scanner.peek().plain): 
    241241                    tag = u'!' 
    242             if start_marker is None: 
    243                 start_marker = self.scanner.peek().start_marker 
     242            if start_mark is None: 
     243                start_mark = self.scanner.peek().start_mark 
    244244            event = None 
    245245            collection_events = None 
    246246            if indentless_sequence and self.scanner.check(BlockEntryToken): 
    247                 end_marker = self.scanner.peek().end_marker 
    248                 event = SequenceEvent(anchor, tag, start_marker, end_marker) 
     247                end_mark = self.scanner.peek().end_mark 
     248                event = SequenceEvent(anchor, tag, start_mark, end_mark) 
    249249                collection_events = self.parse_indentless_sequence() 
    250250            else: 
    251251                if self.scanner.check(ScalarToken): 
    252252                    token = self.scanner.get() 
    253                     end_marker = token.end_marker 
     253                    end_mark = token.end_mark 
    254254                    event = ScalarEvent(anchor, tag, token.value, 
    255                             start_marker, end_marker) 
     255                            start_mark, end_mark) 
    256256                elif self.scanner.check(FlowSequenceStartToken): 
    257                     end_marker = self.scanner.peek().end_marker 
    258                     event = SequenceEvent(anchor, tag, start_marker, end_marker) 
     257                    end_mark = self.scanner.peek().end_mark 
     258                    event = SequenceEvent(anchor, tag, start_mark, end_mark) 
    259259                    collection_events = self.parse_flow_sequence() 
    260260                elif self.scanner.check(FlowMappingStartToken): 
    261                     end_marker = self.scanner.peek().end_marker 
    262                     event = MappingEvent(anchor, tag, start_marker, end_marker) 
     261                    end_mark = self.scanner.peek().end_mark 
     262                    event = MappingEvent(anchor, tag, start_mark, end_mark) 
    263263                    collection_events = self.parse_flow_mapping() 
    264264                elif block and self.scanner.check(BlockSequenceStartToken): 
    265                     end_marker = self.scanner.peek().start_marker 
    266                     event = SequenceEvent(anchor, tag, start_marker, end_marker) 
     265                    end_mark = self.scanner.peek().start_mark 
     266                    event = SequenceEvent(anchor, tag, start_mark, end_mark) 
    267267                    collection_events = self.parse_block_sequence() 
    268268                elif block and self.scanner.check(BlockMappingStartToken): 
    269                     end_marker = self.scanner.peek().start_marker 
    270                     event = MappingEvent(anchor, tag, start_marker, end_marker) 
     269                    end_mark = self.scanner.peek().start_mark 
     270                    event = MappingEvent(anchor, tag, start_mark, end_mark) 
    271271                    collection_events = self.parse_block_mapping() 
    272272                else: 
     
    276276                        node = 'flow' 
    277277                    token = self.scanner.peek() 
    278                     raise ParserError("while scanning a %s node" % node, start_marker, 
     278                    raise ParserError("while scanning a %s node" % node, start_mark, 
    279279                            "expected the node content, but found %r" % token.id, 
    280                             token.start_marker) 
     280                            token.start_mark) 
    281281            yield event 
    282282            if collection_events is not None: 
     
    287287        # BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END 
    288288        token = self.scanner.get() 
    289         start_marker = token.start_marker 
     289        start_mark = token.start_mark 
    290290        while self.scanner.check(BlockEntryToken): 
    291291            token = self.scanner.get() 
     
    294294                    yield event 
    295295            else: 
    296                 yield self.process_empty_scalar(token.end_marker) 
     296                yield self.process_empty_scalar(token.end_mark) 
    297297        if not self.scanner.check(BlockEndToken): 
    298298            token = self.scanner.peek() 
    299             raise ParserError("while scanning a block collection", start_marker, 
    300                     "expected <block end>, but found %r" % token.id, token.start_marker) 
    301         token = self.scanner.get() 
    302         yield CollectionEndEvent(token.start_marker, token.end_marker) 
     299            raise ParserError("while scanning a block collection", start_mark, 
     300                    "expected <block end>, but found %r" % token.id, token.start_mark) 
     301        token = self.scanner.get() 
     302        yield CollectionEndEvent(token.start_mark, token.end_mark) 
    303303 
    304304    def parse_indentless_sequence(self): 
     
    311311                    yield event 
    312312            else: 
    313                 yield self.process_empty_scalar(token.end_marker) 
     313                yield self.process_empty_scalar(token.end_mark) 
    314314        token = self.scanner.peek() 
    315         yield CollectionEndEvent(token.start_marker, token.start_marker) 
     315        yield CollectionEndEvent(token.start_mark, token.start_mark) 
    316316 
    317317    def parse_block_mapping(self): 
     
    321321        # BLOCK-END 
    322322        token = self.scanner.get() 
    323         start_marker = token.start_marker 
     323        start_mark = token.start_mark 
    324324        while self.scanner.check(KeyToken, ValueToken): 
    325325            if self.scanner.check(KeyToken): 
     
    329329                        yield event 
    330330                else: 
    331                     yield self.process_empty_scalar(token.end_marker) 
     331                    yield self.process_empty_scalar(token.end_mark) 
    332332            if self.scanner.check(ValueToken): 
    333333                token = self.scanner.get() 
     
    336336                        yield event 
    337337                else: 
    338                     yield self.process_empty_scalar(token.end_marker) 
     338                    yield self.process_empty_scalar(token.end_mark) 
    339339            else: 
    340340                token = self.scanner.peek() 
    341                 yield self.process_empty_scalar(token.start_marker) 
     341                yield self.process_empty_scalar(token.start_mark) 
    342342        if not self.scanner.check(BlockEndToken): 
    343343            token = self.scanner.peek() 
    344             raise ParserError("while scanning a block mapping", start_marker, 
    345                     "expected <block end>, but found %r" % token.id, token.start_marker) 
    346         token = self.scanner.get() 
    347         yield CollectionEndEvent(token.start_marker, token.end_marker) 
     344            raise ParserError("while scanning a block mapping", start_mark, 
     345                    "expected <block end>, but found %r" % token.id, token.start_mark) 
     346        token = self.scanner.get() 
     347        yield CollectionEndEvent(token.start_mark, token.end_mark) 
    348348 
    349349    def parse_flow_sequence(self): 
     
    359359        # generate an inline mapping (set syntax). 
    360360        token = self.scanner.get() 
    361         start_marker = token.start_marker 
     361        start_mark = token.start_mark 
    362362        while not self.scanner.check(FlowSequenceEndToken): 
    363363            if self.scanner.check(KeyToken): 
    364364                token = self.scanner.get() 
    365365                yield MappingEvent(None, u'!', 
    366                         token.start_marker, token.end_marker) 
     366                        token.start_mark, token.end_mark) 
    367367                if not self.scanner.check(ValueToken, 
    368368                        FlowEntryToken, FlowSequenceEndToken): 
     
    370370                        yield event 
    371371                else: 
    372                     yield self.process_empty_scalar(token.end_marker) 
     372                    yield self.process_empty_scalar(token.end_mark) 
    373373                if self.scanner.check(ValueToken): 
    374374                    token = self.scanner.get() 
     
    377377                            yield event 
    378378                    else: 
    379                         yield self.process_empty_scalar(token.end_marker) 
     379                        yield self.process_empty_scalar(token.end_mark) 
    380380                else: 
    381381                    token = self.scanner.peek() 
    382                     yield self.process_empty_scalar(token.start_marker) 
     382                    yield self.process_empty_scalar(token.start_mark) 
    383383                token = self.scanner.peek() 
    384                 yield CollectionEndEvent(token.start_marker, token.start_marker) 
     384                yield CollectionEndEvent(token.start_mark, token.start_mark) 
    385385            else: 
    386386                for event in self.parse_flow_node(): 
     
    388388            if not self.scanner.check(FlowEntryToken, FlowSequenceEndToken): 
    389389                token = self.scanner.peek() 
    390                 raise ParserError("while scanning a flow sequence", start_marker, 
    391                         "expected ',' or ']', but got %r" % token.id, token.start_marker) 
     390                raise ParserError("while scanning a flow sequence", start_mark, 
     391                        "expected ',' or ']', but got %r" % token.id, token.start_mark) 
    392392            if self.scanner.check(FlowEntryToken): 
    393393                self.scanner.get() 
    394394        token = self.scanner.get() 
    395         yield CollectionEndEvent(token.start_marker, token.end_marker) 
     395        yield CollectionEndEvent(token.start_mark, token.end_mark) 
    396396 
    397397    def parse_flow_mapping(self): 
     
    402402        # flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
    403403        token = self.scanner.get() 
    404         start_marker = token.start_marker 
     404        start_mark = token.start_mark 
    405405        while not self.scanner.check(FlowMappingEndToken): 
    406406            if self.scanner.check(KeyToken): 
     
    411411                        yield event 
    412412                else: 
    413                     yield self.process_empty_scalar(token.end_marker) 
     413                    yield self.process_empty_scalar(token.end_mark) 
    414414                if self.scanner.check(ValueToken): 
    415415                    token = self.scanner.get() 
     
    418418                            yield event 
    419419                    else: 
    420                         yield self.process_empty_scalar(token.end_marker) 
     420                        yield self.process_empty_scalar(token.end_mark) 
    421421                else: 
    422422                    token = self.scanner.peek() 
    423                     yield self.process_empty_scalar(token.start_marker) 
     423                    yield self.process_empty_scalar(token.start_mark) 
    424424            else: 
    425425                for event in self.parse_flow_node(): 
    426426                    yield event 
    427                 yield self.process_empty_scalar(self.scanner.peek().start_marker) 
     427                yield self.process_empty_scalar(self.scanner.peek().start_mark) 
    428428            if not self.scanner.check(FlowEntryToken, FlowMappingEndToken): 
    429429                token = self.scanner.peek() 
    430                 raise ParserError("while scanning a flow mapping", start_marker, 
    431                         "expected ',' or '}', but got %r" % token.id, token.start_marker) 
     430                raise ParserError("while scanning a flow mapping", start_mark, 
     431                        "expected ',' or '}', but got %r" % token.id, token.start_mark) 
    432432            if self.scanner.check(FlowEntryToken): 
    433433                self.scanner.get() 
    434434        if not self.scanner.check(FlowMappingEndToken): 
    435435            token = self.scanner.peek() 
    436             raise ParserError("while scanning a flow mapping", start_marker, 
    437                     "expected '}', but found %r" % token.id, token.start_marker) 
    438         token = self.scanner.get() 
    439         yield CollectionEndEvent(token.start_marker, token.end_marker) 
    440  
    441     def process_empty_scalar(self, marker): 
    442         return ScalarEvent(None, None, u'', marker, marker) 
    443  
     436            raise ParserError("while scanning a flow mapping", start_mark, 
     437                    "expected '}', but found %r" % token.id, token.start_mark) 
     438        token = self.scanner.get() 
     439        yield CollectionEndEvent(token.start_mark, token.end_mark) 
     440 
     441    def process_empty_scalar(self, mark): 
     442        return ScalarEvent(None, None, u'', mark, mark) 
     443 
Note: See TracChangeset for help on using the changeset viewer.