Changeset 136 for pyyaml/trunk/lib/yaml/scanner.py

Timestamp:

04/15/06 19:54:52 (6 years ago)

Author:

xi

Message:

Major refactoring.

Files:

• pyyaml/trunk/lib/yaml/scanner.py (modified) (63 diffs)

pyyaml/trunk/lib/yaml/scanner.py

@@ -46 +46 @@
 class Scanner:
 
-
-    def __init__(self, reader):
+    def __init__(self):
         """Initialize the scanner."""
-        # The input stream. The Reader class do the dirty work of checking for
-        # BOM and converting the input data to Unicode. It also adds NUL to
-        # the end.
+        # It is assumed that Scanner and Reader will have a common descendant.
+        # Reader do the dirty work of checking for BOM and converting the
+        # input data to Unicode. It also adds NUL to the end.
         #
         # Reader supports the following methods
-        #   self.reader.peek(i=0)       # peek the next i-th character
-        #   self.reader.prefix(l=1)     # peek the next l characters
-        #   self.reader.forward(l=1)    # read the next l characters
-                                        # and move the pointer
-        self.reader = reader
+        #   self.peek(i=0)       # peek the next i-th character
+        #   self.prefix(l=1)     # peek the next l characters
+        #   self.forward(l=1)    # read the next l characters and move the pointer.
 
         # Had we reached the end of the stream?
@@ -114 +111 @@
     # Public methods.
 
-    def check(self, *choices):
+    def check_token(self, *choices):
         # Check if the next token is one of the given types.
         while self.need_more_tokens():
             self.fetch_more_tokens()
         if self.tokens:
+            if not choices:
+                return True
             for choice in choices:
                 if isinstance(self.tokens[0], choice):
@@ -124 +123 @@
         return False
 
-    def peek(self):
+    def peek_token(self):
         # Return the next token, but do not delete if from the queue.
         while self.need_more_tokens():
@@ -131 +130 @@
             return self.tokens[0]
 
-    def get(self):
+    def get_token(self):
         # Return the next token.
         while self.need_more_tokens():
@@ -172 +171 @@
         # Compare the current indentation and column. It may add some tokens
         # and decrease the current indentation level.
-        self.unwind_indent(self.reader.column)
+        self.unwind_indent(self.column)
 
         # Peek the next character.
-        ch = self.reader.peek()
+        ch = self.peek()
 
         # Is it the end of stream?
@@ -266 +265 @@
         raise ScannerError("while scanning for the next token", None,
                 "found character %r that cannot start any token"
-                % ch.encode('utf-8'), self.reader.get_mark())
+                % ch.encode('utf-8'), self.get_mark())
 
     # Simple keys treatment.
@@ -294 +293 @@
         for level in self.possible_simple_keys.keys():
             key = self.possible_simple_keys[level]
-            if key.line != self.reader.line  \
-                    or self.reader.index-key.index > 1024:
+            if key.line != self.line  \
+                    or self.index-key.index > 1024:
                 if key.required:
                     raise ScannerError("while scanning a simple key", key.mark,
-                            "could not found expected ':'", self.reader.get_mark())
+                            "could not found expected ':'", self.get_mark())
                 del self.possible_simple_keys[level]
 
@@ -307 +306 @@
 
         # Check if a simple key is required at the current position.
-        required = not self.flow_level and self.indent == self.reader.column
+        required = not self.flow_level and self.indent == self.column
 
         # A simple key is required only if it is the first token in the current
@@ -318 +317 @@
             self.remove_possible_simple_key()
             token_number = self.tokens_taken+len(self.tokens)
-            index = self.reader.index
-            line = self.reader.line
-            column = self.reader.column
-            mark = self.reader.get_mark()
             key = SimpleKey(token_number, required,
-                    index, line, column, mark)
+                    self.index, self.line, self.column, self.get_mark())
             self.possible_simple_keys[self.flow_level] = key
 
@@ -335 +330 @@
             #if key.required:
             #    raise ScannerError("while scanning a simple key", key.mark,
