Ignore:
Timestamp:
03/26/06 17:57:23 (9 years ago)
Author:
xi
Message:

Parser now provides style information. Allow empty plain scalars if a tag or anchor is given.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/branches/working-on-emitter/lib/yaml/parser.py

    r121 r127  
    131131        # Parse start of stream. 
    132132        token = self.scanner.get() 
    133         yield StreamStartEvent(token.start_mark, token.end_mark) 
     133        yield StreamStartEvent(token.start_mark, token.end_mark, 
     134                encoding=token.encoding) 
    134135 
    135136        # Parse implicit document. 
     
    139140            token = self.scanner.peek() 
    140141            start_mark = end_mark = token.start_mark 
    141             yield DocumentStartEvent(start_mark, end_mark) 
     142            yield DocumentStartEvent(start_mark, end_mark, implicit=True) 
    142143            for event in self.parse_block_node(): 
    143144                yield event 
     
    153154            token = self.scanner.peek() 
    154155            start_mark = token.start_mark 
    155             self.process_directives() 
     156            version, tags = self.process_directives() 
    156157            if not self.scanner.check(DocumentStartToken): 
    157158                raise ParserError(None, None, 
     
    161162            token = self.scanner.get() 
    162163            end_mark = token.end_mark 
    163             yield DocumentStartEvent(start_mark, end_mark) 
     164            yield DocumentStartEvent(start_mark, end_mark, 
     165                    implicit=False, version=version, tags=tags) 
    164166            if self.scanner.check(DirectiveToken, 
    165167                    DocumentStartToken, DocumentEndToken, StreamEndToken): 
     
    202204                            token.start_mark) 
    203205                self.tag_handles[handle] = prefix 
     206        version_value = self.yaml_version 
     207        tags_value = None 
     208        if self.tag_handles: 
     209            tags_value = self.tag_handles.copy() 
    204210        for key in self.DEFAULT_TAGS: 
    205211            if key not in self.tag_handles: 
    206212                self.tag_handles[key] = self.DEFAULT_TAGS[key] 
     213        return version_value, tags_value 
    207214 
    208215    def parse_block_node(self): 
     
    233240            if self.scanner.check(AnchorToken): 
    234241                token = self.scanner.get() 
    235                 start_mark = end_mark = token.start_mark 
     242                start_mark = token.start_mark 
     243                end_mark = token.end_mark 
    236244                anchor = token.value 
    237245                if self.scanner.check(TagToken): 
    238246                    token = self.scanner.get() 
    239                     end_mark = tag_mark = token.start_mark 
     247                    tag_mark = token.start_mark 
     248                    end_mark = token.end_mark 
    240249                    tag = token.value 
    241250            elif self.scanner.check(TagToken): 
    242251                token = self.scanner.get() 
    243                 start_mark = end_mark = tag_mark = token.start_mark 
     252                start_mark = tag_mark = token.start_mark 
     253                end_mark = token.end_mark 
    244254                tag = token.value 
    245255                if self.scanner.check(AnchorToken): 
    246256                    token = self.scanner.get() 
    247                     end_mark = token.start_mark 
     257                    end_mark = token.end_mark 
    248258                    anchor = token.value 
    249259            if tag is not None: 
     
    262272                    tag = u'!' 
    263273            if start_mark is None: 
    264                 start_mark = self.scanner.peek().start_mark 
     274                start_mark = end_mark = self.scanner.peek().start_mark 
    265275            event = None 
    266276            collection_events = None 
    267277            if indentless_sequence and self.scanner.check(BlockEntryToken): 
    268278                end_mark = self.scanner.peek().end_mark 
    269                 event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     279                event = SequenceEvent(anchor, tag, start_mark, end_mark, 
     280                        flow=False, compact=False) 
    270281                collection_events = self.parse_indentless_sequence() 
    271282            else: 
     
    274285                    end_mark = token.end_mark 
    275286                    event = ScalarEvent(anchor, tag, token.value, 
    276                             start_mark, end_mark) 
     287                            start_mark, end_mark, 
     288                            implicit=(tag is None), style=token.style) 
    277289                elif self.scanner.check(FlowSequenceStartToken): 
    278290                    end_mark = self.scanner.peek().end_mark 
    279                     event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     291                    event = SequenceEvent(anchor, tag, start_mark, end_mark, 
     292                            flow=True) 
    280293                    collection_events = self.parse_flow_sequence() 
    281294                elif self.scanner.check(FlowMappingStartToken): 
    282295                    end_mark = self.scanner.peek().end_mark 
    283                     event = MappingEvent(anchor, tag, start_mark, end_mark) 
     296                    event = MappingEvent(anchor, tag, start_mark, end_mark, 
     297                            flow=True) 
    284298                    collection_events = self.parse_flow_mapping() 
    285299                elif block and self.scanner.check(BlockSequenceStartToken): 
    286300                    end_mark = self.scanner.peek().start_mark 
    287                     event = SequenceEvent(anchor, tag, start_mark, end_mark) 
     301                    compact = self.scanner.peek().inline 
     302                    event = SequenceEvent(anchor, tag, start_mark, end_mark, 
     303                            flow=False, compact=compact) 
    288304                    collection_events = self.parse_block_sequence() 
    289305                elif block and self.scanner.check(BlockMappingStartToken): 
    290306                    end_mark = self.scanner.peek().start_mark 
    291                     event = MappingEvent(anchor, tag, start_mark, end_mark) 
     307                    compact = self.scanner.peek().inline 
     308                    event = MappingEvent(anchor, tag, start_mark, end_mark, 
     309                            flow=False, compact=compact) 
    292310                    collection_events = self.parse_block_mapping() 
     311                elif anchor is not None or tag is not None: 
     312                    # Empty scalars are allowed even if a tag or an anchor is 
     313                    # specified. 
     314                    event = ScalarEvent(anchor, tag, u'', start_mark, end_mark, 
     315                            implicit=False, style='') 
    293316                else: 
    294317                    if block: 
     
    385408                token = self.scanner.get() 
    386409                yield MappingEvent(None, u'!', 
    387                         token.start_mark, token.end_mark) 
     410                        token.start_mark, token.end_mark, 
     411                        flow=True, compact=True) 
    388412                if not self.scanner.check(ValueToken, 
    389413                        FlowEntryToken, FlowSequenceEndToken): 
     
    461485 
    462486    def process_empty_scalar(self, mark): 
    463         return ScalarEvent(None, None, u'', mark, mark) 
    464  
     487        return ScalarEvent(None, None, u'', mark, mark, implicit=True) 
     488 
Note: See TracChangeset for help on using the changeset viewer.