Index: C:/projects/workspace_python/PyYAML_2/lib/yaml/scanner.py
===================================================================
--- C:/projects/workspace_python/PyYAML_2/lib/yaml/scanner.py	(revision 298)
+++ C:/projects/workspace_python/PyYAML_2/lib/yaml/scanner.py	(working copy)
@@ -45,17 +45,18 @@
 
 class Scanner(object):
 
-    def __init__(self):
+    def __init__(self, reader):
         """Initialize the scanner."""
-        # It is assumed that Scanner and Reader will have a common descendant.
-        # Reader do the dirty work of checking for BOM and converting the
+        # Reader does 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.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.
+        #   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
+        
         # Had we reached the end of the stream?
         self.done = False
 
@@ -160,10 +161,10 @@
 
         # Compare the current indentation and column. It may add some tokens
         # and decrease the current indentation level.
-        self.unwind_indent(self.column)
+        self.unwind_indent(self.reader.column)
 
         # Peek the next character.
-        ch = self.peek()
+        ch = self.reader.peek()
 
         # Is it the end of stream?
         if ch == u'\0':
@@ -254,7 +255,7 @@
         # No? It's an error. Let's produce a nice error message.
         raise ScannerError("while scanning for the next token", None,
                 "found character %r that cannot start any token"
-                % ch.encode('utf-8'), self.get_mark())
+                % ch.encode('utf-8'), self.reader.get_mark())
 
     # Simple keys treatment.
 
@@ -282,11 +283,11 @@
         # height (may cause problems if indentation is broken though).
         for level in self.possible_simple_keys.keys():
             key = self.possible_simple_keys[level]
-            if key.line != self.line  \
-                    or self.index-key.index > 1024:
+            if key.line != self.reader.line  \
+                    or self.reader.index-key.index > 1024:
                 if key.required:
                     raise ScannerError("while scanning a simple key", key.mark,
-                            "could not found expected ':'", self.get_mark())
+                            "could not found expected ':'", self.reader.get_mark())
                 del self.possible_simple_keys[level]
 
     def save_possible_simple_key(self):
@@ -295,7 +296,7 @@
         #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
 
         # Check if a simple key is required at the current position.
-        required = not self.flow_level and self.indent == self.column
+        required = not self.flow_level and self.indent == self.reader.column
 
         # A simple key is required only if it is the first token in the current
         # line. Therefore it is always allowed.
@@ -307,7 +308,7 @@
             self.remove_possible_simple_key()
             token_number = self.tokens_taken+len(self.tokens)
             key = SimpleKey(token_number, required,
-                    self.index, self.line, self.column, self.get_mark())
+                    self.reader.index, self.reader.line, self.reader.column, self.reader.get_mark())
             self.possible_simple_keys[self.flow_level] = key
 
     def remove_possible_simple_key(self):
@@ -317,7 +318,7 @@
             
             if key.required:
                 raise ScannerError("while scanning a simple key", key.mark,
-                        "could not found expected ':'", self.get_mark())
+                        "could not found expected ':'", self.reader.get_mark())
 
             del self.possible_simple_keys[self.flow_level]
 
@@ -334,7 +335,7 @@
         #if self.flow_level and self.indent > column:
         #    raise ScannerError(None, None,
         #            "invalid intendation or unclosed '[' or '{'",
-        #            self.get_mark())
+        #            self.reader.get_mark())
 
         # In the flow context, indentation is ignored. We make the scanner less
         # restrictive then specification requires.
@@ -343,7 +344,7 @@
 
         # In block context, we may need to issue the BLOCK-END tokens.
         while self.indent > column:
-            mark = self.get_mark()
+            mark = self.reader.get_mark()
             self.indent = self.indents.pop()
             self.tokens.append(BlockEndToken(mark, mark))
 
@@ -362,11 +363,11 @@
         # last token.
 
         # Read the token.
-        mark = self.get_mark()
+        mark = self.reader.get_mark()
         
         # Add STREAM-START.
         self.tokens.append(StreamStartToken(mark, mark,
-            encoding=self.encoding))
+            encoding=self.reader.encoding))
         
 
     def fetch_stream_end(self):
