Ignore:
Timestamp:
02/15/06 08:35:29 (8 years ago)
Author:
xi
Message:

All tests passed! Scanner and Parser seem to be correct.

File:
1 edited

Legend:

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

    r43 r44  
    2323        self.end_marker = end_marker 
    2424 
    25 class YAMLDirective(Token): 
     25class DirectiveToken(Token): 
     26    pass 
     27 
     28class YAMLDirectiveToken(DirectiveToken): 
    2629    def __init__(self, major_version, minor_version, start_marker, end_marker): 
    2730        self.major_version = major_version 
     
    3033        self.end_marker = end_marker 
    3134 
    32 class TagDirective(Token): 
    33     pass 
    34  
    35 class ReservedDirective(Token): 
     35class TagDirectiveToken(DirectiveToken): 
     36    pass 
     37 
     38class ReservedDirectiveToken(DirectiveToken): 
    3639    def __init__(self, name, start_marker, end_marker): 
    3740        self.name = name 
     
    3942        self.end_marker = end_marker 
    4043 
    41 class DocumentStart(Token): 
    42     pass 
    43  
    44 class DocumentEnd(Token): 
    45     pass 
    46  
    47 class End(Token): 
    48     pass 
    49  
    50 class BlockSequenceStart(Token): 
    51     pass 
    52  
    53 class BlockMappingStart(Token): 
    54     pass 
    55  
    56 class BlockEnd(Token): 
    57     pass 
    58  
    59 class FlowSequenceStart(Token): 
    60     pass 
    61  
    62 class FlowMappingStart(Token): 
    63     pass 
    64  
    65 class FlowSequenceEnd(Token): 
    66     pass 
    67  
    68 class FlowMappingEnd(Token): 
    69     pass 
    70  
    71 class Key(Token): 
    72     pass 
    73  
    74 class Value(Token): 
    75     pass 
    76  
    77 class Entry(Token): 
    78     pass 
    79  
    80 class Alias(Token): 
     44class DocumentStartToken(Token): 
     45    pass 
     46 
     47class DocumentEndToken(Token): 
     48    pass 
     49 
     50class EndToken(Token): 
     51    pass 
     52 
     53class BlockSequenceStartToken(Token): 
     54    pass 
     55 
     56class BlockMappingStartToken(Token): 
     57    pass 
     58 
     59class BlockEndToken(Token): 
     60    pass 
     61 
     62class FlowSequenceStartToken(Token): 
     63    pass 
     64 
     65class FlowMappingStartToken(Token): 
     66    pass 
     67 
     68class FlowSequenceEndToken(Token): 
     69    pass 
     70 
     71class FlowMappingEndToken(Token): 
     72    pass 
     73 
     74class KeyToken(Token): 
     75    pass 
     76 
     77class ValueToken(Token): 
     78    pass 
     79 
     80class EntryToken(Token): 
     81    pass 
     82 
     83class AliasToken(Token): 
    8184    def __init__(self, value, start_marker, end_marker): 
    8285        self.value = value 
     
    8487        self.end_marker = end_marker 
    8588 
    86 class Anchor(Token): 
     89class AnchorToken(Token): 
    8790    def __init__(self, value, start_marker, end_marker): 
    8891        self.value = value 
     
    9093        self.end_marker = end_marker 
    9194 
    92 class Tag(Token): 
     95class TagToken(Token): 
    9396    def __init__(self, value, start_marker, end_marker): 
    9497        self.value = value 
     
    9699        self.end_marker = end_marker 
    97100 
    98 class Scalar(Token): 
     101class ScalarToken(Token): 
    99102    def __init__(self, value, plain, start_marker, end_marker): 
    100103        self.value = value 
     
    380383            marker = self.stream.get_marker() 
    381384            self.indent = self.indents.pop() 
    382             self.tokens.append(BlockEnd(marker, marker)) 
     385            self.tokens.append(BlockEndToken(marker, marker)) 
    383386 
    384387    def add_indent(self, column): 
     
    405408         
    406409        # Add END. 
    407         self.tokens.append(End(marker, marker)) 
     410        self.tokens.append(EndToken(marker, marker)) 
    408411 
    409412        # The stream is ended. 
     
    423426 
    424427    def fetch_document_start(self): 
    425         self.fetch_document_indicator(DocumentStart) 
     428        self.fetch_document_indicator(DocumentStartToken) 
    426429 
    427430    def fetch_document_end(self): 
    428         self.fetch_document_indicator(DocumentEnd) 
     431        self.fetch_document_indicator(DocumentEndToken) 
    429432 
    430433    def fetch_document_indicator(self, TokenClass): 
     
    445448 
    446449    def fetch_flow_sequence_start(self): 
    447         self.fetch_flow_collection_start(FlowSequenceStart) 
     450        self.fetch_flow_collection_start(FlowSequenceStartToken) 
    448451 
    449452    def fetch_flow_mapping_start(self): 
    450         self.fetch_flow_collection_start(FlowMappingStart) 
     453        self.fetch_flow_collection_start(FlowMappingStartToken) 
    451454 
    452455    def fetch_flow_collection_start(self, TokenClass): 
     456 
     457        # '[' and '{' may start a simple key. 
     458        self.save_possible_simple_key() 
    453459 
    454460        # Increase the flow level. 
    455461        self.flow_level += 1 
    456  
    457         # '[' and '{' may start a simple key. 
    458         self.save_possible_simple_key() 
    459462 
    460463        # Simple keys are allowed after '[' and '{'. 
     
    468471 
    469472    def fetch_flow_sequence_end(self): 
    470         self.fetch_flow_collection_end(FlowSequenceEnd) 
     473        self.fetch_flow_collection_end(FlowSequenceEndToken) 
    471474 
    472475    def fetch_flow_mapping_end(self): 
    473         self.fetch_flow_collection_end(FlowMappingEnd) 
     476        self.fetch_flow_collection_end(FlowMappingEndToken) 
    474477 
    475478    def fetch_flow_collection_end(self, TokenClass): 
     
    502505            if self.add_indent(self.stream.column): 
    503506                marker = self.stream.get_marker() 
    504                 self.tokens.append(BlockSequenceStart(marker, marker)) 
     507                self.tokens.append(BlockSequenceStartToken(marker, marker)) 
    505508 
    506509        # Simple keys are allowed after '-' and ','. 
     
    514517        self.stream.read() 
    515518        end_marker = self.stream.get_marker() 
    516         self.tokens.append(Entry(start_marker, end_marker)) 
     519        self.tokens.append(EntryToken(start_marker, end_marker)) 
    517520 
    518521    def fetch_key(self): 
     
    528531            if self.add_indent(self.stream.column): 
    529532                marker = self.stream.get_marker() 
    530                 self.tokens.append(BlockMappingStart(marker, marker)) 
     533                self.tokens.append(BlockMappingStartToken(marker, marker)) 
    531534 
    532535        # Simple keys are allowed after '?' in the block context. 
     
    540543        self.stream.read() 
    541544        end_marker = self.stream.get_marker() 
    542         self.tokens.append(Key(start_marker, end_marker)) 
     545        self.tokens.append(KeyToken(start_marker, end_marker)) 
    543546 
    544547    def fetch_value(self): 
     
    551554            del self.possible_simple_keys[self.flow_level] 
    552555            self.tokens.insert(key.token_number-self.tokens_taken, 
    553                     Key(key.marker, key.marker)) 
     556                    KeyToken(key.marker, key.marker)) 
    554557 
    555558            # If this key starts a new block mapping, we need to add 
     
    558561                if self.add_indent(key.column): 
    559562                    self.tokens.insert(key.token_number-self.tokens_taken, 
    560                             BlockMappingStart(key.marker, key.marker)) 
     563                            BlockMappingStartToken(key.marker, key.marker)) 
    561564 
    562565            # There cannot be two simple keys one after another. 
     
    576579        self.stream.read() 
    577580        end_marker = self.stream.get_marker() 
    578         self.tokens.append(Value(start_marker, end_marker)) 
     581        self.tokens.append(ValueToken(start_marker, end_marker)) 
    579582 
    580583    def fetch_alias(self): 
     
    587590 
    588591        # Scan and add ALIAS. 
    589         self.scan_anchor(Alias) 
     592        self.scan_anchor(AliasToken) 
    590593 
    591594    def fetch_anchor(self): 
     
    598601 
    599602        # Scan and add ANCHOR. 
    600         self.scan_anchor(Anchor) 
     603        self.scan_anchor(AnchorToken) 
    601604 
    602605    def fetch_tag(self): 
     
    739742        marker = self.stream.get_marker() 
    740743        if self.stream.peek(5) == u'%YAML ': 
    741             self.tokens.append(YAMLDirective(1, 1, marker, marker)) 
     744            self.tokens.append(YAMLDirectiveToken(1, 1, marker, marker)) 
    742745        elif self.stream.peek(4) == u'%TAG ': 
    743             self.tokens.append(TagDirective(marker, marker)) 
     746            self.tokens.append(TagDirectiveToken(marker, marker)) 
    744747        else: 
    745             self.tokens.append(ReservedDirective('', marker, marker)) 
     748            self.tokens.append(ReservedDirectiveToken('', marker, marker)) 
    746749        while self.stream.peek() not in u'\0\r\n': 
    747750            self.stream.read() 
     
    760763            self.stream.read() 
    761764        end_marker = self.stream.get_marker() 
    762         self.tokens.append(Tag('', start_marker, end_marker)) 
     765        self.tokens.append(TagToken('', start_marker, end_marker)) 
    763766 
    764767    def scan_block_scalar(self, folded): 
     
    768771            indent = 1 
    769772        while True: 
    770             while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n': 
     773            while self.stream.peek() and self.stream.peek() and self.stream.peek() not in u'\0\r\n\x85\u2028\u2029': 
    771774                self.stream.read() 
    772775            if self.stream.peek() != u'\0': 
     
    776779                self.stream.read() 
    777780                count += 1 
    778             if count < indent and self.stream.peek() not in u'#\r\n': 
     781            if count < indent and self.stream.peek() not in u'#\r\n\x85\u2028\u2029': 
    779782                break 
    780         self.tokens.append(Scalar('', False, start_marker, start_marker)) 
     783        self.tokens.append(ScalarToken('', False, start_marker, start_marker)) 
    781784 
    782785    def scan_flow_scalar(self, double): 
     
    791794                self.stream.read(1) 
    792795        self.stream.read(1) 
    793         self.tokens.append(Scalar('', False, marker, marker)) 
     796        self.tokens.append(ScalarToken('', False, marker, marker)) 
    794797 
    795798    def scan_plain(self): 
     
    823826                break 
    824827            space = True 
    825         self.tokens.append(Scalar('', True, marker, marker)) 
     828        self.tokens.append(ScalarToken('', True, marker, marker)) 
    826829 
    827830    def invalid_token(self): 
Note: See TracChangeset for help on using the changeset viewer.