IRB::Context

 
               # File irb/context.rb, line 22
    def initialize(irb, workspace = nil, input_method = nil, output_method = nil)
      @irb = irb
      if workspace
        @workspace = workspace
      else
        @workspace = WorkSpace.new
      end
      @thread = Thread.current if defined? Thread
#      @irb_level = 0

      # copy of default configuration
      @ap_name = IRB.conf[:AP_NAME]
      @rc = IRB.conf[:RC]
      @load_modules = IRB.conf[:LOAD_MODULES]

      @use_readline = IRB.conf[:USE_READLINE]
      @inspect_mode = IRB.conf[:INSPECT_MODE]

      self.math_mode = IRB.conf[:MATH_MODE] if IRB.conf[:MATH_MODE]
      self.use_tracer = IRB.conf[:USE_TRACER] if IRB.conf[:USE_TRACER]
      self.use_loader = IRB.conf[:USE_LOADER] if IRB.conf[:USE_LOADER]
      self.eval_history = IRB.conf[:EVAL_HISTORY] if IRB.conf[:EVAL_HISTORY]

      @ignore_sigint = IRB.conf[:IGNORE_SIGINT]
      @ignore_eof = IRB.conf[:IGNORE_EOF]

      @back_trace_limit = IRB.conf[:BACK_TRACE_LIMIT]
      
      self.prompt_mode = IRB.conf[:PROMPT_MODE]

      if IRB.conf[:SINGLE_IRB] or !defined?(JobManager)
        @irb_name = IRB.conf[:IRB_NAME]
      else
        @irb_name = "irb#"+IRB.JobManager.n_jobs.to_s
      end
      @irb_path = "(" + @irb_name + ")"

      case input_method
      when nil
        case use_readline?
        when nil
          if (defined?(ReadlineInputMethod) && STDIN.tty? &&
              IRB.conf[:PROMPT_MODE] != :INF_RUBY)
            @io = ReadlineInputMethod.new
          else
            @io = StdioInputMethod.new
          end
        when false
          @io = StdioInputMethod.new
        when true
          if defined?(ReadlineInputMethod)
            @io = ReadlineInputMethod.new
          else
            @io = StdioInputMethod.new
          end
        end

      when String
        @io = FileInputMethod.new(input_method)
        @irb_name = File.basename(input_method)
        @irb_path = input_method
      else
        @io = input_method
      end
      self.save_history = IRB.conf[:SAVE_HISTORY] if IRB.conf[:SAVE_HISTORY]

      if output_method
        @output_method = output_method
      else
        @output_method = StdioOutputMethod.new
      end

      @verbose = IRB.conf[:VERBOSE] 
      @echo = IRB.conf[:ECHO]
      if @echo.nil?
        @echo = true
      end
      @debug_level = IRB.conf[:DEBUG_LEVEL]
    end
            

 
               # File irb/ext/change-ws.rb, line 24
def change_workspace(*_main)
  if _main.empty?
    @workspace = home_workspace 
    return main
  end
  
  @workspace = WorkSpace.new(_main[0])
  
  if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
    main.extend ExtendCommandBundle
  end
end
            

 
               # File irb/context.rb, line 213
def debug?
  @debug_level > 0
end
            

 
               # File irb/context.rb, line 207
def debug_level=(value)
  @debug_level = value
  RubyLex.debug_level = value
  SLex.debug_level = value
end
            

 
               # File irb/ext/history.rb, line 34
def eval_history=(no)
  if no
    if defined?(@eval_history) && @eval_history
      @eval_history_values.size(no)
    else
      @eval_history_values = History.new(no)
      IRB.conf[:__TMP__EHV__] = @eval_history_values
      @workspace.evaluate(self, "__ = IRB.conf[:__TMP__EHV__]")
      IRB.conf.delete(:__TMP_EHV__)
    end
  else
    @eval_history_values = nil
  end
  @eval_history = no
end
            

 
               # File irb/context.rb, line 217
    def evaluate(line, line_no)
      @line_no = line_no
      set_last_value(@workspace.evaluate(self, line, irb_path, line_no))
#      @workspace.evaluate("_ = IRB.conf[:MAIN_CONTEXT]._")
#      @_ = @workspace.evaluate(line, irb_path, line_no)
    end
            

 
               # File irb/context.rb, line 225
def exit(ret = 0)
  IRB.irb_exit(@irb, ret)
end
            

 
               # File irb/context.rb, line 188
def file_input?
  @io.class == FileInputMethod
end
            

 
               # File irb/ext/save-history.rb, line 41
def history_file
  IRB.conf[:HISTORY_FILE]
end
            

 
               # File irb/ext/save-history.rb, line 45
def history_file=(hist)
  IRB.conf[:HISTORY_FILE] = hist
end
            

 
               # File irb/ext/change-ws.rb, line 16
def home_workspace
  if defined? @home_workspace
    @home_workspace
  else
    @home_workspace = @workspace
  end
end
            

 
               # File irb/ext/save-history.rb, line 22
def init_save_history
  unless (class<<@io;self;end).include?(HistorySavingAbility)
    @io.extend(HistorySavingAbility)
  end
end
            

 
               # File irb/context.rb, line 234
