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

Back to work :). Rename markers to marks.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib/yaml/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 
Note: See TracChangeset for help on using the changeset viewer.