* io.c (rb_io_ctl): do not call ioctl/fcntl for f2, if f and f2

have same fileno.

* eval.c (rb_load): raise LocaJumpError if unexpected local jumps
  appear during load.

* ext/socket/socket.c (bsock_close_read): don't call rb_thread_fd_close();
  it's supposed to be called by io_io_close().

* ext/socket/socket.c (bsock_close_read): do not modify f and f2.

* ext/socket/socket.c (bsock_close_write): ditto.

* ext/socket/socket.c (sock_new): avoid dup(2) on sockets.

* parse.y (primary): preserve and clear in_single and in_def using
  stack to prevent nested method errors in singleton class bodies.


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

ChangeLog

@@ -7,7 +7,40 @@ Sun Feb 11 16:00:30 2001  WATANABE Hirofumi  <eban@ruby-lang.org>
 
 	* configure.in: add ac_cv_func_getpgrp_void=yes on DJGPP.
 
-Fri Feb 10 00:00:30 2001  Nobuyoshi Nakada  <nobu.nakada@nifty.ne.jp>
+Tue Feb 13 08:43:10 2001  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* io.c (rb_io_ctl): do not call ioctl/fcntl for f2, if f and f2
+	  have same fileno.
+
+Tue Feb 13 01:13:43 2001  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* eval.c (rb_load): raise LocaJumpError if unexpected local jumps
+	  appear during load.
+
+	* ext/socket/socket.c (bsock_close_read): don't call rb_thread_fd_close();
+	  it's supposed to be called by io_io_close().
+
+	* ext/socket/socket.c (bsock_close_read): do not modify f and f2.
+
+	* ext/socket/socket.c (bsock_close_write): ditto.
+
+	* ext/socket/socket.c (sock_new): avoid dup(2) on sockets.
+
+	* parse.y (primary): preserve and clear in_single and in_def using
+	  stack to prevent nested method errors in singleton class bodies.
+
+Sat Feb 10 23:43:49 2001  Nobuyoshi Nakada  <nobu.nakada@nifty.ne.jp>
+
+	* hash.c (rb_any_hash): dumped core on machines sizeof(int) != sizeof(long).
+
+Sat Feb 10 23:07:15 2001  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* io.c (rb_io_s_for_fd): IO::for_fd(fd) - new method.
+
+	* regex.c (PREV_IS_A_LETTER): should not treat c>0x7f as a word
+	  character if -Kn.
+
+Sat Feb 10 00:00:30 2001  Nobuyoshi Nakada  <nobu.nakada@nifty.ne.jp>
 
 	* win32/win32.c (win32_stat): replace stat for enable when pathname
 	  ends with '/' or '\' for mswin32 on Win9X / Win2k.
@@ -25,6 +58,10 @@ Fri Feb  9 22:54:57 2001  WATANABE Hirofumi  <eban@ruby-lang.org>
 	* ruby.c (ruby_init_loadpath): convert '\\' to '/'
 	  before finding executable file path.
 
+Fri Feb  9 17:41:53 2001  Triet H. Lai  <thlai@mail.usyd.edu.au>
+
+	* dir.c (rb_glob_helper): do not follow symbolic links.
+
 Thu Feb  8 21:27:24 2001  WATANABE Hirofumi  <eban@ruby-lang.org>
 
 	* lib/mkmf.rb (install_rb): fix handling of relative path.

ToDo

@@ -1,6 +1,5 @@
 Language Spec.
 
-- %q!\!! => "!" (not "\\!")
 * operator !! for rescue. ???
 * objectify characters
 * ../... outside condition invokes operator method too.
@@ -45,13 +44,13 @@ Hacking Interpreter
 * warn for inconsistent local variable usage (lv m and method m at the same time). 
 * MicroRuby
 * Built-in Interactive Ruby.
-* regex /\ba/ on "[a in HIRAGANA]a[a in HIRAGANA]"
 
 Standard Libraries
 
 - Module#define_method which takes a name and a body (block, proc or method).
 - Enume#inject
 - Array#fetch
+- IO::for_fd
 * Enumerable#sort_by for Schwartzian transformation
 * String#scanf(?)
 * Object#fmt(?)
@@ -67,7 +66,6 @@ Standard Libraries
 * Process::waitall [ruby-talk:4557]
 * synchronized method - synchronized{...}, synchronized :foo, :bar
 * move Time::times to Process.
-* IO#for_fd in general
 * Array#&, Array#| to allow duplication. ???
 * fork_and_kill_other_threads.
 * way to specify immortal (fork endurance) thread;

dir.c

@@ -601,11 +601,22 @@ rb_glob_helper(path, flag, func, arg)
 		rb_glob_helper(buf, flag, func, arg);
 		free(buf);
 	    }
-	    dirp = opendir(dir);
+	    if (lstat(dir, &st) < 0) {
-	    if (dirp == NULL) {
+	        free(base);
-		free(base);
+	        break;
-		break;
 	    }
+	    if (S_ISDIR(st.st_mode)) {
+	       dirp = opendir(dir);
+	       if (dirp == NULL) {
+		   free(base);
+		   break;
+	       }
+	    }
+	    else {
+	      free(base);
+	      break;
+	    }
+	    
 #define BASE (*base && !(*base == '/' && !base[1]))
 
 	    for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
@@ -636,7 +647,7 @@ rb_glob_helper(path, flag, func, arg)
 	    free(base);
 	    free(magic);
 	    while (link) {
-		stat(link->path, &st); /* should success */
+		lstat(link->path, &st); /* should success */
 		if (S_ISDIR(st.st_mode)) {
 		    int len = strlen(link->path);
 		    int mlen = strlen(m);

eval.c

@@ -1298,6 +1298,34 @@ rb_eval_string_wrap(str, state)
     return val;
 }
 
+static void
+jump_tag_but_local_jump(state)
+    int state;
+{
+    switch (state) {
+      case 0:
+	break;
+      case TAG_RETURN:
+	rb_raise(rb_eLocalJumpError, "unexpected return");
+	break;
+      case TAG_NEXT:
+	rb_raise(rb_eLocalJumpError, "unexpected next");
+	break;
+      case TAG_BREAK:
+	rb_raise(rb_eLocalJumpError, "unexpected break");
+	break;
+      case TAG_REDO:
+	rb_raise(rb_eLocalJumpError, "unexpected redo");
+	break;
+      case TAG_RETRY:
+	rb_raise(rb_eLocalJumpError, "retry outside of rescue clause");
+	break;
+      default:
+	JUMP_TAG(state);
+	break;
+    }
+}
+
 VALUE
 rb_eval_cmd(cmd, arg)
     VALUE cmd, arg;
@@ -1333,28 +1361,7 @@ rb_eval_cmd(cmd, arg)
     POP_TAG();
     POP_CLASS();
 
-    switch (state) {
+    jump_tag_but_local_jump(state);
-      case 0:
-	break;
-      case TAG_RETURN:
-	rb_raise(rb_eLocalJumpError, "unexpected return");
-	break;
-      case TAG_NEXT:
-	rb_raise(rb_eLocalJumpError, "unexpected next");
-	break;
-      case TAG_BREAK:
-	rb_raise(rb_eLocalJumpError, "unexpected break");
-	break;
-      case TAG_REDO:
-	rb_raise(rb_eLocalJumpError, "unexpected redo");
-	break;
-      case TAG_RETRY:
-	rb_raise(rb_eLocalJumpError, "retry outside of rescue clause");
-	break;
-      default:
-	JUMP_TAG(state);
-	break;
-    }
     return val;
 }
 
@@ -3644,10 +3651,8 @@ rb_yield_0(val, self, klass, acheck)
 	if (!block->tag) {
 	    switch (state & TAG_MASK) {
 	      case TAG_BREAK:
-		rb_raise(rb_eLocalJumpError, "unexpected break");
-		break;
 	      case TAG_RETURN:
-		rb_raise(rb_eLocalJumpError, "unexpected return");
+		jump_tag_but_local_jump(state & TAG_MASK);
 		break;
 	    }
 	}
@@ -4454,21 +4459,14 @@ rb_call0(klass, recv, id, argc, argv, body, nosuper)
 	      case 0:
 		break;
 
-	      case TAG_NEXT:
-		rb_raise(rb_eLocalJumpError, "unexpected next");
-		break;
-	      case TAG_BREAK:
-		rb_raise(rb_eLocalJumpError, "unexpected break");
-		break;
-	      case TAG_REDO:
-		rb_raise(rb_eLocalJumpError, "unexpected redo");
-		break;
 	      case TAG_RETRY:
-		if (!rb_block_given_p()) {
+		if (rb_block_given_p()) {
-		    rb_raise(rb_eLocalJumpError, "retry outside of rescue clause");
+		    break;
 		}
+		/* fall through */
 	      default:
-		JUMP_TAG(state);
+		jump_tag_but_local_jump(state);
+		break;
 	    }
 	}
     }
@@ -5189,7 +5187,7 @@ rb_load(fname, wrap)
 	rb_exc_raise(ruby_errinfo);
     }
     TMP_PROTECT_END;
-    if (state) JUMP_TAG(state);
+    if (state) jump_tag_but_local_jump(state);
     if (!NIL_P(ruby_errinfo))	/* exception during load */
 	rb_exc_raise(ruby_errinfo);
 }

ext/dbm/dbm.c

@@ -22,7 +22,7 @@
 #include <fcntl.h>
 #include <errno.h>
 
-VALUE cDBM;
+VALUE cDBM, rb_eDBMError;
 
 struct dbmdata {
     int  di_size;
@@ -37,6 +37,7 @@ closed_dbm()
 
 #define GetDBM(obj, dbmp) {\
     Data_Get_Struct(obj, struct dbmdata, dbmp);\
+    if (dbmp == 0) closed_dbm();\
     if (dbmp->di_dbm == 0) closed_dbm();\
 }
 
@@ -44,21 +45,35 @@ static void
 free_dbm(dbmp)
     struct dbmdata *dbmp;
 {
-    if (dbmp->di_dbm) dbm_close(dbmp->di_dbm);
+    if (dbmp) {
-    free(dbmp);
+	if (dbmp->di_dbm) dbm_close(dbmp->di_dbm);
+	free(dbmp);
+    }
 }
 
+static VALUE fdbm_close _((VALUE));
+
 static VALUE
-fdbm_s_open(argc, argv, klass)
+fdbm_s_new(argc, argv, klass)
     int argc;
     VALUE *argv;
     VALUE klass;
+{
+    VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
+    rb_obj_call_init(obj, argc, argv);
+    return obj;
+}
+
+static VALUE
+fdbm_initialize(argc, argv, obj)
+    int argc;
+    VALUE *argv;
+    VALUE obj;
 {
     VALUE file, vmode;
     DBM *dbm;
     struct dbmdata *dbmp;
     int mode;
-    VALUE obj;
 
     if (rb_scan_args(argc, argv, "11", &file, &vmode) == 1) {
 	mode = 0666;		/* default value */
@@ -87,13 +102,33 @@ fdbm_s_open(argc, argv, klass)
 	rb_sys_fail(RSTRING(file)->ptr);
     }
 
-    obj = Data_Make_Struct(klass,struct dbmdata,0,free_dbm,dbmp);
+    dbmp = ALLOC(struct dbmdata);
+    DATA_PTR(obj) = dbmp;
     dbmp->di_dbm = dbm;
     dbmp->di_size = -1;
 
     return obj;
 }
 
+static VALUE
+fdbm_s_open(argc, argv, klass)
+    int argc;
+    VALUE *argv;
+    VALUE klass;
+{
+    VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
+
+    if (NIL_P(fdbm_initialize(argc, argv, obj))) {
+	return Qnil;
+    }
+
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, obj, fdbm_close, obj);
+    }
+
+    return obj;
+}
+
 static VALUE
 fdbm_close(obj)
     VALUE obj;
@@ -143,10 +178,14 @@ fdbm_fetch_m(argc, argv, obj)
     VALUE *argv;
     VALUE obj;
 {
-    VALUE keystr, ifnone;
+    VALUE keystr, valstr, ifnone;
 
     rb_scan_args(argc, argv, "11", &keystr, &ifnone);
-    return fdbm_fetch(obj, keystr, ifnone);
+    valstr = fdbm_fetch(obj, keystr, ifnone);
+    if (argc == 1 && !rb_block_given_p() && NIL_P(valstr))
+	rb_raise(rb_eIndexError, "key not found");
+
+    return valstr;
 }
 
 static VALUE
@@ -166,8 +205,9 @@ fdbm_index(obj, valstr)
     for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
 	val = dbm_fetch(dbm, key);
 	if (val.dsize == RSTRING(valstr)->len &&
-	    memcmp(val.dptr, RSTRING(valstr)->ptr, val.dsize) == 0)
+	    memcmp(val.dptr, RSTRING(valstr)->ptr, val.dsize) == 0) {
 	    return rb_tainted_str_new(key.dptr, key.dsize);
+	}
     }
     return Qnil;
 }
@@ -213,7 +253,7 @@ fdbm_delete(obj, keystr)
 
     if (dbm_delete(dbm, key)) {
 	dbmp->di_size = -1;
-	rb_raise(rb_eRuntimeError, "dbm_delete failed");
+	rb_raise(rb_eDBMError, "dbm_delete failed");
     }
     else if (dbmp->di_size >= 0) {
 	dbmp->di_size--;
@@ -262,7 +302,7 @@ fdbm_delete_if(obj)
 	valstr = rb_tainted_str_new(val.dptr, val.dsize);
 	if (RTEST(rb_yield(rb_assoc_new(keystr, valstr)))) {
 	    if (dbm_delete(dbm, key)) {
-		rb_raise(rb_eRuntimeError, "dbm_delete failed");
+		rb_raise(rb_eDBMError, "dbm_delete failed");
 	    }
 	}
     }
@@ -283,7 +323,7 @@ fdbm_clear(obj)
     dbmp->di_size = -1;
     for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
 	if (dbm_delete(dbm, key)) {
-	    rb_raise(rb_eRuntimeError, "dbm_delete failed");
+	    rb_raise(rb_eDBMError, "dbm_delete failed");
 	}
     }
     return obj;
@@ -374,7 +414,7 @@ fdbm_store(obj, keystr, valstr)
 	dbm_clearerr(dbm);
 #endif
 	if (errno == EPERM) rb_sys_fail(0);
-	rb_raise(rb_eRuntimeError, "dbm_store failed");
+	rb_raise(rb_eDBMError, "dbm_store failed");
     }
 
     return valstr;
@@ -618,10 +658,13 @@ void
 Init_dbm()
 {
     cDBM = rb_define_class("DBM", rb_cObject);
+    rb_eDBMError = rb_define_class("DBMError", rb_eStandardError);
     rb_include_module(cDBM, rb_mEnumerable);
 
+    rb_define_singleton_method(cDBM, "new", fdbm_s_new, -1);
     rb_define_singleton_method(cDBM, "open", fdbm_s_open, -1);
-    rb_define_singleton_method(cDBM, "new", fdbm_s_open, -1);
+
+    rb_define_method(cDBM, "initialize", fdbm_initialize, -1);
     rb_define_method(cDBM, "close", fdbm_close, 0);
     rb_define_method(cDBM, "[]", fdbm_aref, 1);
     rb_define_method(cDBM, "fetch", fdbm_fetch_m, -1);

ext/gdbm/gdbm.c

@@ -14,7 +14,7 @@
 #include <fcntl.h>
 #include <errno.h>
 
-VALUE cGDBM;
+VALUE cGDBM, rb_eGDBMError;
 
 #define MY_BLOCK_SIZE (2048)
 #define MY_FATAL_FUNC (0)
@@ -32,6 +32,7 @@ closed_dbm()
 
 #define GetDBM(obj, dbmp) {\
     Data_Get_Struct(obj, struct dbmdata, dbmp);\
+    if (dbmp == 0) closed_dbm();\
     if (dbmp->di_dbm == 0) closed_dbm();\
 }
 
@@ -39,23 +40,37 @@ static void
 free_dbm(dbmp)
     struct dbmdata *dbmp;
 {
-    if (dbmp->di_dbm) gdbm_close(dbmp->di_dbm);
+    if (dbmp) {
-    free(dbmp);
+	if (dbmp->di_dbm) gdbm_close(dbmp->di_dbm);
+	free(dbmp);
+    }
 }
 
+static VALUE fgdbm_close _((VALUE));
+
 static VALUE