-            #            "could not found expected ':'", self.reader.get_mark())
+            #            "could not found expected ':'", self.get_mark())
 
     # Indentation functions.
@@ -350 +345 @@
         #    raise ScannerError(None, None,
         #            "invalid intendation or unclosed '[' or '{'",
-        #            self.reader.get_mark())
+        #            self.get_mark())
 
         # In the flow context, indentation is ignored. We make the scanner less
@@ -359 +354 @@
         # In block context, we may need to issue the BLOCK-END tokens.
         while self.indent > column:
-            mark = self.reader.get_mark()
+            mark = self.get_mark()
             self.indent = self.indents.pop()
             self.tokens.append(BlockEndToken(mark, mark))
@@ -378 +373 @@
 
         # Read the token.
-        mark = self.reader.get_mark()
+        mark = self.get_mark()
         
         # Add STREAM-START.
         self.tokens.append(StreamStartToken(mark, mark,
-            encoding=self.reader.encoding))
+            encoding=self.encoding))
         
 
@@ -395 +390 @@
 
         # Read the token.
-        mark = self.reader.get_mark()
+        mark = self.get_mark()
         
         # Add STREAM-END.
         self.tokens.append(StreamEndToken(mark, mark))
 
-        # The reader is ended.
+        # The steam is finished.
         self.done = True
 
@@ -432 +427 @@
 
         # Add DOCUMENT-START or DOCUMENT-END.
-        start_mark = self.reader.get_mark()
-        self.reader.forward(3)
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward(3)
+        end_mark = self.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
@@ -455 +450 @@
 
         # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
@@ -478 +473 @@
 
         # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
@@ -492 +487 @@
 
         # Add FLOW-ENTRY.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(FlowEntryToken(start_mark, end_mark))
 
@@ -506 +501 @@
                 raise ScannerError(None, None,
                         "sequence entries are not allowed here",
-                        self.reader.get_mark())
+                        self.get_mark())
 
             # We may need to add BLOCK-SEQUENCE-START.
-            if self.add_indent(self.reader.column):
-                mark = self.reader.get_mark()
+            if self.add_indent(self.column):
+                mark = self.get_mark()
                 self.tokens.append(BlockSequenceStartToken(mark, mark))
 
@@ -525 +520 @@
 
         # Add BLOCK-ENTRY.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(BlockEntryToken(start_mark, end_mark))
 
@@ -539 +534 @@
                 raise ScannerError(None, None,
                         "mapping keys are not allowed here",
-                        self.reader.get_mark())
+                        self.get_mark())
 
             # We may need to add BLOCK-MAPPING-START.
-            if self.add_indent(self.reader.column):
-                mark = self.reader.get_mark()
+            if self.add_indent(self.column):
+                mark = self.get_mark()
                 self.tokens.append(BlockMappingStartToken(mark, mark))
 
@@ -553 +548 @@
 
         # Add KEY.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(KeyToken(start_mark, end_mark))
 
@@ -592 +587 @@
                     raise ScannerError(None, None,
                             "mapping values are not allowed here",
-                            self.reader.get_mark())
+                            self.get_mark())
 
             # Simple keys are allowed after ':' in the block context.
@@ -601 +596 @@
 
         # Add VALUE.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         self.tokens.append(ValueToken(start_mark, end_mark))
 
@@ -692 +687 @@
         # DIRECTIVE:        ^ '%' ...
         # The '%' indicator is already checked.
-        if self.reader.column == 0:
+        if self.column == 0:
             return True
 
@@ -698 +693 @@
 
         # DOCUMENT-START:   ^ '---' (' '|'\n')
-        if self.reader.column == 0:
-            if self.reader.prefix(3) == u'---'  \
-                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+        if self.column == 0:
+            if self.prefix(3) == u'---'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                 return True
 
@@ -706 +701 @@
 
         # DOCUMENT-END:     ^ '...' (' '|'\n')
-        if self.reader.column == 0:
-            prefix = self.reader.peek(4)
-            if self.reader.prefix(3) == u'...'  \
-                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+        if self.column == 0:
+            prefix = self.peek(4)
+            if self.prefix(3) == u'...'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                 return True
 
