Changeset 118


Ignore:
Timestamp:
03/19/06 08:00:38 (7 years ago)
Author:
xi
Message:
  • Add the token STREAM-START.
  • Add parsing events: STREAM-START, DOCUMENT-START, DOCUMENT-END.
Location:
pyyaml/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • pyyaml/trunk/lib/yaml/composer.py

    r116 r118  
    1616        self.complete_anchors = {} 
    1717 
     18        # Drop the STREAM-START event. 
     19        self.parser.get() 
     20 
    1821    def check(self): 
    1922        # If there are more documents available? 
    … …  
    3134 
    3235    def compose_document(self): 
     36 
     37        # Drop the DOCUMENT-START event. 
     38        self.parser.get() 
     39 
     40        # Compose the root node. 
    3341        node = self.compose_node() 
     42 
     43        # Drop the DOCUMENT-END event. 
     44        self.parser.get() 
     45 
    3446        self.all_anchors = {} 
    3547        self.complete_anchors = {} 

  • pyyaml/trunk/lib/yaml/events.py

    r116 r118  
    4545    pass 
    4646 
     47class DocumentStartEvent(Event): 
     48    pass 
     49 
     50class DocumentEndEvent(Event): 
     51    pass 
     52 
     53class StreamStartEvent(Event): 
     54    pass 
     55 
    4756class StreamEndEvent(Event): 
    4857    pass 

  • pyyaml/trunk/lib/yaml/parser.py

    r116 r118  
    33# 
    44# We use the following production rules: 
    5 # stream            ::= implicit_document? explicit_document* STREAM-END 
     5# stream            ::= STREAM-START implicit_document? explicit_document* STREAM-END 
    66# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END? 
    77# implicit_document ::= block_node DOCUMENT-END? 
    … …  
    4343 
    4444# FIRST sets: 
    45 # stream: FIRST(block_node) + { DIRECTIVE DOCUMENT-START } 
     45# stream: { STREAM-START } 
    4646# explicit_document: { DIRECTIVE DOCUMENT-START } 
    4747# implicit_document: FIRST(block_node) 
    … …  
    127127 
    128128    def parse_stream(self): 
    129         # implicit_document? explicit_document* STREAM-END 
     129        # STREAM-START implicit_document? explicit_document* STREAM-END 
     130 
     131        # Parse start of stream. 
     132        token = self.scanner.get() 
     133        yield StreamStartEvent(token.start_mark, token.end_mark) 
    130134 
    131135        # Parse implicit document. 
    … …  
    133137                StreamEndToken): 
    134138            self.tag_handles = self.DEFAULT_TAGS 
     139            token = self.scanner.peek() 
     140            start_mark = end_mark = token.start_mark 
     141            yield DocumentStartEvent(start_mark, end_mark) 
    135142            for event in self.parse_block_node(): 
    136143                yield event 
     144            token = self.scanner.peek() 
     145            start_mark = end_mark = token.start_mark 
     146            while self.scanner.check(DocumentEndToken): 
     147                token = self.scanner.get() 
     148                end_mark = token.end_mark 
     149            yield DocumentEndEvent(start_mark, end_mark) 
    137150 
    138151        # Parse explicit documents. 
    139152        while not self.scanner.check(StreamEndToken): 
     153            token = self.scanner.peek() 
     154            start_mark = token.start_mark 
    140155            self.process_directives() 
    141156            if not self.scanner.check(DocumentStartToken): 
    … …  
    145160                        self.scanner.peek().start_mark) 
    146161            token = self.scanner.get() 
     162            end_mark = token.end_mark 
     163            yield DocumentStartEvent(start_mark, end_mark) 
    147164            if self.scanner.check(DirectiveToken, 
    148165                    DocumentStartToken, DocumentEndToken, StreamEndToken): 
    … …  
    151168                for event in self.parse_block_node(): 
    152169                    yield event 
     170            token = self.scanner.peek() 
     171            start_mark = end_mark = token.start_mark 
    153172            while self.scanner.check(DocumentEndToken): 
    154                 self.scanner.get() 
     173                token = self.scanner.get() 
     174                end_mark = token.end_mark 
     175            yield DocumentEndEvent(start_mark, end_mark) 
    155176 
    156177        # Parse end of stream. 

  • pyyaml/trunk/lib/yaml/scanner.py

    r117 r118  
    11 
    22# Scanner produces tokens of the following types: 
     3# STREAM-START 
     4# STREAM-END 
    35# DIRECTIVE(name, value) 
    46# DOCUMENT-START 
    57# DOCUMENT-END 
    6 # STREAM-END 
    78# BLOCK-SEQUENCE-START 
    89# BLOCK-MAPPING-START 
    … …  
    6970        self.tokens = [] 
    7071 
     72        # Add the STREAM-START token. 
     73        self.fetch_stream_start() 
     74 
    7175        # Number of tokens that were emitted through the `get_token` method. 
    7276        self.tokens_taken = 0 
    … …  
    369373    # Fetchers. 
    370374 
     375    def fetch_stream_start(self): 
     376        # We always add STREAM-START as the first token and STREAM-END as the 
     377        # last token. 
     378 
     379        # Read the token. 
     380        mark = self.reader.get_mark() 
     381         
     382        # Add STREAM-END. 
     383        self.tokens.append(StreamStartToken(mark, mark)) 
     384         
     385 
    371386    def fetch_stream_end(self): 
    372387 
    … …  
    381396        mark = self.reader.get_mark() 
    382397         
    383         # Add END. 
     398        # Add STREAM-END. 
    384399        self.tokens.append(StreamEndToken(mark, mark)) 
    385400 

  • pyyaml/trunk/lib/yaml/tokens.py

    r116 r118  
    2828class DocumentEndToken(Token): 
    2929    id = '<document end>' 
     30 
     31class StreamStartToken(Token): 
     32    id = '<stream start>' 
    3033 
    3134class StreamEndToken(Token): 

  • pyyaml/trunk/tests/test_appliance.py

    r54 r118  
    4848        #print self.data[self.index:] 
    4949        tokens = [] 
     50        tokens.append(StreamStartToken(None, None)) 
    5051        while True: 
    5152            self.find_token() 
    … …  
    207208        self.events = [] 
    208209 
    209     # stream: document* END 
     210    # stream: STREAM-START document* STREAM-END 
    210211    def parse_stream(self): 
     212        self.consume_token(StreamStartToken) 
     213        self.events.append(StreamStartEvent(None, None)) 
    211214        while not self.test_token(StreamEndToken): 
    212215            if self.test_token(DirectiveToken, DocumentStartToken): 
    … …  
    214217            else: 
    215218                raise Error("document is expected, got "+repr(self.tokens[self.index])) 
     219        self.consume_token(StreamEndToken) 
    216220        self.events.append(StreamEndEvent(None, None)) 
    217221 
    … …  
    222226            self.consume_token(DirectiveToken) 
    223227        self.consume_token(DocumentStartToken) 
     228        self.events.append(DocumentStartEvent(None, None)) 
    224229        self.parse_node() 
     230        self.events.append(DocumentEndEvent(None, None)) 
    225231 
    226232    # node: ALIAS | ANCHOR? TAG? (SCALAR|sequence|mapping) 

  • pyyaml/trunk/tests/test_structure.py

    r57 r118  
    1313            node1 = [] 
    1414            while not parser.check(StreamEndEvent): 
    15                 node1.append(self._convert(parser)) 
     15                if not parser.check(StreamStartEvent, DocumentStartEvent, DocumentEndEvent): 
     16                    node1.append(self._convert(parser)) 
     17                else: 
     18                    parser.get() 
    1619            parser.get() 
    1720            if len(node1) == 1: 

  • pyyaml/trunk/tests/test_tokens.py

    r51 r118  
    5555            tokens1 = [] 
    5656            for token in scanner: 
    57                 if not isinstance(token, StreamEndToken): 
     57                if not isinstance(token, (StreamStartToken, StreamEndToken)): 
    5858                    tokens1.append(token) 
    5959            tokens1 = [self.replaces[t.__class__] for t in tokens1] 
    … …  
    7878                tokens = [] 
    7979                for token in scanner: 
    80                     if not isinstance(token, StreamEndToken): 
     80                    if not isinstance(token, (StreamStartToken, StreamEndToken)): 
    8181                        tokens.append(token.__class__.__name__) 
    8282            except: 
Note: See TracChangeset for help on using the changeset viewer.