YAML ^(Module)

# File yaml.rb, line 111
        def YAML.add_builtin_type( type_re, &transfer_proc )
            @@loader.add_builtin_type( type_re, &transfer_proc )
        end

# File yaml.rb, line 104
        def YAML.add_domain_type( domain, type_re, &transfer_proc )
        @@loader.add_domain_type( domain, type_re, &transfer_proc )
        end

# File yaml.rb, line 125
        def YAML.add_private_type( type_re, &transfer_proc )
            @@loader.add_private_type( type_re, &transfer_proc )
        end

# File yaml.rb, line 118
        def YAML.add_ruby_type( type, &transfer_proc )
        @@loader.add_ruby_type( type, &transfer_proc )
        end

# File yaml.rb, line 132
    def YAML.detect_implicit( val )
        @@loader.detect_implicit( val )
    end

# File yaml.rb, line 29
        def YAML.dump( obj, io = nil )
        io ||= ""
        io << obj.to_yaml
        io
        end

# File yaml.rb, line 93
        def YAML.dump_stream( *objs )
                d = YAML::Stream.new
        objs.each do |doc|
                        d.add( doc ) 
        end
        d.emit
        end

# File yaml.rb, line 52
        def YAML.each_document( io, &doc_proc )
                yp = @@parser.new.load_documents( io, &doc_proc )
    end

# File yaml.rb, line 66
        def YAML.each_node( io, &doc_proc )
                yp = @@parser.new( :Model => :Generic ).load_documents( io, &doc_proc )
    end

# File yaml/encoding.rb, line 10
        def YAML.escape( value )
                value.gsub( /\\/, "\\\\\\" ).gsub( /"/, "\\\"" ).gsub( /([\x00-\x1f])/ ) { |x| ESCAPES[ x.unpack("C")[0] ] }
        end

# File yaml.rb, line 38
        def YAML.load( io )
                yp = @@parser.new.load( io )
        end

# File yaml.rb, line 59
        def YAML.load_documents( io, &doc_proc )
                YAML.each_document( io, &doc_proc )
    end

# File yaml.rb, line 80
        def YAML.load_stream( io )
                yp = @@parser.new
                d = nil
                yp.load_documents( io ) { |doc|
                        d = YAML::Stream.new( yp.options ) if not d
                        d.add( doc ) 
                }
                return d
        end

# File yaml/stringio.rb, line 55
        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

# File yaml.rb, line 163
    def YAML.object_maker( obj_class, val, is_attr = false )
        if Hash === val
            # name = obj_class.name

            # ostr = sprintf( "%c%co:%c%s\000", ::Marshal::MAJOR_VERSION, ::Marshal::MINOR_VERSION,

            #                 name.length + 5, name )

            # if is_attr

            #     ostr[ -1, 1 ] = ::Marshal.dump( val ).sub( /^[^{]+\{/, '' )

            # end

            o = obj_class.allocate
            unless is_attr
                val.each_pair { |k,v|
                    o.instance_variable_set("@#{k}", v)
                }
            end
            o
        else
            raise YAML::Error, "Invalid object explicitly tagged !ruby/Object: " + val.inspect
        end
    end

# File yaml.rb, line 45
        def YAML.parse( io )
                yp = @@parser.new( :Model => :Generic ).load( io )
        end

# File yaml.rb, line 73
        def YAML.parse_documents( io, &doc_proc )
                YAML.each_node( io, &doc_proc )
    end

# File yaml.rb, line 186
        def YAML.quick_emit( oid, opts = {}, &e )
                old_opt = nil
                if opts[:Emitter].is_a? @@emitter
                        out = opts.delete( :Emitter )
                        old_opt = out.options.dup
                        out.options.update( opts )
                else
                        out = @@emitter.new( opts )
                end
        aidx = out.start_object( oid )
        if aidx
            out.simple( "*#{ aidx }" )
        else
            e.call( out )
        end
                if old_opt.is_a? Hash
                        out.options = old_opt
                end 
                out.end_object
        end

# File yaml.rb, line 154
    def YAML.read_type_class( type, obj_class )
        scheme, domain, type, tclass = type.split( ':', 4 )
        tclass.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tclass
        return [ type, obj_class ]
    end

# File yaml.rb, line 139
    def YAML.transfer( type_id, obj )
        @@loader.transfer( type_id, obj )
    end

# File yaml.rb, line 146
        def YAML.try_implicit( obj )
                YAML.transfer( YAML.detect_implicit( obj ), obj )
        end

# File yaml/encoding.rb, line 17
        def YAML.unescape( value )
                value.gsub( /\\(?:([nevfbart\\])|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