#
# DO NOT MODIFY!!!!
# This file is automatically generated by racc 1.4.3
# from racc grammer file "src/yaml.y.rb".
#
#
# src/yaml.rb: generated by racc (runtime embedded)
#

###### racc/parser.rb

unless $".index 'racc/parser.rb'
$".push 'racc/parser.rb'

self.class.module_eval <<'..end /usr/local/lib/ruby/site_ruby/1.8/racc/parser.rb modeval..id4449eb2054', '/usr/local/lib/ruby/site_ruby/1.8/racc/parser.rb', 1
#
# parser.rb
#
#   Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
#
#   This program is free software.
#   You can distribute/modify this program under the same terms of ruby.
#
#   As a special exception, when this code is copied by Racc
#   into a Racc output file, you may use that output file
#   without restriction.
#
#   $Id: yaml.rb,v 1.2 2003/07/04 09:20:01 ljulliar Exp $
#

unless defined? NotImplementedError
  NotImplementedError = NotImplementError
end


module Racc
  class ParseError < StandardError; end
end
unless defined? ::ParseError
  ParseError = Racc::ParseError
end


module Racc

  unless defined? Racc_No_Extentions
    Racc_No_Extentions = false
  end

  class Parser

    Racc_Runtime_Version = '1.4.3'
    Racc_Runtime_Revision = '$Revision: 1.2 $'.split(/\s+/)[1]

    Racc_Runtime_Core_Version_R = '1.4.3'
    Racc_Runtime_Core_Revision_R = '$Revision: 1.2 $'.split(/\s+/)[1]
    begin
      require 'racc/cparse'
    # Racc_Runtime_Core_Version_C  = (defined in extention)
      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split(/\s+/)[2]
      unless new.respond_to?(:_racc_do_parse_c, true)
        raise LoadError, 'old cparse.so'
      end
      if Racc_No_Extentions
        raise LoadError, 'selecting ruby version of racc runtime core'
      end

      Racc_Main_Parsing_Routine    = :_racc_do_parse_c
      Racc_YY_Parse_Method         = :_racc_yyparse_c
      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
      Racc_Runtime_Type            = 'c'
    rescue LoadError
      Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
      Racc_YY_Parse_Method         = :_racc_yyparse_rb
      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_R
      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_R
      Racc_Runtime_Type            = 'ruby'
    end

    def self.racc_runtime_type
      Racc_Runtime_Type
    end

    private

    def _racc_setup
      @yydebug = false unless self.class::Racc_debug_parser
      @yydebug = false unless defined? @yydebug
      if @yydebug
        @racc_debug_out = $stderr unless defined? @racc_debug_out
        @racc_debug_out ||= $stderr
      end
      arg = self.class::Racc_arg
      arg[13] = true if arg.size < 14
      arg
    end

    def _racc_init_sysvars
      @racc_state  = [0]
      @racc_tstack = []
      @racc_vstack = []

      @racc_t = nil
      @racc_val = nil

      @racc_read_next = true

      @racc_user_yyerror = false
      @racc_error_status = 0
    end


    ###
    ### do_parse
    ###

    def do_parse
      __send__ Racc_Main_Parsing_Routine, _racc_setup(), false
    end

    def next_token
      raise NotImplementedError, "#{self.class}\#next_token is not defined"
    end

    def _racc_do_parse_rb( arg, in_debug )
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg

      _racc_init_sysvars()
      tok = act = i = nil
      nerr = 0

      catch(:racc_end_parse) {
          while true
            if i = action_pointer[@racc_state[-1]]
              if @racc_read_next
                if @racc_t != 0   # not EOF
                  tok, @racc_val = next_token()
                  unless tok      # EOF
                    @racc_t = 0
                  else
                    @racc_t = (token_table[tok] or 1)   # error token
                  end
                  racc_read_token(@racc_t, tok, @racc_val) if @yydebug
                  @racc_read_next = false
                end
              end
              i += @racc_t
              if  i >= 0 and
                  act = action_table[i] and
                  action_check[i] == @racc_state[-1]
                ;
              else
                act = action_default[@racc_state[-1]]
              end
            else
              act = action_default[@racc_state[-1]]
            end
            while act = _racc_evalact(act, arg)
            end
          end
      }
    end


    ###
    ### yyparse
    ###

    def yyparse( recv, mid )
      __send__ Racc_YY_Parse_Method, recv, mid, _racc_setup(), true
    end

    def _racc_yyparse_rb( recv, mid, arg, c_debug )
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg

      _racc_init_sysvars
      tok = nil
      act = nil
      i = nil
      nerr = 0


      catch(:racc_end_parse) {
        until i = action_pointer[@racc_state[-1]]
          while act = _racc_evalact(action_default[@racc_state[-1]], arg)
          end
        end

        recv.__send__(mid) do |tok, val|
# $stderr.puts "rd: tok=#{tok}, val=#{val}"
          unless tok
            @racc_t = 0
          else
            @racc_t = (token_table[tok] or 1)   # error token
          end
          @racc_val = val
          @racc_read_next = false

          i += @racc_t
          if  i >= 0 and
              act = action_table[i] and
              action_check[i] == @racc_state[-1]
            ;
# $stderr.puts "01: act=#{act}"
          else
            act = action_default[@racc_state[-1]]
# $stderr.puts "02: act=#{act}"
# $stderr.puts "curstate=#{@racc_state[-1]}"
          end

          while act = _racc_evalact(act, arg)
          end

          while not (i = action_pointer[@racc_state[-1]]) or
                not @racc_read_next or
                @racc_t == 0   # $
            if i and i += @racc_t and
               i >= 0 and
               act = action_table[i] and
               action_check[i] == @racc_state[-1]
              ;
# $stderr.puts "03: act=#{act}"
            else
# $stderr.puts "04: act=#{act}"
              act = action_default[@racc_state[-1]]
            end

            while act = _racc_evalact(act, arg)
            end
          end
        end
      }
    end


    ###
    ### common
    ###

    def _racc_evalact( act, arg )
# $stderr.puts "ea: act=#{act}"
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg
nerr = 0   # tmp

      if act > 0 and act < shift_n
        #
        # shift
        #

        if @racc_error_status > 0
          @racc_error_status -= 1 unless @racc_t == 1   # error token
        end

        @racc_vstack.push @racc_val
        @racc_state.push act
        @racc_read_next = true

        if @yydebug
          @racc_tstack.push @racc_t
          racc_shift @racc_t, @racc_tstack, @racc_vstack
        end

      elsif act < 0 and act > -reduce_n
        #
        # reduce
        #

        code = catch(:racc_jump) {
            @racc_state.push _racc_do_reduce(arg, act)
            false
        }
        if code
          case code
          when 1 # yyerror
            @racc_user_yyerror = true   # user_yyerror
            return -reduce_n
          when 2 # yyaccept
            return shift_n
          else
            raise RuntimeError, '[Racc Bug] unknown jump code'
          end
        end

      elsif act == shift_n
        #
        # accept
        #

        racc_accept if @yydebug
        throw :racc_end_parse, @racc_vstack[0]

      elsif act == -reduce_n
        #
        # error
        #

        case @racc_error_status
        when 0
          unless arg[21]    # user_yyerror
            nerr += 1
            on_error @racc_t, @racc_val, @racc_vstack
          end
        when 3
          if @racc_t == 0   # is $
            throw :racc_end_parse, nil
          end
          @racc_read_next = true
        end
        @racc_user_yyerror = false
        @racc_error_status = 3

        while true
          if i = action_pointer[@racc_state[-1]]
            i += 1   # error token
            if  i >= 0 and
                (act = action_table[i]) and
                action_check[i] == @racc_state[-1]
              break
            end
          end

          throw :racc_end_parse, nil if @racc_state.size < 2
          @racc_state.pop
          @racc_vstack.pop
          if @yydebug
            @racc_tstack.pop
            racc_e_pop @racc_state, @racc_tstack, @racc_vstack
          end
        end

        return act

      else
        raise RuntimeError, "[Racc Bug] unknown action #{act.inspect}"
      end

      racc_next_state(@racc_state[-1], @racc_state) if @yydebug

      nil
    end

    def _racc_do_reduce( arg, act )
      action_table, action_check, action_default, action_pointer,
      goto_table,   goto_check,   goto_default,   goto_pointer,
      nt_base,      reduce_table, token_table,    shift_n,
      reduce_n,     use_result,   * = arg
      state = @racc_state
      vstack = @racc_vstack
      tstack = @racc_tstack

      i = act * -3
      len       = reduce_table[i]
      reduce_to = reduce_table[i+1]
      method_id = reduce_table[i+2]
      void_array = []

      tmp_t = tstack[-len, len] if @yydebug
      tmp_v = vstack[-len, len]
      tstack[-len, len] = void_array if @yydebug
      vstack[-len, len] = void_array
      state[-len, len]  = void_array

      # tstack must be updated AFTER method call
      if use_result
        vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
      else
        vstack.push __send__(method_id, tmp_v, vstack)
      end
      tstack.push reduce_to

      racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug

      k1 = reduce_to - nt_base
      if i = goto_pointer[k1]
        i += state[-1]
        if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
          return curstate
        end
      end
      goto_default[k1]
    end

    def on_error( t, val, vstack )
      raise ParseError, sprintf("\nparse error on value %s (%s)",
                                val.inspect, token_to_str(t) || '?')
    end

    def yyerror
      throw :racc_jump, 1
    end

    def yyaccept
      throw :racc_jump, 2
    end

    def yyerrok
      @racc_error_status = 0
    end


    # for debugging output

    def racc_read_token( t, tok, val )
      @racc_debug_out.print 'read    '
      @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
      @racc_debug_out.puts val.inspect
      @racc_debug_out.puts
    end

    def racc_shift( tok, tstack, vstack )
      @racc_debug_out.puts "shift   #{racc_token2str tok}"
      racc_print_stacks tstack, vstack
      @racc_debug_out.puts
    end

    def racc_reduce( toks, sim, tstack, vstack )
      out = @racc_debug_out
      out.print 'reduce '
      if toks.empty?
        out.print ' <none>'
      else
        toks.each {|t| out.print ' ', racc_token2str(t) }
      end
      out.puts " --> #{racc_token2str(sim)}"
          
      racc_print_stacks tstack, vstack
      @racc_debug_out.puts
    end

    def racc_accept
      @racc_debug_out.puts 'accept'
      @racc_debug_out.puts
    end

    def racc_e_pop( state, tstack, vstack )
      @racc_debug_out.puts 'error recovering mode: pop token'
      racc_print_states state
      racc_print_stacks tstack, vstack
      @racc_debug_out.puts
    end

    def racc_next_state( curstate, state )
      @racc_debug_out.puts  "goto    #{curstate}"
      racc_print_states state
      @racc_debug_out.puts
    end

    def racc_print_stacks( t, v )
      out = @racc_debug_out
      out.print '        ['
      t.each_index do |i|
        out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
      end
      out.puts ' ]'
    end

    def racc_print_states( s )
      out = @racc_debug_out
      out.print '        ['
      s.each {|st| out.print ' ', st }
      out.puts ' ]'
    end

    def racc_token2str( tok )
      self.class::Racc_token_to_s_table[tok] or
          raise RuntimeError, "[Racc Bug] can't convert token #{tok} to string"
    end

    def token_to_str( t )
      self.class::Racc_token_to_s_table[t]
    end

  end

end
..end /usr/local/lib/ruby/site_ruby/1.8/racc/parser.rb modeval..id4449eb2054
end   # end of racc/parser.rb