@@ -379,7 +380,7 @@
         self.possible_simple_keys = {}
 
         # Read the token.
-        mark = self.get_mark()
+        mark = self.reader.get_mark()
         
         # Add STREAM-END.
         self.tokens.append(StreamEndToken(mark, mark))
@@ -416,9 +417,9 @@
         self.allow_simple_key = False
 
         # Add DOCUMENT-START or DOCUMENT-END.
-        start_mark = self.get_mark()
-        self.forward(3)
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward(3)
+        end_mark = self.reader.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
     def fetch_flow_sequence_start(self):
@@ -439,9 +440,9 @@
         self.allow_simple_key = True
 
         # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
     def fetch_flow_sequence_end(self):
@@ -462,9 +463,9 @@
         self.allow_simple_key = False
 
         # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(TokenClass(start_mark, end_mark))
 
     def fetch_flow_entry(self):
@@ -476,9 +477,9 @@
         self.remove_possible_simple_key()
 
         # Add FLOW-ENTRY.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(FlowEntryToken(start_mark, end_mark))
 
     def fetch_block_entry(self):
@@ -490,11 +491,11 @@
             if not self.allow_simple_key:
                 raise ScannerError(None, None,
                         "sequence entries are not allowed here",
-                        self.get_mark())
+                        self.reader.get_mark())
 
             # We may need to add BLOCK-SEQUENCE-START.
-            if self.add_indent(self.column):
-                mark = self.get_mark()
+            if self.add_indent(self.reader.column):
+                mark = self.reader.get_mark()
                 self.tokens.append(BlockSequenceStartToken(mark, mark))
 
         # It's an error for the block entry to occur in the flow context,
@@ -509,9 +510,9 @@
         self.remove_possible_simple_key()
 
         # Add BLOCK-ENTRY.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(BlockEntryToken(start_mark, end_mark))
 
     def fetch_key(self):
@@ -523,11 +524,11 @@
             if not self.allow_simple_key:
                 raise ScannerError(None, None,
                         "mapping keys are not allowed here",
-                        self.get_mark())
+                        self.reader.get_mark())
 
             # We may need to add BLOCK-MAPPING-START.
-            if self.add_indent(self.column):
-                mark = self.get_mark()
+            if self.add_indent(self.reader.column):
+                mark = self.reader.get_mark()
                 self.tokens.append(BlockMappingStartToken(mark, mark))
 
         # Simple keys are allowed after '?' in the block context.
@@ -537,9 +538,9 @@
         self.remove_possible_simple_key()
 
         # Add KEY.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(KeyToken(start_mark, end_mark))
 
     def fetch_value(self):
@@ -576,14 +577,14 @@
                 if not self.allow_simple_key:
                     raise ScannerError(None, None,
                             "mapping values are not allowed here",
-                            self.get_mark())
+                            self.reader.get_mark())
 
             # If this value starts a new block mapping, we need to add
             # BLOCK-MAPPING-START.  It will be detected as an error later by
             # the parser.
             if not self.flow_level:
-                if self.add_indent(self.column):
-                    mark = self.get_mark()
+                if self.add_indent(self.reader.column):
+                    mark = self.reader.get_mark()
                     self.tokens.append(BlockMappingStartToken(mark, mark))
 
             # Simple keys are allowed after ':' in the block context.
@@ -593,9 +594,9 @@
             self.remove_possible_simple_key()
 
         # Add VALUE.
-        start_mark = self.get_mark()
-        self.forward()
-        end_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         self.tokens.append(ValueToken(start_mark, end_mark))
 
     def fetch_alias(self):
@@ -684,29 +685,29 @@
 
         # DIRECTIVE:        ^ '%' ...
         # The '%' indicator is already checked.
-        if self.column == 0:
+        if self.reader.column == 0:
             return True
 
     def check_document_start(self):
 
         # DOCUMENT-START:   ^ '---' (' '|'\n')
-        if self.column == 0:
-            if self.prefix(3) == u'---'  \
-                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+        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':
                 return True
 
     def check_document_end(self):
 
         # DOCUMENT-END:     ^ '...' (' '|'\n')
-        if self.column == 0:
-            if self.prefix(3) == u'...'  \
-                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+        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':
                 return True
 
     def check_block_entry(self):
 
         # BLOCK-ENTRY:      '-' (' '|'\n')
