Ignore:
Timestamp:
12/29/08 12:24:05 (6 years ago)
Author:
xi
Message:

Added basic support for Python 3 (Thanks idadesub(at)users(dot)sourceforge(dot)net).

Location:
pyyaml/trunk/lib3
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib3/yaml/scanner.py

    r222 r328  
    2727__all__ = ['Scanner', 'ScannerError'] 
    2828 
    29 from error import MarkedYAMLError 
    30 from tokens import * 
     29from .error import MarkedYAMLError 
     30from .tokens import * 
    3131 
    3232class ScannerError(MarkedYAMLError): 
    3333    pass 
    3434 
    35 class SimpleKey(object): 
     35class SimpleKey: 
    3636    # See below simple keys treatment. 
    3737 
     
    4444        self.mark = mark 
    4545 
    46 class Scanner(object): 
     46class Scanner: 
    4747 
    4848    def __init__(self): 
     
    167167 
    168168        # Is it the end of stream? 
    169         if ch == u'\0': 
     169        if ch == '\0': 
    170170            return self.fetch_stream_end() 
    171171 
    172172        # Is it a directive? 
    173         if ch == u'%' and self.check_directive(): 
     173        if ch == '%' and self.check_directive(): 
    174174            return self.fetch_directive() 
    175175 
    176176        # Is it the document start? 
    177         if ch == u'-' and self.check_document_start(): 
     177        if ch == '-' and self.check_document_start(): 
    178178            return self.fetch_document_start() 
    179179 
    180180        # Is it the document end? 
    181         if ch == u'.' and self.check_document_end(): 
     181        if ch == '.' and self.check_document_end(): 
    182182            return self.fetch_document_end() 
    183183 
    184184        # TODO: support for BOM within a stream. 
    185         #if ch == u'\uFEFF': 
     185        #if ch == '\uFEFF': 
    186186        #    return self.fetch_bom()    <-- issue BOMToken 
    187187 
     
    189189 
    190190        # Is it the flow sequence start indicator? 
    191         if ch == u'[': 
     191        if ch == '[': 
    192192            return self.fetch_flow_sequence_start() 
    193193 
    194194        # Is it the flow mapping start indicator? 
    195         if ch == u'{': 
     195        if ch == '{': 
    196196            return self.fetch_flow_mapping_start() 
    197197 
    198198        # Is it the flow sequence end indicator? 
    199         if ch == u']': 
     199        if ch == ']': 
    200200            return self.fetch_flow_sequence_end() 
    201201 
    202202        # Is it the flow mapping end indicator? 
    203         if ch == u'}': 
     203        if ch == '}': 
    204204            return self.fetch_flow_mapping_end() 
    205205 
    206206        # Is it the flow entry indicator? 
    207         if ch == u',': 
     207        if ch == ',': 
    208208            return self.fetch_flow_entry() 
    209209 
    210210        # Is it the block entry indicator? 
    211         if ch == u'-' and self.check_block_entry(): 
     211        if ch == '-' and self.check_block_entry(): 
    212212            return self.fetch_block_entry() 
    213213 
    214214        # Is it the key indicator? 
    215         if ch == u'?' and self.check_key(): 
     215        if ch == '?' and self.check_key(): 
    216216            return self.fetch_key() 
    217217 
    218218        # Is it the value indicator? 
    219         if ch == u':' and self.check_value(): 
     219        if ch == ':' and self.check_value(): 
    220220            return self.fetch_value() 
    221221 
    222222        # Is it an alias? 
    223         if ch == u'*': 
     223        if ch == '*': 
    224224            return self.fetch_alias() 
    225225 
    226226        # Is it an anchor? 
    227         if ch == u'&': 
     227        if ch == '&': 
    228228            return self.fetch_anchor() 
    229229 
    230230        # Is it a tag? 
    231         if ch == u'!': 
     231        if ch == '!': 
    232232            return self.fetch_tag() 
    233233 
    234234        # Is it a literal scalar? 
    235         if ch == u'|' and not self.flow_level: 
     235        if ch == '|' and not self.flow_level: 
    236236            return self.fetch_literal() 
    237237 
    238238        # Is it a folded scalar? 
    239         if ch == u'>' and not self.flow_level: 
     239        if ch == '>' and not self.flow_level: 
    240240            return self.fetch_folded() 
    241241 
    242242        # Is it a single quoted scalar? 
    243         if ch == u'\'': 
     243        if ch == '\'': 
    244244            return self.fetch_single() 
    245245 
    246246        # Is it a double quoted scalar? 
    247         if ch == u'\"': 
     247        if ch == '\"': 
    248248            return self.fetch_double() 
    249249 
     
    254254        # No? It's an error. Let's produce a nice error message. 
    255255        raise ScannerError("while scanning for the next token", None, 
    256                 "found character %r that cannot start any token" 
    257                 % ch.encode('utf-8'), self.get_mark()) 
     256                "found character %r that cannot start any token" % ch, 
     257                self.get_mark()) 
    258258 
    259259    # Simple keys treatment. 
     
    281281        # Disabling this procedure will allow simple keys of any length and 
    282282        # height (may cause problems if indentation is broken though). 
    283         for level in self.possible_simple_keys.keys(): 
     283        for level in list(self.possible_simple_keys): 
    284284            key = self.possible_simple_keys[level] 
    285285            if key.line != self.line  \ 
     
    692692        # DOCUMENT-START:   ^ '---' (' '|'\n') 
    693693        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.prefix(3) == '---'  \ 
     695                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    696696                return True 
    697697 
     
    700700        # DOCUMENT-END:     ^ '...' (' '|'\n') 
    701701        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.prefix(3) == '...'  \ 
     703                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    704704                return True 
    705705 
     
    707707 
    708708        # BLOCK-ENTRY:      '-' (' '|'\n') 
    709         return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     709        return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    710710 
    711711    def check_key(self): 
     
    717717        # KEY(block context):   '?' (' '|'\n') 
    718718        else: 
    719             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     719            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    720720 
    721721    def check_value(self): 
     
    727727        # VALUE(block context): ':' (' '|'\n') 
    728728        else: 
    729             return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' 
     729            return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' 
    730730 
    731731    def check_plain(self): 
     
    744744        # independent. 
    745745        ch = self.peek() 
    746         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                         and (ch == u'-' or (not self.flow_level and ch in u'?:'))) 
     746        return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \ 
     747                or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029' 
     748                        and (ch == '-' or (not self.flow_level and ch in '?:'))) 
    749749 
    750750    # Scanners. 
     
    770770        # Scanners for block, flow, and plain scalars need to be modified. 
    771771 
    772         if self.index == 0 and self.peek() == u'\uFEFF': 
     772        if self.index == 0 and self.peek() == '\uFEFF': 
    773773            self.forward() 
    774774        found = False 
    775775        while not found: 
    776             while self.peek() == u' ': 
     776            while self.peek() == ' ': 
    777777                self.forward() 
    778             if self.peek() == u'#': 
    779                 while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     778            if self.peek() == '#': 
     779                while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    780780                    self.forward() 
    781781            if self.scan_line_break(): 
     
    791791        name = self.scan_directive_name(start_mark) 
    792792        value = None 
    793         if name == u'YAML': 
     793        if name == 'YAML': 
    794794            value = self.scan_yaml_directive_value(start_mark) 
    795795            end_mark = self.get_mark() 
    796         elif name == u'TAG': 
     796        elif name == 'TAG': 
    797797            value = self.scan_tag_directive_value(start_mark) 
    798798            end_mark = self.get_mark() 
    799799        else: 
    800800            end_mark = self.get_mark() 
    801             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     801            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    802802                self.forward() 
    803803        self.scan_directive_ignored_line(start_mark) 
     
    808808        length = 0 
    809809        ch = self.peek(length) 
    810         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    811                 or ch in u'-_': 
     810        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     811                or ch in '-_': 
    812812            length += 1 
    813813            ch = self.peek(length) 
     
    815815            raise ScannerError("while scanning a directive", start_mark, 
    816816                    "expected alphabetic or numeric character, but found %r" 
    817                     % ch.encode('utf-8'), self.get_mark()) 
     817                    % ch, self.get_mark()) 
    818818        value = self.prefix(length) 
    819819        self.forward(length) 
    820820        ch = self.peek() 
    821         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     821        if ch not in '\0 \r\n\x85\u2028\u2029': 
    822822            raise ScannerError("while scanning a directive", start_mark, 
    823823                    "expected alphabetic or numeric character, but found %r" 
    824                     % ch.encode('utf-8'), self.get_mark()) 
     824                    % ch, self.get_mark()) 
    825825        return value 
    826826 
    827827    def scan_yaml_directive_value(self, start_mark): 
    828828        # See the specification for details. 
    829         while self.peek() == u' ': 
     829        while self.peek() == ' ': 
    830830            self.forward() 
    831831        major = self.scan_yaml_directive_number(start_mark) 
    832832        if self.peek() != '.': 
    833833            raise ScannerError("while scanning a directive", start_mark, 
    834                     "expected a digit or '.', but found %r" 
    835                     % self.peek().encode('utf-8'), 
     834                    "expected a digit or '.', but found %r" % self.peek(), 
    836835                    self.get_mark()) 
    837836        self.forward() 
    838837        minor = self.scan_yaml_directive_number(start_mark) 
    839         if self.peek() not in u'\0 \r\n\x85\u2028\u2029': 
     838        if self.peek() not in '\0 \r\n\x85\u2028\u2029': 
    840839            raise ScannerError("while scanning a directive", start_mark, 
    841                     "expected a digit or ' ', but found %r" 
    842                     % self.peek().encode('utf-8'), 
     840                    "expected a digit or ' ', but found %r" % self.peek(), 
    843841                    self.get_mark()) 
    844842        return (major, minor) 
     
    847845        # See the specification for details. 
    848846        ch = self.peek() 
    849         if not (u'0' <= ch <= '9'): 
     847        if not ('0' <= ch <= '9'): 
    850848            raise ScannerError("while scanning a directive", start_mark, 
    851                     "expected a digit, but found %r" % ch.encode('utf-8'), 
    852                     self.get_mark()) 
     849                    "expected a digit, but found %r" % ch, self.get_mark()) 
    853850        length = 0 
    854         while u'0' <= self.peek(length) <= u'9': 
     851        while '0' <= self.peek(length) <= '9': 
    855852            length += 1 
    856853        value = int(self.prefix(length)) 
     
    860857    def scan_tag_directive_value(self, start_mark): 
    861858        # See the specification for details. 
    862         while self.peek() == u' ': 
     859        while self.peek() == ' ': 
    863860            self.forward() 
    864861        handle = self.scan_tag_directive_handle(start_mark) 
    865         while self.peek() == u' ': 
     862        while self.peek() == ' ': 
    866863            self.forward() 
    867864        prefix = self.scan_tag_directive_prefix(start_mark) 
     
    872869        value = self.scan_tag_handle('directive', start_mark) 
    873870        ch = self.peek() 
    874         if ch != u' ': 
     871        if ch != ' ': 
    875872            raise ScannerError("while scanning a directive", start_mark, 
    876                     "expected ' ', but found %r" % ch.encode('utf-8'), 
    877                     self.get_mark()) 
     873                    "expected ' ', but found %r" % ch, self.get_mark()) 
    878874        return value 
    879875 
     
    882878        value = self.scan_tag_uri('directive', start_mark) 
    883879        ch = self.peek() 
    884         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     880        if ch not in '\0 \r\n\x85\u2028\u2029': 
    885881            raise ScannerError("while scanning a directive", start_mark, 
    886                     "expected ' ', but found %r" % ch.encode('utf-8'), 
    887                     self.get_mark()) 
     882                    "expected ' ', but found %r" % ch, self.get_mark()) 
    888883        return value 
    889884 
    890885    def scan_directive_ignored_line(self, start_mark): 
    891886        # See the specification for details. 
    892         while self.peek() == u' ': 
     887        while self.peek() == ' ': 
    893888            self.forward() 
    894         if self.peek() == u'#': 
    895             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     889        if self.peek() == '#': 
     890            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    896891                self.forward() 
    897892        ch = self.peek() 
    898         if ch not in u'\0\r\n\x85\u2028\u2029': 
     893        if ch not in '\0\r\n\x85\u2028\u2029': 
    899894            raise ScannerError("while scanning a directive", start_mark, 
    900895                    "expected a comment or a line break, but found %r" 
    901                         % ch.encode('utf-8'), self.get_mark()) 
     896                        % ch, self.get_mark()) 
    902897        self.scan_line_break() 
    903898 
     
    920915        length = 0 
    921916        ch = self.peek(length) 
    922         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    923                 or ch in u'-_': 
     917        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     918                or ch in '-_': 
    924919            length += 1 
    925920            ch = self.peek(length) 
     
    927922            raise ScannerError("while scanning an %s" % name, start_mark, 
    928923                    "expected alphabetic or numeric character, but found %r" 
    929                     % ch.encode('utf-8'), self.get_mark()) 
     924                    % ch, self.get_mark()) 
    930925        value = self.prefix(length) 
    931926        self.forward(length) 
    932927        ch = self.peek() 
    933         if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
     928        if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`': 
    934929            raise ScannerError("while scanning an %s" % name, start_mark, 
    935930                    "expected alphabetic or numeric character, but found %r" 
    936                     % ch.encode('utf-8'), self.get_mark()) 
     931                    % ch, self.get_mark()) 
    937932        end_mark = self.get_mark() 
    938933        return TokenClass(value, start_mark, end_mark) 
     
    942937        start_mark = self.get_mark() 
    943938        ch = self.peek(1) 
    944         if ch == u'<': 
     939        if ch == '<': 
    945940            handle = None 
    946941            self.forward(2) 
    947942            suffix = self.scan_tag_uri('tag', start_mark) 
    948             if self.peek() != u'>': 
     943            if self.peek() != '>': 
    949944                raise ScannerError("while parsing a tag", start_mark, 
    950                         "expected '>', but found %r" % self.peek().encode('utf-8'), 
     945                        "expected '>', but found %r" % self.peek(), 
    951946                        self.get_mark()) 
    952947            self.forward() 
    953         elif ch in u'\0 \t\r\n\x85\u2028\u2029': 
     948        elif ch in '\0 \t\r\n\x85\u2028\u2029': 
    954949            handle = None 
    955             suffix = u'!' 
     950            suffix = '!' 
    956951            self.forward() 
    957952        else: 
    958953            length = 1 
    959954            use_handle = False 
    960             while ch not in u'\0 \r\n\x85\u2028\u2029': 
    961                 if ch == u'!': 
     955            while ch not in '\0 \r\n\x85\u2028\u2029': 
     956                if ch == '!': 
    962957                    use_handle = True 
    963958                    break 
    964959                length += 1 
    965960                ch = self.peek(length) 
    966             handle = u'!' 
     961            handle = '!' 
    967962            if use_handle: 
    968963                handle = self.scan_tag_handle('tag', start_mark) 
    969964            else: 
    970                 handle = u'!' 
     965                handle = '!' 
    971966                self.forward() 
    972967            suffix = self.scan_tag_uri('tag', start_mark) 
    973968        ch = self.peek() 
    974         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     969        if ch not in '\0 \r\n\x85\u2028\u2029': 
    975970            raise ScannerError("while scanning a tag", start_mark, 
    976                     "expected ' ', but found %r" % ch.encode('utf-8'), 
    977                     self.get_mark()) 
     971                    "expected ' ', but found %r" % ch, self.get_mark()) 
    978972        value = (handle, suffix) 
    979973        end_mark = self.get_mark() 
     
    10061000            indent = min_indent+increment-1 
    10071001            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1008         line_break = u'' 
     1002        line_break = '' 
    10091003 
    10101004        # Scan the inner part of the block scalar. 
    1011         while self.column == indent and self.peek() != u'\0': 
     1005        while self.column == indent and self.peek() != '\0': 
    10121006            chunks.extend(breaks) 
    1013             leading_non_space = self.peek() not in u' \t' 
     1007            leading_non_space = self.peek() not in ' \t' 
    10141008            length = 0 
    1015             while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': 
     1009            while self.peek(length) not in '\0\r\n\x85\u2028\u2029': 
    10161010                length += 1 
    10171011            chunks.append(self.prefix(length)) 
     
    10191013            line_break = self.scan_line_break() 
    10201014            breaks, end_mark = self.scan_block_scalar_breaks(indent) 
    1021             if self.column == indent and self.peek() != u'\0': 
     1015            if self.column == indent and self.peek() != '\0': 
    10221016 
    10231017                # Unfortunately, folding rules are ambiguous. 
     
    10251019                # This is the folding according to the specification: 
    10261020                 
    1027                 if folded and line_break == u'\n'   \ 
    1028                         and leading_non_space and self.peek() not in u' \t': 
     1021                if folded and line_break == '\n'    \ 
     1022                        and leading_non_space and self.peek() not in ' \t': 
    10291023                    if not breaks: 
    1030                         chunks.append(u' ') 
     1024                        chunks.append(' ') 
    10311025                else: 
    10321026                    chunks.append(line_break) 
     
    10351029                # examples): 
    10361030                # 
    1037                 #if folded and line_break == u'\n': 
     1031                #if folded and line_break == '\n': 
    10381032                #    if not breaks: 
    10391033                #        if self.peek() not in ' \t': 
    1040                 #            chunks.append(u' ') 
     1034                #            chunks.append(' ') 
    10411035                #        else: 
    10421036                #            chunks.append(line_break) 
     
    10531047 
    10541048        # We are done. 
    1055         return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1049        return ScalarToken(''.join(chunks), False, start_mark, end_mark, 
    10561050                style) 
    10571051 
     
    10611055        increment = None 
    10621056        ch = self.peek() 
    1063         if ch in u'+-': 
     1057        if ch in '+-': 
    10641058            if ch == '+': 
    10651059                chomping = True 
     
    10681062            self.forward() 
    10691063            ch = self.peek() 
    1070             if ch in u'0123456789': 
     1064            if ch in '0123456789': 
    10711065                increment = int(ch) 
    10721066                if increment == 0: 
     
    10751069                            self.get_mark()) 
    10761070                self.forward() 
    1077         elif ch in u'0123456789': 
     1071        elif ch in '0123456789': 
    10781072            increment = int(ch) 
    10791073            if increment == 0: 
     
    10831077            self.forward() 
    10841078            ch = self.peek() 
    1085             if ch in u'+-': 
     1079            if ch in '+-': 
    10861080                if ch == '+': 
    10871081                    chomping = True 
     
    10901084                self.forward() 
    10911085        ch = self.peek() 
    1092         if ch not in u'\0 \r\n\x85\u2028\u2029': 
     1086        if ch not in '\0 \r\n\x85\u2028\u2029': 
    10931087            raise ScannerError("while scanning a block scalar", start_mark, 
    10941088                    "expected chomping or indentation indicators, but found %r" 
    1095                         % ch.encode('utf-8'), self.get_mark()) 
     1089                    % ch, self.get_mark()) 
    10961090        return chomping, increment 
    10971091 
    10981092    def scan_block_scalar_ignored_line(self, start_mark): 
    10991093        # See the specification for details. 
    1100         while self.peek() == u' ': 
     1094        while self.peek() == ' ': 
    11011095            self.forward() 
    1102         if self.peek() == u'#': 
    1103             while self.peek() not in u'\0\r\n\x85\u2028\u2029': 
     1096        if self.peek() == '#': 
     1097            while self.peek() not in '\0\r\n\x85\u2028\u2029': 
    11041098                self.forward() 
    11051099        ch = self.peek() 
    1106         if ch not in u'\0\r\n\x85\u2028\u2029': 
     1100        if ch not in '\0\r\n\x85\u2028\u2029': 
    11071101            raise ScannerError("while scanning a block scalar", start_mark, 
    1108                     "expected a comment or a line break, but found %r" 
    1109                         % ch.encode('utf-8'), self.get_mark()) 
     1102                    "expected a comment or a line break, but found %r" % ch, 
     1103                    self.get_mark()) 
    11101104        self.scan_line_break() 
    11111105 
     
    11151109        max_indent = 0 
    11161110        end_mark = self.get_mark() 
    1117         while self.peek() in u' \r\n\x85\u2028\u2029': 
    1118             if self.peek() != u' ': 
     1111        while self.peek() in ' \r\n\x85\u2028\u2029': 
     1112            if self.peek() != ' ': 
    11191113                chunks.append(self.scan_line_break()) 
    11201114                end_mark = self.get_mark() 
     
    11291123        chunks = [] 
    11301124        end_mark = self.get_mark() 
    1131         while self.column < indent and self.peek() == u' ': 
     1125        while self.column < indent and self.peek() == ' ': 
    11321126            self.forward() 
    1133         while self.peek() in u'\r\n\x85\u2028\u2029': 
     1127        while self.peek() in '\r\n\x85\u2028\u2029': 
    11341128            chunks.append(self.scan_line_break()) 
    11351129            end_mark = self.get_mark() 
    1136             while self.column < indent and self.peek() == u' ': 
     1130            while self.column < indent and self.peek() == ' ': 
    11371131                self.forward() 
    11381132        return chunks, end_mark 
     
    11591153        self.forward() 
    11601154        end_mark = self.get_mark() 
    1161         return ScalarToken(u''.join(chunks), False, start_mark, end_mark, 
     1155        return ScalarToken(''.join(chunks), False, start_mark, end_mark, 
    11621156                style) 
    11631157 
    11641158    ESCAPE_REPLACEMENTS = { 
    1165         u'0':   u'\0', 
    1166         u'a':   u'\x07', 
    1167         u'b':   u'\x08', 
    1168         u't':   u'\x09', 
    1169         u'\t':  u'\x09', 
    1170         u'n':   u'\x0A', 
    1171         u'v':   u'\x0B', 
    1172         u'f':   u'\x0C', 
    1173         u'r':   u'\x0D', 
    1174         u'e':   u'\x1B', 
    1175         u' ':   u'\x20', 
    1176         u'\"':  u'\"', 
    1177         u'\\':  u'\\', 
    1178         u'N':   u'\x85', 
    1179         u'_':   u'\xA0', 
    1180         u'L':   u'\u2028', 
    1181         u'P':   u'\u2029', 
     1159        '0':    '\0', 
     1160        'a':    '\x07', 
     1161        'b':    '\x08', 
     1162        't':    '\x09', 
     1163        '\t':   '\x09', 
     1164        'n':    '\x0A', 
     1165        'v':    '\x0B', 
     1166        'f':    '\x0C', 
     1167        'r':    '\x0D', 
     1168        'e':    '\x1B', 
     1169        ' ':    '\x20', 
     1170        '\"':   '\"', 
     1171        '\\':   '\\', 
     1172        'N':    '\x85', 
     1173        '_':    '\xA0', 
     1174        'L':    '\u2028', 
     1175        'P':    '\u2029', 
    11821176    } 
    11831177 
    11841178    ESCAPE_CODES = { 
    1185         u'x':   2, 
    1186         u'u':   4, 
    1187         u'U':   8, 
     1179        'x':    2, 
     1180        'u':    4, 
     1181        'U':    8, 
    11881182    } 
    11891183 
     
    11931187        while True: 
    11941188            length = 0 
    1195             while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': 
     1189            while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029': 
    11961190                length += 1 
    11971191            if length: 
     
    11991193                self.forward(length) 
    12001194            ch = self.peek() 
    1201             if not double and ch == u'\'' and self.peek(1) == u'\'': 
    1202                 chunks.append(u'\'') 
     1195            if not double and ch == '\'' and self.peek(1) == '\'': 
     1196                chunks.append('\'') 
    12031197                self.forward(2) 
    1204             elif (double and ch == u'\'') or (not double and ch in u'\"\\'): 
     1198            elif (double and ch == '\'') or (not double and ch in '\"\\'): 
    12051199                chunks.append(ch) 
    12061200                self.forward() 
    1207             elif double and ch == u'\\': 
     1201            elif double and ch == '\\': 
    12081202                self.forward() 
    12091203                ch = self.peek() 
     
    12151209                    self.forward() 
    12161210                    for k in range(length): 
    1217                         if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1211                        if self.peek(k) not in '0123456789ABCDEFabcdef': 
    12181212                            raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    12191213                                    "expected escape sequence of %d hexdecimal numbers, but found %r" % 
    1220                                         (length, self.peek(k).encode('utf-8')), self.get_mark()) 
     1214                                        (length, self.peek(k)), self.get_mark()) 
    12211215                    code = int(self.prefix(length), 16) 
    1222                     chunks.append(unichr(code)) 
     1216                    chunks.append(chr(code)) 
    12231217                    self.forward(length) 
    1224                 elif ch in u'\r\n\x85\u2028\u2029': 
     1218                elif ch in '\r\n\x85\u2028\u2029': 
    12251219                    self.scan_line_break() 
    12261220                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) 
    12271221                else: 
    12281222                    raise ScannerError("while scanning a double-quoted scalar", start_mark, 
    1229                             "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark()) 
     1223                            "found unknown escape character %r" % ch, self.get_mark()) 
    12301224            else: 
    12311225                return chunks 
     
    12351229        chunks = [] 
    12361230        length = 0 
    1237         while self.peek(length) in u' \t': 
     1231        while self.peek(length) in ' \t': 
    12381232            length += 1 
    12391233        whitespaces = self.prefix(length) 
    12401234        self.forward(length) 
    12411235        ch = self.peek() 
    1242         if ch == u'\0': 
     1236        if ch == '\0': 
    12431237            raise ScannerError("while scanning a quoted scalar", start_mark, 
    12441238                    "found unexpected end of stream", self.get_mark()) 
    1245         elif ch in u'\r\n\x85\u2028\u2029': 
     1239        elif ch in '\r\n\x85\u2028\u2029': 
    12461240            line_break = self.scan_line_break() 
    12471241            breaks = self.scan_flow_scalar_breaks(double, start_mark) 
    1248             if line_break != u'\n': 
     1242            if line_break != '\n': 
    12491243                chunks.append(line_break) 
    12501244            elif not breaks: 
    1251                 chunks.append(u' ') 
     1245                chunks.append(' ') 
    12521246            chunks.extend(breaks) 
    12531247        else: 
     
    12621256            # separators. 
    12631257            prefix = self.prefix(3) 
    1264             if (prefix == u'---' or prefix == u'...')   \ 
    1265                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1258            if (prefix == '---' or prefix == '...')   \ 
     1259                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    12661260                raise ScannerError("while scanning a quoted scalar", start_mark, 
    12671261                        "found unexpected document separator", self.get_mark()) 
    1268             while self.peek() in u' \t': 
     1262            while self.peek() in ' \t': 
    12691263                self.forward() 
    1270             if self.peek() in u'\r\n\x85\u2028\u2029': 
     1264            if self.peek() in '\r\n\x85\u2028\u2029': 
    12711265                chunks.append(self.scan_line_break()) 
    12721266            else: 
     
    12901284        while True: 
    12911285            length = 0 
    1292             if self.peek() == u'#': 
     1286            if self.peek() == '#': 
    12931287                break 
    12941288            while True: 
    12951289                ch = self.peek(length) 
    1296                 if ch in u'\0 \t\r\n\x85\u2028\u2029'   \ 
    1297                         or (not self.flow_level and ch == u':' and 
    1298                                 self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ 
    1299                         or (self.flow_level and ch in u',:?[]{}'): 
     1290                if ch in '\0 \t\r\n\x85\u2028\u2029'    \ 
     1291                        or (not self.flow_level and ch == ':' and 
     1292                                self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029') \ 
     1293                        or (self.flow_level and ch in ',:?[]{}'): 
    13001294                    break 
    13011295                length += 1 
    13021296            # It's not clear what we should do with ':' in the flow context. 
    1303             if (self.flow_level and ch == u':' 
    1304                     and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): 
     1297            if (self.flow_level and ch == ':' 
     1298                    and self.peek(length+1) not in '\0 \t\r\n\x85\u2028\u2029,[]{}'): 
    13051299                self.forward(length) 
    13061300                raise ScannerError("while scanning a plain scalar", start_mark, 
     
    13151309            end_mark = self.get_mark() 
    13161310            spaces = self.scan_plain_spaces(indent, start_mark) 
    1317             if not spaces or self.peek() == u'#' \ 
     1311            if not spaces or self.peek() == '#' \ 
    13181312                    or (not self.flow_level and self.column < indent): 
    13191313                break 
    1320         return ScalarToken(u''.join(chunks), True, start_mark, end_mark) 
     1314        return ScalarToken(''.join(chunks), True, start_mark, end_mark) 
    13211315 
    13221316    def scan_plain_spaces(self, indent, start_mark): 
     
    13261320        chunks = [] 
    13271321        length = 0 
    1328         while self.peek(length) in u' ': 
     1322        while self.peek(length) in ' ': 
    13291323            length += 1 
    13301324        whitespaces = self.prefix(length) 
    13311325        self.forward(length) 
    13321326        ch = self.peek() 
    1333         if ch in u'\r\n\x85\u2028\u2029': 
     1327        if ch in '\r\n\x85\u2028\u2029': 
    13341328            line_break = self.scan_line_break() 
    13351329            self.allow_simple_key = True 
    13361330            prefix = self.prefix(3) 
    1337             if (prefix == u'---' or prefix == u'...')   \ 
    1338                     and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1331            if (prefix == '---' or prefix == '...')   \ 
     1332                    and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    13391333                return 
    13401334            breaks = [] 
    1341             while self.peek() in u' \r\n\x85\u2028\u2029': 
     1335            while self.peek() in ' \r\n\x85\u2028\u2029': 
    13421336                if self.peek() == ' ': 
    13431337                    self.forward() 
     
    13451339                    breaks.append(self.scan_line_break()) 
    13461340                    prefix = self.prefix(3) 
    1347                     if (prefix == u'---' or prefix == u'...')   \ 
    1348                             and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': 
     1341                    if (prefix == '---' or prefix == '...')   \ 
     1342                            and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': 
    13491343                        return 
    1350             if line_break != u'\n': 
     1344            if line_break != '\n': 
    13511345                chunks.append(line_break) 
    13521346            elif not breaks: 
    1353                 chunks.append(u' ') 
     1347                chunks.append(' ') 
    13541348            chunks.extend(breaks) 
    13551349        elif whitespaces: 
     
    13621356        # tag handles. I have allowed it anyway. 
    13631357        ch = self.peek() 
    1364         if ch != u'!': 
     1358        if ch != '!': 
    13651359            raise ScannerError("while scanning a %s" % name, start_mark, 
    1366                     "expected '!', but found %r" % ch.encode('utf-8'), 
    1367                     self.get_mark()) 
     1360                    "expected '!', but found %r" % ch, self.get_mark()) 
    13681361        length = 1 
    13691362        ch = self.peek(length) 
    1370         if ch != u' ': 
    1371             while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    1372                     or ch in u'-_': 
     1363        if ch != ' ': 
     1364            while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     1365                    or ch in '-_': 
    13731366                length += 1 
    13741367                ch = self.peek(length) 
    1375             if ch != u'!': 
     1368            if ch != '!': 
    13761369                self.forward(length) 
    13771370                raise ScannerError("while scanning a %s" % name, start_mark, 
    1378                         "expected '!', but found %r" % ch.encode('utf-8'), 
    1379                         self.get_mark()) 
     1371                        "expected '!', but found %r" % ch, self.get_mark()) 
    13801372            length += 1 
    13811373        value = self.prefix(length) 
     
    13891381        length = 0 
    13901382        ch = self.peek(length) 
    1391         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \ 
    1392                 or ch in u'-;/?:@&=+$,_.!~*\'()[]%': 
    1393             if ch == u'%': 
     1383        while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z'  \ 
     1384                or ch in '-;/?:@&=+$,_.!~*\'()[]%': 
     1385            if ch == '%': 
    13941386                chunks.append(self.prefix(length)) 
    13951387                self.forward(length) 
     
    14051397        if not chunks: 
    14061398            raise ScannerError("while parsing a %s" % name, start_mark, 
    1407                     "expected URI, but found %r" % ch.encode('utf-8'), 
    1408                     self.get_mark()) 
    1409         return u''.join(chunks) 
     1399                    "expected URI, but found %r" % ch, self.get_mark()) 
     1400        return ''.join(chunks) 
    14101401 
    14111402    def scan_uri_escapes(self, name, start_mark): 
    14121403        # See the specification for details. 
    1413         bytes = [] 
     1404        codes = [] 
    14141405        mark = self.get_mark() 
    1415         while self.peek() == u'%': 
     1406        while self.peek() == '%': 
    14161407            self.forward() 
    14171408            for k in range(2): 
    1418                 if self.peek(k) not in u'0123456789ABCDEFabcdef': 
     1409                if self.peek(k) not in '0123456789ABCDEFabcdef': 
    14191410                    raise ScannerError("while scanning a %s" % name, start_mark, 
    1420                             "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))) 
     1411                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" 
     1412                            % self.peek(k), self.get_mark()) 
     1413            codes.append(int(self.prefix(2), 16)) 
    14231414            self.forward(2) 
    14241415        try: 
    1425             value = unicode(''.join(bytes), 'utf-8') 
    1426         except UnicodeDecodeError, exc: 
     1416            value = bytes(codes).decode('utf-8') 
     1417        except UnicodeDecodeError as exc: 
    14271418            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) 
    14281419        return value 
     
    14381429        #   default     :   '' 
    14391430        ch = self.peek() 
    1440         if ch in u'\r\n\x85': 
    1441             if self.prefix(2) == u'\r\n': 
     1431        if ch in '\r\n\x85': 
     1432            if self.prefix(2) == '\r\n': 
    14421433                self.forward(2) 
    14431434            else: 
    14441435                self.forward() 
    1445             return u'\n' 
    1446         elif ch in u'\u2028\u2029': 
     1436            return '\n' 
     1437        elif ch in '\u2028\u2029': 
    14471438            self.forward() 
    14481439            return ch 
    1449         return u'' 
     1440        return '' 
    14501441 
    14511442#try: 
Note: See TracChangeset for help on using the changeset viewer.