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

Major refactoring.

File:
1 edited

Legend:

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

    r132 r136  
    4646class Scanner: 
    4747 
    48  
    49     def __init__(self, reader): 
     48    def __init__(self): 
    5049        """Initialize the scanner.""" 
    51         # The input stream. The Reader class do the dirty work of checking for 
    52         # BOM and converting the input data to Unicode. It also adds NUL to 
    53         # the end. 
     50        # It is assumed that Scanner and Reader will have a common descendant. 
     51        # Reader do the dirty work of checking for BOM and converting the 
     52        # input data to Unicode. It also adds NUL to the end. 
    5453        # 
    5554        # Reader supports the following methods 
    56         #   self.reader.peek(i=0)       # peek the next i-th character 
    57         #   self.reader.prefix(l=1)     # peek the next l characters 
    58         #   self.reader.forward(l=1)    # read the next l characters 
    59                                         # and move the pointer 
    60         self.reader = reader 
     55        #   self.peek(i=0)       # peek the next i-th character 
     56        #   self.prefix(l=1)     # peek the next l characters 
     57        #   self.forward(l=1)    # read the next l characters and move the pointer. 
    6158 
    6259        # Had we reached the end of the stream? 
     
    114111    # Public methods. 
    115112 
    116     def check(self, *choices): 
     113    def check_token(self, *choices): 
    117114        # Check if the next token is one of the given types. 
    118115        while self.need_more_tokens(): 
    119116            self.fetch_more_tokens() 
    120117        if self.tokens: 
     118            if not choices: 
     119                return True 
    121120            for choice in choices: 
    122121                if isinstance(self.tokens[0], choice): 
     
    124123        return False 
    125124 
    126     def peek(self): 
     125    def peek_token(self): 
    127126        # Return the next token, but do not delete if from the queue. 
    128127        while self.need_more_tokens(): 
     
    131130            return self.tokens[0] 
    132131 
    133     def get(self): 
     132    def get_token(self): 
    134133        # Return the next token. 
    135134        while self.need_more_tokens(): 
     
    172171        # Compare the current indentation and column. It may add some tokens 
    173172        # and decrease the current indentation level. 
    174         self.unwind_indent(self.reader.column) 
     173        self.unwind_indent(self.column) 
    175174 
    176175        # Peek the next character. 
    177         ch = self.reader.peek() 
     176        ch = self.peek() 
    178177 
    179178        # Is it the end of stream? 
     
    266265        raise ScannerError("while scanning for the next token", None, 
    267266                "found character %r that cannot start any token" 
    268                 % ch.encode('utf-8'), self.reader.get_mark()) 
     267                % ch.encode('utf-8'), self.get_mark()) 
    269268 
    270269    # Simple keys treatment. 
     
    294293        for level in self.possible_simple_keys.keys(): 
    295294            key = self.possible_simple_keys[level] 
    296             if key.line != self.reader.line  \ 
    297                     or self.reader.index-key.index > 1024: 
     295            if key.line != self.line  \ 
     296                    or self.index-key.index > 1024: 
    298297                if key.required: 
    299298                    raise ScannerError("while scanning a simple key", key.mark, 
    300                             "could not found expected ':'", self.reader.get_mark()) 
     299                            "could not found expected ':'", self.get_mark()) 
    301300                del self.possible_simple_keys[level] 
    302301 
     
    307306 
    308307        # Check if a simple key is required at the current position. 
    309         required = not self.flow_level and self.indent == self.reader.column 
     308        required = not self.flow_level and self.indent == self.column 
    310309 
    311310        # A simple key is required only if it is the first token in the current 
     
    318317            self.remove_possible_simple_key() 
    319318            token_number = self.tokens_taken+len(self.tokens) 
    320             index = self.reader.index 
    321             line = self.reader.line 
    322             column = self.reader.column 
    323             mark = self.reader.get_mark() 
    324319            key = SimpleKey(token_number, required, 
    325                     index, line, column, mark) 
     320                    self.index, self.line, self.column, self.get_mark()) 
    326321            self.possible_simple_keys[self.flow_level] = key 
    327322 
     
    335330            #if key.required: 
    336331            #    raise ScannerError("while scanning a simple key", key.mark, 
    337             #            "could not found expected ':'", self.reader.get_mark()) 
     332            #            "could not found expected ':'", self.get_mark()) 
    338333 
    339334    # Indentation functions. 
     
    350345        #    raise ScannerError(None, None, 
    351346        #            "invalid intendation or unclosed '[' or '{'", 
    352         #            self.reader.get_mark()) 
     347        #            self.get_mark()) 
    353348 
    354349        # In the flow context, indentation is ignored. We make the scanner less 
     
    359354        # In block context, we may need to issue the BLOCK-END tokens. 
    360355        while self.indent > column: 
    361             mark = self.reader.get_mark() 
     356            mark = self.get_mark() 
    362357            self.indent = self.indents.pop() 
    363358            self.tokens.append(BlockEndToken(mark, mark)) 
     
    378373 
    379374        # Read the token. 
    380         mark = self.reader.get_mark() 
     375        mark = self.get_mark() 
    381376         
    382377        # Add STREAM-START. 
    383378        self.tokens.append(StreamStartToken(mark, mark, 
    384             encoding=self.reader.encoding)) 
     379            encoding=self.encoding)) 
    385380         
    386381 
     
    395390 
    396391        # Read the token. 
    397         mark = self.reader.get_mark() 
     392        mark = self.get_mark() 
    398393         
    399394        # Add STREAM-END. 
    400395        self.tokens.append(StreamEndToken(mark, mark)) 
    401396 
    402         # The reader is ended. 
     397        # The steam is finished. 
    403398        self.done = True 
    404399 
     
    432427 
    433428        # Add DOCUMENT-START or DOCUMENT-END. 
    434         start_mark = self.reader.get_mark() 
    435         self.reader.forward(3) 
    436         end_mark = self.reader.get_mark() 
     429        start_mark = self.get_mark() 
     430        self.forward(3) 
     431        end_mark = self.get_mark() 
    437432        self.tokens.append(TokenClass(start_mark, end_mark)) 
    438433 
     
    455450 
    456451        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. 
    457         start_mark = self.reader.get_mark() 
    458         self.reader.forward() 
    459         end_mark = self.reader.get_mark() 
     452        start_mark = self.get_mark() 
     453        self.forward() 
     454        end_mark = self.get_mark() 
    460455        self.tokens.append(TokenClass(start_mark, end_mark)) 
    461456 
     
    478473 
    479474        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. 
    480         start_mark = self.reader.get_mark() 
    481         self.reader.forward() 
    482         end_mark = self.reader.get_mark() 
     475        start_mark = self.get_mark() 
     476        self.forward() 
     477        end_mark = self.get_mark() 
    483478        self.tokens.append(TokenClass(start_mark, end_mark)) 
    484479 
     
    492487 
    493488        # Add FLOW-ENTRY. 
    494         start_mark = self.reader.get_mark() 
    495         self.reader.forward() 
    496         end_mark = self.reader.get_mark() 
     489        start_mark = self.get_mark() 
     490        self.forward() 
     491        end_mark = self.get_mark() 
    497492        self.tokens.append(FlowEntryToken(start_mark, end_mark)) 
    498493 
     
    506501                raise ScannerError(None, None, 
    507502                        "sequence entries are not allowed here", 
    508                         self.reader.get_mark()) 
     503                        self.get_mark()) 
    509504 
    510505            # We may need to add BLOCK-SEQUENCE-START. 
    511             if self.add_indent(self.reader.column): 
    512                 mark = self.reader.get_mark() 
     506            if self.add_indent(self.column): 
     507                mark = self.get_mark() 
    513508                self.tokens.append(BlockSequenceStartToken(mark, mark)) 
    514509 
     
    525520 
    526521        # Add BLOCK-ENTRY. 
    527         start_mark = self.reader.get_mark() 
    528         self.reader.forward() 
    529         end_mark = self.reader.get_mark() 
     522        start_mark = self.get_mark() 
     523        self.forward() 
     524        end_mark = self.get_mark() 
    530525        self.tokens.append(BlockEntryToken(start_mark, end_mark)) 
    531526 
     
    539534                raise ScannerError(None, None, 
    540535                        "mapping keys are not allowed here", 
    541                         self.reader.get_mark()) 
     536                        self.get_mark()) 
    542537 
    543538            # We may need to add BLOCK-MAPPING-START. 
    544             if self.add_indent(self.reader.column): 
    545                 mark = self.reader.get_mark() 
     539            if self.add_indent(self.column): 
     540                mark = self.get_mark() 
    546541                self.tokens.append(BlockMappingStartToken(mark, mark)) 
    547542 
     
    553548 
    554549        # Add KEY. 
    555         start_mark = self.reader.get_mark() 
    556         self.reader.forward() 
    557         end_mark = self.reader.get_mark() 
     550        start_mark = self.get_mark() 
     551        self.forward() 
     552        end_mark = self.get_mark() 
    558553        self.tokens.append(KeyToken(start_mark, end_mark)) 
    559554 
     
    592587                    raise ScannerError(None, None, 
    593588                            "mapping values are not allowed here", 
    594                             self.reader.get_mark()) 
     589                            self.get_mark()) 
    595590 
    596591            # Simple keys are allowed after ':' in the block context. 
     
    601596 
    602597        # Add VALUE. 
    603         start_mark = self.reader.get_mark() 
    604         self.reader.forward() 
    605         end_mark = self.reader.get_mark() 
     598        start_mark = self.get_mark() 
     599        self.forward() 
     600        end_mark = self.get_mark() 
    606601        self.tokens.append(ValueToken(start_mark, end_mark)) 
    607602 
     
    692687        # DIRECTIVE:        ^ '%' ... 
    693688        # The '%' indicator is already checked. 
    694         if self.reader.column == 0: 
     689        if self.column == 0: 
    695690            return True 
    696691 
     
    698693 
    699694        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    700         if self.reader.column == 0: 
    701             if self.reader.prefix(3) == u'---'  \ 
    702                     and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     695        if self.column == 0: 
     696            if self.prefix(3) == u'---'  \ 
     697                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    703698                return True 
    704699 
     
    706701 
    707702        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    708         if self.reader.column == 0: 
    709             prefix = self.reader.peek(4) 
    710             if self.reader.prefix(3) == u'...'  \ 
    711                     and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     703        if self.column == 0: 
     704            prefix = self.peek(4) 
     705            if self.prefix(3) == u'...'  \ 
     706                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    712707                return True 
    713708 
     
    715710 
    716711        # BLOCK-ENTRY:      '-' (' '|'\n') 
    717         return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     712        return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    718713 
    719714    def check_key(self): 
     
    725720        # KEY(block context):   '?' (' '|'\n') 
    726721        else: 
    727             return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     722            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    728723 
    729724    def check_value(self): 
     
    735730        # VALUE(block context): ':' (' '|'\n') 
    736731        else: 
    737             return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     732            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    738733 
    739734    def check_plain(self): 
     
    751746        # '-' character) because we want the flow context to be space 
    752747        # independent. 
    753         ch = self.reader.peek() 
     748        ch = self.peek() 
    754749        return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \ 
    755                 or (self.reader.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' 
     750                or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' 
    756751                        and (ch == u'-' or (not self.flow_level and ch in u'?:'))) 
    757752 
     
    778773        # Scanners for block, flow, and plain scalars need to be modified. 
    779774 
    780         if self.reader.index == 0 and self.reader.peek() == u'\uFEFF': 
    781             self.reader.forward() 
     775        if self.index == 0 and self.peek() == u'\uFEFF': 
     776            self.forward() 
    782777        found = False 
    783778        while not found: 
    784             while self.reader.peek() == u' ': 
    785                 self.reader.forward() 
    786             if self.reader.peek() == u'#': 
    787                 while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
    788                     self.reader.forward() 
     779            while self.peek() == u' ': 
     780                self.forward() 
     781            if self.peek() == u'#': 
     782                while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     783                    self.forward() 
    789784            if self.scan_line_break(): 
    790785                if not self.flow_level: 
     
    795790    def scan_directive(self): 
    796791        # See the specification for details. 
    797         start_mark = self.reader.get_mark() 
    798         self.reader.forward() 
     792        start_mark = self.get_mark() 
     793        self.forward() 
    799794        name = self.scan_directive_name(start_mark) 
    800795        value = None 
    801796        if name == u'YAML': 
    802797            value = self.scan_yaml_directive_value(start_mark) 
    803             end_mark = self.reader.get_mark() 
     798            end_mark = self.get_mark() 
    804799        elif name == u'TAG': 
    805800            value = self.scan_tag_directive_value(start_mark) 
    806             end_mark = self.reader.get_mark() 
     801            end_mark = self.get_mark() 
    807802        else: 
    808             end_mark = self.reader.get_mark() 
    809             while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
    810                 self.reader.forward() 
     803            end_mark = self.get_mark() 
     804            while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     805                self.forward() 
    811806        self.scan_directive_ignored_line(start_mark) 
    812807        return DirectiveToken(name, value, start_mark, end_mark) 
     
    815810        # See the specification for details. 
    816811        length = 0 
    817         ch = self.reader.peek(length) 
     812        ch = self.peek(length) 
    818813        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    819814                or ch in u'-_': 
    820815            length += 1 
    821             ch = self.reader.peek(length) 
     816            ch = self.peek(length) 
    822817        if not length: 
    823818            raise ScannerError("while scanning a directive", start_mark, 
    824819                    "expected alphabetic or numeric character, but found %r" 
    825                     % ch.encode('utf-8'), self.reader.get_mark()) 
    826         value = self.reader.prefix(length) 
    827         self.reader.forward(length) 
    828         ch = self.reader.peek() 
     820                    % ch.encode('utf-8'), self.get_mark()) 
     821        value = self.prefix(length) 
     822        self.forward(length) 
     823        ch = self.peek() 
    829824        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    830825            raise ScannerError("while scanning a directive", start_mark, 
    831826                    "expected alphabetic or numeric character, but found %r" 
    832                     % ch.encode('utf-8'), self.reader.get_mark()) 
     827                    % ch.encode('utf-8'), self.get_mark()) 
    833828        return value 
    834829 
    835830    def scan_yaml_directive_value(self, start_mark): 
    836831        # See the specification for details. 
    837         while self.reader.peek() == u' ': 
    838             self.reader.forward() 
     832        while self.peek() == u' ': 
     833            self.forward() 
    839834        major = self.scan_yaml_directive_number(start_mark) 
    840         if self.reader.peek() != '.': 
     835        if self.peek() != '.': 
    841836            raise ScannerError("while scanning a directive", start_mark, 
    842837                    "expected a digit or '.', but found %r" 
    843                     % self.reader.peek().encode('utf-8'), 
    844                     self.reader.get_mark()) 
    845         self.reader.forward() 
     838                    % self.peek().encode('utf-8'), 
     839                    self.get_mark()) 
     840        self.forward() 
    846841        minor = self.scan_yaml_directive_number(start_mark) 
    847         if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029': 
     842        if self.peek() not in u'\0 \r\n\x85\u2028\u2029': 
    848843            raise ScannerError("while scanning a directive", start_mark, 
    849844                    "expected a digit or ' ', but found %r" 
    850                     % self.reader.peek().encode('utf-8'), 
    851                     self.reader.get_mark()) 
     845                    % self.peek().encode('utf-8'), 
     846                    self.get_mark()) 
    852847        return (major, minor) 
    853848 
    854849    def scan_yaml_directive_number(self, start_mark): 
    855850        # See the specification for details. 
    856         ch = self.reader.peek() 
     851        ch = self.peek() 
    857852        if not (u'0' <= ch <= '9'): 
    858853            raise ScannerError("while scanning a directive", start_mark, 
    859854                    "expected a digit, but found %r" % ch.encode('utf-8'), 
    860                     self.reader.get_mark()) 
     855                    self.get_mark()) 
    861856        length = 0 
    862         while u'0' <= self.reader.peek(length) <= u'9': 
     857        while u'0' <= self.peek(length) <= u'9': 
    863858            length += 1 
    864         value = int(self.reader.prefix(length)) 
    865         self.reader.forward(length) 
     859        value = int(self.prefix(length)) 
     860        self.forward(length) 
    866861        return value 
    867862 
    868863    def scan_tag_directive_value(self, start_mark): 
    869864        # See the specification for details. 
    870         while self.reader.peek() == u' ': 
    871             self.reader.forward() 
     865        while self.peek() == u' ': 
     866            self.forward() 
    872867        handle = self.scan_tag_directive_handle(start_mark) 
    873         while self.reader.peek() == u' ': 
    874             self.reader.forward() 
     868        while self.peek() == u' ': 
     869            self.forward() 
    875870        prefix = self.scan_tag_directive_prefix(start_mark) 
    876871        return (handle, prefix) 
     
    879874        # See the specification for details. 
    880875        value = self.scan_tag_handle('directive', start_mark) 
    881         ch = self.reader.peek() 
     876        ch = self.peek() 
    882877        if ch != u' ': 
    883878            raise ScannerError("while scanning a directive", start_mark, 
    884879                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    885                     self.reader.get_mark()) 
     880                    self.get_mark()) 
    886881        return value 
    887882 
     
    889884        # See the specification for details. 
    890885        value = self.scan_tag_uri('directive', start_mark) 
    891         ch = self.reader.peek() 
     886        ch = self.peek() 
    892887        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    893888            raise ScannerError("while scanning a directive", start_mark, 
    894889                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    895                     self.reader.get_mark()) 
     890                    self.get_mark()) 
    896891        return value 
    897892 
    898893    def scan_directive_ignored_line(self, start_mark): 
    899894        # See the specification for details. 
    900         while self.reader.peek() == u' ': 
    901             self.reader.forward() 
    902         if self.reader.peek() == u'#': 
    903             while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
    904                 self.reader.forward() 
    905         ch = self.reader.peek() 
     895        while self.peek() == u' ': 
     896            self.forward() 
     897        if self.peek() == u'#': 
     898            while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     899                self.forward() 
     900        ch = self.peek() 
    906901        if ch not in u'\0\r\n\x85\u2028\u2029': 
    907902            raise ScannerError("while scanning a directive", start_mark, 
    908903                    "expected a comment or a line break, but found %r" 
    909                         % ch.encode('utf-8'), self.reader.get_mark()) 
     904                        % ch.encode('utf-8'), self.get_mark()) 
    910905        self.scan_line_break() 
    911906 
     
    919914        #   [ *alias , "value" ] 
    920915        # Therefore we restrict aliases to numbers and ASCII letters. 
    921         start_mark = self.reader.get_mark() 
    922         indicator = self.reader.peek() 
     916        start_mark = self.get_mark() 
     917        indicator = self.peek() 
    923918        if indicator == '*': 
    924919            name = 'alias' 
    925920        else: 
    926921            name = 'anchor' 
    927         self.reader.forward() 
     922        self.forward() 
    928923        length = 0 
    929         ch = self.reader.peek(length) 
     924        ch = self.peek(length) 
    930925        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    931926                or ch in u'-_': 
    932927            length += 1 
    933             ch = self.reader.peek(length) 
     928            ch = self.peek(length) 
    934929        if not length: 
    935930            raise ScannerError("while scanning an %s" % name, start_mark, 
    936931                    "expected alphabetic or numeric character, but found %r" 
    937                     % ch.encode('utf-8'), self.reader.get_mark()) 
    938         value = self.reader.prefix(length) 
    939         self.reader.forward(length) 
    940         ch = self.reader.peek() 
     932                    % ch.encode('utf-8'), self.get_mark()) 
     933        value = self.prefix(length) 
     934        self.forward(length) 
     935        ch = self.peek() 
    941936        if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
    942937            raise ScannerError("while scanning an %s" % name, start_mark, 
    943938                    "expected alphabetic or numeric character, but found %r" 
    944                     % ch.encode('utf-8'), self.reader.get_mark()) 
    945         end_mark = self.reader.get_mark() 
     939                    % ch.encode('utf-8'), self.get_mark()) 
     940        end_mark = self.get_mark() 
    946941        return TokenClass(value, start_mark, end_mark) 
    947942 
    948943    def scan_tag(self): 
    949944        # See the specification for details. 
    950         start_mark = self.reader.get_mark() 
    951         ch = self.reader.peek(1) 
     945        start_mark = self.get_mark() 
     946        ch = self.peek(1) 
    952947        if ch == u'<': 
    953948            handle = None 
    954             self.reader.forward(2) 
     949            self.forward(2) 
    955950            suffix = self.scan_tag_uri('tag', start_mark) 
    956             if self.reader.peek() != u'>': 
     951            if self.peek() != u'>': 
    957952                raise ScannerError("while parsing a tag", start_mark, 
    958                         "expected '>', but found %r" % self.reader.peek().encode('utf-8'), 
    959                         self.reader.get_mark()) 
    960             self.reader.forward() 
     953                        "expected '>', but found %r" % self.peek().encode('utf-8'), 
     954                        self.get_mark()) 
     955            self.forward() 
    961956        elif ch in u'\0 \t\r\n\x85\u2028\u2029': 
    962957            handle = None 
    963958            suffix = u'!' 
    964             self.reader.forward() 
     959            self.forward() 
    965960        else: 
    966961            length = 1 
     
    971966                    break 
    972967                length += 1 
    973                 ch = self.reader.peek(length) 
     968                ch = self.peek(length) 
    974969            handle = u'!' 
    975970            if use_handle: 
     
    977972            else: 
    978973                handle = u'!' 
    979                 self.reader.forward() 
     974                self.forward() 
    980975            suffix = self.scan_tag_uri('tag', start_mark) 
    981         ch = self.reader.peek() 
     976        ch = self.peek() 
    982977        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    983978            raise ScannerError("while scanning a tag", start_mark, 
    984979                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    985                     self.reader.get_mark()) 
     980                    self.get_mark()) 
    986981        value = (handle, suffix) 
    987         end_mark = self.reader.get_mark() 
     982        end_mark = self.get_mark() 
    988983        return TagToken(value, start_mark, end_mark) 
    989984 
     
    997992 
    998993        chunks = [] 
    999         start_mark = self.reader.get_mark() 
     994        start_mark = self.get_mark() 
    1000995 
    1001996        # Scan the header. 
    1002         self.reader.forward() 
     997        self.forward() 
    1003998        chomping, increment = self.scan_block_scalar_indicators(start_mark) 
    1004999        self.scan_block_scalar_ignored_line(start_mark) 
     
    10171012 
    10181013        # Scan the inner part of the block scalar. 
    1019         while self.reader.column == indent and self.reader.peek() != u'\0': 
     1014        while self.column == indent and self.peek() != u'\0': 
    10201015            chunks.extend(breaks) 
    1021             leading_non_space = self.reader.peek() not in u' \t' 
     1016            leading_non_space = self.peek() not in u' \t' 
    10221017            length = 0 
    1023             while self.reader.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
     1018            while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
    10241019                length += 1 
    1025             chunks.append(self.reader.prefix(length)) 
    1026             self.reader.forward(length) 
     1020            chunks.append(self.prefix(length)) 
     1021            self.forward(length) 
    10271022            line_break = self.scan_line_break() 
    10281023            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1029             if self.reader.column == indent and self.reader.peek() != u'\0': 
     1024            if self.column == indent and self.peek() != u'\0': 
    10301025 
    10311026                # Unfortunately, folding rules are ambiguous. 
     
    10341029                 
    10351030                if folded and line_break == u'\n'   \ 
    1036                         and leading_non_space and self.reader.peek() not in u' \t': 
     1031                        and leading_non_space and self.peek() not in u' \t': 
    10371032                    if not breaks: 
    10381033                        chunks.append(u' ') 
     
    10451040                #if folded and line_break == u'\n': 
    10461041                #    if not breaks: 
    1047                 #        if self.reader.peek() not in ' \t': 
     1042                #        if self.peek() not in ' \t': 
    10481043                #            chunks.append(u' ') 
    10491044                #        else: 
     
    10681063        chomping = None 
    10691064        increment = None 
    1070         ch = self.reader.peek() 
     1065        ch = self.peek() 
    10711066        if ch in u'+-': 
    10721067            if ch == '+': 
     
    10741069            else: 
    10751070                chomping = False 
    1076             self.reader.forward() 
    1077             ch = self.reader.peek() 
     1071            self.forward() 
     1072            ch = self.peek() 
    10781073            if ch in u'0123456789': 
    10791074                increment = int(ch) 
     
    10811076                    raise ScannerError("while scanning a block scalar", start_mark, 
    10821077                            "expected indentation indicator in the range 1-9, but found 0", 
    1083                             self.reader.get_mark()) 
    1084                 self.reader.forward() 
     1078                            self.get_mark()) 
     1079                self.forward() 
    10851080        elif ch in u'0123456789': 
    10861081            increment = int(ch) 
     
    10881083                raise ScannerError("while scanning a block scalar", start_mark, 
    10891084                        "expected indentation indicator in the range 1-9, but found 0", 
    1090                         self.reader.get_mark()) 
    1091             self.reader.forward() 
    1092             ch = self.reader.peek() 
     1085                        self.get_mark()) 
     1086            self.forward() 
     1087            ch = self.peek() 
    10931088            if ch in u'+-': 
    10941089                if ch == '+': 
     
    10961091                else: 
    10971092                    chomping = False 
    1098                 self.reader.forward() 
    1099         ch = self.reader.peek() 
     1093                self.forward() 
     1094        ch = self.peek() 
    11001095        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    11011096            raise ScannerError("while scanning a block scalar", start_mark, 
    11021097                    "expected chomping or indentation indicators, but found %r" 
    1103                         % ch.encode('utf-8'), self.reader.get_mark()) 
     1098                        % ch.encode('utf-8'), self.get_mark()) 
    11041099        return chomping, increment 
    11051100 
    11061101    def scan_block_scalar_ignored_line(self, start_mark): 
    11071102        # See the specification for details. 
    1108         while self.reader.peek() == u' ': 
    1109             self.reader.forward() 
    1110         if self.reader.peek() == u'#': 
    1111             while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
    1112                 self.reader.forward() 
    1113         ch = self.reader.peek() 
     1103        while self.peek() == u' ': 
     1104            self.forward() 
     1105        if self.peek() == u'#': 
     1106            while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     1107                self.forward() 
     1108        ch = self.peek() 
    11141109        if ch not in u'\0\r\n\x85\u2028\u2029': 
    11151110            raise ScannerError("while scanning a block scalar", start_mark, 
    11161111                    "expected a comment or a line break, but found %r" 
    1117                         % ch.encode('utf-8'), self.reader.get_mark()) 
     1112                        % ch.encode('utf-8'), self.get_mark()) 
    11181113        self.scan_line_break() 
    11191114 
     
    11221117        chunks = [] 
    11231118        max_indent = 0 
    1124         end_mark = self.reader.get_mark() 
    1125         while self.reader.peek() in u' \r\n\x85\u2028\u2029': 
    1126             if self.reader.peek() != u' ': 
     1119        end_mark = self.get_mark() 
     1120        while self.peek() in u' \r\n\x85\u2028\u2029': 
     1121            if self.peek() != u' ': 
    11271122                chunks.append(self.scan_line_break()) 
    1128                 end_mark = self.reader.get_mark() 
     1123                end_mark = self.get_mark() 
    11291124            else: 
    1130                 self.reader.forward() 
    1131                 if self.reader.column > max_indent: 
    1132                     max_indent = self.reader.column 
     1125                self.forward() 
     1126                if self.column > max_indent: 
     1127                    max_indent = self.column 
    11331128        return chunks, max_indent, end_mark 
    11341129 
     
    11361131        # See the specification for details. 
    11371132        chunks = [] 
    1138         end_mark = self.reader.get_mark() 
    1139         while self.reader.column < indent and self.reader.peek() == u' ': 
    1140             self.reader.forward() 
    1141         while self.reader.peek() in u'\r\n\x85\u2028\u2029': 
     1133        end_mark = self.get_mark() 
     1134        while self.column < indent and self.peek() == u' ': 
     1135            self.forward() 
     1136        while self.peek() in u'\r\n\x85\u2028\u2029': 
    11421137            chunks.append(self.scan_line_break()) 
    1143             end_mark = self.reader.get_mark() 
    1144             while self.reader.column < indent and self.reader.peek() == u' ': 
    1145                 self.reader.forward() 
     1138            end_mark = self.get_mark() 
     1139            while self.column < indent and self.peek() == u' ': 
     1140                self.forward() 
    11461141        return chunks, end_mark 
    11471142 
     
    11581153            double = False 
    11591154        chunks = [] 
    1160         start_mark = self.reader.get_mark() 
    1161         quote = self.reader.peek() 
    1162         self.reader.forward() 
     1155        start_mark = self.get_mark() 
     1156        quote = self.peek() 
     1157        self.forward() 
    11631158        chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) 
    1164         while self.reader.peek() != quote: 
     1159        while self.peek() != quote: 
    11651160            chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) 
    11661161            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) 
    1167         self.reader.forward() 
    1168         end_mark = self.reader.get_mark() 
     1162        self.forward() 
     1163        end_mark = self.get_mark() 
    11691164        return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
    11701165                style) 
     
    12011196        while True: 
    12021197            length = 0 
    1203             while self.reader.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
     1198            while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
    12041199                length += 1 
    12051200            if length: 
    1206                 chunks.append(self.reader.prefix(length)) 
    1207                 self.reader.forward(length) 
    1208             ch = self.reader.peek() 
    1209             if not double and ch == u'\'' and self.reader.peek(1) == u'\'': 
     1201                chunks.append(self.prefix(length)) 
     1202                self.forward(length) 
     1203            ch = self.peek() 
     1204            if not double and ch == u'\'' and self.peek(1) == u'\'': 
    12101205                chunks.append(u'\'') 
    1211                 self.reader.forward(2) 
     1206                self.forward(2) 
    12121207            elif (double and ch == u'\'') or (not double and ch in u'\"\\'): 
    12131208                chunks.append(ch) 
    1214                 self.reader.forward() 
     1209                self.forward() 
    12151210            elif double and ch == u'\\': 
    1216                 self.reader.forward() 
    1217                 ch = self.reader.peek() 
     1211                self.forward() 
     1212                ch = self.peek() 
    12181213                if ch in self.ESCAPE_REPLACEMENTS: 
    12191214                    chunks.append(self.ESCAPE_REPLACEMENTS[ch]) 
    1220                     self.reader.forward() 
     1215                    self.forward() 
    12211216                elif ch in self.ESCAPE_CODES: 
    12221217                    length = self.ESCAPE_CODES[ch] 
    1223                     self.reader.forward() 
     1218                    self.forward() 
    12241219                    for k in range(length): 
    1225                         if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
     1220                        if self.peek(k) not in u'0123456789ABCDEFabcdef': 
    12261221                            raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    12271222                                    "expected escape sequence of %d hexdecimal numbers, but found %r" % 
    1228                                         (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) 
    1229                     code = int(self.reader.prefix(length), 16) 
     1223                                        (length, self.peek(k).encode('utf-8')), self.get_mark()) 
     1224                    code = int(self.prefix(length), 16) 
    12301225                    chunks.append(unichr(code)) 
    1231                     self.reader.forward(length) 
     1226                    self.forward(length) 
    12321227                elif ch in u'\r\n\x85\u2028\u2029': 
    12331228                    self.scan_line_break() 
     
    12351230                else: 
    12361231                    raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    1237                             "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark()) 
     1232                            "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark()) 
    12381233            else: 
    12391234                return chunks 
     
    12431238        chunks = [] 
    12441239        length = 0 
    1245         while self.reader.peek(length) in u' \t': 
     1240        while self.peek(length) in u' \t': 
    12461241            length += 1 
    1247         whitespaces = self.reader.prefix(length) 
    1248         self.reader.forward(length) 
    1249         ch = self.reader.peek() 
     1242        whitespaces = self.prefix(length) 
     1243        self.forward(length) 
     1244        ch = self.peek() 
    12501245        if ch == u'\0': 
    12511246            raise ScannerError("while scanning a quoted scalar", start_mark, 
    1252                     "found unexpected end of stream", self.reader.get_mark()) 
     1247                    "found unexpected end of stream", self.get_mark()) 
    12531248        elif ch in u'\r\n\x85\u2028\u2029': 
    12541249            line_break = self.scan_line_break() 
     
    12691264            # Instead of checking indentation, we check for document 
    12701265            # separators. 
    1271             prefix = self.reader.prefix(3) 
     1266            prefix = self.prefix(3) 
    12721267            if (prefix == u'---' or prefix == u'...')   \ 
    1273                     and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1268                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    12741269                raise ScannerError("while scanning a quoted scalar", start_mark, 
    1275                         "found unexpected document separator", self.reader.get_mark()) 
    1276             while self.reader.peek() in u' \t': 
    1277                 self.reader.forward() 
    1278             if self.reader.peek() in u'\r\n\x85\u2028\u2029': 
     1270                        "found unexpected document separator", self.get_mark()) 
     1271            while self.peek() in u' \t': 
     1272                self.forward() 
     1273            if self.peek() in u'\r\n\x85\u2028\u2029': 
    12791274                chunks.append(self.scan_line_break()) 
    12801275            else: 
     
    12881283        # Indentation rules are loosed for the flow context. 
    12891284        chunks = [] 
    1290         start_mark = self.reader.get_mark() 
     1285        start_mark = self.get_mark() 
    12911286        end_mark = start_mark 
    12921287        indent = self.indent+1 
     
    12981293        while True: 
    12991294            length = 0 
    1300             if self.reader.peek() == u'#': 
     1295            if self.peek() == u'#': 
    13011296                break 
    13021297            while True: 
    1303                 ch = self.reader.peek(length) 
     1298                ch = self.peek(length) 
    13041299                if ch in u'\0 \t\r\n\x85\u2028\u2029'   \ 
    13051300                        or (not self.flow_level and ch == u':' and 
    1306                                 self.reader.peek(length+1) in u'\0 \t\r\n\x28\u2028\u2029') \ 
     1301                                self.peek(length+1) in u'\0 \t\r\n\x28\u2028\u2029') \ 
    13071302                        or (self.flow_level and ch in u',:?[]{}'): 
    13081303                    break 
     
    13121307            self.allow_simple_key = False 
    13131308            chunks.extend(spaces) 
    1314             chunks.append(self.reader.prefix(length)) 
    1315             self.reader.forward(length) 
    1316             end_mark = self.reader.get_mark() 
     1309            chunks.append(self.prefix(length)) 
     1310            self.forward(length) 
     1311            end_mark = self.get_mark() 
    13171312            spaces = self.scan_plain_spaces(indent, start_mark) 
    1318             if not spaces or self.reader.peek() == u'#' \ 
    1319                     or (not self.flow_level and self.reader.column < indent): 
     1313            if not spaces or self.peek() == u'#' \ 
     1314                    or (not self.flow_level and self.column < indent): 
    13201315                break 
    13211316        return ScalarToken(u''.join(chunks), True, start_mark, end_mark) 
     
    13271322        chunks = [] 
    13281323        length = 0 
    1329         while self.reader.peek(length) in u' ': 
     1324        while self.peek(length) in u' ': 
    13301325            length += 1 
    1331         whitespaces = self.reader.prefix(length) 
    1332         self.reader.forward(length) 
    1333         ch = self.reader.peek() 
     1326        whitespaces = self.prefix(length) 
     1327        self.forward(length) 
     1328        ch = self.peek() 
    13341329        if ch in u'\r\n\x85\u2028\u2029': 
    13351330            line_break = self.scan_line_break() 
    13361331            self.allow_simple_key = True 
    1337             prefix = self.reader.prefix(3) 
     1332            prefix = self.prefix(3) 
    13381333            if (prefix == u'---' or prefix == u'...')   \ 
    1339                     and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1334                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    13401335                return 
    13411336            breaks = [] 
    1342             while self.reader.peek() in u' \r\n\x85\u2028\u2029': 
    1343                 if self.reader.peek() == ' ': 
    1344                     self.reader.forward() 
     1337            while self.peek() in u' \r\n\x85\u2028\u2029': 
     1338                if self.peek() == ' ': 
     1339                    self.forward() 
    13451340                else: 
    13461341                    breaks.append(self.scan_line_break()) 
    1347                     prefix = self.reader.prefix(3) 
     1342                    prefix = self.prefix(3) 
    13481343                    if (prefix == u'---' or prefix == u'...')   \ 
    1349                             and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1344                            and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    13501345                        return 
    13511346            if line_break != u'\n': 
     
    13621357        # For some strange reasons, the specification does not allow '_' in 
    13631358        # tag handles. I have allowed it anyway. 
    1364         ch = self.reader.peek() 
     1359        ch = self.peek() 
    13651360        if ch != u'!': 
    13661361            raise ScannerError("while scanning a %s" % name, start_mark, 
    13671362                    "expected '!', but found %r" % ch.encode('utf-8'), 
    1368                     self.reader.get_mark()) 
     1363                    self.get_mark()) 
    13691364        length = 1 
    1370         ch = self.reader.peek(length) 
     1365        ch = self.peek(length) 
    13711366        if ch != u' ': 
    13721367            while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    13731368                    or ch in u'-_': 
    13741369                length += 1 
    1375                 ch = self.reader.peek(length) 
     1370                ch = self.peek(length) 
    13761371            if ch != u'!': 
    1377                 self.reader.forward(length) 
     1372                self.forward(length) 
    13781373                raise ScannerError("while scanning a %s" % name, start_mark, 
    13791374                        "expected '!', but found %r" % ch.encode('utf-8'), 
    1380                         self.reader.get_mark()) 
     1375                        self.get_mark()) 
    13811376            length += 1 
    1382         value = self.reader.prefix(length) 
    1383         self.reader.forward(length) 
     1377        value = self.prefix(length) 
     1378        self.forward(length) 
    13841379        return value 
    13851380 
     
    13891384        chunks = [] 
    13901385        length = 0 
    1391         ch = self.reader.peek(length) 
     1386        ch = self.peek(length) 
    13921387        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    13931388                or ch in u'-;/?:@&=+$,_.!~*\'()[]%': 
    13941389            if ch == u'%': 
    1395                 chunks.append(self.reader.prefix(length)) 
    1396                 self.reader.forward(length) 
     1390                chunks.append(self.prefix(length)) 
     1391                self.forward(length) 
    13971392                length = 0 
    13981393                chunks.append(self.scan_uri_escapes(name, start_mark)) 
    13991394            else: 
    14001395                length += 1 
    1401             ch = self.reader.peek(length) 
     1396            ch = self.peek(length) 
    14021397        if length: 
    1403             chunks.append(self.reader.prefix(length)) 
    1404             self.reader.forward(length) 
     1398            chunks.append(self.prefix(length)) 
     1399            self.forward(length) 
    14051400            length = 0 
    14061401        if not chunks: 
    14071402            raise ScannerError("while parsing a %s" % name, start_mark, 
    14081403                    "expected URI, but found %r" % ch.encode('utf-8'), 
    1409                     self.reader.get_mark()) 
     1404                    self.get_mark()) 
    14101405        return u''.join(chunks) 
    14111406 
     
    14131408        # See the specification for details. 
    14141409        bytes = [] 
    1415         mark = self.reader.get_mark() 
    1416         while self.reader.peek() == u'%': 
    1417             self.reader.forward() 
     1410        mark = self.get_mark() 
     1411        while self.peek() == u'%': 
     1412            self.forward() 
    14181413            for k in range(2): 
    1419                 if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
     1414                if self.peek(k) not in u'0123456789ABCDEFabcdef': 
    14201415                    raise ScannerError("while scanning a %s" % name, start_mark, 
    14211416                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % 
    1422                                 (self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) 
    1423             bytes.append(chr(int(self.reader.prefix(2), 16))) 
    1424             self.reader.forward(2) 
     1417                                (self.peek(k).encode('utf-8')), self.get_mark()) 
     1418            bytes.append(chr(int(self.prefix(2), 16))) 
     1419            self.forward(2) 
    14251420        try: 
    14261421            value = unicode(''.join(bytes), 'utf-8') 
     
    14381433        #   '\u2029     :   '\u2029' 
    14391434        #   default     :   '' 
    1440         ch = self.reader.peek() 
     1435        ch = self.peek() 
    14411436        if ch in u'\r\n\x85': 
    1442             if self.reader.prefix(2) == u'\r\n': 
    1443                 self.reader.forward(2) 
     1437            if self.prefix(2) == u'\r\n': 
     1438                self.forward(2) 
    14441439            else: 
    1445                 self.reader.forward() 
     1440                self.forward() 
    14461441            return u'\n' 
    14471442        elif ch in u'\u2028\u2029': 
    1448             self.reader.forward() 
     1443            self.forward() 
    14491444            return ch 
    14501445        return u'' 
Note: See TracChangeset for help on using the changeset viewer.