@@ -715 +710 @@
 
         # BLOCK-ENTRY:      '-' (' '|'\n')
-        return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+        return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_key(self):
@@ -725 +720 @@
         # KEY(block context):   '?' (' '|'\n')
         else:
-            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_value(self):
@@ -735 +730 @@
         # VALUE(block context): ':' (' '|'\n')
         else:
-            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_plain(self):
@@ -751 +746 @@
         # '-' character) because we want the flow context to be space
         # independent.
-        ch = self.reader.peek()
+        ch = self.peek()
         return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
-                or (self.reader.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029'
+                or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029'
                         and (ch == u'-' or (not self.flow_level and ch in u'?:')))
 
@@ -778 +773 @@
         # Scanners for block, flow, and plain scalars need to be modified.
 
-        if self.reader.index == 0 and self.reader.peek() == u'\uFEFF':
-            self.reader.forward()
+        if self.index == 0 and self.peek() == u'\uFEFF':
+            self.forward()
         found = False
         while not found:
-            while self.reader.peek() == u' ':
-                self.reader.forward()
-            if self.reader.peek() == u'#':
-                while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029':
-                    self.reader.forward()
+            while self.peek() == u' ':
+                self.forward()
+            if self.peek() == u'#':
+                while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                    self.forward()
             if self.scan_line_break():
                 if not self.flow_level:
@@ -795 +790 @@
     def scan_directive(self):
         # See the specification for details.
-        start_mark = self.reader.get_mark()
-        self.reader.forward()
+        start_mark = self.get_mark()
+        self.forward()
         name = self.scan_directive_name(start_mark)
         value = None
         if name == u'YAML':
             value = self.scan_yaml_directive_value(start_mark)
-            end_mark = self.reader.get_mark()
+            end_mark = self.get_mark()
         elif name == u'TAG':
             value = self.scan_tag_directive_value(start_mark)
-            end_mark = self.reader.get_mark()
+            end_mark = self.get_mark()
         else:
-            end_mark = self.reader.get_mark()
-            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029':
-                self.reader.forward()
+            end_mark = self.get_mark()
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
         self.scan_directive_ignored_line(start_mark)
         return DirectiveToken(name, value, start_mark, end_mark)
@@ -815 +810 @@
         # See the specification for details.
         length = 0
-        ch = self.reader.peek(length)
+        ch = self.peek(length)
         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \
                 or ch in u'-_':
             length += 1
-            ch = self.reader.peek(length)
+            ch = self.peek(length)
         if not length:
             raise ScannerError("while scanning a directive", start_mark,
                     "expected alphabetic or numeric character, but found %r"
-                    % ch.encode('utf-8'), self.reader.get_mark())
-        value = self.reader.prefix(length)
-        self.reader.forward(length)
-        ch = self.reader.peek()
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
         if ch not in u'\0 \r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected alphabetic or numeric character, but found %r"
-                    % ch.encode('utf-8'), self.reader.get_mark())
+                    % ch.encode('utf-8'), self.get_mark())
         return value
 
     def scan_yaml_directive_value(self, start_mark):
         # See the specification for details.
-        while self.reader.peek() == u' ':
-            self.reader.forward()
+        while self.peek() == u' ':
+            self.forward()
         major = self.scan_yaml_directive_number(start_mark)
-        if self.reader.peek() != '.':
+        if self.peek() != '.':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected a digit or '.', but found %r"
-                    % self.reader.peek().encode('utf-8'),
-                    self.reader.get_mark())
-        self.reader.forward()
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
+        self.forward()
         minor = self.scan_yaml_directive_number(start_mark)
-        if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029':
+        if self.peek() not in u'\0 \r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected a digit or ' ', but found %r"
-                    % self.reader.peek().encode('utf-8'),
-                    self.reader.get_mark())
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
         return (major, minor)
 
     def scan_yaml_directive_number(self, start_mark):
         # See the specification for details.
