2000-05-12

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@687 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,6 +1,57 @@
-Tue May  9 17:08:43 2000  Yukihiro Matsumoto  <matz@netlab.co.jp>
+Fri May 12 17:33:44 2000  Yukihiro Matsumoto  <matz@netlab.co.jp>
 
-	* array.c (Init_Array): prepare 'append' as alias to `push'. 
+	* regex.c (re_compile_pattern): charset_not should not exclude
+	  newline from matching set.
+
+Thu May 11 22:51:05 2000  Ryunosuke Ohshima  <ryu@jaist.ac.jp>
+
+	* pack.c (pack_pack): Bignum support.
+
+	* pack.c (pack_unpack): ditto.
+
+Thu May 11 21:19:29 2000  Hiroshi Igarashi  <iga@ruby-lang.org>
+
+	* intern.h: add missing declarations of ruby API functions.
+
+	* ruby.h: fix function name in declarations.
+
+Thu May 11 22:29:25 2000  Katsuyuki Komatsu  <komatsu@sarion.co.jp>
+
+	* ext/md5/depend: add $(topdir)/config.h dependency to md5c.o.
+
+	* ext/md5/extconf.rb: new file to add -DHAVE_CONFIG_H flag for Alpha.
+
+Thu May 11 10:55:52 2000  Ryunosuke Ohshima  <ryu@jaist.ac.jp>
+
+	* pack.c (pack_pack): packing BER compressed integer by `w'.
+
+	* pack.c (pack_unpack): unpacking BER.
+
+Thu May 11 00:37:55 2000  Yukihiro Matsumoto  <matz@netlab.co.jp>
+
+	* parse.y (parse_regx): remove in_brack.
+
+Wed May 10 12:51:18 2000  Yukihiro Matsumoto  <matz@netlab.co.jp>
+
+	* ruby.c (proc_options): move adding RUBYLIB and "." to the load
+	  path after #! line parsing.
+
+	* parse.y (parse_regx): should parse backslash escape like `\c['
+	  here to avoid causing `unterminated regexp' error.
+
+Wed May 10 00:19:53 2000  Katsuyuki Komatsu  <komatsu@sarion.co.jp>
+
+	* MANIFEST, beos/GNUmakefile.in, configure.in: no longer need
+	  beos/GNUmakefile.in to support BeOS R4.5.2 (Intel) as a result
+	  of eban's Makefile.in change.
+
+	* io.c: NOFILE is already defined on BeOS R4.5 (Intel) or later.
+
+	* lib/matrix.rb: remove debug print.
+
+	* regex.c: don't use nested comment.
+
+Tue May  9 17:08:43 2000  Yukihiro Matsumoto  <matz@netlab.co.jp>
 
 	* eval.c (massign): no longer convert nil into empty array.
 

MANIFEST

@@ -75,7 +75,6 @@ util.c
 variable.c
 version.c
 version.h
-beos/GNUmakefile.in
 cygwin/GNUmakefile.in
 ext/Setup
 ext/Setup.dj

ToDo

@@ -41,6 +41,7 @@ Hacking Interpreter
 * scrambled script, or script filter
 * setuid ruby
 * performance tune for in-block (dynamic) local variables.
+* generational GC ?? (is it possible?)
 
 Standard Libraries
 
@@ -64,6 +65,7 @@ Standard Libraries
 - Kernel#scan
 - call initialize for builtin classes too (not yet: Regexp, Class, Module)
 - performance tune for String's non-bang methods.
+- 'w' template for pack/unpack
 * String#scanf(?)
 * Object#fmt(?)
 * Integer#{bin,oct,hex,heX}

array.c

@@ -1601,7 +1601,6 @@ Init_Array()
     rb_define_method(rb_cArray, "last", rb_ary_last, 0);
     rb_define_method(rb_cArray, "concat", rb_ary_concat, 1);
     rb_define_method(rb_cArray, "<<", rb_ary_push, 1);
-    rb_define_method(rb_cArray, "append", rb_ary_push_m, -1);
     rb_define_method(rb_cArray, "push", rb_ary_push_m, -1);
     rb_define_method(rb_cArray, "pop", rb_ary_pop, 0);
     rb_define_method(rb_cArray, "shift", rb_ary_shift, 0);

bignum.c

@@ -423,6 +423,7 @@ rb_big2ulong(x)
     unsigned long num = big2ulong(x, "unsigned long");
 
     if (!RBIGNUM(x)->sign) return -num;
+    return num;
 }
 
 long
@@ -944,7 +945,7 @@ rb_big_remainder(x, y)
     return rb_big_modulo(x, y, 0);
 }
 
-static VALUE
+VALUE
 rb_big_divmod(x, y)
     VALUE x, y;
 {

configure

@@ -4870,7 +4870,6 @@ if test "$target_os" = "beos"; then
       ;;
     i586*)
       LDFLAGS="$LDFLAGS -L."
-      FIRSTMAKEFILE=GNUmakefile:beos/GNUmakefile.in
       ;;
     *)
       echo EXPORTS > ruby.def

configure.in

@@ -707,7 +707,6 @@ if test "$target_os" = "beos"; then
       ;;
     i586*)
       LDFLAGS="$LDFLAGS -L."
-      FIRSTMAKEFILE=GNUmakefile:beos/GNUmakefile.in
       ;;
     *)
       echo EXPORTS > ruby.def

dln.c

@@ -15,6 +15,7 @@
 #include "dln.h"
 
 char *dln_argv0;
+void rb_loaderror();
 
 #ifdef _AIX
 #pragma alloca

eval.c

