mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* sample/irb.rb, lib/irb.rb, lib/irb/*, doc/irb/*: Merge from irb
0.7.3 and irb-tools 0.7.1. * instruby.rb: Install help-message's too. * lib/irb/main.rb: This file is not needed anymore. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_6@1351 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
knu
parent
b346da947e
commit
7083ecb820
14 changed files with 231 additions and 954 deletions
|
|
@ -1,3 +1,12 @@
|
|||
Tue May 1 03:36:50 2001 Akinori MUSHA <knu@iDaemons.org>
|
||||
|
||||
* sample/irb.rb, lib/irb.rb, lib/irb/*, doc/irb/*: Merge from irb
|
||||
0.7.3 and irb-tools 0.7.1.
|
||||
|
||||
* instruby.rb: Install help-message's too.
|
||||
|
||||
* lib/irb/main.rb: This file is not needed anymore.
|
||||
|
||||
Thu Apr 26 22:36:11 2001 WATANABE Hirofumi <eban@ruby-lang.org>
|
||||
|
||||
* configure.in: don't use tzname on cygwin 1.3.1+.
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ Dir.chdir CONFIG["srcdir"]
|
|||
File.install "sample/irb.rb", "#{bindir}/irb", 0755, true
|
||||
|
||||
Find.find("lib") do |f|
|
||||
next unless /\.rb$/ =~ f
|
||||
next unless /\.rb$/ =~ f || /help-message$/ =~ f
|
||||
dir = rubylibdir+"/"+File.dirname(f[4..-1])
|
||||
File.makedirs dir, true unless File.directory? dir
|
||||
File.install f, dir, 0644, true
|
||||
|
|
|
|||
|
|
@ -1,8 +1,19 @@
|
|||
#
|
||||
# irb/completor.rb -
|
||||
# $Release Version: 0.7.1$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
# From Original Idea of shugo@ruby-lang.org
|
||||
#
|
||||
|
||||
require "readline"
|
||||
|
||||
module IRB
|
||||
module InputCompletion
|
||||
module InputCompletor
|
||||
|
||||
@RCS_ID='-$Id$-'
|
||||
|
||||
ReservedWords = [
|
||||
"BEGIN", "END",
|
||||
"alias", "and",
|
||||
|
|
@ -20,28 +31,147 @@ module IRB
|
|||
"then", "true",
|
||||
"undef", "unless", "until",
|
||||
"when", "while",
|
||||
"yield"
|
||||
"yield",
|
||||
]
|
||||
|
||||
CompletionProc = proc { |input|
|
||||
bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
|
||||
case input
|
||||
when /^([^.]+)\.([^.]*)$/
|
||||
when /^(\/[^\/]*\/)\.([^.]*)$/
|
||||
# Regexp
|
||||
receiver = $1
|
||||
message = $2
|
||||
if eval("(local_variables|#{receiver}.type.constants).include?('#{receiver}')",
|
||||
IRB.conf[:MAIN_CONTEXT].bind)
|
||||
candidates = eval("#{receiver}.methods", IRB.conf[:MAIN_CONTEXT].bind)
|
||||
message = Regexp.quote($2)
|
||||
|
||||
candidates = Regexp.instance_methods(true)
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
when /^([^\]]*\])\.([^.]*)$/
|
||||
# Array
|
||||
receiver = $1
|
||||
message = Regexp.quote($2)
|
||||
|
||||
candidates = Array.instance_methods(true)
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
when /^([^\}]*\})\.([^.]*)$/
|
||||
# Proc or Hash
|
||||
receiver = $1
|
||||
message = Regexp.quote($2)
|
||||
|
||||
candidates = Proc.instance_methods(true) | Hash.instance_methods(true)
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
when /^(:[^:]*)$/
|
||||
# Symbol
|
||||
if Symbol.respond_to?(:all_symbols)
|
||||
sym = $1
|
||||
candidates = Symbol.all_symbols.collect{|s| s.id2name}
|
||||
candidates.grep(/^#{sym}/)
|
||||
else
|
||||
[]
|
||||
end
|
||||
|
||||
when /^::([A-Z][^:\.\(]*)$/
|
||||
# Absolute Constant or class methods
|
||||
receiver = $1
|
||||
candidates = Object.constants
|
||||
candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
|
||||
|
||||
when /^(((::)?[A-Z][^:.\(]*)+)::?([^:.]*)$/
|
||||
# Constant or class methods
|
||||
receiver = $1
|
||||
message = Regexp.quote($4)
|
||||
begin
|
||||
candidates = eval("#{receiver}.constants | #{receiver}.methods", bind)
|
||||
rescue Exception
|
||||
candidates = []
|
||||
end
|
||||
candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
|
||||
|
||||
when /^(:[^.]+)\.([^.]*)$/
|
||||
# Symbol
|
||||
receiver = $1
|
||||
message = Regexp.quote($2)
|
||||
|
||||
candidates = Symbol.instance_methods(true)
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
when /^([0-9_]+(\.[0-9_]+)?(e[0-9]+)?)\.([^.]*)$/
|
||||
# Numeric
|
||||
receiver = $1
|
||||
message = Regexp.quote($4)
|
||||
|
||||
begin
|
||||
candidates = eval(receiver, bind).methods
|
||||
rescue Exception
|
||||
candidates
|
||||
end
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
# when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
|
||||
when /^((\.?[^.]+)+)\.([^.]*)$/
|
||||
# variable
|
||||
receiver = $1
|
||||
message = Regexp.quote($3)
|
||||
|
||||
gv = eval "global_variables", bind
|
||||
lv = eval "local_variables", bind
|
||||
cv = eval "type.constants", bind
|
||||
|
||||
if (gv | lv | cv).include?(receiver)
|
||||
# foo.func and foo is local var.
|
||||
candidates = eval("#{receiver}.methods", bind)
|
||||
elsif /^[A-Z]/ =~ receiver and /\./ !~ receiver
|
||||
# Foo::Bar.func
|
||||
begin
|
||||
candidates = eval("#{receiver}.methods", bind)
|
||||
rescue Exception
|
||||
candidates = []
|
||||
end
|
||||
candidates.grep(/^#{Regexp.quote(message)}/).collect{|e| receiver + "." + e}
|
||||
else
|
||||
candidates = eval("methods | private_methods | local_variables | type.constants",
|
||||
IRB.conf[:MAIN_CONTEXT].bind)
|
||||
# func1.func2
|
||||
candidates = []
|
||||
ObjectSpace.each_object(Module){|m|
|
||||
next if /^(IRB|SLex|RubyLex|RubyToken)/ =~ m.name
|
||||
candidates.concat m.instance_methods
|
||||
}
|
||||
candidates.sort!
|
||||
candidates.uniq!
|
||||
end
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
when /^\.([^.]*)$/
|
||||
# unknown(maybe String)
|
||||
|
||||
receiver = ""
|
||||
message = Regexp.quote($1)
|
||||
|
||||
candidates = String.instance_methods(true)
|
||||
select_message(receiver, message, candidates)
|
||||
|
||||
else
|
||||
candidates = eval("methods | private_methods | local_variables | type.constants", bind)
|
||||
|
||||
(candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
|
||||
end
|
||||
}
|
||||
|
||||
Operators = ["%", "&", "*", "**", "+", "-", "/",
|
||||
"<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
|
||||
"[]", "[]=", "^",]
|
||||
|
||||
def self.select_message(receiver, message, candidates)
|
||||
candidates.grep(/^#{message}/).collect do |e|
|
||||
case e
|
||||
when /^[a-zA-Z_]/
|
||||
receiver + "." + e
|
||||
when /^[0-9]/
|
||||
when *Operators
|
||||
#receiver + " " + e
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
Readline.completion_proc = IRB::InputCompletion::CompletionProc
|
||||
Readline.completion_proc = IRB::InputCompletor::CompletionProc
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#
|
||||
# frame.rb -
|
||||
# $Release Version: 0.6$
|
||||
# $Release Version: 0.7.1$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# input-method.rb - input methods using irb
|
||||
# $Release Version: 0.6$
|
||||
# irb/input-method.rb - input methods using irb
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -23,9 +23,9 @@ module IRB
|
|||
def initialize(file = STDIN_FILE_NAME)
|
||||
@file_name = file
|
||||
end
|
||||
attr :file_name
|
||||
attr_reader :file_name
|
||||
|
||||
attr :prompt, true
|
||||
attr_accessor :prompt
|
||||
|
||||
def gets
|
||||
IRB.fail NotImplementError, "gets"
|
||||
|
|
@ -67,7 +67,7 @@ module IRB
|
|||
super
|
||||
@io = open(file)
|
||||
end
|
||||
attr :file_name
|
||||
attr_reader :file_name
|
||||
|
||||
def eof?
|
||||
@io.eof?
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# irb-loader.rb -
|
||||
# $Release Version: 0.6$
|
||||
# irb/loader.rb - irb loader
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
|
|||
867
lib/irb/main.rb
867
lib/irb/main.rb
|
|
@ -1,867 +0,0 @@
|
|||
#
|
||||
# main.rb - irb main module
|
||||
# $Release Version: 0.6 $
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
#
|
||||
# --
|
||||
#
|
||||
#
|
||||
#
|
||||
require "e2mmap"
|
||||
require "irb/ruby-lex"
|
||||
require "irb/input-method"
|
||||
require "irb/workspace-binding"
|
||||
|
||||
STDOUT.sync = true
|
||||
|
||||
module IRB
|
||||
@RCS_ID='-$Id$-'
|
||||
|
||||
# exceptions
|
||||
extend Exception2MessageMapper
|
||||
def_exception :UnrecognizedSwitch, "Unrecognized switch: %s"
|
||||
def_exception :NotImplementError, "Need to define `%s'"
|
||||
def_exception :CantRetuenNormalMode, "Can't return normal mode."
|
||||
def_exception :IllegalParameter, "Illegal parameter(%s)."
|
||||
def_exception :IrbAlreadyDead, "Irb is already dead."
|
||||
def_exception :IrbSwitchToCurrentThread, "Change to current thread."
|
||||
def_exception :NoSuchJob, "No such job(%s)."
|
||||
def_exception :CanNotGoMultiIrbMode, "Can't go multi irb mode."
|
||||
def_exception :CanNotChangeBinding, "Can't change binding to (%s)."
|
||||
def_exception :UndefinedPromptMode, "Undefined prompt mode(%s)."
|
||||
|
||||
class Abort < Exception;end
|
||||
|
||||
# initialize IRB and start TOP_LEVEL irb
|
||||
def IRB.start(ap_path = nil)
|
||||
$0 = File::basename(ap_path, ".rb") if ap_path
|
||||
|
||||
IRB.initialize(ap_path)
|
||||
IRB.parse_opts
|
||||
IRB.load_modules
|
||||
|
||||
bind = workspace_binding
|
||||
main = eval("self", bind)
|
||||
|
||||
if @CONF[:SCRIPT]
|
||||
irb = Irb.new(main, bind, @CONF[:SCRIPT])
|
||||
else
|
||||
irb = Irb.new(main, bind)
|
||||
end
|
||||
|
||||
@CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
|
||||
@CONF[:MAIN_CONTEXT] = irb.context
|
||||
|
||||
trap("SIGINT") do
|
||||
irb.signal_handle
|
||||
end
|
||||
|
||||
catch(:IRB_EXIT) do
|
||||
irb.eval_input
|
||||
end
|
||||
print "\n"
|
||||
end
|
||||
|
||||
# initialize config
|
||||
def IRB.initialize(ap_path)
|
||||
IRB.init_config(ap_path)
|
||||
IRB.run_config
|
||||
end
|
||||
|
||||
#
|
||||
# @CONF functions
|
||||
#
|
||||
@CONF = {}
|
||||
# @CONF default setting
|
||||
def IRB.init_config(ap_path)
|
||||
# class instance variables
|
||||
@TRACER_INITIALIZED = false
|
||||
@MATHN_INITIALIZED = false
|
||||
|
||||
# default configurations
|
||||
unless ap_path and @CONF[:AP_NAME]
|
||||
ap_path = File.join(File.dirname(File.dirname(__FILE__)), "irb.rb")
|
||||
end
|
||||
@CONF[:AP_NAME] = File::basename(ap_path, ".rb")
|
||||
|
||||
@CONF[:IRB_NAME] = "irb"
|
||||
@CONF[:IRB_LIB_PATH] = File.dirname(__FILE__)
|
||||
|
||||
@CONF[:RC] = true
|
||||
@CONF[:LOAD_MODULES] = []
|
||||
@CONF[:IRB_RC] = nil
|
||||
|
||||
@CONF[:MATH_MODE] = false
|
||||
@CONF[:USE_READLINE] = false unless defined?(ReadlineInputMethod)
|
||||
@CONF[:INSPECT_MODE] = nil
|
||||
@CONF[:USE_TRACER] = false
|
||||
@CONF[:USE_LOADER] = false
|
||||
@CONF[:IGNORE_SIGINT] = true
|
||||
@CONF[:IGNORE_EOF] = false
|
||||
|
||||
@CONF[:BACK_TRACE_LIMIT] = 16
|
||||
|
||||
@CONF[:PROMPT] = {
|
||||
:NULL => {
|
||||
:PROMPT_I => nil,
|
||||
:PROMPT_S => nil,
|
||||
:PROMPT_C => nil,
|
||||
:RETURN => "%s\n"
|
||||
},
|
||||
:DEFAULT => {
|
||||
:PROMPT_I => "%N(%m):%03n:%i> ",
|
||||
:PROMPT_S => "%N(%m):%03n:%i%l ",
|
||||
:PROMPT_C => "%N(%m):%03n:%i* ",
|
||||
:RETURN => "%s\n"
|
||||
},
|
||||
:SIMPLE => {
|
||||
:PROMPT_I => ">> ",
|
||||
:PROMPT_S => nil,
|
||||
:PROMPT_C => "?> ",
|
||||
:RETURN => "=> %s\n"
|
||||
},
|
||||
:INF_RUBY => {
|
||||
:PROMPT_I => "%N(%m):%03n:%i> ",
|
||||
:PROMPT_S => nil,
|
||||
:PROMPT_C => nil,
|
||||
:RETURN => "%s\n",
|
||||
:AUTO_INDENT => true
|
||||
},
|
||||
:XMP => {
|
||||
:PROMPT_I => nil,
|
||||
:PROMPT_S => nil,
|
||||
:PROMPT_C => nil,
|
||||
:RETURN => " ==>%s\n"
|
||||
}
|
||||
}
|
||||
|
||||
@CONF[:PROMPT_MODE] = :DEFAULT
|
||||
@CONF[:AUTO_INDENT] = false
|
||||
|
||||
@CONF[:CONTEXT_MODE] = 3
|
||||
@CONF[:SINGLE_IRB] = false
|
||||
|
||||
@CONF[:DEBUG_LEVEL] = 1
|
||||
@CONF[:VERBOSE] = true
|
||||
end
|
||||
|
||||
# IRB version method
|
||||
def IRB.version
|
||||
if v = @CONF[:VERSION] then return v end
|
||||
|
||||
require "irb/version"
|
||||
rv = @RELEASE_VERSION.sub(/\.0/, "")
|
||||
@CONF[:VERSION] = format("irb %s(%s)", rv, @LAST_UPDATE_DATE)
|
||||
end
|
||||
|
||||
def IRB.conf
|
||||
@CONF
|
||||
end
|
||||
|
||||
# option analyzing
|
||||
def IRB.parse_opts
|
||||
while opt = ARGV.shift
|
||||
case opt
|
||||
when "-f"
|
||||
opt = ARGV.shift
|
||||
@CONF[:RC] = false
|
||||
when "-m"
|
||||
@CONF[:MATH_MODE] = true
|
||||
when "-d"
|
||||
$DEBUG = true
|
||||
when "-r"
|
||||
opt = ARGV.shift
|
||||
@CONF[:LOAD_MODULES].push opt if opt
|
||||
when "--inspect"
|
||||
@CONF[:INSPECT_MODE] = true
|
||||
when "--noinspect"
|
||||
@CONF[:INSPECT_MODE] = false
|
||||
when "--readline"
|
||||
@CONF[:USE_READLINE] = true
|
||||
when "--noreadline"
|
||||
@CONF[:USE_READLINE] = false
|
||||
when "--prompt-mode", "--prompt"
|
||||
prompt_mode = ARGV.shift.upcase.tr("-", "_").intern
|
||||
IRB.fail(UndefinedPromptMode,
|
||||
prompt_mode.id2name) unless @CONF[:PROMPT][prompt_mode]
|
||||
@CONF[:PROMPT_MODE] = prompt_mode
|
||||
when "--noprompt"
|
||||
@CONF[:PROMPT_MODE] = :NULL
|
||||
when "--inf-ruby-mode"
|
||||
@CONF[:PROMPT_MODE] = :INF_RUBY
|
||||
when "--sample-book-mode", "--simple-prompt"
|
||||
@CONF[:PROMPT_MODE] = :SIMPLE
|
||||
when "--tracer"
|
||||
@CONF[:USE_TRACER] = true
|
||||
when "--back-trace-limit"
|
||||
@CONF[:BACK_TRACE_LIMIT] = ARGV.shift.to_i
|
||||
when "--context-mode"
|
||||
@CONF[:CONTEXT_MODE] = ARGV.shift.to_i
|
||||
when "--single-irb"
|
||||
@CONF[:SINGLE_IRB] = true
|
||||
when "--irb_debug"
|
||||
@CONF[:DEBUG_LEVEL] = ARGV.shift.to_i
|
||||
when "-v", "--version"
|
||||
print IRB.version, "\n"
|
||||
exit(0)
|
||||
when /^-/
|
||||
IRB.fail UnrecognizedSwitch, opt
|
||||
else
|
||||
@CONF[:USE_READLINE] = false
|
||||
@CONF[:SCRIPT] = opt
|
||||
$0 = opt
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# running config
|
||||
def IRB.run_config
|
||||
if @CONF[:RC]
|
||||
rcs = []
|
||||
rcs.push File.expand_path("~/.irbrc") if ENV.key?("HOME")
|
||||
rcs.push ".irbrc"
|
||||
rcs.push "irb.rc"
|
||||
rcs.push "_irbrc"
|
||||
rcs.push "$irbrc"
|
||||
catch(:EXIT) do
|
||||
for rc in rcs
|
||||
begin
|
||||
load rc
|
||||
throw :EXIT
|
||||
rescue LoadError, Errno::ENOENT
|
||||
rescue
|
||||
print "load error: #{rc}\n"
|
||||
print $!.type, ": ", $!, "\n"
|
||||
for err in $@[0, $@.size - 2]
|
||||
print "\t", err, "\n"
|
||||
end
|
||||
throw :EXIT
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# loading modules
|
||||
def IRB.load_modules
|
||||
for m in @CONF[:LOAD_MODULES]
|
||||
begin
|
||||
require m
|
||||
rescue
|
||||
print $@[0], ":", $!.type, ": ", $!, "\n"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# initialize tracing function
|
||||
def IRB.initialize_tracer
|
||||
unless @TRACER_INITIALIZED
|
||||
require("tracer")
|
||||
Tracer.verbose = false
|
||||
Tracer.add_filter {
|
||||
|event, file, line, id, binding|
|
||||
File::dirname(file) != @CONF[:IRB_LIB_PATH]
|
||||
}
|
||||
@TRACER_INITIALIZED = true
|
||||
end
|
||||
end
|
||||
|
||||
# initialize mathn function
|
||||
def IRB.initialize_mathn
|
||||
unless @MATHN_INITIALIZED
|
||||
require "mathn"
|
||||
@MATHN_INITIALIZED = true
|
||||
end
|
||||
end
|
||||
|
||||
# initialize loader function
|
||||
def IRB.initialize_loader
|
||||
unless @LOADER_INITIALIZED
|
||||
require "irb/loader"
|
||||
@LOADER_INITIALIZED = true
|
||||
end
|
||||
end
|
||||
|
||||
def IRB.irb_exit(irb, ret)
|
||||
throw :IRB_EXIT, ret
|
||||
end
|
||||
|
||||
def IRB.irb_abort(irb, exception = Abort)
|
||||
if defined? Thread
|
||||
irb.context.thread.raise exception, "abort then interrupt!!"
|
||||
else
|
||||
raise exception, "abort then interrupt!!"
|
||||
end
|
||||
end
|
||||
|
||||
#
|
||||
# irb interpriter main routine
|
||||
#
|
||||
class Irb
|
||||
def initialize(main, bind, input_method = nil)
|
||||
@context = Context.new(self, main, bind, input_method)
|
||||
main.extend ExtendCommand
|
||||
@signal_status = :IN_IRB
|
||||
|
||||
@scanner = RubyLex.new
|
||||
@scanner.exception_on_syntax_error = false
|
||||
end
|
||||
attr :context
|
||||
attr :scanner, true
|
||||
|
||||
def eval_input
|
||||
# @scanner = RubyLex.new
|
||||
@scanner.set_input(@context.io) do
|
||||
signal_status(:IN_INPUT) do
|
||||
unless l = @context.io.gets
|
||||
if @context.ignore_eof? and @context.io.readable_atfer_eof?
|
||||
l = "\n"
|
||||
if @context.verbose?
|
||||
printf "Use \"exit\" to leave %s\n", @context.ap_name
|
||||
end
|
||||
end
|
||||
end
|
||||
l
|
||||
end
|
||||
end
|
||||
|
||||
@scanner.set_prompt do
|
||||
|ltype, indent, continue, line_no|
|
||||
if ltype
|
||||
f = @context.prompt_s
|
||||
elsif continue
|
||||
f = @context.prompt_c
|
||||
else @context.prompt_i
|
||||
f = @context.prompt_i
|
||||
end
|
||||
f = "" unless f
|
||||
@context.io.prompt = p = prompt(f, ltype, indent, line_no)
|
||||
if @context.auto_indent_mode
|
||||
unless ltype
|
||||
ind = prompt(@context.prompt_i, ltype, indent, line_no).size +
|
||||
indent * 2 - p.size
|
||||
ind += 2 if continue
|
||||
@context.io.prompt = p + " " * ind if ind > 0
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@scanner.each_top_level_statement do
|
||||
|line, line_no|
|
||||
signal_status(:IN_EVAL) do
|
||||
begin
|
||||
trace_in do
|
||||
@context._ = eval(line, @context.bind, @context.irb_path, line_no)
|
||||
# @context._ = irb_eval(line, @context.bind, @context.irb_path, line_no)
|
||||
end
|
||||
|
||||
if @context.inspect?
|
||||
printf @context.return_format, @context._.inspect
|
||||
else
|
||||
printf @context.return_format, @context._
|
||||
end
|
||||
rescue StandardError, ScriptError, Abort
|
||||
$! = RuntimeError.new("unknown exception raised") unless $!
|
||||
print $!.type, ": ", $!, "\n"
|
||||
if $@[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && $!.type.to_s !~ /^IRB/
|
||||
irb_bug = true
|
||||
else
|
||||
irb_bug = false
|
||||
end
|
||||
|
||||
messages = []
|
||||
lasts = []
|
||||
levels = 0
|
||||
for m in $@
|
||||
if m !~ /irb2?(\/.*|-.*|\.rb)?:/ or irb_bug
|
||||
if messages.size < @context.back_trace_limit
|
||||
messages.push m
|
||||
else
|
||||
lasts.push m
|
||||
if lasts.size > @context.back_trace_limit
|
||||
lasts.shift
|
||||
levels += 1
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
print messages.join("\n"), "\n"
|
||||
unless lasts.empty?
|
||||
printf "... %d levels...\n", levels if levels > 0
|
||||
print lasts.join("\n")
|
||||
end
|
||||
print "Maybe IRB bug!!\n" if irb_bug
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# def irb_eval(line, bind, path, line_no)
|
||||
# id, str = catch(:IRB_TOPLEVEL_EVAL){
|
||||
# return eval(line, bind, path, line_no)
|
||||
# }
|
||||
# case id
|
||||
# when :EVAL_TOPLEVEL
|
||||
# eval(str, bind, "(irb_internal)", 1)
|
||||
# when :EVAL_CONTEXT
|
||||
# @context.instance_eval(str)
|
||||
# else
|
||||
# IRB.fail IllegalParameter
|
||||
# end
|
||||
# end
|
||||
|
||||
def signal_handle
|
||||
unless @context.ignore_sigint?
|
||||
print "\nabort!!\n" if @context.verbose?
|
||||
exit
|
||||
end
|
||||
|
||||
case @signal_status
|
||||
when :IN_INPUT
|
||||
print "^C\n"
|
||||
@scanner.initialize_input
|
||||
print @context.io.prompt
|
||||
when :IN_EVAL
|
||||
IRB.irb_abort(self)
|
||||
when :IN_LOAD
|
||||
IRB.irb_abort(self, LoadAbort)
|
||||
when :IN_IRB
|
||||
# ignore
|
||||
else
|
||||
# ignore
|
||||
end
|
||||
end
|
||||
|
||||
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 trace_in
|
||||
Tracer.on if @context.use_tracer?
|
||||
begin
|
||||
yield
|
||||
ensure
|
||||
Tracer.off if @context.use_tracer?
|
||||
end
|
||||
end
|
||||
|
||||
def prompt(prompt, ltype, indent, line_no)
|
||||
p = prompt.dup
|
||||
p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
|
||||
case $2
|
||||
when "N"
|
||||
@context.irb_name
|
||||
when "m"
|
||||
@context.main.to_s
|
||||
when "M"
|
||||
@context.main.inspect
|
||||
when "l"
|
||||
ltype
|
||||
when "i"
|
||||
if $1
|
||||
format("%" + $1 + "d", indent)
|
||||
else
|
||||
indent.to_s
|
||||
end
|
||||
when "n"
|
||||
if $1
|
||||
format("%" + $1 + "d", line_no)
|
||||
else
|
||||
line_no.to_s
|
||||
end
|
||||
when "%"
|
||||
"%"
|
||||
end
|
||||
end
|
||||
p
|
||||
end
|
||||
|
||||
def inspect
|
||||
ary = []
|
||||
for iv in instance_variables
|
||||
case iv
|
||||
when "@signal_status"
|
||||
ary.push format("%s=:%s", iv, @signal_status.id2name)
|
||||
when "@context"
|
||||
ary.push format("%s=%s", iv, eval(iv).__to_s__)
|
||||
else
|
||||
ary.push format("%s=%s", iv, eval(iv))
|
||||
end
|
||||
end
|
||||
format("#<%s: %s>", type, ary.join(", "))
|
||||
end
|
||||
end
|
||||
|
||||
#
|
||||
# irb context
|
||||
#
|
||||
class Context
|
||||
#
|
||||
# Arguments:
|
||||
# input_method: nil -- stdin or readline
|
||||
# String -- File
|
||||
# other -- using this as InputMethod
|
||||
#
|
||||
def initialize(irb, main, bind, input_method = nil)
|
||||
@irb = irb
|
||||
@main = main
|
||||
@bind = bind
|
||||
@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]
|
||||
|
||||
self.math_mode = IRB.conf[:MATH_MODE]
|
||||
@use_readline = IRB.conf[:USE_READLINE]
|
||||
@inspect_mode = IRB.conf[:INSPECT_MODE]
|
||||
@use_tracer = IRB.conf[:USE_TRACER]
|
||||
# @use_loader = IRB.conf[:USE_LOADER]
|
||||
|
||||
self.prompt_mode = IRB.conf[:PROMPT_MODE]
|
||||
|
||||
@ignore_sigint = IRB.conf[:IGNORE_SIGINT]
|
||||
@ignore_eof = IRB.conf[:IGNORE_EOF]
|
||||
|
||||
@back_trace_limit = IRB.conf[:BACK_TRACE_LIMIT]
|
||||
|
||||
debug_level = IRB.conf[:DEBUG_LEVEL]
|
||||
@verbose = IRB.conf[:VERBOSE]
|
||||
|
||||
@tracer_initialized = false
|
||||
|
||||
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
|
||||
if (use_readline.nil? && IRB.conf[:PROMPT_MODE] != :INF_RUBY ||
|
||||
use_readline?)
|
||||
@io = ReadlineInputMethod.new
|
||||
else
|
||||
@io = StdioInputMethod.new
|
||||
end
|
||||
when String
|
||||
@io = FileInputMethod.new(input_method)
|
||||
@irb_name = File.basename(input_method)
|
||||
@irb_path = input_method
|
||||
else
|
||||
@io = input_method
|
||||
end
|
||||
end
|
||||
|
||||
attr :bind, true
|
||||
attr :main, true
|
||||
attr :thread
|
||||
attr :io, true
|
||||
|
||||
attr :_
|
||||
|
||||
attr :irb
|
||||
attr :ap_name
|
||||
attr :rc
|
||||
attr :load_modules
|
||||
attr :irb_name
|
||||
attr :irb_path
|
||||
|
||||
attr :math_mode, true
|
||||
attr :use_readline, true
|
||||
attr :inspect_mode
|
||||
attr :use_tracer
|
||||
# attr :use_loader
|
||||
|
||||
attr :debug_level
|
||||
attr :verbose, true
|
||||
|
||||
attr :prompt_mode
|
||||
attr :prompt_i, true
|
||||
attr :prompt_s, true
|
||||
attr :prompt_c, true
|
||||
attr :auto_indent_mode, true
|
||||
attr :return_format, true
|
||||
|
||||
attr :ignore_sigint, true
|
||||
attr :ignore_eof, true
|
||||
|
||||
attr :back_trace_limit
|
||||
|
||||
# alias use_loader? use_loader
|
||||
alias use_tracer? use_tracer
|
||||
alias use_readline? use_readline
|
||||
alias rc? rc
|
||||
alias math? math_mode
|
||||
alias verbose? verbose
|
||||
alias ignore_sigint? ignore_sigint
|
||||
alias ignore_eof? ignore_eof
|
||||
|
||||
def _=(value)
|
||||
@_ = value
|
||||
eval "_ = IRB.conf[:MAIN_CONTEXT]._", @bind
|
||||
end
|
||||
|
||||
def irb_name
|
||||
if @irb_level == 0
|
||||
@irb_name
|
||||
elsif @irb_name =~ /#[0-9]*$/
|
||||
@irb_name + "." + @irb_level.to_s
|
||||
else
|
||||
@irb_name + "#0." + @irb_level.to_s
|
||||
end
|
||||
end
|
||||
|
||||
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]
|
||||
@return_format = pconf[:RETURN]
|
||||
if ai = pconf.include?(:AUTO_INDENT)
|
||||
@auto_indent_mode = ai
|
||||
else
|
||||
@auto_indent_mode = IRB.conf[:AUTO_INDENT]
|
||||
end
|
||||
end
|
||||
|
||||
def inspect?
|
||||
@inspect_mode.nil? && !@math_mode or @inspect_mode
|
||||
end
|
||||
|
||||
def file_input?
|
||||
@io.type == FileInputMethod
|
||||
end
|
||||
|
||||
def use_tracer=(opt)
|
||||
if opt
|
||||
IRB.initialize_tracer
|
||||
unless @tracer_initialized
|
||||
Tracer.set_get_line_procs(@irb_path) {
|
||||
|line_no|
|
||||
@io.line(line_no)
|
||||
}
|
||||
@tracer_initialized = true
|
||||
end
|
||||
elsif !opt && @use_tracer
|
||||
Tracer.off
|
||||
end
|
||||
@use_tracer=opt
|
||||
end
|
||||
|
||||
def use_loader
|
||||
IRB.conf[:USE_LOADER]
|
||||
end
|
||||
|
||||
def use_loader=(opt)
|
||||
IRB.conf[:USE_LOADER] = opt
|
||||
if opt
|
||||
IRB.initialize_loader
|
||||
end
|
||||
print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
|
||||
opt
|
||||
end
|
||||
|
||||
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
|
||||
|
||||
def math_mode=(opt)
|
||||
if @math_mode == true && opt == false
|
||||
IRB.fail CantRetuenNormalMode
|
||||
return
|
||||
end
|
||||
|
||||
@math_mode = opt
|
||||
if math_mode
|
||||
IRB.initialize_mathn
|
||||
@main.instance_eval("include Math")
|
||||
print "start math mode\n" if verbose?
|
||||
end
|
||||
end
|
||||
|
||||
def use_readline=(opt)
|
||||
@use_readline = opt
|
||||
print "use readline module\n" if @use_readline
|
||||
end
|
||||
|
||||
def debug_level=(value)
|
||||
@debug_level = value
|
||||
RubyLex.debug_level = value
|
||||
SLex.debug_level = value
|
||||
end
|
||||
|
||||
def debug?
|
||||
@debug_level > 0
|
||||
end
|
||||
|
||||
def change_binding(*main)
|
||||
back = [@bind, @main]
|
||||
@bind = IRB.workspace_binding(*main)
|
||||
unless main.empty?
|
||||
@main = eval("self", @bind)
|
||||
begin
|
||||
@main.extend ExtendCommand
|
||||
rescue
|
||||
print "can't change binding to: ", @main.inspect, "\n"
|
||||
@bind, @main = back
|
||||
return nil
|
||||
end
|
||||
end
|
||||
@irb_level += 1
|
||||
begin
|
||||
catch(:SU_EXIT) do
|
||||
@irb.eval_input
|
||||
end
|
||||
ensure
|
||||
@irb_level -= 1
|
||||
@bind, @main = back
|
||||
end
|
||||
end
|
||||
|
||||
alias __exit__ exit
|
||||
def exit(ret = 0)
|
||||
if @irb_level == 0
|
||||
IRB.irb_exit(@irb, ret)
|
||||
else
|
||||
throw :SU_EXIT, ret
|
||||
end
|
||||
end
|
||||
|
||||
NOPRINTING_IVARS = ["@_"]
|
||||
NO_INSPECTING_IVARS = ["@irb", "@io"]
|
||||
IDNAME_IVARS = ["@prompt_mode"]
|
||||
|
||||
alias __inspect__ inspect
|
||||
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
|
||||
next
|
||||
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
|
||||
alias __to_s__ to_s
|
||||
alias to_s inspect
|
||||
|
||||
end
|
||||
|
||||
#
|
||||
# IRB extended command
|
||||
#
|
||||
module Loader; end
|
||||
module ExtendCommand
|
||||
include Loader
|
||||
|
||||
alias irb_exit_org exit
|
||||
def irb_exit(ret = 0)
|
||||
irb_context.exit(ret)
|
||||
end
|
||||
alias exit irb_exit
|
||||
alias quit irb_exit
|
||||
|
||||
alias irb_fork fork
|
||||
def fork(&block)
|
||||
unless irb_fork
|
||||
eval "alias exit irb_exit_org"
|
||||
instance_eval "alias exit irb_exit_org"
|
||||
if iterator?
|
||||
yield
|
||||
exit
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def irb_change_binding(*main)
|
||||
irb_context.change_binding(*main)
|
||||
end
|
||||
alias cb irb_change_binding
|
||||
|
||||
def irb_source(file)
|
||||
irb_context.source(file)
|
||||
end
|
||||
alias source irb_source
|
||||
|
||||
def irb(*obj)
|
||||
require "irb/multi-irb"
|
||||
IRB.irb(nil, *obj)
|
||||
end
|
||||
|
||||
def irb_context
|
||||
IRB.conf[:MAIN_CONTEXT]
|
||||
end
|
||||
alias conf irb_context
|
||||
|
||||
def irb_jobs
|
||||
require "irb/multi-irb"
|
||||
IRB.JobManager
|
||||
end
|
||||
alias jobs irb_jobs
|
||||
|
||||
def irb_fg(key)
|
||||
require "irb/multi-irb"
|
||||
IRB.JobManager.switch(key)
|
||||
end
|
||||
alias fg irb_fg
|
||||
|
||||
def irb_kill(*keys)
|
||||
require "irb/multi-irb"
|
||||
IRB.JobManager.kill(*keys)
|
||||
end
|
||||
alias kill irb_kill
|
||||
end
|
||||
|
||||
# Singleton method
|
||||
def @CONF.inspect
|
||||
IRB.version unless self[:VERSION]
|
||||
|
||||
array = []
|
||||
for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
|
||||
case k
|
||||
when :MAIN_CONTEXT
|
||||
next
|
||||
when :PROMPT
|
||||
s = v.collect{
|
||||
|kk, vv|
|
||||
ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
|
||||
format(":%s=>{%s}", kk.id2name, ss.join(", "))
|
||||
}
|
||||
array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
|
||||
else
|
||||
array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
|
||||
end
|
||||
end
|
||||
array.join("\n")
|
||||
end
|
||||
end
|
||||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# multi-irb.rb - multiple irb module
|
||||
# $Release Version: 0.6$
|
||||
# irb/multi-irb.rb - multiple irb module(JP: $BJ#?t(Birb$BBP1~%b%8%e!<%k(B)
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -14,6 +14,7 @@ require "thread"
|
|||
|
||||
module IRB
|
||||
# job management class
|
||||
# (JP: job$B4IM}%/%i%9(B)
|
||||
class JobManager
|
||||
@RCS_ID='-$Id$-'
|
||||
|
||||
|
|
@ -23,7 +24,7 @@ module IRB
|
|||
@current_job = nil
|
||||
end
|
||||
|
||||
attr :current_job, true
|
||||
attr_accessor :current_job
|
||||
|
||||
def n_jobs
|
||||
@jobs.size
|
||||
|
|
@ -140,20 +141,16 @@ module IRB
|
|||
@JobManager
|
||||
end
|
||||
|
||||
# invoke multiple irb
|
||||
# invoke multi-irb
|
||||
# (JP: irb$B5/F0(B)
|
||||
def IRB.irb(file = nil, *main)
|
||||
workspace = IRB.workspace_binding(*main)
|
||||
if main.empty?
|
||||
main = eval("self", workspace)
|
||||
else
|
||||
main = main[0]
|
||||
end
|
||||
workspace = WorkSpace.new(*main)
|
||||
parent_thread = Thread.current
|
||||
Thread.start do
|
||||
begin
|
||||
irb = Irb.new(main, workspace, file)
|
||||
irb = Irb.new(workspace, file)
|
||||
rescue
|
||||
print "Subirb can't start with context(self): ", main.inspect, "\n"
|
||||
print "Subirb can't start with context(self): ", workspace.main.inspect, "\n"
|
||||
print "return to main irb\n"
|
||||
Thread.pass
|
||||
Thread.main.wakeup
|
||||
|
|
@ -190,7 +187,7 @@ module IRB
|
|||
class Context
|
||||
def _=(value)
|
||||
@_ = value
|
||||
eval "_ = IRB.JobManager.irb(Thread.current).context._", @bind
|
||||
@workspace.evaluate "_ = IRB.JobManager.irb(Thread.current).context._"
|
||||
end
|
||||
end
|
||||
|
||||
|
|
@ -198,7 +195,7 @@ module IRB
|
|||
def irb_context
|
||||
IRB.JobManager.irb(Thread.current).context
|
||||
end
|
||||
alias conf irb_context
|
||||
# alias conf irb_context
|
||||
end
|
||||
|
||||
@CONF[:SINGLE_IRB_MODE] = false
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# ruby-lex.rb - ruby lexcal analizer
|
||||
# $Release Version: 0.6$
|
||||
# irb/ruby-lex.rb - ruby lexcal analizer
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -28,7 +28,7 @@ class RubyLex
|
|||
include RubyToken
|
||||
|
||||
class << self
|
||||
attr :debug_level, TRUE
|
||||
attr_accessor :debug_level
|
||||
def debug?
|
||||
@debug_level > 0
|
||||
end
|
||||
|
|
@ -54,14 +54,14 @@ class RubyLex
|
|||
@exception_on_syntax_error = true
|
||||
end
|
||||
|
||||
attr :skip_space, true
|
||||
attr :readed_auto_clean_up, true
|
||||
attr :exception_on_syntax_error, true
|
||||
attr_accessor :skip_space
|
||||
attr_accessor :readed_auto_clean_up
|
||||
attr_accessor :exception_on_syntax_error
|
||||
|
||||
attr :seek
|
||||
attr :char_no
|
||||
attr :line_no
|
||||
attr :indent
|
||||
attr_reader :seek
|
||||
attr_reader :char_no
|
||||
attr_reader :line_no
|
||||
attr_reader :indent
|
||||
|
||||
# io functions
|
||||
def set_input(io, p = nil)
|
||||
|
|
@ -202,8 +202,8 @@ class RubyLex
|
|||
@space_seen = false
|
||||
@here_header = false
|
||||
|
||||
@continue = false
|
||||
prompt
|
||||
@continue = FALSE
|
||||
|
||||
@line = ""
|
||||
@exp_line_no = @line_no
|
||||
|
|
@ -212,7 +212,7 @@ class RubyLex
|
|||
def each_top_level_statement
|
||||
initialize_input
|
||||
loop do
|
||||
@continue = FALSE
|
||||
@continue = false
|
||||
prompt
|
||||
unless l = lex
|
||||
break if @line == ''
|
||||
|
|
@ -239,8 +239,8 @@ class RubyLex
|
|||
until (((tk = token).kind_of?(TkNL) || tk.kind_of?(TkEND_OF_SCRIPT)) &&
|
||||
!@continue or
|
||||
tk.nil?)
|
||||
# p tk
|
||||
# p self
|
||||
#p tk
|
||||
#p self
|
||||
end
|
||||
line = get_readed
|
||||
# print self.inspect
|
||||
|
|
@ -315,7 +315,7 @@ class RubyLex
|
|||
end
|
||||
|
||||
@OP.def_rules(" ", "\t", "\f", "\r", "\13") do
|
||||
@space_seen = TRUE
|
||||
@space_seen = true
|
||||
while getc =~ /[ \t\f\r\13]/; end
|
||||
ungetc
|
||||
Token(TkSPACE)
|
||||
|
|
@ -333,7 +333,7 @@ class RubyLex
|
|||
until peek_equal?("=end") && peek(4) =~ /\s/
|
||||
until getc == "\n"; end
|
||||
end
|
||||
getc; getc; getc; getc
|
||||
gets
|
||||
@ltype = nil
|
||||
Token(TkRD_COMMENT)
|
||||
end
|
||||
|
|
@ -342,9 +342,9 @@ class RubyLex
|
|||
print "\\n\n" if RubyLex.debug?
|
||||
case @lex_state
|
||||
when EXPR_BEG, EXPR_FNAME, EXPR_DOT
|
||||
@continue = TRUE
|
||||
@continue = true
|
||||
else
|
||||
@continue = FALSE
|
||||
@continue = false
|
||||
@lex_state = EXPR_BEG
|
||||
end
|
||||
@here_header = false
|
||||
|
|
@ -459,6 +459,7 @@ class RubyLex
|
|||
identify_number
|
||||
else
|
||||
# for obj.if
|
||||
# (JP: obj.if $B$J$I$NBP1~(B)
|
||||
@lex_state = EXPR_DOT
|
||||
Token(TkDOT)
|
||||
end
|
||||
|
|
@ -691,7 +692,8 @@ class RubyLex
|
|||
if ch == "!" or ch == "?"
|
||||
token.concat getc
|
||||
end
|
||||
# fix token
|
||||
# almost fix token
|
||||
# (JP: $BBgBN(Bfix token)
|
||||
|
||||
case token
|
||||
when /^\$/
|
||||
|
|
@ -707,11 +709,13 @@ class RubyLex
|
|||
token_c, *trans = TkReading2Token[token]
|
||||
if token_c
|
||||
# reserved word?
|
||||
# (JP: $BM=Ls8l$+$I$&$+(B?)
|
||||
|
||||
if (@lex_state != EXPR_BEG &&
|
||||
@lex_state != EXPR_FNAME &&
|
||||
trans[1])
|
||||
# modifiers
|
||||
# (JP: $B=$>~;R(B)
|
||||
token_c = TkSymbol2Token[trans[1]]
|
||||
@lex_state = trans[0]
|
||||
else
|
||||
|
|
@ -752,6 +756,7 @@ class RubyLex
|
|||
|
||||
def identify_here_document
|
||||
ch = getc
|
||||
# if lt = PERCENT_LTYPE[ch]
|
||||
if ch == "-"
|
||||
ch = getc
|
||||
indent = true
|
||||
|
|
@ -835,8 +840,8 @@ class RubyLex
|
|||
end
|
||||
|
||||
type = TkINTEGER
|
||||
allow_point = TRUE
|
||||
allow_e = TRUE
|
||||
allow_point = true
|
||||
allow_e = true
|
||||
while ch = getc
|
||||
case ch
|
||||
when /[0-9_]/
|
||||
|
|
@ -955,6 +960,7 @@ class RubyLex
|
|||
end
|
||||
else
|
||||
# other characters
|
||||
#(JP:$B$=$NB>$NJ8;z(B)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# ruby-token.rb - ruby tokens
|
||||
# $Release Version: 0.6$
|
||||
# irb/ruby-token.rb - ruby tokens
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -18,6 +18,11 @@ module RubyToken
|
|||
EXPR_DOT = :EXPR_DOT
|
||||
EXPR_CLASS = :EXPR_CLASS
|
||||
|
||||
# for ruby 1.4X
|
||||
if !defined?(Symbol)
|
||||
Symbol = Integer
|
||||
end
|
||||
|
||||
class Token
|
||||
def initialize(seek, line_no, char_no)
|
||||
@seek = seek
|
||||
|
|
@ -241,7 +246,7 @@ module RubyToken
|
|||
TkSymbol2Token = {}
|
||||
|
||||
def RubyToken.def_token(token_n, super_token = Token, reading = nil, *opts)
|
||||
token_n = token_n.id2name unless token_n.kind_of?(String)
|
||||
token_n = token_n.id2name if token_n.kind_of?(Symbol)
|
||||
if RubyToken.const_defined?(token_n)
|
||||
IRB.fail AlreadyDefinedToken, token_n
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# irb-slex.rb - symple lex analizer
|
||||
# $Release Version: 0.6$
|
||||
# irb/slex.rb - symple lex analizer
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
# by Keiju ISHITSUKA(keiju@ishituska.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -20,7 +20,7 @@ class SLex
|
|||
def_exception :ErrNodeAlreadyExists, "node already exists"
|
||||
|
||||
class << self
|
||||
attr :debug_level, TRUE
|
||||
attr_accessor :debug_level
|
||||
def debug?
|
||||
debug_level > 0
|
||||
end
|
||||
|
|
@ -90,14 +90,15 @@ class SLex
|
|||
class Node
|
||||
# if postproc no exist, this node is abstract node.
|
||||
# if postproc isn't nil, this node is real node.
|
||||
# (JP: postproc$B$,$J$1$l$PCj>]%N!<%I(B, nil$B$8$c$J$1$l$P6q>]%N!<%I(B)
|
||||
def initialize(preproc = nil, postproc = nil)
|
||||
@Tree = {}
|
||||
@preproc = preproc
|
||||
@postproc = postproc
|
||||
end
|
||||
|
||||
attr :preproc, TRUE
|
||||
attr :postproc, TRUE
|
||||
attr_accessor :preproc
|
||||
attr_accessor :postproc
|
||||
|
||||
def search(chrs, opt = nil)
|
||||
return self if chrs.empty?
|
||||
|
|
@ -158,9 +159,11 @@ class SLex
|
|||
|
||||
#
|
||||
# chrs: String
|
||||
# character array
|
||||
# character array (JP: $B0lJ8;z$E$D$N(BArray)
|
||||
# io It must have getc()/ungetc(), and ungetc() can be
|
||||
# called any number of times.
|
||||
# (JP:$B$@$@$7(B, getc/ungetc$B$,Hw$o$C$F$$$J$1$l$P$J$i$J$$(B.
|
||||
# $B$5$i$K(B, ungetc$B$OJ#?t2s2DG=$G$J$/$F$O$J$i$J$$(B.)
|
||||
#
|
||||
def match(chrs, op = "")
|
||||
print "match>: ", chrs, "op:", op, "\n" if SLex.debug?
|
||||
|
|
@ -265,7 +268,7 @@ if $0 == __FILE__
|
|||
print "0: ", tr.inspect, "\n"
|
||||
tr.def_rule("=") {print "=\n"}
|
||||
print "1: ", tr.inspect, "\n"
|
||||
tr.def_rule("==", proc{FALSE}) {print "==\n"}
|
||||
tr.def_rule("==", proc{false}) {print "==\n"}
|
||||
print "2: ", tr.inspect, "\n"
|
||||
|
||||
print "case 1:\n"
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#
|
||||
# version.rb - irb version definition file
|
||||
# $Release Version: 0.6.1$
|
||||
# irb/version.rb - irb version definition file
|
||||
# $Release Version: 0.7.3$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
# --
|
||||
#
|
||||
|
|
@ -11,6 +11,6 @@
|
|||
#
|
||||
|
||||
module IRB
|
||||
@RELEASE_VERSION = "0.6.1"
|
||||
@LAST_UPDATE_DATE = "99/09/16"
|
||||
@RELEASE_VERSION = "0.7.3"
|
||||
@LAST_UPDATE_DATE = "01/04/16"
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#
|
||||
# xmp.rb - irb version of gotoken xmp
|
||||
# $Release Version: 0.6$
|
||||
# $Release Version: 0.7.1$
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
|
|
|
|||
|
|
@ -1,19 +1,13 @@
|
|||
#!/usr/bin/env ruby
|
||||
#
|
||||
# irb.rb - intaractive ruby
|
||||
# $Release Version: 0.6 $
|
||||
# $Release Version: 0.7.3 $
|
||||
# $Revision$
|
||||
# $Date$
|
||||
# by Keiju ISHITSUKA(Nippon Rational Inc.)
|
||||
#
|
||||
# --
|
||||
# Usage:
|
||||
#
|
||||
# irb.rb [options] file_name opts
|
||||
#
|
||||
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
|
||||
#
|
||||
|
||||
require "irb/main"
|
||||
require "irb"
|
||||
|
||||
if __FILE__ == $0
|
||||
IRB.start(__FILE__)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue