Changeset 116


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

Back to work :). Rename markers to marks.

Location:
pyyaml/trunk
Files:
10 edited
2 moved

Legend:

Unmodified
Added
Removed
  • 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            self.indent = self.indents.pop() 
    354             self.tokens.append(BlockEndToken(marker, marker)) 
     354            self.tokens.append(BlockEndToken(mark, mark)) 
    355355 
    356356    def add_indent(self, column): 
     
    374374 
    375375        # Read the token. 
    376         marker = self.reader.get_marker() 
     376        mark = self.reader.get_mark() 
    377377         
    378378        # Add END. 
    379         self.tokens.append(StreamEndToken(marker, marker)) 
     379        self.tokens.append(StreamEndToken(mark, mark)) 
    380380 
    381381        # The reader is ended. 
     
    411411 
    412412        # Add DOCUMENT-START or DOCUMENT-END. 
    413         start_marker = self.reader.get_marker() 
     413        start_mark = self.reader.get_mark() 
    414414        self.reader.forward(3) 
    415         end_marker = self.reader.get_marker() 
    416         self.tokens.append(TokenClass(start_marker, end_marker)) 
     415        end_mark = self.reader.get_mark() 
     416        self.tokens.append(TokenClass(start_mark, end_mark)) 
    417417 
    418418    def fetch_flow_sequence_start(self): 
     
    434434 
    435435        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. 
    436         start_marker = self.reader.get_marker() 
     436        start_mark = self.reader.get_mark() 
    437437        self.reader.forward() 
    438         end_marker = self.reader.get_marker() 
    439         self.tokens.append(TokenClass(start_marker, end_marker)) 
     438        end_mark = self.reader.get_mark() 
     439        self.tokens.append(TokenClass(start_mark, end_mark)) 
    440440 
    441441    def fetch_flow_sequence_end(self): 
     
    457457 
    458458        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. 
    459         start_marker = self.reader.get_marker() 
     459        start_mark = self.reader.get_mark() 
    460460        self.reader.forward() 
    461         end_marker = self.reader.get_marker() 
    462         self.tokens.append(TokenClass(start_marker, end_marker)) 
     461        end_mark = self.reader.get_mark() 
     462        self.tokens.append(TokenClass(start_mark, end_mark)) 
    463463 
    464464    def fetch_flow_entry(self): 
     
    471471 
    472472        # Add FLOW-ENTRY. 
    473         start_marker = self.reader.get_marker() 
     473        start_mark = self.reader.get_mark() 
    474474        self.reader.forward() 
    475         end_marker = self.reader.get_marker() 
    476         self.tokens.append(FlowEntryToken(start_marker, end_marker)) 
     475        end_mark = self.reader.get_mark() 
     476        self.tokens.append(FlowEntryToken(start_mark, end_mark)) 
    477477 
    478478    def fetch_block_entry(self): 
     
    485485                raise ScannerError(None, None, 
    486486                        "sequence entries are not allowed here", 
    487                         self.reader.get_marker()) 
     487                        self.reader.get_mark()) 
    488488 
    489489            # We may need to add BLOCK-SEQUENCE-START. 
    490490            if self.add_indent(self.reader.column): 
    491                 marker = self.reader.get_marker() 
    492                 self.tokens.append(BlockSequenceStartToken(marker, marker)) 
     491                mark = self.reader.get_mark() 
     492                self.tokens.append(BlockSequenceStartToken(mark, mark)) 
    493493 
    494494        # It's an error for the block entry to occur in the flow context, 
     
    504504 
    505505        # Add BLOCK-ENTRY. 
    506         start_marker = self.reader.get_marker() 
     506        start_mark = self.reader.get_mark() 
    507507        self.reader.forward() 
    508         end_marker = self.reader.get_marker() 
    509         self.tokens.append(BlockEntryToken(start_marker, end_marker)) 
     508        end_mark = self.reader.get_mark() 
     509        self.tokens.append(BlockEntryToken(start_mark, end_mark)) 
    510510 
    511511    def fetch_key(self): 
     
    518518                raise ScannerError(None, None, 
    519519                        "mapping keys are not allowed here", 
    520                         self.reader.get_marker()) 
     520                        self.reader.get_mark()) 
    521521 
    522522            # We may need to add BLOCK-MAPPING-START. 
    523523            if self.add_indent(self.reader.column): 
    524                 marker = self.reader.get_marker() 
    525                 self.tokens.append(BlockMappingStartToken(marker, marker)) 
     524                mark = self.reader.get_mark() 
     525                self.tokens.append(BlockMappingStartToken(mark, mark)) 
    526526 
    527527        # Simple keys are allowed after '?' in the block context. 
     
    532532 
    533533        # Add KEY. 
    534         start_marker = self.reader.get_marker() 
     534        start_mark = self.reader.get_mark() 
    535535        self.reader.forward() 
    536         end_marker = self.reader.get_marker() 
    537         self.tokens.append(KeyToken(start_marker, end_marker)) 
     536        end_mark = self.reader.get_mark() 
     537        self.tokens.append(KeyToken(start_mark, end_mark)) 
    538538 
    539539    def fetch_value(self): 
     
    546546            del self.possible_simple_keys[self.flow_level] 
    547547            self.tokens.insert(key.token_number-self.tokens_taken, 
    548                     KeyToken(key.marker, key.marker)) 
     548                    KeyToken(key.mark, key.mark)) 
    549549 
    550550            # If this key starts a new block mapping, we need to add 
     
    553553                if self.add_indent(key.column): 
    554554                    self.tokens.insert(key.token_number-self.tokens_taken, 
    555                             BlockMappingStartToken(key.marker, key.marker)) 
     555                            BlockMappingStartToken(key.mark, key.mark)) 
    556556 
    557557            # There cannot be two simple keys one after another. 
     
    571571                    raise ScannerError(None, None, 
    572572                            "mapping values are not allowed here", 
    573                             self.reader.get_marker()) 
     573                            self.reader.get_mark()) 
    574574 
    575575            # Simple keys are allowed after ':' in the block context. 
     
    580580 
    581581        # Add VALUE. 
    582         start_marker = self.reader.get_marker() 
     582        start_mark = self.reader.get_mark() 
    583583        self.reader.forward() 
    584         end_marker = self.reader.get_marker() 
    585         self.tokens.append(ValueToken(start_marker, end_marker)) 
     584        end_mark = self.reader.get_mark() 
     585        self.tokens.append(ValueToken(start_mark, end_mark)) 
    586586 
    587587    def fetch_alias(self): 
     
    774774    def scan_directive(self): 
    775775        # See the specification for details. 
    776         start_marker = self.reader.get_marker() 
     776        start_mark = self.reader.get_mark() 
    777777        self.reader.forward() 
    778         name = self.scan_directive_name(start_marker) 
     778        name = self.scan_directive_name(start_mark) 
    779779        value = None 
    780780        if name == u'YAML': 
    781             value = self.scan_yaml_directive_value(start_marker) 
    782             end_marker = self.reader.get_marker() 
     781            value = self.scan_yaml_directive_value(start_mark) 
     782            end_mark = self.reader.get_mark() 
    783783        elif name == u'TAG': 
    784             value = self.scan_tag_directive_value(start_marker) 
    785             end_marker = self.reader.get_marker() 
     784            value = self.scan_tag_directive_value(start_mark) 
     785            end_mark = self.reader.get_mark() 
    786786        else: 
    787             end_marker = self.reader.get_marker() 
     787            end_mark = self.reader.get_mark() 
    788788            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
    789789                self.reader.forward() 
    790         self.scan_directive_ignored_line(start_marker) 
    791         return DirectiveToken(name, value, start_marker, end_marker) 
    792  
    793     def scan_directive_name(self, start_marker): 
     790        self.scan_directive_ignored_line(start_mark) 
     791        return DirectiveToken(name, value, start_mark, end_mark) 
     792 
     793    def scan_directive_name(self, start_mark): 
    794794        # See the specification for details. 
    795795        length = 0 
     
    800800            ch = self.reader.peek(length) 
    801801        if not length: 
    802             raise ScannerError("while scanning a directive", start_marker, 
     802            raise ScannerError("while scanning a directive", start_mark, 
    803803                    "expected alphabetic or numeric character, but found %r" 
    804                     % ch.encode('utf-8'), self.reader.get_marker()) 
     804                    % ch.encode('utf-8'), self.reader.get_mark()) 
    805805        value = self.reader.prefix(length) 
    806806        self.reader.forward(length) 
    807807        ch = self.reader.peek() 
    808808        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    809             raise ScannerError("while scanning a directive", start_marker, 
     809            raise ScannerError("while scanning a directive", start_mark, 
    810810                    "expected alphabetic or numeric character, but found %r" 
    811                     % ch.encode('utf-8'), self.reader.get_marker()) 
     811                    % ch.encode('utf-8'), self.reader.get_mark()) 
    812812        return value 
    813813 
    814     def scan_yaml_directive_value(self, start_marker): 
     814    def scan_yaml_directive_value(self, start_mark): 
    815815        # See the specification for details. 
    816816        while self.reader.peek() == u' ': 
    817817            self.reader.forward() 
    818         major = self.scan_yaml_directive_number(start_marker) 
     818        major = self.scan_yaml_directive_number(start_mark) 
    819819        if self.reader.peek() != '.': 
    820             raise ScannerError("while scanning a directive", start_marker, 
     820            raise ScannerError("while scanning a directive", start_mark, 
    821821                    "expected a digit or '.', but found %r" 
    822822                    % self.reader.peek().encode('utf-8'), 
    823                     self.reader.get_marker()) 
     823                    self.reader.get_mark()) 
    824824        self.reader.forward() 
    825         minor = self.scan_yaml_directive_number(start_marker) 
     825        minor = self.scan_yaml_directive_number(start_mark) 
    826826        if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029': 
    827             raise ScannerError("while scanning a directive", start_marker, 
     827            raise ScannerError("while scanning a directive", start_mark, 
    828828                    "expected a digit or ' ', but found %r" 
    829829                    % self.reader.peek().encode('utf-8'), 
    830                     self.reader.get_marker()) 
     830                    self.reader.get_mark()) 
    831831        return (major, minor) 
    832832 
    833     def scan_yaml_directive_number(self, start_marker): 
     833    def scan_yaml_directive_number(self, start_mark): 
    834834        # See the specification for details. 
    835835        ch = self.reader.peek() 
    836836        if not (u'0' <= ch <= '9'): 
    837             raise ScannerError("while scanning a directive", start_marker, 
     837            raise ScannerError("while scanning a directive", start_mark, 
    838838                    "expected a digit, but found %r" % ch.encode('utf-8'), 
    839                     self.reader.get_marker()) 
     839                    self.reader.get_mark()) 
    840840        length = 0 
    841841        while u'0' <= self.reader.peek(length) <= u'9': 
     
    845845        return value 
    846846 
    847     def scan_tag_directive_value(self, start_marker): 
     847    def scan_tag_directive_value(self, start_mark): 
    848848        # See the specification for details. 
    849849        while self.reader.peek() == u' ': 
    850850            self.reader.forward() 
    851         handle = self.scan_tag_directive_handle(start_marker) 
     851        handle = self.scan_tag_directive_handle(start_mark) 
    852852        while self.reader.peek() == u' ': 
    853853            self.reader.forward() 
    854         prefix = self.scan_tag_directive_prefix(start_marker) 
     854        prefix = self.scan_tag_directive_prefix(start_mark) 
    855855        return (handle, prefix) 
    856856 
    857     def scan_tag_directive_handle(self, start_marker): 
    858         # See the specification for details. 
    859         value = self.scan_tag_handle('directive', start_marker) 
     857    def scan_tag_directive_handle(self, start_mark): 
     858        # See the specification for details. 
     859        value = self.scan_tag_handle('directive', start_mark) 
    860860        ch = self.reader.peek() 
    861861        if ch != u' ': 
    862             raise ScannerError("while scanning a directive", start_marker, 
     862            raise ScannerError("while scanning a directive", start_mark, 
    863863                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    864                     self.reader.get_marker()) 
     864                    self.reader.get_mark()) 
    865865        return value 
    866866 
    867     def scan_tag_directive_prefix(self, start_marker): 
    868         # See the specification for details. 
    869         value = self.scan_tag_uri('directive', start_marker) 
     867    def scan_tag_directive_prefix(self, start_mark): 
     868        # See the specification for details. 
     869        value = self.scan_tag_uri('directive', start_mark) 
    870870        ch = self.reader.peek() 
    871871        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    872             raise ScannerError("while scanning a directive", start_marker, 
     872            raise ScannerError("while scanning a directive", start_mark, 
    873873                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    874                     self.reader.get_marker()) 
     874                    self.reader.get_mark()) 
    875875        return value 
    876876 
    877     def scan_directive_ignored_line(self, start_marker): 
     877    def scan_directive_ignored_line(self, start_mark): 
    878878        # See the specification for details. 
    879879        while self.reader.peek() == u' ': 
     
    884884        ch = self.reader.peek() 
    885885        if ch not in u'\0\r\n\x85\u2028\u2029': 
    886             raise ScannerError("while scanning a directive", start_marker, 
     886            raise ScannerError("while scanning a directive", start_mark, 
    887887                    "expected a comment or a line break, but found %r" 
    888                         % ch.encode('utf-8'), self.reader.get_marker()) 
     888                        % ch.encode('utf-8'), self.reader.get_mark()) 
    889889        self.scan_line_break() 
    890890 
     
    898898        #   [ *alias , "value" ] 
    899899        # Therefore we restrict aliases to numbers and ASCII letters. 
    900         start_marker = self.reader.get_marker() 
     900        start_mark = self.reader.get_mark() 
    901901        indicator = self.reader.peek() 
    902902        if indicator == '*': 
     
    912912            ch = self.reader.peek(length) 
    913913        if not length: 
    914             raise ScannerError("while scanning an %s" % name, start_marker, 
     914            raise ScannerError("while scanning an %s" % name, start_mark, 
    915915                    "expected alphabetic or numeric character, but found %r" 
    916                     % ch.encode('utf-8'), self.reader.get_marker()) 
     916                    % ch.encode('utf-8'), self.reader.get_mark()) 
    917917        value = self.reader.prefix(length) 
    918918        self.reader.forward(length) 
    919919        ch = self.reader.peek() 
    920920        if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
    921             raise ScannerError("while scanning an %s" % name, start_marker, 
     921            raise ScannerError("while scanning an %s" % name, start_mark, 
    922922                    "expected alphabetic or numeric character, but found %r" 
    923                     % ch.encode('utf-8'), self.reader.get_marker()) 
    924         end_marker = self.reader.get_marker() 
    925         return TokenClass(value, start_marker, end_marker) 
     923                    % ch.encode('utf-8'), self.reader.get_mark()) 
     924        end_mark = self.reader.get_mark() 
     925        return TokenClass(value, start_mark, end_mark) 
    926926 
    927927    def scan_tag(self): 
    928928        # See the specification for details. 
    929         start_marker = self.reader.get_marker() 
     929        start_mark = self.reader.get_mark() 
    930930        ch = self.reader.peek(1) 
    931931        if ch == u'<': 
    932932            handle = None 
    933933            self.reader.forward(2) 
    934             suffix = self.scan_tag_uri('tag', start_marker) 
     934            suffix = self.scan_tag_uri('tag', start_mark) 
    935935            if self.reader.peek() != u'>': 
    936                 raise ScannerError("while parsing a tag", start_marker, 
     936                raise ScannerError("while parsing a tag", start_mark, 
    937937                        "expected '>', but found %r" % self.reader.peek().encode('utf-8'), 
    938                         self.reader.get_marker()) 
     938                        self.reader.get_mark()) 
    939939            self.reader.forward() 
    940940        elif ch in u'\0 \t\r\n\x85\u2028\u2029': 
     
    953953            handle = u'!' 
    954954            if use_handle: 
    955                 handle = self.scan_tag_handle('tag', start_marker) 
     955                handle = self.scan_tag_handle('tag', start_mark) 
    956956            else: 
    957957                handle = u'!' 
    958958                self.reader.forward() 
    959             suffix = self.scan_tag_uri('tag', start_marker) 
     959            suffix = self.scan_tag_uri('tag', start_mark) 
    960960        ch = self.reader.peek() 
    961961        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    962             raise ScannerError("while scanning a tag", start_marker, 
     962            raise ScannerError("while scanning a tag", start_mark, 
    963963                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    964                     self.reader.get_marker()) 
     964                    self.reader.get_mark()) 
    965965        value = (handle, suffix) 
    966         end_marker = self.reader.get_marker() 
    967         return TagToken(value, start_marker, end_marker) 
     966        end_mark = self.reader.get_mark() 
     967        return TagToken(value, start_mark, end_mark) 
    968968 
    969969    def scan_block_scalar(self, folded): 
     
    971971 
    972972        chunks = [] 
    973         start_marker = self.reader.get_marker() 
     973        start_mark = self.reader.get_mark() 
    974974 
    975975        # Scan the header. 
    976976        self.reader.forward() 
    977         chomping, increment = self.scan_block_scalar_indicators(start_marker) 
    978         self.scan_block_scalar_ignored_line(start_marker) 
     977        chomping, increment = self.scan_block_scalar_indicators(start_mark) 
     978        self.scan_block_scalar_ignored_line(start_mark) 
    979979 
    980980        # Determine the indentation level and go to the first non-empty line. 
     
    983983            min_indent = 1 
    984984        if increment is None: 
    985             breaks, max_indent, end_marker = self.scan_block_scalar_indentation() 
     985            breaks, max_indent, end_mark = self.scan_block_scalar_indentation() 
    986986            indent = max(min_indent, max_indent) 
    987987        else: 
    988988            indent = min_indent+increment-1 
    989             breaks, end_marker = self.scan_block_scalar_breaks(indent) 
     989            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    990990        line_break = u'' 
    991991 
     
    10001000            self.reader.forward(length) 
    10011001            line_break = self.scan_line_break() 
    1002             breaks, end_marker = self.scan_block_scalar_breaks(indent) 
     1002            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    10031003            if self.reader.column == indent and self.reader.peek() != u'\0': 
    10041004                # Unfortunately, folding rules are ambiguous. 
     
    10341034 
    10351035        # We are done. 
    1036         return ScalarToken(u''.join(chunks), False, start_marker, end_marker) 
    1037  
    1038     def scan_block_scalar_indicators(self, start_marker): 
     1036        return ScalarToken(u''.join(chunks), False, start_mark, end_mark) 
     1037 
     1038    def scan_block_scalar_indicators(self, start_mark): 
    10391039        # See the specification for details. 
    10401040        chomping = None 
     
    10511051                increment = int(ch) 
    10521052                if increment == 0: 
    1053                     raise ScannerError("while scanning a block scalar", start_marker, 
     1053                    raise ScannerError("while scanning a block scalar", start_mark, 
    10541054                            "expected indentation indicator in the range 1-9, but found 0", 
    1055                             self.reader.get_marker()) 
     1055                            self.reader.get_mark()) 
    10561056                self.reader.forward() 
    10571057        elif ch in u'0123456789': 
    10581058            increment = int(ch) 
    10591059            if increment == 0: 
    1060                 raise ScannerError("while scanning a block scalar", start_marker, 
     1060                raise ScannerError("while scanning a block scalar", start_mark, 
    10611061                        "expected indentation indicator in the range 1-9, but found 0", 
    1062                         self.reader.get_marker()) 
     1062                        self.reader.get_mark()) 
    10631063            self.reader.forward() 
    10641064            ch = self.reader.peek() 
     
    10711071        ch = self.reader.peek() 
    10721072        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    1073             raise ScannerError("while scanning a block scalar", start_marker, 
     1073            raise ScannerError("while scanning a block scalar", start_mark, 
    10741074                    "expected chomping or indentation indicators, but found %r" 
    1075                         % ch.encode('utf-8'), self.reader.get_marker()) 
     1075                        % ch.encode('utf-8'), self.reader.get_mark()) 
    10761076        return chomping, increment 
    10771077 
    1078     def scan_block_scalar_ignored_line(self, start_marker): 
     1078    def scan_block_scalar_ignored_line(self, start_mark): 
    10791079        # See the specification for details. 
    10801080        while self.reader.peek() == u' ': 
     
    10851085        ch = self.reader.peek() 
    10861086        if ch not in u'\0\r\n\x85\u2028\u2029': 
    1087             raise ScannerError("while scanning a block scalar", start_marker, 
     1087            raise ScannerError("while scanning a block scalar", start_mark, 
    10881088                    "expected a comment or a line break, but found %r" 
    1089                         % ch.encode('utf-8'), self.reader.get_marker()) 
     1089                        % ch.encode('utf-8'), self.reader.get_mark()) 
    10901090        self.scan_line_break() 
    10911091 
     
    10941094        chunks = [] 
    10951095        max_indent = 0 
    1096         end_marker = self.reader.get_marker() 
     1096        end_mark = self.reader.get_mark() 
    10971097        while self.reader.peek() in u' \r\n\x85\u2028\u2029': 
    10981098            if self.reader.peek() != u' ': 
    10991099                chunks.append(self.scan_line_break()) 
    1100                 end_marker = self.reader.get_marker() 
     1100                end_mark = self.reader.get_mark() 
    11011101            else: 
    11021102                self.reader.forward() 
    11031103                if self.reader.column > max_indent: 
    11041104                    max_indent = self.reader.column 
    1105         return chunks, max_indent, end_marker 
     1105        return chunks, max_indent, end_mark 
    11061106 
    11071107    def scan_block_scalar_breaks(self, indent): 
    11081108        # See the specification for details. 
    11091109        chunks = [] 
    1110         end_marker = self.reader.get_marker() 
     1110        end_mark = self.reader.get_mark() 
    11111111        while self.reader.column < indent and self.reader.peek() == u' ': 
    11121112            self.reader.forward() 
    11131113        while self.reader.peek() in u'\r\n\x85\u2028\u2029': 
    11141114            chunks.append(self.scan_line_break()) 
    1115             end_marker = self.reader.get_marker() 
     1115            end_mark = self.reader.get_mark() 
    11161116            while self.reader.column < indent and self.reader.peek() == u' ': 
    11171117                self.reader.forward() 
    1118         return chunks, end_marker 
     1118        return chunks, end_mark 
    11191119 
    11201120    def scan_flow_scalar(self, double): 
    11211121        # See the specification for details. 
    11221122        chunks = [] 
    1123         start_marker = self.reader.get_marker() 
     1123        start_mark = self.reader.get_mark() 
    11241124        indent = self.indent+1 
    11251125        if indent == 0: 
     
    11271127        quote = self.reader.peek() 
    11281128        self.reader.forward() 
    1129         chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_marker)) 
     1129        chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_mark)) 
    11301130        while self.reader.peek() != quote: 
    1131             chunks.extend(self.scan_flow_scalar_spaces(double, indent, start_marker)) 
    1132             chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_marker)) 
     1131            chunks.extend(self.scan_flow_scalar_spaces(double, indent, start_mark)) 
     1132            chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_mark)) 
    11331133        self.reader.forward() 
    1134         end_marker = self.reader.get_marker() 
    1135         return ScalarToken(u''.join(chunks), False, start_marker, end_marker) 
     1134        end_mark = self.reader.get_mark() 
     1135        return ScalarToken(u''.join(chunks), False, start_mark, end_mark) 
    11361136 
    11371137    ESCAPE_REPLACEMENTS = { 
     
    11611161    } 
    11621162 
    1163     def scan_flow_scalar_non_spaces(self, double, indent, start_marker): 
     1163    def scan_flow_scalar_non_spaces(self, double, indent, start_mark): 
    11641164        # See the specification for details. 
    11651165        chunks = [] 
     
    11891189                    for k in range(length): 
    11901190                        if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
    1191                             raise ScannerError("while scanning a double-quoted scalar", start_marker, 
     1191                            raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    11921192                                    "expected escape sequence of %d hexdecimal numbers, but found %r" % 
    1193                                         (length, self.reader.peek(k).encode('utf-8')), self.reader.get_marker()) 
     1193                                        (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) 
    11941194                    code = int(self.reader.prefix(length), 16) 
    11951195                    chunks.append(unichr(code)) 
     
    11971197                elif ch in u'\r\n\x85\u2028\u2029': 
    11981198                    self.scan_line_break() 
    1199                     chunks.extend(self.scan_flow_scalar_breaks(double, indent, start_marker)) 
     1199                    chunks.extend(self.scan_flow_scalar_breaks(double, indent, start_mark)) 
    12001200                else: 
    1201                     raise ScannerError("while scanning a double-quoted scalar", start_marker, 
    1202                             "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_marker()) 
     1201                    raise ScannerError("while scanning a double-quoted scalar", start_mark, 
     1202                            "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark()) 
    12031203            else: 
    12041204                return chunks 
    12051205 
    1206     def scan_flow_scalar_spaces(self, double, indent, start_marker): 
     1206    def scan_flow_scalar_spaces(self, double, indent, start_mark): 
    12071207        # See the specification for details. 
    12081208        chunks = [] 
     
    12141214        ch = self.reader.peek() 
    12151215        if ch == u'\0': 
    1216             raise ScannerError("while scanning a quoted scalar", start_marker, 
    1217                     "found unexpected end of stream", self.reader.get_marker()) 
     1216            raise ScannerError("while scanning a quoted scalar", start_mark, 
     1217                    "found unexpected end of stream", self.reader.get_mark()) 
    12181218        elif ch in u'\r\n\x85\u2028\u2029': 
    12191219            line_break = self.scan_line_break() 
    1220             breaks = self.scan_flow_scalar_breaks(double, indent, start_marker) 
     1220            breaks = self.scan_flow_scalar_breaks(double, indent, start_mark) 
    12211221            if line_break != u'\n': 
    12221222                chunks.append(line_break) 
     
    12281228        return chunks 
    12291229 
    1230     def scan_flow_scalar_breaks(self, double, indent, start_marker): 
     1230    def scan_flow_scalar_breaks(self, double, indent, start_mark): 
    12311231        # See the specification for details. 
    12321232        chunks = [] 
     
    12391239                if indent == 1: 
    12401240                    s = '' 
    1241                 raise ScannerError("while scanning a quoted scalar", start_marker, 
     1241                raise ScannerError("while scanning a quoted scalar", start_mark, 
    12421242                        "expected %d space%s indentation, but found %r" 
    12431243                        % (indent, s, self.reader.peek().encode('utf-8')), 
    1244                         self.reader.get_marker()) 
     1244                        self.reader.get_mark()) 
    12451245            while self.reader.peek() in u' \t': 
    12461246                self.reader.forward() 
     
    12561256        # We also keep track of the `allow_simple_key` flag here. 
    12571257        chunks = [] 
    1258         start_marker = self.reader.get_marker() 
    1259         end_marker = start_marker 
     1258        start_mark = self.reader.get_mark() 
     1259        end_mark = start_mark 
    12601260        indent = self.indent+1 
    12611261        if indent == 0: 
     
    12801280            chunks.append(self.reader.prefix(length)) 
    12811281            self.reader.forward(length) 
    1282             end_marker = self.reader.get_marker() 
     1282            end_mark = self.reader.get_mark() 
    12831283            spaces = self.scan_plain_spaces(indent) 
    12841284            if not spaces or self.reader.peek() == u'#' \ 
    12851285                    or self.reader.column < indent: 
    12861286                break 
    1287         return ScalarToken(u''.join(chunks), True, start_marker, end_marker) 
     1287        return ScalarToken(u''.join(chunks), True, start_mark, end_mark) 
    12881288 
    12891289    def scan_plain_spaces(self, indent): 
     
    13161316        return chunks 
    13171317 
    1318     def scan_tag_handle(self, name, start_marker): 
     1318    def scan_tag_handle(self, name, start_mark): 
    13191319        # See the specification for details. 
    13201320        # For some strange reasons, the specification does not allow '_' in 
     
    13221322        ch = self.reader.peek() 
    13231323        if ch != u'!': 
    1324             raise ScannerError("while scanning a %s" % name, start_marker, 
     1324            raise ScannerError("while scanning a %s" % name, start_mark, 
    13251325                    "expected '!', but found %r" % ch.encode('utf-8'), 
    1326                     self.reader.get_marker()) 
     1326                    self.reader.get_mark()) 
    13271327        length = 1 
    13281328        ch = self.reader.peek(length) 
     
    13341334            if ch != u'!': 
    13351335                self.reader.forward(length) 
    1336                 raise ScannerError("while scanning a %s" % name, start_marker, 
     1336                raise ScannerError("while scanning a %s" % name, start_mark, 
    13371337                        "expected '!', but found %r" % ch.encode('utf-8'), 
    1338                         self.reader.get_marker()) 
     1338                        self.reader.get_mark()) 
    13391339            length += 1 
    13401340        value = self.reader.prefix(length) 
     
    13421342        return value 
    13431343 
    1344     def scan_tag_uri(self, name, start_marker): 
     1344    def scan_tag_uri(self, name, start_mark): 
    13451345        # See the specification for details. 
    13461346        # Note: we do not check if URI is well-formed. 
     
    13541354                self.reader.forward(length) 
    13551355                length = 0 
    1356                 chunks.append(self.scan_uri_escapes(name, start_marker)) 
     1356                chunks.append(self.scan_uri_escapes(name, start_mark)) 
    13571357            else: 
    13581358                length += 1 
     
    13631363            length = 0 
    13641364        if not chunks: 
    1365             raise ScannerError("while parsing a %s" % name, start_marker, 
     1365            raise ScannerError("while parsing a %s" % name, start_mark, 
    13661366                    "expected URI, but found %r" % ch.encode('utf-8'), 
    1367                     self.reader.get_marker()) 
     1367                    self.reader.get_mark()) 
    13681368        return u''.join(chunks) 
    13691369 
    1370     def scan_uri_escapes(self, name, start_marker): 
     1370    def scan_uri_escapes(self, name, start_mark): 
    13711371        # See the specification for details. 
    13721372        bytes = [] 
    1373         marker = self.reader.get_marker() 
     1373        mark = self.reader.get_mark() 
    13741374        while self.reader.peek() == u'%': 
    13751375            self.reader.forward() 
    13761376            for k in range(2): 
    13771377                if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
    1378                     raise ScannerError("while scanning a %s" % name, start_marker, 
     1378                    raise ScannerError("while scanning a %s" % name, start_mark, 
    13791379                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % 
    1380                                 (self.reader.peek(k).encode('utf-8')), self.reader.get_marker()) 
     1380                                (self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) 
    13811381            bytes.append(chr(int(self.reader.prefix(2), 16))) 
    13821382            self.reader.forward(2) 
     
    13841384            value = unicode(''.join(bytes), 'utf-8') 
    13851385        except UnicodeDecodeError, exc: 
    1386             raise ScannerError("while scanning a %s" % name, start_marker, str(exc), marker) 
     1386            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) 
    13871387        return value 
    13881388 
  • pyyaml/trunk/lib/yaml/tokens.py

    r52 r116  
    11 
    22class Token: 
    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)) 
     
    1717class DirectiveToken(Token): 
    1818    id = '<directive>' 
    19     def __init__(self, name, value, start_marker, end_marker): 
     19    def __init__(self, name, value, start_mark, end_mark): 
    2020        self.name = name 
    2121        self.value = value 
    22         self.start_marker = start_marker 
    23         self.end_marker = end_marker 
     22        self.start_mark = start_mark 
     23        self.end_mark = end_mark 
    2424 
    2525class DocumentStartToken(Token): 
     
    6767class AliasToken(Token): 
    6868    id = '<alias>' 
    69     def __init__(self, value, start_marker, end_marker): 
     69    def __init__(self, value, start_mark, end_mark): 
    7070        self.value = value 
    71         self.start_marker = start_marker 
    72         self.end_marker = end_marker 
     71        self.start_mark = start_mark 
     72        self.end_mark = end_mark 
    7373 
    7474class AnchorToken(Token): 
    7575    id = '<anchor>' 
    76     def __init__(self, value, start_marker, end_marker): 
     76    def __init__(self, value, start_mark, end_mark): 
    7777        self.value = value 
    78         self.start_marker = start_marker 
    79         self.end_marker = end_marker 
     78        self.start_mark = start_mark 
     79        self.end_mark = end_mark 
    8080 
    8181class TagToken(Token): 
    8282    id = '<tag>' 
    83     def __init__(self, value, start_marker, end_marker): 
     83    def __init__(self, value, start_mark, end_mark): 
    8484        self.value = value 
    85         self.start_marker = start_marker 
    86         self.end_marker = end_marker 
     85        self.start_mark = start_mark 
     86        self.end_mark = end_mark 
    8787 
    8888class ScalarToken(Token): 
    8989    id = '<scalar>' 
    90     def __init__(self, value, plain, start_marker, end_marker): 
     90    def __init__(self, value, plain, start_mark, end_mark): 
    9191        self.value = value 
    9292        self.plain = plain 
    93         self.start_marker = start_marker 
    94         self.end_marker = end_marker 
     93        self.start_mark = start_mark 
     94        self.end_mark = end_mark 
    9595 
  • pyyaml/trunk/tests/test_mark.py

    r47 r116  
    22import test_appliance 
    33 
    4 from yaml.reader import Marker 
     4from yaml.reader import Mark 
    55 
    6 class TestMarker(test_appliance.TestAppliance): 
     6class TestMark(test_appliance.TestAppliance): 
    77 
    8     def _testMarkers(self, test_name, markers_filename): 
    9         inputs = file(markers_filename, 'rb').read().split('---\n')[1:] 
     8    def _testMarks(self, test_name, marks_filename): 
     9        inputs = file(marks_filename, 'rb').read().split('---\n')[1:] 
    1010        for input in inputs: 
    1111            index = 0 
     
    1919                    column += 1 
    2020                index += 1 
    21             marker = Marker(test_name, line, column, unicode(input), index) 
    22             snippet = marker.get_snippet(indent=2, max_length=79) 
     21            mark = Mark(test_name, line, column, unicode(input), index) 
     22            snippet = mark.get_snippet(indent=2, max_length=79) 
    2323            #print "INPUT:" 
    2424            #print input 
     
    3131            self.failUnlessEqual(data[len(pointer)-1], '*') 
    3232 
    33 TestMarker.add_tests('testMarkers', '.markers') 
     33TestMark.add_tests('testMarks', '.marks') 
    3434 
  • pyyaml/trunk/tests/test_yaml.py

    r58 r116  
    22import unittest 
    33 
    4 from test_marker import * 
     4from test_mark import * 
    55from test_reader import * 
    66from test_canonical import * 
Note: See TracChangeset for help on using the changeset viewer.