@@ -1362,7 +1362,6 @@ ev_const_set(cref, id, val)
     VALUE val;
 {
     NODE *cbase = cref;
-    VALUE tmp;
 
     while (cbase && cbase->nd_clss != rb_cObject) {
 	struct RClass *klass = RCLASS(cbase->nd_clss);
@@ -2760,9 +2759,12 @@ rb_eval(self, n)
 	    else if (SCOPE_TEST(SCOPE_PROTECTED)) {
 		noex = NOEX_PROTECTED;
 	    }
-	    else {
+	    else if (ruby_class == rb_cObject) {
 		noex =  node->nd_noex;
 	    }
+	    else {
+		noex = NOEX_PUBLIC;
+	    }
 	    if (body && origin == ruby_class && body->nd_noex & NOEX_UNDEF) {
 		noex |= NOEX_UNDEF;
 	    }
@@ -4552,7 +4554,7 @@ rb_f_eval(argc, argv, self)
     VALUE *argv;
     VALUE self;
 {
-    VALUE src, scope, vfile, vline, val;
+    VALUE src, scope, vfile, vline;
     char *file = "(eval)";
     int line = 1;
 
@@ -4660,7 +4662,7 @@ yield_under_i(self)
     if (ruby_block->flags & BLOCK_DYNAMIC) {
 	struct BLOCK * volatile old_block = ruby_block;
 	struct BLOCK block;
-	volatile VALUE cbase = ruby_block->frame.cbase;
+
 	/* cbase should be pointed from volatile local variable */
 	/* to be protected from GC. 				*/
 	VALUE result;
@@ -4977,9 +4979,8 @@ rb_f_require(obj, fname)
     buf = ALLOCA_N(char, strlen(RSTRING(fname)->ptr) + 5);
     strcpy(buf, RSTRING(fname)->ptr);
     strcat(buf, ".rb");
-    file = rb_find_file(buf);
+    if (rb_find_file(buf)) {
-    if (file) {
+	fname = rb_str_new2(buf);
-	fname = rb_str_new2(file);
 	feature = buf;
 	goto load_rb;
     }
@@ -6490,8 +6491,9 @@ thread_switch(n)
 	break;
       case RESTORE_NORMAL:
       default:
-	return 1;
+	break;
     }
+    return 1;
 }
 
 #define THREAD_SAVE_CONTEXT(th) \

ext/etc/etc.c

@@ -10,6 +10,11 @@
 
 #include "ruby.h"
 
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
 #ifdef HAVE_GETPWENT
 #include <pwd.h>
 #endif

ext/md5/depend

@@ -1,2 +1,2 @@
-md5c.o: md5c.c md5.h
+md5c.o: md5c.c md5.h $(topdir)/config.h
 md5init.o: md5init.c $(hdrdir)/ruby.h $(topdir)/config.h $(hdrdir)/defines.h md5.h

ext/socket/socket.c

@@ -15,6 +15,11 @@
 #include "rubysig.h"
 #include <stdio.h>
 #include <sys/types.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
 #ifndef NT
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -538,7 +543,7 @@ ip_addrsetup(host, port)
 	portp = 0;
     }
     else if (FIXNUM_P(port)) {
-	snprintf(pbuf, sizeof(pbuf), "%d", FIX2INT(port));
+	snprintf(pbuf, sizeof(pbuf), "%ld", FIX2INT(port));
 	portp = pbuf;
     }
     else {
@@ -726,7 +731,7 @@ open_inet(class, h, serv, type)
 	host = NULL;
     }
     if (FIXNUM_P(serv)) {
-	snprintf(pbuf, sizeof(pbuf), "%d", FIX2UINT(serv));
+	snprintf(pbuf, sizeof(pbuf), "%ld", FIX2UINT(serv));
 	portp = pbuf;
     }
     else {
@@ -1748,7 +1753,7 @@ sock_s_getaddrinfo(argc, argv)
 	pptr = NULL;
     }
     else if (FIXNUM_P(port)) {
-	snprintf(pbuf, sizeof(pbuf), "%d", FIX2INT(port));
+	snprintf(pbuf, sizeof(pbuf), "%ld", FIX2INT(port));
 	pptr = pbuf;
     }
     else {
@@ -1788,7 +1793,7 @@ sock_s_getnameinfo(argc, argv)
     int argc;
     VALUE *argv;
 {
-    VALUE sa, af, host, port, flags;
+    VALUE sa, af = Qnil, host = Qnil, port = Qnil, flags;
     static char hbuf[1024], pbuf[1024];
     char *hptr, *pptr;
     int fl;
@@ -1824,6 +1829,10 @@ sock_s_getnameinfo(argc, argv)
 		host = RARRAY(sa)->ptr[2];
 	    }
 	}
+	else {
+	    rb_raise(rb_eArgError, "array size should be 3 or 4, %d given",
+		     RARRAY(sa)->len);
+	}
 	if (NIL_P(host)) {
 	    hptr = NULL;
 	}
@@ -1837,7 +1846,7 @@ sock_s_getnameinfo(argc, argv)
 	    pptr = NULL;
 	}
 	else if (!NIL_P(port)) {
-	    snprintf(pbuf, sizeof(pbuf), "%d", NUM2INT(port));
+	    snprintf(pbuf, sizeof(pbuf), "%ld", NUM2INT(port));
 	    pptr = pbuf;
 	}
 	else {
@@ -1872,7 +1881,6 @@ sock_s_getnameinfo(argc, argv)
 	fl = NUM2INT(flags);
     }
 
-  gotsap:
     error = getnameinfo(sap, SA_LEN(sap), hbuf, sizeof(hbuf),
 			pbuf, sizeof(pbuf), fl);
     if (error) {

ext/socket/sockport.h

@@ -37,7 +37,7 @@
 # define SET_SIN_LEN(si,len) (si)->sin_len = (len)
 #else
 # define SIN_LEN(si) sizeof(struct sockaddr_in)
-# define SET_SIN_LEN(si,len) (len)
+# define SET_SIN_LEN(si,len)
 #endif
 
 #endif

file.c

@@ -25,6 +25,12 @@
 #include <unistd.h>
 #endif
 
+#ifdef HAVE_SYS_FILE_H
+# include <sys/file.h>
+#else
+int flock _((int, int));
+#endif
+
 #ifdef HAVE_SYS_PARAM_H
 # include <sys/param.h>
 #else
@@ -875,6 +881,7 @@ rb_file_s_chmod(argc, argv)
     VALUE rest;
     int mode, n;
 
+    rb_secure(2);
     rb_scan_args(argc, argv, "1*", &vmode, &rest);
     mode = NUM2INT(vmode);
 
@@ -927,6 +934,7 @@ rb_file_s_chown(argc, argv)
     struct chown_args arg;
     int n;
 
+    rb_secure(2);
     rb_scan_args(argc, argv, "2*", &o, &g, &rest);
     if (NIL_P(o)) {
 	arg.owner = -1;
@@ -1377,6 +1385,7 @@ static VALUE
 rb_file_s_truncate(obj, path, len)
     VALUE obj, path, len;
 {
+    rb_secure(2);
     Check_SafeStr(path);
 
 #ifdef HAVE_TRUNCATE

gc.c

@@ -52,7 +52,6 @@ static unsigned long malloc_memories = 0;
 static unsigned long alloc_objects = 0;
 
 static int malloc_called = 0;
-static int second_mem_error = 0;
 
 static void
 mem_error(mesg)
@@ -947,11 +946,7 @@ rb_gc()
     setjmp(save_regs_gc_mark);
     mark_locations_array((VALUE*)save_regs_gc_mark, sizeof(save_regs_gc_mark) / sizeof(VALUE *));
     rb_gc_mark_locations(rb_gc_stack_start, (VALUE*)STACK_END);
-#if defined(THINK_C) || defined(__human68k__)
+#if defined(__human68k__)
-#ifndef __human68k__
-    mark_locations_array((VALUE*)((char*)save_regs_gc_mark+2),
-			 sizeof(save_regs_gc_mark) / sizeof(VALUE *));
-#endif
     rb_gc_mark_locations((VALUE*)((char*)rb_gc_stack_start + 2),
 			 (VALUE*)((char*)STACK_END + 2));
 #endif

hash.c

@@ -688,8 +688,6 @@ static VALUE
 rb_hash_to_s(hash)
     VALUE hash;
 {
-    VALUE str;
-
     if (rb_inspecting_p(hash)) return rb_str_new2("{...}");
     return rb_protect_inspect(to_s_hash, hash, 0);
 }
@@ -929,8 +927,6 @@ env_fetch(argc, argv)
     char *nam, *env;
     int len;
 
-    VALUE val;
-
     rb_scan_args(argc, argv, "11", &key, &if_none);
     nam = rb_str2cstr(key, &len);
     if (strlen(nam) != len) {

intern.h

@@ -68,6 +68,7 @@ double rb_big2dbl _((VALUE));
 VALUE rb_big_plus _((VALUE, VALUE));
 VALUE rb_big_minus _((VALUE, VALUE));
 VALUE rb_big_mul _((VALUE, VALUE));
+VALUE rb_big_divmod _((VALUE, VALUE));
 VALUE rb_big_pow _((VALUE, VALUE));
 VALUE rb_big_and _((VALUE, VALUE));
 VALUE rb_big_or _((VALUE, VALUE));
@@ -105,6 +106,7 @@ VALUE rb_exc_new3 _((VALUE, VALUE));
 void rb_loaderror __((const char*, ...)) NORETURN;
 void rb_compile_error __((const char*, ...));
 void rb_compile_error_append __((const char*, ...));
+void rb_error_frozen _((char*));
 /* eval.c */
 void rb_exc_raise _((VALUE)) NORETURN;
 void rb_exc_fatal _((VALUE)) NORETURN;
@@ -219,6 +221,7 @@ VALUE rb_obj_clone _((VALUE));
 VALUE rb_obj_taint _((VALUE));
 VALUE rb_obj_tainted _((VALUE));
 VALUE rb_obj_untaint _((VALUE));
+VALUE rb_obj_freeze _((VALUE));
 VALUE rb_obj_id _((VALUE));
 VALUE rb_convert_type _((VALUE,int,const char*,const char*));
 VALUE rb_Integer _((VALUE));
@@ -240,6 +243,7 @@ void rb_parser_append_print _((void));
 void rb_parser_while_loop _((int, int));
 int rb_is_const_id _((ID));
 int rb_is_instance_id _((ID));
+int rb_is_class_id _((ID));
 VALUE rb_backref_get _((void));
 void rb_backref_set _((VALUE));
 VALUE rb_lastline_get _((void));
@@ -352,8 +356,12 @@ int rb_const_defined _((VALUE, ID));
 VALUE rb_const_get _((VALUE, ID));
 VALUE rb_const_get_at _((VALUE, ID));
 void rb_const_set _((VALUE, ID, VALUE));
+void rb_const_assign _((VALUE, ID, VALUE));
 VALUE rb_mod_constants _((VALUE));
 void rb_autoload_load _((ID));
+void rb_cvar_declare _((VALUE, ID, VALUE));
+VALUE rb_cvar_get _((VALUE, ID));
+void rb_cvar_set _((VALUE, ID, VALUE));
 /* version.c */
 void ruby_show_version _((void));
 void ruby_show_copyright _((void));

io.c

@@ -63,7 +63,7 @@ char *strdup();
 extern void Init_File _((void));
 
 #ifdef __BEOS__
-# ifdef _X86_
+# ifdef NOFILE
 #  define NOFILE (OPEN_MAX)
 # endif
 #include <net/socket.h>
@@ -170,6 +170,25 @@ rb_read_check(fp)
     }
 }
 
+static int
+rb_dup(orig)
+    int orig;
+{
+    int fd;
+
+    fd = dup(orig);
+    if (fd < 0) {
+	if (errno == EMFILE || errno == ENFILE) {
+	    rb_gc();
+	    fd = dup(orig);
+	}
+	if (fd < 0) {
+	    rb_sys_fail(0);
+	}
+    }
+    return fd;
+}
+
 /* writing functions */
 static VALUE
 io_write(io, str)
@@ -1893,10 +1912,10 @@ rb_io_clone(io)
 	else          mode = "r+";
 	break;
     }
-    fd = dup(fileno(orig->f));
+    fd = rb_dup(fileno(orig->f));
     fptr->f = rb_fdopen(fd, mode);
     if (fptr->f2) {
-	fd = dup(fileno(orig->f2));
+	fd = rb_dup(fileno(orig->f2));
 	fptr->f = rb_fdopen(fd, "w");
     }
     if (fptr->mode & FMODE_BINMODE) {
@@ -2126,25 +2145,6 @@ rb_io_defset(val, id)
     rb_defout = val;
 }
 
-static int
-rb_dup(orig)
-    int orig;
-{
-    int fd;
-
-    fd = dup(orig);
-    if (fd < 0) {
-	if (errno == EMFILE || errno == ENFILE) {
-	    rb_gc();
-	    fd = dup(orig);
-	}
-	if (fd < 0) {
-	    rb_sys_fail(0);
-	}
-    }
-    return fd;
-}
-
 static void
 set_stdin(val, id, var)
     VALUE val;
@@ -2152,8 +2152,6 @@ set_stdin(val, id, var)
     VALUE *var;
 {
     OpenFile *fptr;
-    int fd;
-    char *mode;
 
     if (val == *var) return;
     if (TYPE(val) != T_FILE) {
@@ -2180,8 +2178,6 @@ set_outfile(val, var, orig, stdf)
 {
     OpenFile *fptr;
     FILE *f;
-    int fd;
-    char *mode;
 
     if (val == *var) return;
 
@@ -2247,7 +2243,6 @@ rb_io_s_new(argc, argv, klass)
     VALUE *argv;
     VALUE klass;
 {
-    OpenFile *fp;
     NEWOBJ(io, struct RFile);
     OBJSETUP(io, klass, T_FILE);
     

lib/irb/completion.rb

@@ -0,0 +1,47 @@
+
+require "readline"
+
+module IRB
+  module InputCompletion
+    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|
+      case input
+      when /^([^.]+)\.([^.]*)$/
+	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)
+	else
+	  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)
+	(candidates|ReservedWords).grep(/^#{Regexp.quote(input)}/)
+      end
+    }
+  end
+end
+
+Readline.completion_proc = IRB::InputCompletion::CompletionProc

lib/irb/frame.rb

@@ -0,0 +1,67 @@
+#
+#   frame.rb - 
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+require "e2mmap"
+
+module IRB
+  class Frame
+    extend Exception2MessageMapper
+    def_exception :FrameOverflow, "frame overflow"
+    def_exception :FrameUnderflow, "frame underflow"
+
+    INIT_STACK_TIMES = 3
+    CALL_STACK_OFFSET = 3
+
+    def initialize
+      @frames = [TOPLEVEL_BINDING] * INIT_STACK_TIMES
+    end
+
+    def trace_func(event, file, line, id, binding)
+      case event
+      when 'call', 'class'
+	@frames.push binding
+      when 'return', 'end'
+	@frames.pop
+      end
+    end
+
+    def top(n = 0)
+      bind = @frames[-(n + CALL_STACK_OFFSET)]
+      Fail FrameUnderflow unless bind
+      bind
+    end
+
+    def bottom(n = 0)
+      bind = @frames[n]
+      Fail FrameOverflow unless bind
+      bind
+    end
+
+    # singleton functions
+    def Frame.bottom(n = 0)
+      @backtrace.bottom(n)
+    end
+
+    def Frame.top(n = 0)
+      @backtrace.top(n)
+    end
+
+    def Frame.sender
+      eval "self", @backtrace.top
+    end
+
+    @backtrace = Frame.new
+    set_trace_func proc{|event, file, line, id, binding|
+      @backtrace.trace_func(event, file, line, id, binding)
+    }
+  end
+end

lib/irb/input-method.rb

@@ -0,0 +1,118 @@
+#
+#   input-method.rb - input methods using irb
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+module IRB
+  # 
+  # InputMethod
+  #	StdioInputMethod
+  #	FileInputMethod
+  #	(ReadlineInputMethod)
+  #
+  STDIN_FILE_NAME = "(line)"
+  class InputMethod
+    @RCS_ID='-$Id$-'
+
+    def initialize(file = STDIN_FILE_NAME)
+      @file_name = file
+    end
+    attr :file_name
+
+    attr :prompt, true
+    
+    def gets
+      IRB.fail NotImplementError, "gets"
+    end
+    public :gets
+
+    def readable_atfer_eof?
+      false
+    end
+  end
+  
+  class StdioInputMethod < InputMethod
+    def initialize
+      super
+      @line_no = 0
+      @line = []
+    end
+
+    def gets
+      print @prompt
+      @line[@line_no += 1] = $stdin.gets
+    end
+
+    def eof?
+      $stdin.eof?
+    end
+
+    def readable_atfer_eof?
+      true
+    end
+
+    def line(line_no)
+      @line[line_no]
+    end
+  end
+  
+  class FileInputMethod < InputMethod
+    def initialize(file)
+      super
+      @io = open(file)
+    end
+    attr :file_name
+
+    def eof?
+      @io.eof?
+    end
+
+    def gets
+      l = @io.gets
+      print @prompt, l
+      l
+    end
+  end
+
+  begin
+    require "readline"
+    class ReadlineInputMethod < InputMethod
+      include Readline 
+      def initialize
+	super
+
+	@line_no = 0
+	@line = []
+	@eof = false
+      end
+
+      def gets
+	if l = readline(@prompt, true)
+	  @line[@line_no += 1] = l + "\n"
+	else
+	  @eof = true
+	  l
+	end
+      end
+
+      def eof?
+	@eof
+      end
+
+      def readable_atfer_eof?
+	true
+      end
+
+      def line(line_no)
+	@line[line_no]
+      end
+    end
+  rescue LoadError
+  end
+end

lib/irb/loader.rb

@@ -0,0 +1,118 @@
+#
+#   irb-loader.rb - 
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+module IRB
+  class LoadAbort < GlobalExit;end
+
+  module Loader
+    @RCS_ID='-$Id$-'
+
+    alias ruby_load load
+    alias ruby_require require
+
+    def irb_load(file_name)
+      return ruby_load(file_name) unless IRB.conf[:USE_LOADER]
+
+      load_sub(file_name)
+      return true
+    end
+
+    def irb_require(file_name)
+      return ruby_require(file_name) unless IRB.conf[:USE_LOADER]
+
+      rex = Regexp.new("#{Regexp.quote(file_name)}(\.o|\.rb)?")
+      return false if $".find{|f| f =~ rex}
+
+      case file_name
+      when /\.rb$/
+	begin
+	  load_sub(file_name)
+	  $".push file_name
+	  return true
+	rescue LoadError
+	end
+      when /\.(so|o|sl)$/
+	return ruby_require(file_name)
+      end
+      
+      begin
+	load_sub(f = file_name + ".rb")
+	$".push f
+	return true
+      rescue LoadError
+	return ruby_require(file_name)
+      end
+    end
+
+    def load_sub(fn)
+      if fn =~ /^#{Regexp.quote(File::Separator)}/
+	return false unless File.exist?(fn)
+	return irb_context.load_file(fn)
+      end
+      
+      for path in $:
+	if File.exist?(f = File.join(path, fn))
+	  return irb_context.load_file(f)
+	end
+      end
+      raise LoadError, "No such file to load -- #{file_name}"
+    end
+
+    alias load irb_load
+    alias require irb_require
+  end
+
+#   class Context
+#     def load_from(file_name)
+#       io = FileInputMethod.new(file_name)
+#       @irb.signal_status(:IN_LOAD) do
+# 	switch_io(io, file_name) do
+# 	  eval_input
+# 	end
+#       end
+#     end
+#   end
+
+  class Context
+    def load_file(path)
+      back_io = @io
+      back_path = @irb_path
+      back_name = @irb_name
+      back_scanner = @irb.scanner
+      begin
+ 	@io = FileInputMethod.new(path)
+ 	@irb_name = File.basename(path)
+	@irb_path = path
+	@irb.signal_status(:IN_LOAD) do
+	  if back_io.kind_of?(FileInputMethod)
+	    @irb.eval_input
+	  else
+	    begin
+	      @irb.eval_input
+	    rescue LoadAbort
+	      print "load abort!!\n"
+	    end
+	  end
+	end
+      ensure
+ 	@io = back_io
+ 	@irb_name = back_name
+ 	@irb_path = back_path
+	@irb.scanner = back_scanner
+      end
+    end
+  end
+
+  module ExtendCommand
+    include Loader
+  end
+end

lib/irb/main.rb

@@ -0,0 +1,867 @@
+#
+#   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

lib/irb/multi-irb.rb

@@ -0,0 +1,212 @@
+#
+#   multi-irb.rb - multiple irb module
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+IRB.fail CanNotGoMultiIrbMode unless defined?(Thread)
+require "thread"
+
+module IRB
+  # job management class
+  class JobManager
+    @RCS_ID='-$Id$-'
+
+    def initialize
+      # @jobs = [[thread, irb],...]
+      @jobs = []
+      @current_job = nil
+    end
+
+    attr :current_job, true
+
+    def n_jobs
+      @jobs.size
+    end
+
+    def thread(key)
+      th, irb = search(key)
+      irb
+    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 IrbSwitchToCurrentThread 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)
+      case key
+      when Integer
+	@jobs[key]
+      when Irb
+	@jobs.find{|k, v| v.equal?(irb)}
+      when Thread
+	@jobs.assoc(key)
+      else
+	assoc = @jobs.find{|k, v| v.context.main.equal?(key)}
+	IRB.fail NoSuchJob, key if assoc.nil?
+	assoc
+      end
+    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
+
+  # invoke multiple irb 
+  def IRB.irb(file = nil, *main)
+    workspace = IRB.workspace_binding(*main)
+    if main.empty?
+      main = eval("self", workspace)
+    else
+      main = main[0]
+    end
+    parent_thread = Thread.current
+    Thread.start do
+      begin
+	irb = Irb.new(main, workspace, file)
+      rescue 
+	print "Subirb can't start with context(self): ", 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)
+      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 _=(value)
+      @_ = value
+      eval "_ = IRB.JobManager.irb(Thread.current).context._", @bind
+    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
+
+  trap("SIGINT") do
+    @JobManager.current_job.signal_handle
+  end
+
+end

lib/irb/ruby-lex.rb

@@ -0,0 +1,955 @@
+#
+#   ruby-lex.rb - ruby lexcal analizer
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "e2mmap"
+require "irb/slex"
+require "irb/ruby-token"
+
+class RubyLex
+  @RCS_ID='-$Id$-'
+
+  extend Exception2MessageMapper
+  def_exception(:AlreadyDefinedToken, "Already defined token(%s)")
+  def_exception(:TkReading2TokenNoKey, "key nothing(key='%s')")
+  def_exception(:TkSymbol2TokenNoKey, "key nothing(key='%s')")
+  def_exception(:TkReading2TokenDuplicateError, 
+		"key duplicate(token_n='%s', key='%s')")
+  def_exception(:SyntaxError, "%s")
+  
+  include RubyToken
+
+  class << self
+    attr :debug_level, TRUE
+    def debug?
+      @debug_level > 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
+
+    @skip_space = false
+    @readed_auto_clean_up = false
+    @exception_on_syntax_error = true
+  end
+
+  attr :skip_space, true
+  attr :readed_auto_clean_up, true
+  attr :exception_on_syntax_error, true
+
+  attr :seek
+  attr :char_no
+  attr :line_no
+  attr :indent
+
+  # io functions
+  def set_input(io, p = nil)
+    @io = io
+    if p.kind_of?(Proc)
+      @input = p
+    elsif iterator?
+      @input = proc
+    else
+      @input = proc{@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
+    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
+    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 = proc)
+    if p.kind_of?(Proc)
+      @prompt = p
+    else
+      @prompt = proc{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
+    @lex_state = EXPR_BEG
+    @space_seen = false
+    @here_header = false
+    
+    prompt
+    @continue = FALSE
+
+    @line = ""
+    @exp_line_no = @line_no
+  end
+  
+  def each_top_level_statement
+    initialize_input
+    loop do
+      @continue = FALSE
+      prompt
+      unless l = lex
+	break 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
+      prompt
+    end
+  end
+
+  def lex
+    until (((tk = token).kind_of?(TkNL) || tk.kind_of?(TkEND_OF_SCRIPT)) &&
+	     !@continue or
+	     tk.nil?)
+      #	p tk
+      #	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
+	abort 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" => "]"
+  }
+  
+  PERCENT_PAREN = {
+    "{" => "}",
+    "[" => "]",
+    "<" => ">",
+    "(" => ")"
+  }
+
+  Ltype2Token = {
+    "\'" => TkSTRING,
+    "\"" => TkSTRING,
+    "\`" => TkXSTRING,
+    "\/" => TkREGEXP,
+    "]" => TkDSTRING
+  }
+  DLtype2Token = {
+    "\"" => TkDSTRING,
+    "\`" => TkDXSTRING,
+    "\/" => TkDREGEXP,
+  }
+
+  def lex_init()
+    @OP = SLex.new
+    @OP.def_rules("\0", "\004", "\032") do
+      Token(TkEND_OF_SCRIPT)
+    end
+
+    @OP.def_rules(" ", "\t", "\f", "\r", "\13") do
+      @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{@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
+      getc; getc; getc; getc
+      @ltype = nil
+      Token(TkRD_COMMENT)
+    end
+
+    @OP.def_rule("\n") do
+      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
+      end
+      @here_header = false
+      @here_readed = []
+      Token(TkNL)
+    end
+
+    @OP.def_rules("*", "**",	
+		  "!", "!=", "!~",
+		  "=", "==", "===", 
+		  "=~", "<=>",	
+		  "<", "<=",
+		  ">", ">=", ">>") do
+      |op, io|
+      @lex_state = EXPR_BEG
+      Token(op)
+    end
+
+    @OP.def_rules("<<") do
+      |op, io|
+      if @lex_state != EXPR_END && @lex_state != EXPR_CLASS &&
+	  (@lex_state != EXPR_ARG || @space_seen)
+	c = peek(0)
+	if /\S/ =~ c && (/["'`]/ =~ c || /[\w_]/ =~ c)
+	  tk = identify_here_document;
+	end
+      else
+	tk = 	Token(op)
+      end
+      tk
+    end
+
+    @OP.def_rules("'", '"') do
+      |op, io|
+      identify_string(op)
+    end
+
+    @OP.def_rules("`") do
+      |op, io|
+      if @lex_state == EXPR_FNAME
+	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{@lex_state == EXPR_FNAME}) do
+      Token(TkUPLUS)
+    end
+
+    @OP.def_rule("-@", proc{@lex_state == EXPR_FNAME}) do
+      Token(TkUMINUS)
+    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
+      @lex_state = EXPR_BEG
+      if peek(0) =~ /[0-9]/
+	ungetc
+	identify_number
+      else
+	# for obj.if
+	@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
+      Token(op)
+    end
+
+    @OP.def_rule(":") do
+      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
+#      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
+      @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_rule("~") do
+      @lex_state = EXPR_BEG
+      Token("~")
+    end
+
+    @OP.def_rule("~@", proc{@lex_state = EXPR_FNAME}) do
+      @lex_state = EXPR_BEG
+      Token("~")
+    end
+    
+    @OP.def_rule("(") do
+      @indent += 1
+      if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
+	@lex_state = EXPR_BEG
+	Token(TkfLPAREN)
+      else
+	@lex_state = EXPR_BEG
+	Token(TkLPAREN)
+      end
+    end
+
+    @OP.def_rule("[]", proc{@lex_state == EXPR_FNAME}) do
+      Token("[]")
+    end
+
+    @OP.def_rule("[]=", proc{@lex_state == EXPR_FNAME}) do
+      Token("[]=")
+    end
+
+    @OP.def_rule("[") do
+      @indent += 1
+      if @lex_state == EXPR_FNAME
+	Token(TkfLBRACK)
+      else
+	if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
+	  t = Token(TkLBRACK)
+	elsif @lex_state == EXPR_ARG && @space_seen
+	  t = Token(TkLBRACK)
+	else
+	  t = Token(TkfLBRACK)
+	end
+	@lex_state = EXPR_BEG
+	t
+      end
+    end
+
+    @OP.def_rule("{") do
+      @indent += 1
+      if @lex_state != EXPR_END && @lex_state != EXPR_ARG
+	t = Token(TkLBRACE)
+      else
+	t = Token(TkfLBRACE)
+      end
+      @lex_state = EXPR_BEG
+      t
+    end
+
+    @OP.def_rule('\\') do
+      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(OP_ASGIN, "%")
+      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
+      identify_gvar
+    end
+
+    @OP.def_rule('@') do
+      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 = ""
+    token.concat getc if peek(0) =~ /[$@]/
+    while (ch = getc) =~ /\w|_/
+      print ":", ch, ":" if RubyLex.debug?
+      token.concat ch
+    end
+    ungetc
+    
+    if ch == "!" or ch == "?"
+      token.concat getc
+    end
+    # fix token
+
+    case token
+    when /^\$/
+      return Token(TkGVAR, 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)
+	      @indent += 1
+	    elsif DEINDENT_CLAUSE.include?(token)
+	      @indent -= 1
+	    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]
+      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.chomp) && l != quoted
+    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 ch = getc
+      if peek(0) == "x"
+	ch = getc
+	match = /[0-9a-f_]/
+      else
+	match = /[0-7_]/
+      end
+      while ch = getc
+	if ch !~ match
+	  ungetc
+	  break
+	end
+      end
+      return Token(TkINTEGER)
+    end
+    
+    type = TkINTEGER
+    allow_point = TRUE
+    allow_e = TRUE
+    while ch = getc
+      case ch
+      when /[0-9_]/
+      when allow_point && "."
+	type = TkFLOAT
+	if peek(0) !~ /[0-9]/
+	  ungetc
+	  break
+	end
+	allow_point = false
+      when allow_e && "e", allow_e && "E"
+	type = TkFLOAT
+	if peek(0) =~ /[+-]/
+	  getc
+	end
+	allow_e = false
+	allow_point = false
+      else
+	ungetc
+	break
+      end
+    end
+    Token(type)
+  end
+  
+  def identify_string(ltype, quoted = ltype)
+    @ltype = ltype
+    @quoted = quoted
+    subtype = nil
+    begin
+      while ch = getc 
+	if @quoted == ch
+	  break
+	elsif @ltype != "'" && @ltype != "]" and ch == "#"
+	  subtype = true
+	elsif ch == '\\' #'
+	  read_escape
+	end
+      end
+      if @ltype == "/"
+	if peek(0) =~ /i|o|n|e|s/
+	  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" #"
+    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(chrs)
+	end
+      end
+
+    when "C", "c", "^"
+      if ch == "C" and (ch = getc) != "-"
+	ungetc
+      elsif (ch = getc) == "\\" #"
+	read_escape(chrs)
+      end
+    else
+      # other characters
+    end
+  end
+end

lib/irb/ruby-token.rb

@@ -0,0 +1,266 @@
+#
+#   ruby-token.rb - ruby tokens 
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+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
+  
+  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] 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],
+    [:TkIVAR,	    TkId],
+    [:TkCONSTANT,   TkId],
+
+    [:TkINTEGER,    TkVal],
+    [:TkFLOAT,      TkVal],
+    [:TkSTRING,     TkVal],
+    [:TkXSTRING,    TkVal],
+    [:TkREGEXP,     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,   "`"],
+
+    [:TkASSGIN,     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 unless token_n.kind_of?(String)
+    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

lib/irb/slex.rb

@@ -0,0 +1,279 @@
+#
+#   irb-slex.rb - symple lex analizer
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "e2mmap"
+
+class SLex
+  @RCS_ID='-$Id$-'
+
+  extend Exception2MessageMapper
+  def_exception :ErrNodeNothing, "node nothing"
+  def_exception :ErrNodeAlreadyExists, "node already exists"
+
+  class << self
+    attr :debug_level, TRUE
+    def debug?
+      debug_level > 0
+    end
+  end
+  @debug_level = 0
+
+  def initialize
+    @head = Node.new("")
+  end
+  
+  def def_rule(token, preproc = nil, postproc = nil)
+    #      print node.inspect, "\n" if SLex.debug?
+    postproc = proc if iterator?
+    node = create(token, preproc, postproc)
+  end
+  
+  def def_rules(*tokens)
+    if iterator?
+      p = proc
+    end
+    for token in tokens
+      def_rule(token, nil, p)
+    end
+  end
+  
+  def preporc(token, proc)
+    node = search(token)
+    node.preproc=proc
+  end
+  
+  def postproc(token)
+    node = search(token, proc)
+    node.postproc=proc
+  end
+  
+  def search(token)
+    @head.search(token.split(//))
+  end
+
+  def create(token, preproc = nil, postproc = nil)
+    @head.create_subnode(token.split(//), preproc, postproc)
+  end
+  
+  def match(token)
+    case token
+    when Array
+    when String
+      token = token.split(//)
+      match(token.split(//))
+    else
+      return @head.match_io(token)
+    end
+    ret = @head.match(token)
+    printf "match end: %s:%s", ret, token.inspect if SLex.debug?
+    ret
+  end
+  
+  def inspect
+    format("<SLex: @head = %s>", @head.inspect)
+  end
+
+  #----------------------------------------------------------------------
+  #
+  #   class Node - 
+  #
+  #----------------------------------------------------------------------
+  class Node
+    # if postproc no exist, this node is abstract node.
+    # if postproc isn't nil, this node is real node.
+    def initialize(preproc = nil, postproc = nil)
+      @Tree = {}
+      @preproc = preproc
+      @postproc = postproc
+    end
+
+    attr :preproc, TRUE
+    attr :postproc, TRUE
+    
+    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
+	  p node
+	  SLex.fail ErrNodeAlreadyExists
+	else
+	  print "Warn: change abstruct node to real node\n" if SLex.debug?
+	  @preproc = preproc
+	  @postproc = postproc
+	end
+	return self
+      end
+      
+      ch = chrs.shift
+      if node = @Tree[ch]
+	if chrs.empty?
+	  if node.postproc
+	    p node
+	    p self
+	    p ch
+	    p chrs
+	    SLex.fail ErrNodeAlreadyExists
+	  else
+	    print "Warn: change abstruct node to real node\n" if SLex.debug?
+	    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 It must have getc()/ungetc(), and ungetc() can be
+    #          called any number of times. 
+    #
+    def match(chrs, op = "")
+      print "match>: ", chrs, "op:", op, "\n" if SLex.debug?
+      if chrs.empty?
+	if @preproc.nil? || @preproc.call(op, chrs)
+	  printf "op1: %s\n", op if SLex.debug?
+	  @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)
+	      printf "op2: %s\n", op.inspect if SLex.debug?
+	      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)
+	    printf "op3: %s\n", op if SLex.debug?
+	    @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)
+	  printf "op1: %s\n", op if SLex.debug?
+	  @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)
+	      printf "op2: %s\n", op.inspect if SLex.debug?
+	      @postproc.call(op, io)
+	    else
+	      nil
+	    end
+	  end
+	else
+	  io.ungetc ch
+	  if @postproc and @preproc.nil? || @preproc.call(op, io)
+	    printf "op3: %s\n", op if SLex.debug?
+	    @postproc.call(op, io)
+	  else
+	    nil
+	  end
+	end
+      end
+    end
+  end
+end
+
+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

lib/irb/version.rb

@@ -0,0 +1,16 @@
+#
+#   version.rb - irb version definition file
+#   	$Release Version: 0.6.1$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+module IRB
+  @RELEASE_VERSION = "0.6.1"
+  @LAST_UPDATE_DATE = "99/09/16"
+end

lib/irb/workspace-binding-2.rb

@@ -0,0 +1,15 @@
+#
+#   bind.rb - 
+#   	$Release Version: $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+while true
+  IRB::BINDING_QUEUE.push b = binding
+end

lib/irb/workspace-binding.rb

@@ -0,0 +1,77 @@
+#
+#   workspace-binding.rb - 
+#   	$Release Version: $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#   
+#
+
+
+module IRB
+  # create new workspace. 
+  def IRB.workspace_binding(*main)
+    if @CONF[:SINGLE_IRB]
+      bind = TOPLEVEL_BINDING
+    else
+      case @CONF[:CONTEXT_MODE]
+      when 0
+	bind = eval("proc{binding}.call",
+		    TOPLEVEL_BINDING, 
+		    "(irb_local_binding)",
+		    1)
+      when 1
+	require "tempfile"
+	f = Tempfile.open("irb-binding")
+	f.print <<EOF
+	$binding = binding
+EOF
+	f.close
+	load f.path
+	bind = $binding
+
+      when 2
+	unless defined? BINDING_QUEUE
+	  require "thread"
+	  
+	  IRB.const_set("BINDING_QUEUE", SizedQueue.new(1))
+	  Thread.abort_on_exception = true
+	  Thread.start do
+	    eval "require \"irb/workspace-binding-2\"", TOPLEVEL_BINDING, __FILE__, __LINE__
+	  end
+	  Thread.pass
+
+	end
+
+	bind = BINDING_QUEUE.pop
+
+      when 3
+	bind = eval("def irb_binding; binding; end; irb_binding",
+		    TOPLEVEL_BINDING, 
+		    __FILE__,
+		    __LINE__ - 3)
+      end
+    end
+    unless main.empty?
+      @CONF[:__MAIN__] = main[0]
+      case main[0]
+      when Module
+	bind = eval("IRB.conf[:__MAIN__].module_eval('binding')", bind)
+      else
+	begin 
+	  bind = eval("IRB.conf[:__MAIN__].instance_eval('binding')", bind)
+	rescue TypeError
+	  IRB.fail CanNotChangeBinding, main[0].inspect
+	end
+      end
+    end
+    eval("_=nil", bind)
+    bind
+  end
+
+  def IRB.delete_caller
+  end
+end

lib/irb/xmp.rb

@@ -0,0 +1,84 @@
+#
+#   xmp.rb - irb version of gotoken xmp
+#   	$Release Version: 0.6$
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+#
+#   
+#
+
+require "irb/irb"
+require "irb/frame"
+
+class XMP
+  @RCS_ID='-$Id$-'
+
+  def initialize(bind = nil)
+    #IRB.parse_opts
+    #IRB.load_modules
+
+    bind = IRB::Frame.top(1) unless bind
+    main = eval("self", bind)
+    @io = StringInputMethod.new
+    @irb = IRB::Irb.new(main, bind, @io)
+    @irb.context.prompt_mode = :XMP
+    @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

lib/matrix.rb

@@ -420,7 +420,6 @@ class Matrix
 	  vij = 0
 	  0.upto(column_size - 1) do
 	    |k|
-	    p [k,j,m[k,j]]
 	    vij += self[i, k] * m[k, j]
 	  end
 	  vij

lib/thread.rb

@@ -157,9 +157,11 @@ class Queue
       t.wakeup if t
     rescue ThreadError
       retry
-    end
+    ensure
       Thread.critical = false
     end
+    t.run if t
+  end
   alias enq push
 
   def pop non_block=false
@@ -250,10 +252,13 @@ class SizedQueue<Queue
     if @que.length < @max
       begin
 	t = @queue_wait.shift
-	t.run if t
+	t.wakeup if t
       rescue ThreadError
 	retry
+      ensure
+	Thread.critical = false
       end
+      t.run if t
     end
     super
   end

marshal.c

@@ -208,8 +208,6 @@ w_ivar(tbl, arg)
     st_table *tbl;
     struct dump_call_arg *arg;
 {
-    struct dump_call_arg c_arg;
-
     if (tbl) {
 	w_long(tbl->num_entries, arg->arg);
 	st_foreach(tbl, obj_each, arg);

pack.c

@@ -843,6 +843,53 @@ pack_pack(ary, fmt)
 	    }
 	    break;
 
+	  case 'w':
+	    while (len-- > 0) {
+		unsigned long ul;
+		VALUE buf = rb_str_new(0, 0);
+		char c, *bufs, *bufe;
+
+		from = NEXTFROM;
+
+		if (TYPE(from) == T_BIGNUM) {
+		    VALUE big128 = rb_uint2big(128);
+		    while (TYPE(from) == T_BIGNUM) {
+			from = rb_big_divmod(from, big128);
+			c = NUM2INT(RARRAY(from)->ptr[1]) | 0x80; /* mod */
+			rb_str_cat(buf, &c, sizeof(char));
+			from = RARRAY(from)->ptr[0]; /* div */
+		    }
+		}
+
+		if (NIL_P(from)) ul = 0;
+		else {
+		    ul = NUM2ULONG(from);
+		}
+
+		while (ul) {
+		    c = ((ul & 0x7f) | 0x80);
+		    rb_str_cat(buf, &c, sizeof(char));
+		    ul >>=  7;
+		}
+
+		if (RSTRING(buf)->len) {
+		    bufs = RSTRING(buf)->ptr;
+		    bufe = bufs + RSTRING(buf)->len - 1;
+		    *bufs &= 0x7f; /* clear continue bit */
+		    while (bufs < bufe) { /* reverse */
+			c = *bufs;
+			*bufs++ = *bufe;
+			*bufe-- = c;
+		    }
+		    rb_str_cat(res, RSTRING(buf)->ptr, RSTRING(buf)->len);
+		}
+		else {
+		    c = 0;
+		    rb_str_cat(res, &c, sizeof(char));
+		}
+	    }
+	    break;
+
 	  default:
 	    break;
 	}
@@ -1573,6 +1620,37 @@ pack_unpack(str, fmt)
 	    }
 	    break;
 
+	  case 'w':
+	    {
+		unsigned long ul = 0;
+		unsigned long ulmask = 0xfe << ((sizeof(unsigned long) - 1) * 8);
+
+		while (len > 0 && s < send) {
+		    ul <<= 7;
+		    ul |= (*s & 0x7f);
+		    if (!(*s++ & 0x80)) {
+			rb_ary_push(ary, rb_uint2inum(ul));
+			len--;
+			ul = 0;
+		    }
+		    else if (ul & ulmask) {
+			VALUE big = rb_uint2big(ul);
+			VALUE big128 = rb_uint2big(128);
+			while (s < send) {
+			    big = rb_big_mul(big, big128);
+			    big = rb_big_plus(big, rb_uint2big(*s & 0x7f));
+			    if (!(*s++ & 0x80)) {
+				rb_ary_push(ary, big);
+				len--;
+				ul = 0;
+				break;
+			    }
+			}
+		    }
+		}
+	    }
+	    break;
+
 	  default:
 	    break;
 	}

parse.y

@@ -2124,6 +2124,84 @@ read_escape()
     }
 }
 