-        ch = self.reader.peek()
+        ch = self.peek()
         if not (u'0' <= ch <= '9'):
             raise ScannerError("while scanning a directive", start_mark,
                     "expected a digit, but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         length = 0
-        while u'0' <= self.reader.peek(length) <= u'9':
+        while u'0' <= self.peek(length) <= u'9':
             length += 1
-        value = int(self.reader.prefix(length))
-        self.reader.forward(length)
+        value = int(self.prefix(length))
+        self.forward(length)
         return value
 
     def scan_tag_directive_value(self, start_mark):
         # See the specification for details.
-        while self.reader.peek() == u' ':
-            self.reader.forward()
+        while self.peek() == u' ':
+            self.forward()
         handle = self.scan_tag_directive_handle(start_mark)
-        while self.reader.peek() == u' ':
-            self.reader.forward()
+        while self.peek() == u' ':
+            self.forward()
         prefix = self.scan_tag_directive_prefix(start_mark)
         return (handle, prefix)
@@ -879 +874 @@
         # See the specification for details.
         value = self.scan_tag_handle('directive', start_mark)
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch != u' ':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected ' ', but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         return value
 
@@ -889 +884 @@
         # See the specification for details.
         value = self.scan_tag_uri('directive', start_mark)
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch not in u'\0 \r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected ' ', but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         return value
 
     def scan_directive_ignored_line(self, start_mark):
         # See the specification for details.
-        while self.reader.peek() == u' ':
-            self.reader.forward()
-        if self.reader.peek() == u'#':
-            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029':
-                self.reader.forward()
-        ch = self.reader.peek()
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
         if ch not in u'\0\r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected a comment or a line break, but found %r"
-                        % ch.encode('utf-8'), self.reader.get_mark())
+                        % ch.encode('utf-8'), self.get_mark())
         self.scan_line_break()
 
@@ -919 +914 @@
         #   [ *alias , "value" ]
         # Therefore we restrict aliases to numbers and ASCII letters.
-        start_mark = self.reader.get_mark()
-        indicator = self.reader.peek()
+        start_mark = self.get_mark()
+        indicator = self.peek()
         if indicator == '*':
             name = 'alias'
         else:
             name = 'anchor'
-        self.reader.forward()
+        self.forward()
         length = 0
-        ch = self.reader.peek(length)
+        ch = self.peek(length)
         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \
                 or ch in u'-_':
             length += 1
-            ch = self.reader.peek(length)
+            ch = self.peek(length)
         if not length:
             raise ScannerError("while scanning an %s" % name, start_mark,
                     "expected alphabetic or numeric character, but found %r"
-                    % ch.encode('utf-8'), self.reader.get_mark())
-        value = self.reader.prefix(length)
-        self.reader.forward(length)
-        ch = self.reader.peek()
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
         if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
             raise ScannerError("while scanning an %s" % name, start_mark,
                     "expected alphabetic or numeric character, but found %r"
-                    % ch.encode('utf-8'), self.reader.get_mark())
-        end_mark = self.reader.get_mark()
+                    % ch.encode('utf-8'), self.get_mark())
+        end_mark = self.get_mark()
         return TokenClass(value, start_mark, end_mark)
 
     def scan_tag(self):
         # See the specification for details.
-        start_mark = self.reader.get_mark()
-        ch = self.reader.peek(1)
+        start_mark = self.get_mark()
+        ch = self.peek(1)
         if ch == u'<':
             handle = None
-            self.reader.forward(2)
+            self.forward(2)
             suffix = self.scan_tag_uri('tag', start_mark)
-            if self.reader.peek() != u'>':
+            if self.peek() != u'>':
                 raise ScannerError("while parsing a tag", start_mark,
-                        "expected '>', but found %r" % self.reader.peek().encode('utf-8'),
-                        self.reader.get_mark())
-            self.reader.forward()
+                        "expected '>', but found %r" % self.peek().encode('utf-8'),
+                        self.get_mark())
+            self.forward()
         elif ch in u'\0 \t\r\n\x85\u2028\u2029':
             handle = None
             suffix = u'!'
-            self.reader.forward()
+            self.forward()
         else:
             length = 1
@@ -971 +966 @@
                     break
                 length += 1