-        return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+        return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_key(self):
 
@@ -716,7 +717,7 @@
 
         # KEY(block context):   '?' (' '|'\n')
         else:
-            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_value(self):
 
@@ -726,7 +727,7 @@
 
         # VALUE(block context): ':' (' '|'\n')
         else:
-            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+            return self.reader.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
 
     def check_plain(self):
 
@@ -742,9 +743,9 @@
         # Note that we limit the last rule to the block context (except the
         # '-' character) because we want the flow context to be space
         # independent.
-        ch = self.peek()
+        ch = self.reader.peek()
         return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
-                or (self.peek(1) 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'
                         and (ch == u'-' or (not self.flow_level and ch in u'?:')))
 
     # Scanners.
@@ -769,15 +770,15 @@
         # `unwind_indent` before issuing BLOCK-END.
         # Scanners for block, flow, and plain scalars need to be modified.
 
-        if self.index == 0 and self.peek() == u'\uFEFF':
-            self.forward()
+        if self.reader.index == 0 and self.reader.peek() == u'\uFEFF':
+            self.reader.forward()
         found = False
         while not found:
-            while self.peek() == u' ':
-                self.forward()
-            if self.peek() == u'#':
-                while self.peek() not in u'\0\r\n\x85\u2028\u2029':
-                    self.forward()
+            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()
             if self.scan_line_break():
                 if not self.flow_level:
                     self.allow_simple_key = True
@@ -786,119 +787,119 @@
 
     def scan_directive(self):
         # See the specification for details.
-        start_mark = self.get_mark()
-        self.forward()
+        start_mark = self.reader.get_mark()
+        self.reader.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.get_mark()
+            end_mark = self.reader.get_mark()
         elif name == u'TAG':
             value = self.scan_tag_directive_value(start_mark)
-            end_mark = self.get_mark()
+            end_mark = self.reader.get_mark()
         else:
-            end_mark = self.get_mark()
-            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
-                self.forward()
+            end_mark = self.reader.get_mark()
+            while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.reader.forward()
         self.scan_directive_ignored_line(start_mark)
         return DirectiveToken(name, value, start_mark, end_mark)
 
     def scan_directive_name(self, start_mark):
         # See the specification for details.
         length = 0
-        ch = self.peek(length)
+        ch = self.reader.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.peek(length)
+            ch = self.reader.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.get_mark())
-        value = self.prefix(length)
-        self.forward(length)
-        ch = self.peek()
+                    % ch.encode('utf-8'), self.reader.get_mark())
+        value = self.reader.prefix(length)
+        self.reader.forward(length)
+        ch = self.reader.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.get_mark())
+                    % ch.encode('utf-8'), self.reader.get_mark())
         return value
 
     def scan_yaml_directive_value(self, start_mark):
         # See the specification for details.
-        while self.peek() == u' ':
-            self.forward()
+        while self.reader.peek() == u' ':
+            self.reader.forward()
         major = self.scan_yaml_directive_number(start_mark)
-        if self.peek() != '.':
+        if self.reader.peek() != '.':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected a digit or '.', but found %r"
-                    % self.peek().encode('utf-8'),
-                    self.get_mark())
-        self.forward()
+                    % self.reader.peek().encode('utf-8'),
+                    self.reader.get_mark())
+        self.reader.forward()
         minor = self.scan_yaml_directive_number(start_mark)
-        if self.peek() not in u'\0 \r\n\x85\u2028\u2029':
+        if self.reader.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.peek().encode('utf-8'),
-                    self.get_mark())
+                    % self.reader.peek().encode('utf-8'),
+                    self.reader.get_mark())
         return (major, minor)
 
     def scan_yaml_directive_number(self, start_mark):
         # See the specification for details.
-        ch = self.peek()
+        ch = self.reader.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.get_mark())
+                    self.reader.get_mark())
         length = 0
-        while u'0' <= self.peek(length) <= u'9':
+        while u'0' <= self.reader.peek(length) <= u'9':
             length += 1