+static int
+tokadd_escape()
+{
+    int c;
+
+    switch (c = nextc()) {
+      case '\n':
+	return 0;		/* just ignore */
+
+      case '0': case '1': case '2': case '3': /* octal constant */
+      case '4': case '5': case '6': case '7':
+	{
+	    int i;
+
+	    tokadd('\\');
+	    tokadd(c);
+	    for (i=0; i<2; i++) {
+		c = nextc();
+		if (c == -1) goto eof;
+		if (c < '0' || '7' < c) {
+		    pushback(c);
+		    break;
+		}
+		tokadd(c);
+	    }
+	}
+	return 0;
+
+      case 'x':	/* hex constant */
+	{
+	    int numlen;
+
+	    scan_hex(lex_p, 2, &numlen);
+	    while (numlen--)
+		tokadd(nextc());
+	}
+	return 0;
+
+      case 'M':
+	if ((c = nextc()) != '-') {
+	    yyerror("Invalid escape character syntax");
+	    pushback(c);
+	    return 0;
+	}
+	tokadd('\\'); tokadd('M'); tokadd('-');
+	goto escaped;
+
+      case 'C':
+	if ((c = nextc()) != '-') {
+	    yyerror("Invalid escape character syntax");
+	    pushback(c);
+	    return 0;
+	}
+	tokadd('\\'); tokadd('C'); tokadd('-');
+	goto escaped;
+
+      case 'c':
+	tokadd('\\'); tokadd('c');
+      escaped:
+	if ((c = nextc()) == '\\') {
+	    return tokadd_escape();
+	}
+	else if (c == -1) goto eof;
+	tokadd(c);
+	return 0;
+
+      eof:
+      case -1:
+        yyerror("Invalid escape character syntax");
+	return -1;
+
+      default:
+	tokadd('\\');
+	tokadd(c);
+    }
+    return 0;
+}
+
 static int
 parse_regx(term, paren)
     int term, paren;
