diff options
Diffstat (limited to 'hash.c')
| -rw-r--r-- | hash.c | 921 |
1 files changed, 617 insertions, 304 deletions
@@ -6,37 +6,36 @@ $Date$ created at: Mon Nov 22 18:51:18 JST 1993 - Copyright (C) 1993-1997 Yukihiro Matsumoto + Copyright (C) 1993-1998 Yukihiro Matsumoto ************************************************/ #include "ruby.h" #include "st.h" -#include "sig.h" +#include "rubysig.h" +#include <sys/types.h> #include <sys/stat.h> #ifndef HAVE_STRING_H -char *strchr(); +char *strchr _((char*,char)); #endif -#define HASH_DELETED 0x1 -#define HASH_REHASHED 0x2 - #define HASH_FREEZE FL_USER1 +#define HASH_DELETED FL_USER2 static void -hash_modify(hash) +rb_hash_modify(hash) VALUE hash; { - rb_secure(5); - if (FL_TEST(hash, HASH_FREEZE)) { - TypeError("can't modify frozen hash"); - } + if (FL_TEST(hash, HASH_FREEZE)) + rb_raise(rb_eTypeError, "can't modify frozen hash"); + if (rb_safe_level() >= 4 && !FL_TEST(hash, FL_TAINT)) + rb_raise(rb_eSecurityError, "Insecure: can't modify hash"); } VALUE -hash_freeze(hash) +rb_hash_freeze(hash) VALUE hash; { FL_SET(hash, HASH_FREEZE); @@ -44,19 +43,15 @@ hash_freeze(hash) } static VALUE -hash_frozen_p(hash) +rb_hash_frozen_p(hash) VALUE hash; { if (FL_TEST(hash, HASH_FREEZE)) - return TRUE; - return FALSE; + return Qtrue; + return Qfalse; } -#ifndef NT -char *getenv(); -#endif - -VALUE cHash; +VALUE rb_cHash; static VALUE envtbl; static ID hash; @@ -69,14 +64,14 @@ rb_hash(obj) } static int -any_cmp(a, b) +rb_any_cmp(a, b) VALUE a, b; { if (FIXNUM_P(a)) { if (FIXNUM_P(b)) return a != b; } else if (TYPE(a) == T_STRING) { - if (TYPE(b) == T_STRING) return str_cmp(a, b); + if (TYPE(b) == T_STRING) return rb_str_cmp(a, b); } DEFER_INTS; @@ -86,9 +81,8 @@ any_cmp(a, b) } static int -any_hash(a, mod) +rb_any_hash(a) VALUE a; - int mod; { unsigned int hval; @@ -98,7 +92,7 @@ any_hash(a, mod) break; case T_STRING: - hval = str_hash(a); + hval = rb_str_hash(a); break; default: @@ -108,161 +102,181 @@ any_hash(a, mod) hval = rb_funcall(hval, '%', 1, INT2FIX(65439)); } ENABLE_INTS; - hval = FIX2INT(hval); + hval = FIX2LONG(hval); } - return hval % mod; + return hval; } static struct st_hash_type objhash = { - any_cmp, - any_hash, + rb_any_cmp, + rb_any_hash, }; -struct hash_foreach_arg { +struct rb_hash_foreach_arg { VALUE hash; enum st_retval (*func)(); char *arg; }; static int -hash_foreach_iter(key, value, arg) +rb_hash_foreach_iter(key, value, arg) VALUE key, value; - struct hash_foreach_arg *arg; + struct rb_hash_foreach_arg *arg; { int status; + st_table *tbl = RHASH(arg->hash)->tbl; + struct st_table_entry **bins = tbl->bins; if (key == Qnil) return ST_CONTINUE; status = (*arg->func)(key, value, arg->arg); - if (RHASH(arg->hash)->status & HASH_REHASHED) return ST_STOP; + if (RHASH(arg->hash)->tbl != tbl || RHASH(arg->hash)->tbl->bins != bins){ + rb_raise(rb_eIndexError, "rehash occurred during iteration"); + } return status; } static VALUE -hash_foreach_call(arg) - struct hash_foreach_arg *arg; +rb_hash_foreach_call(arg) + struct rb_hash_foreach_arg *arg; { - st_foreach(RHASH(arg->hash)->tbl, hash_foreach_iter, arg); + st_foreach(RHASH(arg->hash)->tbl, rb_hash_foreach_iter, arg); return Qnil; } static int -hash_delete_nil(key, value) +rb_hash_delete_nil(key, value) VALUE key, value; { - if (key == Qnil) return ST_DELETE; + if (value == Qnil) return ST_DELETE; return ST_CONTINUE; } -static void -hash_foreach_ensure(hash) +static VALUE +rb_hash_foreach_ensure(hash) VALUE hash; { RHASH(hash)->iter_lev--; if (RHASH(hash)->iter_lev == 0) { - if (RHASH(hash)->status & HASH_DELETED) { - st_foreach(RHASH(hash)->tbl, hash_delete_nil, 0); + if (FL_TEST(hash, HASH_DELETED)) { + st_foreach(RHASH(hash)->tbl, rb_hash_delete_nil, 0); + FL_UNSET(hash, HASH_DELETED); } - RHASH(hash)->status = 0; } + return 0; } static int -hash_foreach(hash, func, farg) +rb_hash_foreach(hash, func, farg) VALUE hash; enum st_retval (*func)(); char *farg; { - struct hash_foreach_arg arg; + struct rb_hash_foreach_arg arg; RHASH(hash)->iter_lev++; arg.hash = hash; arg.func = func; arg.arg = farg; - return rb_ensure(hash_foreach_call, (VALUE)&arg, hash_foreach_ensure, (VALUE)hash); + return rb_ensure(rb_hash_foreach_call, (VALUE)&arg, rb_hash_foreach_ensure, hash); } static VALUE -hash_s_new(argc, argv, class) +rb_hash_s_new(argc, argv, klass) int argc; VALUE *argv; - VALUE class; + VALUE klass; { - VALUE sz; + VALUE sz, ifnone; int size; NEWOBJ(hash, struct RHash); - OBJSETUP(hash, class, T_HASH); - - rb_scan_args(argc, argv, "01", &sz); - if (NIL_P(sz)) size = 0; - else size = NUM2INT(sz); + OBJSETUP(hash, klass, T_HASH); hash->iter_lev = 0; - hash->status = 0; + hash->ifnone = Qnil; hash->tbl = 0; /* avoid GC crashing */ + + rb_scan_args(argc, argv, "02", &ifnone, &sz); + if (NIL_P(sz)) { + size = 0; + } + else size = NUM2INT(sz); + + hash->ifnone = ifnone; hash->tbl = st_init_table_with_size(&objhash, size); + rb_obj_call_init((VALUE)hash); return (VALUE)hash; } static VALUE -hash_new2(class) - VALUE class; +rb_hash_new2(klass) + VALUE klass; { - return hash_s_new(0, 0, class); + NEWOBJ(hash, struct RHash); + OBJSETUP(hash, klass, T_HASH); + + hash->iter_lev = 0; + hash->ifnone = Qnil; + hash->tbl = 0; /* avoid GC crashing */ + hash->tbl = st_init_table(&objhash); + + return (VALUE)hash; } VALUE -hash_new() +rb_hash_new() { - return hash_new2(cHash); + return rb_hash_new2(rb_cHash); } static VALUE -hash_s_create(argc, argv, class) +rb_hash_s_create(argc, argv, klass) int argc; VALUE *argv; - VALUE class; + VALUE klass; { VALUE hash; int i; if (argc == 1 && TYPE(argv[0]) == T_HASH) { - if (class == CLASS_OF(argv[0])) return argv[0]; + if (klass == CLASS_OF(argv[0])) return argv[0]; else { NEWOBJ(hash, struct RHash); - OBJSETUP(hash, class, T_HASH); + OBJSETUP(hash, klass, T_HASH); hash->iter_lev = 0; - hash->status = 0; + hash->ifnone = Qnil; hash->tbl = 0; /* avoid GC crashing */ hash->tbl = (st_table*)st_copy(RHASH(argv[0])->tbl); + rb_obj_call_init((VALUE)hash); return (VALUE)hash; } } if (argc % 2 != 0) { - ArgError("odd number args for Hash"); + rb_raise(rb_eArgError, "odd number args for Hash"); } - hash = hash_new2(class); + hash = rb_hash_new2(klass); for (i=0; i<argc; i+=2) { st_insert(RHASH(hash)->tbl, argv[i], argv[i+1]); } + rb_obj_call_init(hash); return hash; } static VALUE -hash_clone(hash) +rb_hash_clone(hash) VALUE hash; { NEWOBJ(hash2, struct RHash); CLONESETUP(hash2, hash); hash2->iter_lev = 0; - hash2->status = 0; + hash2->ifnone = RHASH(hash)->ifnone; hash2->tbl = 0; /* avoid GC crashing */ hash2->tbl = (st_table*)st_copy(RHASH(hash)->tbl); @@ -270,22 +284,29 @@ hash_clone(hash) } static VALUE -hash_dup(hash) +rb_hash_dup(hash) VALUE hash; { NEWOBJ(hash2, struct RHash); OBJSETUP(hash2, CLASS_OF(hash), T_HASH); hash2->iter_lev = 0; - hash2->status = 0; + hash2->ifnone = RHASH(hash)->ifnone; hash2->tbl = 0; /* avoid GC crashing */ hash2->tbl = (st_table*)st_copy(RHASH(hash)->tbl); return (VALUE)hash2; } +static VALUE +to_hash(hash) + VALUE hash; +{ + return rb_convert_type(hash, T_HASH, "Hash", "to_hash"); +} + static int -hash_rehash_i(key, value, tbl) +rb_hash_rehash_i(key, value, tbl) VALUE key, value; st_table *tbl; { @@ -296,34 +317,71 @@ hash_rehash_i(key, value, tbl) } static VALUE -hash_rehash(hash) +rb_hash_rehash(hash) VALUE hash; { st_table *tbl; tbl = st_init_table_with_size(&objhash, RHASH(hash)->tbl->num_entries); - st_foreach(RHASH(hash)->tbl, hash_rehash_i, tbl); + st_foreach(RHASH(hash)->tbl, rb_hash_rehash_i, tbl); st_free_table(RHASH(hash)->tbl); RHASH(hash)->tbl = tbl; - if (RHASH(hash)->iter_lev > 0) RHASH(hash)->status |= HASH_REHASHED; - return (VALUE)hash; + return hash; } VALUE -hash_aref(hash, key) +rb_hash_aref(hash, key) VALUE hash, key; { VALUE val; if (!st_lookup(RHASH(hash)->tbl, key, &val)) { - return Qnil; + return RHASH(hash)->ifnone; } return val; } static VALUE -hash_indexes(argc, argv, hash) +rb_hash_fetch(argc, argv, hash) + int argc; + VALUE *argv; + VALUE hash; +{ + VALUE key, if_none; + VALUE val; + + rb_scan_args(argc, argv, "11", &key, &if_none); + + if (!st_lookup(RHASH(hash)->tbl, key, &val)) { + if (rb_iterator_p()) { + if (argc > 1) { + rb_raise(rb_eArgError, "wrong # of arguments", argc); + } + return rb_yield(argv[0]); + } + return if_none; + } + return val; +} + +static VALUE +rb_hash_default(hash) + VALUE hash; +{ + return RHASH(hash)->ifnone; +} + +static VALUE +rb_hash_set_default(hash, ifnone) + VALUE hash, ifnone; +{ + RHASH(hash)->ifnone = ifnone; + return hash; +} + +static VALUE +rb_hash_indexes(argc, argv, hash) int argc; VALUE *argv; VALUE hash; @@ -331,27 +389,31 @@ hash_indexes(argc, argv, hash) VALUE indexes; int i; - indexes = ary_new2(argc); + indexes = rb_ary_new2(argc); for (i=0; i<argc; i++) { - RARRAY(indexes)->ptr[i] = hash_aref(hash, argv[i]); + RARRAY(indexes)->ptr[i] = rb_hash_aref(hash, argv[i]); } RARRAY(indexes)->len = i; return indexes; } static VALUE -hash_delete(hash, key) +rb_hash_delete(hash, key) VALUE hash, key; { VALUE val; - hash_modify(hash); - if (RHASH(hash)->iter_lev > 0 - && st_delete_safe(RHASH(hash)->tbl, &key, &val, Qnil)) + rb_hash_modify(hash); + if (RHASH(hash)->iter_lev > 0 && + st_delete_safe(RHASH(hash)->tbl, &key, &val, Qnil)) { + FL_SET(hash, HASH_DELETED); return val; + } else if (st_delete(RHASH(hash)->tbl, &key, &val)) return val; - if (iterator_p()) rb_yield(key); + if (rb_iterator_p()) { + return rb_yield(key); + } return Qnil; } @@ -375,17 +437,17 @@ shift_i(key, value, var) } static VALUE -hash_shift(hash) +rb_hash_shift(hash) VALUE hash; { struct shift_var var; - hash_modify(hash); + rb_hash_modify(hash); var.stop = 0; st_foreach(RHASH(hash)->tbl, shift_i, &var); if (var.stop == 0) return Qnil; - return assoc_new(var.key, var.val); + return rb_assoc_new(var.key, var.val); } static int @@ -393,19 +455,19 @@ delete_if_i(key, value) VALUE key, value; { if (key == Qnil) return ST_CONTINUE; - if (rb_yield(assoc_new(key, value))) + if (rb_yield(rb_assoc_new(key, value))) return ST_DELETE; return ST_CONTINUE; } static VALUE -hash_delete_if(hash) +rb_hash_delete_if(hash) VALUE hash; { - hash_modify(hash); - hash_foreach(hash, delete_if_i, 0); + rb_hash_modify(hash); + rb_hash_foreach(hash, delete_if_i, 0); - return (VALUE)hash; + return hash; } static int @@ -416,45 +478,66 @@ clear_i(key, value) } static VALUE -hash_clear(hash) +rb_hash_clear(hash) VALUE hash; { - hash_modify(hash); + rb_hash_modify(hash); st_foreach(RHASH(hash)->tbl, clear_i); - return (VALUE)hash; + return hash; } VALUE -hash_aset(hash, key, val) +rb_hash_aset(hash, key, val) VALUE hash, key, val; { - hash_modify(hash); + rb_hash_modify(hash); if (NIL_P(val)) { - hash_delete(hash, key); + rb_hash_delete(hash, key); return Qnil; } - if (TYPE(key) == T_STRING) { - key = str_dup_freezed(key); + if (TYPE(key) != T_STRING || st_lookup(RHASH(hash)->tbl, key, 0)) { + st_insert(RHASH(hash)->tbl, key, val); + } + else { + st_add_direct(RHASH(hash)->tbl, rb_str_dup_frozen(key), val); } - st_insert(RHASH(hash)->tbl, key, val); return val; } +static int +replace_i(key, val, hash) + VALUE key, val, hash; +{ + rb_hash_aset(hash, key, val); + return ST_CONTINUE; +} + static VALUE -hash_length(hash) +rb_hash_replace(hash, hash2) + VALUE hash, hash2; +{ + hash2 = to_hash(hash2); + rb_hash_clear(hash); + st_foreach(RHASH(hash2)->tbl, replace_i, hash); + + return hash; +} + +static VALUE +rb_hash_length(hash) VALUE hash; { return INT2FIX(RHASH(hash)->tbl->num_entries); } static VALUE -hash_empty_p(hash) +rb_hash_empty_p(hash) VALUE hash; { if (RHASH(hash)->tbl->num_entries == 0) - return TRUE; - return FALSE; + return Qtrue; + return Qfalse; } static int @@ -467,11 +550,11 @@ each_value_i(key, value) } static VALUE -hash_each_value(hash) +rb_hash_each_value(hash) VALUE hash; { - hash_foreach(hash, each_value_i); - return (VALUE)hash; + rb_hash_foreach(hash, each_value_i, 0); + return hash; } static int @@ -484,11 +567,11 @@ each_key_i(key, value) } static VALUE -hash_each_key(hash) +rb_hash_each_key(hash) VALUE hash; { - hash_foreach(hash, each_key_i); - return (VALUE)hash; + rb_hash_foreach(hash, each_key_i, 0); + return hash; } static int @@ -496,16 +579,16 @@ each_pair_i(key, value) VALUE key, value; { if (key == Qnil) return ST_CONTINUE; - rb_yield(assoc_new(key, value)); + rb_yield(rb_assoc_new(key, value)); return ST_CONTINUE; } static VALUE -hash_each_pair(hash) +rb_hash_each_pair(hash) VALUE hash; { - hash_foreach(hash, each_pair_i); - return (VALUE)hash; + rb_hash_foreach(hash, each_pair_i, 0); + return hash; } static int @@ -513,22 +596,29 @@ to_a_i(key, value, ary) VALUE key, value, ary; { if (key == Qnil) return ST_CONTINUE; - ary_push(ary, assoc_new(key, value)); + rb_ary_push(ary, rb_assoc_new(key, value)); return ST_CONTINUE; } static VALUE -hash_to_a(hash) +rb_hash_to_a(hash) VALUE hash; { VALUE ary; - ary = ary_new(); + ary = rb_ary_new(); st_foreach(RHASH(hash)->tbl, to_a_i, ary); return ary; } +static VALUE +rb_hash_sort(hash) + VALUE hash; +{ + return rb_ary_sort_bang(rb_hash_to_a(hash)); +} + static int inspect_i(key, value, str) VALUE key, value, str; @@ -537,35 +627,60 @@ inspect_i(key, value, str) if (key == Qnil) return ST_CONTINUE; if (RSTRING(str)->len > 1) { - str_cat(str, ", ", 2); + rb_str_cat(str, ", ", 2); } str2 = rb_inspect(key); - str_cat(str, RSTRING(str2)->ptr, RSTRING(str2)->len); - str_cat(str, "=>", 2); + rb_str_cat(str, RSTRING(str2)->ptr, RSTRING(str2)->len); + rb_str_cat(str, "=>", 2); str2 = rb_inspect(value); - str_cat(str, RSTRING(str2)->ptr, RSTRING(str2)->len); + rb_str_cat(str, RSTRING(str2)->ptr, RSTRING(str2)->len); return ST_CONTINUE; } static VALUE -hash_inspect(hash) +inspect_hash(hash) VALUE hash; { VALUE str; - str = str_new2("{"); + str = rb_str_new2("{"); st_foreach(RHASH(hash)->tbl, inspect_i, str); - str_cat(str, "}", 1); + rb_str_cat(str, "}", 1); return str; } static VALUE +rb_hash_inspect(hash) + VALUE hash; +{ + if (RHASH(hash)->tbl->num_entries == 0) return rb_str_new2("{}"); + if (rb_inspecting_p(hash)) return rb_str_new2("{...}"); + return rb_protect_inspect(inspect_hash, hash, 0); +} + +static VALUE hash_to_s(hash) VALUE hash; { - return ary_to_s(hash_to_a(hash)); + if (rb_inspecting_p(hash)) return rb_str_new2("{...}"); + return rb_ary_to_s(rb_hash_to_a(hash)); +} + +static VALUE +rb_hash_to_s(hash) + VALUE hash; +{ + if (rb_inspecting_p(hash)) return rb_str_new2("{...}"); + return rb_protect_inspect(hash_to_s, hash, 0); +} + +static VALUE +rb_hash_to_hash(hash) + VALUE hash; +{ + return hash; } static int @@ -573,17 +688,17 @@ keys_i(key, value, ary) VALUE key, value, ary; { if (key == Qnil) return ST_CONTINUE; - ary_push(ary, key); + rb_ary_push(ary, key); return ST_CONTINUE; } static VALUE -hash_keys(hash) +rb_hash_keys(hash) VALUE hash; { VALUE ary; - ary = ary_new(); + ary = rb_ary_new(); st_foreach(RHASH(hash)->tbl, keys_i, ary); return ary; @@ -594,55 +709,55 @@ values_i(key, value, ary) VALUE key, value, ary; { if (key == Qnil) return ST_CONTINUE; - ary_push(ary, value); + rb_ary_push(ary, value); return ST_CONTINUE; } static VALUE -hash_values(hash) +rb_hash_values(hash) VALUE hash; { VALUE ary; - ary = ary_new(); + ary = rb_ary_new(); st_foreach(RHASH(hash)->tbl, values_i, ary); return ary; } static VALUE -hash_has_key(hash, key) +rb_hash_has_key(hash, key) VALUE hash; VALUE key; { if (st_lookup(RHASH(hash)->tbl, key, 0)) { - return TRUE; + return Qtrue; } - return FALSE; + return Qfalse; } static int -hash_search_value(key, value, data) +rb_hash_search_value(key, value, data) VALUE key, value, *data; { if (key == Qnil) return ST_CONTINUE; if (rb_equal(value, data[1])) { - data[0] = TRUE; + data[0] = Qtrue; return ST_STOP; } return ST_CONTINUE; } static VALUE -hash_has_value(hash, val) +rb_hash_has_value(hash, val) VALUE hash; VALUE val; { VALUE data[2]; - data[0] = FALSE; + data[0] = Qfalse; data[1] = val; - st_foreach(RHASH(hash)->tbl, hash_search_value, data); + st_foreach(RHASH(hash)->tbl, rb_hash_search_value, data); return data[0]; } @@ -660,79 +775,79 @@ equal_i(key, val1, data) if (key == Qnil) return ST_CONTINUE; if (!st_lookup(data->tbl, key, &val2)) { - data->result = FALSE; + data->result = Qfalse; return ST_STOP; } if (!rb_equal(val1, val2)) { - data->result = FALSE; + data->result = Qfalse; return ST_STOP; } return ST_CONTINUE; } static VALUE -hash_equal(hash1, hash2) +rb_hash_equal(hash1, hash2) VALUE hash1, hash2; { struct equal_data data; - if (TYPE(hash2) != T_HASH) return FALSE; + if (TYPE(hash2) != T_HASH) return Qfalse; if (RHASH(hash1)->tbl->num_entries != RHASH(hash2)->tbl->num_entries) - return FALSE; + return Qfalse; data.tbl = RHASH(hash2)->tbl; - data.result = TRUE; + data.result = Qtrue; st_foreach(RHASH(hash1)->tbl, equal_i, &data); return data.result; } static int -hash_invert_i(key, value, hash) +rb_hash_invert_i(key, value, hash) VALUE key, value; VALUE hash; { if (key == Qnil) return ST_CONTINUE; - hash_aset(hash, value, key); + rb_hash_aset(hash, value, key); return ST_CONTINUE; } static VALUE -hash_invert(hash) +rb_hash_invert(hash) VALUE hash; { - VALUE h = hash_new(); + VALUE h = rb_hash_new(); - st_foreach(RHASH(hash)->tbl, hash_invert_i, h); + st_foreach(RHASH(hash)->tbl, rb_hash_invert_i, h); return h; } static int -hash_update_i(key, value, hash) +rb_hash_update_i(key, value, hash) VALUE key, value; VALUE hash; { if (key == Qnil) return ST_CONTINUE; - hash_aset(hash, key, value); + rb_hash_aset(hash, key, value); return ST_CONTINUE; } static VALUE -hash_update(hash1, hash2) +rb_hash_update(hash1, hash2) VALUE hash1, hash2; { - Check_Type(hash2, T_HASH); - - st_foreach(RHASH(hash2)->tbl, hash_update_i, hash1); + hash2 = to_hash(hash2); + st_foreach(RHASH(hash2)->tbl, rb_hash_update_i, hash1); return hash1; } -int env_path_tainted(); +#ifndef __MACOS__ /* no environment variables on MacOS. */ static int path_tainted = -1; #ifndef NT extern char **environ; #endif +static char **origenviron; static VALUE env_delete(obj, name) @@ -742,10 +857,9 @@ env_delete(obj, name) char *nam, *val = 0; rb_secure(4); - Check_Type(name, T_STRING); - nam = RSTRING(name)->ptr; - len = strlen(nam); + nam = STR2CSTR(name); if (strcmp(nam, "PATH") == 0) path_tainted = 0; + len = strlen(nam); for(i=0; environ[i]; i++) { if (strncmp(environ[i], nam, len) == 0 && environ[i][len] == '=') { val = environ[i]+len+1; @@ -757,7 +871,7 @@ env_delete(obj, name) i++; } if (val) { - return str_new2(val); + return rb_str_new2(val); } return Qnil; } @@ -767,26 +881,26 @@ env_delete_method(obj, name) VALUE obj, name; { VALUE val = env_delete(obj, name); - if (iterator_p()) rb_yield(name); + if (rb_iterator_p()) rb_yield(name); return val; } static VALUE -f_getenv(obj, name) +rb_f_getenv(obj, name) VALUE obj, name; { - char *env; + char *nam, *env; + int len; - Check_Type(name, T_STRING); - - if (strlen(RSTRING(name)->ptr) != RSTRING(name)->len) - ArgError("Bad environment name"); - - env = getenv(RSTRING(name)->ptr); + nam = str2cstr(name, &len); + if (strlen(nam) != len) { + rb_raise(rb_eArgError, "Bad environment variable name"); + } + env = getenv(nam); if (env) { - if (strcmp(RSTRING(name)->ptr, "PATH") == 0 && !env_path_tainted()) - return str_new2(env); - return str_taint(str_new2(env)); + if (strcmp(nam, "PATH") == 0 && !rb_env_path_tainted()) + return rb_str_new2(env); + return rb_tainted_str_new2(env); } return Qnil; } @@ -800,7 +914,7 @@ path_check_1(path) char *s; for (;;) { - if (stat(path, &st) == 0 && (st.st_mode & 2)) { + if (stat(path, &st) == 0 && (st.st_mode & 002)) { return 0; } s = strrchr(path, '/'); @@ -811,19 +925,17 @@ path_check_1(path) } } -static void -path_check(path) +int +rb_path_check(path) char *path; { - char *p = path; - char *pend = strchr(path, ':'); + char *p, *pend; + const char sep = RUBY_PATH_SEP[0]; - if (!path) { - path_tainted = 0; - } + if (!path) return 1; p = path; - pend = strchr(path, ':'); + pend = strchr(path, sep); for (;;) { int safe; @@ -831,72 +943,207 @@ path_check(path) if (pend) *pend = '\0'; safe = path_check_1(p); if (!pend) break; - *pend = ':'; + *pend = sep; if (!safe) { - path_tainted = 1; - return; + return 0; } p = pend + 1; - pend = strchr(p, ':'); + pend = strchr(p, sep); } - path_tainted = 0; + return 1; +} + +static void +path_tainted_p(path) + char *path; +{ + path_tainted = rb_path_check(path)?0:1; } int -env_path_tainted() +rb_env_path_tainted() { if (path_tainted < 0) { - path_check(getenv("PATH")); + path_tainted_p(getenv("PATH")); } return path_tainted; } +static int +envix(nam) +char *nam; +{ + register int i, len = strlen(nam); + + for (i = 0; environ[i]; i++) { + if ( +#ifdef WIN32 + strnicmp(environ[i],nam,len) == 0 +#else + memcmp(environ[i],nam,len) == 0 +#endif + && environ[i][len] == '=') + break; /* memcmp must come first to avoid */ + } /* potential SEGV's */ + return i; +} + +static void +my_setenv(name, value) + char *name; + char *value; +{ +#ifdef WIN32 +#ifdef USE_WIN32_RTL_ENV + register char *envstr; + STRLEN namlen = strlen(name); + STRLEN vallen; + char *oldstr = environ[envix(name)]; + + /* putenv() has totally broken semantics in both the Borland + * and Microsoft CRTLs. They either store the passed pointer in + * the environment without making a copy, or make a copy and don't + * free it. And on top of that, they dont free() old entries that + * are being replaced/deleted. This means the caller must + * free any old entries somehow, or we end up with a memory + * leak every time setenv() is called. One might think + * one could directly manipulate environ[], like the UNIX code + * above, but direct changes to environ are not allowed when + * calling putenv(), since the RTLs maintain an internal + * *copy* of environ[]. Bad, bad, *bad* stink. + * GSAR 97-06-07 + */ + + if (!value) { + if (!oldstr) + return; + value = ""; + vallen = 0; + } + else + vallen = strlen(val); + envstr = ALLOC_N(char, namelen + vallen + 3); + sprintf(envstr,"%s=%s",name,value); + putenv(envstr); + if (oldstr) free(oldstr); +#ifdef _MSC_VER + free(envstr); /* MSVCRT leaks without this */ +#endif + +#else /* !USE_WIN32_RTL_ENV */ + + /* The sane way to deal with the environment. + * Has these advantages over putenv() & co.: + * * enables us to store a truly empty value in the + * environment (like in UNIX). + * * we don't have to deal with RTL globals, bugs and leaks. + * * Much faster. + * Why you may want to enable USE_WIN32_RTL_ENV: + * * environ[] and RTL functions will not reflect changes, + * which might be an issue if extensions want to access + * the env. via RTL. This cuts both ways, since RTL will + * not see changes made by extensions that call the Win32 + * functions directly, either. + * GSAR 97-06-07 + */ + SetEnvironmentVariable(name,value); +#endif + +#else /* WIN32 */ + + register int i=envix(name); /* where does it go? */ + + if (environ == origenviron) { /* need we copy environment? */ + int j; + int max; + char **tmpenv; + + for (max = i; environ[max]; max++) ; + tmpenv = ALLOC_N(char*, max+2); + for (j=0; j<max; j++) /* copy environment */ + tmpenv[j] = strdup(environ[j]); + tmpenv[max] = 0; + environ = tmpenv; /* tell exec where it is now */ + } + if (!value) { + while (environ[i]) { + environ[i] = environ[i+1]; + i++; + } + return; + } + if (!environ[i]) { /* does not exist yet */ + REALLOC_N(environ, char*, i+2); /* just expand it a bit */ + environ[i+1] = 0; /* make sure it's null terminated */ + } + else { + free(environ[i]); + } + environ[i] = ALLOC_N(char, strlen(name) + strlen(value) + 2); +#ifndef MSDOS + sprintf(environ[i],"%s=%s",name,value); /* all that work just for this */ +#else + /* MS-DOS requires environment variable names to be in uppercase */ + /* [Tom Dinger, 27 August 1990: Well, it doesn't _require_ it, but + * some utilities and applications may break because they only look + * for upper case strings. (Fixed strupr() bug here.)] + */ + strcpy(environ[i],name); strupr(environ[i]); + sprintf(environ[i] + strlen(name),"=%s", value); +#endif /* MSDOS */ + +#endif /* WIN32 */ +} + static VALUE -f_setenv(obj, name, value) - VALUE obj, name, value; +rb_f_setenv(obj, nm, val) + VALUE obj, nm, val; { + char *name, *value; + int nlen, vlen; + if (rb_safe_level() >= 4) { - extern VALUE eSecurityError; - Raise(eSecurityError, "cannot change environment variable"); + rb_raise(rb_eSecurityError, "cannot change environment variable"); } - Check_SafeStr(name); - if (NIL_P(value)) { - env_delete(obj, name); + if (NIL_P(val)) { + env_delete(obj, nm); return Qnil; } - Check_SafeStr(value); - if (strlen(RSTRING(name)->ptr) != RSTRING(name)->len) - ArgError("Bad environment name"); - if (strlen(RSTRING(value)->ptr) != RSTRING(value)->len) - ArgError("Bad environment value"); + name = str2cstr(nm, &nlen); + value = STR2CSTR(val &vlen); + if (strlen(name) != nlen) + rb_raise(rb_eArgError, "Bad environment name"); + if (strlen(value) != vlen) + rb_raise(rb_eArgError, "Bad environment value"); - setenv(RSTRING(name)->ptr, RSTRING(value)->ptr, 1); - if (strcmp(RSTRING(name)->ptr, "PATH") == 0) { - char *p, pend; - - if (str_tainted(value)) { + my_setenv(name, value); + if (strcmp(name, "PATH") == 0) { + if (OBJ_TAINTED(val)) { /* already tainted, no check */ path_tainted = 1; - return TRUE; + return Qtrue; + } + else { + path_tainted_p(value); } - - path_check(RSTRING(name)->ptr); } - return TRUE; + return Qtrue; } static VALUE env_keys() { char **env; - VALUE ary = ary_new(); + VALUE ary = rb_ary_new(); env = environ; while (*env) { char *s = strchr(*env, '='); - ary_push(ary, str_taint(str_new(*env, s-*env))); + if (s) { + rb_ary_push(ary, rb_tainted_str_new(*env, s-*env)); + } env++; } return ary; @@ -906,19 +1153,31 @@ static VALUE env_each_key(hash) VALUE hash; { - return ary_each(env_keys()); + char **env; + + env = environ; + while (*env) { + char *s = strchr(*env, '='); + if (s) { + rb_yield(rb_tainted_str_new(*env, s-*env)); + } + env++; + } + return Qnil; } static VALUE env_values() { char **env; - VALUE ary = ary_new(); + VALUE ary = rb_ary_new(); env = environ; while (*env) { char *s = strchr(*env, '='); - ary_push(ary, str_taint(str_new2(s+1))); + if (s) { + rb_ary_push(ary, rb_tainted_str_new2(s+1)); + } env++; } return ary; @@ -928,38 +1187,53 @@ static VALUE env_each_value(hash) VALUE hash; { - return ary_each(env_values()); + char **env; + + env = environ; + while (*env) { + char *s = strchr(*env, '='); + if (s) { + rb_yield(rb_tainted_str_new2(s+1)); + } + env++; + } + return Qnil; } static VALUE env_each(hash) VALUE hash; { - VALUE ary = env_keys(); - VALUE *ptr = RARRAY(ary)->ptr; - int len = RARRAY(ary)->len; + char **env; - while (len--) { - VALUE val = f_getenv(Qnil, *ptr); - if (!NIL_P(val)) { - rb_yield(assoc_new(*ptr, val)); + env = environ; + while (*env) { + char *s = strchr(*env, '='); + if (s) { + rb_yield(rb_assoc_new(rb_tainted_str_new(*env, s-*env), + rb_tainted_str_new2(s+1))); } - ptr++; + env++; } - return hash; + return Qnil; } static VALUE env_delete_if() { - VALUE ary = env_keys(); - VALUE *ptr = RARRAY(ary)->ptr; - int len = RARRAY(ary)->len; + volatile VALUE keys; + VALUE *ptr; + int len; + + rb_secure(4); + keys = env_keys(); + ptr = RARRAY(keys)->ptr; + len = RARRAY(keys)->len; while (len--) { - VALUE val = f_getenv(Qnil, *ptr); + VALUE val = rb_f_getenv(Qnil, *ptr); if (!NIL_P(val)) { - if (RTEST(rb_yield(assoc_new(*ptr, val)))) { + if (RTEST(rb_yield(rb_assoc_new(*ptr, val)))) { env_delete(Qnil, *ptr); } } @@ -971,20 +1245,22 @@ env_delete_if() static VALUE env_to_s() { - return str_new2("ENV"); + return rb_str_new2("ENV"); } static VALUE env_to_a() { char **env; - VALUE ary = ary_new(); + VALUE ary = rb_ary_new(); env = environ; while (*env) { char *s = strchr(*env, '='); - ary_push(ary, assoc_new(str_taint(str_new(*env, s-*env)), - str_taint(str_new2(s+1)))); + if (s) { + rb_ary_push(ary, rb_assoc_new(rb_tainted_str_new(*env, s-*env), + rb_tainted_str_new2(s+1))); + } env++; } return ary; @@ -1009,17 +1285,17 @@ env_size() static VALUE env_empty_p() { - if (environ[0] == 0) return TRUE; - return FALSE; + if (environ[0] == 0) return Qtrue; + return Qfalse; } static VALUE env_has_key(env, key) VALUE env, key; { - if (TYPE(key) != T_STRING) return FALSE; - if (getenv(RSTRING(key)->ptr)) return TRUE; - return FALSE; + if (TYPE(key) != T_STRING) return Qfalse; + if (getenv(STR2CSTR(key))) return Qtrue; + return Qfalse; } static VALUE @@ -1027,18 +1303,20 @@ env_has_value(dmy, value) VALUE dmy, value; { char **env; - VALUE ary; + volatile VALUE ary; - if (TYPE(value) != T_STRING) return FALSE; - ary = ary_new(); + if (TYPE(value) != T_STRING) return Qfalse; + ary = rb_ary_new(); env = environ; while (*env) { char *s = strchr(*env, '=')+1; - int len = strlen(s); - if (strncmp(s, RSTRING(value)->ptr, len) == 0) return TRUE; + if (s) { + if (strncmp(s, RSTRING(value)->ptr, strlen(s)) == 0) + return Qtrue; + } env++; } - return FALSE; + return Qfalse; } static VALUE @@ -1047,7 +1325,7 @@ env_indexes(argc, argv) VALUE *argv; { int i; - VALUE indexes = ary_new2(argc); + VALUE indexes = rb_ary_new2(argc); for (i=0;i<argc;i++) { char *v = 0; @@ -1055,7 +1333,7 @@ env_indexes(argc, argv) v = getenv(RSTRING(argv[i])->ptr); } if (v) { - RARRAY(indexes)->ptr[i] = str_new2(v); + RARRAY(indexes)->ptr[i] = rb_tainted_str_new2(v); } else { RARRAY(indexes)->ptr[i] = Qnil; @@ -1066,65 +1344,94 @@ env_indexes(argc, argv) return indexes; } -void -Init_Hash() +static VALUE +env_to_hash(obj) + VALUE obj; { - extern VALUE mEnumerable; - - hash = rb_intern("hash"); - - cHash = rb_define_class("Hash", cObject); - - rb_include_module(cHash, mEnumerable); - - rb_define_singleton_method(cHash, "new", hash_s_new, -1); - rb_define_singleton_method(cHash, "[]", hash_s_create, -1); - - rb_define_method(cHash,"clone", hash_clone, 0); - rb_define_method(cHash,"dup", hash_dup, 0); - rb_define_method(cHash,"rehash", hash_rehash, 0); - - rb_define_method(cHash,"freeze", hash_freeze, 0); - rb_define_method(cHash,"frozen?",hash_frozen_p, 0); - - rb_define_method(cHash,"to_a", hash_to_a, 0); - rb_define_method(cHash,"to_s", hash_to_s, 0); - rb_define_method(cHash,"inspect", hash_inspect, 0); - - rb_define_method(cHash,"==", hash_equal, 1); - rb_define_method(cHash,"[]", hash_aref, 1); - rb_define_method(cHash,"[]=", hash_aset, 2); - rb_define_method(cHash,"indexes", hash_indexes, -1); - rb_define_method(cHash,"length", hash_length, 0); - rb_define_alias(cHash, "size", "length"); - rb_define_method(cHash,"empty?", hash_empty_p, 0); - - rb_define_method(cHash,"each", hash_each_pair, 0); - rb_define_method(cHash,"each_value", hash_each_value, 0); - rb_define_method(cHash,"each_key", hash_each_key, 0); - rb_define_method(cHash,"each_pair", hash_each_pair, 0); - - rb_define_method(cHash,"keys", hash_keys, 0); - rb_define_method(cHash,"values", hash_values, 0); + char **env; + VALUE hash = rb_hash_new(); - rb_define_method(cHash,"shift", hash_shift, 0); - rb_define_method(cHash,"delete", hash_delete, 1); - rb_define_method(cHash,"delete_if", hash_delete_if, 0); - rb_define_method(cHash,"clear", hash_clear, 0); - rb_define_method(cHash,"invert", hash_invert, 0); - rb_define_method(cHash,"update", hash_update, 1); + env = environ; + while (*env) { + char *s = strchr(*env, '='); + if (s) { + rb_hash_aset(hash, rb_tainted_str_new(*env, s-*env), + rb_tainted_str_new2(s+1)); + } + env++; + } + return hash; +} - rb_define_method(cHash,"include?", hash_has_key, 1); - rb_define_method(cHash,"has_key?", hash_has_key, 1); - rb_define_method(cHash,"has_value?", hash_has_value, 1); - rb_define_method(cHash,"key?", hash_has_key, 1); - rb_define_method(cHash,"value?", hash_has_value, 1); +#endif /* ifndef __MACOS__ no environment variables on MacOS. */ - envtbl = obj_alloc(cObject); - rb_extend_object(envtbl, mEnumerable); +void +Init_Hash() +{ + hash = rb_intern("hash"); - rb_define_singleton_method(envtbl,"[]", f_getenv, 1); - rb_define_singleton_method(envtbl,"[]=", f_setenv, 2); + rb_cHash = rb_define_class("Hash", rb_cObject); + + rb_include_module(rb_cHash, rb_mEnumerable); + + rb_define_singleton_method(rb_cHash, "new", rb_hash_s_new, -1); + rb_define_singleton_method(rb_cHash, "[]", rb_hash_s_create, -1); + + rb_define_method(rb_cHash,"clone", rb_hash_clone, 0); + rb_define_method(rb_cHash,"dup", rb_hash_dup, 0); + rb_define_method(rb_cHash,"rehash", rb_hash_rehash, 0); + + rb_define_method(rb_cHash,"freeze", rb_hash_freeze, 0); + rb_define_method(rb_cHash,"frozen?",rb_hash_frozen_p, 0); + + rb_define_method(rb_cHash,"to_hash", rb_hash_to_hash, 0); + rb_define_method(rb_cHash,"to_a", rb_hash_to_a, 0); + rb_define_method(rb_cHash,"to_s", rb_hash_to_s, 0); + rb_define_method(rb_cHash,"inspect", rb_hash_inspect, 0); + + rb_define_method(rb_cHash,"==", rb_hash_equal, 1); + rb_define_method(rb_cHash,"[]", rb_hash_aref, 1); + rb_define_method(rb_cHash,"fetch", rb_hash_fetch, -1); + rb_define_method(rb_cHash,"[]=", rb_hash_aset, 2); + rb_define_method(rb_cHash,"store", rb_hash_aset, 2); + rb_define_method(rb_cHash,"default", rb_hash_default, 0); + rb_define_method(rb_cHash,"default=", rb_hash_set_default, 1); + rb_define_method(rb_cHash,"indexes", rb_hash_indexes, -1); + rb_define_method(rb_cHash,"indices", rb_hash_indexes, -1); + rb_define_method(rb_cHash,"length", rb_hash_length, 0); + rb_define_alias(rb_cHash, "size", "length"); + rb_define_method(rb_cHash,"empty?", rb_hash_empty_p, 0); + + rb_define_method(rb_cHash,"each", rb_hash_each_pair, 0); + rb_define_method(rb_cHash,"each_value", rb_hash_each_value, 0); + rb_define_method(rb_cHash,"each_key", rb_hash_each_key, 0); + rb_define_method(rb_cHash,"each_pair", rb_hash_each_pair, 0); + rb_define_method(rb_cHash,"sort", rb_hash_sort, 0); + + rb_define_method(rb_cHash,"keys", rb_hash_keys, 0); + rb_define_method(rb_cHash,"values", rb_hash_values, 0); + + rb_define_method(rb_cHash,"shift", rb_hash_shift, 0); + rb_define_method(rb_cHash,"delete", rb_hash_delete, 1); + rb_define_method(rb_cHash,"delete_if", rb_hash_delete_if, 0); + rb_define_method(rb_cHash,"clear", rb_hash_clear, 0); + rb_define_method(rb_cHash,"invert", rb_hash_invert, 0); + rb_define_method(rb_cHash,"update", rb_hash_update, 1); + rb_define_method(rb_cHash,"replace", rb_hash_replace, 1); + + rb_define_method(rb_cHash,"include?", rb_hash_has_key, 1); + rb_define_method(rb_cHash,"has_key?", rb_hash_has_key, 1); + rb_define_method(rb_cHash,"has_value?", rb_hash_has_value, 1); + rb_define_method(rb_cHash,"key?", rb_hash_has_key, 1); + rb_define_method(rb_cHash,"value?", rb_hash_has_value, 1); + +#ifndef __MACOS__ /* environment variables nothing on MacOS. */ + origenviron = environ; + envtbl = rb_obj_alloc(rb_cObject); + rb_extend_object(envtbl, rb_mEnumerable); + + rb_define_singleton_method(envtbl,"[]", rb_f_getenv, 1); + rb_define_singleton_method(envtbl,"[]=", rb_f_setenv, 2); rb_define_singleton_method(envtbl,"each", env_each, 0); rb_define_singleton_method(envtbl,"each_pair", env_each, 0); rb_define_singleton_method(envtbl,"each_key", env_each_key, 0); @@ -1135,6 +1442,7 @@ Init_Hash() rb_define_singleton_method(envtbl,"rehash", env_none, 0); rb_define_singleton_method(envtbl,"to_a", env_to_a, 0); rb_define_singleton_method(envtbl,"indexes", env_indexes, -1); + rb_define_singleton_method(envtbl,"indices", env_indexes, -1); rb_define_singleton_method(envtbl,"length", env_size, 0); rb_define_singleton_method(envtbl,"empty?", env_empty_p, 0); rb_define_singleton_method(envtbl,"keys", env_keys, 0); @@ -1144,6 +1452,11 @@ Init_Hash() rb_define_singleton_method(envtbl,"has_value?", env_has_value, 1); rb_define_singleton_method(envtbl,"key?", env_has_key, 1); rb_define_singleton_method(envtbl,"value?", env_has_value, 1); + rb_define_singleton_method(envtbl,"to_hash", env_to_hash, 0); rb_define_global_const("ENV", envtbl); +#else /* __MACOS__ */ + envtbl = rb_hash_s_new(0, NULL, rb_cHash); + rb_define_global_const("ENV", envtbl); +#endif /* ifndef __MACOS__ environment variables nothing on MacOS. */ } |