-fgdbm_s_open(argc, argv, klass)
+fgdbm_s_new(argc, argv, klass)
     int argc;
     VALUE *argv;
     VALUE klass;
 {
-    VALUE file, vmode;
+    VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
+    rb_obj_call_init(obj, argc, argv);
+    return obj;
+}
+
+static VALUE
+fgdbm_initialize(argc, argv, obj)
+    int argc;
+    VALUE *argv;
+    VALUE obj;
+{
+    VALUE file, vmode, vflags;
     GDBM_FILE dbm;
     struct dbmdata *dbmp;
-    int mode;
+    int mode, flags = 0;
-    VALUE obj;
 
-    if (rb_scan_args(argc, argv, "11", &file, &vmode) == 1) {
+    if (rb_scan_args(argc, argv, "12", &file, &vmode, &vflags) == 1) {
 	mode = 0666;		/* default value */
     }
     else if (NIL_P(vmode)) {
@@ -64,31 +79,61 @@ fgdbm_s_open(argc, argv, klass)
     else {
 	mode = NUM2INT(vmode);
     }
+
+    if (!NIL_P(vflags))
+        flags = NUM2INT(vflags);
+
     Check_SafeStr(file);
 
     dbm = 0;
     if (mode >= 0)
 	dbm = gdbm_open(RSTRING(file)->ptr, MY_BLOCK_SIZE, 
-			O_RDWR|O_CREAT, mode, MY_FATAL_FUNC);
+			GDBM_WRCREAT|flags, mode, MY_FATAL_FUNC);
     if (!dbm)
 	dbm = gdbm_open(RSTRING(file)->ptr, MY_BLOCK_SIZE, 
-			O_RDWR, 0, MY_FATAL_FUNC);
+			GDBM_WRITER|flags, 0, MY_FATAL_FUNC);
     if (!dbm)
 	dbm = gdbm_open(RSTRING(file)->ptr, MY_BLOCK_SIZE, 
-			O_RDONLY, 0, MY_FATAL_FUNC);
+			GDBM_READER|flags, 0, MY_FATAL_FUNC);
 
     if (!dbm) {
 	if (mode == -1) return Qnil;
-	rb_sys_fail(RSTRING(file)->ptr);
+
+	if (gdbm_errno == GDBM_FILE_OPEN_ERROR ||
+	    gdbm_errno == GDBM_CANT_BE_READER ||
+	    gdbm_errno == GDBM_CANT_BE_WRITER)
+	    rb_sys_fail(RSTRING(file)->ptr);
+	else
+	    rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
     }
 
-    obj = Data_Make_Struct(klass,struct dbmdata,0,free_dbm,dbmp);
+    dbmp = ALLOC(struct dbmdata);
+    DATA_PTR(obj) = dbmp;
     dbmp->di_dbm = dbm;
     dbmp->di_size = -1;
 
     return obj;
 }
 
+static VALUE
+fgdbm_s_open(argc, argv, klass)
+    int argc;
+    VALUE *argv;
+    VALUE klass;
+{
+    VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
+
+    if (NIL_P(fgdbm_initialize(argc, argv, obj))) {
+	return Qnil;
+    }
+
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, obj, fgdbm_close, obj);
+    }
+
+    return obj;
+}
+
 static VALUE
 fgdbm_close(obj)
     VALUE obj;
@@ -102,6 +147,21 @@ fgdbm_close(obj)
     return Qnil;
 }
 
+static datum
+gdbm_fetch_1(dbm, key)
+    GDBM_FILE dbm;
+    datum key;
+{
+    static char *ptr;
+    datum val;
+
+    val = gdbm_fetch(dbm, key);
+    if (ptr) free(ptr);
+    ptr = val.dptr;
+
+    return val;
+}
+
 static VALUE
 fgdbm_fetch(obj, keystr, ifnone)
     VALUE obj, keystr, ifnone;