@@ -2133,78 +2211,31 @@ parse_regx(term, paren)
     int once = 0;
     int nest = 0;
     int options = 0;
-    int in_brack = 0;
     int re_start = ruby_sourceline;
     NODE *list = 0;
 
     newtok();
     while ((c = nextc()) != -1) {
-	if (!in_brack && c == term && nest == 0) {
+	if (c == term && nest == 0) {
 	    goto regx_end;
 	}
 
 	switch (c) {
-	  case '[':
-	    in_brack = 1;
-	    break;
-	  case ']':
-	    in_brack = 0;
-	    break;
-
 	  case '#':
 	    list = str_extend(list, term);
 	    if (list == (NODE*)-1) return 0;
 	    continue;
 
 	  case '\\':
-	    switch (c = nextc()) {
+	    if (tokadd_escape() < 0)
-	      case -1:
-		ruby_sourceline = re_start;
-		rb_compile_error("unterminated regexp meets end of file");
 		return 0;
-
-	      case '\n':
-		break;
-
-	      case '\\':
-	      case '^':
-	      case 's':
-		tokadd('\\');
-		tokadd(c);
-		break;
-
-	      case '1': case '2': case '3':
-	      case '4': case '5': case '6':
-	      case '7': case '8': case '9':
-	      case '0': case 'x':
-		tokadd('\\');
-		tokadd(c);
-		break;
-
-	      case 'b':
-		if (!in_brack) {
-		    tokadd('\\');
-		    tokadd('b');
-		    break;
-		}
-		/* fall through */
-	      default:
-		if (c == term) {
-		    tokadd(c);
-		}
-		else {
-		    tokadd('\\');
-		    tokadd(c);
-		}
-	    }
 	    continue;
 
 	  case -1:
-	    rb_compile_error("unterminated regexp");
+	    goto unterminated;
-	    return 0;
 
 	  default:
-	    if (paren && !in_brack)  {
+	    if (paren)  {
 	      if (c == paren) nest++;
 	      if (c == term) nest--;
 	    }
@@ -2272,7 +2303,9 @@ parse_regx(term, paren)
 	}
 	tokadd(c);
     }
-    rb_compile_error("unterminated regexp");
+  unterminated:
+    ruby_sourceline = re_start;
+    rb_compile_error("unterminated regexp meets end of file");
     return 0;
 }
 

regex.c

@@ -22,13 +22,11 @@
 /* UTF-8 extension added Jan 16 1999 by Yoshida Masato  <yoshidam@tau.bekkoame.ne.jp> */
 
 #include "config.h"
-#ifdef RUBY_PLATFORM
+
-# define RUBY
+#ifdef HAVE_STRING_H
-extern int rb_prohibit_interrupt;
+# include <string.h>
-extern int rb_trap_pending;
+#else
-# define CHECK_INTS if (!rb_prohibit_interrupt) {\
+# include <strings.h>
-    if (rb_trap_pending) rb_trap_exec();\
-}
 #endif
 
 /* We write fatal error messages on standard error.  */
