mirror of
https://github.com/mruby/mruby
synced 2026-06-08 16:11:16 +00:00
Remove commented out code.
This commit is contained in:
@@ -29,7 +29,6 @@ mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str)
|
||||
return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str);
|
||||
}
|
||||
|
||||
//mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr);
|
||||
/*
|
||||
* call-seq:
|
||||
* Exception.new(msg = nil) -> exception
|
||||
@@ -307,14 +306,6 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr)
|
||||
case 3:
|
||||
n = 1;
|
||||
exception_call:
|
||||
//if (argv[0] == sysstack_error) return argv[0];
|
||||
|
||||
//CONST_ID(mrb, exception, "exception");
|
||||
//mesg = mrb_check_funcall(mrb, argv[0], exception, n, argv+1);
|
||||
//if (mrb_nil_p(mesg)) {
|
||||
// /* undef */
|
||||
// mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
|
||||
//}
|
||||
if (mrb_respond_to(mrb, argv[0], mrb_intern(mrb, "exception"))) {
|
||||
mesg = mrb_funcall_argv(mrb, argv[0], "exception", n, argv+1);
|
||||
}
|
||||
|
||||
@@ -52,11 +52,6 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty
|
||||
mrb_value
|
||||
mrb_lastline_get(mrb_state *mrb)
|
||||
{
|
||||
//mrb_value *var = mrb_svar(0);
|
||||
//if (var) {
|
||||
// return *var;
|
||||
//}
|
||||
//return mrb_nil_value();
|
||||
mrb_value *argv;
|
||||
int argc;
|
||||
|
||||
|
||||
+4
-4
@@ -1339,9 +1339,9 @@ mrb_init_hash(mrb_state *mrb)
|
||||
mrb_define_method(mrb, h, "default_proc", mrb_hash_default_proc,ARGS_NONE()); /* 15.2.13.4.7 */
|
||||
mrb_define_method(mrb, h, "default_proc=", mrb_hash_set_default_proc,ARGS_REQ(1)); /* 15.2.13.4.7 */
|
||||
mrb_define_method(mrb, h, "__delete", mrb_hash_delete, ARGS_REQ(1)); /* core of 15.2.13.4.8 */
|
||||
//mrb_define_method(mrb, h, "each", mrb_hash_each_pair, ARGS_NONE()); /* 15.2.13.4.9 */ /* move to mrblib\hash.rb */
|
||||
//mrb_define_method(mrb, h, "each_key", mrb_hash_each_key, ARGS_NONE()); /* 15.2.13.4.10 */ /* move to mrblib\hash.rb */
|
||||
//mrb_define_method(mrb, h, "each_value", mrb_hash_each_value, ARGS_NONE()); /* 15.2.13.4.11 */ /* move to mrblib\hash.rb */
|
||||
// "each" 15.2.13.4.9 move to mrblib/hash.rb
|
||||
// "each_key" 15.2.13.4.10 move to mrblib/hash.rb
|
||||
// "each_value" 15.2.13.4.11 move to mrblib/hash.rb
|
||||
mrb_define_method(mrb, h, "empty?", mrb_hash_empty_p, ARGS_NONE()); /* 15.2.13.4.12 */
|
||||
mrb_define_method(mrb, h, "has_key?", mrb_hash_has_key, ARGS_REQ(1)); /* 15.2.13.4.13 */
|
||||
mrb_define_method(mrb, h, "has_value?", mrb_hash_has_value, ARGS_REQ(1)); /* 15.2.13.4.14 */
|
||||
@@ -1352,7 +1352,7 @@ mrb_init_hash(mrb_state *mrb)
|
||||
mrb_define_method(mrb, h, "keys", mrb_hash_keys, ARGS_NONE()); /* 15.2.13.4.19 */
|
||||
mrb_define_method(mrb, h, "length", mrb_hash_size_m, ARGS_NONE()); /* 15.2.13.4.20 */
|
||||
mrb_define_method(mrb, h, "member?", mrb_hash_has_key, ARGS_REQ(1)); /* 15.2.13.4.21 */
|
||||
//mrb_define_method(mrb, h, "merge", mrb_hash_merge, ARGS_REQ(1)); /* 15.2.13.4.22 */ /* move to mrblib\hash.rb */
|
||||
// "merge" 15.2.13.4.22 move to mrblib/hash.rb
|
||||
mrb_define_method(mrb, h, "replace", mrb_hash_replace, ARGS_REQ(1)); /* 15.2.13.4.23 */
|
||||
mrb_define_method(mrb, h, "shift", mrb_hash_shift, ARGS_NONE()); /* 15.2.13.4.24 */
|
||||
mrb_define_method(mrb, h, "size", mrb_hash_size_m, ARGS_NONE()); /* 15.2.13.4.25 */
|
||||
|
||||
+20
-56
@@ -72,9 +72,6 @@ inspect_obj(mrb_state *mrb, mrb_value obj, mrb_value str, int recur)
|
||||
int
|
||||
mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
|
||||
{
|
||||
//const mrb_method_entry_t *me = mrb_method_entry(CLASS_OF(obj), mrb_intern("to_s"));
|
||||
//if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC &&
|
||||
//me->def->body.cfunc.func == mrb_any_to_s)
|
||||
struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern(mrb, "to_s"));
|
||||
if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s))
|
||||
return 1;
|
||||
@@ -314,52 +311,38 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
|
||||
{
|
||||
struct RClass *klass = RBASIC(obj)->c;
|
||||
|
||||
//if (!FL_TEST(klass, FL_SINGLETON))
|
||||
//return klass;
|
||||
if (klass->tt != MRB_TT_SCLASS)
|
||||
return klass;
|
||||
else {
|
||||
//struct clone_method_data data;
|
||||
/* copy singleton(unnamed) class */
|
||||
//VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
|
||||
/* copy singleton(unnamed) class */
|
||||
struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
|
||||
//clone->super = objklass->super;
|
||||
|
||||
if ((mrb_type(obj) == MRB_TT_CLASS) ||
|
||||
(mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
|
||||
clone->c = clone;
|
||||
}
|
||||
else {
|
||||
clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
|
||||
}
|
||||
if ((mrb_type(obj) == MRB_TT_CLASS) ||
|
||||
(mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */
|
||||
clone->c = clone;
|
||||
}
|
||||
else {
|
||||
clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
|
||||
}
|
||||
|
||||
clone->super = klass->super;
|
||||
if (klass->iv) {
|
||||
clone->iv = klass->iv;
|
||||
}
|
||||
if (klass->mt) {
|
||||
clone->mt = kh_copy(mt, mrb, klass->mt);
|
||||
}
|
||||
else {
|
||||
clone->mt = kh_init(mt, mrb);
|
||||
}
|
||||
clone->tt = MRB_TT_SCLASS;
|
||||
return clone;
|
||||
clone->super = klass->super;
|
||||
if (klass->iv) {
|
||||
clone->iv = klass->iv;
|
||||
}
|
||||
if (klass->mt) {
|
||||
clone->mt = kh_copy(mt, mrb, klass->mt);
|
||||
}
|
||||
else {
|
||||
clone->mt = kh_init(mt, mrb);
|
||||
}
|
||||
clone->tt = MRB_TT_SCLASS;
|
||||
return clone;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
|
||||
{
|
||||
//if (OBJ_FROZEN(dest)) {
|
||||
// rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest));
|
||||
//}
|
||||
//RBASIC(dest)->flags &= ~(T_MASK|FL_EXIVAR);
|
||||
//RBASIC(dest)->flags |= RBASIC(obj)->flags & (T_MASK|FL_EXIVAR|FL_TAINT);
|
||||
//if (FL_TEST(obj, FL_EXIVAR)) {
|
||||
// mrb_copy_generic_ivar(dest, obj);
|
||||
//}
|
||||
//mrb_gc_copy_finalizer(dest, obj);
|
||||
switch (mrb_type(obj)) {
|
||||
case MRB_TT_OBJECT:
|
||||
case MRB_TT_CLASS:
|
||||
@@ -416,8 +399,6 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self)
|
||||
clone = (struct RObject*)mrb_obj_alloc(mrb, self.tt, mrb_obj_class(mrb, self));
|
||||
clone->c = mrb_singleton_class_clone(mrb, self);
|
||||
init_copy(mrb, mrb_obj_value(clone), self);
|
||||
//1-9-2 no bug mrb_funcall(mrb, clone, "initialize_clone", 1, self);
|
||||
//RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;
|
||||
|
||||
return mrb_obj_value(clone);
|
||||
}
|
||||
@@ -466,7 +447,6 @@ mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
|
||||
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
|
||||
}
|
||||
for (i = 0; i < argc; i++) {
|
||||
//Check_Type(argv[i], T_MODULE);
|
||||
mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
|
||||
}
|
||||
while (argc--) {
|
||||
@@ -511,19 +491,6 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
|
||||
return mrb_obj_extend(mrb, argc, argv, self);
|
||||
}
|
||||
|
||||
/* 15.3.1.2.4 */
|
||||
/* 15.3.1.3.14 */
|
||||
/*
|
||||
* call-seq:
|
||||
* global_variables -> array
|
||||
*
|
||||
* Returns an array of the names of global variables.
|
||||
*
|
||||
* global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
|
||||
*/
|
||||
//mrb_value
|
||||
//mrb_f_global_variables(mrb_state *mrb, mrb_value self)
|
||||
|
||||
/* 15.3.1.3.15 */
|
||||
/*
|
||||
* call-seq:
|
||||
@@ -824,7 +791,6 @@ mrb_obj_singleton_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value o
|
||||
recur = mrb_true_value();
|
||||
}
|
||||
else {
|
||||
//mrb_scan_args(argc, argv, "01", &recur);
|
||||
recur = argv[0];
|
||||
}
|
||||
klass = mrb_class(mrb, obj);
|
||||
@@ -853,7 +819,6 @@ retry:
|
||||
else {
|
||||
mrb_value recur;
|
||||
|
||||
//mrb_scan_args(argc, argv, "1", &recur);
|
||||
recur = argv[0];
|
||||
if (mrb_test(recur)) {
|
||||
argc = 0;
|
||||
@@ -1073,7 +1038,6 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
|
||||
mrb_sym id;
|
||||
|
||||
mrb_get_args(mrb, "*", &argv, &argc);
|
||||
//mrb_scan_args(argc, argv, "11", &mid, &priv);
|
||||
mid = argv[0];
|
||||
if (argc > 1) priv = argv[1];
|
||||
else priv = mrb_nil_value();
|
||||
|
||||
@@ -516,7 +516,6 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
|
||||
mrb_value v;
|
||||
|
||||
if (FIXNUM_P(val)) return val;
|
||||
//if (TYPE(val) == T_BIGNUM) return val;
|
||||
v = convert_type(mrb, val, "Integer", method, TRUE);
|
||||
if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) {
|
||||
const char *cname = mrb_obj_classname(mrb, val);
|
||||
|
||||
@@ -412,7 +412,6 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy)
|
||||
mrb_get_args(mrb, "o", &src);
|
||||
|
||||
if (mrb_obj_equal(mrb, copy, src)) return copy;
|
||||
//mrb_check_frozen(copy);
|
||||
if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
|
||||
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
|
||||
}
|
||||
|
||||
@@ -1354,7 +1354,6 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang)
|
||||
static mrb_value
|
||||
mrb_str_gsub(mrb_state *mrb, mrb_value self)
|
||||
{
|
||||
//return str_gsub(argc, argv, self, 0);
|
||||
return str_gsub(mrb, self, 0);
|
||||
}
|
||||
|
||||
@@ -1469,10 +1468,8 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
|
||||
int argc;
|
||||
|
||||
mrb_value sub;
|
||||
//mrb_value initpos;
|
||||
mrb_int pos;
|
||||
|
||||
//if (mrb_scan_args(argc, argv, "11", &sub, &initpos) == 2) {
|
||||
mrb_get_args(mrb, "*", &argv, &argc);
|
||||
if (argc == 2) {
|
||||
pos = mrb_fixnum(argv[1]);
|
||||
@@ -1959,7 +1956,6 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start)
|
||||
|
||||
if (mrb_reg_search(mrb, pat, str, *start, 0) >= 0) {
|
||||
match = mrb_backref_get(mrb);
|
||||
//regs = RMATCH(match)->regs;
|
||||
pmatch = mrb_match_ptr(match);
|
||||
regs = &pmatch->rmatch->regs;
|
||||
if (regs->beg[0] == regs->end[0]) {
|
||||
@@ -2143,7 +2139,6 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
|
||||
split_type = awk;
|
||||
}
|
||||
else {
|
||||
//fs_set:
|
||||
if (mrb_type(spat) == MRB_TT_STRING) {
|
||||
split_type = string;
|
||||
#ifdef ENABLE_REGEXP
|
||||
@@ -2546,7 +2541,6 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck)
|
||||
if (s) {
|
||||
len = RSTRING_LEN(str);
|
||||
if (s[len]) { /* no sentinel somehow */
|
||||
//char *p = ALLOCA_N(char, len+1);
|
||||
char *p = mrb_malloc(mrb, len+1);
|
||||
|
||||
//MEMCPY(p, s, char, len);
|
||||
@@ -2584,10 +2578,8 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
|
||||
{
|
||||
mrb_value *argv;
|
||||
int argc;
|
||||
//mrb_value b;
|
||||
int base;
|
||||
|
||||
//mrb_scan_args(argc, *argv, "01", &b);
|
||||
mrb_get_args(mrb, "*", &argv, &argc);
|
||||
if (argc == 0)
|
||||
base = 10;
|
||||
@@ -2710,7 +2702,6 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck)
|
||||
static mrb_value
|
||||
mrb_str_to_f(mrb_state *mrb, mrb_value self)
|
||||
{
|
||||
//return mrb_float_new(mrb_str_to_dbl(self, 0/*Qfalse*/));
|
||||
return mrb_float_value(mrb_str_to_dbl(mrb, self, 0/*Qfalse*/));
|
||||
}
|
||||
|
||||
|
||||
@@ -38,8 +38,6 @@ struct_ivar_get(mrb_state *mrb, mrb_value c, mrb_sym id)
|
||||
|
||||
mrb_value ans;
|
||||
for (;;) {
|
||||
//if (mrb_ivar_defined(c, id))
|
||||
// return mrb_iv_get(mrb, c, id);
|
||||
ans = mrb_iv_get(mrb, c, id);
|
||||
if (!mrb_nil_p(ans)) return ans;
|
||||
kclass = RCLASS_SUPER(c);
|
||||
@@ -260,19 +258,15 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k
|
||||
//OBJ_FREEZE(members);
|
||||
if (mrb_nil_p(name)) {
|
||||
c = mrb_class_new(mrb, klass);
|
||||
//mrb_make_metaclass(nstr, RBASIC(klass)->c);
|
||||
//mrb_class_inherited(klass, nstr);
|
||||
}
|
||||
else {
|
||||
/* old style: should we warn? */
|
||||
name = mrb_str_to_str(mrb, name);
|
||||
id = mrb_to_id(mrb, name);
|
||||
if (!mrb_is_const_id(id)) {
|
||||
//mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name));
|
||||
mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name));
|
||||
}
|
||||
if (mrb_const_defined_at(mrb, klass, id)) {
|
||||
//mrb_warn("redefining constant Struct::%s", StringValuePtr(name));
|
||||
mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name));
|
||||
//?rb_mod_remove_const(klass, mrb_sym2name(mrb, id));
|
||||
}
|
||||
@@ -376,7 +370,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
|
||||
mrb_get_args(mrb, "&*", &b, &argv, &argc);
|
||||
if (argc > 0) name = argv[0];
|
||||
if (argc > 1) rest = argv[1];
|
||||
//mrb_scan_args(argc, argv, "1*", &name, &rest);
|
||||
if (mrb_type(rest) == MRB_TT_ARRAY) {
|
||||
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
|
||||
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
|
||||
@@ -389,7 +382,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
|
||||
argcnt = argc-1;
|
||||
if (!mrb_nil_p(name) && SYMBOL_P(name)) {
|
||||
/* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
|
||||
//mrb_ary_unshift(mrb, rest, name);
|
||||
name = mrb_nil_value();
|
||||
pargv = &argv[0];
|
||||
argcnt++;
|
||||
@@ -557,7 +549,6 @@ mrb_struct_init_copy(mrb_state *mrb, mrb_value copy)
|
||||
mrb_get_args(mrb, "o", &s);
|
||||
|
||||
if (mrb_obj_equal(mrb, copy, s)) return copy;
|
||||
//mrb_check_frozen(copy);
|
||||
if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) {
|
||||
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
|
||||
}
|
||||
|
||||
@@ -460,10 +460,6 @@ kiv_lookup(khash_t(iv)* table, mrb_sym key, mrb_value *value)
|
||||
khash_t(iv) *h=table;
|
||||
khiter_t k;
|
||||
|
||||
// you must check(iv==0), before you call this function.
|
||||
//if (!obj->iv) {
|
||||
// return 0;
|
||||
//}
|
||||
k = kh_get(iv, h, key);
|
||||
if (k != kh_end(h)) {
|
||||
*value = kh_value(h, k);
|
||||
@@ -505,7 +501,6 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
|
||||
mrb_value
|
||||
mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
|
||||
{
|
||||
//return ivar_get(obj, id, FALSE);
|
||||
return mrb_iv_get(mrb, obj, id);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user