@@ -116,7 +176,7 @@ fgdbm_fetch(obj, keystr, ifnone)
 
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
-    value = gdbm_fetch(dbm, key);
+    value = gdbm_fetch_1(dbm, key);
     if (value.dptr == 0) {
 	if (ifnone == Qnil && rb_block_given_p())
 	    return rb_yield(rb_tainted_str_new(key.dptr, key.dsize));
@@ -138,10 +198,14 @@ fgdbm_fetch_m(argc, argv, obj)
     VALUE *argv;
     VALUE obj;
 {
-    VALUE keystr, ifnone;
+    VALUE keystr, valstr, ifnone;
 
     rb_scan_args(argc, argv, "11", &keystr, &ifnone);
-    return fgdbm_fetch(obj, keystr, ifnone);
+    valstr = fgdbm_fetch(obj, keystr, ifnone);
+    if (argc == 1 && !rb_block_given_p() && NIL_P(valstr))
+	rb_raise(rb_eIndexError, "key not found");
+
+    return valstr;
 }
 
 static VALUE
@@ -159,7 +223,7 @@ fgdbm_index(obj, valstr)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	if (val.dsize == RSTRING(valstr)->len &&
 	    memcmp(val.dptr, RSTRING(valstr)->ptr, val.dsize) == 0)
 	    return rb_tainted_str_new(key.dptr, key.dsize);
@@ -188,7 +252,7 @@ static VALUE
 fgdbm_delete(obj, keystr)
     VALUE obj, keystr;
 {
-    datum key, value;
+    datum key;
     struct dbmdata *dbmp;
     GDBM_FILE dbm;
 
@@ -200,15 +264,14 @@ fgdbm_delete(obj, keystr)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
 
-    value = gdbm_fetch(dbm, key);
+    if (!gdbm_exists(dbm, key)) {
-    if (value.dptr == 0) {
 	if (rb_block_given_p()) rb_yield(keystr);
 	return Qnil;
     }
 
     if (gdbm_delete(dbm, key)) {
 	dbmp->di_size = -1;
-	rb_raise(rb_eRuntimeError, "gdbm_delete failed");
+	rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
     }
     else if (dbmp->di_size >= 0) {
 	dbmp->di_size--;
@@ -231,7 +294,7 @@ fgdbm_shift(obj)
 
     key = gdbm_firstkey(dbm); 
     if (!key.dptr) return Qnil;
-    val = gdbm_fetch(dbm, key);
+    val = gdbm_fetch_1(dbm, key);
     gdbm_delete(dbm, key);
 
     keystr = rb_tainted_str_new(key.dptr, key.dsize);
@@ -252,12 +315,12 @@ fgdbm_delete_if(obj)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	keystr = rb_tainted_str_new(key.dptr, key.dsize);
 	valstr = rb_tainted_str_new(val.dptr, val.dsize);
 	if (RTEST(rb_yield(rb_assoc_new(keystr, valstr)))) {
 	    if (gdbm_delete(dbm, key)) {
-		rb_raise(rb_eRuntimeError, "gdbm_delete failed");
+		rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
 	    }
 	}
     }
@@ -279,7 +342,7 @@ fgdbm_clear(obj)
     for (key = gdbm_firstkey(dbm); key.dptr; key = nextkey) {
 	nextkey = gdbm_nextkey(dbm, key);
 	if (gdbm_delete(dbm, key)) {
-	    rb_raise(rb_eRuntimeError, "gdbm_delete failed");
+	    rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
 	}
     }
     return obj;
@@ -298,7 +361,7 @@ fgdbm_invert(obj)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	keystr = rb_tainted_str_new(key.dptr, key.dsize);
 	valstr = rb_tainted_str_new(val.dptr, val.dsize);
 	rb_hash_aset(hash, valstr, keystr);
@@ -367,7 +430,7 @@ fgdbm_store(obj, keystr, valstr)
     dbm = dbmp->di_dbm;
     if (gdbm_store(dbm, key, val, GDBM_REPLACE)) {
 	if (errno == EPERM) rb_sys_fail(0);
-	rb_raise(rb_eRuntimeError, "gdbm_store failed");
+	rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
     }
 
     return valstr;
@@ -429,7 +492,7 @@ fgdbm_each_value(obj)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	rb_yield(rb_tainted_str_new(val.dptr, val.dsize));
     }
     return obj;
@@ -464,7 +527,7 @@ fgdbm_each_pair(obj)
     dbm = dbmp->di_dbm;
 
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	keystr = rb_tainted_str_new(key.dptr, key.dsize);
 	valstr = rb_tainted_str_new(val.dptr, val.dsize);
 	rb_yield(rb_assoc_new(keystr, valstr));
@@ -507,7 +570,7 @@ fgdbm_values(obj)
 
     ary = rb_ary_new();
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	rb_ary_push(ary, rb_tainted_str_new(val.dptr, val.dsize));
     }
 
@@ -537,7 +600,7 @@ static VALUE
 fgdbm_has_value(obj, valstr)
     VALUE obj, valstr;
 {
-    datum key, val;
+    datum key;
     struct dbmdata *dbmp;
     GDBM_FILE dbm;
 
@@ -548,7 +611,7 @@ fgdbm_has_value(obj, valstr)
     GetDBM(obj, dbmp);
     dbm = dbmp->di_dbm;
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	if (val.dsize == RSTRING(valstr)->len &&
 	    memcmp(val.dptr, RSTRING(valstr)->ptr, val.dsize) == 0)
 	    return Qtrue;
@@ -570,7 +633,7 @@ fgdbm_to_a(obj)
 
     ary = rb_ary_new();
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	rb_ary_push(ary, rb_assoc_new(rb_tainted_str_new(key.dptr, key.dsize),
 				rb_tainted_str_new(val.dptr, val.dsize)));
     }
@@ -592,6 +655,88 @@ fgdbm_reorganize(obj)
     return obj;
 }
 
+static VALUE
+fgdbm_sync(obj)
+    VALUE obj;
+{
+    struct dbmdata *dbmp;
+    GDBM_FILE dbm;
+
+    rb_secure(4);
+    GetDBM(obj, dbmp);
+    dbm = dbmp->di_dbm;
+    gdbm_sync(dbm);
+    return obj;
+}
+
+static VALUE
+fgdbm_set_cachesize(obj, val)
+    VALUE obj, val;
+{
+    struct dbmdata *dbmp;
+    GDBM_FILE dbm;
+    VALUE hash;
+    int optval;
+
+    GetDBM(obj, dbmp);
+    dbm = dbmp->di_dbm;
+
+    optval = FIX2INT(val);
+    if (gdbm_setopt(dbm, GDBM_CACHESIZE, &optval, sizeof(optval)) == -1) {
+	rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
+    }
+    return val;
+}
+
+static VALUE
+fgdbm_set_fastmode(obj, val)
+    VALUE obj, val;
+{
+    struct dbmdata *dbmp;
+    GDBM_FILE dbm;
+    VALUE hash;
+    int optval;
+
+    GetDBM(obj, dbmp);
+    dbm = dbmp->di_dbm;
+
+    optval = 0;
+    if (RTEST(val))
+        optval = 1;
+
+    if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval, sizeof(optval)) == -1) {
+	rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
+    }
+    return val;
+}
+
+static VALUE
+fgdbm_set_syncmode(obj, val)
+    VALUE obj, val;
+{
+#if !defined(GDBM_SYNCMODE)
+    fgdbm_set_fastmode(obj, RTEST(val) ? Qfalse : Qtrue);
+    return val;
+#else
+    struct dbmdata *dbmp;
+    GDBM_FILE dbm;
+    VALUE hash;
+    int optval;
+
+    GetDBM(obj, dbmp);
+    dbm = dbmp->di_dbm;
+
+    optval = 0;
+    if (RTEST(val))
+        optval = 1;
+
+    if (gdbm_setopt(dbm, GDBM_FASTMODE, &optval, sizeof(optval)) == -1) {
+	rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
+    }
+    return val;
+#endif
+}
+
 static VALUE
 fgdbm_to_hash(obj)
     VALUE obj;