-        value = int(self.prefix(length))
-        self.forward(length)
+        value = int(self.reader.prefix(length))
+        self.reader.forward(length)
         return value
 
     def scan_tag_directive_value(self, start_mark):
         # See the specification for details.
-        while self.peek() == u' ':
-            self.forward()
+        while self.reader.peek() == u' ':
+            self.reader.forward()
         handle = self.scan_tag_directive_handle(start_mark)
-        while self.peek() == u' ':
-            self.forward()
+        while self.reader.peek() == u' ':
+            self.reader.forward()
         prefix = self.scan_tag_directive_prefix(start_mark)
         return (handle, prefix)
 
     def scan_tag_directive_handle(self, start_mark):
         # See the specification for details.
         value = self.scan_tag_handle('directive', start_mark)
-        ch = self.peek()
+        ch = self.reader.peek()
         if ch != u' ':
             raise ScannerError("while scanning a directive", start_mark,
                     "expected ' ', but found %r" % ch.encode('utf-8'),
-                    self.get_mark())
+                    self.reader.get_mark())
         return value
 
     def scan_tag_directive_prefix(self, start_mark):
         # See the specification for details.
         value = self.scan_tag_uri('directive', start_mark)
-        ch = self.peek()
+        ch = self.reader.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.get_mark())
+                    self.reader.get_mark())
         return value
 
     def scan_directive_ignored_line(self, start_mark):
         # See the specification for details.
-        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()
+        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()
         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.get_mark())
+                        % ch.encode('utf-8'), self.reader.get_mark())
         self.scan_line_break()
 
     def scan_anchor(self, TokenClass):
@@ -910,50 +911,50 @@
         # and
         #   [ *alias , "value" ]
         # Therefore we restrict aliases to numbers and ASCII letters.
-        start_mark = self.get_mark()
-        indicator = self.peek()
+        start_mark = self.reader.get_mark()
+        indicator = self.reader.peek()
         if indicator == '*':
             name = 'alias'
         else:
             name = 'anchor'
-        self.forward()
+        self.reader.forward()
         length = 0
-        ch = self.peek(length)
+        ch = self.reader.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.peek(length)
+            ch = self.reader.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.get_mark())
-        value = self.prefix(length)
-        self.forward(length)
-        ch = self.peek()
+                    % ch.encode('utf-8'), self.reader.get_mark())
+        value = self.reader.prefix(length)
+        self.reader.forward(length)
+        ch = self.reader.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.get_mark())
-        end_mark = self.get_mark()
+                    % ch.encode('utf-8'), self.reader.get_mark())
+        end_mark = self.reader.get_mark()
         return TokenClass(value, start_mark, end_mark)
 
     def scan_tag(self):
         # See the specification for details.
-        start_mark = self.get_mark()
-        ch = self.peek(1)
+        start_mark = self.reader.get_mark()
+        ch = self.reader.peek(1)
         if ch == u'<':
             handle = None
-            self.forward(2)
+            self.reader.forward(2)
             suffix = self.scan_tag_uri('tag', start_mark)
-            if self.peek() != u'>':
+            if self.reader.peek() != u'>':
                 raise ScannerError("while parsing a tag", start_mark,
-                        "expected '>', but found %r" % self.peek().encode('utf-8'),
-                        self.get_mark())
-            self.forward()
+                        "expected '>', but found %r" % self.reader.peek().encode('utf-8'),
+                        self.reader.get_mark())
+            self.reader.forward()
         elif ch in u'\0 \t\r\n\x85\u2028\u2029':
             handle = None
             suffix = u'!'
-            self.forward()
+            self.reader.forward()
         else:
             length = 1
             use_handle = False
@@ -962,21 +963,21 @@
                     use_handle = True
                     break
                 length += 1
-                ch = self.peek(length)
+                ch = self.reader.peek(length)
             handle = u'!'
             if use_handle:
                 handle = self.scan_tag_handle('tag', start_mark)
             else:
                 handle = u'!'
-                self.forward()
+                self.reader.forward()
             suffix = self.scan_tag_uri('tag', start_mark)
-        ch = self.peek()
+        ch = self.reader.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.get_mark())
+                    self.reader.get_mark())
         value = (handle, suffix)
-        end_mark = self.get_mark()
+        end_mark = self.reader.get_mark()
         return TagToken(value, start_mark, end_mark)
 
     def scan_block_scalar(self, style):
