Ignore:
Timestamp:
02/16/06 17:22:59 (8 years ago)
Author:
xi
Message:

Some renaming.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/pyyaml3000/lib/yaml/scanner.py

    r45 r46  
    99# ALIAS(name), ANCHOR(name), TAG(value), SCALAR(value, plain) 
    1010 
    11  
    12 from marker import Marker 
    13 #from error import YAMLError 
    14 from stream import Stream 
    15  
    16 #class ScannerError(YAMLError): 
    17 class ScannerError(Exception): 
     11__all__ = ['Scanner', 'ScannerError'] 
     12 
     13from error import YAMLError 
     14from tokens import * 
     15 
     16class ScannerError(YAMLError): 
     17    # TODO: 
     18    # ScannerError: while reading a quoted string 
     19    #         in '...', line 5, column 10: 
     20    # key: "valu\?e" 
     21    #      ^ 
     22    # got unknown quote character '?' 
     23    #         in '...', line 5, column 15: 
     24    # key: "valu\?e" 
     25    #            ^ 
    1826    pass 
    19  
    20 class Token: 
    21     def __init__(self, start_marker, end_marker): 
    22         self.start_marker = start_marker 
    23         self.end_marker = end_marker 
    24  
    25 class DirectiveToken(Token): 
    26     pass 
    27  
    28 class YAMLDirectiveToken(DirectiveToken): 
    29     def __init__(self, major_version, minor_version, start_marker, end_marker): 
    30         self.major_version = major_version 
    31         self.minor_version = minor_version 
    32         self.start_marker = start_marker 
    33         self.end_marker = end_marker 
    34  
    35 class TagDirectiveToken(DirectiveToken): 
    36     pass 
    37  
    38 class ReservedDirectiveToken(DirectiveToken): 
    39     def __init__(self, name, start_marker, end_marker): 
    40         self.name = name 
    41         self.start_marker = start_marker 
    42         self.end_marker = end_marker 
    43  
    44 class DocumentStartToken(Token): 
    45     pass 
    46  
    47 class DocumentEndToken(Token): 
    48     pass 
    49  
    50 class EndToken(Token): 
    51     pass 
    52  
    53 class BlockSequenceStartToken(Token): 
    54     pass 
    55  
    56 class BlockMappingStartToken(Token): 
    57     pass 
    58  
    59 class BlockEndToken(Token): 
    60     pass 
    61  
    62 class FlowSequenceStartToken(Token): 
    63     pass 
    64  
    65 class FlowMappingStartToken(Token): 
    66     pass 
    67  
    68 class FlowSequenceEndToken(Token): 
    69     pass 
    70  
    71 class FlowMappingEndToken(Token): 
    72     pass 
    73  
    74 class KeyToken(Token): 
    75     pass 
    76  
    77 class ValueToken(Token): 
    78     pass 
    79  
    80 class EntryToken(Token): 
    81     pass 
    82  
    83 class AliasToken(Token): 
    84     def __init__(self, value, start_marker, end_marker): 
    85         self.value = value 
    86         self.start_marker = start_marker 
    87         self.end_marker = end_marker 
    88  
    89 class AnchorToken(Token): 
    90     def __init__(self, value, start_marker, end_marker): 
    91         self.value = value 
    92         self.start_marker = start_marker 
    93         self.end_marker = end_marker 
    94  
    95 class TagToken(Token): 
    96     def __init__(self, value, start_marker, end_marker): 
    97         self.value = value 
    98         self.start_marker = start_marker 
    99         self.end_marker = end_marker 
    100  
    101 class ScalarToken(Token): 
    102     def __init__(self, value, plain, start_marker, end_marker): 
    103         self.value = value 
    104         self.plain = plain 
    105         self.start_marker = start_marker 
    106         self.end_marker = end_marker 
    10727 
    10828class SimpleKey: 
     
    11737class Scanner: 
    11838 
    119     def __init__(self, source, data): 
     39 
     40    def __init__(self, reader): 
    12041        """Initialize the scanner.""" 
    121         # The input stream. The Stream class do the dirty work of checking for 
     42        # The input stream. The Reader class do the dirty work of checking for 
    12243        # BOM and converting the input data to Unicode. It also adds NUL to 
    12344        # the end. 
    12445        # 
    125         # Stream supports the following methods 
    126         #   self.stream.peek(k=1)   # peek the next k characters 
    127         #   self.stream.forward(k=1)   # read the next k characters and move the 
     46        # Reader supports the following methods 
     47        #   self.reader.peek(k=1)   # peek the next k characters 
     48        #   self.reader.forward(k=1)   # read the next k characters and move the 
    12849        #                           # pointer 
    129         self.stream = Stream(source, data) 
     50        self.reader = reader 
    13051 
    13152        # Had we reached the end of the stream? 
     
    218139        # Compare the current indentation and column. It may add some tokens 
    219140        # and decrease the current indentation level. 
    220         self.unwind_indent(self.stream.column) 
     141        self.unwind_indent(self.reader.column) 
    221142 
    222143        #print 
    223         #print self.stream.get_marker().get_snippet() 
     144        #print self.reader.get_marker().get_snippet() 
    224145 
    225146        # Peek the next character. 
    226         ch = self.stream.peek() 
    227  
    228         # Is it the end of stream? 
     147        ch = self.reader.peek() 
     148 
     149        # Is it the end of reader? 
    229150        if ch == u'\0': 
    230151            return self.fetch_end() 
     
    333254        for level in self.possible_simple_keys.keys(): 
    334255            key = self.possible_simple_keys[level] 
    335             if key.line != self.stream.line  \ 
    336                     or self.stream.index-key.index > 1024: 
     256            if key.line != self.reader.line  \ 
     257                    or self.reader.index-key.index > 1024: 
    337258                if key.required: 
    338259                    self.fail("simple key is required") 
     
    345266 
    346267        # Check if a simple key is required at the current position. 
    347         required = not self.flow_level and self.indent == self.stream.column 
     268        required = not self.flow_level and self.indent == self.reader.column 
    348269 
    349270        # The next token might be a simple key. Let's save it's number and 
     
    352273            self.remove_possible_simple_key() 
    353274            token_number = self.tokens_taken+len(self.tokens) 
    354             index = self.stream.index 
    355             line = self.stream.line 
    356             column = self.stream.column 
    357             marker = self.stream.get_marker() 
     275            index = self.reader.index 
     276            line = self.reader.line 
     277            column = self.reader.column 
     278            marker = self.reader.get_marker() 
    358279            key = SimpleKey(token_number, required, 
    359280                    index, line, column, marker) 
     
    381302        # In block context, we may need to issue the BLOCK-END tokens. 
    382303        while self.indent > column: 
    383             marker = self.stream.get_marker() 
     304            marker = self.reader.get_marker() 
    384305            self.indent = self.indents.pop() 
    385306            self.tokens.append(BlockEndToken(marker, marker)) 
     
    405326 
    406327        # Read the token. 
    407         marker = self.stream.get_marker() 
     328        marker = self.reader.get_marker() 
    408329         
    409330        # Add END. 
    410331        self.tokens.append(EndToken(marker, marker)) 
    411332 
    412         # The stream is ended. 
     333        # The reader is ended. 
    413334        self.done = True 
    414335 
     
    442363 
    443364        # Add DOCUMENT-START or DOCUMENT-END. 
    444         start_marker = self.stream.get_marker() 
    445         self.stream.forward(3) 
    446         end_marker = self.stream.get_marker() 
     365        start_marker = self.reader.get_marker() 
     366        self.reader.forward(3) 
     367        end_marker = self.reader.get_marker() 
    447368        self.tokens.append(TokenClass(start_marker, end_marker)) 
    448369 
     
    465386 
    466387        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. 
    467         start_marker = self.stream.get_marker() 
    468         self.stream.forward() 
    469         end_marker = self.stream.get_marker() 
     388        start_marker = self.reader.get_marker() 
     389        self.reader.forward() 
     390        end_marker = self.reader.get_marker() 
    470391        self.tokens.append(TokenClass(start_marker, end_marker)) 
    471392 
     
    488409 
    489410        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. 
    490         start_marker = self.stream.get_marker() 
    491         self.stream.forward() 
    492         end_marker = self.stream.get_marker() 
     411        start_marker = self.reader.get_marker() 
     412        self.reader.forward() 
     413        end_marker = self.reader.get_marker() 
    493414        self.tokens.append(TokenClass(start_marker, end_marker)) 
    494415 
     
    503424 
    504425            # We may need to add BLOCK-SEQUENCE-START. 
    505             if self.add_indent(self.stream.column): 
    506                 marker = self.stream.get_marker() 
     426            if self.add_indent(self.reader.column): 
     427                marker = self.reader.get_marker() 
    507428                self.tokens.append(BlockSequenceStartToken(marker, marker)) 
    508429 
     
    514435 
    515436        # Add ENTRY. 
    516         start_marker = self.stream.get_marker() 
    517         self.stream.forward() 
    518         end_marker = self.stream.get_marker() 
     437        start_marker = self.reader.get_marker() 
     438        self.reader.forward() 
     439        end_marker = self.reader.get_marker() 
    519440        self.tokens.append(EntryToken(start_marker, end_marker)) 
    520441 
     
    529450 
    530451            # We may need to add BLOCK-MAPPING-START. 
    531             if self.add_indent(self.stream.column): 
    532                 marker = self.stream.get_marker() 
     452            if self.add_indent(self.reader.column): 
     453                marker = self.reader.get_marker() 
    533454                self.tokens.append(BlockMappingStartToken(marker, marker)) 
    534455 
     
    540461 
    541462        # Add KEY. 
    542         start_marker = self.stream.get_marker() 
    543         self.stream.forward() 
    544         end_marker = self.stream.get_marker() 
     463        start_marker = self.reader.get_marker() 
     464        self.reader.forward() 
     465        end_marker = self.reader.get_marker() 
    545466        self.tokens.append(KeyToken(start_marker, end_marker)) 
    546467 
     
    576497 
    577498        # Add VALUE. 
    578         start_marker = self.stream.get_marker() 
    579         self.stream.forward() 
    580         end_marker = self.stream.get_marker() 
     499        start_marker = self.reader.get_marker() 
     500        self.reader.forward() 
     501        end_marker = self.reader.get_marker() 
    581502        self.tokens.append(ValueToken(start_marker, end_marker)) 
    582503 
     
    667588        # DIRECTIVE:        ^ '%' ... 
    668589        # The '%' indicator is already checked. 
    669         if self.stream.column == 0: 
     590        if self.reader.column == 0: 
    670591            return True 
    671592 
     
    673594 
    674595        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    675         if self.stream.column == 0: 
    676             prefix = self.stream.peek(4) 
     596        if self.reader.column == 0: 
     597            prefix = self.reader.peek(4) 
    677598            if prefix[:3] == u'---' and prefix[3] in u'\0 \t\r\n\x85\u2028\u2029': 
    678599                return True 
     
    681602 
    682603        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    683         if self.stream.column == 0: 
    684             prefix = self.stream.peek(4) 
     604        if self.reader.column == 0: 
     605            prefix = self.reader.peek(4) 
    685606            if prefix[:3] == u'...' and prefix[3] in u'\0 \t\r\n\x85\u2028\u2029': 
    686607                return True 
     
    690611        # ENTRY(flow context):      ',' 
    691612        if self.flow_level: 
    692             return self.stream.peek() == u',' 
     613            return self.reader.peek() == u',' 
    693614 
    694615        # ENTRY(block context):     '-' (' '|'\n') 
    695616        else: 
    696             prefix = self.stream.peek(2) 
     617            prefix = self.reader.peek(2) 
    697618            return prefix[0] == u'-' and prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    698619 
     
    705626        # KEY(block context):   '?' (' '|'\n') 
    706627        else: 
    707             prefix = self.stream.peek(2) 
     628            prefix = self.reader.peek(2) 
    708629            return prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    709630 
     
    716637        # VALUE(block context): ':' (' '|'\n') 
    717638        else: 
    718             prefix = self.stream.peek(2) 
     639            prefix = self.reader.peek(2) 
    719640            return prefix[1] in u'\0 \t\r\n\x85\u2028\u2029' 
    720641 
     
    727648        found = False 
    728649        while not found: 
    729             while self.stream.peek() == u' ': 
    730                 self.stream.forward() 
    731             if self.stream.peek() == u'#': 
    732                 while self.stream.peek() not in u'\r\n': 
    733                     self.stream.forward() 
    734             if self.stream.peek() in u'\r\n': 
    735                 self.stream.forward() 
     650            while self.reader.peek() == u' ': 
     651                self.reader.forward() 
     652            if self.reader.peek() == u'#': 
     653                while self.reader.peek() not in u'\r\n': 
     654                    self.reader.forward() 
     655            if self.reader.peek() in u'\r\n': 
     656                self.reader.forward() 
    736657                if not self.flow_level: 
    737658                    self.allow_simple_key = True 
     
    740661 
    741662    def scan_directive(self): 
    742         marker = self.stream.get_marker() 
    743         if self.stream.peek(5) == u'%YAML ': 
     663        marker = self.reader.get_marker() 
     664        if self.reader.peek(5) == u'%YAML ': 
    744665            self.tokens.append(YAMLDirectiveToken(1, 1, marker, marker)) 
    745         elif self.stream.peek(4) == u'%TAG ': 
     666        elif self.reader.peek(4) == u'%TAG ': 
    746667            self.tokens.append(TagDirectiveToken(marker, marker)) 
    747668        else: 
    748669            self.tokens.append(ReservedDirectiveToken('', marker, marker)) 
    749         while self.stream.peek() not in u'\0\r\n': 
    750             self.stream.forward() 
    751         self.stream.forward() 
     670        while self.reader.peek() not in u'\0\r\n': 
     671            self.reader.forward() 
     672        self.reader.forward() 
    752673 
    753674    def scan_anchor(self, TokenClass): 
    754         start_marker = self.stream.get_marker() 
    755         while self.stream.peek() not in u'\0 \t\r\n,:': 
    756             self.stream.forward() 
    757         end_marker = self.stream.get_marker() 
     675        start_marker = self.reader.get_marker() 
     676        while self.reader.peek() not in u'\0 \t\r\n,:': 
     677            self.reader.forward() 
     678        end_marker = self.reader.get_marker() 
    758679        self.tokens.append(TokenClass('', start_marker, end_marker)) 
    759680 
    760681    def scan_tag(self): 
    761         start_marker = self.stream.get_marker() 
    762         while self.stream.peek() not in u'\0 \t\r\n': 
    763             self.stream.forward() 
    764         end_marker = self.stream.get_marker() 
     682        start_marker = self.reader.get_marker() 
     683        while self.reader.peek() not in u'\0 \t\r\n': 
     684            self.reader.forward() 
     685        end_marker = self.reader.get_marker() 
    765686        self.tokens.append(TagToken('', start_marker, end_marker)) 
    766687 
    767688    def scan_block_scalar(self, folded): 
    768         start_marker = self.stream.get_marker() 
     689        start_marker = self.reader.get_marker() 
    769690        indent = self.indent+1 
    770691        if indent < 1: 
    771692            indent = 1 
    772693        while True: 
    773             while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n\x85\u2028\u2029': 
    774                 self.stream.forward() 
    775             if self.stream.peek() != u'\0': 
    776                 self.stream.forward() 
     694            while self.reader.peek() and self.reader.peek() and self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     695                self.reader.forward() 
     696            if self.reader.peek() != u'\0': 
     697                self.reader.forward() 
    777698            count = 0 
    778             while count < indent and self.stream.peek() == u' ': 
    779                 self.stream.forward() 
     699            while count < indent and self.reader.peek() == u' ': 
     700                self.reader.forward() 
    780701                count += 1 
    781             if count < indent and self.stream.peek() not in u'#\r\n\x85\u2028\u2029': 
     702            if count < indent and self.reader.peek() not in u'#\r\n\x85\u2028\u2029': 
    782703                break 
    783704        self.tokens.append(ScalarToken('', False, start_marker, start_marker)) 
    784705 
    785706    def scan_flow_scalar(self, double): 
    786         marker = self.stream.get_marker() 
    787         quote = self.stream.peek() 
    788         self.stream.forward() 
    789         while self.stream.peek() != quote: 
    790             if double and self.stream.peek() == u'\\': 
    791                 self.stream.forward(2) 
    792             elif not double and self.stream.peek(3)[1:] == u'\'\'': 
    793                 self.stream.forward(3) 
     707        marker = self.reader.get_marker() 
     708        quote = self.reader.peek() 
     709        self.reader.forward() 
     710        while self.reader.peek() != quote: 
     711            if double and self.reader.peek() == u'\\': 
     712                self.reader.forward(2) 
     713            elif not double and self.reader.peek(3)[1:] == u'\'\'': 
     714                self.reader.forward(3) 
    794715            else: 
    795                 self.stream.forward(1) 
    796         self.stream.forward(1) 
     716                self.reader.forward(1) 
     717        self.reader.forward(1) 
    797718        self.tokens.append(ScalarToken('', False, marker, marker)) 
    798719 
     
    802723            indent = 1 
    803724        space = False 
    804         marker = self.stream.get_marker() 
     725        marker = self.reader.get_marker() 
    805726        while True: 
    806             while self.stream.peek() == u' ': 
    807                 self.stream.forward() 
     727            while self.reader.peek() == u' ': 
     728                self.reader.forward() 
    808729                space = True 
    809             while self.stream.peek() not in u'\0\r\n?:,[]{}#'   \ 
    810                     or (not space and self.stream.peek() == '#')    \ 
    811                     or (not self.flow_level and self.stream.peek() in '?,[]{}') \ 
    812                     or (not self.flow_level and self.stream.peek() == ':' and self.stream.peek(2)[1] not in u' \0\r\n'): 
    813                 space = self.stream.peek() not in u' \t' 
    814                 self.stream.forward() 
     730            while self.reader.peek() not in u'\0\r\n?:,[]{}#'   \ 
     731                    or (not space and self.reader.peek() == '#')    \ 
     732                    or (not self.flow_level and self.reader.peek() in '?,[]{}') \ 
     733                    or (not self.flow_level and self.reader.peek() == ':' and self.reader.peek(2)[1] not in u' \0\r\n'): 
     734                space = self.reader.peek() not in u' \t' 
     735                self.reader.forward() 
    815736                self.allow_simple_key = False 
    816             if self.stream.peek() not in u'\r\n': 
     737            if self.reader.peek() not in u'\r\n': 
    817738                break 
    818             while self.stream.peek() in u'\r\n': 
    819                 self.stream.forward() 
     739            while self.reader.peek() in u'\r\n': 
     740                self.reader.forward() 
    820741                if not self.flow_level: 
    821742                    self.allow_simple_key = True 
    822743            count = 0 
    823             while self.stream.peek() == u' ' and count < indent: 
    824                 self.stream.forward() 
     744            while self.reader.peek() == u' ' and count < indent: 
     745                self.reader.forward() 
    825746                count += 1 
    826747            if count < indent: 
Note: See TracChangeset for help on using the changeset viewer.