@@ -606,7 +751,7 @@ fgdbm_to_hash(obj)
 
     hash = rb_hash_new();
     for (key = gdbm_firstkey(dbm); key.dptr; key = gdbm_nextkey(dbm, key)) {
-	val = gdbm_fetch(dbm, key);
+	val = gdbm_fetch_1(dbm, key);
 	rb_hash_aset(hash, rb_tainted_str_new(key.dptr, key.dsize),
 		           rb_tainted_str_new(val.dptr, val.dsize));
     }
@@ -625,10 +770,13 @@ void
 Init_gdbm()
 {
     cGDBM = rb_define_class("GDBM", rb_cObject);
+    rb_eGDBMError = rb_define_class("GDBMError", rb_eStandardError);
     rb_include_module(cGDBM, rb_mEnumerable);
 
+    rb_define_singleton_method(cGDBM, "new", fgdbm_s_new, -1);
     rb_define_singleton_method(cGDBM, "open", fgdbm_s_open, -1);
-    rb_define_singleton_method(cGDBM, "new", fgdbm_s_open, -1);
+
+    rb_define_method(cGDBM, "initialize", fgdbm_initialize, -1);
     rb_define_method(cGDBM, "close", fgdbm_close, 0);
     rb_define_method(cGDBM, "[]", fgdbm_aref, 1);
     rb_define_method(cGDBM, "fetch", fgdbm_fetch_m, -1);
@@ -656,6 +804,11 @@ Init_gdbm()
     rb_define_method(cGDBM,"update", fgdbm_update, 1);
     rb_define_method(cGDBM,"replace", fgdbm_replace, 1);
     rb_define_method(cGDBM,"reorganize", fgdbm_reorganize, 0);
+    rb_define_method(cGDBM,"sync", fgdbm_sync, 0);
+    /* rb_define_method(cGDBM,"setopt", fgdbm_setopt, 2); */
+    rb_define_method(cGDBM,"cachesize=", fgdbm_set_cachesize, 1);
+    rb_define_method(cGDBM,"fastmode=", fgdbm_set_fastmode, 1);
+    rb_define_method(cGDBM,"syncmode=", fgdbm_set_syncmode, 1);
 
     rb_define_method(cGDBM, "include?", fgdbm_has_key, 1);
     rb_define_method(cGDBM, "has_key?", fgdbm_has_key, 1);
@@ -666,4 +819,24 @@ Init_gdbm()
 
     rb_define_method(cGDBM, "to_a", fgdbm_to_a, 0);
     rb_define_method(cGDBM, "to_hash", fgdbm_to_hash, 0);
+
+    /* flags for gdbm_opn() */
+    /*
+    rb_define_const(cGDBM, "READER",  INT2FIX(GDBM_READER));
+    rb_define_const(cGDBM, "WRITER",  INT2FIX(GDBM_WRITER));
+    rb_define_const(cGDBM, "WRCREAT", INT2FIX(GDBM_WRCREAT));
+    rb_define_const(cGDBM, "NEWDB",   INT2FIX(GDBM_NEWDB));
+    */
+    rb_define_const(cGDBM, "FAST", INT2FIX(GDBM_FAST));
+    /* this flag is obsolete in gdbm 1.8.
+       On gdbm 1.8, fast mode is default behavior. */
+
+    /* gdbm version 1.8 specific */
+#if defined(GDBM_SYNC)
+    rb_define_const(cGDBM, "SYNC",    INT2FIX(GDBM_SYNC));
+#endif
+#if defined(GDBM_NOLOCK)
+    rb_define_const(cGDBM, "NOLOCK",  INT2FIX(GDBM_NOLOCK));
+#endif
+    rb_define_const(cGDBM, "VERSION",  rb_str_new2(gdbm_version));
 }

ext/socket/extconf.rb

@@ -338,9 +338,9 @@ if have_func(test_func)
   end
   if ENV["SOCKS_SERVER"] or enable_config("socks", false)
     if have_library("socks5", "SOCKSinit")
-      $CFLAGS="-DSOCKS5 -DSOCKS"
+      $CFLAGS+=" -DSOCKS5 -DSOCKS"
     elsif have_library("socks", "Rconnect")
-      $CFLAGS="-DSOCKS"
+      $CFLAGS+=" -DSOCKS"
     end
   end
   create_makefile("socket")

ext/socket/socket.c

@@ -182,9 +182,7 @@ sock_new(class, fd)
     fp->f = rb_fdopen(fd, "r");
 #ifdef NT
     fp->finalize = sock_finalize;
-    fd = myfddup(fd);
 #else
-    fd = dup(fd);
 #endif
     fp->f2 = rb_fdopen(fd, "w");
     fp->mode = FMODE_READWRITE;
@@ -233,18 +231,10 @@ bsock_close_read(sock)
     }
     GetOpenFile(sock, fptr);
     shutdown(fileno(fptr->f), 0);
-    if (fptr->f2 == 0) {
+    if (!(fptr->mode & FMODE_WRITABLE)) {
 	return rb_io_close(sock);
     }
-    rb_thread_fd_close(fileno(fptr->f));
     fptr->mode &= ~FMODE_READABLE;
-#ifdef NT
-    myfdclose(fptr->f);
-#else
-    fclose(fptr->f);
-#endif
-    fptr->f = fptr->f2;
-    fptr->f2 = 0;
 
     return Qnil;
 }
@@ -259,17 +249,11 @@ bsock_close_write(sock)
 	rb_raise(rb_eSecurityError, "Insecure: can't close socket");
     }
     GetOpenFile(sock, fptr);
