Changeset 116

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

Back to work :). Rename markers to marks.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • pyyaml/trunk/lib/yaml/composer.py

    r57 r116  
    4242            if anchor not in self.all_anchors: 
    4343                raise ComposerError(None, None, "found undefined alias %r" 
    44                         % anchor.encode('utf-8'), event.start_marker) 
     44                        % anchor.encode('utf-8'), event.start_mark) 
    4545            if anchor not in self.complete_anchors: 
    4646                collection_event = self.all_anchors[anchor] 
    4747                raise ComposerError("while composing a collection", 
    48                         collection_event.start_marker, 
     48                        collection_event.start_mark, 
    4949                        "found recursive anchor %r" % anchor.encode('utf-8'), 
    50                         event.start_marker) 
     50                        event.start_mark) 
    5151            return self.complete_anchors[anchor] 
    5252        event = self.parser.peek() 
    …… 
    5555            if anchor in self.all_anchors: 
    5656                raise ComposerError("found duplicate anchor %r; first occurence" 
    57                         % anchor.encode('utf-8'), self.all_anchors[anchor].start_marker, 
    58                         "second occurence", event.start_marker) 
     57                        % anchor.encode('utf-8'), self.all_anchors[anchor].start_mark, 
     58                        "second occurence", event.start_mark) 
    5959            self.all_anchors[anchor] = event 
    6060        if self.parser.check(ScalarEvent): 
    …… 
    7171        event = self.parser.get() 
    7272        return ScalarNode(event.tag, event.value, 
    73                 event.start_marker, event.end_marker) 
     73                event.start_mark, event.end_mark) 
    7474 
    7575    def compose_sequence_node(self): 
    …… 
    8080        end_event = self.parser.get() 
    8181        return SequenceNode(start_event.tag, value, 
    82                 start_event.start_marker, end_event.end_marker) 
     82                start_event.start_mark, end_event.end_mark) 
    8383 
    8484    def compose_mapping_node(self): 
    …… 
    9090            item_value = self.compose_node() 
    9191            if item_key in value: 
    92                 raise ComposerError("while composing a mapping", start_event.start_marker, 
    93                         "found duplicate key", key_event.start_marker) 
     92                raise ComposerError("while composing a mapping", start_event.start_mark, 
     93                        "found duplicate key", key_event.start_mark) 
    9494            value[item_key] = item_value 
    9595        end_event = self.parser.get() 
    9696        return MappingNode(start_event.tag, value, 
    97                 start_event.start_marker, end_event.end_marker) 
     97                start_event.start_mark, end_event.end_mark) 
    9898 

  • pyyaml/trunk/lib/yaml/constructor.py

    r59 r116  
    7171            raise ConstructorError(None, None, 
    7272                    "expected a scalar node, but found %s" % node.id, 
    73                     node.start_marker) 
     73                    node.start_mark) 
    7474        return node.value 
    7575 
    …… 
    7878            raise ConstructorError(None, None, 
    7979                    "expected a sequence node, but found %s" % node.id, 
    80                     node.start_marker) 
     80                    node.start_mark) 
    8181        return [self.construct_object(child) for child in node.value] 
    8282 
    …… 
    8585            raise ConstructorError(None, None, 
    8686                    "expected a mapping node, but found %s" % node.id, 
    87                     node.start_marker) 
     87                    node.start_mark) 
    8888        mapping = {} 
    8989        merge = None 
    …… 
    9191            if key_node.tag == u'tag:yaml.org,2002:merge': 
    9292                if merge is not None: 
    93                     raise ConstructorError("while constructing a mapping", node.start_marker, 
    94                             "found duplicate merge key", key_node.start_marker) 
     93                    raise ConstructorError("while constructing a mapping", node.start_mark, 
     94                            "found duplicate merge key", key_node.start_mark) 
    9595                value_node = node.value[key_node] 
    9696                if isinstance(value_node, MappingNode): 
    …… 
    101101                        if not isinstance(subnode, MappingNode): 
    102102                            raise ConstructorError("while constructing a mapping", 
    103                                     node.start_marker, 
     103                                    node.start_mark, 
    104104                                    "expected a mapping for merging, but found %s" 
    105                                     % subnode.id, subnode.start_marker) 
     105                                    % subnode.id, subnode.start_mark) 
    106106                        merge.append(self.construct_mapping(subnode)) 
    107107                    merge.reverse() 
    108108                else: 
    109                     raise ConstructorError("while constructing a mapping", node.start_marker, 
     109                    raise ConstructorError("while constructing a mapping", node.start_mark, 
    110110                            "expected a mapping or list of mappings for merging, but found %s" 
    111                             % value_node.id, value_node.start_marker) 
     111                            % value_node.id, value_node.start_mark) 
    112112            elif key_node.tag == u'tag:yaml.org,2002:value': 
    113113                if '=' in mapping: 
    114                     raise ConstructorError("while construction a mapping", node.start_marker, 
    115                             "found duplicate value key", key_node.start_marker) 
     114                    raise ConstructorError("while construction a mapping", node.start_mark, 
     115                            "found duplicate value key", key_node.start_mark) 
    116116                value = self.construct_object(node.value[key_node]) 
    117117                mapping['='] = value 
    …… 
    121121                    duplicate_key = key in mapping 
    122122                except TypeError, exc: 
    123                     raise ConstructorError("while constructing a mapping", node.start_marker, 
    124                             "found unacceptable key (%s)" % exc, key_node.start_marker) 
     123                    raise ConstructorError("while constructing a mapping", node.start_mark, 
     124                            "found unacceptable key (%s)" % exc, key_node.start_mark) 
    125125                if duplicate_key: 
    126                     raise ConstructorError("while constructing a mapping", node.start_marker, 
    127                             "found duplicate key", key_node.start_marker) 
     126                    raise ConstructorError("while constructing a mapping", node.start_mark, 
     127                            "found duplicate key", key_node.start_mark) 
    128128                value = self.construct_object(node.value[key_node]) 
    129129                mapping[key] = value 
    …… 
    139139            raise ConstructorError(None, None, 
    140140                    "expected a mapping node, but found %s" % node.id, 
    141                     node.start_marker) 
     141                    node.start_mark) 
    142142        pairs = [] 
    143143        for key_node in node.value: 
    …… 
    235235        except (binascii.Error, UnicodeEncodeError), exc: 
    236236            raise ConstructorError(None, None, 
    237                     "failed to decode base64 data: %s" % exc, node.start_marker)  
     237                    "failed to decode base64 data: %s" % exc, node.start_mark)  
    238238 
    239239    timestamp_regexp = re.compile( 
    …… 
    272272        # CPU-expensive. 
    273273        if not isinstance(node, SequenceNode): 
    274             raise ConstructorError("while constructing an ordered map", node.start_marker, 
    275                     "expected a sequence, but found %s" % node.id, node.start_marker) 
     274            raise ConstructorError("while constructing an ordered map", node.start_mark, 
     275                    "expected a sequence, but found %s" % node.id, node.start_mark) 
    276276        omap = [] 
    277277        for subnode in node.value: 
    278278            if not isinstance(subnode, MappingNode): 
    279                 raise ConstructorError("while constructing an ordered map", node.start_marker, 
     279                raise ConstructorError("while constructing an ordered map", node.start_mark, 
    280280                        "expected a mapping of length 1, but found %s" % subnode.id, 
    281                         subnode.start_marker) 
     281                        subnode.start_mark) 
    282282            if len(subnode.value) != 1: 
    283                 raise ConstructorError("while constructing an ordered map", node.start_marker, 
     283                raise ConstructorError("while constructing an ordered map", node.start_mark, 
    284284                        "expected a single mapping item, but found %d items" % len(subnode.value), 
    285                         subnode.start_marker) 
     285                        subnode.start_mark) 
    286286            key_node = subnode.value.keys()[0] 
    287287            key = self.construct_object(key_node) 
    …… 
    293293        # Note: the same code as `construct_yaml_omap`. 
    294294        if not isinstance(node, SequenceNode): 
    295             raise ConstructorError("while constructing pairs", node.start_marker, 
    296                     "expected a sequence, but found %s" % node.id, node.start_marker) 
     295            raise ConstructorError("while constructing pairs", node.start_mark, 
     296                    "expected a sequence, but found %s" % node.id, node.start_mark) 
    297297        pairs = [] 
    298298        for subnode in node.value: 
    299299            if not isinstance(subnode, MappingNode): 
    300                 raise ConstructorError("while constructing pairs", node.start_marker, 
     300                raise ConstructorError("while constructing pairs", node.start_mark, 
    301301                        "expected a mapping of length 1, but found %s" % subnode.id, 
    302                         subnode.start_marker) 
     302                        subnode.start_mark) 
    303303            if len(subnode.value) != 1: 
    304                 raise ConstructorError("while constructing pairs", node.start_marker, 
     304                raise ConstructorError("while constructing pairs", node.start_mark, 
    305305                        "expected a single mapping item, but found %d items" % len(subnode.value), 
    306                         subnode.start_marker) 
     306                        subnode.start_mark) 
    307307            key_node = subnode.value.keys()[0] 
    308308            key = self.construct_object(key_node) 
    …… 
    331331        raise ConstructorError(None, None, 
    332332                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), 
    333                 node.start_marker) 
     333                node.start_mark) 
    334334 
    335335Constructor.add_constructor( 
    …… 
    403403        raise ConstructorError(None, None, 
    404404                "found undefined constructor for the tag %r" 
    405                 % node.tag.encode('utf-8'), node.start_marker) 
     405                % node.tag.encode('utf-8'), node.start_mark) 
    406406    from_yaml = classmethod(from_yaml) 
    407407 

  • pyyaml/trunk/lib/yaml/error.py

    r53 r116  
    11 
    2 __all__ = ['Marker', 'YAMLError', 'MarkedYAMLError'] 
     2__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] 
    33 
    4 class Marker: 
     4class Mark: 
    55 
    66    def __init__(self, name, line, column, buffer, pointer): 
    …… 
    4747class MarkedYAMLError(YAMLError): 
    4848 
    49     def __init__(self, context=None, context_marker=None, 
    50             problem=None, problem_marker=None): 
     49    def __init__(self, context=None, context_mark=None, 
     50            problem=None, problem_mark=None): 
    5151        self.context = context 
    52         self.context_marker = context_marker 
     52        self.context_mark = context_mark 
    5353        self.problem = problem 
    54         self.problem_marker = problem_marker 
     54        self.problem_mark = problem_mark 
    5555 
    5656    def __str__(self): 
    5757        lines = [] 
    58         #for (place, marker) in [(self.context, self.context_marker), 
    59         #                        (self.problem, self.problem_marker)]: 
     58        #for (place, mark) in [(self.context, self.context_mark), 
     59        #                        (self.problem, self.problem_mark)]: 
    6060        #    if place is not None: 
    6161        #        lines.append(place) 
    62         #        if marker is not None: 
    63         #            lines.append(str(marker)) 
     62        #        if mark is not None: 
     63        #            lines.append(str(mark)) 
    6464        if self.context is not None: 
    6565            lines.append(self.context) 
    66         if self.context_marker is not None  \ 
    67             and (self.problem is None or self.problem_marker is None 
    68                     or self.context_marker.name != self.problem_marker.name 
    69                     or self.context_marker.line != self.problem_marker.line 
    70                     or self.context_marker.column != self.problem_marker.column): 
    71             lines.append(str(self.context_marker)) 
     66        if self.context_mark is not None  \ 
     67            and (self.problem is None or self.problem_mark is None 
     68                    or self.context_mark.name != self.problem_mark.name 
     69                    or self.context_mark.line != self.problem_mark.line 
     70                    or self.context_mark.column != self.problem_mark.column): 
     71            lines.append(str(self.context_mark)) 
    7272        if self.problem is not None: 
    7373            lines.append(self.problem) 
    74         if self.problem_marker is not None: 
    75             lines.append(str(self.problem_marker)) 
     74        if self.problem_mark is not None: 
     75            lines.append(str(self.problem_mark)) 
    7676        return '\n'.join(lines) 
    7777 

  • pyyaml/trunk/lib/yaml/events.py

    r53 r116  
    11 
    22class Event: 
    3     def __init__(self, start_marker, end_marker): 
    4         self.start_marker = start_marker 
    5         self.end_marker = end_marker 
     3    def __init__(self, start_mark, end_mark): 
     4        self.start_mark = start_mark 
     5        self.end_mark = end_mark 
    66    def __repr__(self): 
    77        attributes = [key for key in self.__dict__ 
    8                 if not key.endswith('_marker')] 
     8                if not key.endswith('_mark')] 
    99        attributes.sort() 
    1010        arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) 
    …… 
    1313 
    1414class NodeEvent(Event): 
    15     def __init__(self, anchor, start_marker, end_marker): 
     15    def __init__(self, anchor, start_mark, end_mark): 
    1616        self.anchor = anchor 
    17         self.start_marker = start_marker 
    18         self.end_marker = end_marker 
     17        self.start_mark = start_mark 
     18        self.end_mark = end_mark 
    1919 
    2020class AliasEvent(NodeEvent): 
    …… 
    2222 
    2323class ScalarEvent(NodeEvent): 
    24     def __init__(self, anchor, tag, value, start_marker, end_marker): 
     24    def __init__(self, anchor, tag, value, start_mark, end_mark): 
    2525        self.anchor = anchor 
    2626        self.tag = tag 
    2727        self.value = value 
    28         self.start_marker = start_marker 
    29         self.end_marker = end_marker 
     28        self.start_mark = start_mark 
     29        self.end_mark = end_mark 
    3030 
    3131class CollectionEvent(NodeEvent): 
    32     def __init__(self, anchor, tag, start_marker, end_marker): 
     32    def __init__(self, anchor, tag, start_mark, end_mark): 
    3333        self.anchor = anchor 
    3434        self.tag = tag 
    35         self.start_marker = start_marker 
    36         self.end_marker = end_marker 
     35        self.start_mark = start_mark 
     36        self.end_mark = end_mark 
    3737 
    3838class SequenceEvent(CollectionEvent): 

  • pyyaml/trunk/lib/yaml/nodes.py

    r55 r116  
    11 
    22class Node: 
    3     def __init__(self, tag, value, start_marker, end_marker): 
     3    def __init__(self, tag, value, start_mark, end_mark): 
    44        self.tag = tag 
    55        self.value = value 
    6         self.start_marker = start_marker 
    7         self.end_marker = end_marker 
     6        self.start_mark = start_mark 
     7        self.end_mark = end_mark 
    88    def __repr__(self): 
    99        value = self.value 

  • 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 

  • pyyaml/trunk/lib/yaml/reader.py

    r52 r116  
    44# We define two classes here. 
    55# 
    6 #   Marker(source, line, column) 
     6#   Mark(source, line, column) 
    77# It's just a record and its only use is producing nice error messages. 
    88# Parser does not use it for any other purposes. 
    …… 
    1818__all__ = ['Reader', 'ReaderError'] 
    1919 
    20 from error import YAMLError, Marker 
     20from error import YAMLError, Mark 
    2121 
    2222import codecs, re 
    …… 
    143143                self.column += 1 
    144144 
    145     def get_marker(self): 
     145    def get_mark(self): 
    146146        if self.stream is None: 
    147             return Marker(self.name, self.line, self.column, 
     147            return Mark(self.name, self.line, self.column, 
    148148                    self.buffer, self.pointer) 
    149149        else: 
    150             return Marker(self.name, self.line, self.column, None, None) 
     150            return Mark(self.name, self.line, self.column, None, None) 
    151151 
    152152    def determine_encoding(self): 

  • pyyaml/trunk/lib/yaml/scanner.py

    r60 r116  
    3535    # See below simple keys treatment. 
    3636 
    37     def __init__(self, token_number, required, index, line, column, marker): 
     37    def __init__(self, token_number, required, index, line, column, mark): 
    3838        self.token_number = token_number 
    3939        self.required = required 
    …… 
    4141        self.line = line 
    4242        self.column = column 
    43         self.marker = marker 
     43        self.mark = mark 
    4444 
    4545class Scanner: 
    …… 
    103103        # is `flow_level`; there can be no more that one possible simple key 
    104104        # for each level. The value is a SimpleKey record: 
    105         #   (token_number, required, index, line, column, marker) 
     105        #   (token_number, required, index, line, column, mark) 
    106106        # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), 
    107107        # '[', or '{' tokens. 
    …… 
    262262        raise ScannerError("while scanning for the next token", None, 
    263263                "found character %r that cannot start any token" 
    264                 % ch.encode('utf-8'), self.reader.get_marker()) 
     264                % ch.encode('utf-8'), self.reader.get_mark()) 
    265265 
    266266    # Simple keys treatment. 
    …… 
    293293                    or self.reader.index-key.index > 1024: 
    294294                if key.required: 
    295                     raise ScannerError("while scanning a simple key", key.marker, 
    296                             "could not found expected ':'", self.reader.get_marker()) 
     295                    raise ScannerError("while scanning a simple key", key.mark, 
     296                            "could not found expected ':'", self.reader.get_mark()) 
    297297                del self.possible_simple_keys[level] 
    298298 
    …… 
    317317            line = self.reader.line 
    318318            column = self.reader.column 
    319             marker = self.reader.get_marker() 
     319            mark = self.reader.get_mark() 
    320320            key = SimpleKey(token_number, required, 
    321                     index, line, column, marker) 
     321                    index, line, column, mark) 
    322322            self.possible_simple_keys[self.flow_level] = key 
    323323 
    …… 
    330330            assert not key.required 
    331331            #if key.required: 
    332             #    raise ScannerError("while scanning a simple key", key.marker, 
    333             #            "could not found expected ':'", self.reader.get_marker()) 
     332            #    raise ScannerError("while scanning a simple key", key.mark, 
     333            #            "could not found expected ':'", self.reader.get_mark()) 
    334334 
    335335    # Indentation functions. 
    …… 
    346346            raise ScannerError(None, None, 
    347347                    "invalid intendation or unclosed '[' or '{'", 
    348                     self.reader.get_marker()) 
     348                    self.reader.get_mark()) 
    349349 
    350350        # In block context, we may need to issue the BLOCK-END tokens. 
    351351        while self.indent > column: 
    352             marker = self.reader.get_marker() 
     352            mark = self.reader.get_mark() 
    353353