@@ -988,10 +989,10 @@
             folded = False
 
         chunks = []
-        start_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
 
         # Scan the header.
-        self.forward()
+        self.reader.forward()
         chomping, increment = self.scan_block_scalar_indicators(start_mark)
         self.scan_block_scalar_ignored_line(start_mark)
 
@@ -1008,24 +1009,24 @@
         line_break = u''
 
         # Scan the inner part of the block scalar.
-        while self.column == indent and self.peek() != u'\0':
+        while self.reader.column == indent and self.reader.peek() != u'\0':
             chunks.extend(breaks)
-            leading_non_space = self.peek() not in u' \t'
+            leading_non_space = self.reader.peek() not in u' \t'
             length = 0
-            while self.peek(length) not in u'\0\r\n\x85\u2028\u2029':
+            while self.reader.peek(length) not in u'\0\r\n\x85\u2028\u2029':
                 length += 1
-            chunks.append(self.prefix(length))
-            self.forward(length)
+            chunks.append(self.reader.prefix(length))
+            self.reader.forward(length)
             line_break = self.scan_line_break()
             breaks, end_mark = self.scan_block_scalar_breaks(indent)
-            if self.column == indent and self.peek() != u'\0':
+            if self.reader.column == indent and self.reader.peek() != u'\0':
 
                 # Unfortunately, folding rules are ambiguous.
                 #
                 # This is the folding according to the specification:
                 
                 if folded and line_break == u'\n'   \
-                        and leading_non_space and self.peek() not in u' \t':
+                        and leading_non_space and self.reader.peek() not in u' \t':
                     if not breaks:
                         chunks.append(u' ')
                 else:
@@ -1036,7 +1037,7 @@
                 #
                 #if folded and line_break == u'\n':
                 #    if not breaks:
-                #        if self.peek() not in ' \t':
+                #        if self.reader.peek() not in ' \t':
                 #            chunks.append(u' ')
                 #        else:
                 #            chunks.append(line_break)
@@ -1059,82 +1060,82 @@
         # See the specification for details.
         chomping = None
         increment = None
-        ch = self.peek()
+        ch = self.reader.peek()
         if ch in u'+-':
             if ch == '+':
                 chomping = True
             else:
                 chomping = False
-            self.forward()
-            ch = self.peek()
+            self.reader.forward()
+            ch = self.reader.peek()
             if ch in u'0123456789':
                 increment = int(ch)
                 if increment == 0:
                     raise ScannerError("while scanning a block scalar", start_mark,
                             "expected indentation indicator in the range 1-9, but found 0",
-                            self.get_mark())
-                self.forward()
+                            self.reader.get_mark())
+                self.reader.forward()
         elif ch in u'0123456789':
             increment = int(ch)
             if increment == 0:
                 raise ScannerError("while scanning a block scalar", start_mark,
                         "expected indentation indicator in the range 1-9, but found 0",
-                        self.get_mark())
-            self.forward()
-            ch = self.peek()
+                        self.reader.get_mark())
+            self.reader.forward()
+            ch = self.reader.peek()
             if ch in u'+-':
                 if ch == '+':
                     chomping = True
                 else:
                     chomping = False
-                self.forward()
-        ch = self.peek()
+                self.reader.forward()
+        ch = self.reader.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.get_mark())
+                        % ch.encode('utf-8'), self.reader.get_mark())
         return chomping, increment
 
     def scan_block_scalar_ignored_line(self, start_mark):
         # See the specification for details.
-        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()
+        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()
         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.get_mark())
+                        % ch.encode('utf-8'), self.reader.get_mark())
         self.scan_line_break()
 
     def scan_block_scalar_indentation(self):
         # See the specification for details.
         chunks = []
         max_indent = 0
-        end_mark = self.get_mark()
-        while self.peek() in u' \r\n\x85\u2028\u2029':
-            if self.peek() != u' ':
+        end_mark = self.reader.get_mark()
+        while self.reader.peek() in u' \r\n\x85\u2028\u2029':
+            if self.reader.peek() != u' ':
                 chunks.append(self.scan_line_break())