-    if (fptr->f2 == 0) {
+    if (!(fptr->mode & FMODE_READABLE)) {
 	return rb_io_close(sock);
     }
     shutdown(fileno(fptr->f2), 1);
     fptr->mode &= ~FMODE_WRITABLE;
-#ifdef NT
-    myfdclose(fptr->f2);
-#else
-    fclose(fptr->f2);
-#endif
-    fptr->f2 = 0;
 
     return Qnil;
 }

hash.c

@@ -79,16 +79,16 @@ static int
 rb_any_hash(a)
     VALUE a;
 {
-    unsigned int hval;
+    VALUE hval;
 
     switch (TYPE(a)) {
       case T_FIXNUM:
       case T_SYMBOL:
-	hval = a;
+	return (int)a;
 	break;
 
       case T_STRING:
-	hval = rb_str_hash(a);
+	return rb_str_hash(a);
 	break;
 
       default:
@@ -98,9 +98,8 @@ rb_any_hash(a)
 	    hval = rb_funcall(hval, '%', 1, INT2FIX(65439));
 	}
 	ENABLE_INTS;
-	hval = FIX2LONG(hval);
+	return (int)FIX2LONG(hval);
     }
-    return  hval;
 }
 
 static struct st_hash_type objhash = {

io.c

@@ -1960,7 +1960,9 @@ rb_io_clone(io)
     fd = rb_dup(fileno(orig->f));
     fptr->f = rb_fdopen(fd, mode);
     if (fptr->f2) {
-	fd = rb_dup(fileno(orig->f2));
+	if (fileno(orig->f) != fileno(orig->f2)) {
+	    fd = rb_dup(fileno(orig->f2));
+	}
 	fptr->f = rb_fdopen(fd, "w");
     }
     if (fptr->mode & FMODE_BINMODE) {
@@ -2376,6 +2378,30 @@ rb_file_initialize(argc, argv, io)
     return file;
 }
 
+static VALUE
+rb_io_s_for_fd(argc, argv, klass)
+    int argc;
+    VALUE *argv;
+    VALUE klass;
+{
+    VALUE fnum, mode;
+    OpenFile *fp;
+    char *m = "r";
+    NEWOBJ(io, struct RFile);
+    OBJSETUP(io, klass, T_FILE);
+    
+    if (rb_scan_args(argc, argv, "11", &fnum, &mode) == 2) {
+	Check_SafeStr(mode);
+	m = RSTRING(mode)->ptr;
+    }
+    MakeOpenFile(io, fp);
+
+    fp->f = rb_fdopen(NUM2INT(fnum), m);
+    fp->mode = rb_io_mode_flags(m);
+
+    return (VALUE)io;
+}
+
 static int binmode = 0;
 
 static VALUE
@@ -2853,7 +2879,8 @@ rb_io_ctl(io, req, arg, io_p)
 	rb_raise(rb_eArgError, "return value overflowed string");
     }
 
-    if (fptr->f2) {		/* call on f2 too; ignore result */
+    if (fptr->f2 && fileno(fptr->f) != fileno(fptr->f2)) {
+	/* call on f2 too; ignore result */
 	io_cntl(fileno(fptr->f2), cmd, narg, io_p);
     }
 
@@ -3382,6 +3409,7 @@ Init_IO()
     rb_include_module(rb_cIO, rb_mEnumerable);
 
     rb_define_singleton_method(rb_cIO, "new", rb_io_s_new, -1);
+    rb_define_singleton_method(rb_cIO, "for_fd", rb_io_s_for_fd, -1);
     rb_define_method(rb_cIO, "initialize", rb_io_initialize, -1);
     rb_define_singleton_method(rb_cIO, "popen", rb_io_s_popen, -1);
     rb_define_singleton_method(rb_cIO, "foreach", rb_io_s_foreach, -1);

lib/cgi/session.rb

@@ -25,7 +25,6 @@ class CGI
       md5.update('foobar')
       md5.hexdigest[0,16]
     end
-    private :create_new_id
 
     def initialize(request, option={})
       session_key = option['session_key'] || '_session_id'

lib/importenv.rb

@@ -9,9 +9,8 @@
 
 for k,v in ENV
   next unless /^[a-zA-Z][_a-zA-Z0-9]*/ =~ k
-  v = v.gsub(/\\/) {|s| '\\'+s}
   eval <<EOS
-  $#{k} = %q\0#{v}\0
+  $#{k} = v
   trace_var "$#{k}", proc{|v|
     ENV[%q!#{k}!] = v
     $#{k} = v

parse.y

@@ -87,6 +87,7 @@ static stack_type cmdarg_stack = 0;
 
 static int class_nest = 0;
 static int in_single = 0;
+static int in_def = 0;
 static int compile_for_eval = 0;
 static ID cur_mid = 0;
 
@@ -314,13 +315,13 @@ stmts		: none
 
 stmt		: kALIAS fitem {lex_state = EXPR_FNAME;} fitem
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("alias within method");
 		        $$ = NEW_ALIAS($2, $4);
 		    }
 		| kALIAS tGVAR tGVAR
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("alias within method");
 		        $$ = NEW_VALIAS($2, $3);
 		    }
@@ -328,7 +329,7 @@ stmt		: kALIAS fitem {lex_state = EXPR_FNAME;} fitem
 		    {
 			char buf[3];
 
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("alias within method");
 			sprintf(buf, "$%c", $3->nd_nth);
 		        $$ = NEW_VALIAS($2, rb_intern(buf));
@@ -340,7 +341,7 @@ stmt		: kALIAS fitem {lex_state = EXPR_FNAME;} fitem
 		    }
 		| kUNDEF undef_list
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("undef within method");
 			$$ = $2;
 		    }