self.class.module_eval <<'..end src/emitter.rb modeval..iddd2784be19', 'src/emitter.rb', 1
#												vim:sw=4:ts=4
# $Id: yaml.rb,v 1.2 2003/07/04 09:20:01 ljulliar Exp $
#
# YAML for Ruby:
# - Thanks to Brian Ingerson for YAML.pm
#
# Docs in YAML (see /doc/)
#
require 'pstore'
require 'parsedate'
require 'date'

begin
require 'stringio'
rescue LoadError
    # StringIO based on code by MoonWolf
    class StringIO
        def initialize(string="")
            @string=string
            @pos=0
            @eof=(string.size==0)
        end
        def pos
            @pos
        end    
        def eof
            @eof
        end
        alias eof? eof
        def readline(rs=$/)
            if @eof
                raise EOFError
            else
                if p = @string[@pos..-1]=~rs
                    line = @string[@pos,p+1]
                else
                    line = @string[@pos..-1]
                end
                @pos+=line.size
                @eof =true if @pos==@string.size
                $_ = line
            end
        end
        def rewind
            seek(0,0)
        end
        def seek(offset,whence)
            case whence
            when 0
                @pos=offset
            when 1
                @pos+=offset
            when 2
                @pos=@string.size+offset
            end
            @eof=(@pos>=@string.size)
            0
        end
    end

end