def inspect
  array = []
  for ivar in instance_variables.sort{|e1, e2| e1 <=> e2}
    name = ivar.sub(/^@(.*)$/){$1}
    val = instance_eval(ivar)
    case ivar
    when *NOPRINTING_IVARS
      array.push format("conf.%s=%s", name, "...")
    when *NO_INSPECTING_IVARS
      array.push format("conf.%s=%s", name, val.to_s)
    when *IDNAME_IVARS
      array.push format("conf.%s=:%s", name, val.id2name)
    else
      array.push format("conf.%s=%s", name, val.inspect)
    end
  end
  array.join("\n")
end
            

 
               # File irb/context.rb, line 184
def inspect?
  @inspect_mode.nil? or @inspect_mode
end
            

 
               # File irb/context.rb, line 192
def inspect_mode=(opt)
  if opt
    @inspect_mode = opt
  else
    @inspect_mode = !@inspect_mode
  end
  print "Switch to#{unless @inspect_mode; ' non';end} inspect mode.\n" if verbose?
  @inspect_mode
end
            

 
               # File irb/ext/workspaces.rb, line 16
def irb_level
  workspace_stack.size
end
            

 
               # File irb/context.rb, line 102
def main
  @workspace.main
end
            

 
               # File irb/ext/math-mode.rb, line 19
def math_mode=(opt)
  if @math_mode == true && opt == false
    IRB.fail CantReturnToNormalMode
    return
  end

  @math_mode = opt
  if math_mode
    main.extend Math
    print "start math mode\n" if verbose?
  end
end
            

 
               # File irb/ext/workspaces.rb, line 47
def pop_workspace
  if workspaces.empty?
    print "workspace stack empty\n"
    return
  end
  @workspace = workspaces.pop
end
            

 
               # File irb/context.rb, line 169
def prompt_mode=(mode)
  @prompt_mode = mode
  pconf = IRB.conf[:PROMPT][mode]
  @prompt_i = pconf[:PROMPT_I]
  @prompt_s = pconf[:PROMPT_S]
  @prompt_c = pconf[:PROMPT_C]
  @prompt_n = pconf[:PROMPT_N]
  @return_format = pconf[:RETURN]
  if ai = pconf.include?(:AUTO_INDENT)
    @auto_indent_mode = ai
  else
    @auto_indent_mode = IRB.conf[:AUTO_INDENT]
  end
end
            

 
               # File irb/context.rb, line 155
def prompting?
  verbose? || (STDIN.tty? && @io.kind_of?(StdioInputMethod) ||
            (defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)))
end
            

 
               # File irb/ext/workspaces.rb, line 28
def push_workspace(*_main)
  if _main.empty?
    if workspaces.empty?
      print "No other workspace\n"
      return nil
    end
    ws = workspaces.pop
    workspaces.push @workspace
    @workspace = ws
    return workspaces
  end

  workspaces.push @workspace
  @workspace = WorkSpace.new(@workspace.binding, _main[0])
  if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
    main.extend ExtendCommandBundle
  end
end
            

 
               # File irb/ext/save-history.rb, line 28
def save_history
  IRB.conf[:SAVE_HISTORY]
end
            

 
               # File irb/ext/save-history.rb, line 32
def save_history=(val)
  IRB.conf[:SAVE_HISTORY] = val
  if val
    main_context = IRB.conf[:MAIN_CONTEXT]
    main_context = self unless main_context
    main_context.init_save_history
  end
end
            

 
               # File irb/context.rb, line 162
def set_last_value(value)
  @last_value = value
  @workspace.evaluate self, "_ = IRB.CurrentContext.last_value"
end
            

 
               # File irb/ext/use-loader.rb, line 35
def use_loader
  IRB.conf[:USE_LOADER]
end
            

 
               # File irb/ext/use-loader.rb, line 41
def use_loader=(opt)

  if IRB.conf[:USE_LOADER] != opt
    IRB.conf[:USE_LOADER] = opt
    if opt
      if !$".include?("irb/cmd/load")
      end
      (class<<@workspace.main;self;end).instance_eval {
        alias_method :load, :irb_load
        alias_method :require, :irb_require
      }
    else
      (class<<@workspace.main;self;end).instance_eval {
        alias_method :load, :__original__load__IRB_use_loader__
        alias_method :require, :__original__require__IRB_use_loader__
      }
    end
  end
  print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
  opt
end
            

 
               # File irb/context.rb, line 202
def use_readline=(opt)
  @use_readline = opt
  print "use readline module\n" if @use_readline
end
            

 
               # File irb/ext/tracer.rb, line 30
def use_tracer=(opt)
  if opt
    Tracer.set_get_line_procs(@irb_path) {
      |line_no, *rests|
      @io.line(line_no)
    }
  elsif !opt && @use_tracer
    Tracer.off
  end
  @use_tracer=opt
end
            

 
               # File irb/context.rb, line 143
def verbose?
  if @verbose.nil?
    if defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod) 
      false
    elsif !STDIN.tty? or @io.kind_of?(FileInputMethod)
      true
    else
      false
    end
  end
end
            

 
               # File irb/ext/workspaces.rb, line 20
def workspaces
  if defined? @workspaces
    @workspaces
  else
    @workspaces = []
  end
end