-                ch = self.reader.peek(length)
+                ch = self.peek(length)
             handle = u'!'
             if use_handle:
@@ -977 +972 @@
             else:
                 handle = u'!'
-                self.reader.forward()
+                self.forward()
             suffix = self.scan_tag_uri('tag', start_mark)
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch not in u'\0 \r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a tag", start_mark,
                     "expected ' ', but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         value = (handle, suffix)
-        end_mark = self.reader.get_mark()
+        end_mark = self.get_mark()
         return TagToken(value, start_mark, end_mark)
 
@@ -997 +992 @@
 
         chunks = []
-        start_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
 
         # Scan the header.
-        self.reader.forward()
+        self.forward()
         chomping, increment = self.scan_block_scalar_indicators(start_mark)
         self.scan_block_scalar_ignored_line(start_mark)
@@ -1017 +1012 @@
 
         # Scan the inner part of the block scalar.
-        while self.reader.column == indent and self.reader.peek() != u'\0':
+        while self.column == indent and self.peek() != u'\0':
             chunks.extend(breaks)
-            leading_non_space = self.reader.peek() not in u' \t'
+            leading_non_space = self.peek() not in u' \t'
             length = 0
-            while self.reader.peek(length) not in u'\0\r\n\x85\u2028\u2029':
+            while self.peek(length) not in u'\0\r\n\x85\u2028\u2029':
                 length += 1
-            chunks.append(self.reader.prefix(length))
-            self.reader.forward(length)
+            chunks.append(self.prefix(length))
+            self.forward(length)
             line_break = self.scan_line_break()
             breaks, end_mark = self.scan_block_scalar_breaks(indent)
-            if self.reader.column == indent and self.reader.peek() != u'\0':
+            if self.column == indent and self.peek() != u'\0':
 
                 # Unfortunately, folding rules are ambiguous.
@@ -1034 +1029 @@
                 
                 if folded and line_break == u'\n'   \
-                        and leading_non_space and self.reader.peek() not in u' \t':
+                        and leading_non_space and self.peek() not in u' \t':
                     if not breaks:
                         chunks.append(u' ')
@@ -1045 +1040 @@
                 #if folded and line_break == u'\n':
                 #    if not breaks:
-                #        if self.reader.peek() not in ' \t':
+                #        if self.peek() not in ' \t':
                 #            chunks.append(u' ')
                 #        else:
@@ -1068 +1063 @@
         chomping = None
         increment = None
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch in u'+-':
             if ch == '+':
@@ -1074 +1069 @@
             else:
                 chomping = False
-            self.reader.forward()
-            ch = self.reader.peek()
+            self.forward()
+            ch = self.peek()
             if ch in u'0123456789':
                 increment = int(ch)
@@ -1081 +1076 @@
                     raise ScannerError("while scanning a block scalar", start_mark,
                             "expected indentation indicator in the range 1-9, but found 0",
-                            self.reader.get_mark())
-                self.reader.forward()
+                            self.get_mark())
+                self.forward()
         elif ch in u'0123456789':
             increment = int(ch)
@@ -1088 +1083 @@
                 raise ScannerError("while scanning a block scalar", start_mark,
                         "expected indentation indicator in the range 1-9, but found 0",
-                        self.reader.get_mark())
-            self.reader.forward()
-            ch = self.reader.peek()
+                        self.get_mark())
+            self.forward()
+            ch = self.peek()
             if ch in u'+-':
                 if ch == '+':
@@ -1096 +1091 @@
                 else:
                     chomping = False
-                self.reader.forward()
-        ch = self.reader.peek()
+                self.forward()
+        ch = self.peek()
         if ch not in u'\0 \r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a block scalar", start_mark,
                     "expected chomping or indentation indicators, but found %r"
-                        % ch.encode('utf-8'), self.reader.get_mark())
+                        % ch.encode('utf-8'), self.get_mark())
         return chomping, increment
 
     def scan_block_scalar_ignored_line(self, start_mark):
         # See the specification for details.