module YAML

	#
	# Constants
	#
	VERSION = '0.49'
	SUPPORTED_YAML_VERSIONS = ['1.0']

	#
	# Parser tokens
	#
	WORD_CHAR = 'A-Za-z0-9'
	PRINTABLE_CHAR = '-_A-Za-z0-9!?/()$\'". ' 
	NOT_PLAIN_CHAR = '\x7f\x0-\x1f\x80-\x9f'
	ESCAPE_CHAR = '[\\x00-\\x08\\x0b-\\x0d\\x0e-\\x1f]'
	INDICATOR_CHAR = '*&!|\\\\^@%{}[]='
	SPACE_INDICATORS = '-#:,?'
	RESTRICTED_INDICATORS = '#:,}]'
	DNS_COMP_RE = "\\w(?:[-\\w]*\\w)?"
	DNS_NAME_RE = "(?:(?:#{DNS_COMP_RE}\\.)+#{DNS_COMP_RE}|#{DNS_COMP_RE})"
	ESCAPES = %w{\z		\x01	\x02	\x03	\x04	\x05	\x06	\a
			     \x08	\t		\n		\v		\f		\r		\x0e	\x0f
				 \x10	\x11	\x12	\x13	\x14	\x15	\x16	\x17
				 \x18	\x19	\x1a	\e		\x1c	\x1d	\x1e	\x1f
			    }
	UNESCAPES = {
				'z' => "\x00", 'a' => "\x07", 'b' => "\x08", 't' => "\x09", 
				'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
				'r' => "\x0d", 'e' => "\x1b", '\\' => '\\',
			    }

	#
	# Encodings ( $-K to ICONV )
	#
	CHARSETS = {
		'NONE' => 'LATIN1',
		'ASCII' => 'US-ASCII',
		'UTF-8' => 'UTF-8',
		'EUC' => 'EUC-JP',
		'SJIS' => 'SHIFT-JIS'
	}

	#
	# Error messages
	#
	ERROR_NO_HEADER_NODE = "With UseHeader=false, the node Array or Hash must have elements"
	ERROR_NEED_HEADER = "With UseHeader=false, the node must be an Array or Hash"
	ERROR_BAD_EXPLICIT = "Unsupported explicit transfer: '%s'"
    ERROR_MANY_EXPLICIT = "More than one explicit transfer"
	ERROR_MANY_IMPLICIT = "More than one implicit request"
	ERROR_NO_ANCHOR = "No anchor for alias '%s'"
	ERROR_BAD_ANCHOR = "Invalid anchor: %s"
	ERROR_MANY_ANCHOR = "More than one anchor"
	ERROR_ANCHOR_ALIAS = "Can't define both an anchor and an alias"
	ERROR_BAD_ALIAS = "Invalid alias: %s"
	ERROR_MANY_ALIAS = "More than one alias"
	ERROR_ZERO_INDENT = "Can't use zero as an indentation width"
	ERROR_UNSUPPORTED_VERSION = "This release of YAML.rb does not support YAML version %s"
	ERROR_UNSUPPORTED_ENCODING = "Attempt to use unsupported encoding: %s"

	#
	# Default settings
	#
	DEFAULTS = {
		:Indent => 2, :UseHeader => false, :UseVersion => false, :Version => '1.0',
		:SortKeys => false, :AnchorFormat => 'id%03d', :ExplicitTypes => false,
		:WidthType => 'absolute', :BestWidth => 80,
		:UseBlock => false, :UseFold => false, :Encoding => :None
	}
	TRANSFER_DOMAINS = {
		'yaml.org,2002' => {},
		'ruby.yaml.org,2002' => {}
	}
	PRIVATE_TYPES = {}
	IMPLICIT_TYPES = [ 'null', 'bool', 'time', 'int', 'float' ]

    def YAML.object_maker( obj_class, val )
        if Hash === val
            o = obj_class.new_without_initialize
            val.each_pair { |k,v|
                o.instance_eval "@#{k} = v"
            }
            o
        else
            raise YAML::Error, "Invalid object explicitly tagged !ruby/Object: " + val.inspect
        end
    end

	#
	# YAML documents can be in UTF-8, UTF-16 or UTF-32
	# So let's read and write in Unicode
	#
    @@unicode = false
	begin
		require 'iconv'
		DEFAULTS[:Encoding] = :Utf8
	rescue LoadError
	end

    def YAML.unicode; @@unicode; end
    def YAML.unicode=( bool ); @@unicode = bool; end

	#
	# YAML Error class
	#
	class Error < StandardError; end
	class ParseError < Error; end

    #
    # YAML Generic Model container
    #
    class YamlNode
        attr_accessor :kind, :type_id, :value, :anchor
        def initialize( t, v )
            @type_id = t
            if Hash === v
                @kind = 'map'
                @value = {}
                v.each { |k,v|
                    @value[ k.transform ] = [ k, v ]
                }
            elsif Array === v
                @kind = 'seq'
                @value = v
            elsif String === v
                @kind = 'scalar'
                @value = v
            end
        end

        #
        # Search for YPath entry and return
        # qualified nodes.
        #
        def select( ypath_str )
            matches = match_path( ypath_str )

            #
            # Create a new generic view of the elements selected
            #
            if matches
                result = []
                matches.each { |m|
                    result.push m.last
                }
                YamlNode.new( 'seq', result )
            end
        end

        #
        # Search for YPath entry and return a list of
        # qualified paths.
        #
        def search( ypath_str )
            matches = match_path( ypath_str )

            if matches
                matches.collect { |m|
                    path = []
                    m.each_index { |i|
                        path.push m[i] if ( i % 2 ).zero?
                    }
                    "/" + path.compact.join( "/" )
                }
            end
        end

        def at( seg )
            if Hash === @value and @value.has_key?( seg )
                @value[seg][1]
            elsif Array === @value and seg =~ /\A\d+\Z/ and @value[seg.to_i]
                @value[seg.to_i]
            end
        end

        #
        # YPath search returning a complete depth array
        #
        def match_path( ypath_str )
            depth = 0
            matches = []
            YPath.each_path( ypath_str ) do |ypath|
                seg = match_segment( ypath, 0 )
                matches += seg if seg
            end
            matches.uniq
        end

        #
        # Search a node for a single YPath segment
        #
        def match_segment( ypath, depth )
            deep_nodes = []
            seg = ypath.segments[ depth ]
            if seg == "/"
                unless String === @value
                    idx = -1
                    @value.collect { |v|
                        idx += 1
                        if Hash === @value
                            match_init = [v[0], v[1][1]]
                            match_deep = v[1][1].match_segment( ypath, depth )
                        else
                            match_init = [idx, v]
                            match_deep = v.match_segment( ypath, depth )
                        end
                        if match_deep
                            match_deep.each { |m|
                                deep_nodes.push( match_init + m )
                            }
                        end
                    }
                end
                depth += 1
                seg = ypath.segments[ depth ]
            end
            match_nodes =
                case seg
                when "."
                    [[nil, self]]
                when ".."
                    [["..", nil]]
                when "*"
                    unless String === @value
                        idx = -1
                        @value.collect { |h|
                            idx += 1
                            if Hash === @value
                                [h[0], h[1][1]]
                            else
                                [idx, h]
                            end
                        }
                    end
                else
                    if seg =~ /^"(.*)"$/
                        seg = $1
                    elsif seg =~ /^'(.*)'$/
                        seg = $1
                    end
                    if ( v = at( seg ) )
                        [[ seg, v ]]
                    end
                end
            return deep_nodes unless match_nodes
            pred = ypath.predicates[ depth ]
            if pred
                case pred
                when /^\.=/
                    pred = $' #'
                    match_nodes.reject! { |n|
                        n.last.value != pred
                    }
                else
                    match_nodes.reject! { |n|
                        n.last.at( pred ).nil?
                    }
                end
            end
            return match_nodes + deep_nodes unless ypath.segments.length > depth + 1

            #puts "DEPTH: #{depth + 1}"
            deep_nodes = []
            match_nodes.each { |n|
                if n[1].is_a? YamlNode
                    match_deep = n[1].match_segment( ypath, depth + 1 )
                    if match_deep
                        match_deep.each { |m|
                            deep_nodes.push( n + m )
                        }
                    end
                else
                    deep_nodes = []
                end
            }
            deep_nodes = nil if deep_nodes.length == 0
            deep_nodes
        end

        #
        # Transform this node fully into a native type
        #
        def transform
            t = nil
            if @value.is_a? Hash
                t = {}
                @value.each { |k,v|
                    t[ k ] = v[1].transform
                }
            elsif @value.is_a? Array
                t = []
                @value.each { |v|
                    t.push v.transform
                }
            else
                t = @value
            end
            YAML.transfer_method( @type_id, t )
        end

        #
        # We want the node to act like as Hash
        # if it is.
        #
        def []( *k )
            if Hash === @value
                v = @value.[]( *k )
                v[1] if v
            elsif Array === @value
                @value.[]( *k )
            end
        end

        def children
            if Hash === @value
                @value.values.collect { |c| c[1] }
            elsif Array === @value
                @value
            end
        end

        def children_with_index
            if Hash === @value
                @value.keys.collect { |i| [self[i], i] }
            elsif Array === @value
                i = -1; @value.collect { |v| i += 1; [v, i] }
            end
        end

        def emit
            transform.to_yaml
        end
    end

    class YPath
        attr_accessor :segments, :predicates, :flags
        def initialize( str )
            @segments = []
            @predicates = []
            @flags = nil
            while str =~ /^\/?(\/|[^\/\[]+)(?:\[([^\]]+)\])?/
                @segments.push $1
                @predicates.push $2
                str = $'
            end
            unless str.to_s.empty?
                @segments += str.split( "/" )
            end
            if @segments.length == 0
                @segments.push "."
            end
        end
        def YPath.each_path( str )
            #
            # Find choices
            #
            paths = []
            str = "(#{ str })"
            while str.sub!( /\(([^()]+)\)/, "\n#{ paths.length }\n" )
                paths.push $1.split( '|' )
            end

            #
            # Construct all possible paths
            #
            all = [ str ]
            ( paths.length - 1 ).downto( 0 ) do |i|
                all = all.collect do |a|
                    paths[i].collect do |p|
                        a.gsub( /\n#{ i }\n/, p )
                    end
                end.flatten.uniq
            end
            all.collect do |path|
                yield YPath.new( path )
            end
        end
    end

	#
	# Class method for creating streams
	#
	def YAML.make_stream( io )
        if String === io
            io = StringIO.new( io )
        elsif not IO === io
            raise YAML::Error, "YAML stream must be an IO or String object."
        end
        if YAML::unicode
            def io.readline
                YAML.utf_to_internal( readline( @ln_sep ), @utf_encoding )
            end
            def io.check_unicode
                @utf_encoding = YAML.sniff_encoding( read( 4 ) )
                @ln_sep = YAML.enc_separator( @utf_encoding )
                seek( -4, IO::SEEK_CUR )
            end
		    def io.utf_encoding
		    	@utf_encoding
		    end
            io.check_unicode
        else
            def io.utf_encoding
                :None
            end
        end
        io
	end

	#
	# Unicode conversion
	#
	def YAML.utf_to_internal( str, from_enc )
		return unless str
		to_enc = CHARSETS[$-K]
		case from_enc
			when :Utf32
				Iconv.iconv( to_enc, 'UTF-32', str )[0]
			when :Utf16
				Iconv.iconv( to_enc, 'UTF-16', str )[0]
			when :Utf8
				Iconv.iconv( to_enc, 'UTF-8', str )[0]
			when :None
				str
			else
				raise YAML::Error, ERROR_UNSUPPORTED_ENCODING % from_enc.inspect
		end
	end

	def YAML.internal_to_utf( str, to_enc )
		return unless str
		from_enc = CHARSETS[$-K]
		case to_enc
			when :Utf32
				Iconv.iconv( 'UTF-32', from_enc, str )[0]
			when :Utf16                        
				Iconv.iconv( 'UTF-16', from_enc, str )[0]
			when :Utf8                         
				Iconv.iconv( 'UTF-8', from_enc, str )[0]
			when :None
				str
			else
				raise YAML::Error, ERROR_UNSUPPORTED_ENCODING % to_enc.inspect
		end
	end

	def YAML.sniff_encoding( str )
		unless YAML::unicode
			:None
		else
			case str
				when /^\x00\x00\xFE\xFF/	# UTF-32
					:Utf32
				when /^\xFE\xFF/	# UTF-32BE
					:Utf16
				else
					:Utf8
			end
		end
	end

	def YAML.enc_separator( enc )
		case enc
			when :Utf32
				"\000\000\000\n"
			when :Utf16
				"\000\n"
			when :Utf8
				"\n"
			when :None
				"\n"
			else
				raise YAML::Error, ERROR_UNSUPPORTED_ENCODING % enc.inspect
		end
	end

	#
	# Output methods
	#

	#
	# Emit a set of values
	#
	class Emitter
		attr_accessor :options
		def initialize( opts )
			opts = {} if opts.class != Hash
			@options = YAML::DEFAULTS.dup.update( opts )
            @headless = 0
            @seq_map = false
            @anchors = {}
            @anchor_extras = {}
            @active_anchors = []
            @level = -1
            self.clear
		end

		def clear
			@buffer = []
		end

		#
		# Version string
		#
		def version_s
			" %YAML:#{@options[:Version]}" if @options[:UseVersion]
		end

		#
		# Header
		#
		def header
            if @headless.nonzero?
                ""
            else
                "---#{version_s} "
            end
		end

        #
        # Emit binary data
        #
        def binary_base64( value )
            self << "!binary "
            self.node_text( [value].pack("m"), '|' )
        end

		#
		# Emit plain, normal flowing text
		#
		def node_text( value, block = '>' )
			valx = value.dup
			if @options[:UseBlock]
				block = '|'
			elsif not @options[:UseFold] and valx =~ /\n[ \t]/ and not valx =~ /#{YAML::ESCAPE_CHAR}/
				block = '|'
			end 
			str = block.dup
			if valx =~ /\n\Z\n/
				str << "+"
			elsif valx =~ /\Z\n/
			else
				str << "-"
			end
			if valx =~ /#{YAML::ESCAPE_CHAR}/
				valx = YAML::escape( valx )
			end
			if valx =~ /\A[ \t#]/
				str << @options[:Indent].to_s
			end
			if block == '>'
				valx = fold( valx ) 
			end
			self << str + indent_text( valx ) + "\n"
		end

		#
		# Emit a simple, unqouted string
		#
		def simple( value )
            self << value.to_s
		end

		#
		# Emit double-quoted string
		#
		def double( value )
			"\"#{YAML.escape( value )}\"" 
		end

		#
		# Emit single-quoted string
		#
		def single( value )
			"'#{value}'"
		end

		#
		# Write a text block with the current indent
		#
		def indent_text( text )
			return "" if text.to_s.empty?
            spacing = " " * ( @level * @options[:Indent] )
			return "\n" + text.gsub( /^([^\n])/, "#{spacing}\\1" )
		end

		#
		# Write a current indent
		#
		def indent
            #p [ self.id, @level, :INDENT ]
			return " " * ( @level * @options[:Indent] )
		end

		#
		# Add indent to the buffer
		#
		def indent!
			self << indent
		end

		#
		# Folding paragraphs within a column
		#
		def fold( value )
			value.gsub!( /\A\n+/, '' )
			folded = $&.to_s
			width = (0..@options[:BestWidth])
			while not value.empty?
				last = value.index( /(\n+)/ )
				chop_s = false
				if width.include?( last )
					last += $1.length - 1
				elsif width.include?( value.length )
					last = value.length
				else
					last = value.rindex( /[ \t]/, @options[:BestWidth] )
					chop_s = true
				end
				folded += value.slice!( 0, width.include?( last ) ? last + 1 : @options[:BestWidth] )
				folded.chop! if chop_s
				folded += "\n" unless value.empty?
			end
			folded
		end

        #
        # Quick mapping
        #
        def map( type, &e )
            val = Mapping.new
            e.call( val )
			self << "#{type} " if type.length.nonzero?

			#
			# Empty hashes
			#
			if val.length.zero?
				self << "{}"
			else
                if @buffer.length == 1 and @options[:UseHeader] == false and type.length.zero? 
			        @headless = 1 
                end

                defkey = @options.delete( :DefaultKey )
                if defkey
                    seq_map_shortcut
                    self << "= : "
                    defkey.to_yaml( :Emitter => self )
                end

				#
				# Emit the key and value
				#
                val.each { |v|
                    seq_map_shortcut
                    if v[0].is_complex_yaml?
                        self << "? "
                    end
                    v[0].to_yaml( :Emitter => self )
                    if v[0].is_complex_yaml?
                        self << "\n"
                        indent!
                    end
                    self << ": " 
                    v[1].to_yaml( :Emitter => self )
                }
			end
        end

        def seq_map_shortcut
            if @seq_map
                @anchor_extras[@buffer.length - 1] = "\n" + indent
                @seq_map = false
            else
                self << "\n"
                indent! 
            end
        end

        #
        # Quick sequence
        #
        def seq( type, &e )
            val = Sequence.new
            e.call( val )
			self << "#{type} " if type.length.nonzero?

			#
			# Empty arrays
			#
			if val.length.zero?
				self << "[]"
			else
                if @buffer.length == 1 and @options[:UseHeader] == false and type.length.zero? 
			        @headless = 1 
                end
				#
				# Emit the key and value
				#
                val.each { |v|
                    self << "\n"
                    indent!
                    self << "- "
                    @seq_map = true if v.class == Hash
                    v.to_yaml( :Emitter => self )
                }
			end
        end

		#
		# Concatenate to the buffer
		#
		def <<( str )
            #p [ self.id, @level, str ]
			@buffer.last << str
		end

        #
        # Monitor objects and allow references
        #
        def start_object( oid )
		    @level += 1
            @buffer.push( "" )
            #p [ self.id, @level, :OPEN ]
            idx = nil
            if oid
                if @anchors.has_key?( oid )
                    idx = @active_anchors.index( oid )
                    unless idx
                        idx = @active_anchors.length
                        af_str = "&#{@options[:AnchorFormat]} " % [ idx + 1 ]
                        af_str += @anchor_extras[ @anchors[ oid ] ].to_s
                        @buffer[ @anchors[ oid ] ][0,0] = af_str
					    @headless = 0 if @anchors[ oid ].zero?
                    end
                    idx += 1
                    @active_anchors.push( oid )
                else
                    @anchors[ oid ] = @buffer.length - 1
                end
            end
            return idx
        end

		#
		# Output method
		#
		def end_object
		    @level -= 1
            @buffer.push( "" )
            #p [ self.id, @level, :END ]
			if @level < 0
				YAML.internal_to_utf( header + @buffer.to_s[@headless..-1], @options[:Encoding] )
			end
		end
	end

    #
    # Emitter helper classes
    #
    class Mapping < Array
        def add( k, v )
            push [k, v]
        end
    end

    class Sequence < Array
        def add( v )
            push v
        end
    end

	#
	# Input methods
	#

	#
	# Load a single document from the current stream
	#
	def YAML.load( io )
		yp = YAML::Parser.new.parse( io )
	end

	#
	# Parse a single document from the current stream
	#
	def YAML.parse( io )
		yp = YAML::Parser.new( :Model => :Generic ).parse( io )
	end

	#
	# Load all documents from the current stream
	#
	def YAML.each_document( io, &doc_proc )
		yp = YAML::Parser.new.parse_documents( io, &doc_proc )
    end

	#
	# Identical to each_document
	#
	def YAML.load_documents( io, &doc_proc )
		YAML.each_document( io, &doc_proc )
    end

	#
	# Parse all documents from the current stream
	#
	def YAML.each_node( io, &doc_proc )
		yp = YAML::Parser.new( :Model => :Generic ).parse_documents( io, &doc_proc )
    end

	#
	# Parse all documents from the current stream
	#
	def YAML.parse_documents( io, &doc_proc )
		YAML.each_node( io, &doc_proc )
    end

	#
	# Load all documents from the current stream
	#
	def YAML.load_stream( io )
		yp = YAML::Parser.new
		d = nil
		yp.parse_documents( io ) { |doc|
			d = YAML::Stream.new( yp.options ) if not d
			d.add( doc ) 
		}
		return d
	end

	#
	# Racc parser will go here
	#
	# class Parser; def initialize; raise YAML::Error, "No parser available"; end; end

	#
	# Add a transfer method to a domain
	#
	def YAML.add_domain_type( domain, type_re, &transfer_proc )
		type_re = /^#{Regexp::quote( type_re )}$/ if type_re.class == String
		if not YAML::TRANSFER_DOMAINS.has_key?( domain )
			YAML::TRANSFER_DOMAINS[ domain ] = {}
		end
		YAML::TRANSFER_DOMAINS[ domain ][ type_re ] = transfer_proc
	end

	#
	# Add a transfer method for a builtin type
	#
	def YAML.add_builtin_type( type_re, &transfer_proc )
		type_re = /^#{Regexp::quote( type_re )}$/ if type_re.class == String
		YAML::TRANSFER_DOMAINS[ 'yaml.org,2002' ][ type_re ] = transfer_proc
	end

	#
	# Add a transfer method for a builtin type
	#
	def YAML.add_ruby_type( type, &transfer_proc )
		type_re = /^#{Regexp::quote( type.to_s )}(?::.+)?$/i
		YAML::TRANSFER_DOMAINS[ 'ruby.yaml.org,2002' ][ type_re ] = transfer_proc
	end

	#
	# Add a private document type
	#
	def YAML.add_private_type( type_re, &transfer_proc )
		type_re = /^#{Regexp::quote( type_re )}$/ if type_re.class == String
		YAML::PRIVATE_TYPES[ type_re ] = transfer_proc
	end

    #
    # Method to extract colon-seperated type and class, returning
    # the type and the constant of the class
    #
    def YAML.read_type_class( type, obj_class )
        type =~ /^([^:]+):(.+)/i
        if $2
            type = $1
            $2.split( "::" ).each { |c|
                obj_class = obj_class.const_get( c )
            }
        end
        return [ type, obj_class ]
    end

	#
	# Default private type
	#
	class PrivateType
		attr_accessor :type_id, :value
		def initialize( type, val )
			@type_id = type; @value = val
		end
		def to_yaml( opts = {} )
			YAML::quick_emit( self.id, opts ) { |out|
				out << " !!#{@type_id}"
				value.to_yaml( :Emitter => out )
			}
		end
	end

    #
    # Default domain type
    #
    class DomainType
		attr_accessor :domain, :type_id, :value
		def initialize( domain, type, val )
			@domain = domain; @type_id = type; @value = val
		end
        def to_yaml_type
            dom = @domain.dup
            if dom =~ /\.yaml\.org,2002$/
                dom = $`
            end
            "#{dom}/#{@type_id}"
        end
		def to_yaml( opts = {} )
			YAML::quick_emit( self.id, opts ) { |out|
				out << " !#{to_yaml_type} "
				value.to_yaml( :Emitter => out )
			}
		end
	end

	#
	# Utility functions
	#

    #
    # Handle all transfer methods
    # http://www.yaml.org/spec/#syntax-trans
    #
    def YAML.transfer_method( type, val )
        domain = "yaml.org,2002"

        #
        # Figure out the domain
        #
        if type =~ /^(\w+)\/(.+)$/
            domain = "#{$1}.yaml.org,2002"; type = $2
        elsif type =~ /^(#{DNS_NAME_RE},\d{4}(?:-\d{2}){0,2})\/(.+)$/
            domain = $1; type = $2
        end

        #
        # Route the data, transfer it
        #
        begin
            r = nil
            if type == ""
                YAML.try_implicit( val )
            elsif type =~ /^!(.*)/
                type = $1
                if YAML::PRIVATE_TYPES.keys.detect { |r| type =~ r }
                    YAML::PRIVATE_TYPES[r].call( type, val )
                else
                    YAML::PrivateType.new( type, val )
                end
            else
                type = YAML.escape( type )
                if YAML::TRANSFER_DOMAINS.has_key?( domain ) and
                    YAML::TRANSFER_DOMAINS[domain].keys.detect { |r| type =~ r } 
                    YAML::TRANSFER_DOMAINS[domain][r].call( type, val )
                else
                        YAML::DomainType.new( domain, type, val )
                end
            end
        end
    end

	#
	# Try a string against all implicit YAML types
	# http://www.yaml.org/spec/#trans
	#
	def YAML.detect_implicit( str )
        r = nil
        YAML::IMPLICIT_TYPES.each { |type|
            if YAML::TRANSFER_DOMAINS['yaml.org,2002'].keys.detect { |r| type =~ r } 
                val = YAML::TRANSFER_DOMAINS['yaml.org,2002'][r].call( :Implicit, str )
                return type unless Symbol === val and val == :InvalidType
            end
        }
        return 'str'
	end

    #
    # Uses the implicit if found
    #
    def YAML.try_implicit( str )
        type = YAML.detect_implicit( str )
        YAML.transfer_method( type, str )
    end

	#
	# Make a time with the time zone
	#
	def YAML.mktime( year, mon, day, hour, min, sec, usec, zone = "Z" )
        usec = usec.to_s.to_f * 1000000
		val = Time::utc( year.to_i, mon.to_i, day.to_i, hour.to_i, min.to_i, sec.to_i, usec )
		if zone != "Z"
			hour = zone[0,3].to_i * 3600
			min = zone[3,2].to_i * 60
			ofs = (hour + min)
			val = Time.at( val.to_f - ofs )
		end
		return val
	end

	#
	# Retrieve plain scalar regexp
	#
	def YAML.plain_re( allow = '' )
		space_set = ''
		restrict_set = RESTRICTED_INDICATORS.delete( allow )
		restrict_set.split( // ).each { |ind|
			if ind == "#"
				space_set << "[^#\\s]#+|#+[^#\\s]|"
			elsif SPACE_INDICATORS.include?( ind )
				ind = Regexp::quote( ind )
				space_set << "#{ind}+[^#{ind}\\s]|"
			end
		} 
		/\A([^#{NOT_PLAIN_CHAR}#{Regexp::quote(INDICATOR_CHAR)}](?:#{space_set}[^#{NOT_PLAIN_CHAR}#{Regexp::quote(restrict_set)}])*)/
	end

	#
	# Escape the string, condensing common escapes
	#
	def YAML.escape( value )
		value.gsub( /\\/, "\\\\\\" ).gsub( /"/, "\\\"" ).gsub( /([\x00-\x1f])/ ) { |x| ESCAPES[ x.unpack("C")[0] ] }
	end

	#
	# Unescape the condenses escapes
	#
	def YAML.unescape( value )
		value.gsub( /\\(?:([nevbr\\fartz])|0?x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/ ) { |x| 
			if $3
				["#$3".hex ].pack('U*')
			elsif $2
				[$2].pack( "H2" ) 
			else
				UNESCAPES[$1] 
			end
		}
	end

	#
	# YAML::Stream -- for emitting many documents
	#
	class Stream

		attr_accessor :documents, :options

		def initialize( opts = {} )
			@options = opts
			@documents = []
		end
		
        def []( i )
            @documents[ i ]
        end

		def add( doc )
			@documents << doc
		end

		def edit( doc_num, doc )
			@documents[ doc_num ] = doc
		end

		def emit
            opts = @options.dup
			opts[:UseHeader] = true if @documents.length > 1
			ct = 0
            out = Emitter.new( opts )
            @documents.each { |v|
                if ct > 0
                    out << "\n--- " 
                end
                v.to_yaml( :Emitter => out )
                ct += 1
            }
            out.end_object
		end

	end

	#
	# Allocate an Emitter if needed
	#
	def YAML.quick_emit( oid, opts = {}, &e )
		old_opt = nil
		if opts[:Emitter].is_a? YAML::Emitter
			out = opts.delete( :Emitter )
			old_opt = out.options.dup
			out.options.update( opts )
		else
			out = YAML::Emitter.new( opts )
		end
        aidx = out.start_object( oid )
        if aidx
            out.simple( "*#{out.options[:AnchorFormat]} " % [ aidx ] )
        else
            e.call( out )
        end
		if old_opt.is_a? Hash
			out.options = old_opt
		end 
		out.end_object
	end
	
	#
	# YAML::Store -- Pstore replacement
	#
	class Store < PStore
		#
		# Constructor
		# 
		def initialize( *o )
			@opt = YAML::DEFAULTS.dup
            if String === o.first
                super(o.pop)
            end
            if o.last.is_a? Hash
                @opt.update(o.pop)
            end
        end

		#
		# Override Pstore#transaction
		#
		def transaction
			raise YAML::Error, "nested transaction" if @transaction
			raise YAML::Error, "no filename for transaction" unless @filename
			begin
				@transaction = true
				value = nil
				backup = @filename+"~"
				if File::exist?(@filename)
					file = File::open(@filename, "rb+")
					orig = true
				else
					@table = {}
					file = File::open(@filename, "wb+")
					file.write( @table.to_yaml( @opt ) )
				end
				file.flock(File::LOCK_EX)
				if orig
					File::copy @filename, backup
					@table = YAML::load( file )
				end
				begin
					catch(:pstore_abort_transaction) do
						value = yield(self)
					end
				rescue Exception
					@abort = true
					raise
				ensure
					unless @abort
						begin
							file.rewind
							file.write( @table.to_yaml( @opt ) )
							file.truncate(file.pos)
						rescue
							File::rename backup, @filename if File::exist?(backup)
							raise
						end
					end
					@abort = false
				end
			ensure
				@table = nil
				@transaction = false
				file.close if file
			end
			value
		end
	end

	#
	# YAML Hash class to support comments and defaults
	#
	class SpecialHash < Hash 
		attr_accessor :default
        def inspect
            self.default.to_s
        end
		def to_s
			self.default.to_s
		end
		def update( h )
			if YAML::SpecialHash === h
				@default = h.default if h.default
			end
			super( h )
		end
        def to_yaml( opts = {} )
            opts[:DefaultKey] = self.default
            super( opts )
        end
	end

    #
    # Builtin collection: !omap
    #
    class Omap < Array
        def self.[]( *vals )
            o = Omap.new
            0.step( vals.length - 1, 2 ) { |i|
                o[vals[i]] = vals[i+1]
            }
            o
        end
        def []( k )
            self.assoc( k ).to_a[1]
        end
        def []=( k, *rest )
            val, set = rest.reverse
            if ( tmp = self.assoc( k ) ) and not set
                tmp[1] = val
            else
                self << [ k, val ] 
            end
            val
        end
        def has_key?( k )
            self.assoc( k ) ? true : false
        end
        def is_complex_yaml?
            true
        end
        def to_yaml( opts = {} )
            YAML::quick_emit( self.id, opts ) { |out|
                out.seq( "!omap" ) { |seq|
                    self.each { |v|
                        seq.add( Hash[ *v ] )
                    }
                }
            }
        end
    end

    YAML.add_builtin_type( "omap" ) { |type, val|
        if Array === val
            p = Omap.new
            val.each { |v|
                if Hash === v
                    p.concat( v.to_a )		# Convert the map to a sequence
                else
                    raise YAML::Error, "Invalid !omap entry: " + val.inspect
                end
            }
        else
            raise YAML::Error, "Invalid !omap: " + val.inspect
        end
        p
    }

    #
    # Builtin collection: !pairs
    #
    class Pairs < Array
        def self.[]( *vals )
            p = Pairs.new
            0.step( vals.length - 1, 2 ) { |i|
                p[vals[i]] = vals[i+1]
            }
            p
        end
        def []( k )
            self.assoc( k ).to_a
        end
        def []=( k, val )
            self << [ k, val ] 
            val
        end
        def has_key?( k )
            self.assoc( k ) ? true : false
        end
        def is_complex_yaml?
            true
        end
        def to_yaml( opts = {} )
            YAML::quick_emit( self.id, opts ) { |out|
                out.seq( "!pairs" ) { |seq|
                    self.each { |v|
                        seq.add( Hash[ *v ] )
                    }
                }
            }
        end
    end

    YAML.add_builtin_type( "pairs" ) { |type, val|
        if Array === val
            p = Pairs.new
            val.each { |v|
                if Hash === v
                    p.concat( v.to_a )		# Convert the map to a sequence
                else
                    raise YAML::Error, "Invalid !pairs entry: " + val.inspect
                end
            }
        else
            raise YAML::Error, "Invalid !pairs: " + val.inspect
        end
        p
    }

    #
    # Builtin collection: !set
    #
    class Set < Hash
        def to_yaml_type
            "!set"
        end
    end

    YAML.add_builtin_type( 'set' ) { |type, val|
        if Array === val
            val = Set[ *val ]
        elsif Hash === val
            Set[ val ]
        else
            raise YAML::Error, "Invalid map explicitly tagged !map: " + val.inspect
        end
        val
    }

    #
    # Ruby-specific collection: !ruby/flexhash
    #
    class FlexHash < Array
        def []( k )
            self.assoc( k ).to_a[1]
        end
        def []=( k, *rest )
            val, set = rest.reverse
            if ( tmp = self.assoc( k ) ) and not set
                tmp[1] = val
            else
                self << [ k, val ] 
            end
            val
        end
        def has_key?( k )
            self.assoc( k ) ? true : false
        end
        def is_complex_yaml?
            true
        end
        def to_yaml( opts = {} )
            YAML::quick_emit( self.id, opts ) { |out|
                out.seq( "!ruby/flexhash" ) { |seq|
                    self.each { |v|
                        if v[1]
                            seq.add( Hash.[]( *v ) )
                        else
                            seq.add( v[0] )
                        end
                    }
                }
            }
        end
    end

    YAML.add_ruby_type( :flexhash ) { |type, val|
        if Array === val
            p = FlexHash.new
            val.each { |v|
                if Hash === v
                    p.concat( v.to_a )		# Convert the map to a sequence
                else
                    p << [ v, nil ]
                end
            }
            p
        else
            raise YAML::Error, "Invalid !ruby/flexhash: " + val.inspect
        end
    }

end

#
# Type conversions
#
class Object
    def is_complex_yaml?
        true
    end
    def to_yaml_type
        "!ruby/object:#{self.class}"
    end
    def to_yaml_properties
        instance_variables.sort
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( self.id, opts ) { |out|
            out.map( self.to_yaml_type ) { |map|
				to_yaml_properties.each { |m|
                    map.add( m[1..-1], instance_eval( m ) )
                }
            }
		}
	end
end

class Class
	def new_without_initialize( *args )
		self.class_eval %{
			alias :old_initialize_with_args :initialize
			def initialize( *args ); end
		}
		begin
			result = self.new( *args )
		ensure
			self.class_eval %{
				alias :initialize :old_initialize_with_args
			}
		end
		result
	end
end

YAML.add_ruby_type( Object ) { |type, val|
    type, obj_class = YAML.read_type_class( type, Object )
    YAML.object_maker( obj_class, val )
}

#
# Maps: Hash#to_yaml
#
class Hash
    def is_complex_yaml?
        true
    end
    def to_yaml_type
        if self.class == Hash or self.class == YAML::SpecialHash
            "!map"
        else
            "!ruby/hash:#{self.class}"
        end
    end
	def to_yaml( opts = {} )
		opts[:DocType] = self.class if Hash === opts
		YAML::quick_emit( self.id, opts ) { |out|
            hash_type = to_yaml_type
            if not out.options[:ExplicitTypes] and hash_type == "!map"
                hash_type = ""
            end
            out.map( hash_type ) { |map|
				#
				# Sort the hash
				#
                if out.options[:SortKeys]
				    map.concat( self.sort )
                else
                    map.concat( self.to_a )
                end
            }
		}
	end
end

hash_proc = Proc.new { |type, val|
	if Array === val
 		val = Hash.[]( *val )		# Convert the map to a sequence
	elsif Hash === val
	    type, obj_class = YAML.read_type_class( type, Hash )
        if obj_class != Hash
            o = obj_class.new
            o.update( val )
            val = o
        end
    else
 		raise YAML::Error, "Invalid map explicitly tagged !map: " + val.inspect
	end
	val
}
YAML.add_builtin_type( /^map/, &hash_proc )
YAML.add_ruby_type( Hash, &hash_proc ) 

#
# Structs: export as a !map
#
class Struct
    def is_complex_yaml?
        true
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( self.id, opts ) { |out|
			#
			# Basic struct is passed as a YAML map
			#
			struct_name = self.class.name.gsub( "Struct:", "" )
            out.map( "!ruby/struct#{struct_name}" ) { |map|
				self.members.each { |m|
                    map.add( m, self[m] )
				}
			}
		}
	end
end

YAML.add_ruby_type( Struct ) { |type, val|
	type =~ /^struct:(\w+)/
	if Hash === val
		type = $1
		struct_type = nil
		struct_def = []
		struct_name = ""
		if $1.to_s.length > 1
			struct_name = $1[0..$1.length]
			struct_def << struct_name
		end

		#
		# Use existing Struct if it exists
		#
		begin
			struct_type = Struct.const_get( struct_name )
		rescue NameError
		end
		if not struct_type
			struct_type = Struct.new( *struct_def.concat( val.keys.collect { |k| k.intern } ) ) 
		end

		#
		# Set the Struct properties
		#
		st = struct_type.new
		st.members.each { |m|
			st.send( "#{m}=", val[m] )
		}
		st
	else
		raise YAML::Error, "Invalid Ruby Struct: " + val.inspect
	end
}

#
# Sequences: Array#to_yaml
#
class Array
    def is_complex_yaml?
        true
    end
    def to_yaml_type
        if self.class == Array 
            "!seq"
        else
            "!ruby/array:#{self.class}"
        end
    end
	def to_yaml( opts = {} )
		opts[:DocType] = self.class if Hash === opts
		YAML::quick_emit( self.id, opts ) { |out|
            array_type = to_yaml_type 
            if not out.options[:ExplicitTypes] and array_type == "!seq"
                array_type = ""
            end
			
            out.seq( array_type ) { |seq|
                seq.concat( self )
            }
		}
	end
end

array_proc = Proc.new { |type, val|
    if Array === val
        type, obj_class = YAML.read_type_class( type, Array )
        if obj_class != Array
            o = obj_class.new
            o.concat( val )
            val = o
        end
        val
    else
        val.to_a
    end
}
YAML.add_builtin_type( /^seq/, &array_proc )
YAML.add_ruby_type( Array, &array_proc ) 

#
# String#to_yaml
#
class String
    def is_complex_yaml?
        ( self =~ /\n.+/ ? true : false )
    end
    def is_binary_data?
        ( self.count( "^ -~", "^\r\n" ) / self.size > 0.3 || self.count( "\x00" ) > 0 )
    end
	def to_yaml( opts = {} )
        complex = false
        if self.is_complex_yaml?
            complex = true
        elsif opts[:BestWidth].to_i > 0
            if self.length > opts[:BestWidth] and opts[:UseFold]
                complex = true
            end
        end
		YAML::quick_emit( complex ? self.id : nil, opts ) { |out|
            if complex
                if self.is_binary_data?
                    out.binary_base64( self )
                else
                    out.node_text( self )
                end
            else
                ostr = 	if out.options[:KeepValue]
                            self
                        elsif empty?
                            "''"
                        elsif YAML.detect_implicit( self ) != 'str'
                            "\"#{YAML.escape( self )}\"" 
                        elsif self =~ /#{YAML::ESCAPE_CHAR}|[#{YAML::SPACE_INDICATORS}] |\n|\'/
                            "\"#{YAML.escape( self )}\"" 
                        elsif self =~ /^[^#{YAML::WORD_CHAR}]/
                            "\"#{YAML.escape( self )}\"" 
                        else
                            self
                        end
                out.simple( ostr )
            end
		}
	end
end

YAML.add_builtin_type( 'str' ) { |type,val| val.to_s }
YAML.add_builtin_type( 'binary' ) { |type,val|
	enctype = "m"
	if String === val
		val.gsub( /\s+/, '' ).unpack( enctype )[0]
	else
		raise YAML::Error, "Binary data must be represented by a string: " + val.inspect
	end
}

#
# Symbol#to_yaml
#
class Symbol
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( nil, opts ) { |out|
			out << "!ruby/sym "
			self.id2name.to_yaml( :Emitter => out )
		}
	end
end

symbol_proc = Proc.new { |type, val|
	if String === val
		val.intern
	else
		raise YAML::Error, "Invalid Symbol: " + val.inspect
	end
}
YAML.add_ruby_type( Symbol, &symbol_proc ) 
YAML.add_ruby_type( :sym, &symbol_proc ) 

#
# Range#to_yaml
#
class Range
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( nil, opts ) { |out|
			out << "!ruby/range " 
			self.inspect.to_yaml( :Emitter => out )
		}
	end
end

YAML.add_ruby_type( Range ) { |type, val|
	if String === val and val =~ /^(.*[^.])(\.{2,3})([^.].*)$/
        r1, rdots, r2 = $1, $2, $3
		Range.new( YAML.try_implicit( r1 ), YAML.try_implicit( r2 ), rdots.length == 3 )
	elsif Hash === val
		Range.new( val['begin'], val['end'], val['exclude_end?'] )
	else
		raise YAML::Error, "Invalid Range: " + val.inspect
	end
}

#
# Make an RegExp
#
class Regexp
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( nil, opts ) { |out|
			out << "!ruby/regexp "
			self.inspect.to_yaml( :Emitter => out )
		}
	end
end

regexp_proc = Proc.new { |type, val|
	if String === val and val =~ /^\/(.*)\/([mix]*)$/
		val = { 'REGEXP' => $1, 'MODIFIERS' => $2 }
	end
	if Hash === val
		mods = nil
		unless val['MODIFIERS'].to_s.empty?
			mods = 0x00
			if val['MODIFIERS'].include?( 'x' )
				mods |= Regexp::EXTENDED
			elsif val['MODIFIERS'].include?( 'i' )
				mods |= Regexp::IGNORECASE
			elsif val['MODIFIERS'].include?( 'm' )
				mods |= Regexp::POSIXLINE
			end
		end
		Regexp::compile( val['REGEXP'], mods )
	else
		raise YAML::Error, "Invalid Regular expression: " + val.inspect
	end
}
YAML.add_domain_type( "perl.yaml.org,2002", /^regexp/, &regexp_proc )
YAML.add_ruby_type( Regexp, &regexp_proc )

#
# Emit a Time object as an ISO 8601 timestamp
#
class Time
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		YAML::quick_emit( nil, opts ) { |out|
            tz = "Z"
            # from the tidy Tobias Peters <t-peters@gmx.de> Thanks!
            unless self.utc?
                utc_same_instant = self.dup.utc
                utc_same_writing = Time.utc(year,month,day,hour,min,sec,usec)
                difference_to_utc = utc_same_writing - utc_same_instant
                if (difference_to_utc < 0) 
                    difference_sign = '-'
                    absolute_difference = -difference_to_utc
                else
                    difference_sign = '+'
                    absolute_difference = difference_to_utc
                end
                difference_minutes = (absolute_difference/60).round
                tz = "%s%02d:%02d" % [ difference_sign, difference_minutes / 60, difference_minutes % 60]
            end
            ( self.strftime( "%Y-%m-%d %H:%M:%S." ) +
                "%06d %s" % [usec, tz] ).
                to_yaml( :Emitter => out, :KeepValue => true )
		}
	end
end

YAML.add_builtin_type( 'time' ) { |type, val|
    if val =~ /\A(\d{4})\-(\d{1,2})\-(\d{1,2})[Tt](\d{2})\:(\d{2})\:(\d{2})(\.\d{1,2})?(Z|[-+][0-9][0-9](?:\:[0-9][0-9])?)\Z/
        YAML.mktime( *$~.to_a[1,8] )
    elsif val =~ /\A(\d{4})\-(\d{1,2})\-(\d{1,2})[ \t]+(\d{2})\:(\d{2})\:(\d{2})(\.\d+)?[ \t]+(Z|[-+][0-9][0-9](?:\:[0-9][0-9])?)\Z/
        YAML.mktime( *$~.to_a[1,8] )
    elsif val =~ /\A(\d{4})\-(\d{1,2})\-(\d{1,2})[ \t]+(\d{2})\:(\d{2})\:(\d{2})(\.\d{1,2})?\Z/
        YAML.mktime( *$~.to_a[1,7] )
	elsif val =~ /\A(\d{4})\-(\d{1,2})\-(\d{1,2})\Z/
		Date.new($1.to_i, $2.to_i, $3.to_i)
    elsif type == :Implicit
        :InvalidType
    else
        raise YAML::TypeError, "Invalid !time string: " + val.inspect
    end
}

#
# Emit a Date object as a simple implicit
#
class Date
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		opts[:KeepValue] = true
		self.to_s.to_yaml( opts )
	end
end

#
# Send Integer, Booleans, NilClass to String
#
class Numeric
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		str = self.to_s
		if str == "Infinity"
			str = ".Inf"
		elsif str == "-Infinity"
			str = "-.Inf"
		elsif str == "NaN"
			str = ".NaN"
		end
		opts[:KeepValue] = true
		str.to_yaml( opts )
	end
end

YAML.add_builtin_type( 'float' ) { |type, val|
    if val =~ /\A[-+]?[\d][\d,]*\.[\d,]*[eE][-+][0-9]+\Z/						# Float (exponential)
        $&.tr( ',', '' ).to_f
    elsif val =~ /\A[-+]?[\d][\d,]*\.[\d,]*\Z/									# Float (fixed)
        $&.tr( ',', '' ).to_f
    elsif val =~ /\A([-+]?)\.(inf|Inf|INF)\Z/										# Float (english)
        ( $1 == "-" ? -1.0/0.0 : 1.0/0.0 )
    elsif val =~ /\A\.(nan|NaN|NAN)\Z/
        0.0/0.0
    elsif type == :Implicit
        :InvalidType
    else
        val.to_f
    end
}

YAML.add_builtin_type( 'int' ) { |type, val|
    if val =~ /\A[-+]?0[0-7,]+\Z/												# Integer (octal)
        $&.oct
    elsif val =~ /\A[-+]?0x[0-9a-fA-F,]+\Z/										# Integer (hex)
        $&.hex
    elsif val =~ /\A[-+]?\d[\d,]*\Z/												# Integer (canonical)
        $&.tr( ',', '' ).to_i
    elsif val =~ /\A([-+]?)(\d[\d,]*(?::[0-5]?[0-9])+)\Z/
        sign = ( $1 == '-' ? -1 : 1 )
        digits = $2.split( /:/ ).collect { |x| x.to_i }
        val = 0; digits.each { |x| val = ( val * 60 ) + x }; val *= sign
    elsif type == :Implicit
        :InvalidType
    else
        val.to_i
    end
}

class TrueClass
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		opts[:KeepValue] = true
		"true".to_yaml( opts )
	end
end

class FalseClass
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		opts[:KeepValue] = true
		"false".to_yaml( opts )
	end
end

YAML.add_builtin_type( 'bool' ) { |type, val|
    if val =~ /\A(\+|true|True|TRUE|yes|Yes|YES|on|On|ON)\Z/
        true
    elsif val =~ /\A(\-|false|False|FALSE|no|No|NO|off|Off|OFF)\Z/
        false
    elsif type == :Implicit
        :InvalidType
    else
        raise YAML::TypeError, "Invalid !bool string: " + val.inspect
    end
}

class NilClass 
    def is_complex_yaml?
        false
    end
	def to_yaml( opts = {} )
		opts[:KeepValue] = true
		"".to_yaml( opts )
	end
end

YAML.add_builtin_type( 'null' ) { |type, val| 
    if val =~ /\A(\~|null|Null|NULL)\Z/
        nil
    elsif val.empty?
        nil
    elsif type == :Implicit
        :InvalidType
    else
        raise YAML::TypeError, "Invalid !null string: " + val.inspect
    end
}

#
# ryan: You know how Kernel.p is a really convenient way to dump ruby
#       structures?  The only downside is that it's not as legible as
#       YAML.
#
# _why: (listening)
#
# ryan: I know you don't want to urinate all over your users' namespaces.
#       But, on the other hand, convenience of dumping for debugging is,
#       IMO, a big YAML use case.
#
# _why: Go nuts!  Have a pony parade!
#
# ryan: Either way, I certainly will have a pony parade.
#
module Kernel
    def y( x )
        puts x.to_yaml
    end
end

#
# Example of using YAML to replace PStore
#
if __FILE__ == $0
	y = YAML::Store.new( "/tmp/yaml.store.1", :Indent => 2, 
		:UseHeader => true, :UseVersion => true )
	y.transaction do
	 	y['names'] = ['Steve', 'Jonathan', 'Tom']
	 	y['hello'] = {'hi' => 'hello', 'yes' => 'YES!!' }
	end
end

#
# Example of using YAML::Stream
#
# a = "File ID"
# y = YAML::Stream.new( :Indent => 2, :UseVersion => 0 )
# y.add( {'hi2' => 'hello', 'map' => {'good' => 'two'}, 'time' => Time.now, 'try' => /^po(.*)$/, 'bye' => 'goodbye' } )
# y.add( {'po' => nil, 'oper' => 90 } )
# y.add( {'hi' => 'wow!', 'bye' => 'wow!'} )
# y.add( {['Red Socks','Boston'] => ['One', 'Two', 'Three']} )
# y.add( [true, false, false] )  # This should use aliases
# puts y.emit
  
#
# Example of loading a YAML document
#
# obj = YAML::load( "/tmp/yaml.store.1" )

#
# Examples of using #to_yaml
#
# puts [1, 2, 3, nil, 'hello', "Glow all!", 'hi', Time.now, /^po(.*)/im ].to_yaml( :UseBlock => true )
# puts Hash['hi', 'hello', 'time', Time.now, 'try', /^po(.*)$/, 'bye', 'goodbye' ].to_yaml
# puts [
# 	{'hi' => 'hello', 'time' => Time.now, 'try' => /^po(.*)$/, 'bye' => 'goodbye' }, 
# 	{'po' => nil, 'oper' => 90 }, 
# 	{'hi' => 'wow!', 'bye' => 'wow!'} ].to_yaml


..end src/emitter.rb modeval..iddd2784be19

module YAML

  class Parser < Racc::Parser

module_eval <<'..end src/yaml.y.rb modeval..idae682a68eb', 'src/yaml.y.rb', 140

attr_accessor :finished, :directives, :options

#
# Reset the directives, EOF flag
#
def initialize( opts = {} )
	@directives = { 'YAML' => '1.0', 'TAB' => 'NONE' }
	@options = YAML::DEFAULTS.dup.update( opts )
	@finished = false
    @plain_sets = {
        :AllowInline => YAML.plain_re( ',}]' ),
        :AllowMapping => YAML.plain_re( ':' ),
        :AllowNone => YAML.plain_re
    }
end

#
# Iterator for parsing many documents 
#
def parse_documents( io, &doc_proc )
	@stream = YAML.make_stream( io )
    @lineno = 0
    @charno = 0
    @leftovers = nil
	@options[:Encoding] = @stream.utf_encoding
	while true
		o = _parse
		doc_proc.call( o )
		break if @finished
	end
end

#
# Basic single document parsing
# 
def parse( io )
	@stream = YAML.make_stream( io )
    @lineno = 0
    @charno = 0
    @leftovers = nil
	@options[:Encoding] = @stream.utf_encoding
	_parse
end

#
# Common tokenizer and parser
#
def _parse

	#
	# Parser instance variables
	#
	@anchor = {}
	@lvl = [ Level.new( -1, :Implicit, "" ) ]
	@separator = nil
	@last_tokens = []
	@plain_set = @plain_sets[ :AllowInline ]

    reset_indent
    reset_tokens

    # Tokenizer
    do_tokenize

    @finished = true if eof? and @leftovers.nil?
    return nil if @q.length.zero?

    add_end_indent -1
    close_tokens

    # @q.each { |tok|
    #     p [ tok.sym, tok.data ]
    # }

    # Parser
    begin
        do_parse
    rescue Racc::ParseError => rpe
        token = @last_tokens.last
        raise YAML::ParseError, "Parse error at line #{token.lineno}, char #{token.charno}: [#{token.sym}, #{token.data}]"
    end
end

def do_tokenize
    until eof? and @leftovers.nil? do
        if @leftovers
            yline = @leftovers
            @leftovers = nil
        else
            yline = readline.chomp
        end
        handle_indent( yline )
        until yline.empty? do
            handle_content( yline )
            if [ :End, :Pause ].include?( @lvl.last.status )
                @leftovers = yline
                return
            end
        end
    end
end

def handle_indent( yline )
    if ( indt_match = @lvl.last.indent_re.match( yline ) )
        @indent_raw << "\n" + indt_match[0]
        case indt_match[2]
            when /^#/
                yline.replace ""
            when /^-/
                @indent << "\n" + yline.slice!( 0, indt_match[1].length ) + " "
                @charno += indt_match[1].length
            else
                @indent << "\n" + yline.slice!( 0, indt_match[0].length )
                @charno += indt_match[0].length
        end
    end
end

def handle_content( yline )
    if @charno == 1
        case yline
            when /\A---( |$)/
                if @q.length.zero? 
                    reset_indent
                    @lvl.last.status = :Header
                    @charno += $&.length
                    yline.replace $'
                else
                    @lvl.last.status = :End
                end
                return
            when /\A\.\.\.( |$)/
                @lvl.last.status = :Pause
                @charno += $&.length
                yline.replace $'
                return
        end
    elsif @lvl.last.status == :Header
        if yline =~ /\A%(\w+):(\S+)/
            @directives[$1] = $2
            case $1
                when "YAML"
                    @options[:Version] = $2
                    @options[:UseVersion] = true
            end
            len = $&.length
            yline.slice!( 0, len )
            @charno += len
            return
        else
            @lvl.last.status = :Implicit
        end
    end
    if @lvl.last.status != :Block or @q.last.sym == :FSTART
        case yline
            when /\A#/
                # Throwaway comments
                yline.replace ""
                return
            when /\A +/
                # Throwaway space
                len = $&.length
                yline.slice!( 0, len )
                @charno += len
                return
        end
    end
    apply_indent
    if @lvl.last.status == :Block
        add_token :FOLD, yline
        yline.replace ""
        return
    end
    len = 0
    case yline
        when /\A[#{ Regexp::quote( SPACE_INDICATORS ) }]( |$)/
            # Space indicators
            len = $&.length
            c = yline[ 0, 1 ]
            if @lvl.last.status == :Inline
                if c == ':'
                    @plain_set = @plain_sets[ :AllowMapping ]
                elsif c == ','
                    @plain_set = @plain_sets[ :AllowNone ]
                end
            else
                if c == ':'
                    @plain_set = @plain_sets[ :AllowInline ]
                elsif c == '-'
                    handle_seq_shortcuts
                    if @q[-1] and [ :INDENT, :IOPEN, :IEND ].include?( @q[-1] )
                        @lvl.last.spaces = @charno + 1
                        @q.last.data = @charno + 1
                    end
                end
            end
            add_token c, c
		when /\A([>|])([-+\d]*)/
            len = $&.length
            fold = $&
            fold_type = $1
            @lvl.push Level.new( @lvl.last.spaces + 1, :Block, fold_type == "|" ? :Literal : :Folded )
            @q.push Token.new( :IOPEN, @lvl.last.spaces, @lineno, 1 )
            add_token :FSTART, fold
        when /\A([{\[])/
            len = $&.length
            tok = $&
            @lvl.push Level.new( @lvl.last.spaces + 2, :Inline, @lvl.last.domain )
            @plain_set = @plain_sets[ :AllowNone ]
            add_token tok, tok 
        when /\A([}\]])/
            len = $&.length
            tok = $&
            @lvl.pop
            @plain_set = @plain_sets[ :AllowInline ]
            add_token tok, tok 
        when /\A&(\w+)/
            len = $&.length
            add_token :ANCHOR, $1
        when /\A\*(\w+)/
            len = $&.length
            add_token :ALIAS, $1
        when /\A!(\S*)/
            len = $&.length
            ttype = $1
            if ttype =~ /(.*)\^(.+)/
                if $1.length > 0
                    @lvl.last.domain = $1
                    ttype = $1 + $2
                else
                    ttype = @lvl.last.domain + $2
                end
            end
            add_token :TRANSFER, ttype
        when /\A"((?:\\\"|[^\n"])*)/
            handle_seq_shortcuts
            len = $&.length
            yline.slice!( 0, len )
            @charno += len
            qstr = $1.to_s
            qstr_indt = "+"
            while yline[0,1] != '"'
                if qstr[-1,1] == "\\"
                    qstr = qstr.chop!
                else
                    qstr << " "
                end
                yline = readline
                yline =~ /\A(\s#{qstr_indt})((?:\\\"|[^\n"])*)/
                len = $&.to_s.length
                yline.slice!( 0, len )
                @charno += len
                qstr << $2.to_s
            end
            len = 1
            add_token :WORD, YAML.unescape(qstr.gsub( /\\"/, '"' ))
        when /\A'((?:''|[^\n'])*)/
            handle_seq_shortcuts
            len = $&.length
            yline.slice!( 0, len )
            @charno += len
            qstr = $1.to_s
            qstr_indt = "+"
            nl_mode = false
            while yline[0,1] != "'"
                qstr << " " if qstr[-1,1] != "\n"
                yline = readline
                yline =~ /\A(\s#{qstr_indt})((?:''|[^\n'])*)/
                qstr_indt = "{0,#{$1.length}}" if qstr_indt == "+"
                inner_str = $2.to_s.strip
                if inner_str == ""
                    qstr = ( nl_mode ? qstr : qstr[0..-2] ) + "\n"
                    nl_mode = true
                else
                    qstr << $2
                    nl_mode = false
                end
                len = $&.to_s.length
                yline.slice!( 0, len )
                @charno += len
            end
            len = 1
            add_token :WORD, qstr.gsub( "''", "'" )
        when @plain_set
            handle_seq_shortcuts
            len = $&.length
            match = $&.strip
            if @q.last and @q.last.sym == :PLAIN
                @q.last.data += " " if @q.last.data !~ /\Z\n/
                @q.last.data += match
            else
                add_token :PLAIN, match
            end
        else
            handle_seq_shortcuts
            len = 1
            c = yline[ 0, 1 ]
            add_token c, c
    end
    yline.slice!( 0, len )
    @charno += len
end

def handle_seq_shortcuts
    if @q[-1] and @q[-1].sym == '-' and @q[-2] and [:IOPEN, :INDENT, :IEND].include?( @q[-2].sym )
        # Check the current level and indent to match the dash
        @lvl.last.spaces = @q[-1].charno
        @q[-2].data = @q[-1].charno
        # Add open indent after the dash
        @lvl.push Level.new( @charno - 1, @lvl.last.status, @lvl.last.domain )
        @q.push Token.new( :IOPEN, @charno - 1, @lineno, @charno )
    end
end

#
# Level descent class added 2002 Dec 31
#   The levels of indentation are tracked using this class.
#   Each level has an indentation space count, a status field
#   indicating what sort of data is contained at this depth,
#   and the domain anchored at this depth.
#
class Level
    attr_accessor :spaces, :status, :domain
    def initialize( ct, s, d )
        @spaces, @status, @domain = ct, s, d
    end
    def indent_re
        if @status == :Block
            if @spaces > 0
                /\A( {0,#{ @spaces - 1 }})(#[^\n]+|-( +(?!:)|$)| *)?/
            else
                /\A( *)(#[^\n]+)?/
            end
        else
            /\A( *)(#[^\n]+|-( +(?!:)|$))?/
        end
    end
end

#
# Token class added 2002 Dec 26.
#   Thanks to this class, we can now track line numbers
#   and store accessory data to our tokens.  This should
#   eventually assist our emitter in reforming a document
#   in its original form.
#
class Token
    attr_accessor :sym, :data, :lineno, :charno
    def initialize( s, d, ln, cn )
        @sym, @data, @lineno, @charno = s, d, ln, cn
    end
end

#
# Token stack ops
#
def reset_indent
    @indent, @indent_raw = "", ""
end

def reset_tokens
    @q = []
end

def add_token( sym, data )
    if sym == :FOLD 
        if @q.last.sym != :FOLD
            raise YAML::Error, "Improper fold!!"
        end
        if @q.last.data =~ / \Z/
            @lvl.last.domain = :FoldIndt if @lvl.last.domain == :Folded
        elsif @lvl.last.domain == :Folded
            @q.last.data.gsub!( /\n\Z\n/, "\n" ) unless @q.last.data.gsub!( /(.)\Z\n/, '\1 ' )
        elsif @lvl.last.domain == :FoldIndt
            @lvl.last.domain = :Folded
        end
        @q.last.data += data
    else
        @q.push Token.new( sym, data, @lineno, @charno )
    end
end

def apply_indent
    # Turn indent into a token
    unless @indent.empty?
        indt_len = /^ *\Z/.match( @indent )[0].length
        if @lvl.last.status == :Block and @q.last.sym == :FOLD
            add_fold_indent
        end
        if @lvl.last.spaces > indt_len
            add_end_indent indt_len
        end
        if @lvl.last.status == :Block
            fold_txt = ""
            if @q.last.sym == :FSTART
                if @q.last.data =~ /(\d+)/
                    if @lvl.last.spaces > 0
                        @lvl.last.spaces -= 1
                    end
                    indt_len = $1.to_i + @lvl.last.spaces
                end
                @lvl.last.spaces = indt_len
                @q.push Token.new( :FOLD, fold_txt, @lineno, 1 )
                @indent.slice!( 0, 1 )
                add_fold_indent
            end
        else
            indt_type = :INDENT
            if @lvl.last.spaces < indt_len
                indt_type = :IOPEN
            end
            if @q.last and @q.last.sym == :PLAIN and ( indt_type == :IOPEN or 
              ( @lvl.last.spaces == indt_len and @q[-2] and @q[-2].sym == :IOPEN ) )
                unless @q.last.data.empty?
                    @q.last.data += @indent_raw.gsub( /^ +/, '' ).gsub( /\n(\n*)/, '\1' )
                end
            elsif @lvl.last.status != :Inline
                @plain_set = @plain_sets[ :AllowInline ]
                if indt_type == :IOPEN
                    @lvl.push Level.new( indt_len, @lvl.last.status, @lvl.last.domain )
                end
                @q.push Token.new( indt_type, indt_len, @lineno, 1 )
            end
        end
        reset_indent
    end
end

def close_tokens
    @q.push Token.new( false, '$', @lineno, @charno )
end

def pop_token
    @q.pop
end

def push_token( tok )
    @q.push tok
end

#
# Used by Racc
# The @last_token stored for error_reporting
#
def next_token
	@last_tokens.push @q.first
	if @last_tokens.length > 5
		@last_tokens.shift
	end
	tok = @q.shift
    [ tok.sym, tok.data ]
end

def add_end_indent( indt_len )
    while @lvl.last.spaces > indt_len
        @q.push Token.new( :IEND, @lvl.pop.spaces, @lineno, 1 )
    end
end

#
# Keep line number count
#
def readline
    @lineno += 1
    @charno = 1
    begin
        @stream.readline
    rescue IOError
    end
end

def eof?; @stream.eof?; end

#
# Handle Hash special keys
#
def hash_update( h, item )
	if item.class == Array
		# if h.class != YAML::SpecialHash
		# 	h = YAML::SpecialHash.new.update( h )
		# end
        if item[0] == :MERGE
            if Hash === item[1]
                h.update( item[1] )
            elsif Array === item[1]
                item[1].flatten.reverse.each { |hmerge|
                    h.update( hmerge )
                }
            end
		elsif item[0] == :DEFAULT
			h.default = item[1]
		# elsif item[0] == :COMMENT
		# 	h.comment = item[1]
		end
	elsif item.class == YAML::SpecialHash
		h = item.update( h )
	elsif item.is_a? Hash
		h.update( item )
	else
		raise YAML::Error, "Invalid update to Hash with item: " + item.inspect
	end
	return h
end

def attach_transfer( meth, val )
    meth = YAML.unescape( meth )
    if @options[:Model] == :Generic
        val.type_id = meth
        val
    else
        YAML.transfer_method( meth, val ) 
    end
end

#
# Add a new node
#
def new_node( type_id, val )
    if @options[:Model] == :Generic
        val = YamlNode.new( type_id, val )
    end
    val
end

#
# Take block text and format based on the block def characters
#
def process_block( fold_type, fold_text )
    fold_text.chomp! if fold_type.include?( '|' )
    if fold_type.include?( '+' )
        fold_text << "\n"
    else
        fold_text.chomp!( '' )
        if fold_type.include?( '-' )
            fold_text.chomp!
        else
            fold_text << "\n" 
        end
    end
    return fold_text
end

def add_fold_indent
    if @lvl.last.spaces > 0
        @indent.gsub!( /^ {0,#{ @lvl.last.spaces }}/, '' )
    end
    @q.last.data += @indent
end

def process_plain( p )
    if @options[:Model] == :Generic
        new_node( YAML.detect_implicit( p ), p )
    else
        YAML.try_implicit( p ) 
    end
end
..end src/yaml.y.rb modeval..idae682a68eb

##### racc 1.4.3 generates ###

racc_reduce_table = [
 0, 0, :racc_error,
 1, 22, :_reduce_none,
 1, 22, :_reduce_none,
 2, 22, :_reduce_3,
 1, 22, :_reduce_4,
 1, 25, :_reduce_none,
 0, 25, :_reduce_6,
 2, 23, :_reduce_7,
 1, 23, :_reduce_8,
 1, 23, :_reduce_9,
 3, 23, :_reduce_10,
 2, 24, :_reduce_11,
 1, 24, :_reduce_none,
 1, 24, :_reduce_none,
 1, 24, :_reduce_none,
 3, 24, :_reduce_15,
 1, 24, :_reduce_none,
 1, 24, :_reduce_none,
 3, 24, :_reduce_18,
 4, 26, :_reduce_19,
 3, 26, :_reduce_20,
 3, 27, :_reduce_21,
 2, 32, :_reduce_22,
 1, 31, :_reduce_23,
 3, 31, :_reduce_24,
 3, 28, :_reduce_25,
 2, 28, :_reduce_26,
 1, 33, :_reduce_27,
 2, 33, :_reduce_28,
 3, 33, :_reduce_29,
 3, 29, :_reduce_30,
 3, 35, :_reduce_31,
 3, 35, :_reduce_32,
 1, 36, :_reduce_none,
 5, 36, :_reduce_34,
 1, 34, :_reduce_35,
 3, 34, :_reduce_36,
 3, 30, :_reduce_37,
 2, 30, :_reduce_38,
 1, 37, :_reduce_39,
 3, 37, :_reduce_40 ]

racc_reduce_n = 41

racc_shift_n = 74

racc_action_table = [
     4,     6,     8,    10,    12,    14,    59,    60,    52,    61,
    58,     3,    30,    10,    12,    34,    51,    15,     4,     6,
     8,    10,    12,    14,    68,    31,    44,    45,    42,     3,
    30,    10,    12,    34,    43,    15,     4,     6,     8,    10,
    12,    14,    50,    31,    33,    62,    49,     3,    20,    21,
    63,    54,    17,    15,     4,     6,     8,    10,    12,    14,
    30,    10,    12,    34,    57,     3,    30,    10,    12,    34,
    52,    15,     4,     6,     8,    10,    12,    14,    25,    31,
    70,    53,    72,     3,    30,    10,    12,    34,    51,    15,
     4,     6,     8,    10,    12,    14,   nil,   nil,   nil,   nil,
   nil,     3,   nil,   nil,   nil,   nil,   nil,    15,     4,     6,
     8,    10,    12,    14,   nil,   nil,   nil,   nil,   nil,     3,
   nil,   nil,   nil,   nil,   nil,    15,     4,     6,     8,    10,
    12,    14,   nil,   nil,   nil,   nil,   nil,     3,   nil,   nil,
   nil,   nil,   nil,    15,     4,     6,     8,    10,    12,    14,
   nil,   nil,   nil,   nil,   nil,     3,   nil,   nil,   nil,   nil,
   nil,    15,     4,     6,     8,    10,    12,    14,     8,    10,
    12,    14,   nil,     3,   nil,   nil,   nil,     3,   nil,    15,
   nil,   nil,   nil,    15,    30,    10,    12,    34,   nil,    37,
   nil,    25,   nil,     3,   nil,   nil,   nil,    31,    33,    15 ]

racc_action_check = [
     0,     0,     0,     0,     0,     0,    36,    37,    27,    37,
    36,     0,    15,    15,    15,    15,    27,     0,    53,    53,
    53,    53,    53,    53,    55,    15,    19,    19,    15,    53,
    49,    49,    49,    49,    17,    53,     3,     3,     3,     3,
     3,     3,    26,    49,    49,    41,    26,     3,     3,     3,
    41,    32,     1,     3,     4,     4,     4,     4,     4,     4,
    30,    30,    30,    30,    35,     4,    62,    62,    62,    62,
    56,     4,    51,    51,    51,    51,    51,    51,    58,    62,
    61,    31,    68,    51,    34,    34,    34,    34,    39,    51,
    45,    45,    45,    45,    45,    45,   nil,   nil,   nil,   nil,
   nil,    45,   nil,   nil,   nil,   nil,   nil,    45,    21,    21,
    21,    21,    21,    21,   nil,   nil,   nil,   nil,   nil,    21,
   nil,   nil,   nil,   nil,   nil,    21,    33,    33,    33,    33,
    33,    33,   nil,   nil,   nil,   nil,   nil,    33,   nil,   nil,
   nil,   nil,   nil,    33,    25,    25,    25,    25,    25,    25,
   nil,   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,
   nil,    25,    72,    72,    72,    72,    72,    72,     8,     8,
     8,     8,   nil,    72,   nil,   nil,   nil,     8,   nil,    72,
   nil,   nil,   nil,     8,    14,    14,    14,    14,   nil,    14,
   nil,    14,   nil,    14,   nil,   nil,   nil,    14,    14,    14 ]

racc_action_pointer = [
    -2,    52,   nil,    34,    52,   nil,   nil,   nil,   164,   nil,
   nil,   nil,   nil,   nil,   180,     8,   nil,    34,   nil,    12,
   nil,   106,   nil,   nil,   nil,   142,    34,     0,   nil,   nil,
    56,    65,    43,   124,    80,    56,    -2,    -1,   nil,    72,
   nil,    30,   nil,   nil,   nil,    88,   nil,   nil,   nil,    26,
   nil,    70,   nil,    16,   nil,    12,    62,   nil,    67,   nil,
   nil,    72,    62,   nil,   nil,   nil,   nil,   nil,    66,   nil,
   nil,   nil,   160,   nil ]

racc_action_default = [
   -41,   -41,    -1,   -41,   -41,    -2,    -4,   -12,   -41,   -13,
    -8,   -14,    -9,   -16,   -41,   -41,   -17,   -41,   -27,   -41,
   -26,    -6,    -3,    -7,   -11,    -6,   -41,   -41,   -33,   -35,
   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -23,   -41,
   -39,   -41,   -38,    74,   -25,    -6,    -5,   -28,   -22,   -41,
   -30,    -6,   -10,    -6,   -15,   -41,   -41,   -18,   -41,   -21,
   -20,   -41,   -41,   -37,   -29,   -36,   -31,   -32,   -41,   -24,
   -19,   -40,    -6,   -34 ]

racc_goto_table = [
    23,    47,    40,    38,    29,    48,    27,    39,    36,     1,
    35,    19,    18,    22,    26,    32,    24,    41,   nil,   nil,
   nil,   nil,    23,   nil,   nil,    64,    56,   nil,   nil,   nil,
   nil,    66,   nil,    67,   nil,   nil,   nil,   nil,   nil,    65,
   nil,    39,    55,   nil,   nil,   nil,   nil,    69,   nil,    71,
   nil,   nil,    73,   nil,    39 ]

racc_goto_check = [
     2,     4,    14,    11,    15,     4,     2,     2,    10,     1,
     9,    12,     1,     1,    13,     7,     3,    16,   nil,   nil,
   nil,   nil,     2,   nil,   nil,     4,     2,   nil,   nil,   nil,
   nil,     4,   nil,     4,   nil,   nil,   nil,   nil,   nil,    15,
   nil,     2,     1,   nil,   nil,   nil,   nil,    11,   nil,    14,
   nil,   nil,     4,   nil,     2 ]

racc_goto_pointer = [
   nil,     9,    -8,     8,   -20,   nil,   nil,     1,   nil,    -4,
    -6,   -11,     8,     0,   -13,   -10,     2 ]

racc_goto_default = [
   nil,    46,     2,     5,   nil,     7,     9,    11,    13,    16,
   nil,   nil,   nil,   nil,    28,   nil,   nil ]

racc_token_table = {
 false => 0,
 Object.new => 1,
 :ANCHOR => 2,
 :ALIAS => 3,
 :TRANSFER => 4,
 :WORD => 5,
 :PLAIN => 6,
 :IOPEN => 7,
 :IEND => 8,
 :FSTART => 9,
 :FOLD => 10,
 "-" => 11,
 :INDENT => 12,
 "[" => 13,
 "]" => 14,
 "," => 15,
 ":" => 16,
 "=" => 17,
 "?" => 18,
 "{" => 19,
 "}" => 20 }

racc_use_result_var = true

racc_nt_base = 21

Racc_arg = [
 racc_action_table,
 racc_action_check,
 racc_action_default,
 racc_action_pointer,
 racc_goto_table,
 racc_goto_check,
 racc_goto_default,
 racc_goto_pointer,
 racc_nt_base,
 racc_reduce_table,
 racc_token_table,
 racc_shift_n,
 racc_reduce_n,
 racc_use_result_var ]

Racc_token_to_s_table = [
'$end',
'error',
'ANCHOR',
'ALIAS',
'TRANSFER',
'WORD',
'PLAIN',
'IOPEN',
'IEND',
'FSTART',
'FOLD',
'"-"',
'INDENT',
'"["',
'"]"',
'","',
'":"',
'"="',
'"?"',
'"{"',
'"}"',
'$start',
'atom',
'word_rep',
'struct_rep',
'atom_or_empty',
'scalar_block',
'implicit_seq',
'inline_seq',
'implicit_map',
'inline_map',
'in_implicit_seq',
'basic_seq',
'in_inline_seq',
'in_implicit_map',
'basic_mapping',
'complex_mapping',
'in_inline_map']

Racc_debug_parser = false

##### racc system variables end #####

 # reduce 0 omitted

 # reduce 1 omitted

 # reduce 2 omitted

module_eval <<'.,.,', 'src/yaml.y.rb', 17
  def _reduce_3( val, _values, result )
            if @options[:Model] == :Generic
                val[1].anchor = val[0]   
            end
            result = @anchor[ val[0] ] = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 22
  def _reduce_4( val, _values, result )
 result = @anchor[ val[0] ]
   result
  end
.,.,

 # reduce 5 omitted

module_eval <<'.,.,', 'src/yaml.y.rb', 25
  def _reduce_6( val, _values, result )
 result = new_node( 'null', nil )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 32
  def _reduce_7( val, _values, result )
 result = attach_transfer( val[0], val[1] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 33
  def _reduce_8( val, _values, result )
 result = new_node( 'str', val[0] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 34
  def _reduce_9( val, _values, result )
 result = process_plain( val[0] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 35
  def _reduce_10( val, _values, result )
 result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 41
  def _reduce_11( val, _values, result )
 result = attach_transfer( val[0], val[1] )
   result
  end
.,.,

 # reduce 12 omitted

 # reduce 13 omitted

 # reduce 14 omitted

module_eval <<'.,.,', 'src/yaml.y.rb', 45
  def _reduce_15( val, _values, result )
 result = val[1]
   result
  end
.,.,

 # reduce 16 omitted

 # reduce 17 omitted

module_eval <<'.,.,', 'src/yaml.y.rb', 48
  def _reduce_18( val, _values, result )
 result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 56
  def _reduce_19( val, _values, result )
                    result = new_node( 'str', process_block( val[1], val[2] ) )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 60
  def _reduce_20( val, _values, result )
                    result = new_node( 'str', '' )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 66
  def _reduce_21( val, _values, result )
 result = new_node( 'seq', val[1] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 68
  def _reduce_22( val, _values, result )
 result = val[1]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 70
  def _reduce_23( val, _values, result )
 result = val
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 73
  def _reduce_24( val, _values, result )
					result.push val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 79
  def _reduce_25( val, _values, result )
 result = new_node( 'seq', val[1] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 80
  def _reduce_26( val, _values, result )
 result = new_node( 'seq', [] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 82
  def _reduce_27( val, _values, result )
 result = val
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 83
  def _reduce_28( val, _values, result )
 result = [ result = new_node( 'null', nil ), val[1] ]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 84
  def _reduce_29( val, _values, result )
 result.push val[2]
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 89
  def _reduce_30( val, _values, result )
 result = new_node( 'map', val[1] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 93
  def _reduce_31( val, _values, result )
                    if val[0] == '<<'
                        result = [ :MERGE, val[2] ]
                    else
                        result = { val[0] => val[2] }
                    end
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 101
  def _reduce_32( val, _values, result )
					result = [ :DEFAULT, val[2] ]
   result
  end
.,.,

 # reduce 33 omitted

module_eval <<'.,.,', 'src/yaml.y.rb', 107
  def _reduce_34( val, _values, result )
					result = { val[1] => val[4] }
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 112
  def _reduce_35( val, _values, result )
                    result = hash_update( {}, val[0] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 116
  def _reduce_36( val, _values, result )
					result = hash_update( val[0], val[2] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 122
  def _reduce_37( val, _values, result )
 result = new_node( 'map', val[1] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 123
  def _reduce_38( val, _values, result )
 result = new_node( 'map', Hash.new )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 127
  def _reduce_39( val, _values, result )
					result = hash_update( {}, val[0] )
   result
  end
.,.,

module_eval <<'.,.,', 'src/yaml.y.rb', 131
  def _reduce_40( val, _values, result )
					result = hash_update( val[0], val[2] )
   result
  end
.,.,

 def _reduce_none( val, _values, result )
  result
 end

  end   # class Parser

end   # module YAML
