RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/{scanner.rb.~1.2.~ → scanner.rb.~1.5.~}

@@ -23,42 +23,43 @@
 # Read comments in the Scanner code for more details.
 #
 
+require 'rbyaml/util'
 require 'rbyaml/error'
 require 'rbyaml/tokens'
 
 module RbYAML
   class ScannerError < MarkedYAMLError
   end
-  
-  class SimpleKey
-    attr_reader :token_number, :required, :index, :line, :column, :mark
-
-    def initialize(token_number,required,index,line,column,mark)
-      @token_number = token_number
-      @required = required
-      @index = index
-      @line = line
-      @column = column
-      @mark = mark
+  class ReaderError < YAMLError
+    def initialize(name, position, character, encoding, reason)
+      @name = name
+      @position = position
+      @character = character
+      @encoding = encoding
+      @reason = reason
+    end
+
+    def to_s
+      if @character.__is_str
+        "'#{@encoding}' codec can't decode byte #x%02x: #{@reason}\n  in \"#{@name}\", position #{@position}" % @character.to_i
+      else
+        "unacceptable character #x%04x: #{@reason}\n  in \"#{@name}\", position #{@position}" % @character.to_i
+      end
     end
   end
 
-  module Scanner
-    def initialize_scanner
-      # It is assumed that Scanner and Reader will mixin to the same point.
-      # Reader do the dirty work of checking for BOM. 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.
+  SimpleKey = Struct.new(:token_number, :required, :index, :line, :column, :mark)
 
+  class Scanner
+    attr_reader :column, :stream, :stream_pointer, :eof, :buffer, :pointer, :index, :line
+    def initialize(stream)
       # Had we reached the end of the stream?
       @done = false
 
       # The number of unclosed '{' and '['. `flow_level == 0` means block
       # context.
       @flow_level = 0
+      @flow_zero = true
 
       # List of processed tokens that are not yet emitted.
       @tokens = []
@@ -104,6 +105,199 @@ module RbYAML
       # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow),
       # '[', or '{' tokens.
       @possible_simple_keys = {}
+
+      @stream = nil
+      @stream_pointer = 0
+      @eof = true
+      @buffer = ""
+      @buffer_length = 0
+      @pointer = 0
+      @pointer1 = 1
+      @column = 0
+      if stream.__is_str
+        @name = "<string>"
+        @raw_buffer = stream
+      else
+        @stream = stream
+        @name = stream.respond_to?(:path) ? stream.path : stream.inspect
+        @eof = false
+        @raw_buffer = ""
+      end
+    end
+
+    def peek(index=0)
+      peekn(index)
+    end
+
+    def peek0
+      update(1) unless @pointer1 < @buffer_length
+      @buffer[@pointer]
+    end
+
+    def peek1
+      update(2) unless @pointer1+1 < @buffer_length
+      @buffer[@pointer1]
+    end
+
+    def peek2
+      update(3) unless @pointer1+2 < @buffer_length
+      @buffer[@pointer1+1]
+    end
+
+    def peek3
+      update(4) unless @pointer1+3 < @buffer_length
+      @buffer[@pointer1+2]
+    end
+
+    def peekn(index=0)
+      pix = @pointer1+index
+      unless pix < @buffer_length
+        update(index+1)
+        pix = @pointer1+index
+      end
+      @buffer[pix-1]
+    end
+    
+    def prefix(length=1)
+      update(length) unless @pointer+length < @buffer_length
+      @buffer[@pointer...@pointer+length]
+    end
+
+    def prefix2()
+      update(2) unless @pointer1+1 < @buffer_length
+      @buffer[@pointer..@pointer1]
+    end
+
+    def forward(length=1)
+      case length
+        when 0: forward0
+        when 1: forward1
+        when 2: forward2
+        when 3: forward3
+        when 4: forward4
+        when 5: forward5
+        when 6: forward6
+        else forwardn(length)
+      end
+    end
+
+    def forward0
+      update(1) unless @pointer1 < @buffer_length
+    end
+
+    LINE_BR = "\n\x85"
+
+    def forward1
+      update(2) unless @pointer1+1 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+1]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? -index : column+1
+      @pointer += 1
+      @pointer1 += 1
+    end
+    
+    def forward2
+      update(3) unless @pointer1+2 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+2]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? 1-index : column+2
+      @pointer += 2
+      @pointer1 += 2
+    end
+
+    def forward3
+      update(4) unless @pointer1+3 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+3]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? 2-index : column+3
+      @pointer += 3
+      @pointer1 += 3
+    end
+
+    def forward4
+      update(5) unless @pointer1+4 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+4]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? 3-index : column+4
+      @pointer += 4
+      @pointer1 += 4
+    end
+
+    def forward5
+      update(6) unless @pointer1+5 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+5]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? 4-index : column+5
+      @pointer += 5
+      @pointer1 += 5
+    end
+
+    def forward6
+      update(7) unless @pointer1+6 < @buffer_length
+      buff = @buffer[@pointer...@pointer1+6]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? 5-index : column+6
+      @pointer += 6
+      @pointer1 += 6
+    end
+
+    LINE_BR_REG = /[\n\x85]|(?:\r[^\n])/
+    def forwardn(length)
+      update(length + 1) unless @pointer1+length < @buffer_length
+      buff = @buffer[@pointer...@pointer+length]
+      index = buff.rindex(LINE_BR_REG)
+      @column = index ? (length-index)-1 : column+length
+      @pointer += length
+      @pointer1 += length
+    end
+    
+    def get_mark
+      if @stream.nil?
+        Mark.new(@name,@column,@buffer,@pointer)
+      else
+        Mark.new(@name,@column,nil,nil)
+      end
+    end
+    
+    NON_PRINTABLE = /[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\xFF]/
+    def check_printable(data)
+      if NON_PRINTABLE =~ data
+        position = @buffer.length-@pointer+($~.offset(0)[0])
+        raise ReaderError.new(@name, position, $&,"unicode","special characters are not allowed"),"special characters are not allowed"
+      end
+    end
+
+
+    def update(length)
+      return if @raw_buffer.nil?
+      @buffer = @buffer[@pointer..-1]
+      @pointer = 0
+      while @buffer.length < length
+        unless @eof
+          data = @stream.read(1024)
+          if data && !data.empty?
+            @buffer << data
+            @stream_pointer += data.length
+            @raw_buffer = ""
+          else
+            @eof = true
+            @buffer << ?\0
+            @raw_buffer = nil
+            break
+          end
+        else
+          @buffer << @raw_buffer << ?\0
+          @raw_buffer = nil
+          break
+        end
+      end
+      @buffer_length = @buffer.length
+      if @eof
+        check_printable(@buffer[(-length)..-2])
+      else
+        check_printable(@buffer[(-length)..-1])
+      end
+      @pointer1 = @pointer+1
     end
 
     def check_token(*choices)
