Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! z/ /
version.rbnu [ #
# irb/version.rb - irb version definition file
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
#
# --
#
#
#
module IRB
@RELEASE_VERSION = "0.9.5"
@LAST_UPDATE_DATE = "05/04/13"
end
PK ! - - output-method.rbnu [ #
# output-method.rb - optput methods used by irb
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "e2mmap"
module IRB
# OutputMethod
# StdioOutputMethod
class OutputMethod
@RCS_ID='-$Id: output-method.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
def print(*opts)
IRB.fail NotImplementError, "print"
end
def printn(*opts)
print opts.join(" "), "\n"
end
# extend printf
def printf(format, *opts)
if /(%*)%I/ =~ format
format, opts = parse_printf_format(format, opts)
end
print sprintf(format, *opts)
end
# %
# <ե饰> [#0- +]
# <Ǿե> (\*|\*[1-9][0-9]*\$|[1-9][0-9]*)
# <>.(\*|\*[1-9][0-9]*\$|[1-9][0-9]*|)?
# #<Ĺʸ>(hh|h|l|ll|L|q|j|z|t)
# <Ѵʸ>[diouxXeEfgGcsb%]
def parse_printf_format(format, opts)
return format, opts if $1.size % 2 == 1
end
def foo(format)
pos = 0
inspects = []
format.scan(/%[#0\-+ ]?(\*(?=[^0-9])|\*[1-9][0-9]*\$|[1-9][0-9]*(?=[^0-9]))?(\.(\*(?=[^0-9])|\*[1-9][0-9]*\$|[1-9][0-9]*(?=[^0-9])))?(([1-9][0-9]*\$)*)([diouxXeEfgGcsb%])/) {|f, p, pp, pos, new_pos, c|
puts [f, p, pp, pos, new_pos, c].join("!")
pos = new_pos if new_pos
if c == "I"
inspects.push pos.to_i
(f||"")+(p||"")+(pp||"")+(pos||"")+"s"
else
$&
end
}
end
def puts(*objs)
for obj in objs
print(*obj)
print "\n"
end
end
def pp(*objs)
puts(*objs.collect{|obj| obj.inspect})
end
def ppx(prefix, *objs)
puts(*objs.collect{|obj| prefix+obj.inspect})
end
end
class StdioOutputMethod {
:PROMPT_I => nil,
:PROMPT_N => nil,
:PROMPT_S => nil,
:PROMPT_C => nil,
:RETURN => "%s\n"
},
:DEFAULT => {
:PROMPT_I => "%N(%m):%03n:%i> ",
:PROMPT_N => "%N(%m):%03n:%i> ",
:PROMPT_S => "%N(%m):%03n:%i%l ",
:PROMPT_C => "%N(%m):%03n:%i* ",
:RETURN => "=> %s\n"
},
:CLASSIC => {
:PROMPT_I => "%N(%m):%03n:%i> ",
:PROMPT_N => "%N(%m):%03n:%i> ",
:PROMPT_S => "%N(%m):%03n:%i%l ",
:PROMPT_C => "%N(%m):%03n:%i* ",
:RETURN => "%s\n"
},
:SIMPLE => {
:PROMPT_I => ">> ",
:PROMPT_N => ">> ",
:PROMPT_S => nil,
:PROMPT_C => "?> ",
:RETURN => "=> %s\n"
},
:INF_RUBY => {
:PROMPT_I => "%N(%m):%03n:%i> ",
# :PROMPT_N => "%N(%m):%03n:%i> ",
:PROMPT_N => nil,
:PROMPT_S => nil,
:PROMPT_C => nil,
:RETURN => "%s\n",
:AUTO_INDENT => true
},
:XMP => {
:PROMPT_I => nil,
:PROMPT_N => nil,
:PROMPT_S => nil,
:PROMPT_C => nil,
:RETURN => " ==>%s\n"
}
}
@CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
@CONF[:AUTO_INDENT] = false
@CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
@CONF[:SINGLE_IRB] = false
# @CONF[:LC_MESSAGES] = "en"
@CONF[:LC_MESSAGES] = Locale.new
@CONF[:AT_EXIT] = []
@CONF[:DEBUG_LEVEL] = 1
end
def IRB.init_error
@CONF[:LC_MESSAGES].load("irb/error.rb")
end
FEATURE_IOPT_CHANGE_VERSION = "1.9.0"
# option analyzing
def IRB.parse_opts
load_path = []
while opt = ARGV.shift
case opt
when "-f"
@CONF[:RC] = false
when "-m"
@CONF[:MATH_MODE] = true
when "-d"
$DEBUG = true
when /^-r(.+)?/
opt = $1 || ARGV.shift
@CONF[:LOAD_MODULES].push opt if opt
when /^-I(.+)?/
opt = $1 || ARGV.shift
load_path.concat(opt.split(File::PATH_SEPARATOR)) if opt
when /^-K(.)/
$KCODE = $1
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 "--echo"
@CONF[:ECHO] = true
when "--noecho"
@CONF[:ECHO] = false
when "--verbose"
@CONF[:VERBOSE] = true
when "--noverbose"
@CONF[:VERBOSE] = false
when "--prompt-mode", "--prompt"
prompt_mode = ARGV.shift.upcase.tr("-", "_").intern
@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 "-h", "--help"
require "irb/help"
IRB.print_usage
exit 0
when /^-/
IRB.fail UnrecognizedSwitch, opt
else
@CONF[:SCRIPT] = opt
$0 = opt
break
end
end
if RUBY_VERSION >= FEATURE_IOPT_CHANGE_VERSION
load_path.collect! do |path|
/\A\.\// =~ path ? path : File.expand_path(path)
end
end
$LOAD_PATH.unshift(*load_path)
end
# running config
def IRB.run_config
if @CONF[:RC]
begin
load rc_file
rescue LoadError, Errno::ENOENT
rescue
print "load error: #{rc_file}\n"
print $!.class, ": ", $!, "\n"
for err in $@[0, $@.size - 2]
print "\t", err, "\n"
end
end
end
end
IRBRC_EXT = "rc"
def IRB.rc_file(ext = IRBRC_EXT)
if !@CONF[:RC_NAME_GENERATOR]
rc_file_generators do |rcgen|
@CONF[:RC_NAME_GENERATOR] ||= rcgen
if File.exist?(rcgen.call(IRBRC_EXT))
@CONF[:RC_NAME_GENERATOR] = rcgen
break
end
end
end
@CONF[:RC_NAME_GENERATOR].call ext
end
# enumerate possible rc-file base name generators
def IRB.rc_file_generators
if irbrc = ENV["IRBRC"]
yield proc{|rc| rc == "rc" ? irbrc : irbrc+rc}
end
if home = ENV["HOME"]
yield proc{|rc| home+"/.irb#{rc}"}
end
home = Dir.pwd
yield proc{|rc| home+"/.irb#{rc}"}
yield proc{|rc| home+"/irb#{rc.sub(/\A_?/, '.')}"}
yield proc{|rc| home+"/_irb#{rc}"}
yield proc{|rc| home+"/$irb#{rc}"}
end
# loading modules
def IRB.load_modules
for m in @CONF[:LOAD_MODULES]
begin
require m
rescue
print $@[0], ":", $!.class, ": ", $!, "\n"
end
end
end
end
PK ! \·
ruby-token.rbnu [ #
# irb/ruby-token.rb - ruby tokens
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
module RubyToken
EXPR_BEG = :EXPR_BEG
EXPR_MID = :EXPR_MID
EXPR_END = :EXPR_END
EXPR_ARG = :EXPR_ARG
EXPR_FNAME = :EXPR_FNAME
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
@line_no = line_no
@char_no = char_no
end
attr :seek
attr :line_no
attr :char_no
end
class TkNode < Token
def initialize(seek, line_no, char_no)
super
end
attr :node
end
class TkId < Token
def initialize(seek, line_no, char_no, name)
super(seek, line_no, char_no)
@name = name
end
attr :name
end
class TkVal < Token
def initialize(seek, line_no, char_no, value = nil)
super(seek, line_no, char_no)
@value = value
end
attr :value
end
class TkOp < Token
attr :name, true
end
class TkOPASGN < TkOp
def initialize(seek, line_no, char_no, op)
super(seek, line_no, char_no)
op = TkReading2Token[op][0] unless op.kind_of?(Symbol)
@op = op
end
attr :op
end
class TkUnknownChar < Token
def initialize(seek, line_no, char_no, id)
super(seek, line_no, char_no)
@name = name
end
attr :name
end
class TkError < Token
end
def Token(token, value = nil)
case token
when String
if (tk = TkReading2Token[token]).nil?
IRB.fail TkReading2TokenNoKey, token
end
tk = Token(tk[0], value)
if tk.kind_of?(TkOp)
tk.name = token
end
return tk
when Symbol
if (tk = TkSymbol2Token[token]).nil?
IRB.fail TkSymbol2TokenNoKey, token
end
return Token(tk[0], value)
else
if (token.ancestors & [TkId, TkVal, TkOPASGN, TkUnknownChar]).empty?
token.new(@prev_seek, @prev_line_no, @prev_char_no)
else
token.new(@prev_seek, @prev_line_no, @prev_char_no, value)
end
end
end
TokenDefinitions = [
[:TkCLASS, TkId, "class", EXPR_CLASS],
[:TkMODULE, TkId, "module", EXPR_BEG],
[:TkDEF, TkId, "def", EXPR_FNAME],
[:TkUNDEF, TkId, "undef", EXPR_FNAME],
[:TkBEGIN, TkId, "begin", EXPR_BEG],
[:TkRESCUE, TkId, "rescue", EXPR_MID],
[:TkENSURE, TkId, "ensure", EXPR_BEG],
[:TkEND, TkId, "end", EXPR_END],
[:TkIF, TkId, "if", EXPR_BEG, :TkIF_MOD],
[:TkUNLESS, TkId, "unless", EXPR_BEG, :TkUNLESS_MOD],
[:TkTHEN, TkId, "then", EXPR_BEG],
[:TkELSIF, TkId, "elsif", EXPR_BEG],
[:TkELSE, TkId, "else", EXPR_BEG],
[:TkCASE, TkId, "case", EXPR_BEG],
[:TkWHEN, TkId, "when", EXPR_BEG],
[:TkWHILE, TkId, "while", EXPR_BEG, :TkWHILE_MOD],
[:TkUNTIL, TkId, "until", EXPR_BEG, :TkUNTIL_MOD],
[:TkFOR, TkId, "for", EXPR_BEG],
[:TkBREAK, TkId, "break", EXPR_END],
[:TkNEXT, TkId, "next", EXPR_END],
[:TkREDO, TkId, "redo", EXPR_END],
[:TkRETRY, TkId, "retry", EXPR_END],
[:TkIN, TkId, "in", EXPR_BEG],
[:TkDO, TkId, "do", EXPR_BEG],
[:TkRETURN, TkId, "return", EXPR_MID],
[:TkYIELD, TkId, "yield", EXPR_END],
[:TkSUPER, TkId, "super", EXPR_END],
[:TkSELF, TkId, "self", EXPR_END],
[:TkNIL, TkId, "nil", EXPR_END],
[:TkTRUE, TkId, "true", EXPR_END],
[:TkFALSE, TkId, "false", EXPR_END],
[:TkAND, TkId, "and", EXPR_BEG],
[:TkOR, TkId, "or", EXPR_BEG],
[:TkNOT, TkId, "not", EXPR_BEG],
[:TkIF_MOD, TkId],
[:TkUNLESS_MOD, TkId],
[:TkWHILE_MOD, TkId],
[:TkUNTIL_MOD, TkId],
[:TkALIAS, TkId, "alias", EXPR_FNAME],
[:TkDEFINED, TkId, "defined?", EXPR_END],
[:TklBEGIN, TkId, "BEGIN", EXPR_END],
[:TklEND, TkId, "END", EXPR_END],
[:Tk__LINE__, TkId, "__LINE__", EXPR_END],
[:Tk__FILE__, TkId, "__FILE__", EXPR_END],
[:TkIDENTIFIER, TkId],
[:TkFID, TkId],
[:TkGVAR, TkId],
[:TkCVAR, TkId],
[:TkIVAR, TkId],
[:TkCONSTANT, TkId],
[:TkINTEGER, TkVal],
[:TkFLOAT, TkVal],
[:TkSTRING, TkVal],
[:TkXSTRING, TkVal],
[:TkREGEXP, TkVal],
[:TkSYMBOL, TkVal],
[:TkDSTRING, TkNode],
[:TkDXSTRING, TkNode],
[:TkDREGEXP, TkNode],
[:TkNTH_REF, TkNode],
[:TkBACK_REF, TkNode],
[:TkUPLUS, TkOp, "+@"],
[:TkUMINUS, TkOp, "-@"],
[:TkPOW, TkOp, "**"],
[:TkCMP, TkOp, "<=>"],
[:TkEQ, TkOp, "=="],
[:TkEQQ, TkOp, "==="],
[:TkNEQ, TkOp, "!="],
[:TkGEQ, TkOp, ">="],
[:TkLEQ, TkOp, "<="],
[:TkANDOP, TkOp, "&&"],
[:TkOROP, TkOp, "||"],
[:TkMATCH, TkOp, "=~"],
[:TkNMATCH, TkOp, "!~"],
[:TkDOT2, TkOp, ".."],
[:TkDOT3, TkOp, "..."],
[:TkAREF, TkOp, "[]"],
[:TkASET, TkOp, "[]="],
[:TkLSHFT, TkOp, "<<"],
[:TkRSHFT, TkOp, ">>"],
[:TkCOLON2, TkOp],
[:TkCOLON3, TkOp],
# [:OPASGN, TkOp], # +=, -= etc. #
[:TkASSOC, TkOp, "=>"],
[:TkQUESTION, TkOp, "?"], #?
[:TkCOLON, TkOp, ":"], #:
[:TkfLPAREN], # func( #
[:TkfLBRACK], # func[ #
[:TkfLBRACE], # func{ #
[:TkSTAR], # *arg
[:TkAMPER], # &arg #
[:TkSYMBEG], # :SYMBOL
[:TkGT, TkOp, ">"],
[:TkLT, TkOp, "<"],
[:TkPLUS, TkOp, "+"],
[:TkMINUS, TkOp, "-"],
[:TkMULT, TkOp, "*"],
[:TkDIV, TkOp, "/"],
[:TkMOD, TkOp, "%"],
[:TkBITOR, TkOp, "|"],
[:TkBITXOR, TkOp, "^"],
[:TkBITAND, TkOp, "&"],
[:TkBITNOT, TkOp, "~"],
[:TkNOTOP, TkOp, "!"],
[:TkBACKQUOTE, TkOp, "`"],
[:TkASSIGN, Token, "="],
[:TkDOT, Token, "."],
[:TkLPAREN, Token, "("], #(exp)
[:TkLBRACK, Token, "["], #[arry]
[:TkLBRACE, Token, "{"], #{hash}
[:TkRPAREN, Token, ")"],
[:TkRBRACK, Token, "]"],
[:TkRBRACE, Token, "}"],
[:TkCOMMA, Token, ","],
[:TkSEMICOLON, Token, ";"],
[:TkCOMMENT],
[:TkRD_COMMENT],
[:TkSPACE],
[:TkNL],
[:TkEND_OF_SCRIPT],
[:TkBACKSLASH, TkUnknownChar, "\\"],
[:TkAT, TkUnknownChar, "@"],
[:TkDOLLAR, TkUnknownChar, "$"],
]
# {reading => token_class}
# {reading => [token_class, *opt]}
TkReading2Token = {}
TkSymbol2Token = {}
def RubyToken.def_token(token_n, super_token = Token, reading = nil, *opts)
token_n = token_n.id2name if token_n.kind_of?(Symbol)
if RubyToken.const_defined?(token_n)
IRB.fail AlreadyDefinedToken, token_n
end
token_c = eval("class #{token_n} < #{super_token}; end; #{token_n}")
if reading
if TkReading2Token[reading]
IRB.fail TkReading2TokenDuplicateError, token_n, reading
end
if opts.empty?
TkReading2Token[reading] = [token_c]
else
TkReading2Token[reading] = [token_c].concat(opts)
end
end
TkSymbol2Token[token_n.intern] = token_c
end
for defs in TokenDefinitions
def_token(*defs)
end
end
PK ! r)X X
cmd/nop.rbnu [ #
# nop.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
module IRB
module ExtendCommand
class Nop
@RCS_ID='-$Id: nop.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
def self.execute(conf, *opts)
command = new(conf)
command.execute(*opts)
end
def initialize(conf)
@irb_context = conf
end
attr_reader :irb_context
def irb
@irb_context.irb
end
def execute(*opts)
#nop
end
end
end
end
PK ! E1
cmd/pushws.rbnu [ #
# change-ws.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "irb/cmd/nop.rb"
require "irb/ext/workspaces.rb"
module IRB
module ExtendCommand
class Workspaces 0
end
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
alias __exit__ exit
def exit(ret = 0)
IRB.irb_exit(@irb, ret)
end
NOPRINTING_IVARS = ["@last_value"]
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
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
alias __to_s__ to_s
alias to_s inspect
end
end
PK ! Jx x ext/save-history.rbnu [ #!/usr/local/bin/ruby
#
# save-history.rb -
# $Release Version: 0.9.5$
# $Revision: 24483 $
# $Date: 2009-08-09 17:44:15 +0900 (Sun, 09 Aug 2009) $
# by Keiju ISHITSUKAkeiju@ruby-lang.org)
#
# --
#
#
#
require "readline"
module IRB
module HistorySavingAbility
@RCS_ID='-$Id: save-history.rb 24483 2009-08-09 08:44:15Z shyouhei $-'
end
class Context
def init_save_history
unless (class<<@io;self;end).include?(HistorySavingAbility)
@io.extend(HistorySavingAbility)
end
end
def save_history
IRB.conf[:SAVE_HISTORY]
end
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
def history_file
IRB.conf[:HISTORY_FILE]
end
def history_file=(hist)
IRB.conf[:HISTORY_FILE] = hist
end
end
module HistorySavingAbility
include Readline
# def HistorySavingAbility.create_finalizer
# proc do
# if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) > 0
# if hf = IRB.conf[:HISTORY_FILE]
# file = File.expand_path(hf)
# end
# file = IRB.rc_file("_history") unless file
# open(file, 'w' ) do |f|
# hist = HISTORY.to_a
# f.puts(hist[-num..-1] || hist)
# end
# end
# end
# end
def HistorySavingAbility.extended(obj)
# ObjectSpace.define_finalizer(obj, HistorySavingAbility.create_finalizer)
IRB.conf[:AT_EXIT].push proc{obj.save_history}
obj.load_history
obj
end
def load_history
hist = IRB.conf[:HISTORY_FILE]
hist = IRB.rc_file("_history") unless hist
if File.exist?(hist)
open(hist) do |f|
f.each {|l| HISTORY << l.chomp}
end
end
end
def save_history
if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) > 0
if history_file = IRB.conf[:HISTORY_FILE]
history_file = File.expand_path(history_file)
end
history_file = IRB.rc_file("_history") unless history_file
open(history_file, 'w' ) do |f|
hist = HISTORY.to_a
f.puts(hist[-num..-1] || hist)
end
end
end
end
end
PK ! + ext/multi-irb.rbnu [ #
# irb/multi-irb.rb - multiple irb module
# $Release Version: 0.9.5$
# $Revision: 25814 $
# $Date: 2009-11-17 15:51:29 +0900 (Tue, 17 Nov 2009) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
IRB.fail CantShiftToMultiIrbMode unless defined?(Thread)
require "thread"
module IRB
# job management class
class JobManager
@RCS_ID='-$Id: multi-irb.rb 25814 2009-11-17 06:51:29Z shyouhei $-'
def initialize
# @jobs = [[thread, irb],...]
@jobs = []
@current_job = nil
end
attr_accessor :current_job
def n_jobs
@jobs.size
end
def thread(key)
th, irb = search(key)
th
end
def irb(key)
th, irb = search(key)
irb
end
def main_thread
@jobs[0][0]
end
def main_irb
@jobs[0][1]
end
def insert(irb)
@jobs.push [Thread.current, irb]
end
def switch(key)
th, irb = search(key)
IRB.fail IrbAlreadyDead unless th.alive?
IRB.fail IrbSwitchedToCurrentThread if th == Thread.current
@current_job = irb
th.run
Thread.stop
@current_job = irb(Thread.current)
end
def kill(*keys)
for key in keys
th, irb = search(key)
IRB.fail IrbAlreadyDead unless th.alive?
th.exit
end
end
def search(key)
job = case key
when Integer
@jobs[key]
when Irb
@jobs.find{|k, v| v.equal?(key)}
when Thread
@jobs.assoc(key)
else
@jobs.find{|k, v| v.context.main.equal?(key)}
end
IRB.fail NoSuchJob, key if job.nil?
job
end
def delete(key)
case key
when Integer
IRB.fail NoSuchJob, key unless @jobs[key]
@jobs[key] = nil
else
catch(:EXISTS) do
@jobs.each_index do
|i|
if @jobs[i] and (@jobs[i][0] == key ||
@jobs[i][1] == key ||
@jobs[i][1].context.main.equal?(key))
@jobs[i] = nil
throw :EXISTS
end
end
IRB.fail NoSuchJob, key
end
end
until assoc = @jobs.pop; end unless @jobs.empty?
@jobs.push assoc
end
def inspect
ary = []
@jobs.each_index do
|i|
th, irb = @jobs[i]
next if th.nil?
if th.alive?
if th.stop?
t_status = "stop"
else
t_status = "running"
end
else
t_status = "exited"
end
ary.push format("#%d->%s on %s (%s: %s)",
i,
irb.context.irb_name,
irb.context.main,
th,
t_status)
end
ary.join("\n")
end
end
@JobManager = JobManager.new
def IRB.JobManager
@JobManager
end
def IRB.CurrentContext
IRB.JobManager.irb(Thread.current).context
end
# invoke multi-irb
def IRB.irb(file = nil, *main)
workspace = WorkSpace.new(*main)
parent_thread = Thread.current
Thread.start do
begin
irb = Irb.new(workspace, file)
rescue
print "Subirb can't start with context(self): ", workspace.main.inspect, "\n"
print "return to main irb\n"
Thread.pass
Thread.main.wakeup
Thread.exit
end
@CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
@JobManager.insert(irb)
@JobManager.current_job = irb
begin
system_exit = false
catch(:IRB_EXIT) do
irb.eval_input
end
rescue SystemExit
system_exit = true
raise
#fail
ensure
unless system_exit
@JobManager.delete(irb)
if parent_thread.alive?
@JobManager.current_job = @JobManager.irb(parent_thread)
parent_thread.run
else
@JobManager.current_job = @JobManager.main_irb
@JobManager.main_thread.run
end
end
end
end
Thread.stop
@JobManager.current_job = @JobManager.irb(Thread.current)
end
# class Context
# def set_last_value(value)
# @last_value = value
# @workspace.evaluate "_ = IRB.JobManager.irb(Thread.current).context.last_value"
# if @eval_history #and !@__.equal?(@last_value)
# @eval_history_values.push @line_no, @last_value
# @workspace.evaluate "__ = IRB.JobManager.irb(Thread.current).context.instance_eval{@eval_history_values}"
# end
# @last_value
# end
# end
# module ExtendCommand
# def irb_context
# IRB.JobManager.irb(Thread.current).context
# end
# # alias conf irb_context
# end
@CONF[:SINGLE_IRB_MODE] = false
@JobManager.insert(@CONF[:MAIN_CONTEXT].irb)
@JobManager.current_job = @CONF[:MAIN_CONTEXT].irb
class Irb
def signal_handle
unless @context.ignore_sigint?
print "\nabort!!\n" if @context.verbose?
exit
end
case @signal_status
when :IN_INPUT
print "^C\n"
IRB.JobManager.thread(self).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
end
trap("SIGINT") do
@JobManager.current_job.signal_handle
Thread.stop
end
end
PK ! G ext/change-ws.rbnu [ #
# irb/ext/cb.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
module IRB
class Context
def home_workspace
if defined? @home_workspace
@home_workspace
else
@home_workspace = @workspace
end
end
def change_workspace(*_main)
if _main.empty?
@workspace = home_workspace
return main
end
@workspace = WorkSpace.new(_main[0])
if !(class<= 0
@contents.find{|no, val| no == idx}[1]
else
@contents[idx][1]
end
rescue NameError
nil
end
end
def push(no, val)
@contents.push [no, val]
@contents.shift if @size != 0 && @contents.size > @size
end
alias real_inspect inspect
def inspect
if @contents.empty?
return real_inspect
end
unless (last = @contents.pop)[1].equal?(self)
@contents.push last
last = nil
end
str = @contents.collect{|no, val|
if val.equal?(self)
"#{no} ...self-history..."
else
"#{no} #{val.inspect}"
end
}.join("\n")
if str == ""
str = "Empty."
end
@contents.push last if last
str
end
end
end
PK ! >
ext/tracer.rbnu [ #
# irb/lib/tracer.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "tracer"
module IRB
# initialize tracing function
def IRB.initialize_tracer
Tracer.verbose = false
Tracer.add_filter {
|event, file, line, id, binding, *rests|
/^#{Regexp.quote(@CONF[:IRB_LIB_PATH])}/ !~ file and
File::basename(file) != "irb.rb"
}
end
class Context
attr_reader :use_tracer
alias use_tracer? use_tracer
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
end
class WorkSpace
alias __evaluate__ evaluate
def evaluate(context, statements, file = nil, line = nil)
if context.use_tracer? && file != nil && line != nil
Tracer.on
begin
__evaluate__(context, statements, file, line)
ensure
Tracer.off
end
else
__evaluate__(context, statements, file || __FILE__, line || __LINE__)
end
end
end
IRB.initialize_tracer
end
PK ! I|S S ext/use-loader.rbnu [ #
# use-loader.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "irb/cmd/load"
require "irb/ext/loader"
class Object
alias __original__load__IRB_use_loader__ load
alias __original__require__IRB_use_loader__ require
end
module IRB
module ExtendCommandBundle
def irb_load(*opts, &b)
ExtendCommand::Load.execute(irb_context, *opts, &b)
end
def irb_require(*opts, &b)
ExtendCommand::Require.execute(irb_context, *opts, &b)
end
end
class Context
IRB.conf[:USE_LOADER] = false
def use_loader
IRB.conf[:USE_LOADER]
end
alias use_loader? use_loader
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
end
end
PK ! cq q ext/math-mode.rbnu [ #
# math-mode.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "mathn"
module IRB
class Context
attr_reader :math_mode
alias math? math_mode
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
def inspect?
@inspect_mode.nil? && !@math_mode or @inspect_mode
end
end
end
PK ! ext/workspaces.rbnu [ #
# push-ws.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
module IRB
class Context
def irb_level
workspace_stack.size
end
def workspaces
if defined? @workspaces
@workspaces
else
@workspaces = []
end
end
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<
def new_alias_name(name, prefix = "__alias_of__", postfix = "__")
base_name = "#{prefix}#{name}#{postfix}"
all_methods = instance_methods(true) + private_instance_methods(true)
same_methods = all_methods.grep(/^#{Regexp.quote(base_name)}[0-9]*$/)
return base_name if same_methods.empty?
no = same_methods.size
while !same_methods.include?(alias_name = base_name + no)
no += 1
end
alias_name
end
end
end
PK ! 6|
|
locale.rbnu [ #
# irb/locale.rb - internationalization module
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
autoload :Kconv, "kconv"
module IRB
class Locale
@RCS_ID='-$Id: locale.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
JPDefaultLocale = "ja"
LOCALE_DIR = "/lc/"
def initialize(locale = nil)
@lang = locale || ENV["IRB_LANG"] || ENV["LC_MESSAGES"] || ENV["LC_ALL"] || ENV["LANG"] || "C"
end
attr_reader :lang
def lc2kconv(lang)
case lang
when "ja_JP.ujis", "ja_JP.euc", "ja_JP.eucJP"
Kconv::EUC
when "ja_JP.sjis", "ja_JP.SJIS"
Kconv::SJIS
when /ja_JP.utf-?8/i
Kconv::UTF8
end
end
private :lc2kconv
def String(mes)
mes = super(mes)
case @lang
when /^ja/
mes = Kconv::kconv(mes, lc2kconv(@lang))
else
mes
end
mes
end
def format(*opts)
String(super(*opts))
end
def gets(*rs)
String(super(*rs))
end
def readline(*rs)
String(super(*rs))
end
def print(*opts)
ary = opts.collect{|opt| String(opt)}
super(*ary)
end
def printf(*opts)
s = format(*opts)
print s
end
def puts(*opts)
ary = opts.collect{|opt| String(opt)}
super(*ary)
end
def require(file, priv = nil)
rex = Regexp.new("lc/#{Regexp.quote(file)}\.(so|o|sl|rb)?")
return false if $".find{|f| f =~ rex}
case file
when /\.rb$/
begin
load(file, priv)
$".push file
return true
rescue LoadError
end
when /\.(so|o|sl)$/
return super
end
begin
load(f = file + ".rb")
$".push f #"
return true
rescue LoadError
return ruby_require(file)
end
end
alias toplevel_load load
def load(file, priv=nil)
dir = File.dirname(file)
dir = "" if dir == "."
base = File.basename(file)
if /^ja(_JP)?$/ =~ @lang
back, @lang = @lang, "C"
end
begin
if dir[0] == ?/ #/
lc_path = search_file(dir, base)
return real_load(lc_path, priv) if lc_path
end
for path in $:
lc_path = search_file(path + "/" + dir, base)
return real_load(lc_path, priv) if lc_path
end
ensure
@lang = back if back
end
raise LoadError, "No such file to load -- #{file}"
end
def real_load(path, priv)
src = self.String(File.read(path))
if priv
eval("self", TOPLEVEL_BINDING).extend(Module.new {eval(src, nil, path)})
else
eval(src, TOPLEVEL_BINDING, path)
end
end
private :real_load
def find(file , paths = $:)
dir = File.dirname(file)
dir = "" if dir == "."
base = File.basename(file)
if dir[0] == ?/ #/
return lc_path = search_file(dir, base)
else
for path in $:
if lc_path = search_file(path + "/" + dir, base)
return lc_path
end
end
end
nil
end
def search_file(path, file)
if File.exist?(p1 = path + lc_path(file, "C"))
if File.exist?(p2 = path + lc_path(file))
return p2
else
end
return p1
else
end
nil
end
private :search_file
def lc_path(file = "", lc = @lang)
case lc
when "C"
LOCALE_DIR + file
when /^ja/
LOCALE_DIR + "ja/" + file
else
LOCALE_DIR + @lang + "/" + file
end
end
private :lc_path
end
end
PK ! . xmp.rbnu [ #
# xmp.rb - irb version of gotoken xmp
# $Release Version: 0.9$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(Nippon Rational Inc.)
#
# --
#
#
#
require "irb"
require "irb/frame"
class XMP
@RCS_ID='-$Id: xmp.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
def initialize(bind = nil)
IRB.init_config(nil)
#IRB.parse_opts
#IRB.load_modules
IRB.conf[:PROMPT_MODE] = :XMP
bind = IRB::Frame.top(1) unless bind
ws = IRB::WorkSpace.new(bind)
@io = StringInputMethod.new
@irb = IRB::Irb.new(ws, @io)
@irb.context.ignore_sigint = false
# IRB.conf[:IRB_RC].call(@irb.context) if IRB.conf[:IRB_RC]
IRB.conf[:MAIN_CONTEXT] = @irb.context
end
def puts(exps)
@io.puts exps
if @irb.context.ignore_sigint
begin
trap_proc_b = trap("SIGINT"){@irb.signal_handle}
catch(:IRB_EXIT) do
@irb.eval_input
end
ensure
trap("SIGINT", trap_proc_b)
end
else
catch(:IRB_EXIT) do
@irb.eval_input
end
end
end
class StringInputMethod < IRB::InputMethod
def initialize
super
@exps = []
end
def eof?
@exps.empty?
end
def gets
while l = @exps.shift
next if /^\s+$/ =~ l
l.concat "\n"
print @prompt, l
break
end
l
end
def puts(exps)
@exps.concat exps.split(/\n/)
end
end
end
def xmp(exps, bind = nil)
bind = IRB::Frame.top(1) unless bind
xmp = XMP.new(bind)
xmp.puts exps
xmp
end
PK ! &F F help.rbnu [ #
# irb/help.rb - print usage module
# $Release Version: 0.9.5$
# $Revision: 16857 $
# $Date: 2008-06-06 17:05:24 +0900 (Fri, 06 Jun 2008) $
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
#
# --
#
#
#
module IRB
def IRB.print_usage
lc = IRB.conf[:LC_MESSAGES]
path = lc.find("irb/help-message")
space_line = false
File.foreach(path) do
|l|
if /^\s*$/ =~ l
lc.puts l unless space_line
space_line = true
next
end
space_line = false
l.sub!(/#.*$/, "")
next if /^\s*$/ =~ l
lc.puts l
end
end
end
PK ! nX lc/error.rbnu [ #
# irb/lc/error.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "e2mmap"
module IRB
# exceptions
extend Exception2MessageMapper
def_exception :UnrecognizedSwitch, "Unrecognized switch: %s"
def_exception :NotImplementedError, "Need to define `%s'"
def_exception :CantReturnToNormalMode, "Can't return to normal mode."
def_exception :IllegalParameter, "Illegal parameter(%s)."
def_exception :IrbAlreadyDead, "Irb is already dead."
def_exception :IrbSwitchedToCurrentThread, "Switched to current thread."
def_exception :NoSuchJob, "No such job(%s)."
def_exception :CantShiftToMultiIrbMode, "Can't shift to multi irb mode."
def_exception :CantChangeBinding, "Can't change binding to (%s)."
def_exception :UndefinedPromptMode, "Undefined prompt mode(%s)."
end
PK ! *O. . lc/ja/error.rbnu [ #
# irb/lc/ja/error.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "e2mmap"
module IRB
# exceptions
extend Exception2MessageMapper
def_exception :UnrecognizedSwitch, '$B%9%$%C%A(B(%s)$B$,J,$j$^$;$s(B'
def_exception :NotImplementedError, '`%s\'$B$NDj5A$,I,MW$G$9(B'
def_exception :CantReturnToNormalMode, 'Normal$B%b!<%I$KLa$l$^$;$s(B.'
def_exception :IllegalParameter, '$B%Q%i%a!<%?(B(%s)$B$,4V0c$C$F$$$^$9(B.'
def_exception :IrbAlreadyDead, 'Irb$B$O4{$K;`$s$G$$$^$9(B.'
def_exception :IrbSwitchedToCurrentThread, '$B%+%l%s%H%9%l%C%I$K@Z$jBX$o$j$^$7$?(B.'
def_exception :NoSuchJob, '$B$=$N$h$&$J%8%g%V(B(%s)$B$O$"$j$^$;$s(B.'
def_exception :CantShiftToMultiIrbMode, 'multi-irb mode$B$K0\$l$^$;$s(B.'
def_exception :CantChangeBinding, '$B%P%$%s%G%#%s%0(B(%s)$B$KJQ99$G$-$^$;$s(B.'
def_exception :UndefinedPromptMode, '$B%W%m%s%W%H%b!<%I(B(%s)$B$ODj5A$5$l$F$$$^$;$s(B.'
end
PK ! lc/ja/help-messagenu [ #
# irb/lc/ja/help-message.rb -
# $Release Version: 0.9.5$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
Usage: irb.rb [options] [programfile] [arguments]
-f ~/.irbrc $B$rFI$_9~$^$J$$(B.
-m bc$B%b!<%I(B($BJ,?t(B, $B9TNs$N7W;;$,$G$-$k(B)
-d $DEBUG $B$r(Btrue$B$K$9$k(B(ruby -d $B$HF1$8(B)
-r load-module ruby -r $B$HF1$8(B.
-I path $LOAD_PATH $B$K(B path $B$rDI2C$9$k(B.
--inspect $B7k2L=PNO$K(Binspect$B$rMQ$$$k(B(bc$B%b!<%I0J30$O%G%U%)%k%H(B).
--noinspect $B7k2L=PNO$K(Binspect$B$rMQ$$$J$$(B.
--readline readline$B%i%$%V%i%j$rMxMQ$9$k(B.
--noreadline readline$B%i%$%V%i%j$rMxMQ$7$J$$(B.
--prompt prompt-mode/--prompt-mode prompt-mode
$B%W%m%s%W%H%b!<%I$r@ZBX$($^$9(B. $B8=:_Dj5A$5$l$F$$$k%W(B
$B%m%s%W%H%b!<%I$O(B, default, simple, xmp, inf-ruby$B$,(B
$BMQ0U$5$l$F$$$^$9(B.
--inf-ruby-mode emacs$B$N(Binf-ruby-mode$BMQ$N%W%m%s%W%HI=<($r9T$J$&(B. $BFC(B
$B$K;XDj$,$J$$8B$j(B, readline$B%i%$%V%i%j$O;H$o$J$/$J$k(B.
--simple-prompt $BHs>o$K%7%s%W%k$J%W%m%s%W%H$rMQ$$$k%b!<%I$G$9(B.
--noprompt $B%W%m%s%W%HI=<($r9T$J$o$J$$(B.
--tracer $B%3%^%s%I", @head.inspect)
end
#----------------------------------------------------------------------
#
# class Node -
#
#----------------------------------------------------------------------
class Node
# if postproc is nil, this node is an abstract node.
# if postproc is non-nil, this node is a real node.
def initialize(preproc = nil, postproc = nil)
@Tree = {}
@preproc = preproc
@postproc = postproc
end
attr_accessor :preproc
attr_accessor :postproc
def search(chrs, opt = nil)
return self if chrs.empty?
ch = chrs.shift
if node = @Tree[ch]
node.search(chrs, opt)
else
if opt
chrs.unshift ch
self.create_subnode(chrs)
else
SLex.fail ErrNodeNothing
end
end
end
def create_subnode(chrs, preproc = nil, postproc = nil)
if chrs.empty?
if @postproc
D_DETAIL.pp node
SLex.fail ErrNodeAlreadyExists
else
D_DEBUG.puts "change abstract node to real node."
@preproc = preproc
@postproc = postproc
end
return self
end
ch = chrs.shift
if node = @Tree[ch]
if chrs.empty?
if node.postproc
DebugLogger.pp node
DebugLogger.pp self
DebugLogger.pp ch
DebugLogger.pp chrs
SLex.fail ErrNodeAlreadyExists
else
D_WARN.puts "change abstract node to real node"
node.preproc = preproc
node.postproc = postproc
end
else
node.create_subnode(chrs, preproc, postproc)
end
else
if chrs.empty?
node = Node.new(preproc, postproc)
else
node = Node.new
node.create_subnode(chrs, preproc, postproc)
end
@Tree[ch] = node
end
node
end
#
# chrs: String
# character array
# io must have getc()/ungetc(); and ungetc() must be
# able to be called arbitrary number of times.
#
def match(chrs, op = "")
D_DETAIL.print "match>: ", chrs, "op:", op, "\n"
if chrs.empty?
if @preproc.nil? || @preproc.call(op, chrs)
DOUT.printf(D_DETAIL, "op1: %s\n", op)
@postproc.call(op, chrs)
else
nil
end
else
ch = chrs.shift
if node = @Tree[ch]
if ret = node.match(chrs, op+ch)
return ret
else
chrs.unshift ch
if @postproc and @preproc.nil? || @preproc.call(op, chrs)
DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)
ret = @postproc.call(op, chrs)
return ret
else
return nil
end
end
else
chrs.unshift ch
if @postproc and @preproc.nil? || @preproc.call(op, chrs)
DOUT.printf(D_DETAIL, "op3: %s\n", op)
@postproc.call(op, chrs)
return ""
else
return nil
end
end
end
end
def match_io(io, op = "")
if op == ""
ch = io.getc
if ch == nil
return nil
end
else
ch = io.getc_of_rests
end
if ch.nil?
if @preproc.nil? || @preproc.call(op, io)
D_DETAIL.printf("op1: %s\n", op)
@postproc.call(op, io)
else
nil
end
else
if node = @Tree[ch]
if ret = node.match_io(io, op+ch)
ret
else
io.ungetc ch
if @postproc and @preproc.nil? || @preproc.call(op, io)
DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}
@postproc.call(op, io)
else
nil
end
end
else
io.ungetc ch
if @postproc and @preproc.nil? || @preproc.call(op, io)
D_DETAIL.printf("op3: %s\n", op)
@postproc.call(op, io)
else
nil
end
end
end
end
end
end
end
SLex=IRB::SLex
if $0 == __FILE__
# Tracer.on
case $1
when "1"
tr = SLex.new
print "0: ", tr.inspect, "\n"
tr.def_rule("=") {print "=\n"}
print "1: ", tr.inspect, "\n"
tr.def_rule("==") {print "==\n"}
print "2: ", tr.inspect, "\n"
print "case 1:\n"
print tr.match("="), "\n"
print "case 2:\n"
print tr.match("=="), "\n"
print "case 3:\n"
print tr.match("=>"), "\n"
when "2"
tr = SLex.new
print "0: ", tr.inspect, "\n"
tr.def_rule("=") {print "=\n"}
print "1: ", tr.inspect, "\n"
tr.def_rule("==", proc{false}) {print "==\n"}
print "2: ", tr.inspect, "\n"
print "case 1:\n"
print tr.match("="), "\n"
print "case 2:\n"
print tr.match("=="), "\n"
print "case 3:\n"
print tr.match("=>"), "\n"
end
exit
end
PK ! sh h
completion.rbnu [ #
# irb/completor.rb -
# $Release Version: 0.9$
# $Revision: 11708 $
# $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
# by Keiju ISHITSUKA(keiju@ishitsuka.com)
# From Original Idea of shugo@ruby-lang.org
#
require "readline"
module IRB
module InputCompletor
@RCS_ID='-$Id: completion.rb 11708 2007-02-12 23:01:19Z shyouhei $-'
ReservedWords = [
"BEGIN", "END",
"alias", "and",
"begin", "break",
"case", "class",
"def", "defined", "do",
"else", "elsif", "end", "ensure",
"false", "for",
"if", "in",
"module",
"next", "nil", "not",
"or",
"redo", "rescue", "retry", "return",
"self", "super",
"then", "true",
"undef", "unless", "until",
"when", "while",
"yield",
]
CompletionProc = proc { |input|
bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
# puts "input: #{input}"
case input
when /^(\/[^\/]*\/)\.([^.]*)$/
# Regexp
receiver = $1
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[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
# Numeric
receiver = $1
message = Regexp.quote($5)
begin
candidates = eval(receiver, bind).methods
rescue Exception
candidates = []
end
select_message(receiver, message, candidates)
when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
# Numeric(0xFFFF)
receiver = $1
message = Regexp.quote($2)
begin
candidates = eval(receiver, bind).methods
rescue Exception
candidates = []
end
select_message(receiver, message, candidates)
when /^(\$[^.]*)$/
candidates = global_variables.grep(Regexp.new(Regexp.quote($1)))
# when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
when /^((\.?[^.]+)+)\.([^.]*)$/
# variable
receiver = $1
message = Regexp.quote($3)
gv = eval("global_variables", bind)
lv = eval("local_variables", bind)
cv = eval("self.class.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
else
# func1.func2
candidates = []
ObjectSpace.each_object(Module){|m|
begin
name = m.name
rescue Exception
name = ""
end
next if name != "IRB::Context" and
/^(IRB|SLex|RubyLex|RubyToken)/ =~ name
candidates.concat m.instance_methods(false)
}
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 | self.class.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
if Readline.respond_to?("basic_word_break_characters=")
Readline.basic_word_break_characters= " \t\n\"\\'`><=;|&{("
end
Readline.completion_append_character = nil
Readline.completion_proc = IRB::InputCompletor::CompletionProc
PK ! fC U
notifier.rbnu [ #
# notifier.rb - output methods used by irb
# $Release Version: 0.9.5$
# $Revision: 16857 $
# $Date: 2008-06-06 17:05:24 +0900 (Fri, 06 Jun 2008) $
# by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#
require "e2mmap"
require "irb/output-method"
module IRB
module Notifier
extend Exception2MessageMapper
def_exception :ErrUndefinedNotifier,
"undefined notifier level: %d is specified"
def_exception :ErrUnrecognizedLevel,
"unrecognized notifier level: %s is specified"
def def_notifier(prefix = "", output_method = StdioOutputMethod.new)
CompositeNotifier.new(prefix, output_method)
end
module_function :def_notifier
class AbstructNotifier
def initialize(prefix, base_notifier)
@prefix = prefix
@base_notifier = base_notifier
end
attr_reader :prefix
def notify?
true
end
def print(*opts)
@base_notifier.print prefix, *opts if notify?
end
def printn(*opts)
@base_notifier.printn prefix, *opts if notify?
end
def printf(format, *opts)
@base_notifier.printf(prefix + format, *opts) if notify?
end
def puts(*objs)
if notify?
@base_notifier.puts(*objs.collect{|obj| prefix + obj.to_s})
end
end
def pp(*objs)
if notify?
@base_notifier.ppx @prefix, *objs
end
end
def ppx(prefix, *objs)
if notify?
@base_notifier.ppx @prefix+prefix, *objs
end
end
def exec_if
yield(@base_notifier) if notify?
end
end
class CompositeNotifier(other)
@level <=> other.level
end
def notify?
@base_notifier.level >= self
end
end
class NoMsgNotifier 0
end
end
@debug_level = 0
def initialize
lex_init
set_input(STDIN)
@seek = 0
@exp_line_no = @line_no = 1
@base_char_no = 0
@char_no = 0
@rests = []
@readed = []
@here_readed = []
@indent = 0
@indent_stack = []
@lex_state = EXPR_BEG
@space_seen = false
@here_header = false
@continue = false
@line = ""
@skip_space = false
@readed_auto_clean_up = false
@exception_on_syntax_error = true
@prompt = nil
end
attr_accessor :skip_space
attr_accessor :readed_auto_clean_up
attr_accessor :exception_on_syntax_error
attr_reader :seek
attr_reader :char_no
attr_reader :line_no
attr_reader :indent
# io functions
def set_input(io, p = nil, &block)
@io = io
if p.respond_to?(:call)
@input = p
elsif block_given?
@input = block
else
@input = Proc.new{@io.gets}
end
end
def get_readed
if idx = @readed.reverse.index("\n")
@base_char_no = idx
else
@base_char_no += @readed.size
end
readed = @readed.join("")
@readed = []
readed
end
def getc
while @rests.empty?
# return nil unless buf_input
@rests.push nil unless buf_input
end
c = @rests.shift
if @here_header
@here_readed.push c
else
@readed.push c
end
@seek += 1
if c == "\n"
@line_no += 1
@char_no = 0
else
@char_no += 1
end
c
end
def gets
l = ""
while c = getc
l.concat(c)
break if c == "\n"
end
return nil if l == "" and c.nil?
l
end
def eof?
@io.eof?
end
def getc_of_rests
if @rests.empty?
nil
else
getc
end
end
def ungetc(c = nil)
if @here_readed.empty?
c2 = @readed.pop
else
c2 = @here_readed.pop
end
c = c2 unless c
@rests.unshift c #c =
@seek -= 1
if c == "\n"
@line_no -= 1
if idx = @readed.reverse.index("\n")
@char_no = @readed.size - idx
else
@char_no = @base_char_no + @readed.size
end
else
@char_no -= 1
end
end
def peek_equal?(str)
chrs = str.split(//)
until @rests.size >= chrs.size
return false unless buf_input
end
@rests[0, chrs.size] == chrs
end
def peek_match?(regexp)
while @rests.empty?
return false unless buf_input
end
regexp =~ @rests.join("")
end
def peek(i = 0)
while @rests.size <= i
return nil unless buf_input
end
@rests[i]
end
def buf_input
prompt
line = @input.call
return nil unless line
@rests.concat line.split(//)
true
end
private :buf_input
def set_prompt(p = nil, &block)
p = block if block_given?
if p.respond_to?(:call)
@prompt = p
else
@prompt = Proc.new{print p}
end
end
def prompt
if @prompt
@prompt.call(@ltype, @indent, @continue, @line_no)
end
end
def initialize_input
@ltype = nil
@quoted = nil
@indent = 0
@indent_stack = []
@lex_state = EXPR_BEG
@space_seen = false
@here_header = false
@continue = false
prompt
@line = ""
@exp_line_no = @line_no
end
def each_top_level_statement
initialize_input
catch(:TERM_INPUT) do
loop do
begin
@continue = false
prompt
unless l = lex
throw :TERM_INPUT if @line == ''
else
#p l
@line.concat l
if @ltype or @continue or @indent > 0
next
end
end
if @line != "\n"
yield @line, @exp_line_no
end
break unless l
@line = ''
@exp_line_no = @line_no
@indent = 0
@indent_stack = []
prompt
rescue TerminateLineInput
initialize_input
prompt
get_readed
end
end
end
end
def lex
until (((tk = token).kind_of?(TkNL) || tk.kind_of?(TkEND_OF_SCRIPT)) &&
!@continue or
tk.nil?)
#p tk
#p @lex_state
#p self
end
line = get_readed
# print self.inspect
if line == "" and tk.kind_of?(TkEND_OF_SCRIPT) || tk.nil?
nil
else
line
end
end
def token
# require "tracer"
# Tracer.on
@prev_seek = @seek
@prev_line_no = @line_no
@prev_char_no = @char_no
begin
begin
tk = @OP.match(self)
@space_seen = tk.kind_of?(TkSPACE)
rescue SyntaxError
raise if @exception_on_syntax_error
tk = TkError.new(@seek, @line_no, @char_no)
end
end while @skip_space and tk.kind_of?(TkSPACE)
if @readed_auto_clean_up
get_readed
end
# Tracer.off
tk
end
ENINDENT_CLAUSE = [
"case", "class", "def", "do", "for", "if",
"module", "unless", "until", "while", "begin" #, "when"
]
DEINDENT_CLAUSE = ["end" #, "when"
]
PERCENT_LTYPE = {
"q" => "\'",
"Q" => "\"",
"x" => "\`",
"r" => "/",
"w" => "]",
"W" => "]",
"s" => ":"
}
PERCENT_PAREN = {
"{" => "}",
"[" => "]",
"<" => ">",
"(" => ")"
}
Ltype2Token = {
"\'" => TkSTRING,
"\"" => TkSTRING,
"\`" => TkXSTRING,
"/" => TkREGEXP,
"]" => TkDSTRING,
":" => TkSYMBOL
}
DLtype2Token = {
"\"" => TkDSTRING,
"\`" => TkDXSTRING,
"/" => TkDREGEXP,
}
def lex_init()
@OP = IRB::SLex.new
@OP.def_rules("\0", "\004", "\032") do |op, io|
Token(TkEND_OF_SCRIPT)
end
@OP.def_rules(" ", "\t", "\f", "\r", "\13") do |op, io|
@space_seen = true
while getc =~ /[ \t\f\r\13]/; end
ungetc
Token(TkSPACE)
end
@OP.def_rule("#") do |op, io|
identify_comment
end
@OP.def_rule("=begin",
proc{|op, io| @prev_char_no == 0 && peek(0) =~ /\s/}) do
|op, io|
@ltype = "="
until getc == "\n"; end
until peek_equal?("=end") && peek(4) =~ /\s/
until getc == "\n"; end
end
gets
@ltype = nil
Token(TkRD_COMMENT)
end
@OP.def_rule("\n") do |op, io|
print "\\n\n" if RubyLex.debug?
case @lex_state
when EXPR_BEG, EXPR_FNAME, EXPR_DOT
@continue = true
else
@continue = false
@lex_state = EXPR_BEG
until (@indent_stack.empty? ||
[TkLPAREN, TkLBRACK, TkLBRACE,
TkfLPAREN, TkfLBRACK, TkfLBRACE].include?(@indent_stack.last))
@indent_stack.pop
end
end
@here_header = false
@here_readed = []
Token(TkNL)
end
@OP.def_rules("*", "**",
"=", "==", "===",
"=~", "<=>",
"<", "<=",
">", ">=", ">>") do
|op, io|
case @lex_state
when EXPR_FNAME, EXPR_DOT
@lex_state = EXPR_ARG
else
@lex_state = EXPR_BEG
end
Token(op)
end
@OP.def_rules("!", "!=", "!~") do
|op, io|
@lex_state = EXPR_BEG
Token(op)
end
@OP.def_rules("<<") do
|op, io|
tk = nil
if @lex_state != EXPR_END && @lex_state != EXPR_CLASS &&
(@lex_state != EXPR_ARG || @space_seen)
c = peek(0)
if /\S/ =~ c && (/["'`]/ =~ c || /[\w_]/ =~ c || c == "-")
tk = identify_here_document
end
end
unless tk
tk = Token(op)
case @lex_state
when EXPR_FNAME, EXPR_DOT
@lex_state = EXPR_ARG
else
@lex_state = EXPR_BEG
end
end
tk
end
@OP.def_rules("'", '"') do
|op, io|
identify_string(op)
end
@OP.def_rules("`") do
|op, io|
if @lex_state == EXPR_FNAME
@lex_state = EXPR_END
Token(op)
else
identify_string(op)
end
end
@OP.def_rules('?') do
|op, io|
if @lex_state == EXPR_END
@lex_state = EXPR_BEG
Token(TkQUESTION)
else
ch = getc
if @lex_state == EXPR_ARG && ch =~ /\s/
ungetc
@lex_state = EXPR_BEG;
Token(TkQUESTION)
else
if (ch == '\\')
read_escape
end
@lex_state = EXPR_END
Token(TkINTEGER)
end
end
end
@OP.def_rules("&", "&&", "|", "||") do
|op, io|
@lex_state = EXPR_BEG
Token(op)
end
@OP.def_rules("+=", "-=", "*=", "**=",
"&=", "|=", "^=", "<<=", ">>=", "||=", "&&=") do
|op, io|
@lex_state = EXPR_BEG
op =~ /^(.*)=$/
Token(TkOPASGN, $1)
end
@OP.def_rule("+@", proc{|op, io| @lex_state == EXPR_FNAME}) do
|op, io|
@lex_state = EXPR_ARG
Token(op)
end
@OP.def_rule("-@", proc{|op, io| @lex_state == EXPR_FNAME}) do
|op, io|
@lex_state = EXPR_ARG
Token(op)
end
@OP.def_rules("+", "-") do
|op, io|
catch(:RET) do
if @lex_state == EXPR_ARG
if @space_seen and peek(0) =~ /[0-9]/
throw :RET, identify_number
else
@lex_state = EXPR_BEG
end
elsif @lex_state != EXPR_END and peek(0) =~ /[0-9]/
throw :RET, identify_number
else
@lex_state = EXPR_BEG
end
Token(op)
end
end
@OP.def_rule(".") do
|op, io|
@lex_state = EXPR_BEG
if peek(0) =~ /[0-9]/
ungetc
identify_number
else
# for "obj.if" etc.
@lex_state = EXPR_DOT
Token(TkDOT)
end
end
@OP.def_rules("..", "...") do
|op, io|
@lex_state = EXPR_BEG
Token(op)
end
lex_int2
end
def lex_int2
@OP.def_rules("]", "}", ")") do
|op, io|
@lex_state = EXPR_END
@indent -= 1
@indent_stack.pop
Token(op)
end
@OP.def_rule(":") do
|op, io|
if @lex_state == EXPR_END || peek(0) =~ /\s/
@lex_state = EXPR_BEG
Token(TkCOLON)
else
@lex_state = EXPR_FNAME;
Token(TkSYMBEG)
end
end
@OP.def_rule("::") do
|op, io|
# p @lex_state.id2name, @space_seen
if @lex_state == EXPR_BEG or @lex_state == EXPR_ARG && @space_seen
@lex_state = EXPR_BEG
Token(TkCOLON3)
else
@lex_state = EXPR_DOT
Token(TkCOLON2)
end
end
@OP.def_rule("/") do
|op, io|
if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
identify_string(op)
elsif peek(0) == '='
getc
@lex_state = EXPR_BEG
Token(TkOPASGN, "/") #/)
elsif @lex_state == EXPR_ARG and @space_seen and peek(0) !~ /\s/
identify_string(op)
else
@lex_state = EXPR_BEG
Token("/") #/)
end
end
@OP.def_rules("^") do
|op, io|
@lex_state = EXPR_BEG
Token("^")
end
# @OP.def_rules("^=") do
# @lex_state = EXPR_BEG
# Token(OP_ASGN, :^)
# end
@OP.def_rules(",") do
|op, io|
@lex_state = EXPR_BEG
Token(op)
end
@OP.def_rules(";") do
|op, io|
@lex_state = EXPR_BEG
until (@indent_stack.empty? ||
[TkLPAREN, TkLBRACK, TkLBRACE,
TkfLPAREN, TkfLBRACK, TkfLBRACE].include?(@indent_stack.last))
@indent_stack.pop
end
Token(op)
end
@OP.def_rule("~") do
|op, io|
@lex_state = EXPR_BEG
Token("~")
end
@OP.def_rule("~@", proc{|op, io| @lex_state == EXPR_FNAME}) do
|op, io|
@lex_state = EXPR_BEG
Token("~")
end
@OP.def_rule("(") do
|op, io|
@indent += 1
if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
@lex_state = EXPR_BEG
tk_c = TkfLPAREN
else
@lex_state = EXPR_BEG
tk_c = TkLPAREN
end
@indent_stack.push tk_c
tk = Token(tk_c)
end
@OP.def_rule("[]", proc{|op, io| @lex_state == EXPR_FNAME}) do
|op, io|
@lex_state = EXPR_ARG
Token("[]")
end
@OP.def_rule("[]=", proc{|op, io| @lex_state == EXPR_FNAME}) do
|op, io|
@lex_state = EXPR_ARG
Token("[]=")
end
@OP.def_rule("[") do
|op, io|
@indent += 1
if @lex_state == EXPR_FNAME
tk_c = TkfLBRACK
else
if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
tk_c = TkLBRACK
elsif @lex_state == EXPR_ARG && @space_seen
tk_c = TkLBRACK
else
tk_c = TkfLBRACK
end
@lex_state = EXPR_BEG
end
@indent_stack.push tk_c
Token(tk_c)
end
@OP.def_rule("{") do
|op, io|
@indent += 1
if @lex_state != EXPR_END && @lex_state != EXPR_ARG
tk_c = TkLBRACE
else
tk_c = TkfLBRACE
end
@lex_state = EXPR_BEG
@indent_stack.push tk_c
Token(tk_c)
end
@OP.def_rule('\\') do
|op, io|
if getc == "\n"
@space_seen = true
@continue = true
Token(TkSPACE)
else
ungetc
Token("\\")
end
end
@OP.def_rule('%') do
|op, io|
if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
identify_quotation
elsif peek(0) == '='
getc
Token(TkOPASGN, :%)
elsif @lex_state == EXPR_ARG and @space_seen and peek(0) !~ /\s/
identify_quotation
else
@lex_state = EXPR_BEG
Token("%") #))
end
end
@OP.def_rule('$') do
|op, io|
identify_gvar
end
@OP.def_rule('@') do
|op, io|
if peek(0) =~ /[\w_@]/
ungetc
identify_identifier
else
Token("@")
end
end
# @OP.def_rule("def", proc{|op, io| /\s/ =~ io.peek(0)}) do
# |op, io|
# @indent += 1
# @lex_state = EXPR_FNAME
# # @lex_state = EXPR_END
# # until @rests[0] == "\n" or @rests[0] == ";"
# # rests.shift
# # end
# end
@OP.def_rule("") do
|op, io|
printf "MATCH: start %s: %s\n", op, io.inspect if RubyLex.debug?
if peek(0) =~ /[0-9]/
t = identify_number
elsif peek(0) =~ /[\w_]/
t = identify_identifier
end
printf "MATCH: end %s: %s\n", op, io.inspect if RubyLex.debug?
t
end
p @OP if RubyLex.debug?
end
def identify_gvar
@lex_state = EXPR_END
case ch = getc
when /[~_*$?!@\/\\;,=:<>".]/ #"
Token(TkGVAR, "$" + ch)
when "-"
Token(TkGVAR, "$-" + getc)
when "&", "`", "'", "+"
Token(TkBACK_REF, "$"+ch)
when /[1-9]/
while getc =~ /[0-9]/; end
ungetc
Token(TkNTH_REF)
when /\w/
ungetc
ungetc
identify_identifier
else
ungetc
Token("$")
end
end
def identify_identifier
token = ""
if peek(0) =~ /[$@]/
token.concat(c = getc)
if c == "@" and peek(0) == "@"
token.concat getc
end
end
while (ch = getc) =~ /\w|_/
print ":", ch, ":" if RubyLex.debug?
token.concat ch
end
ungetc
if (ch == "!" || ch == "?") && token[0,1] =~ /\w/ && peek(0) != "="
token.concat getc
end
# almost fix token
case token
when /^\$/
return Token(TkGVAR, token)
when /^\@\@/
@lex_state = EXPR_END
# p Token(TkCVAR, token)
return Token(TkCVAR, token)
when /^\@/
@lex_state = EXPR_END
return Token(TkIVAR, token)
end
if @lex_state != EXPR_DOT
print token, "\n" if RubyLex.debug?
token_c, *trans = TkReading2Token[token]
if token_c
# reserved word?
if (@lex_state != EXPR_BEG &&
@lex_state != EXPR_FNAME &&
trans[1])
# modifiers
token_c = TkSymbol2Token[trans[1]]
@lex_state = trans[0]
else
if @lex_state != EXPR_FNAME
if ENINDENT_CLAUSE.include?(token)
# check for ``class = val'' etc.
valid = true
case token
when "class"
valid = false unless peek_match?(/^\s*(<<|\w|::)/)
when "def"
valid = false if peek_match?(/^\s*(([+-\/*&\|^]|<<|>>|\|\||\&\&)=|\&\&|\|\|)/)
when "do"
valid = false if peek_match?(/^\s*([+-\/*]?=|\*|<|>|\&)/)
when *ENINDENT_CLAUSE
valid = false if peek_match?(/^\s*([+-\/*]?=|\*|<|>|\&|\|)/)
else
# no nothing
end
if valid
if token == "do"
if ![TkFOR, TkWHILE, TkUNTIL].include?(@indent_stack.last)
@indent += 1
@indent_stack.push token_c
end
else
@indent += 1
@indent_stack.push token_c
end
# p @indent_stack
end
elsif DEINDENT_CLAUSE.include?(token)
@indent -= 1
@indent_stack.pop
end
@lex_state = trans[0]
else
@lex_state = EXPR_END
end
end
return Token(token_c, token)
end
end
if @lex_state == EXPR_FNAME
@lex_state = EXPR_END
if peek(0) == '='
token.concat getc
end
elsif @lex_state == EXPR_BEG || @lex_state == EXPR_DOT
@lex_state = EXPR_ARG
else
@lex_state = EXPR_END
end
if token[0, 1] =~ /[A-Z]/
return Token(TkCONSTANT, token)
elsif token[token.size - 1, 1] =~ /[!?]/
return Token(TkFID, token)
else
return Token(TkIDENTIFIER, token)
end
end
def identify_here_document
ch = getc
# if lt = PERCENT_LTYPE[ch]
if ch == "-"
ch = getc
indent = true
end
if /['"`]/ =~ ch
lt = ch
quoted = ""
while (c = getc) && c != lt
quoted.concat c
end
else
lt = '"'
quoted = ch.dup
while (c = getc) && c =~ /\w/
quoted.concat c
end
ungetc
end
ltback, @ltype = @ltype, lt
reserve = []
while ch = getc
reserve.push ch
if ch == "\\"
reserve.push ch = getc
elsif ch == "\n"
break
end
end
@here_header = false
while l = gets
l = l.sub(/(:?\r)?\n\z/, '')
if (indent ? l.strip : l) == quoted
break
end
end
@here_header = true
@here_readed.concat reserve
while ch = reserve.pop
ungetc ch
end
@ltype = ltback
@lex_state = EXPR_END
Token(Ltype2Token[lt])
end
def identify_quotation
ch = getc
if lt = PERCENT_LTYPE[ch]
ch = getc
elsif ch =~ /\W/
lt = "\""
else
RubyLex.fail SyntaxError, "unknown type of %string"
end
# if ch !~ /\W/
# ungetc
# next
# end
#@ltype = lt
@quoted = ch unless @quoted = PERCENT_PAREN[ch]
identify_string(lt, @quoted)
end
def identify_number
@lex_state = EXPR_END
if peek(0) == "0" && peek(1) !~ /[.eE]/
getc
case peek(0)
when /[xX]/
ch = getc
match = /[0-9a-fA-F_]/
when /[bB]/
ch = getc
match = /[01_]/
when /[oO]/
ch = getc
match = /[0-7_]/
when /[dD]/
ch = getc
match = /[0-9_]/
when /[0-7]/
match = /[0-7_]/
when /[89]/
RubyLex.fail SyntaxError, "Illegal octal digit"
else
return Token(TkINTEGER)
end
len0 = true
non_digit = false
while ch = getc
if match =~ ch
if ch == "_"
if non_digit
RubyLex.fail SyntaxError, "trailing `#{ch}' in number"
else
non_digit = ch
end
else
non_digit = false
len0 = false
end
else
ungetc
if len0
RubyLex.fail SyntaxError, "numeric literal without digits"
end
if non_digit
RubyLex.fail SyntaxError, "trailing `#{non_digit}' in number"
end
break
end
end
return Token(TkINTEGER)
end
type = TkINTEGER
allow_point = true
allow_e = true
non_digit = false
while ch = getc
case ch
when /[0-9]/
non_digit = false
when "_"
non_digit = ch
when allow_point && "."
if non_digit
RubyLex.fail SyntaxError, "trailing `#{non_digit}' in number"
end
type = TkFLOAT
if peek(0) !~ /[0-9]/
type = TkINTEGER
ungetc
break
end
allow_point = false
when allow_e && "e", allow_e && "E"
if non_digit
RubyLex.fail SyntaxError, "trailing `#{non_digit}' in number"
end
type = TkFLOAT
if peek(0) =~ /[+-]/
getc
end
allow_e = false
allow_point = false
non_digit = ch
else
if non_digit
RubyLex.fail SyntaxError, "trailing `#{non_digit}' in number"
end
ungetc
break
end
end
Token(type)
end
def identify_string(ltype, quoted = ltype)
@ltype = ltype
@quoted = quoted
subtype = nil
begin
nest = 0
while ch = getc
if @quoted == ch and nest == 0
break
elsif @ltype != "'" && @ltype != "]" && @ltype != ":" and ch == "#"
subtype = true
elsif ch == '\\' #'
read_escape
end
if PERCENT_PAREN.values.include?(@quoted)
if PERCENT_PAREN[ch] == @quoted
nest += 1
elsif ch == @quoted
nest -= 1
end
end
end
if @ltype == "/"
if peek(0) =~ /i|m|x|o|e|s|u|n/
getc
end
end
if subtype
Token(DLtype2Token[ltype])
else
Token(Ltype2Token[ltype])
end
ensure
@ltype = nil
@quoted = nil
@lex_state = EXPR_END
end
end
def identify_comment
@ltype = "#"
while ch = getc
# if ch == "\\" #"
# read_escape
# end
if ch == "\n"
@ltype = nil
ungetc
break
end
end
return Token(TkCOMMENT)
end
def read_escape
case ch = getc
when "\n", "\r", "\f"
when "\\", "n", "t", "r", "f", "v", "a", "e", "b", "s" #"
when /[0-7]/
ungetc ch
3.times do
case ch = getc
when /[0-7]/
when nil
break
else
ungetc
break
end
end
when "x"
2.times do
case ch = getc
when /[0-9a-fA-F]/
when nil
break
else
ungetc
break
end
end
when "M"
if (ch = getc) != '-'
ungetc
else
if (ch = getc) == "\\" #"
read_escape
end
end
when "C", "c" #, "^"
if ch == "C" and (ch = getc) != "-"
ungetc
elsif (ch = getc) == "\\" #"
read_escape
end
else
# other characters
end
end
end
PK ! z/ /
version.rbnu [ PK ! - - i output-method.rbnu [ PK ! SW W init.rbnu [ PK ! \·
d ruby-token.rbnu [ PK ! r)X X
X> cmd/nop.rbnu [ PK ! E1
@ cmd/pushws.rbnu [ PK ! k=
C cmd/chws.rbnu [ PK ! L M M E cmd/help.rbnu [ PK ! $b
H cmd/subirb.rbnu [ PK ! o o OK cmd/fork.rbnu [ PK ! ิ M cmd/load.rbnu [ PK ! V
R context.rbnu [ PK ! Jx x -k ext/save-history.rbnu [ PK ! + s ext/multi-irb.rbnu [ PK ! G ( ext/change-ws.rbnu [ PK !
ext/loader.rbnu [ PK ! |Ӑ~y y : ext/history.rbnu [ PK ! >
ext/tracer.rbnu [ PK ! I|S S Ԣ ext/use-loader.rbnu [ PK ! cq q h ext/math-mode.rbnu [ PK ! ext/workspaces.rbnu [ PK ! 1I , ws-for-case-2.rbnu [ PK ! B n frame.rbnu [ PK ! ~W extend-command.rbnu [ PK ! 6|
|
locale.rbnu [ PK ! . D xmp.rbnu [ PK ! &F F g help.rbnu [ PK ! nX lc/error.rbnu [ PK ! *O. . lc/ja/error.rbnu [ PK ! ) lc/ja/help-messagenu [ PK ! . . lc/help-messagenu [ PK ! (_; ; f input-method.rbnu [ PK ! L(E E slex.rbnu [ PK ! sh h
\ completion.rbnu [ PK ! fC U
0 notifier.rbnu [ PK ! S0
0
; workspace.rbnu [ PK ! DmU U E ruby-lex.rbnu [ PK % % C