-        while self.reader.peek() == u' ':
-            self.reader.forward()
-        if self.reader.peek() == u'#':
-            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029':
-                self.reader.forward()
-        ch = self.reader.peek()
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
         if ch not in u'\0\r\n\x85\u2028\u2029':
             raise ScannerError("while scanning a block scalar", start_mark,
                     "expected a comment or a line break, but found %r"
-                        % ch.encode('utf-8'), self.reader.get_mark())
+                        % ch.encode('utf-8'), self.get_mark())
         self.scan_line_break()
 
@@ -1122 +1117 @@
         chunks = []
         max_indent = 0
-        end_mark = self.reader.get_mark()
-        while self.reader.peek() in u' \r\n\x85\u2028\u2029':
-            if self.reader.peek() != u' ':
+        end_mark = self.get_mark()
+        while self.peek() in u' \r\n\x85\u2028\u2029':
+            if self.peek() != u' ':
                 chunks.append(self.scan_line_break())
-                end_mark = self.reader.get_mark()
+                end_mark = self.get_mark()
             else:
-                self.reader.forward()
-                if self.reader.column > max_indent:
-                    max_indent = self.reader.column
+                self.forward()
+                if self.column > max_indent:
+                    max_indent = self.column
         return chunks, max_indent, end_mark
 
@@ -1136 +1131 @@
         # See the specification for details.
         chunks = []
-        end_mark = self.reader.get_mark()
-        while self.reader.column < indent and self.reader.peek() == u' ':
-            self.reader.forward()
-        while self.reader.peek() in u'\r\n\x85\u2028\u2029':
+        end_mark = self.get_mark()
+        while self.column < indent and self.peek() == u' ':
+            self.forward()
+        while self.peek() in u'\r\n\x85\u2028\u2029':
             chunks.append(self.scan_line_break())
-            end_mark = self.reader.get_mark()
-            while self.reader.column < indent and self.reader.peek() == u' ':
-                self.reader.forward()
+            end_mark = self.get_mark()
+            while self.column < indent and self.peek() == u' ':
+                self.forward()
         return chunks, end_mark
 
@@ -1158 +1153 @@
             double = False
         chunks = []
-        start_mark = self.reader.get_mark()
-        quote = self.reader.peek()
-        self.reader.forward()
+        start_mark = self.get_mark()
+        quote = self.peek()
+        self.forward()
         chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
-        while self.reader.peek() != quote:
+        while self.peek() != quote:
             chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
             chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
-        self.reader.forward()
-        end_mark = self.reader.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
         return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
                 style)
@@ -1201 +1196 @@
         while True:
             length = 0
-            while self.reader.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
+            while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
                 length += 1
             if length:
-                chunks.append(self.reader.prefix(length))
-                self.reader.forward(length)
-            ch = self.reader.peek()
-            if not double and ch == u'\'' and self.reader.peek(1) == u'\'':
+                chunks.append(self.prefix(length))
+                self.forward(length)
+            ch = self.peek()
+            if not double and ch == u'\'' and self.peek(1) == u'\'':
                 chunks.append(u'\'')
-                self.reader.forward(2)
+                self.forward(2)
             elif (double and ch == u'\'') or (not double and ch in u'\"\\'):
                 chunks.append(ch)
-                self.reader.forward()
+                self.forward()
             elif double and ch == u'\\':
-                self.reader.forward()
-                ch = self.reader.peek()
+                self.forward()
+                ch = self.peek()
                 if ch in self.ESCAPE_REPLACEMENTS:
                     chunks.append(self.ESCAPE_REPLACEMENTS[ch])
-                    self.reader.forward()
+                    self.forward()
                 elif ch in self.ESCAPE_CODES:
                     length = self.ESCAPE_CODES[ch]
-                    self.reader.forward()
+                    self.forward()
                     for k in range(length):
-                        if self.reader.peek(k) not in u'0123456789ABCDEFabcdef':
+                        if self.peek(k) not in u'0123456789ABCDEFabcdef':
                             raise ScannerError("while scanning a double-quoted scalar", start_mark,
                                     "expected escape sequence of %d hexdecimal numbers, but found %r" %
-                                        (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark())
-                    code = int(self.reader.prefix(length), 16)
+                                        (length, self.peek(k).encode('utf-8')), self.get_mark())
+                    code = int(self.prefix(length), 16)
                     chunks.append(unichr(code))
-                    self.reader.forward(length)
+                    self.forward(length)
                 elif ch in u'\r\n\x85\u2028\u2029':
                     self.scan_line_break()
@@ -1235 +1230 @@
                 else:
                     raise ScannerError("while scanning a double-quoted scalar", start_mark,
-                            "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark())
+                            "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark())
             else:
                 return chunks
@@ -1243 +1238 @@
         chunks = []
         length = 0
-        while self.reader.peek(length) in u' \t':
+        while self.peek(length) in u' \t':
             length += 1
-        whitespaces = self.reader.prefix(length)
-        self.reader.forward(length)
-        ch = self.reader.peek()
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
         if ch == u'\0':
             raise ScannerError("while scanning a quoted scalar", start_mark,
-                    "found unexpected end of stream", self.reader.get_mark())
+                    "found unexpected end of stream", self.get_mark())
         elif ch in u'\r\n\x85\u2028\u2029':
             line_break = self.scan_line_break()
@@ -1269 +1264 @@
             # Instead of checking indentation, we check for document
             # separators.
-            prefix = self.reader.prefix(3)
+            prefix = self.prefix(3)
             if (prefix == u'---' or prefix == u'...')   \
-                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                 raise ScannerError("while scanning a quoted scalar", start_mark,
-                        "found unexpected document separator", self.reader.get_mark())
-            while self.reader.peek() in u' \t':
-                self.reader.forward()
-            if self.reader.peek() in u'\r\n\x85\u2028\u2029':
+                        "found unexpected document separator", self.get_mark())
+            while self.peek() in u' \t':
+                self.forward()
+            if self.peek() in u'\r\n\x85\u2028\u2029':
                 chunks.append(self.scan_line_break())
             else:
@@ -1288 +1283 @@
         # Indentation rules are loosed for the flow context.
         chunks = []
-        start_mark = self.reader.get_mark()
+        start_mark = self.get_mark()
         end_mark = start_mark
         indent = self.indent+1
@@ -1298 +1293 @@
         while True:
             length = 0
-            if self.reader.peek() == u'#':
+            if self.peek() == u'#':
                 break
             while True:
-                ch = self.reader.peek(length)
+                ch = self.peek(length)
                 if ch in u'\0 \t\r\n\x85\u2028\u2029'   \
                         or (not self.flow_level and ch == u':' and
-                                self.reader.peek(length+1) in u'\0 \t\r\n\x28\u2028\u2029') \
+                                self.peek(length+1) in u'\0 \t\r\n\x28\u2028\u2029') \
                         or (self.flow_level and ch in u',:?[]{}'):
                     break
@@ -1312 +1307 @@
             self.allow_simple_key = False
             chunks.extend(spaces)
-            chunks.append(self.reader.prefix(length))
-            self.reader.forward(length)
-            end_mark = self.reader.get_mark()
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            end_mark = self.get_mark()
             spaces = self.scan_plain_spaces(indent, start_mark)
-            if not spaces or self.reader.peek() == u'#' \
-                    or (not self.flow_level and self.reader.column < indent):
+            if not spaces or self.peek() == u'#' \
+                    or (not self.flow_level and self.column < indent):
                 break
         return ScalarToken(u''.join(chunks), True, start_mark, end_mark)
@@ -1327 +1322 @@
         chunks = []
         length = 0
-        while self.reader.peek(length) in u' ':
+        while self.peek(length) in u' ':
             length += 1
-        whitespaces = self.reader.prefix(length)
-        self.reader.forward(length)
-        ch = self.reader.peek()
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
         if ch in u'\r\n\x85\u2028\u2029':
             line_break = self.scan_line_break()
             self.allow_simple_key = True
-            prefix = self.reader.prefix(3)
+            prefix = self.prefix(3)
             if (prefix == u'---' or prefix == u'...')   \
-                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                 return
             breaks = []