@@ -392,7 +393,7 @@ stmt		: kALIAS fitem {lex_state = EXPR_FNAME;} fitem
 		    }
 		| klBEGIN
 		    {
-			if (cur_mid || in_single) {
+			if (in_def || in_single) {
 			    yyerror("BEGIN in method");
 			}
 			local_push();
@@ -406,7 +407,7 @@ stmt		: kALIAS fitem {lex_state = EXPR_FNAME;} fitem
 		    }
 		| klEND '{' compstmt '}'
 		    {
-			if (compile_for_eval && (cur_mid || in_single)) {
+			if (compile_for_eval && (in_def || in_single)) {
 			    yyerror("END in method; use at_exit");
 			}
 
@@ -437,7 +438,7 @@ expr		: mlhs '=' mrhs
 		    }
 		| kRETURN ret_args
 		    {
-			if (!compile_for_eval && !cur_mid && !in_single)
+			if (!compile_for_eval && !in_def && !in_single)
 			    yyerror("return appeared outside of method");
 			$$ = NEW_RETURN($2);
 		    }
@@ -495,7 +496,7 @@ command		:  operation command_args
 		    }
 		| kSUPER command_args
 		    {
-			if (!compile_for_eval && !cur_mid && !in_single)
+			if (!compile_for_eval && !in_def && !in_single)
 			    yyerror("super called outside of method");
 			$$ = new_super($2);
 		        fixpos($$, $2);
@@ -1148,20 +1149,20 @@ primary		: literal
 		    }
 		| kRETURN '(' ret_args ')'
 		    {
-			if (!compile_for_eval && !cur_mid && !in_single)
+			if (!compile_for_eval && !in_def && !in_single)
 			    yyerror("return appeared outside of method");
 			value_expr($3);
 			$$ = NEW_RETURN($3);
 		    }
 		| kRETURN '(' ')'
 		    {
-			if (!compile_for_eval && !cur_mid && !in_single)
+			if (!compile_for_eval && !in_def && !in_single)
 			    yyerror("return appeared outside of method");
 			$$ = NEW_RETURN(0);
 		    }
 		| kRETURN
 		    {
-			if (!compile_for_eval && !cur_mid && !in_single)
+			if (!compile_for_eval && !in_def && !in_single)
 			    yyerror("return appeared outside of method");
 			$$ = NEW_RETURN(0);
 		    }
@@ -1254,9 +1255,8 @@ primary		: literal
 		    }
 		| kCLASS cname superclass
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("class definition in method body");
-
 			class_nest++;
 			cref_push();
 			local_push();
@@ -1273,22 +1273,30 @@ primary		: literal
 		    }
 		| kCLASS tLSHFT expr term
 		    {
+		        $<num>$ = in_single;
+		        in_single = 0;
 			class_nest++;
 			cref_push();
 			local_push();
 		    }
+		    {
+			$<num>$ = in_def;
+		        in_def = 0;
+		    }
 		  compstmt
 		  kEND
 		    {
-		        $$ = NEW_SCLASS($3, $6);
+		        $$ = NEW_SCLASS($3, $7);
 		        fixpos($$, $3);
 		        local_pop();
 			cref_pop();
 			class_nest--;
+		        in_single = $<num>5;
+		        in_def = $<num>6;
 		    }
 		| kMODULE cname
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("module definition in method body");
 			class_nest++;
 			cref_push();
@@ -1306,9 +1314,11 @@ primary		: literal
 		    }
 		| kDEF fname
 		    {
-			if (cur_mid || in_single)
+			if (in_def || in_single)
 			    yyerror("nested method definition");
+			$<id>$ = cur_mid;
 			cur_mid = $2;
+			in_def++;
 			local_push();
 		    }
 		  f_arglist
@@ -1330,7 +1340,8 @@ primary		: literal
 			if (is_attrset_id($2)) $$->nd_noex = NOEX_PUBLIC;
 		        fixpos($$, $4);
 		        local_pop();
-			cur_mid = 0;
+			in_def--;
+			cur_mid = $<id>3;
 		    }
 		| kDEF singleton dot_or_colon {lex_state = EXPR_FNAME;} fname
 		    {
@@ -1463,14 +1474,14 @@ method_call	: operation paren_args
 		    }
 		| kSUPER paren_args
 		    {
-			if (!compile_for_eval && !cur_mid &&
+			if (!compile_for_eval && !in_def &&
 		            !in_single && !in_defined)
 			    yyerror("super called outside of method");
 			$$ = new_super($2);
 		    }
 		| kSUPER
 		    {
-			if (!compile_for_eval && !cur_mid &&
+			if (!compile_for_eval && !in_def &&
 		            !in_single && !in_defined)
 			    yyerror("super called outside of method");
 			$$ = NEW_ZSUPER();
@@ -1973,6 +1984,7 @@ yycompile(f, line)
     cond_stack = 0;
     class_nest = 0;
     in_single = 0;
+    in_def = 0;
     cur_mid = 0;
 
     if (n == 0) node = ruby_eval_tree;
@@ -4120,7 +4132,7 @@ assignable(id, val)
 	return NEW_IASGN(id, val);
     }
     else if (is_const_id(id)) {
-	if (cur_mid || in_single)
+	if (in_def || in_single)
 	    yyerror("dynamic constant assignment");
 	return NEW_CDECL(id, val);
     }

regex.c

@@ -3461,7 +3461,8 @@ re_search(bufp, string, size, startpos, range, regs)
 #define PREV_IS_A_LETTER(d) ((current_mbctype == MBCTYPE_SJIS)?		\
 			     IS_A_LETTER((d)-(!AT_STRINGS_BEG((d)-1)&&	\
 					      ismbchar((d)[-2])?2:1)):	\
-			     ((d)[-1] >= 0x80 || IS_A_LETTER((d)-1)))
+                             ((current_mbctype && ((d)[-1] >= 0x80)) ||	\
+			      IS_A_LETTER((d)-1)))
 
 static void
 init_regs(regs, num_regs)