@@ -63,6 +61,17 @@ extern int rb_trap_pending;
 # define _(args) ()
 #endif
 
+#ifdef RUBY_PLATFORM
+# define RUBY
+extern int rb_prohibit_interrupt;
+extern int rb_trap_pending;
+void rb_trap_exec _((void));
+
+# define CHECK_INTS if (!rb_prohibit_interrupt) {\
+    if (rb_trap_pending) rb_trap_exec();\
+}
+#endif
+
 #ifndef xmalloc
 void *xmalloc _((size_t));
 void *xcalloc _((size_t,size_t));
@@ -70,7 +79,7 @@ void *xrealloc _((void*,size_t));
 void free _((void*));
 #endif
 
-#define	NO_ALLOCA /*	/* try it out for now */
+#define	NO_ALLOCA	/* try it out for now */
 #ifndef NO_ALLOCA
 /* Make alloca work the best possible way.  */
 #ifdef __GNUC__
@@ -474,7 +483,7 @@ utf8_firstbyte(c)
 
 static void
 print_mbc(c)
-     unsigned long c;
+     unsigned int c;
 {
   if (current_mbctype == MBCTYPE_UTF8) {
     if (c < 0x80)
@@ -587,13 +596,13 @@ print_mbc(c)
   } while (0)
 
 #define EXTRACT_MBC(p) 							\
-  ((unsigned long)((unsigned char)(p)[0] << 24 |			\
+  ((unsigned int)((unsigned char)(p)[0] << 24 |				\
 		    (unsigned char)(p)[1] << 16 |			\
                     (unsigned char)(p)[2] <<  8 |			\
 		    (unsigned char)(p)[3]))
 
 #define EXTRACT_MBC_AND_INCR(p) 					\
-  ((unsigned long)((p) += 4, 						\
+  ((unsigned int)((p) += 4, 						\
 		    (unsigned char)(p)[-4] << 24 |			\
 		    (unsigned char)(p)[-3] << 16 |			\
                     (unsigned char)(p)[-2] <<  8 |			\
@@ -1398,12 +1407,6 @@ re_compile_pattern(pattern, size, bufp)
       had_num_literal = 0;
       had_char_class = 0;
 
-      /* charset_not matches newline according to a syntax bit.  */
-      if ((enum regexpcode)b[-2] == charset_not) {
-	if (bufp->options & RE_OPTION_POSIXLINE)
-	  SET_LIST_BIT ('\n');
-      }
-
       /* Read in characters and ranges, setting map bits.  */
       for (;;) {
 	int size;
@@ -2325,6 +2328,8 @@ re_compile_pattern(pattern, size, bufp)
 	case dummy_failure_jump:
 	  bufp->options |= RE_OPTIMIZE_ANCHOR;
 	  break;
+	default:
+	  break;
 	}
       }
       else if (*laststart == charset || *laststart == charset_not) {
@@ -3004,6 +3009,7 @@ re_compile_fastmap(bufp)
 	}
 	break;
 
+      case begpos:
       case unused:	/* pacify gcc -Wall */
 	break;
       }
@@ -4247,7 +4253,6 @@ re_match(bufp, string_arg, size, pos, regs)
 	p1 = p;
 	/* If failed to a backwards jump that's part of a repetition
 	   loop, need to pop this failure point and use the next one.  */
-      pop_loop:
 	switch ((enum regexpcode)*p1) {
 	case jump_n:
 	case finalize_push_n:

ruby.c

@@ -291,7 +291,7 @@ static char*
 moreswitches(s)
     char *s;
 {
-    int argc; char *argv[3]; char **argvp = argv;
+    int argc; char *argv[3];
     char *p = s;
 
     argc = 2; argv[0] = argv[2] = 0;
@@ -636,6 +636,12 @@ proc_options(argc, argv)
 	load_file(script, 1);
     }
 
+    if (rb_safe_level() == 0) {
+	rb_ary_push(rb_load_path, rb_str_new2("."));
+	addpath(getenv("RUBYLIB"));
+    }
+
+
     process_sflag();
     xflag = 0;
 }
@@ -917,10 +923,6 @@ ruby_prog_init()
     rb_define_readonly_variable("$-p", &do_print);
     rb_define_readonly_variable("$-l", &do_line);
 
-    if (rb_safe_level() == 0) {
-	addpath(".");
-    }
-
     addpath(RUBY_LIB);
 #if defined(_WIN32) || defined(DJGPP)
     addpath(ruby_libpath());
@@ -942,10 +944,6 @@ ruby_prog_init()
     addpath(RUBY_SEARCH_PATH);
 #endif
 
-    if (rb_safe_level() == 0) {
-	addpath(getenv("RUBYLIB"));
-    }
-
     rb_define_hooked_variable("$0", &rb_progname, 0, set_arg0);
 
     rb_argv = rb_ary_new();

ruby.h

@@ -358,13 +358,13 @@ struct RBignum {
 
 #define FL_ABLE(x) (!SPECIAL_CONST_P(x))
 #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
-#define FL_SET(x,f) (FL_ABLE(x) && (RBASIC(x)->flags |= (f)))
+#define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
-#define FL_UNSET(x,f) (FL_ABLE(x) && (RBASIC(x)->flags &= ~(f)))
+#define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
-#define FL_REVERSE(x,f) (FL_ABLE(x) && (RBASIC(x)->flags ^= (f)))
+#define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
 
 #define OBJ_TAINTED(x) FL_TEST((x), FL_TAINT)
 #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
-#define OBJ_INFECT(x,s) (FL_ABLE(x) && FL_ABLE(s) && (RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT))
+#define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT;} while (0)
 
 #define OBJ_FROZEN(x) FL_TEST((x), FL_FREEZE)
 #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
@@ -394,8 +394,8 @@ void rb_define_variable _((const char*,VALUE*));
 void rb_define_virtual_variable _((const char*,VALUE(*)(),void(*)()));
 void rb_define_hooked_variable _((const char*,VALUE*,VALUE(*)(),void(*)()));
 void rb_define_readonly_variable _((const char*,VALUE*));
-void rb_define_constants _((VALUE,const char*,VALUE));
+void rb_define_const _((VALUE,const char*,VALUE));
-void rb_define_global_constants _((const char*,VALUE));
+void rb_define_global_const _((const char*,VALUE));
 
 void rb_define_method _((VALUE,const char*,VALUE(*)(),int));
 void rb_define_module_function _((VALUE,const char*,VALUE(*)(),int));

sample/irb.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+#   irb.rb - intaractive ruby
+#   	$Release Version: 0.6 $
+#   	$Revision$
+#   	$Date$
+#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
+#
+# --
+# Usage:
+#
+#   irb.rb [options] file_name opts
+#
+#
+
+require "irb/main"
+
+if __FILE__ == $0
+  IRB.start(__FILE__)
+else
+  # check -e option
+  tmp = ENV["TMP"] || ENV["TMPDIR"] || "/tmp"
+  if %r|#{tmp}/rb| =~ $0
+    IRB.start(__FILE__)
+  else
+    IRB.initialize(__FILE__)
+  end
+end

sample/rbc.rb

@@ -413,7 +413,7 @@ module BC_APPLICATION__
       
       ch = chrs.shift
       case ch
-      when /[_~*$?!@/\\;,.=:<>"]/   #"
+      when /[_~*$?!@\/\\;,.=:<>"]/   #"
 	return
 	
       when "-"

string.c

@@ -766,7 +766,7 @@ static VALUE
 rb_str_succ(orig)
     VALUE orig;
 {
-    VALUE str, str2;
+    VALUE str;
     char *sbeg, *s;
     int c = -1;
     int n = 0;
@@ -1039,7 +1039,7 @@ rb_str_slice_bang(argc, argv, str)
     VALUE str;
 {
     VALUE arg1, arg2;
-    long pos, len, i;
+    long pos, len;
 
     rb_str_modify(str);
     if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {

time.c

@@ -79,12 +79,6 @@ time_s_new(argc, argv, klass)
     return obj;
 }
 
-static VALUE
-time_initialize()
-{
-    return Qnil;
-}
-
 static VALUE
 time_new_internal(klass, sec, usec)
     VALUE klass;

util.c

@@ -593,28 +593,6 @@ static void mmswap(a, b) register char *a, *b;
  }
 }
 
-static void mmswapblock(a, b, size) register char *a, *b; int size;
-{
- register int s;
- if (mmkind >= 0) {
-   register char *t = a + (size & (-16)); register int  lo = (size & 0x0C);
-   if (size >= 16) {
-     do {
-       s = A[0]; A[0] = B[0]; B[0] = s;
-       s = A[1]; A[1] = B[1]; B[1] = s;
-       s = A[2]; A[2] = B[2]; B[2] = s;
-       s = A[3]; A[3] = B[3]; B[3] = s;  a += 16; b += 16;
-     }while (a < t);
-   }
-   if (lo != 0) { s = A[0]; A[0] = B[0]; B[0] = s;
-     if (lo >= 8) { s = A[1]; A[1] = B[1]; B[1] = s;
-       if (lo == 12) {s = A[2]; A[2] = B[2]; B[2] = s;}}}
- }else{
-   register char *t = a + size;
-   do {s = *a; *a++ = *b; *b++ = s;} while (a < t);
- }
-}
-
 static void mmrot3(a, b, c) register char *a, *b, *c;
 {
  register int s;

variable.c

@@ -724,7 +724,6 @@ rb_generic_ivar_table(obj)
     VALUE obj;
 {
     st_table *tbl;
-    VALUE val;
 
     if (!generic_iv_tbl) return 0;
     if (!st_lookup(generic_iv_tbl, obj, &tbl)) return 0;
@@ -1336,7 +1335,6 @@ rb_cvar_set(klass, id, val)
     ID id;
     VALUE val;
 {
-    VALUE value;
     VALUE tmp;
 
     if (FL_TEST(klass, FL_SINGLETON)) {
@@ -1382,7 +1380,6 @@ rb_cvar_defined(klass, id)
     VALUE klass;
     ID id;
 {
-    VALUE value;
     VALUE tmp;
 
     if (FL_TEST(klass, FL_SINGLETON)) {

version.h

@@ -1,4 +1,4 @@
-#define RUBY_VERSION "1.5.3"
+#define RUBY_VERSION "1.5.4"
-#define RUBY_RELEASE_DATE "2000-05-10"
+#define RUBY_RELEASE_DATE "2000-05-12"
-#define RUBY_VERSION_CODE 153
+#define RUBY_VERSION_CODE 154
-#define RUBY_RELEASE_CODE 20000510
+#define RUBY_RELEASE_CODE 20000512