@@ -144,70 +338,51 @@ module RbYAML
     
     def need_more_tokens
       return false if @done
-      return true if @tokens.empty?
-      # The current token may be a potential simple key, so we
-      # need to look further.
-      stale_possible_simple_keys
-      return true if next_possible_simple_key == @tokens_taken
+      @tokens.empty? || next_possible_simple_key == @tokens_taken
     end
 
+    ENDING = /^---[\0 \t\r\n\x85]$/
+    START = /^\.\.\.[\0 \t\r\n\x85]$/
+    NULL_OR_OTHER = "\0 \t\r\n\x85"
+#    BEG = /^([^\0 \t\r\n\x85\-?:,\[\]{}#&*!|>'"%@`]|([\-?:][^\0 \t\r\n\x85]))/    #Since current SYCK handles this one wrong, we have to allow backtick right now.
+    BEG = /^([^\0 \t\r\n\x85\-?:,\[\]{}#&*!|>'"%@]|([\-?:][^\0 \t\r\n\x85]))/    
     def fetch_more_tokens
       # Eat whitespaces and comments until we reach the next token.
       scan_to_next_token
 
       # Remove obsolete possible simple keys.
-      stale_possible_simple_keys
+#      stale_possible_simple_keys
 
       # Compare the current indentation and column. It may add some tokens
       # and decrease the current indentation level.
       unwind_indent(@column)
 
       # Peek the next character.
-      ch = peek
-
-      return case
-               # Is it the end of stream?
-             when ch == ?\0: fetch_stream_end
-               # Is it a directive?
-             when ch == ?% && check_directive: fetch_directive
-               # Is it the document start?
-             when ch == ?- && check_document_start: fetch_document_start
-               # Is it the document end?
-             when ch == ?. && check_document_end: fetch_document_end
-               # Is it the flow sequence start indicator?
-             when ch == ?[: fetch_flow_sequence_start
-               # Is it the flow mapping start indicator?
-             when ch == ?{: fetch_flow_mapping_start
-               # Is it the flow sequence end indicator?
-             when ch == ?]: fetch_flow_sequence_end
-               # Is it the flow mapping end indicator?
-             when ch == ?}: fetch_flow_mapping_end
-               # Is it the flow entry indicator?
-             when ch == ?,: fetch_flow_entry
-               # Is it the block entry indicator?
-             when ch == ?- && check_block_entry: fetch_block_entry
-               # Is it the key indicator?
-             when ch == ?? && check_key: fetch_key
-               # Is it the value indicator?
-             when ch == ?: && check_value: fetch_value
-               # Is it an alias?
-             when ch == ?*: fetch_alias
-               # Is it an anchor?
-             when ch == ?&: fetch_anchor
-               # Is it a tag?
-             when ch == ?!: fetch_tag
-               # Is it a literal scalar?
-             when ch == ?| && @flow_level==0: fetch_literal
-               # Is it a folded scalar?
-             when ch == ?> && @flow_level==0: fetch_folded
-               # Is it a single quoted scalar?
-             when ch == ?': fetch_single
-               # Is it a double quoted scalar?
-             when ch == ?": fetch_double
-               # It must be a plain scalar then.
-             when check_plain: fetch_plain
-             else raise ScannerError.new("while scanning for the next token", nil,"found character #{ch.chr}(#{ch}) that cannot start any token",get_mark)
-             end
+      ch = peek0
+      colz = @column == 0
+
+      case ch
+      when ?\0: return fetch_stream_end
+      when ?': return fetch_single
+      when ?": return fetch_double
+      when ??: if !@flow_zero || NULL_OR_OTHER.include?(peek1): return fetch_key end
+      when ?:: if !@flow_zero || NULL_OR_OTHER.include?(peek1): return fetch_value end
+      when ?%: if colz: return fetch_stream_end end
+      when ?-: if colz && ENDING =~ prefix(4): return fetch_document_start; elsif NULL_OR_OTHER.include?(peek1): return fetch_block_entry end
+      when ?.: if colz && START =~ prefix(4): return fetch_document_end end
+      when ?[: return fetch_flow_sequence_start
+      when ?{: return fetch_flow_mapping_start
+      when ?]: return fetch_flow_sequence_end
+      when ?}: return fetch_flow_mapping_end
+      when ?,: return fetch_flow_entry
+      when ?*: return fetch_alias
+      when ?&: return fetch_anchor
+      when ?!: return fetch_tag
+      when ?|: if @flow_zero: return fetch_literal end
+      when ?>: if @flow_zero: return fetch_folded end
+      end
+      return fetch_plain if BEG =~ prefix(2)
+      raise ScannerError.new("while scanning for the next token", nil,"found character #{ch.chr}(#{ch}) that cannot start any token",get_mark)
     end
 
     # Simple keys treatment.
@@ -215,58 +390,22 @@ module RbYAML
     def next_possible_simple_key
       # Return the number of the nearest possible simple key. Actually we
       # don't need to loop through the whole dictionary.
-      min_token_number = nil
-      for level in @possible_simple_keys.keys
-        key = @possible_simple_keys[level]
-        if min_token_number.nil? || key.token_number < min_token_number
-          min_token_number = key.token_number
-        end
-      end
-      min_token_number
+      @possible_simple_keys.each_value {|key| return key.token_number if key.token_number}
+      nil
     end
     
-    def stale_possible_simple_keys
-      # Remove entries that are no longer possible simple keys. According to
-      # the YAML specification, simple keys
-      # - should be limited to a single line,
-      # - should be no longer than 1024 characters.
-      # Disabling this procedure will allow simple keys of any length and
-      # height (may cause problems if indentation is broken though).
-      @possible_simple_keys.delete_if {|level,key| 
-        if key.line != @line || @index-key.index > 1024
-          raise ScannerError.new("while scanning a simple key", key.mark, "could not found expected ':'",get_mark) if key.required
-          return true
-        end
-        return false
-      }
-    end
-
     def save_possible_simple_key
       # The next token may start a simple key. We check if it's possible
       # and save its position. This function is called for
       #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
-      
-      # Check if a simple key is required at the current position.
-      required = @flow_level==0 && @indent == @column
-
       # The next token might be a simple key. Let's save it's number and
       # position.
-      if @allow_simple_key
-        remove_possible_simple_key
-        token_number = @tokens_taken+@tokens.length
-        key = SimpleKey.new(token_number, required,@index,@line,@column,get_mark)
-        @possible_simple_keys[@flow_level] = key
-      end
+      @possible_simple_keys[@flow_level] = SimpleKey.new(@tokens_taken+@tokens.length, @flow_zero && @indent == @column,-1,-1,column,get_mark) if @allow_simple_key
     end
 
-    def remove_possible_simple_key
-      # Remove the saved possible key position at the current flow level.
-      key = @possible_simple_keys[@flow_level] if @possible_simple_keys.member?(@flow_level)
-    end            
-    
     # Indentation functions.
 
-    def unwind_indent(column)
+    def unwind_indent(col)
       ## In flow context, tokens should respect indentation.
       ## Actually the condition should be `@indent >= column` according to
       ## the spec. But this condition will prohibit intuitively correct
@@ -280,20 +419,20 @@ module RbYAML
 
       # In the flow context, indentation is ignored. We make the scanner less
       # restrictive then specification requires.
-      return nil if @flow_level != 0
+      return nil if !@flow_zero
       # In block context, we may need to issue the BLOCK-END tokens.
-      while @indent > column
+      while @indent > col
         mark = get_mark
-        @indent = @indents.pop()
+        @indent = @indents.pop
         @tokens << BlockEndToken.new(mark, mark)
       end
     end
     
-    def add_indent(column)
+    def add_indent(col)
       # Check if we need to increase indentation.
-      if @indent < column
+      if @indent < col
         @indents << @indent
-        @indent = column
+        @indent = col
         return true
       end
       return false
@@ -329,7 +468,6 @@ module RbYAML
       # Set the current intendation to -1.
       unwind_indent(-1)
       # Reset simple keys.
-      remove_possible_simple_key
       @allow_simple_key = false
       # Scan and add DIRECTIVE.
       @tokens << scan_directive
@@ -348,11 +486,10 @@ module RbYAML
       unwind_indent(-1)
       # Reset simple keys. Note that there could not be a block collection
       # after '---'.
-      remove_possible_simple_key
       @allow_simple_key = false
       # Add DOCUMENT-START or DOCUMENT-END.
       start_mark = get_mark
-      forward(3)
+      forward3
       end_mark = get_mark
       @tokens << token.new(start_mark, end_mark)
     end
@@ -370,11 +507,12 @@ module RbYAML
       save_possible_simple_key
       # Increase the flow level.
       @flow_level += 1
+      @flow_zero = false
       # Simple keys are allowed after '[' and '{'.
       @allow_simple_key = true
       # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << token.new(start_mark, end_mark)
     end
@@ -388,15 +526,16 @@ module RbYAML
     end
     
     def fetch_flow_collection_end(token)
-      # Reset possible simple key on the current level.
-      remove_possible_simple_key
       # Decrease the flow level.
       @flow_level -= 1
+      if @flow_level == 0
+        @flow_zero = true
+      end
       # No simple keys after ']' or '}'.
       @allow_simple_key = false
       # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << token.new(start_mark, end_mark)
     end
@@ -404,21 +543,19 @@ module RbYAML
     def fetch_flow_entry
       # Simple keys are allowed after ','.
       @allow_simple_key = true
-      # Reset possible simple key on the current level.
-      remove_possible_simple_key
       # Add FLOW-ENTRY.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << FlowEntryToken.new(start_mark, end_mark)
     end
 
     def fetch_block_entry
       # Block context needs additional checks.
-      if @flow_level==0
+      if @flow_zero
         raise ScannerError.new(nil,nil,"sequence entries are not allowed here",get_mark) if !@allow_simple_key
         # We may need to add BLOCK-SEQUENCE-START.
-        if add_indent(@column)
+        if add_indent(column)
           mark = get_mark
           @tokens << BlockSequenceStartToken.new(mark, mark)
         end
@@ -427,67 +564,63 @@ module RbYAML
       end
       # Simple keys are allowed after '-'.
       @allow_simple_key = true
-      # Reset possible simple key on the current level.
-      remove_possible_simple_key
       # Add BLOCK-ENTRY.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << BlockEntryToken.new(start_mark, end_mark)
     end
 
     def fetch_key
       # Block context needs additional checks.
-      if @flow_level==0
+      if @flow_zero
         # Are we allowed to start a key (not nessesary a simple)?
         raise ScannerError.new(nil,nil,"mapping keys are not allowed here",get_mark) if !@allow_simple_key
         # We may need to add BLOCK-MAPPING-START.
-        if add_indent(@column)
+        if add_indent(column)
           mark = get_mark
           @tokens << BlockMappingStartToken.new(mark, mark)
         end
       end
       # Simple keys are allowed after '?' in the block context.
-      @allow_simple_key = @flow_level==0
-      # Reset possible simple key on the current level.
-      remove_possible_simple_key
+      @allow_simple_key = @flow_zero
       # Add KEY.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << KeyToken.new(start_mark, end_mark)
     end
     
     def fetch_value
+      key = @possible_simple_keys[@flow_level]
       # Do we determine a simple key?
-      if @possible_simple_keys.include?(@flow_level)
-        # Add KEY.
-        key = @possible_simple_keys[@flow_level]
-        @possible_simple_keys.delete(@flow_level)
-        @tokens.insert(key.token_number-@tokens_taken,KeyToken.new(key.mark, key.mark))
-        # If this key starts a new block mapping, we need to add
-        # BLOCK-MAPPING-START.
-        @tokens.insert(key.token_number-@tokens_taken,BlockMappingStartToken.new(key.mark, key.mark)) if @flow_level==0 && add_indent(key.column)
-        # There cannot be two simple keys one after another.
-        @allow_simple_key = false
-        # It must be a part of a complex key.
-      else
+      if key.nil?
         # Block context needs additional checks.
         # (Do we really need them? They will be catched by the parser
         # anyway.)
-        if @flow_level==0
+        if @flow_zero
           # We are allowed to start a complex value if and only if
           # we can start a simple key.
           raise ScannerError.new(nil,nil,"mapping values are not allowed here",get_mark) if !@allow_simple_key
           # Simple keys are allowed after ':' in the block context.
-          @allow_simple_key = @flow_level==0
-          # Reset possible simple key on the current level.
-          remove_possible_simple_key
+          @allow_simple_key = true
         end
+      else
+        # Add KEY.
+        @possible_simple_keys.delete(@flow_level)
+
+        # If this key starts a new block mapping, we need to add
+        # BLOCK-MAPPING-START.
+        se = (@flow_zero && add_indent(key.column)) ? [BlockMappingStartToken.new(key.mark, key.mark)] : []
+        se << KeyToken.new(key.mark, key.mark)
+        @tokens.insert(key.token_number-@tokens_taken,*se)
+        # There cannot be two simple keys one after another.
+        @allow_simple_key = false
+        # It must be a part of a complex key.
       end
       # Add VALUE.
       start_mark = get_mark
-      forward
+      forward1
       end_mark = get_mark
       @tokens << ValueToken.new(start_mark, end_mark)
     end
@@ -530,8 +663,6 @@ module RbYAML
     def fetch_block_scalar(style)
       # A simple key may follow a block scalar.
       @allow_simple_key = true
-      # Reset possible simple key on the current level.
-      remove_possible_simple_key
       # Scan and add SCALAR.
       @tokens << scan_block_scalar(style)
     end
@@ -564,65 +695,9 @@ module RbYAML
       @tokens << scan_plain
     end
 
-    # Checkers.
-
-    def check_directive
-      # DIRECTIVE:        ^ '%' ...
-      # The '%' indicator is already checked.
-      @column == 0
-    end
-
-    def check_document_start
-      # DOCUMENT-START:   ^ '---' (' '|'\n')
-      @column == 0 && prefix(3) == "---" && "\0 \t\r\n\x85".include?(peek(3))
-    end
-
-    def check_document_end
-      # DOCUMENT-END:     ^ '...' (' '|'\n')
-      @column == 0 && prefix(3) == "..." && "\0 \t\r\n\x85".include?(peek(3))
-    end
-
-    def check_block_entry
-      # BLOCK-ENTRY:      '-' (' '|'\n')
-      "\0 \t\r\n\x85".include?(peek(1))
-    end
-    
-    def check_key
-      # KEY(flow context):    '?'
-      # KEY(block context):   '?' (' '|'\n')
-      @flow_level!=0 || "\0 \t\r\n\x85".include?(peek(1)) 
-    end
-
-    def check_value
-      # VALUE(flow context):  ':'
-      # VALUE(block context): ':' (' '|'\n')
-      @flow_level!=0 || "\0 \t\r\n\x85".include?(peek(1)) 
-    end
-    
-    def check_plain
-      # A plain scalar may start with any non-space character except:
-      #   '-', '?', ':', ',', '[', ']', '{', '}',
-      #   '#', '&', '*', '!', '|', '>', '\'', '\"',
-      #   '%', '@', '`'.
-      #
-      # It may also start with
-      #   '-', '?', ':'
-      # if it is followed by a non-space character.
-      #
-      # 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 = peek
-      !("\0 \t\r\n\x85-?:,[]{}#&*!|>'\"%@`".include?(ch)) || (!("\0 \t\r\n\x85".include?(peek(1)) && (ch == ?- || (@flow_level==0 && "?:".include?(ch)))))
-    end
-
-
-
-
-
     
     # Scanners.
-    
+    NULL_OR_LINEBR = "\0\r\n\x85"
     def scan_to_next_token
       # We ignore spaces, line breaks and comments.
       # If we find a line break in the block context, we set the flag
@@ -638,18 +713,20 @@ module RbYAML
       # We also need to add the check for `allow_simple_keys == true` to
       # `unwind_indent` before issuing BLOCK-END.
       # Scanners for block, flow, and plain scalars need to be modified.
-      found = false
-      while !found
-        while peek == 32
-          forward
+      while true
+        while peek0 == 32
+          forward1
         end
-        if peek == ?#
-            forward while !"\0\r\n\x85".include?(peek)
+        if peek0 == ?#
+          while !NULL_OR_LINEBR.include?(peek0)
+            forward1
+          end
         end
+
         if !scan_line_break.empty?
-          @allow_simple_key = true if @flow_level==0
+          @allow_simple_key = true if @flow_zero
         else
-          found = true
+          break
         end
       end
     end
@@ -657,7 +734,7 @@ module RbYAML
     def scan_directive
       # See the specification for details.
       start_mark = get_mark
-      forward
+      forward1
       name = scan_directive_name(start_mark)
       value = nil
       if name == "YAML"
@@ -668,45 +745,50 @@ module RbYAML
         end_mark = get_mark
       else
         end_mark = get_mark
-        forward while !"\0\r\n\x85".include?(peek)
+        forward1 while !NULL_OR_LINEBR.include?(peek0)
       end
       scan_directive_ignored_line(start_mark)
       DirectiveToken.new(name, value, start_mark, end_mark)
     end
 
+    ALPHA_REG = /[-0-9A-Za-z_]/
+    NULL_BL_LINEBR = "\0 \r\n\x85"
+    NULL_BL_T_LINEBR = "\0 \t\r\n\x85"
     def scan_directive_name(start_mark)
       # See the specification for details.
       length = 0
       ch = peek(length)
-      while /[-0-9A-Za-z_]/ =~ ch.chr
+      zlen = true
+      while ALPHA_REG  =~ ch.chr
+        zlen = false
         length += 1
         ch = peek(length)
       end
-      raise ScannerError.new("while scanning a directive", start_mark,"expected alphabetic or numeric character, but found #{ch.to_s}",get_mark) if length==0
+      raise ScannerError.new("while scanning a directive", start_mark,"expected alphabetic or numeric character, but found #{ch.to_s}",get_mark) if zlen
       value = prefix(length)
       forward(length)
-      ch = peek()
-      raise ScannerError.new("while scanning a directive", start_mark,"expected alphabetic or numeric character, but found #{ch.to_s}",get_mark) if !"\0 \r\n\x85".include?(ch)
+      ch = peek0
+      raise ScannerError.new("while scanning a directive", start_mark,"expected alphabetic or numeric character, but found #{ch.to_s}",get_mark) if !NULL_BL_LINEBR.include?(ch)
       value
     end
 
     def scan_yaml_directive_value(start_mark)
       # See the specification for details.
-      forward while peek == 32
+      forward1 while peek0 == 32
       major = scan_yaml_directive_number(start_mark)
-      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit or '.', but found #{peek.to_s}",get_mark) if peek != ?.
-      forward
+      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit or '.', but found #{peek.to_s}",get_mark) if peek0 != ?.
+      forward1
       minor = scan_yaml_directive_number(start_mark)
-      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit or ' ', but found #{peek.to_s}",get_mark) if !"\0 \r\n\x85".include?(peek)
+      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit or ' ', but found #{peek.to_s}",get_mark) if !NULL_BL_LINEBR.include?(peek0)
       [major, minor]
     end
 
     def scan_yaml_directive_number(start_mark)
       # See the specification for details.
-      ch = peek
-      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit, but found #{ch.to_s}",get_mark) if !((?0..?9) === ch)
+      ch = peek0
+      raise ScannerError.new("while scanning a directive", start_mark,"expected a digit, but found #{ch.to_s}",get_mark) if !(ch.__is_ascii_num)
       length = 0
-      length += 1 while ((?0..?9) === peek(length))
+      length += 1 while (peek(length).__is_ascii_num)
       value = prefix(length)
       forward(length)
       value
@@ -714,9 +796,9 @@ module RbYAML
     
     def scan_tag_directive_value(start_mark)
       # See the specification for details.
-      forward while peek == 32
+      forward1 while peek0 == 32
       handle = scan_tag_directive_handle(start_mark)
-      forward while peek == 32
+      forward1 while peek0 == 32
       prefix = scan_tag_directive_prefix(start_mark)
       [handle, prefix]
     end
@@ -724,30 +806,30 @@ module RbYAML
     def scan_tag_directive_handle(start_mark)
       # See the specification for details.
       value = scan_tag_handle("directive", start_mark)
-      ch = peek
-      raise ScannerError.new("while scanning a directive", start_mark,"expected ' ', but found #{ch}",get_mark()) if ch != 32
+      raise ScannerError.new("while scanning a directive", start_mark,"expected ' ', but found #{peek0}",get_mark()) if peek0 != 32
       value
     end
 
     def scan_tag_directive_prefix(start_mark)
       # See the specification for details.
       value = scan_tag_uri("directive", start_mark)
-      ch = peek
-      raise ScannerError.new("while scanning a directive", start_mark,"expected ' ', but found #{ch}",get_mark()) if !"\0 \r\n\x85".include?(ch)
+      raise ScannerError.new("while scanning a directive", start_mark,"expected ' ', but found #{peek0}",get_mark()) if !NULL_BL_LINEBR.include?(peek0)
       value
     end
     
     def scan_directive_ignored_line(start_mark)
       # See the specification for details.
-      forward while peek == 32
-      if peek == ?#
-          forward while !"\0\r\n\x85".include?(peek)
+      forward1 while peek0 == 32
+      if peek0 == ?#
+          forward1 while !NULL_OR_LINEBR.include?(peek0)
       end
-      ch = peek
-      raise ScannerError.new("while scanning a directive", start_mark,"expected a comment or a line break, but found #{ch.to_s}",get_mark()) if !"\0\r\n\x85".include?(ch)
+      ch = peek0
+      raise ScannerError.new("while scanning a directive", start_mark,"expected a comment or a line break, but found #{peek0.to_s}",get_mark()) if !NULL_OR_LINEBR.include?(peek0)
       scan_line_break
     end
-    
+ 
+    NON_ALPHA = /[^-0-9A-Za-z_]/   
+    NON_ALPHA_OR_NUM = "\0 \t\r\n\x85?:,]}%@`"
     def scan_anchor(token)
       # The specification does not restrict characters for anchors and
       # aliases. This may lead to problems, for instance, the document:
@@ -758,45 +840,47 @@ module RbYAML
       #   [ *alias , "value" ]
       # Therefore we restrict aliases to numbers and ASCII letters.
       start_mark = get_mark
-      indicator = peek
+      indicator = peek0
       name = (indicator == ?*) ? "alias":"anchor"
-      forward
+      forward1
       length = 0
-      ch = peek(length)
-      while /[-0-9A-Za-z_]/ =~ ch.chr
-        length += 1
-        ch = peek(length)
+      chunk_size = 16
+      while true
+        chunk = prefix(chunk_size)
+        if length = (NON_ALPHA =~ chunk)
+          break
+        end
+        chunk_size += 16
       end
-      raise ScannerError.new("while scanning an #{name}", start_mark,"expected alphabetic or numeric character, but found #{ch}",get_mark) if length==0
+      raise ScannerError.new("while scanning an #{name}", start_mark,"expected alphabetic or numeric character, but found something else...",get_mark) if length==0
       value = prefix(length)
       forward(length)
-      ch = peek
-      if !"\0 \t\r\n\x85?:,]}%@`".include?(ch)
-        raise ScannerError.new("while scanning an #{name}", start_mark,"expected alphabetic or numeric character, but found #{ch}",get_mark)
+      if !NON_ALPHA_OR_NUM.include?(peek0)
+        raise ScannerError.new("while scanning an #{name}", start_mark,"expected alphabetic or numeric character, but found #{peek0}",get_mark)
       end
       end_mark = get_mark
       token.new(value, start_mark, end_mark)
     end
 
-
+    NULL_T_BL_LINEBR = "\0 \t\r\n\x85"
     def scan_tag
       # See the specification for details.
       start_mark = get_mark
-      ch = peek(1)
+      ch = peek1
       if ch == ?<
         handle = nil
-        forward(2)
+        forward2
         suffix = scan_tag_uri("tag", start_mark)
-        raise ScannerError.new("while parsing a tag", start_mark,"expected '>', but found #{peek.to_s}",get_mark) if peek != ?>
-        forward
-      elsif "\0 \t\r\n\x85".include?(ch)
+        raise ScannerError.new("while parsing a tag", start_mark,"expected '>', but found #{peek.to_s}",get_mark) if peek0 != ?>
+        forward1
+      elsif NULL_T_BL_LINEBR.include?(ch)
         handle = nil
         suffix = "!"
-        forward
+        forward1
       else
         length = 1
         use_handle = false
-        while !"\0 \t\r\n\x85".include?(ch)
+        while !NULL_T_BL_LINEBR.include?(ch)
           if ch == ?!
             use_handle = true
             break
@@ -809,24 +893,24 @@ module RbYAML
           handle = scan_tag_handle("tag", start_mark)
         else
           handle = "!"
-          forward
+          forward1
         end
         suffix = scan_tag_uri("tag", start_mark)
       end
-      ch = peek
-      raise ScannerError.new("while scanning a tag",start_mark,"expected ' ', but found #{ch}",get_mark) if !"\0 \r\n\x85".include?(ch)
+      raise ScannerError.new("while scanning a tag",start_mark,"expected ' ', but found #{peek0}",get_mark) if !NULL_BL_LINEBR.include?(peek0)
       value = [handle, suffix]
       end_mark = get_mark
       TagToken.new(value, start_mark, end_mark)
     end
 
+    BLANK_T = " \t"
     def scan_block_scalar(style)
       # See the specification for details.
       folded = style== ?>
       chunks = []
       start_mark = get_mark
       # Scan the header.
-      forward
+      forward1
       chomping, increment = scan_block_scalar_indicators(start_mark)
       scan_block_scalar_ignored_line(start_mark)
       # Determine the indentation level and go to the first non-empty line.
@@ -841,20 +925,20 @@ module RbYAML
       end
       line_break = ''
       # Scan the inner part of the block scalar.
-      while @column == indent and peek != ?\0
+      while column == indent and peek0 != ?\0
         chunks += breaks
-        leading_non_space = !" \t".include?(peek)
+        leading_non_space = !BLANK_T.include?(peek0)
         length = 0
-        length += 1 while !"\0\r\n\x85".include?(peek(length))
+        length += 1 while !NULL_OR_LINEBR.include?(peek(length))
         chunks << prefix(length)
         forward(length)
         line_break = scan_line_break
         breaks, end_mark = scan_block_scalar_breaks(indent)
-        if @column == indent && peek != 0
+        if column == indent && peek0 != 0
           # Unfortunately, folding rules are ambiguous.
           #
           # This is the folding according to the specification:
-          if folded && line_break == ?\n && leading_non_space && !" \t".include?(peek())
+          if folded && line_break == "\n" && leading_non_space && !BLANK_T.include?(peek0)
             chunks << ' ' if breaks.empty?
           else
             chunks << line_break
@@ -882,76 +966,76 @@ module RbYAML
       end
 
       # We are done.
-      ScalarToken.new(chunks.join(''), false, start_mark, end_mark,style)
+      ScalarToken.new(chunks.to_s, false, start_mark, end_mark,style)
     end
 
+    PLUS_MIN = /[+-]/
     def scan_block_scalar_indicators(start_mark)
       # See the specification for details.
       chomping = nil
       increment = nil
-      ch = peek
-      if /[+-]/ =~ ch.chr
+      ch = peek0
+      if PLUS_MIN =~ ch.chr
         chomping = ch == ?+
-        forward
-        ch = peek
-        if (?0..?9) === ch
-          increment = ch.to_i
+        forward1
+        ch = peek0
+        if ch.__is_ascii_num
+          increment = ch.chr.to_i
           raise ScannerError.new("while scanning a block scalar", start_mark,"expected indentation indicator in the range 1-9, but found 0",get_mark) if increment == 0
-          forward
+          forward1
         end
-      elsif (?0..?9) === ch
-        increment = ch
+      elsif ch.__is_ascii_num
+        increment = ch.chr.to_i
         raise ScannerError.new("while scanning a block scalar", start_mark,"expected indentation indicator in the range 1-9, but found 0",get_mark) if increment == 0
-        forward
-        ch = peek
-        if /[+-]/ =~ ch.chr
+        forward1
+        ch = peek0
+        if PLUS_MIN =~ ch.chr
           chomping = ch == ?+
-          forward
+          forward1
         end
       end
-      ch = peek
-      raise ScannerError.new("while scanning a block scalar", start_mark,"expected chomping or indentation indicators, but found #{ch.to_s}",get_mark) if !"\0 \r\n\x85".include?(ch)
+      raise ScannerError.new("while scanning a block scalar", start_mark,"expected chomping or indentation indicators, but found #{peek0}",get_mark) if !NULL_BL_LINEBR.include?(peek0)
       [chomping, increment]
     end
 
     def scan_block_scalar_ignored_line(start_mark)
       # See the specification for details.
-      forward while peek == 32
-      if peek == ?#
-          forward while !"\0\r\n\x85".include?(peek)
+      forward1 while peek0 == 32
+      if peek0 == ?#
+          forward1 while !NULL_OR_LINEBR.include?(peek0)
       end
-      ch = peek
-      
-      raise ScannerError.new("while scanning a block scalar", start_mark,"expected a comment or a line break, but found #{ch.to_s}",get_mark) if !"\0\r\n\x85".include?(ch)
+      raise ScannerError.new("while scanning a block scalar", start_mark,"expected a comment or a line break, but found #{peek0}",get_mark) if !NULL_OR_LINEBR.include?(peek0)
       scan_line_break
     end
 
+    BLANK_OR_LINEBR = " \r\n\x85"
     def scan_block_scalar_indentation
       # See the specification for details.
       chunks = []
       max_indent = 0
       end_mark = get_mark
-      while " \r\n\x85".include?(peek)
-        if peek != 32
+      while BLANK_OR_LINEBR.include?(peek0)
+        if peek0 != 32
           chunks << scan_line_break
           end_mark = get_mark
         else
-          forward
-          max_indent = @column if @column > max_indent
+          forward1
+          max_indent = column if column > max_indent
         end
       end
       [chunks, max_indent, end_mark]
     end
 
+    FULL_LINEBR = "\r\n\x85"
     def scan_block_scalar_breaks(indent)
       # See the specification for details.
       chunks = []
       end_mark = get_mark
-      forward while @column < indent && peek == 32
-      while "\r\n\x85".include?(peek)
+      forward1 while @column < indent && peek0 == 32
+      while FULL_LINEBR.include?(peek0)
         chunks << scan_line_break
         end_mark = get_mark
-        forward while @column < indent && peek == 32
+        forward1 while @column < indent && peek0 == 32
       end
       [chunks, end_mark]
     end
@@ -966,16 +1050,16 @@ module RbYAML
       double = style == ?"
       chunks = []
       start_mark = get_mark
-      quote = peek
-      forward
+      quote = peek0
+      forward1
       chunks += scan_flow_scalar_non_spaces(double, start_mark)
-      while peek != quote
+      while peek0 != quote
         chunks += scan_flow_scalar_spaces(double, start_mark)
         chunks += scan_flow_scalar_non_spaces(double, start_mark)
       end
-      forward
+      forward1
       end_mark = get_mark
-      ScalarToken.new(chunks.join(''), false, start_mark, end_mark,style)
+      ScalarToken.new(chunks.to_s, false, start_mark, end_mark,style)
     end
     
     ESCAPE_REPLACEMENTS = {
@@ -1000,42 +1084,43 @@ module RbYAML
       'x' =>   2
     }
     
+    SPACES_AND_STUFF = "'\"\\\0 \t\r\n\x85"
+    DOUBLE_ESC = "\"\\"
+    NOT_HEXA = /[^0-9A-Fa-f]/
     def scan_flow_scalar_non_spaces(double, start_mark)
       # See the specification for details.
       chunks = []
       while true
         length = 0
-        length += 1 while !"'\"\\\0 \t\r\n\x85".include?(peek(length))
+        length += 1 while !SPACES_AND_STUFF.include?(peek(length))
         if length!=0
           chunks << prefix(length)
           forward(length)
         end
-        ch = peek
-        if !double && ch == ?' && peek(1) == ?'
+        ch = peek0
+        if !double && ch == ?' && peek1 == ?'
           chunks << ?'
-          forward(2)
-        elsif (double && ch == ?') || (!double && "\"\\".include?(ch))
+          forward2
+        elsif (double && ch == ?') || (!double && DOUBLE_ESC.include?(ch))
           chunks << ch
-          forward
+          forward1
         elsif double && ch == ?\\
-          forward
-          ch = peek
+          forward1
+          ch = peek0
           if ESCAPE_REPLACEMENTS.member?(ch.chr)
             chunks << ESCAPE_REPLACEMENTS[ch.chr]
-            forward
+            forward1
           elsif ESCAPE_CODES.member?(ch.chr)
             length = ESCAPE_CODES[ch.chr]
-            forward
-            length.times do |k|
-              if /[0-9A-Fa-f]/ !~ peek(k).chr
-                raise ScannerError.new("while scanning a double-quoted scalar", start_mark,
-                                       "expected escape sequence of #{length} hexdecimal numbers, but found #{peek(k)}",get_mark)
-              end
+            forward1
+            if NOT_HEXA =~ prefix(length)
+              raise ScannerError.new("while scanning a double-quoted scalar", start_mark,
+                                     "expected escape sequence of #{length} hexdecimal numbers, but found something else: #{prefix(length)}}",get_mark)
             end
-            code = prefix(length).to_i.to_s(16)
+            code = prefix(length).to_i(16).to_s
             chunks << code
             forward(length)
-          elsif "\r\n\x85".include?(ch)
+          elsif FULL_LINEBR.include?(ch)
             scan_line_break
             chunks += scan_flow_scalar_breaks(double, start_mark)
           else
@@ -1051,16 +1136,16 @@ module RbYAML
       # See the specification for details.
       chunks = []
       length = 0
-      length += 1 while /[ \t]/ =~ peek(length).chr
+      length += 1 while BLANK_T.include?(peek(length))
       whitespaces = prefix(length)
       forward(length)
-      ch = peek
+      ch = peek0
       if ch == ?\0
         raise ScannerError.new("while scanning a quoted scalar", start_mark,"found unexpected end of stream",get_mark)
-      elsif "\r\n\x85".include?(ch)
+      elsif FULL_LINEBR.include?(ch)
         line_break = scan_line_break
         breaks = scan_flow_scalar_breaks(double, start_mark)
-        if line_break != ?\n
+        if line_break != "\n"
           chunks << line_break
         elsif breaks.empty?
           chunks << ' '
@@ -1079,17 +1164,22 @@ module RbYAML
         # Instead of checking indentation, we check for document
         # separators.
         prefix = prefix(3)
-        if (prefix == "---" || prefix == "...") && "\0 \t\r\n\x85".include?(peek(3))
+        if (prefix == "---" || prefix == "...") &&NULL_BL_T_LINEBR.include?(peek3)
           raise ScannerError.new("while scanning a quoted scalar", start_mark,"found unexpected document separator", get_mark)
         end
-        forward while /[ \t]/ =~ peek.chr
-        if "\r\n\x85".include?(peek)
+        forward1 while BLANK_T.include?(peek0)
+        if FULL_LINEBR.include?(peek0)
           chunks << scan_line_break
         else
           return chunks
         end
       end
     end
+    
+
+    R_flowzero = /[\0 \t\r\n\x85]|(:[\0 \t\r\n\x28])/
+    R_flownonzero = /[\0 \t\r\n\x85\[\]{},:?]/
+    S4 = "\0 \t\r\n\x28[]{}"
 
     def scan_plain
       # See the specification for details.
@@ -1098,25 +1188,25 @@ module RbYAML
       # We also keep track of the `allow_simple_key` flag here.
       # Indentation rules are loosed for the flow context.
       chunks = []
-      start_mark = get_mark
-      end_mark = start_mark
+      end_mark = start_mark = get_mark
       indent = @indent+1
       # We allow zero indentation for scalars, but then we need to check for
       # document separators at the beginning of the line.
       #if indent == 0
       #    indent = 1
       spaces = []
-      while true
+      if @flow_zero
+        f_nzero, r_check = false, R_flowzero
+      else
+        f_nzero, r_check = true, R_flownonzero
+      end
+
+      while peek0 != ?#
         length = 0
-        break if peek == ?#
-        while true
-          ch = peek(length)
-          if "\0 \t\r\n\x85".include?(ch) || (@flow_level==0 && ch == ?: && "\0 \t\r\n\x28".include?(peek(length+1))) || (@flow_level!=0 && ",:?[]{}".include?(ch))
-            break
-          end
-          length += 1
-        end
-        if @flow_level != 0 && ch == ?: && !"\0 \t\r\n\x28[]{}".include?(peek(length+1))
+        chunk_size = 32
+        chunk_size += 32 until length = (r_check =~ prefix(chunk_size))
+        ch = peek(length)
+        if f_nzero && ch == ?: && !S4.include?(peek(length+1))
           forward(length)
           raise ScannerError.new("while scanning a plain scalar",start_mark,"found unexpected ':'",get_mark,"Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.")
         end
@@ -1127,11 +1217,12 @@ module RbYAML
         forward(length)
         end_mark = get_mark
         spaces = scan_plain_spaces(indent, start_mark)
-        break if spaces.nil? || spaces.empty? || peek == ?# || (@flow_level==0 && @column < indent)
+        break if !spaces || (@flow_zero && @column < indent)
       end
-      return ScalarToken.new(chunks.join(''), true, start_mark, end_mark)
+      return ScalarToken.new(chunks.to_s, true, start_mark, end_mark)
     end
 
+    END_OR_START = /^(---|\.\.\.)[\0 \t\r\n\x85]$/
     def scan_plain_spaces(indent, start_mark)
       # See the specification for details.
       # The specification is really confusing about tabs in plain scalars.
@@ -1141,44 +1232,43 @@ module RbYAML
       length += 1 while peek(length) == 32
       whitespaces = prefix(length)
       forward(length)
-      ch = peek
-      if "\r\n\x85".include?(ch)
+      ch = peek0
+      if FULL_LINEBR.include?(ch)
         line_break = scan_line_break
         @allow_simple_key = true
-        prefix = prefix(3)
-        return if (prefix == "---" || prefix == "...") && "\0 \t\r\n\x85".include?(peek(3))
+        return if END_OR_START =~ prefix(4)
         breaks = []
-        while " \r\n\x85".include?(peek)
-          if peek == 32
-            forward
+        while BLANK_OR_LINEBR.include?(peek0)
+          if peek0 == 32
+            forward1
           else
             breaks << scan_line_break
-            prefix = prefix(3)
-            return if (prefix == "---" || prefix == "...") && "\0 \t\r\n\x85".include?(peek(3))
+            return if END_OR_START =~ prefix(4)
           end
         end
-        if line_break != '\n'
+        if line_break != "\n"
           chunks << line_break
-        elsif breaks.empty?
-          chunks << ' '
+        elsif breaks.nil? || breaks.empty?
+          chunks << " "
         end
         chunks += breaks
-      elsif !whitespaces.empty?
+      else
         chunks << whitespaces
       end
       chunks
     end
 
+    
     def scan_tag_handle(name, start_mark)
       # See the specification for details.
       # For some strange reasons, the specification does not allow '_' in
       # tag handles. I have allowed it anyway.
-      ch = peek
+      ch = peek0
       raise ScannerError.new("while scanning a #{name}", start_mark,"expected '!', but found #{ch}",get_mark) if ch != ?!
       length = 1
       ch = peek(length)
       if ch != 32
-        while /[-_0-9A-Za-z]/ =~ ch.chr
+        while ALPHA_REG =~ ch.chr
           length += 1
           ch = peek(length)
         end
@@ -1193,13 +1283,14 @@ module RbYAML
       value
     end
     
+    STRANGE_CHR = /[\]\[\-';\/?:@&=+$,.!~*()%\w]/
     def scan_tag_uri(name, start_mark)
       # See the specification for details.
       # Note: we do not check if URI is well-formed.
       chunks = []
       length = 0
       ch = peek(length)
-      while /[\]\[\-';\/?:@&=+$,.!~*()%\w]/ =~ ch.chr
+      while  STRANGE_CHR =~ ch.chr
         if ch == ?%
           chunks << prefix(length)
           forward(length)
@@ -1213,29 +1304,27 @@ module RbYAML
       if length!=0
         chunks << prefix(length)
         forward(length)
-        length = 0
       end
       
       raise ScannerError.new("while parsing a #{name}", start_mark,"expected URI, but found #{ch}",get_mark) if chunks.empty?
-      chunks.join('')
+      chunks.to_s
     end
 
+    HEXA_REG = /[0-9A-Fa-f]/
     def scan_uri_escapes(name, start_mark)
       # See the specification for details.
       bytes = []
       mark = get_mark
-      while peek == ?%
-        forward
-        2.times do |k|
-          raise ScannerError.new("while scanning a #{name}", start_mark,"expected URI escape sequence of 2 hexdecimal numbers, but found #{peek(k)}", 
-                                 get_mark) if /[0-9A-Fa-f]/ !~ peek(k).chr
-        end
-        bytes << prefix(2).to_i.to_s(16)
-        forward(2)
+      while peek0 == ?%
+        forward1
+        raise ScannerError.new("while scanning a #{name}", start_mark,"expected URI escape sequence of 2 hexdecimal numbers, but found #{peek1} and #{peek2}",get_mark) if HEXA_REG !~ peek1.chr || HEXA_REG !~ peek2.chr
+        bytes << prefix(2).to_i(16).to_s
+        forward2
       end
-      bytes.join('')
+      bytes.to_s
     end
 
+    RN = "\r\n"
     def scan_line_break
       # Transforms:
       #   '\r\n'      :   '\n'
@@ -1243,12 +1332,11 @@ module RbYAML
       #   '\n'        :   '\n'
       #   '\x85'      :   '\n'
       #   default     :   ''
-      ch = peek
-      if "\r\n\x85".include?(ch)
-        if prefix(2) == "\r\n"
-          forward(2)
+      if FULL_LINEBR.include?(peek0)
+        if prefix2 == RN
+          forward2
         else
-          forward
+          forward1
         end
         return "\n"
       end