Ticket #97: reader.patch

File reader.patch, 47.4 KB (added by py4fun@…, 5 years ago)
  • C:/projects/workspace_python/PyYAML_2/lib/yaml/scanner.py

     
    4545 
    4646class Scanner(object): 
    4747 
    48     def __init__(self): 
     48    def __init__(self, reader): 
    4949        """Initialize the scanner.""" 
    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 
     50        # Reader does the dirty work of checking for BOM and converting the 
    5251        # input data to Unicode. It also adds NUL to the end. 
    5352        # 
    5453        # Reader supports the following methods 
    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. 
     54        #   self.reader.peek(i=0)       # peek the next i-th character 
     55        #   self.reader.prefix(l=1)     # peek the next l characters 
     56        #   self.reader.forward(l=1)    # read the next l characters and move the pointer. 
    5857 
     58        self.reader = reader 
     59         
    5960        # Had we reached the end of the stream? 
    6061        self.done = False 
    6162 
     
    160161 
    161162        # Compare the current indentation and column. It may add some tokens 
    162163        # and decrease the current indentation level. 
    163         self.unwind_indent(self.column) 
     164        self.unwind_indent(self.reader.column) 
    164165 
    165166        # Peek the next character. 
    166         ch = self.peek() 
     167        ch = self.reader.peek() 
    167168 
    168169        # Is it the end of stream? 
    169170        if ch == u'\0': 
     
    254255        # No? It's an error. Let's produce a nice error message. 
    255256        raise ScannerError("while scanning for the next token", None, 
    256257                "found character %r that cannot start any token" 
    257                 % ch.encode('utf-8'), self.get_mark()) 
     258                % ch.encode('utf-8'), self.reader.get_mark()) 
    258259 
    259260    # Simple keys treatment. 
    260261 
     
    282283        # height (may cause problems if indentation is broken though). 
    283284        for level in self.possible_simple_keys.keys(): 
    284285            key = self.possible_simple_keys[level] 
    285             if key.line != self.line  \ 
    286                     or self.index-key.index > 1024: 
     286            if key.line != self.reader.line  \ 
     287                    or self.reader.index-key.index > 1024: 
    287288                if key.required: 
    288289                    raise ScannerError("while scanning a simple key", key.mark, 
    289                             "could not found expected ':'", self.get_mark()) 
     290                            "could not found expected ':'", self.reader.get_mark()) 
    290291                del self.possible_simple_keys[level] 
    291292 
    292293    def save_possible_simple_key(self): 
     
    295296        #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. 
    296297 
    297298        # Check if a simple key is required at the current position. 
    298         required = not self.flow_level and self.indent == self.column 
     299        required = not self.flow_level and self.indent == self.reader.column 
    299300 
    300301        # A simple key is required only if it is the first token in the current 
    301302        # line. Therefore it is always allowed. 
     
    307308            self.remove_possible_simple_key() 
    308309            token_number = self.tokens_taken+len(self.tokens) 
    309310            key = SimpleKey(token_number, required, 
    310                     self.index, self.line, self.column, self.get_mark()) 
     311                    self.reader.index, self.reader.line, self.reader.column, self.reader.get_mark()) 
    311312            self.possible_simple_keys[self.flow_level] = key 
    312313 
    313314    def remove_possible_simple_key(self): 
     
    317318             
    318319            if key.required: 
    319320                raise ScannerError("while scanning a simple key", key.mark, 
    320                         "could not found expected ':'", self.get_mark()) 
     321                        "could not found expected ':'", self.reader.get_mark()) 
    321322 
    322323            del self.possible_simple_keys[self.flow_level] 
    323324 
     
    334335        #if self.flow_level and self.indent > column: 
    335336        #    raise ScannerError(None, None, 
    336337        #            "invalid intendation or unclosed '[' or '{'", 
    337         #            self.get_mark()) 
     338        #            self.reader.get_mark()) 
    338339 
    339340        # In the flow context, indentation is ignored. We make the scanner less 
    340341        # restrictive then specification requires. 
     
    343344 
    344345        # In block context, we may need to issue the BLOCK-END tokens. 
    345346        while self.indent > column: 
    346             mark = self.get_mark() 
     347            mark = self.reader.get_mark() 
    347348            self.indent = self.indents.pop() 
    348349            self.tokens.append(BlockEndToken(mark, mark)) 
    349350 
     
    362363        # last token. 
    363364 
    364365        # Read the token. 
    365         mark = self.get_mark() 
     366        mark = self.reader.get_mark() 
    366367         
    367368        # Add STREAM-START. 
    368369        self.tokens.append(StreamStartToken(mark, mark, 
    369             encoding=self.encoding)) 
     370            encoding=self.reader.encoding)) 
    370371         
    371372 
    372373    def fetch_stream_end(self): 
     
    379380        self.possible_simple_keys = {} 
    380381 
    381382        # Read the token. 
    382         mark = self.get_mark() 
     383        mark = self.reader.get_mark() 
    383384         
    384385        # Add STREAM-END. 
    385386        self.tokens.append(StreamEndToken(mark, mark)) 
     
    416417        self.allow_simple_key = False 
    417418 
    418419        # Add DOCUMENT-START or DOCUMENT-END. 
    419         start_mark = self.get_mark() 
    420         self.forward(3) 
    421         end_mark = self.get_mark() 
     420        start_mark = self.reader.get_mark() 
     421        self.reader.forward(3) 
     422        end_mark = self.reader.get_mark() 
    422423        self.tokens.append(TokenClass(start_mark, end_mark)) 
    423424 
    424425    def fetch_flow_sequence_start(self): 
     
    439440        self.allow_simple_key = True 
    440441 
    441442        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. 
    442         start_mark = self.get_mark() 
    443         self.forward() 
    444         end_mark = self.get_mark() 
     443        start_mark = self.reader.get_mark() 
     444        self.reader.forward() 
     445        end_mark = self.reader.get_mark() 
    445446        self.tokens.append(TokenClass(start_mark, end_mark)) 
    446447 
    447448    def fetch_flow_sequence_end(self): 
     
    462463        self.allow_simple_key = False 
    463464 
    464465        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. 
    465         start_mark = self.get_mark() 
    466         self.forward() 
    467         end_mark = self.get_mark() 
     466        start_mark = self.reader.get_mark() 
     467        self.reader.forward() 
     468        end_mark = self.reader.get_mark() 
    468469        self.tokens.append(TokenClass(start_mark, end_mark)) 
    469470 
    470471    def fetch_flow_entry(self): 
     
    476477        self.remove_possible_simple_key() 
    477478 
    478479        # Add FLOW-ENTRY. 
    479         start_mark = self.get_mark() 
    480         self.forward() 
    481         end_mark = self.get_mark() 
     480        start_mark = self.reader.get_mark() 
     481        self.reader.forward() 
     482        end_mark = self.reader.get_mark() 
    482483        self.tokens.append(FlowEntryToken(start_mark, end_mark)) 
    483484 
    484485    def fetch_block_entry(self): 
     
    490491            if not self.allow_simple_key: 
    491492                raise ScannerError(None, None, 
    492493                        "sequence entries are not allowed here", 
    493                         self.get_mark()) 
     494                        self.reader.get_mark()) 
    494495 
    495496            # We may need to add BLOCK-SEQUENCE-START. 
    496             if self.add_indent(self.column): 
    497                 mark = self.get_mark() 
     497            if self.add_indent(self.reader.column): 
     498                mark = self.reader.get_mark() 
    498499                self.tokens.append(BlockSequenceStartToken(mark, mark)) 
    499500 
    500501        # It's an error for the block entry to occur in the flow context, 
     
    509510        self.remove_possible_simple_key() 
    510511 
    511512        # Add BLOCK-ENTRY. 
    512         start_mark = self.get_mark() 
    513         self.forward() 
    514         end_mark = self.get_mark() 
     513        start_mark = self.reader.get_mark() 
     514        self.reader.forward() 
     515        end_mark = self.reader.get_mark() 
    515516        self.tokens.append(BlockEntryToken(start_mark, end_mark)) 
    516517 
    517518    def fetch_key(self): 
     
    523524            if not self.allow_simple_key: 
    524525                raise ScannerError(None, None, 
    525526                        "mapping keys are not allowed here", 
    526                         self.get_mark()) 
     527                        self.reader.get_mark()) 
    527528 
    528529            # We may need to add BLOCK-MAPPING-START. 
    529             if self.add_indent(self.column): 
    530                 mark = self.get_mark() 
     530            if self.add_indent(self.reader.column): 
     531                mark = self.reader.get_mark() 
    531532                self.tokens.append(BlockMappingStartToken(mark, mark)) 
    532533 
    533534        # Simple keys are allowed after '?' in the block context. 
     
    537538        self.remove_possible_simple_key() 
    538539 
    539540        # Add KEY. 
    540         start_mark = self.get_mark() 
    541         self.forward() 
    542         end_mark = self.get_mark() 
     541        start_mark = self.reader.get_mark() 
     542        self.reader.forward() 
     543        end_mark = self.reader.get_mark() 
    543544        self.tokens.append(KeyToken(start_mark, end_mark)) 
    544545 
    545546    def fetch_value(self): 
     
    576577                if not self.allow_simple_key: 
    577578                    raise ScannerError(None, None, 
    578579                            "mapping values are not allowed here", 
    579                             self.get_mark()) 
     580                            self.reader.get_mark()) 
    580581 
    581582            # If this value starts a new block mapping, we need to add 
    582583            # BLOCK-MAPPING-START.  It will be detected as an error later by 
    583584            # the parser. 
    584585            if not self.flow_level: 
    585                 if self.add_indent(self.column): 
    586                     mark = self.get_mark() 
     586                if self.add_indent(self.reader.column): 
     587                    mark = self.reader.get_mark() 
    587588                    self.tokens.append(BlockMappingStartToken(mark, mark)) 
    588589 
    589590            # Simple keys are allowed after ':' in the block context. 
     
    593594            self.remove_possible_simple_key() 
    594595 
    595596        # Add VALUE. 
    596         start_mark = self.get_mark() 
    597         self.forward() 
    598         end_mark = self.get_mark() 
     597        start_mark = self.reader.get_mark() 
     598        self.reader.forward() 
     599        end_mark = self.reader.get_mark() 
    599600        self.tokens.append(ValueToken(start_mark, end_mark)) 
    600601 
    601602    def fetch_alias(self): 
     
    684685 
    685686        # DIRECTIVE:        ^ '%' ... 
    686687        # The '%' indicator is already checked. 
    687         if self.column == 0: 
     688        if self.reader.column == 0: 
    688689            return True 
    689690 
    690691    def check_document_start(self): 
    691692 
    692693        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    693         if self.column == 0: 
    694             if self.prefix(3) == u'---'  \ 
    695                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     694        if self.reader.column == 0: 
     695            if self.reader.prefix(3) == u'---'  \ 
     696                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    696697                return True 
    697698 
    698699    def check_document_end(self): 
    699700 
    700701        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    701         if self.column == 0: 
    702             if self.prefix(3) == u'...'  \ 
    703                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     702        if self.reader.column == 0: 
     703            if self.reader.prefix(3) == u'...'  \ 
     704                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    704705                return True 
    705706 
    706707    def check_block_entry(self): 
    707708 
    708709        # BLOCK-ENTRY:      '-' (' '|'\n') 
    709         return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     710        return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    710711 
    711712    def check_key(self): 
    712713 
     
    716717 
    717718        # KEY(block context):   '?' (' '|'\n') 
    718719        else: 
    719             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     720            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    720721 
    721722    def check_value(self): 
    722723 
     
    726727 
    727728        # VALUE(block context): ':' (' '|'\n') 
    728729        else: 
    729             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     730            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
    730731 
    731732    def check_plain(self): 
    732733 
     
    742743        # Note that we limit the last rule to the block context (except the 
    743744        # '-' character) because we want the flow context to be space 
    744745        # independent. 
    745         ch = self.peek() 
     746        ch = self.reader.peek() 
    746747        return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \ 
    747                 or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' 
     748                or (self.reader.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' 
    748749                        and (ch == u'-' or (not self.flow_level and ch in u'?:'))) 
    749750 
    750751    # Scanners. 
     
    769770        # `unwind_indent` before issuing BLOCK-END. 
    770771        # Scanners for block, flow, and plain scalars need to be modified. 
    771772 
    772         if self.index == 0 and self.peek() == u'\uFEFF': 
    773             self.forward() 
     773        if self.reader.index == 0 and self.reader.peek() == u'\uFEFF': 
     774            self.reader.forward() 
    774775        found = False 
    775776        while not found: 
    776             while self.peek() == u' ': 
    777                 self.forward() 
    778             if self.peek() == u'#': 
    779                 while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
    780                     self.forward() 
     777            while self.reader.peek() == u' ': 
     778                self.reader.forward() 
     779            if self.reader.peek() == u'#': 
     780                while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     781                    self.reader.forward() 
    781782            if self.scan_line_break(): 
    782783                if not self.flow_level: 
    783784                    self.allow_simple_key = True 
     
    786787 
    787788    def scan_directive(self): 
    788789        # See the specification for details. 
    789         start_mark = self.get_mark() 
    790         self.forward() 
     790        start_mark = self.reader.get_mark() 
     791        self.reader.forward() 
    791792        name = self.scan_directive_name(start_mark) 
    792793        value = None 
    793794        if name == u'YAML': 
    794795            value = self.scan_yaml_directive_value(start_mark) 
    795             end_mark = self.get_mark() 
     796            end_mark = self.reader.get_mark() 
    796797        elif name == u'TAG': 
    797798            value = self.scan_tag_directive_value(start_mark) 
    798             end_mark = self.get_mark() 
     799            end_mark = self.reader.get_mark() 
    799800        else: 
    800             end_mark = self.get_mark() 
    801             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
    802                 self.forward() 
     801            end_mark = self.reader.get_mark() 
     802            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     803                self.reader.forward() 
    803804        self.scan_directive_ignored_line(start_mark) 
    804805        return DirectiveToken(name, value, start_mark, end_mark) 
    805806 
    806807    def scan_directive_name(self, start_mark): 
    807808        # See the specification for details. 
    808809        length = 0 
    809         ch = self.peek(length) 
     810        ch = self.reader.peek(length) 
    810811        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    811812                or ch in u'-_': 
    812813            length += 1 
    813             ch = self.peek(length) 
     814            ch = self.reader.peek(length) 
    814815        if not length: 
    815816            raise ScannerError("while scanning a directive", start_mark, 
    816817                    "expected alphabetic or numeric character, but found %r" 
    817                     % ch.encode('utf-8'), self.get_mark()) 
    818         value = self.prefix(length) 
    819         self.forward(length) 
    820         ch = self.peek() 
     818                    % ch.encode('utf-8'), self.reader.get_mark()) 
     819        value = self.reader.prefix(length) 
     820        self.reader.forward(length) 
     821        ch = self.reader.peek() 
    821822        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    822823            raise ScannerError("while scanning a directive", start_mark, 
    823824                    "expected alphabetic or numeric character, but found %r" 
    824                     % ch.encode('utf-8'), self.get_mark()) 
     825                    % ch.encode('utf-8'), self.reader.get_mark()) 
    825826        return value 
    826827 
    827828    def scan_yaml_directive_value(self, start_mark): 
    828829        # See the specification for details. 
    829         while self.peek() == u' ': 
    830             self.forward() 
     830        while self.reader.peek() == u' ': 
     831            self.reader.forward() 
    831832        major = self.scan_yaml_directive_number(start_mark) 
    832         if self.peek() != '.': 
     833        if self.reader.peek() != '.': 
    833834            raise ScannerError("while scanning a directive", start_mark, 
    834835                    "expected a digit or '.', but found %r" 
    835                     % self.peek().encode('utf-8'), 
    836                     self.get_mark()) 
    837         self.forward() 
     836                    % self.reader.peek().encode('utf-8'), 
     837                    self.reader.get_mark()) 
     838        self.reader.forward() 
    838839        minor = self.scan_yaml_directive_number(start_mark) 
    839         if self.peek() not in u'\0 \r\n\x85\u2028\u2029': 
     840        if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029': 
    840841            raise ScannerError("while scanning a directive", start_mark, 
    841842                    "expected a digit or ' ', but found %r" 
    842                     % self.peek().encode('utf-8'), 
    843                     self.get_mark()) 
     843                    % self.reader.peek().encode('utf-8'), 
     844                    self.reader.get_mark()) 
    844845        return (major, minor) 
    845846 
    846847    def scan_yaml_directive_number(self, start_mark): 
    847848        # See the specification for details. 
    848         ch = self.peek() 
     849        ch = self.reader.peek() 
    849850        if not (u'0' <= ch <= '9'): 
    850851            raise ScannerError("while scanning a directive", start_mark, 
    851852                    "expected a digit, but found %r" % ch.encode('utf-8'), 
    852                     self.get_mark()) 
     853                    self.reader.get_mark()) 
    853854        length = 0 
    854         while u'0' <= self.peek(length) <= u'9': 
     855        while u'0' <= self.reader.peek(length) <= u'9': 
    855856            length += 1 
    856         value = int(self.prefix(length)) 
    857         self.forward(length) 
     857        value = int(self.reader.prefix(length)) 
     858        self.reader.forward(length) 
    858859        return value 
    859860 
    860861    def scan_tag_directive_value(self, start_mark): 
    861862        # See the specification for details. 
    862         while self.peek() == u' ': 
    863             self.forward() 
     863        while self.reader.peek() == u' ': 
     864            self.reader.forward() 
    864865        handle = self.scan_tag_directive_handle(start_mark) 
    865         while self.peek() == u' ': 
    866             self.forward() 
     866        while self.reader.peek() == u' ': 
     867            self.reader.forward() 
    867868        prefix = self.scan_tag_directive_prefix(start_mark) 
    868869        return (handle, prefix) 
    869870 
    870871    def scan_tag_directive_handle(self, start_mark): 
    871872        # See the specification for details. 
    872873        value = self.scan_tag_handle('directive', start_mark) 
    873         ch = self.peek() 
     874        ch = self.reader.peek() 
    874875        if ch != u' ': 
    875876            raise ScannerError("while scanning a directive", start_mark, 
    876877                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    877                     self.get_mark()) 
     878                    self.reader.get_mark()) 
    878879        return value 
    879880 
    880881    def scan_tag_directive_prefix(self, start_mark): 
    881882        # See the specification for details. 
    882883        value = self.scan_tag_uri('directive', start_mark) 
    883         ch = self.peek() 
     884        ch = self.reader.peek() 
    884885        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    885886            raise ScannerError("while scanning a directive", start_mark, 
    886887                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    887                     self.get_mark()) 
     888                    self.reader.get_mark()) 
    888889        return value 
    889890 
    890891    def scan_directive_ignored_line(self, start_mark): 
    891892        # See the specification for details. 
    892         while self.peek() == u' ': 
    893             self.forward() 
    894         if self.peek() == u'#': 
    895             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
    896                 self.forward() 
    897         ch = self.peek() 
     893        while self.reader.peek() == u' ': 
     894            self.reader.forward() 
     895        if self.reader.peek() == u'#': 
     896            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     897                self.reader.forward() 
     898        ch = self.reader.peek() 
    898899        if ch not in u'\0\r\n\x85\u2028\u2029': 
    899900            raise ScannerError("while scanning a directive", start_mark, 
    900901                    "expected a comment or a line break, but found %r" 
    901                         % ch.encode('utf-8'), self.get_mark()) 
     902                        % ch.encode('utf-8'), self.reader.get_mark()) 
    902903        self.scan_line_break() 
    903904 
    904905    def scan_anchor(self, TokenClass): 
     
    910911        # and 
    911912        #   [ *alias , "value" ] 
    912913        # Therefore we restrict aliases to numbers and ASCII letters. 
    913         start_mark = self.get_mark() 
    914         indicator = self.peek() 
     914        start_mark = self.reader.get_mark() 
     915        indicator = self.reader.peek() 
    915916        if indicator == '*': 
    916917            name = 'alias' 
    917918        else: 
    918919            name = 'anchor' 
    919         self.forward() 
     920        self.reader.forward() 
    920921        length = 0 
    921         ch = self.peek(length) 
     922        ch = self.reader.peek(length) 
    922923        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    923924                or ch in u'-_': 
    924925            length += 1 
    925             ch = self.peek(length) 
     926            ch = self.reader.peek(length) 
    926927        if not length: 
    927928            raise ScannerError("while scanning an %s" % name, start_mark, 
    928929                    "expected alphabetic or numeric character, but found %r" 
    929                     % ch.encode('utf-8'), self.get_mark()) 
    930         value = self.prefix(length) 
    931         self.forward(length) 
    932         ch = self.peek() 
     930                    % ch.encode('utf-8'), self.reader.get_mark()) 
     931        value = self.reader.prefix(length) 
     932        self.reader.forward(length) 
     933        ch = self.reader.peek() 
    933934        if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
    934935            raise ScannerError("while scanning an %s" % name, start_mark, 
    935936                    "expected alphabetic or numeric character, but found %r" 
    936                     % ch.encode('utf-8'), self.get_mark()) 
    937         end_mark = self.get_mark() 
     937                    % ch.encode('utf-8'), self.reader.get_mark()) 
     938        end_mark = self.reader.get_mark() 
    938939        return TokenClass(value, start_mark, end_mark) 
    939940 
    940941    def scan_tag(self): 
    941942        # See the specification for details. 
    942         start_mark = self.get_mark() 
    943         ch = self.peek(1) 
     943        start_mark = self.reader.get_mark() 
     944        ch = self.reader.peek(1) 
    944945        if ch == u'<': 
    945946            handle = None 
    946             self.forward(2) 
     947            self.reader.forward(2) 
    947948            suffix = self.scan_tag_uri('tag', start_mark) 
    948             if self.peek() != u'>': 
     949            if self.reader.peek() != u'>': 
    949950                raise ScannerError("while parsing a tag", start_mark, 
    950                         "expected '>', but found %r" % self.peek().encode('utf-8'), 
    951                         self.get_mark()) 
    952             self.forward() 
     951                        "expected '>', but found %r" % self.reader.peek().encode('utf-8'), 
     952                        self.reader.get_mark()) 
     953            self.reader.forward() 
    953954        elif ch in u'\0 \t\r\n\x85\u2028\u2029': 
    954955            handle = None 
    955956            suffix = u'!' 
    956             self.forward() 
     957            self.reader.forward() 
    957958        else: 
    958959            length = 1 
    959960            use_handle = False 
     
    962963                    use_handle = True 
    963964                    break 
    964965                length += 1 
    965                 ch = self.peek(length) 
     966                ch = self.reader.peek(length) 
    966967            handle = u'!' 
    967968            if use_handle: 
    968969                handle = self.scan_tag_handle('tag', start_mark) 
    969970            else: 
    970971                handle = u'!' 
    971                 self.forward() 
     972                self.reader.forward() 
    972973            suffix = self.scan_tag_uri('tag', start_mark) 
    973         ch = self.peek() 
     974        ch = self.reader.peek() 
    974975        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    975976            raise ScannerError("while scanning a tag", start_mark, 
    976977                    "expected ' ', but found %r" % ch.encode('utf-8'), 
    977                     self.get_mark()) 
     978                    self.reader.get_mark()) 
    978979        value = (handle, suffix) 
    979         end_mark = self.get_mark() 
     980        end_mark = self.reader.get_mark() 
    980981        return TagToken(value, start_mark, end_mark) 
    981982 
    982983    def scan_block_scalar(self, style): 
     
    988989            folded = False 
    989990 
    990991        chunks = [] 
    991         start_mark = self.get_mark() 
     992        start_mark = self.reader.get_mark() 
    992993 
    993994        # Scan the header. 
    994         self.forward() 
     995        self.reader.forward() 
    995996        chomping, increment = self.scan_block_scalar_indicators(start_mark) 
    996997        self.scan_block_scalar_ignored_line(start_mark) 
    997998 
     
    10081009        line_break = u'' 
    10091010 
    10101011        # Scan the inner part of the block scalar. 
    1011         while self.column == indent and self.peek() != u'\0': 
     1012        while self.reader.column == indent and self.reader.peek() != u'\0': 
    10121013            chunks.extend(breaks) 
    1013             leading_non_space = self.peek() not in u' \t' 
     1014            leading_non_space = self.reader.peek() not in u' \t' 
    10141015            length = 0 
    1015             while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
     1016            while self.reader.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
    10161017                length += 1 
    1017             chunks.append(self.prefix(length)) 
    1018             self.forward(length) 
     1018            chunks.append(self.reader.prefix(length)) 
     1019            self.reader.forward(length) 
    10191020            line_break = self.scan_line_break() 
    10201021            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1021             if self.column == indent and self.peek() != u'\0': 
     1022            if self.reader.column == indent and self.reader.peek() != u'\0': 
    10221023 
    10231024                # Unfortunately, folding rules are ambiguous. 
    10241025                # 
    10251026                # This is the folding according to the specification: 
    10261027                 
    10271028                if folded and line_break == u'\n'   \ 
    1028                         and leading_non_space and self.peek() not in u' \t': 
     1029                        and leading_non_space and self.reader.peek() not in u' \t': 
    10291030                    if not breaks: 
    10301031                        chunks.append(u' ') 
    10311032                else: 
     
    10361037                # 
    10371038                #if folded and line_break == u'\n': 
    10381039                #    if not breaks: 
    1039                 #        if self.peek() not in ' \t': 
     1040                #        if self.reader.peek() not in ' \t': 
    10401041                #            chunks.append(u' ') 
    10411042                #        else: 
    10421043                #            chunks.append(line_break) 
     
    10591060        # See the specification for details. 
    10601061        chomping = None 
    10611062        increment = None 
    1062         ch = self.peek() 
     1063        ch = self.reader.peek() 
    10631064        if ch in u'+-': 
    10641065            if ch == '+': 
    10651066                chomping = True 
    10661067            else: 
    10671068                chomping = False 
    1068             self.forward() 
    1069             ch = self.peek() 
     1069            self.reader.forward() 
     1070            ch = self.reader.peek() 
    10701071            if ch in u'0123456789': 
    10711072                increment = int(ch) 
    10721073                if increment == 0: 
    10731074                    raise ScannerError("while scanning a block scalar", start_mark, 
    10741075                            "expected indentation indicator in the range 1-9, but found 0", 
    1075                             self.get_mark()) 
    1076                 self.forward() 
     1076                            self.reader.get_mark()) 
     1077                self.reader.forward() 
    10771078        elif ch in u'0123456789': 
    10781079            increment = int(ch) 
    10791080            if increment == 0: 
    10801081                raise ScannerError("while scanning a block scalar", start_mark, 
    10811082                        "expected indentation indicator in the range 1-9, but found 0", 
    1082                         self.get_mark()) 
    1083             self.forward() 
    1084             ch = self.peek() 
     1083                        self.reader.get_mark()) 
     1084            self.reader.forward() 
     1085            ch = self.reader.peek() 
    10851086            if ch in u'+-': 
    10861087                if ch == '+': 
    10871088                    chomping = True 
    10881089                else: 
    10891090                    chomping = False 
    1090                 self.forward() 
    1091         ch = self.peek() 
     1091                self.reader.forward() 
     1092        ch = self.reader.peek() 
    10921093        if ch not in u'\0 \r\n\x85\u2028\u2029': 
    10931094            raise ScannerError("while scanning a block scalar", start_mark, 
    10941095                    "expected chomping or indentation indicators, but found %r" 
    1095                         % ch.encode('utf-8'), self.get_mark()) 
     1096                        % ch.encode('utf-8'), self.reader.get_mark()) 
    10961097        return chomping, increment 
    10971098 
    10981099    def scan_block_scalar_ignored_line(self, start_mark): 
    10991100        # See the specification for details. 
    1100         while self.peek() == u' ': 
    1101             self.forward() 
    1102         if self.peek() == u'#': 
    1103             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
    1104                 self.forward() 
    1105         ch = self.peek() 
     1101        while self.reader.peek() == u' ': 
     1102            self.reader.forward() 
     1103        if self.reader.peek() == u'#': 
     1104            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': 
     1105                self.reader.forward() 
     1106        ch = self.reader.peek() 
    11061107        if ch not in u'\0\r\n\x85\u2028\u2029': 
    11071108            raise ScannerError("while scanning a block scalar", start_mark, 
    11081109                    "expected a comment or a line break, but found %r" 
    1109                         % ch.encode('utf-8'), self.get_mark()) 
     1110                        % ch.encode('utf-8'), self.reader.get_mark()) 
    11101111        self.scan_line_break() 
    11111112 
    11121113    def scan_block_scalar_indentation(self): 
    11131114        # See the specification for details. 
    11141115        chunks = [] 
    11151116        max_indent = 0 
    1116         end_mark = self.get_mark() 
    1117         while self.peek() in u' \r\n\x85\u2028\u2029': 
    1118             if self.peek() != u' ': 
     1117        end_mark = self.reader.get_mark() 
     1118        while self.reader.peek() in u' \r\n\x85\u2028\u2029': 
     1119            if self.reader.peek() != u' ': 
    11191120                chunks.append(self.scan_line_break()) 
    1120                 end_mark = self.get_mark() 
     1121                end_mark = self.reader.get_mark() 
    11211122            else: 
    1122                 self.forward() 
    1123                 if self.column > max_indent: 
    1124                     max_indent = self.column 
     1123                self.reader.forward() 
     1124                if self.reader.column > max_indent: 
     1125                    max_indent = self.reader.column 
    11251126        return chunks, max_indent, end_mark 
    11261127 
    11271128    def scan_block_scalar_breaks(self, indent): 
    11281129        # See the specification for details. 
    11291130        chunks = [] 
    1130         end_mark = self.get_mark() 
    1131         while self.column < indent and self.peek() == u' ': 
    1132             self.forward() 
    1133         while self.peek() in u'\r\n\x85\u2028\u2029': 
     1131        end_mark = self.reader.get_mark() 
     1132        while self.reader.column < indent and self.reader.peek() == u' ': 
     1133            self.reader.forward() 
     1134        while self.reader.peek() in u'\r\n\x85\u2028\u2029': 
    11341135            chunks.append(self.scan_line_break()) 
    1135             end_mark = self.get_mark() 
    1136             while self.column < indent and self.peek() == u' ': 
    1137                 self.forward() 
     1136            end_mark = self.reader.get_mark() 
     1137            while self.reader.column < indent and self.reader.peek() == u' ': 
     1138                self.reader.forward() 
    11381139        return chunks, end_mark 
    11391140 
    11401141    def scan_flow_scalar(self, style): 
     
    11491150        else: 
    11501151            double = False 
    11511152        chunks = [] 
    1152         start_mark = self.get_mark() 
    1153         quote = self.peek() 
    1154         self.forward() 
     1153        start_mark = self.reader.get_mark() 
     1154        quote = self.reader.peek() 
     1155        self.reader.forward() 
    11551156        chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) 
    1156         while self.peek() != quote: 
     1157        while self.reader.peek() != quote: 
    11571158            chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) 
    11581159            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) 
    1159         self.forward() 
    1160         end_mark = self.get_mark() 
     1160        self.reader.forward() 
     1161        end_mark = self.reader.get_mark() 
    11611162        return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
    11621163                style) 
    11631164 
     
    11921193        chunks = [] 
    11931194        while True: 
    11941195            length = 0 
    1195             while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
     1196            while self.reader.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
    11961197                length += 1 
    11971198            if length: 
    1198                 chunks.append(self.prefix(length)) 
    1199                 self.forward(length) 
    1200             ch = self.peek() 
    1201             if not double and ch == u'\'' and self.peek(1) == u'\'': 
     1199                chunks.append(self.reader.prefix(length)) 
     1200                self.reader.forward(length) 
     1201            ch = self.reader.peek() 
     1202            if not double and ch == u'\'' and self.reader.peek(1) == u'\'': 
    12021203                chunks.append(u'\'') 
    1203                 self.forward(2) 
     1204                self.reader.forward(2) 
    12041205            elif (double and ch == u'\'') or (not double and ch in u'\"\\'): 
    12051206                chunks.append(ch) 
    1206                 self.forward() 
     1207                self.reader.forward() 
    12071208            elif double and ch == u'\\': 
    1208                 self.forward() 
    1209                 ch = self.peek() 
     1209                self.reader.forward() 
     1210                ch = self.reader.peek() 
    12101211                if ch in self.ESCAPE_REPLACEMENTS: 
    12111212                    chunks.append(self.ESCAPE_REPLACEMENTS[ch]) 
    1212                     self.forward() 
     1213                    self.reader.forward() 
    12131214                elif ch in self.ESCAPE_CODES: 
    12141215                    length = self.ESCAPE_CODES[ch] 
    1215                     self.forward() 
     1216                    self.reader.forward() 
    12161217                    for k in range(length): 
    1217                         if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1218                        if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
    12181219                            raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    12191220                                    "expected escape sequence of %d hexdecimal numbers, but found %r" % 
    1220                                         (length, self.peek(k).encode('utf-8')), self.get_mark()) 
    1221                     code = int(self.prefix(length), 16) 
     1221                                        (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) 
     1222                    code = int(self.reader.prefix(length), 16) 
    12221223                    chunks.append(unichr(code)) 
    1223                     self.forward(length) 
     1224                    self.reader.forward(length) 
    12241225                elif ch in u'\r\n\x85\u2028\u2029': 
    12251226                    self.scan_line_break() 
    12261227                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) 
    12271228                else: 
    12281229                    raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    1229                             "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark()) 
     1230                            "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark()) 
    12301231            else: 
    12311232                return chunks 
    12321233 
     
    12341235        # See the specification for details. 
    12351236        chunks = [] 
    12361237        length = 0 
    1237         while self.peek(length) in u' \t': 
     1238        while self.reader.peek(length) in u' \t': 
    12381239            length += 1 
    1239         whitespaces = self.prefix(length) 
    1240         self.forward(length) 
    1241         ch = self.peek() 
     1240        whitespaces = self.reader.prefix(length) 
     1241        self.reader.forward(length) 
     1242        ch = self.reader.peek() 
    12421243        if ch == u'\0': 
    12431244            raise ScannerError("while scanning a quoted scalar", start_mark, 
    1244                     "found unexpected end of stream", self.get_mark()) 
     1245                    "found unexpected end of stream", self.reader.get_mark()) 
    12451246        elif ch in u'\r\n\x85\u2028\u2029': 
    12461247            line_break = self.scan_line_break() 
    12471248            breaks = self.scan_flow_scalar_breaks(double, start_mark) 
     
    12601261        while True: 
    12611262            # Instead of checking indentation, we check for document 
    12621263            # separators. 
    1263             prefix = self.prefix(3) 
     1264            prefix = self.reader.prefix(3) 
    12641265            if (prefix == u'---' or prefix == u'...')   \ 
    1265                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1266                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    12661267                raise ScannerError("while scanning a quoted scalar", start_mark, 
    1267                         "found unexpected document separator", self.get_mark()) 
    1268             while self.peek() in u' \t': 
    1269                 self.forward() 
    1270             if self.peek() in u'\r\n\x85\u2028\u2029': 
     1268                        "found unexpected document separator", self.reader.get_mark()) 
     1269            while self.reader.peek() in u' \t': 
     1270                self.reader.forward() 
     1271            if self.reader.peek() in u'\r\n\x85\u2028\u2029': 
    12711272                chunks.append(self.scan_line_break()) 
    12721273            else: 
    12731274                return chunks 
     
    12791280        # We also keep track of the `allow_simple_key` flag here. 
    12801281        # Indentation rules are loosed for the flow context. 
    12811282        chunks = [] 
    1282         start_mark = self.get_mark() 
     1283        start_mark = self.reader.get_mark() 
    12831284        end_mark = start_mark 
    12841285        indent = self.indent+1 
    12851286        # We allow zero indentation for scalars, but then we need to check for 
     
    12891290        spaces = [] 
    12901291        while True: 
    12911292            length = 0 
    1292             if self.peek() == u'#': 
     1293            if self.reader.peek() == u'#': 
    12931294                break 
    12941295            while True: 
    1295                 ch = self.peek(length) 
     1296                ch = self.reader.peek(length) 
    12961297                if ch in u'\0 \t\r\n\x85\u2028\u2029'   \ 
    12971298                        or (not self.flow_level and ch == u':' and 
    1298                                 self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ 
     1299                                self.reader.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ 
    12991300                        or (self.flow_level and ch in u',:?[]{}'): 
    13001301                    break 
    13011302                length += 1 
    13021303            # It's not clear what we should do with ':' in the flow context. 
    13031304            if (self.flow_level and ch == u':' 
    1304                     and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): 
    1305                 self.forward(length) 
     1305                    and self.reader.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): 
     1306                self.reader.forward(length) 
    13061307                raise ScannerError("while scanning a plain scalar", start_mark, 
    1307                     "found unexpected ':'", self.get_mark(), 
     1308                    "found unexpected ':'", self.reader.get_mark(), 
    13081309                    "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.") 
    13091310            if length == 0: 
    13101311                break 
    13111312            self.allow_simple_key = False 
    13121313            chunks.extend(spaces) 
    1313             chunks.append(self.prefix(length)) 
    1314             self.forward(length) 
    1315             end_mark = self.get_mark() 
     1314            chunks.append(self.reader.prefix(length)) 
     1315            self.reader.forward(length) 
     1316            end_mark = self.reader.get_mark() 
    13161317            spaces = self.scan_plain_spaces(indent, start_mark) 
    1317             if not spaces or self.peek() == u'#' \ 
    1318                     or (not self.flow_level and self.column < indent): 
     1318            if not spaces or self.reader.peek() == u'#' \ 
     1319                    or (not self.flow_level and self.reader.column < indent): 
    13191320                break 
    13201321        return ScalarToken(u''.join(chunks), True, start_mark, end_mark) 
    13211322 
     
    13251326        # We just forbid them completely. Do not use tabs in YAML! 
    13261327        chunks = [] 
    13271328        length = 0 
    1328         while self.peek(length) in u' ': 
     1329        while self.reader.peek(length) in u' ': 
    13291330            length += 1 
    1330         whitespaces = self.prefix(length) 
    1331         self.forward(length) 
    1332         ch = self.peek() 
     1331        whitespaces = self.reader.prefix(length) 
     1332        self.reader.forward(length) 
     1333        ch = self.reader.peek() 
    13331334        if ch in u'\r\n\x85\u2028\u2029': 
    13341335            line_break = self.scan_line_break() 
    13351336            self.allow_simple_key = True 
    1336             prefix = self.prefix(3) 
     1337            prefix = self.reader.prefix(3) 
    13371338            if (prefix == u'---' or prefix == u'...')   \ 
    1338                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1339                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    13391340                return 
    13401341            breaks = [] 
    1341             while self.peek() in u' \r\n\x85\u2028\u2029': 
    1342                 if self.peek() == ' ': 
    1343                     self.forward() 
     1342            while self.reader.peek() in u' \r\n\x85\u2028\u2029': 
     1343                if self.reader.peek() == ' ': 
     1344                    self.reader.forward() 
    13441345                else: 
    13451346                    breaks.append(self.scan_line_break()) 
    1346                     prefix = self.prefix(3) 
     1347                    prefix = self.reader.prefix(3) 
    13471348                    if (prefix == u'---' or prefix == u'...')   \ 
    1348                             and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1349                            and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
    13491350                        return 
    13501351            if line_break != u'\n': 
    13511352                chunks.append(line_break) 
     
    13601361        # See the specification for details. 
    13611362        # For some strange reasons, the specification does not allow '_' in 
    13621363        # tag handles. I have allowed it anyway. 
    1363         ch = self.peek() 
     1364        ch = self.reader.peek() 
    13641365        if ch != u'!': 
    13651366            raise ScannerError("while scanning a %s" % name, start_mark, 
    13661367                    "expected '!', but found %r" % ch.encode('utf-8'), 
    1367                     self.get_mark()) 
     1368                    self.reader.get_mark()) 
    13681369        length = 1 
    1369         ch = self.peek(length) 
     1370        ch = self.reader.peek(length) 
    13701371        if ch != u' ': 
    13711372            while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    13721373                    or ch in u'-_': 
    13731374                length += 1 
    1374                 ch = self.peek(length) 
     1375                ch = self.reader.peek(length) 
    13751376            if ch != u'!': 
    1376                 self.forward(length) 
     1377                self.reader.forward(length) 
    13771378                raise ScannerError("while scanning a %s" % name, start_mark, 
    13781379                        "expected '!', but found %r" % ch.encode('utf-8'), 
    1379                         self.get_mark()) 
     1380                        self.reader.get_mark()) 
    13801381            length += 1 
    1381         value = self.prefix(length) 
    1382         self.forward(length) 
     1382        value = self.reader.prefix(length) 
     1383        self.reader.forward(length) 
    13831384        return value 
    13841385 
    13851386    def scan_tag_uri(self, name, start_mark): 
     
    13871388        # Note: we do not check if URI is well-formed. 
    13881389        chunks = [] 
    13891390        length = 0 
    1390         ch = self.peek(length) 
     1391        ch = self.reader.peek(length) 
    13911392        while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    13921393                or ch in u'-;/?:@&=+$,_.!~*\'()[]%': 
    13931394            if ch == u'%': 
    1394                 chunks.append(self.prefix(length)) 
    1395                 self.forward(length) 
     1395                chunks.append(self.reader.prefix(length)) 
     1396                self.reader.forward(length) 
    13961397                length = 0 
    13971398                chunks.append(self.scan_uri_escapes(name, start_mark)) 
    13981399            else: 
    13991400                length += 1 
    1400             ch = self.peek(length) 
     1401            ch = self.reader.peek(length) 
    14011402        if length: 
    1402             chunks.append(self.prefix(length)) 
    1403             self.forward(length) 
     1403            chunks.append(self.reader.prefix(length)) 
     1404            self.reader.forward(length) 
    14041405            length = 0 
    14051406        if not chunks: 
    14061407            raise ScannerError("while parsing a %s" % name, start_mark, 
    14071408                    "expected URI, but found %r" % ch.encode('utf-8'), 
    1408                     self.get_mark()) 
     1409                    self.reader.get_mark()) 
    14091410        return u''.join(chunks) 
    14101411 
    14111412    def scan_uri_escapes(self, name, start_mark): 
    14121413        # See the specification for details. 
    14131414        bytes = [] 
    1414         mark = self.get_mark() 
    1415         while self.peek() == u'%': 
    1416             self.forward() 
     1415        mark = self.reader.get_mark() 
     1416        while self.reader.peek() == u'%': 
     1417            self.reader.forward() 
    14171418            for k in range(2): 
    1418                 if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1419                if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': 
    14191420                    raise ScannerError("while scanning a %s" % name, start_mark, 
    14201421                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % 
    1421                                 (self.peek(k).encode('utf-8')), self.get_mark()) 
    1422             bytes.append(chr(int(self.prefix(2), 16))) 
    1423             self.forward(2) 
     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) 
    14241425        try: 
    14251426            value = unicode(''.join(bytes), 'utf-8') 
    14261427        except UnicodeDecodeError, exc: 
     
    14361437        #   '\u2028'    :   '\u2028' 
    14371438        #   '\u2029     :   '\u2029' 
    14381439        #   default     :   '' 
    1439         ch = self.peek() 
     1440        ch = self.reader.peek() 
    14401441        if ch in u'\r\n\x85': 
    1441             if self.prefix(2) == u'\r\n': 
    1442                 self.forward(2) 
     1442            if self.reader.prefix(2) == u'\r\n': 
     1443                self.reader.forward(2) 
    14431444            else: 
    1444                 self.forward() 
     1445                self.reader.forward() 
    14451446            return u'\n' 
    14461447        elif ch in u'\u2028\u2029': 
    1447             self.forward() 
     1448            self.reader.forward() 
    14481449            return ch 
    14491450        return u'' 
    14501451 
  • C:/projects/workspace_python/PyYAML_2/lib/yaml/loader.py

     
    88from constructor import * 
    99from resolver import * 
    1010 
    11 class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): 
     11class BaseLoader(Scanner, Parser, Composer, BaseConstructor, BaseResolver): 
    1212 
    1313    def __init__(self, stream): 
    14         Reader.__init__(self, stream) 
    15         Scanner.__init__(self) 
     14        Scanner.__init__(self, Reader(stream)) 
    1615        Parser.__init__(self) 
    1716        Composer.__init__(self) 
    1817        BaseConstructor.__init__(self) 
    1918        BaseResolver.__init__(self) 
    2019 
    21 class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): 
     20class SafeLoader(Scanner, Parser, Composer, SafeConstructor, Resolver): 
    2221 
    2322    def __init__(self, stream): 
    24         Reader.__init__(self, stream) 
    25         Scanner.__init__(self) 
     23        Scanner.__init__(self, Reader(stream)) 
    2624        Parser.__init__(self) 
    2725        Composer.__init__(self) 
    2826        SafeConstructor.__init__(self) 
    2927        Resolver.__init__(self) 
    3028 
    31 class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): 
     29class Loader(Scanner, Parser, Composer, Constructor, Resolver): 
    3230 
    3331    def __init__(self, stream): 
    34         Reader.__init__(self, stream) 
    35         Scanner.__init__(self) 
     32        Scanner.__init__(self, Reader(stream)) 
    3633        Parser.__init__(self) 
    3734        Composer.__init__(self) 
    3835        Constructor.__init__(self)