-            while self.reader.peek() in u' \r\n\x85\u2028\u2029':
-                if self.reader.peek() == ' ':
-                    self.reader.forward()
+            while self.peek() in u' \r\n\x85\u2028\u2029':
+                if self.peek() == ' ':
+                    self.forward()
                 else:
                     breaks.append(self.scan_line_break())
-                    prefix = self.reader.prefix(3)
+                    prefix = self.prefix(3)
                     if (prefix == u'---' or prefix == u'...')   \
-                            and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                            and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                         return
             if line_break != u'\n':
@@ -1362 +1357 @@
         # For some strange reasons, the specification does not allow '_' in
         # tag handles. I have allowed it anyway.
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch != u'!':
             raise ScannerError("while scanning a %s" % name, start_mark,
                     "expected '!', but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         length = 1
-        ch = self.reader.peek(length)
+        ch = self.peek(length)
         if ch != u' ':
             while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \
                     or ch in u'-_':
                 length += 1
-                ch = self.reader.peek(length)
+                ch = self.peek(length)
             if ch != u'!':
-                self.reader.forward(length)
+                self.forward(length)
                 raise ScannerError("while scanning a %s" % name, start_mark,
                         "expected '!', but found %r" % ch.encode('utf-8'),
-                        self.reader.get_mark())
+                        self.get_mark())
             length += 1
-        value = self.reader.prefix(length)
-        self.reader.forward(length)
+        value = self.prefix(length)
+        self.forward(length)
         return value
 
@@ -1389 +1384 @@
         chunks = []
         length = 0
-        ch = self.reader.peek(length)
+        ch = self.peek(length)
         while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z'  \
                 or ch in u'-;/?:@&=+$,_.!~*\'()[]%':
             if ch == u'%':
-                chunks.append(self.reader.prefix(length))
-                self.reader.forward(length)
+                chunks.append(self.prefix(length))
+                self.forward(length)
                 length = 0
                 chunks.append(self.scan_uri_escapes(name, start_mark))
             else:
                 length += 1
-            ch = self.reader.peek(length)
+            ch = self.peek(length)
         if length:
-            chunks.append(self.reader.prefix(length))
-            self.reader.forward(length)
+            chunks.append(self.prefix(length))
+            self.forward(length)
             length = 0
         if not chunks:
             raise ScannerError("while parsing a %s" % name, start_mark,
                     "expected URI, but found %r" % ch.encode('utf-8'),
-                    self.reader.get_mark())
+                    self.get_mark())
         return u''.join(chunks)
 
@@ -1413 +1408 @@
         # See the specification for details.
         bytes = []
-        mark = self.reader.get_mark()
-        while self.reader.peek() == u'%':
-            self.reader.forward()
+        mark = self.get_mark()
+        while self.peek() == u'%':
+            self.forward()
             for k in range(2):
-                if self.reader.peek(k) not in u'0123456789ABCDEFabcdef':
+                if self.peek(k) not in u'0123456789ABCDEFabcdef':
                     raise ScannerError("while scanning a %s" % name, start_mark,
                             "expected URI escape sequence of 2 hexdecimal numbers, but found %r" %
-                                (self.reader.peek(k).encode('utf-8')), self.reader.get_mark())
-            bytes.append(chr(int(self.reader.prefix(2), 16)))
-            self.reader.forward(2)
+                                (self.peek(k).encode('utf-8')), self.get_mark())
+            bytes.append(chr(int(self.prefix(2), 16)))
+            self.forward(2)
         try:
             value = unicode(''.join(bytes), 'utf-8')
@@ -1438 +1433 @@
         #   '\u2029     :   '\u2029'
         #   default     :   ''
-        ch = self.reader.peek()
+        ch = self.peek()
         if ch in u'\r\n\x85':
-            if self.reader.prefix(2) == u'\r\n':
-                self.reader.forward(2)
+            if self.prefix(2) == u'\r\n':
+                self.forward(2)
             else:
-                self.reader.forward()
+                self.forward()
             return u'\n'
         elif ch in u'\u2028\u2029':
-            self.reader.forward()
+            self.forward()
             return ch
         return u''