diff options
Diffstat (limited to 'hash.c')
| -rw-r--r-- | hash.c | 476 |
1 files changed, 248 insertions, 228 deletions
@@ -25,17 +25,17 @@ char *strchr _((char*,char)); #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"); + rb_raise(rb_eTypeError, "can't modify frozen hash"); } } VALUE -hash_freeze(hash) +rb_hash_freeze(hash) VALUE hash; { FL_SET(hash, HASH_FREEZE); @@ -43,15 +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; } -VALUE cHash; +VALUE rb_cHash; static VALUE envtbl; static ID hash; @@ -64,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; @@ -81,7 +81,7 @@ any_cmp(a, b) } static int -any_hash(a, mod) +rb_any_hash(a, mod) VALUE a; int mod; { @@ -93,7 +93,7 @@ any_hash(a, mod) break; case T_STRING: - hval = str_hash(a); + hval = rb_str_hash(a); break; default: @@ -105,24 +105,25 @@ any_hash(a, mod) ENABLE_INTS; hval = FIX2LONG(hval); } + if (hval < 0) hval = -hval; return hval % mod; } 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; @@ -131,21 +132,21 @@ hash_foreach_iter(key, value, arg) if (key == Qnil) return ST_CONTINUE; status = (*arg->func)(key, value, arg->arg); if (RHASH(arg->hash)->tbl != tbl || RHASH(arg->hash)->tbl->bins != bins){ - IndexError("rehash occurred during iteration"); + 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 (value == Qnil) return ST_DELETE; @@ -153,14 +154,14 @@ hash_delete_nil(key, value) } static VALUE -hash_foreach_ensure(hash) +rb_hash_foreach_ensure(hash) VALUE hash; { RHASH(hash)->iter_lev--; if (RHASH(hash)->iter_lev == 0) { if (FL_TEST(hash, HASH_DELETED)) { - st_foreach(RHASH(hash)->tbl, hash_delete_nil, 0); + st_foreach(RHASH(hash)->tbl, rb_hash_delete_nil, 0); FL_UNSET(hash, HASH_DELETED); } } @@ -168,56 +169,58 @@ hash_foreach_ensure(hash) } 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, hash); + return rb_ensure(rb_hash_foreach_call, (VALUE)&arg, rb_hash_foreach_ensure, hash); } static VALUE -hash_s_new(argc, argv, klass) +rb_hash_s_new(argc, argv, klass) int argc; VALUE *argv; VALUE klass; { - VALUE sz; + VALUE sz, ifnone; int size; NEWOBJ(hash, struct RHash); OBJSETUP(hash, klass, T_HASH); hash->iter_lev = 0; - hash->status = 0; + hash->ifnone = Qnil; hash->tbl = 0; /* avoid GC crashing */ - if (rb_scan_args(argc, argv, "01", &sz) == 0) { + 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); - obj_call_init((VALUE)hash); + rb_obj_call_init((VALUE)hash); return (VALUE)hash; } static VALUE -hash_new2(klass) +rb_hash_new2(klass) VALUE klass; { NEWOBJ(hash, struct RHash); OBJSETUP(hash, klass, T_HASH); hash->iter_lev = 0; - hash->status = 0; + hash->ifnone = Qnil; hash->tbl = 0; /* avoid GC crashing */ hash->tbl = st_init_table(&objhash); @@ -225,13 +228,13 @@ hash_new2(klass) } VALUE -hash_new() +rb_hash_new() { - return hash_new2(cHash); + return rb_hash_new2(rb_cHash); } static VALUE -hash_s_create(argc, argv, klass) +rb_hash_s_create(argc, argv, klass) int argc; VALUE *argv; VALUE klass; @@ -246,36 +249,36 @@ hash_s_create(argc, argv, klass) 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); - obj_call_init((VALUE)hash); + 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(klass); + hash = rb_hash_new2(klass); for (i=0; i<argc; i+=2) { st_insert(RHASH(hash)->tbl, argv[i], argv[i+1]); } - obj_call_init(hash); + 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); @@ -283,14 +286,14 @@ 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); @@ -305,7 +308,7 @@ to_hash(hash) } static int -hash_rehash_i(key, value, tbl) +rb_hash_rehash_i(key, value, tbl) VALUE key, value; st_table *tbl; { @@ -316,13 +319,13 @@ 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; @@ -330,19 +333,19 @@ hash_rehash(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_fetch(argc, argv, hash) +rb_hash_fetch(argc, argv, hash) int argc; VALUE *argv; VALUE hash; @@ -353,9 +356,9 @@ hash_fetch(argc, argv, hash) rb_scan_args(argc, argv, "11", &key, &if_none); if (!st_lookup(RHASH(hash)->tbl, key, &val)) { - if (iterator_p()) { + if (rb_iterator_p()) { if (argc > 1) { - ArgError("wrong # of arguments", argc); + rb_raise(rb_eArgError, "wrong # of arguments", argc); } return rb_yield(argv[0]); } @@ -365,7 +368,15 @@ hash_fetch(argc, argv, hash) } static VALUE -hash_indexes(argc, argv, hash) +rb_hash_default(hash, ifnone) + VALUE hash; +{ + RHASH(hash)->ifnone = ifnone; + return hash; +} + +static VALUE +rb_hash_indexes(argc, argv, hash) int argc; VALUE *argv; VALUE hash; @@ -373,21 +384,21 @@ 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); + rb_hash_modify(hash); if (RHASH(hash)->iter_lev > 0 && st_delete_safe(RHASH(hash)->tbl, &key, &val, Qnil)) { FL_SET(hash, HASH_DELETED); @@ -395,7 +406,7 @@ hash_delete(hash, key) } else if (st_delete(RHASH(hash)->tbl, &key, &val)) return val; - if (iterator_p()) { + if (rb_iterator_p()) { return rb_yield(key); } return Qnil; @@ -421,17 +432,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 @@ -439,17 +450,17 @@ 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 hash; } @@ -462,26 +473,26 @@ 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 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_frozen(key); + key = rb_str_dup_frozen(key); } st_insert(RHASH(hash)->tbl, key, val); return val; @@ -491,35 +502,35 @@ static int replace_i(key, val, hash) VALUE key, val, hash; { - hash_aset(hash, key, val); + rb_hash_aset(hash, key, val); return ST_CONTINUE; } static VALUE -hash_replace(hash, hash2) +rb_hash_replace(hash, hash2) VALUE hash, hash2; { hash2 = to_hash(hash2); - hash_clear(hash); + rb_hash_clear(hash); st_foreach(RHASH(hash2)->tbl, replace_i, hash); return hash; } static VALUE -hash_length(hash) +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 @@ -532,10 +543,10 @@ each_value_i(key, value) } static VALUE -hash_each_value(hash) +rb_hash_each_value(hash) VALUE hash; { - hash_foreach(hash, each_value_i, 0); + rb_hash_foreach(hash, each_value_i, 0); return hash; } @@ -549,10 +560,10 @@ each_key_i(key, value) } static VALUE -hash_each_key(hash) +rb_hash_each_key(hash) VALUE hash; { - hash_foreach(hash, each_key_i, 0); + rb_hash_foreach(hash, each_key_i, 0); return hash; } @@ -561,15 +572,15 @@ 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, 0); + rb_hash_foreach(hash, each_pair_i, 0); return hash; } @@ -578,22 +589,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; @@ -602,39 +620,39 @@ 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) +rb_hash_inspect(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 -hash_to_s(hash) +rb_hash_to_s(hash) VALUE hash; { - return ary_to_s(hash_to_a(hash)); + return rb_ary_to_s(rb_hash_to_a(hash)); } static VALUE -hash_to_hash(hash) +rb_hash_to_hash(hash) VALUE hash; { return hash; @@ -645,17 +663,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; @@ -666,55 +684,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]; } @@ -732,69 +750,69 @@ 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; { hash2 = to_hash(hash2); - st_foreach(RHASH(hash2)->tbl, hash_update_i, hash1); + st_foreach(RHASH(hash2)->tbl, rb_hash_update_i, hash1); return hash1; } @@ -827,7 +845,7 @@ env_delete(obj, name) i++; } if (val) { - return str_new2(val); + return rb_str_new2(val); } return Qnil; } @@ -837,12 +855,12 @@ 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 *nam, *env; @@ -850,13 +868,13 @@ f_getenv(obj, name) nam = str2cstr(name, &len); if (strlen(nam) != len) { - ArgError("Bad environment variable name"); + rb_raise(rb_eArgError, "Bad environment variable name"); } env = getenv(nam); if (env) { - if (strcmp(nam, "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_str_taint(rb_str_new2(env)); } return Qnil; } @@ -913,7 +931,7 @@ path_check(path) } int -env_path_tainted() +rb_env_path_tainted() { if (path_tainted < 0) { path_check(getenv("PATH")); @@ -922,11 +940,11 @@ env_path_tainted() } static VALUE -f_setenv(obj, name, value) +rb_f_setenv(obj, name, value) VALUE obj, name, value; { if (rb_safe_level() >= 4) { - Raise(eSecurityError, "cannot change environment variable"); + rb_raise(rb_eSecurityError, "cannot change environment variable"); } Check_SafeStr(name); @@ -937,33 +955,33 @@ f_setenv(obj, name, value) Check_SafeStr(value); if (strlen(RSTRING(name)->ptr) != RSTRING(name)->len) - ArgError("Bad environment name"); + rb_raise(rb_eArgError, "Bad environment name"); if (strlen(RSTRING(value)->ptr) != RSTRING(value)->len) - ArgError("Bad environment value"); - + rb_raise(rb_eArgError, "Bad environment value"); + setenv(RSTRING(name)->ptr, RSTRING(value)->ptr, 1); if (strcmp(RSTRING(name)->ptr, "PATH") == 0) { - if (str_tainted(value)) { + if (rb_str_tainted(value)) { /* already tainted, no check */ path_tainted = 1; - return TRUE; + return Qtrue; } 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))); + rb_ary_push(ary, rb_str_taint(rb_str_new(*env, s-*env))); env++; } return ary; @@ -973,19 +991,19 @@ static VALUE env_each_key(hash) VALUE hash; { - return ary_each(env_keys()); + return rb_ary_each(env_keys()); } 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))); + rb_ary_push(ary, rb_str_taint(rb_str_new2(s+1))); env++; } return ary; @@ -995,7 +1013,7 @@ static VALUE env_each_value(hash) VALUE hash; { - return ary_each(env_values()); + return rb_ary_each(env_values()); } static VALUE @@ -1007,9 +1025,9 @@ env_each(hash) int len = RARRAY(ary)->len; while (len--) { - VALUE val = f_getenv(Qnil, *ptr); + VALUE val = rb_f_getenv(Qnil, *ptr); if (!NIL_P(val)) { - rb_yield(assoc_new(*ptr, val)); + rb_yield(rb_assoc_new(*ptr, val)); } ptr++; } @@ -1024,9 +1042,9 @@ env_delete_if() int len = RARRAY(ary)->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); } } @@ -1038,20 +1056,20 @@ 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)))); + rb_ary_push(ary, rb_assoc_new(rb_str_taint(rb_str_new(*env, s-*env)), + rb_str_taint(rb_str_new2(s+1)))); env++; } return ary; @@ -1076,17 +1094,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(RSTRING(key)->ptr)) return Qtrue; + return Qfalse; } static VALUE @@ -1096,16 +1114,16 @@ env_has_value(dmy, value) char **env; 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 (strncmp(s, RSTRING(value)->ptr, len) == 0) return Qtrue; env++; } - return FALSE; + return Qfalse; } static VALUE @@ -1114,7 +1132,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; @@ -1122,7 +1140,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_str_new2(v); } else { RARRAY(indexes)->ptr[i] = Qnil; @@ -1137,15 +1155,15 @@ static VALUE env_to_hash(obj) VALUE obj; { - VALUE hash = hash_new(); + VALUE hash = rb_hash_new(); VALUE ary = env_keys(); VALUE *ptr = RARRAY(ary)->ptr; int len = RARRAY(ary)->len; while (len--) { - VALUE val = f_getenv(Qnil, *ptr); + VALUE val = rb_f_getenv(Qnil, *ptr); if (!NIL_P(val)) { - hash_aset(hash, *ptr, val); + rb_hash_aset(hash, *ptr, val); } ptr++; } @@ -1159,64 +1177,66 @@ Init_Hash() { 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_hash", hash_to_hash, 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,"fetch", hash_fetch, -1); - rb_define_method(cHash,"[]=", hash_aset, 2); - rb_define_method(cHash,"store", hash_aset, 2); - rb_define_method(cHash,"indexes", hash_indexes, -1); - rb_define_method(cHash,"indices", 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); - - 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); - rb_define_method(cHash,"replace", hash_replace, 1); - - 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); + 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, 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. */ - envtbl = obj_alloc(cObject); - rb_extend_object(envtbl, mEnumerable); + envtbl = rb_obj_alloc(rb_cObject); + rb_extend_object(envtbl, rb_mEnumerable); - rb_define_singleton_method(envtbl,"[]", f_getenv, 1); - rb_define_singleton_method(envtbl,"[]=", f_setenv, 2); + 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); @@ -1241,7 +1261,7 @@ Init_Hash() rb_define_global_const("ENV", envtbl); #else /* __MACOS__ */ - envtbl = hash_s_new(0, NULL, cHash); + envtbl = rb_hash_s_new(0, NULL, rb_cHash); rb_define_global_const("ENV", envtbl); #endif /* ifndef __MACOS__ environment variables nothing on MacOS. */ } |