-                end_mark = self.get_mark()
+                end_mark = self.reader.get_mark()
             else:
-                self.forward()
-                if self.column > max_indent:
-                    max_indent = self.column
+                self.reader.forward()
+                if self.reader.column > max_indent:
+                    max_indent = self.reader.column
         return chunks, max_indent, end_mark
 
     def scan_block_scalar_breaks(self, indent):
         # See the specification for details.
         chunks = []
-        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':
+        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':
             chunks.append(self.scan_line_break())
-            end_mark = self.get_mark()
-            while self.column < indent and self.peek() == u' ':
-                self.forward()
+            end_mark = self.reader.get_mark()
+            while self.reader.column < indent and self.reader.peek() == u' ':
+                self.reader.forward()
         return chunks, end_mark
 
     def scan_flow_scalar(self, style):
@@ -1149,15 +1150,15 @@
         else:
             double = False
         chunks = []
-        start_mark = self.get_mark()
-        quote = self.peek()
-        self.forward()
+        start_mark = self.reader.get_mark()
+        quote = self.reader.peek()
+        self.reader.forward()
         chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
-        while self.peek() != quote:
+        while self.reader.peek() != quote:
             chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
             chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
-        self.forward()
-        end_mark = self.get_mark()
+        self.reader.forward()
+        end_mark = self.reader.get_mark()
         return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
                 style)
 
@@ -1192,41 +1193,41 @@
         chunks = []
         while True:
             length = 0
-            while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
+            while self.reader.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
                 length += 1
             if length:
-                chunks.append(self.prefix(length))
-                self.forward(length)
-            ch = self.peek()
-            if not double and ch == u'\'' and self.peek(1) == u'\'':
+                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(u'\'')
-                self.forward(2)
+                self.reader.forward(2)
             elif (double and ch == u'\'') or (not double and ch in u'\"\\'):
                 chunks.append(ch)
-                self.forward()
+                self.reader.forward()
             elif double and ch == u'\\':
-                self.forward()
-                ch = self.peek()
+                self.reader.forward()
+                ch = self.reader.peek()
                 if ch in self.ESCAPE_REPLACEMENTS:
                     chunks.append(self.ESCAPE_REPLACEMENTS[ch])
-                    self.forward()
+                    self.reader.forward()
                 elif ch in self.ESCAPE_CODES:
                     length = self.ESCAPE_CODES[ch]
-                    self.forward()
+                    self.reader.forward()
                     for k in range(length):
-                        if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                        if self.reader.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.peek(k).encode('utf-8')), self.get_mark())
-                    code = int(self.prefix(length), 16)
+                                        (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark())
+                    code = int(self.reader.prefix(length), 16)
                     chunks.append(unichr(code))
-                    self.forward(length)
+                    self.reader.forward(length)
                 elif ch in u'\r\n\x85\u2028\u2029':
                     self.scan_line_break()
                     chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
                 else:
                     raise ScannerError("while scanning a double-quoted scalar", start_mark,
-                            "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark())
+                            "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark())
             else:
                 return chunks
 
@@ -1234,14 +1235,14 @@
         # See the specification for details.
         chunks = []
         length = 0
-        while self.peek(length) in u' \t':
+        while self.reader.peek(length) in u' \t':
             length += 1
-        whitespaces = self.prefix(length)
-        self.forward(length)
-        ch = self.peek()
+        whitespaces = self.reader.prefix(length)
+        self.reader.forward(length)
+        ch = self.reader.peek()
         if ch == u'\0':
             raise ScannerError("while scanning a quoted scalar", start_mark,
-                    "found unexpected end of stream", self.get_mark())
+                    "found unexpected end of stream", self.reader.get_mark())
         elif ch in u'\r\n\x85\u2028\u2029':
             line_break = self.scan_line_break()
             breaks = self.scan_flow_scalar_breaks(double, start_mark)
@@ -1260,14 +1261,14 @@
         while True:
             # Instead of checking indentation, we check for document
             # separators.
-            prefix = self.prefix(3)
+            prefix = self.reader.prefix(3)
             if (prefix == u'---' or prefix == u'...')   \
