.::Undergrounds v3.3 Webshells::.

: / opt / alt / ruby23 / share / ri / 2.3.0 / system / Object /
Filename : cdesc-Object.ri
back
U:RDoc::NormalClass[iI"Object:ET@I"BasicObject;To:RDoc::Markup::Document:@parts[o;;[�:
@fileI"class.c;T:0@omit_headings_from_table_of_contents_below0o;;[o:RDoc::Markup::Paragraph;[I"!frozen_string_literal: false;T;	I"$ext/psych/lib/psych/core_ext.rb;T;
0o;;[�;	I"&ext/psych/lib/psych/deprecated.rb;T;
0o;;[�;	I"lib/irb/ext/use-loader.rb;T;
0o;;[�;	I"lib/rexml/xpath_parser.rb;T;
0o;;[�;	I"lib/timeout.rb;T;
0o;;[o;;[I"KObject is the default root of all Ruby objects.  Object inherits from ;TI"NBasicObject which allows creating alternate object hierarchies.  Methods ;TI"Ion Object are available to all classes unless explicitly overridden.;To:RDoc::Markup::BlankLine�o;;[I"MObject mixes in the Kernel module, making the built-in kernel functions ;TI"Oglobally accessible.  Although the instance methods of Object are defined ;TI"Lby the Kernel module, we have chosen to document them here for clarity.;T@'o;;[I"MWhen referencing constants in classes inheriting from Object you do not ;TI"Mneed to use the full namespace.  For example, referencing +File+ inside ;TI"4+YourClass+ will find the top-level File class.;T@'o;;[I"QIn the descriptions of Object's methods, the parameter <i>symbol</i> refers ;TI"Gto a symbol, which is either a quoted string or a Symbol (such as ;TI"<code>:name</code>).;T;	I"
object.c;T;
0;	0;
0[�[ U:RDoc::Constant[i�I"SCRIPT_LINES__;TI"Object::SCRIPT_LINES__;T00o;;[o;;[I"NWhen a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded ;TI"Kafter the assignment will be added as an Array of lines with the file ;TI"name as the key.;T;	I"ext/ripper/ripper.c;T;
0@E@cRDoc::NormalClass0U;
[i�I"ENV;TI"Object::ENV;T00o;;[o;;[I";ENV is a Hash-like accessor for environment variables.;T@'o;;[I"*See ENV (the class) for more details.;T;	I"hash.c;T;
0@S@@F0U;
[i�I"
STDIN;TI"Object::STDIN;T00o;;[o;;[I"Holds the original stdin;T@';	I"	io.c;T;
0@]@@F0U;
[i�I"STDOUT;TI"Object::STDOUT;T00o;;[o;;[I"Holds the original stdout;T@';	@];
0@]@@F0U;
[i�I"STDERR;TI"Object::STDERR;T00o;;[o;;[I"Holds the original stderr;T@';	@];
0@]@@F0U;
[i�I"	ARGF;TI"Object::ARGF;T00o;;[o;;[I"KARGF is a stream designed for use in scripts that process files given ;TI"6as command-line arguments or passed in via STDIN.;T@'o;;[I"+See ARGF (the class) for more details.;T;	@];
0@]@@F0U;
[i�I"
OptParse;FI"Object::OptParse;T0I"OptionParser;To;;[BS:RDoc::Markup::Heading:
leveli:	textI"OptionParser;T@'S;;i;I"Introduction;T@'o;;[I"POptionParser is a class for command-line option analysis.  It is much more ;TI"Tadvanced, yet also easier to use, than GetoptLong, and is a more Ruby-oriented ;TI"solution.;T@'S;;i;I"
Features;T@'o:RDoc::Markup::List:
@type:NUMBER:@items[
o:RDoc::Markup::ListItem:@label0;[o;;[I"MThe argument specification and the code to handle it are written in the ;TI"same place.;To;;0;[o;;[I"MIt can output an option summary; you don't need to maintain this string ;TI"separately.;To;;0;[o;;[I"DOptional and mandatory arguments are specified very gracefully.;To;;0;[o;;[I"CArguments can be automatically converted to a specified class.;To;;0;[o;;[I"2Arguments can be restricted to a certain set.;T@'o;;[I"HAll of these features are demonstrated in the examples below.  See ;TI")#make_switch for full documentation.;T@'S;;i;I"Minimal example;T@'o:RDoc::Markup::Verbatim;[I"require 'optparse'
;TI"
;TI"options = {}
;TI" OptionParser.new do |opts|
;TI"3  opts.banner = "Usage: example.rb [options]"
;TI"
;TI"?  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
;TI"    options[:verbose] = v
;TI"  end
;TI"end.parse!
;TI"
;TI"p options
;TI"p ARGV
;T:@format0S;;i;I"Generating Help;T@'o;;[I"ROptionParser can be used to automatically generate help for the commands you ;TI"write:;T@'o;;[$I"require 'optparse'
;TI"
;TI"!Options = Struct.new(:name)
;TI"
;TI"class Parser
;TI"  def self.parse(options)
;TI"%    args = Options.new("world")
;TI"
;TI"1    opt_parser = OptionParser.new do |opts|
;TI"7      opts.banner = "Usage: example.rb [options]"
;TI"
;TI"K      opts.on("-nNAME", "--name=NAME", "Name to say hello to") do |n|
;TI"        args.name = n
;TI"      end
;TI"
;TI":      opts.on("-h", "--help", "Prints this help") do
;TI"        puts opts
;TI"        exit
;TI"      end
;TI"
    end
;TI"
;TI"$    opt_parser.parse!(options)
;TI"    return args
;TI"  end
;TI"	end
;TI"'options = Parser.parse %w[--help]
;TI"
;TI"	#=>
;TI"&   # Usage: example.rb [options]
;TI"D   #     -n, --name=NAME                  Name to say hello to
;TI"@   #     -h, --help                       Prints this help
;T;0S;;i;I"Required Arguments;T@'o;;[I"WFor options that require an argument, option specification strings may include an ;TI"Roption name in all caps. If an option is used without the required argument, ;TI"!an exception will be raised.;To;;[I"require 'optparse'
;TI"
;TI"options = {}
;TI""OptionParser.new do |parser|
;TI",  parser.on("-r", "--require LIBRARY",
;TI"N            "Require the LIBRARY before executing your script") do |lib|
;TI"%    puts "You required #{lib}!"
;TI"  end
;TI"end.parse!
;T;0o;;[I"
Used:;T@'o;;[	I"(bash-3.2$ ruby optparse-test.rb -r
;TI"Zoptparse-test.rb:9:in `<main>': missing argument: -r (OptionParser::MissingArgument)
;TI"3bash-3.2$ ruby optparse-test.rb -r my-library
;TI"You required my-library!
;T;0S;;i;I"Type Coercion;T@'o;;[I"HOptionParser supports the ability to coerce command line arguments ;TI"into objects for us.;T@'o;;[I"?OptionParser comes with a few ready-to-use kinds of  type ;TI"coercion. They are:;T@'o;;:BULLET;[o;;0;[o;;[I"/Date  -- Anything accepted by +Date.parse+;To;;0;[o;;[I"6DateTime -- Anything accepted by +DateTime.parse+;To;;0;[o;;[I"ATime -- Anything accepted by +Time.httpdate+ or +Time.parse+;To;;0;[o;;[I"-URI  -- Anything accepted by +URI.parse+;To;;0;[o;;[I"?Shellwords -- Anything accepted by +Shellwords.shellwords+;To;;0;[o;;[I"#String -- Any non-empty string;To;;0;[o;;[I"DInteger -- Any integer. Will convert octal. (e.g. 124, -3, 040);To;;0;[o;;[I"2Float -- Any float. (e.g. 10, 3.14, -100E+13);To;;0;[o;;[I"=Numeric -- Any integer, float, or rational (1, 3.4, 1/3);To;;0;[o;;[I";DecimalInteger -- Like +Integer+, but no octal format.;To;;0;[o;;[I";OctalInteger -- Like +Integer+, but no decimal format.;To;;0;[o;;[I"0DecimalNumeric -- Decimal integer or float.;To;;0;[o;;[I"<TrueClass --  Accepts '+, yes, true, -, no, false' and ;TI"defaults as +true+;To;;0;[o;;[I"?FalseClass -- Same as +TrueClass+, but defaults to +false+;To;;0;[o;;[I"3Array -- Strings separated by ',' (e.g. 1,2,3);To;;0;[o;;[I":Regexp -- Regular expressions. Also includes options.;T@'o;;[I"AWe can also add our own coercions, which we will cover soon.;T@'S;;i	;I"Using Built-in Conversions;T@'o;;[
I"OAs an example, the built-in +Time+ conversion is used. The other built-in ;TI")conversions behave in the same way. ;TI"5OptionParser will attempt to parse the argument ;TI"Bas a +Time+. If it succeeds, that time will be passed to the ;TI";handler block. Otherwise, an exception will be raised.;T@'o;;[I"require 'optparse'
;TI"require 'optparse/time'
;TI""OptionParser.new do |parser|
;TI"Y  parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
;TI"    p time
;TI"  end
;TI"end.parse!
;T;0o;;[I"
Used:;To;;[
I"2bash-3.2$ ruby optparse-test.rb  -t nonsense
;TI"G... invalid argument: -t nonsense (OptionParser::InvalidArgument)
;TI"7from ... time.rb:5:in `block in <top (required)>'
;TI"*from optparse-test.rb:31:in `<main>'
;TI"2bash-3.2$ ruby optparse-test.rb  -t 10-11-12
;TI"2010-11-12 00:00:00 -0500
;TI".bash-3.2$ ruby optparse-test.rb  -t 9:30
;TI"2014-08-13 09:30:00 -0400
;T;0S;;i	;I" Creating Custom Conversions;T@'o;;[I"KThe +accept+ method on OptionParser may be used to create converters. ;TI"PIt specifies which conversion block to call whenever a class is specified. ;TI"\The example below uses it to fetch a +User+ object before the +on+ handler receives it.;T@'o;;[I"require 'optparse'
;TI"
;TI"#User = Struct.new(:id, :name)
;TI"
;TI"def find_user id
;TI"<  not_found = ->{ raise "No User Found for id #{id}" }
;TI"  [ User.new(1, "Sam"),
;TI"9    User.new(2, "Gandalf") ].find(not_found) do |u|
;TI"    u.id == id
;TI"  end
;TI"	end
;TI"
;TI"op = OptionParser.new
;TI""op.accept(User) do |user_id|
;TI"  find_user user_id.to_i
;TI"	end
;TI"
;TI"(op.on("--user ID", User) do |user|
;TI"  puts user
;TI"	end
;TI"
;TI"op.parse!
;T;0o;;[I"output:;To;;[I".bash-3.2$ ruby optparse-test.rb --user 1
;TI"%#<struct User id=1, name="Sam">
;TI".bash-3.2$ ruby optparse-test.rb --user 2
;TI")#<struct User id=2, name="Gandalf">
;TI".bash-3.2$ ruby optparse-test.rb --user 3
;TI"Xoptparse-test.rb:15:in `block in find_user': No User Found for id 3 (RuntimeError)
;T;0S;;i;I"Complete example;T@'o;;[I"SThe following example is a complete Ruby program.  You can run it and see the ;TI"Seffect of specifying various options.  This is probably the best way to learn ;TI" the features of +optparse+.;T@'o;;[�I"require 'optparse'
;TI"require 'optparse/time'
;TI"require 'ostruct'
;TI"require 'pp'
;TI"
;TI"class OptparseExample
;TI"  Version = '1.0.0'
;TI"
;TI"<  CODES = %w[iso-2022-jp shift_jis euc-jp utf8 binary]
;TI"H  CODE_ALIASES = { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }
;TI"
;TI"  class ScriptOptions
;TI"F    attr_accessor :library, :inplace, :encoding, :transfer_type,
;TI"O                  :verbose, :extension, :delay, :time, :record_separator,
;TI"                  :list
;TI"
;TI"    def initialize
;TI"      self.library = []
;TI"       self.inplace = false
;TI""      self.encoding = "utf8"
;TI"&      self.transfer_type = :auto
;TI"       self.verbose = false
;TI"
    end
;TI"
;TI"$    def define_options(parser)
;TI"9      parser.banner = "Usage: example.rb [options]"
;TI"      parser.separator ""
;TI"0      parser.separator "Specific options:"
;TI"
;TI"$      # add additional options
;TI"*      perform_inplace_option(parser)
;TI"*      delay_execution_option(parser)
;TI"*      execute_at_time_option(parser)
;TI"3      specify_record_separator_option(parser)
;TI"'      list_example_option(parser)
;TI"+      specify_encoding_option(parser)
;TI"K      optional_option_argument_with_keyword_completion_option(parser)
;TI"*      boolean_verbose_option(parser)
;TI"
;TI"      parser.separator ""
;TI".      parser.separator "Common options:"
;TI"N      # No argument, shows at tail.  This will print an options summary.
;TI"      # Try it and see!
;TI"B      parser.on_tail("-h", "--help", "Show this message") do
;TI"        puts parser
;TI"        exit
;TI"      end
;TI":      # Another typical switch to print the version.
;TI":      parser.on_tail("--version", "Show version") do
;TI"        puts Version
;TI"        exit
;TI"      end
;TI"
    end
;TI"
;TI",    def perform_inplace_option(parser)
;TI"3      # Specifies an optional option argument
;TI"4      parser.on("-i", "--inplace [EXTENSION]",
;TI"1                "Edit ARGV files in place",
;TI"E                "(make backup if EXTENSION supplied)") do |ext|
;TI"!        self.inplace = true
;TI"(        self.extension = ext || ''
;TI"Y        self.extension.sub!(/\A\.?(?=.)/, ".")  # Ensure extension begins with dot.
;TI"      end
;TI"
    end
;TI"
;TI",    def delay_execution_option(parser)
;TI"/      # Cast 'delay' argument to a Float.
;TI"T      parser.on("--delay N", Float, "Delay N seconds before executing") do |n|
;TI"        self.delay = n
;TI"      end
;TI"
    end
;TI"
;TI",    def execute_at_time_option(parser)
;TI"4      # Cast 'time' argument to a Time object.
;TI"]      parser.on("-t", "--time [TIME]", Time, "Begin execution at given time") do |time|
;TI"        self.time = time
;TI"      end
;TI"
    end
;TI"
;TI"5    def specify_record_separator_option(parser)
;TI"$      # Cast to octal integer.
;TI"H      parser.on("-F", "--irs [OCTAL]", OptionParser::OctalInteger,
;TI"G                "Specify record separator (default \\0)") do |rs|
;TI"(        self.record_separator = rs
;TI"      end
;TI"
    end
;TI"
;TI")    def list_example_option(parser)
;TI"       # List of arguments.
;TI"U      parser.on("--list x,y,z", Array, "Example 'list' of arguments") do |list|
;TI"        self.list = list
;TI"      end
;TI"
    end
;TI"
;TI"-    def specify_encoding_option(parser)
;TI"W      # Keyword completion.  We are specifying a specific set of arguments (CODES
;TI"W      # and CODE_ALIASES - notice the latter is a Hash), and the user may provide
;TI",      # the shortest unambiguous text.
;TI">      code_list = (CODE_ALIASES.keys + CODES).join(', ')
;TI"L      parser.on("--code CODE", CODES, CODE_ALIASES, "Select encoding",
;TI"5                "(#{code_list})") do |encoding|
;TI"&        self.encoding = encoding
;TI"      end
;TI"
    end
;TI"
;TI"M    def optional_option_argument_with_keyword_completion_option(parser)
;TI"H      # Optional '--type' option argument with keyword completion.
;TI"?      parser.on("--type [TYPE]", [:text, :binary, :auto],
;TI"I                "Select transfer type (text, binary, auto)") do |t|
;TI"$        self.transfer_type = t
;TI"      end
;TI"
    end
;TI"
;TI",    def boolean_verbose_option(parser)
;TI"      # Boolean switch.
;TI"E      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
;TI"        self.verbose = v
;TI"      end
;TI"
    end
;TI"  end
;TI"
;TI"	  #
;TI"4  # Return a structure describing the options.
;TI"	  #
;TI"  def parse(args)
;TI"J    # The options specified on the command line will be collected in
;TI"    # *options*.
;TI"
;TI"&    @options = ScriptOptions.new
;TI".    @args = OptionParser.new do |parser|
;TI"+      @options.define_options(parser)
;TI"      parser.parse!(args)
;TI"
    end
;TI"    @options
;TI"  end
;TI"
;TI"%  attr_reader :parser, :options
;TI""end  # class OptparseExample
;TI"
;TI"#example = OptparseExample.new
;TI"#options = example.parse(ARGV)
;TI""pp options # example.options
;TI"
pp ARGV
;T;0S;;i;I"Shell Completion;T@'o;;[I"AFor modern shells (e.g. bash, zsh, etc.), you can use shell ;TI")completion for command line options.;T@'S;;i;I"Further documentation;T@'o;;[I"QThe above examples should be enough to learn how to use this class.  If you ;TI"Dhave any questions, file a ticket at http://bugs.ruby-lang.org.;T;	I"lib/optparse.rb;T;
0@K@@F0U;
[i�I"ParseError;FI"Object::ParseError;T0I"Racc::ParseError;To;;[�;	I"lib/racc/parser.rb;T;
0@S@@F0U;
[i�I"Synchronizer_m;FI"Object::Synchronizer_m;T0I"Sync_m;Fo;;[o;;[I"<A module that provides a two-phase lock with a counter.;T;	I"lib/sync.rb;T;
0@^@@F0U;
[i�I"Synchronizer;FI"Object::Synchronizer;T0I"	Sync;To;;[o;;[I"JA class that provides two-phase lock with a counter.  See Sync_m for ;TI"
details.;T;	@^;
0@^@@F0U;
[i�I"ThWait;FI"Object::ThWait;T0I"ThreadsWait;To;;[
o;;[	I"RThis class watches for termination of multiple threads.  Basic functionality ;TI"P(wait until specified threads have terminated) can be accessed through the ;TI"Mclass method ThreadsWait::all_waits.  Finer control can be gained using ;TI"instance methods.;T@'o;;[I"
Example:;T@'o;;[I"3ThreadsWait.all_waits(thr1, thr2, ...) do |t|
;TI"1  STDERR.puts "Thread #{t} has terminated."
;TI"	end
;TI"
;TI"'th = ThreadsWait.new(thread1,...)
;TI"'th.next_wait # next one to be done;T;0;	I"lib/thwait.rb;T;
0@�@@F0U;
[i�I"TimeoutError;FI"Object::TimeoutError;T0I"Timeout::Error;To;;[o;;[I"8Raised by Timeout#timeout when the block times out.;T;	@;
0@@@F0U;
[i�I"NIL;TI"Object::NIL;T00o;;[o;;[I"An alias of +nil+;T;	@7;
0@7@@F0U;
[i�I"	TRUE;TI"Object::TRUE;T00o;;[o;;[I"An alias of +true+;T;	@7;
0@7@@F0U;
[i�I"
FALSE;TI"Object::FALSE;T00o;;[o;;[I"An alias of +false+;T;	@7;
0@7@@F0U;
[i�I"	DATA;TI"Object::DATA;T00o;;[o;;[I"IDATA is a File that contains the data section of the executed file. ;TI"3To create a data section use <tt>__END__</tt>:;T@'o;;[I"$ cat t.rb
;TI"puts DATA.gets
;TI"
__END__
;TI"hello world!
;TI"
;TI"$ ruby t.rb
;TI"hello world!;T;0;	I"ruby.c;T;
0@�@@F0U;
[i�I"	ARGV;TI"Object::ARGV;T00o;;[o;;[I"?ARGV contains the command line arguments used to run ruby.;T@'o;;[I"EA library like OptionParser can be used to process command-line ;TI"arguments.;T;	@�;
0@�@@F0U;
[i�I"RUBY_VERSION;TI"Object::RUBY_VERSION;T00o;;[o;;[I" The running version of ruby;T;	I"version.c;T;
0@�@@F0U;
[i�I"RUBY_RELEASE_DATE;TI"Object::RUBY_RELEASE_DATE;T00o;;[o;;[I"$The date this ruby was released;T;	@�;
0@�@@F0U;
[i�I"RUBY_PLATFORM;TI"Object::RUBY_PLATFORM;T00o;;[o;;[I"The platform for this ruby;T;	@�;
0@�@@F0U;
[i�I"RUBY_PATCHLEVEL;TI"Object::RUBY_PATCHLEVEL;T00o;;[o;;[I"KThe patchlevel for this ruby.  If this is a development build of ruby ;TI"the patchlevel will be -1;T;	@�;
0@�@@F0U;
[i�I"RUBY_REVISION;TI"Object::RUBY_REVISION;T00o;;[o;;[I"$The SVN revision for this ruby.;T;	@�;
0@�@@F0U;
[i�I"RUBY_DESCRIPTION;TI"Object::RUBY_DESCRIPTION;T00o;;[o;;[I"@The full ruby version string, like <tt>ruby -v</tt> prints';T;	@�;
0@�@@F0U;
[i�I"RUBY_COPYRIGHT;TI"Object::RUBY_COPYRIGHT;T00o;;[o;;[I""The copyright string for ruby;T;	@�;
0@�@@F0U;
[i�I"RUBY_ENGINE;TI"Object::RUBY_ENGINE;T00o;;[o;;[I".The engine or interpreter this ruby uses.;T;	@�;
0@�@@F0U;
[i�I"RUBY_ENGINE_VERSION;TI" Object::RUBY_ENGINE_VERSION;T00o;;[o;;[I"=The version of the engine or interpreter this ruby uses.;T;	@�;
0@�@@F0U;
[i�I"TOPLEVEL_BINDING;TI"Object::TOPLEVEL_BINDING;T00o;;[o;;[I"'The Binding of the top level scope;T;	I"	vm.c;T;
0@%@@F0[[I"MakeMakefile;To;;[�;	I"lib/mkmf.rb;T;
0I"lib/mkmf.rb;T[I"Kernel;To;;[�;	@7;
0I"
object.c;T[[I"
class;T[[:public[[I"
yaml_tag;FI"$ext/psych/lib/psych/core_ext.rb;T[:protected[�[:private[�[I"
instance;T[[;[A[I"!~;T@1[I"<=>;T@1[I"===;T@1[I"=~;T@1[I"CSV;FI"lib/csv.rb;T[I"DelegateClass;FI"lib/delegate.rb;T[I"Digest;FI"ext/digest/lib/digest.rb;T[I"
class;T@1[I"
clone;T@1[I"dclone;FI"lib/rexml/xpath_parser.rb;T[I"default_src_encoding;FI"lib/irb/src_encoding.rb;T[I"define_singleton_method;TI"proc.c;T[I"display;TI"	io.c;T[I"dup;T@1[I"
enum_for;TI"enumerator.c;T[I"	eql?;T@1[I"extend;TI"eval.c;T[I"freeze;T@1[I"frozen?;T@1[I"	hash;T@1[I"inspect;T@1[I"instance_of?;T@1[I"instance_variable_defined?;T@1[I"instance_variable_get;T@1[I"instance_variable_set;T@1[I"instance_variables;T@1[I"
is_a?;T@1[I"itself;T@1[I"
kind_of?;T@1[I"method;T@a[I"methods;T@1[I"	nil?;T@1[I"object_id;TI"	gc.c;T[I"private_methods;T@1[I"protected_methods;T@1[I"psych_to_yaml;F@:[I"public_method;T@a[I"public_methods;T@1[I"public_send;TI"vm_eval.c;T[I"remove_instance_variable;T@1[I"respond_to?;TI"vm_method.c;T[I"respond_to_missing?;T@�[I"	send;T@�[I"singleton_class;T@1[I"singleton_method;T@a[I"singleton_methods;T@1[I"sysread;FI"*lib/webrick/httpservlet/cgi_runner.rb;T[I"
taint;T@1[I"
tainted?;T@1[I"tap;T@1[I"timeout;FI"lib/timeout.rb;T[I"to_enum;T@i[I"	to_s;T@1[I"to_yaml;T@:[I"
trust;T@1[I"unknown;TI"lib/mathn.rb;T[I"untaint;T@1[I"untrust;T@1[I"untrusted?;T@1[I"xmp;FI"lib/irb/xmp.rb;T[;[�[;[�[�[U:RDoc::Context::Section[i�0o;;[�;	0;
0[-@
I"enumerator.c;TI"eval.c;TI"ext/digest/lib/digest.rb;T@@@EI"	gc.c;T@S@]I"lib/English.rb;TI"lib/csv.rb;TI"lib/debug.rb;TI"lib/delegate.rb;TI"lib/drb/drb.rb;T@I"lib/irb/src_encoding.rb;TI"lib/irb/xmp.rb;TI"lib/mathn.rb;T@+@KI"lib/pp.rb;T@S@I"lib/rubygems/syck_hack.rb;T@^@�@I"lib/tracer.rb;TI"lib/un.rb;TI"*lib/webrick/httpservlet/cgi_runner.rb;TI"lib/yaml.rb;T@7I"parse.c;TI"proc.c;T@�@�@%I"vm_eval.c;TI"vm_method.c;T@�cRDoc::TopLevel