-                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                    and self.reader.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.get_mark())
-            while self.peek() in u' \t':
-                self.forward()
-            if self.peek() in u'\r\n\x85\u2028\u2029':
+                        "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':
                 chunks.append(self.scan_line_break())
             else:
                 return chunks
@@ -1279,7 +1280,7 @@
         # We also keep track of the `allow_simple_key` flag here.
         # Indentation rules are loosed for the flow context.
         chunks = []
-        start_mark = self.get_mark()
+        start_mark = self.reader.get_mark()
         end_mark = start_mark
         indent = self.indent+1
         # We allow zero indentation for scalars, but then we need to check for
@@ -1289,33 +1290,33 @@
         spaces = []
         while True:
             length = 0
-            if self.peek() == u'#':
+            if self.reader.peek() == u'#':
                 break
             while True:
-                ch = self.peek(length)
+                ch = self.reader.peek(length)
                 if ch in u'\0 \t\r\n\x85\u2028\u2029'   \
                         or (not self.flow_level and ch == u':' and
-                                self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \
+                                self.reader.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \
                         or (self.flow_level and ch in u',:?[]{}'):
                     break
                 length += 1
             # It's not clear what we should do with ':' in the flow context.
             if (self.flow_level and ch == u':'
-                    and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'):
-                self.forward(length)
+                    and self.reader.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'):
+                self.reader.forward(length)
                 raise ScannerError("while scanning a plain scalar", start_mark,
-                    "found unexpected ':'", self.get_mark(),
+                    "found unexpected ':'", self.reader.get_mark(),
                     "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.")
             if length == 0:
                 break
             self.allow_simple_key = False
             chunks.extend(spaces)
-            chunks.append(self.prefix(length))
-            self.forward(length)
-            end_mark = self.get_mark()
+            chunks.append(self.reader.prefix(length))
+            self.reader.forward(length)
+            end_mark = self.reader.get_mark()
             spaces = self.scan_plain_spaces(indent, start_mark)
-            if not spaces or self.peek() == u'#' \
-                    or (not self.flow_level and self.column < indent):
+            if not spaces or self.reader.peek() == u'#' \
+                    or (not self.flow_level and self.reader.column < indent):
                 break
         return ScalarToken(u''.join(chunks), True, start_mark, end_mark)
 
@@ -1325,27 +1326,27 @@
         # We just forbid them completely. Do not use tabs in YAML!
         chunks = []
         length = 0
-        while self.peek(length) in u' ':
+        while self.reader.peek(length) in u' ':
             length += 1
-        whitespaces = self.prefix(length)
-        self.forward(length)
-        ch = self.peek()
+        whitespaces = self.reader.prefix(length)
+        self.reader.forward(length)
+        ch = self.reader.peek()
         if ch in u'\r\n\x85\u2028\u2029':
             line_break = self.scan_line_break()
             self.allow_simple_key = True
-            prefix = self.prefix(3)
+            prefix = self.reader.prefix(3)
             if (prefix == u'---' or prefix == u'...')   \
-                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                    and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                 return
             breaks = []
-            while self.peek() in u' \r\n\x85\u2028\u2029':
-                if self.peek() == ' ':
-                    self.forward()
+            while self.reader.peek() in u' \r\n\x85\u2028\u2029':
+                if self.reader.peek() == ' ':
+                    self.reader.forward()
                 else:
                     breaks.append(self.scan_line_break())
-                    prefix = self.prefix(3)
+                    prefix = self.reader.prefix(3)
                     if (prefix == u'---' or prefix == u'...')   \
-                            and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                            and self.reader.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
                         return
             if line_break != u'\n':
                 chunks.append(line_break)
@@ -1360,26 +1361,26 @@
         # See the specification for details.
         # For some strange reasons, the specification does not allow '_' in
         # tag handles. I have allowed it anyway.
-        ch = self.peek()
+        ch = self.reader.peek()
         if ch != u'!':
             raise ScannerError("while scanning a %s" % name, start_mark,
                     "expected '!', but found %r" % ch.encode('utf-8'),
-                    self.get_mark())
+                    self.reader.get_mark())
         length = 1
-        ch = self.peek(length)
+        ch = self.reader.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.peek(length)
+                ch = self.reader.peek(length)
             if ch != u'!':
-                self.forward(length)
+                self.reader.forward(length)
                 raise ScannerError("while scanning a %s" % name, start_mark,
                         "expected '!', but found %r" % ch.encode('utf-8'),
-                        self.get_mark())
+                        self.reader.get_mark())
             length += 1
-        value = self.prefix(length)
-        self.forward(length)
+        value = self.reader.prefix(length)
+        self.reader.forward(length)
         return value
 
     def scan_tag_uri(self, name, start_mark):
@@ -1387,40 +1388,40 @@
         # Note: we do not check if URI is well-formed.
         chunks = []
         length = 0
-        ch = self.peek(length)
+        ch = self.reader.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.prefix(length))
-                self.forward(length)
+                chunks.append(self.reader.prefix(length))
+                self.reader.forward(length)
                 length = 0
                 chunks.append(self.scan_uri_escapes(name, start_mark))
             else:
                 length += 1
-            ch = self.peek(length)
+            ch = self.reader.peek(length)
         if length:
-            chunks.append(self.prefix(length))
-            self.forward(length)
+            chunks.append(self.reader.prefix(length))
+            self.reader.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.get_mark())
+                    self.reader.get_mark())
         return u''.join(chunks)
 
     def scan_uri_escapes(self, name, start_mark):
         # See the specification for details.
         bytes = []
-        mark = self.get_mark()
-        while self.peek() == u'%':
-            self.forward()
+        mark = self.reader.get_mark()
+        while self.reader.peek() == u'%':
+            self.reader.forward()
             for k in range(2):
-                if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                if self.reader.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.peek(k).encode('utf-8')), self.get_mark())
-            bytes.append(chr(int(self.prefix(2), 16)))
-            self.forward(2)
+                                (self.reader.peek(k).encode('utf-8')), self.reader.get_mark())
+            bytes.append(chr(int(self.reader.prefix(2), 16)))
+            self.reader.forward(2)
         try:
             value = unicode(''.join(bytes), 'utf-8')
         except UnicodeDecodeError, exc:
@@ -1436,15 +1437,15 @@
         #   '\u2028'    :   '\u2028'
         #   '\u2029     :   '\u2029'
         #   default     :   ''
-        ch = self.peek()
+        ch = self.reader.peek()
         if ch in u'\r\n\x85':
-            if self.prefix(2) == u'\r\n':
-                self.forward(2)
+            if self.reader.prefix(2) == u'\r\n':
+                self.reader.forward(2)
             else:
-                self.forward()
+                self.reader.forward()
             return u'\n'
         elif ch in u'\u2028\u2029':
-            self.forward()
+            self.reader.forward()
             return ch
         return u''
 
Index: C:/projects/workspace_python/PyYAML_2/lib/yaml/loader.py
===================================================================
--- C:/projects/workspace_python/PyYAML_2/lib/yaml/loader.py	(revision 298)
+++ C:/projects/workspace_python/PyYAML_2/lib/yaml/loader.py	(working copy)
@@ -8,31 +8,28 @@
 from constructor import *
 from resolver import *
 
-class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
+class BaseLoader(Scanner, Parser, Composer, BaseConstructor, BaseResolver):
 
     def __init__(self, stream):
-        Reader.__init__(self, stream)
-        Scanner.__init__(self)
+        Scanner.__init__(self, Reader(stream))
         Parser.__init__(self)
         Composer.__init__(self)
         BaseConstructor.__init__(self)
         BaseResolver.__init__(self)
 
-class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
+class SafeLoader(Scanner, Parser, Composer, SafeConstructor, Resolver):
 
     def __init__(self, stream):
-        Reader.__init__(self, stream)
-        Scanner.__init__(self)
+        Scanner.__init__(self, Reader(stream))
         Parser.__init__(self)
         Composer.__init__(self)
         SafeConstructor.__init__(self)
         Resolver.__init__(self)
 
-class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+class Loader(Scanner, Parser, Composer, Constructor, Resolver):
 
     def __init__(self, stream):
-        Reader.__init__(self, stream)
-        Scanner.__init__(self)
+        Scanner.__init__(self, Reader(stream))
         Parser.__init__(self)
         Composer.__init__(self)
         Constructor.__init__(self)