From e65d4938f373132f2ab5c75533e0bd18e188f9bc Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 2 Jun 2012 17:25:18 +0900 Subject: 'mrb_sym' used as 'uint32_t'. it's broken portability; based on the work from @crimsonwoods; close #216 --- src/class.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index b13ab2288..9424e8d84 100644 --- a/src/class.c +++ b/src/class.c @@ -17,8 +17,8 @@ #include "mruby/khash.h" -KHASH_MAP_INIT_INT(mt, struct RProc*); -KHASH_MAP_INIT_INT(iv, mrb_value); +KHASH_INIT(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal) +KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) typedef struct fc_result { mrb_sym name; -- cgit v1.2.3 From 8a41d646f1a801372e03928ae3e6bfea973fe6ed Mon Sep 17 00:00:00 2001 From: Yuichiro MASUI Date: Sat, 2 Jun 2012 23:40:10 +0900 Subject: support Class.new() --- src/class.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 9424e8d84..fa6adaf28 100644 --- a/src/class.c +++ b/src/class.c @@ -806,6 +806,20 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv) return obj; } +mrb_value +mrb_class_new_class(mrb_state *mrb, mrb_value cv) +{ + mrb_value super; + if(mrb->ci->argc > 0) { + mrb_get_args(mrb, "o", &super); + } + else { + super = mrb_obj_value(mrb->object_class); + } + struct RClass *new_class = mrb_class_new(mrb, mrb_class_ptr(super)); + return mrb_obj_value(new_class); +} + static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value cv) { @@ -1226,6 +1240,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, bob, "initialize", mrb_bob_init, ARGS_NONE()); mrb_define_method(mrb, bob, "!", mrb_bob_not, ARGS_NONE()); mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, ARGS_ANY()); /* 15.3.1.3.30 */ + mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, ARGS_ANY()); mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1)); mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); -- cgit v1.2.3 From 5fcd520514095fa9bbb31d2e7eca192b1be7dfc2 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 02:19:12 +0900 Subject: small refactoring after mruby coding convention --- src/class.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index fa6adaf28..544f36527 100644 --- a/src/class.c +++ b/src/class.c @@ -810,13 +810,12 @@ mrb_value mrb_class_new_class(mrb_state *mrb, mrb_value cv) { mrb_value super; - if(mrb->ci->argc > 0) { - mrb_get_args(mrb, "o", &super); - } - else { + struct RClass *new_class; + + if (mrb_get_args(mrb, "|o", &super) == 0) { super = mrb_obj_value(mrb->object_class); } - struct RClass *new_class = mrb_class_new(mrb, mrb_class_ptr(super)); + new_class = mrb_class_new(mrb, mrb_class_ptr(super)); return mrb_obj_value(new_class); } -- cgit v1.2.3 From df80b7835a5d99e2f5a25446abb53ea3e68e7709 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 08:20:48 +0900 Subject: Add Class#superclass; a patch made by @bovi; close #234 --- src/class.c | 10 ++++++++++ test/t/class.rb | 5 +++++ 2 files changed, 15 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 544f36527..748996e62 100644 --- a/src/class.c +++ b/src/class.c @@ -819,6 +819,15 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv) return mrb_obj_value(new_class); } +mrb_value +mrb_class_superclass(mrb_state *mrb, mrb_value klass) +{ + struct RClass *c, *s; + c = mrb_class_ptr(klass); + s = c->super; + return mrb_obj_value(s); +} + static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value cv) { @@ -1240,6 +1249,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, bob, "!", mrb_bob_not, ARGS_NONE()); mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, ARGS_ANY()); /* 15.3.1.3.30 */ mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, ARGS_ANY()); + mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1)); mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); diff --git a/test/t/class.rb b/test/t/class.rb index 92f3df51d..cb056feff 100644 --- a/test/t/class.rb +++ b/test/t/class.rb @@ -5,6 +5,11 @@ assert('Class', '15.2.3') do Class.class == Class end +assert('Class#superclass', '15.2.3.3.4') do + class SubClass < String; end + SubClass.superclass == String +end + # Not ISO specified assert('Class 1') do -- cgit v1.2.3 From 7009a1d8f5271fcd0b06a86645ad28e40c2bc5d9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 23:26:40 +0900 Subject: should not disclose metaclass; close #238 --- src/class.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 748996e62..c689552f5 100644 --- a/src/class.c +++ b/src/class.c @@ -824,7 +824,7 @@ mrb_class_superclass(mrb_state *mrb, mrb_value klass) { struct RClass *c, *s; c = mrb_class_ptr(klass); - s = c->super; + s = mrb_class_real(c->super); return mrb_obj_value(s); } -- cgit v1.2.3 From 5612d195ec39612b7216ff3f28d05ed089452767 Mon Sep 17 00:00:00 2001 From: Daniel Bovensiepen Date: Sun, 3 Jun 2012 23:29:40 +0800 Subject: Improve Class#superclass to ISO --- src/class.c | 12 +++++++++--- test/t/class.rb | 10 +++++++--- 2 files changed, 16 insertions(+), 6 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index c689552f5..594ed08bc 100644 --- a/src/class.c +++ b/src/class.c @@ -822,10 +822,16 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv) mrb_value mrb_class_superclass(mrb_state *mrb, mrb_value klass) { - struct RClass *c, *s; + struct RClass *c; + mrb_value superclass; + c = mrb_class_ptr(klass); - s = mrb_class_real(c->super); - return mrb_obj_value(s); + if (c->super) + superclass = mrb_obj_value(mrb_class_real(c->super)); + else + superclass = mrb_nil_value(); + + return superclass; } static mrb_value diff --git a/test/t/class.rb b/test/t/class.rb index d252cf590..1b809a832 100644 --- a/test/t/class.rb +++ b/test/t/class.rb @@ -5,9 +5,8 @@ assert('Class', '15.2.3') do Class.class == Class end -assert('Class#superclass', '15.2.3.3.4') do - class SubClass < String; end - SubClass.superclass == String +assert('Class superclass', '15.2.3.2') do + Class.superclass == Module end assert('Class#new', '15.2.3.3.3') do @@ -40,6 +39,11 @@ assert('Class#new', '15.2.3.3.3') do # with block doesn't work yet end +assert('Class#superclass', '15.2.3.3.4') do + class SubClass < String; end + SubClass.superclass == String +end + # Not ISO specified assert('Class 1') do -- cgit v1.2.3 From e3d17e54f83d442e72a18be26425f58ad6d51078 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 5 Jun 2012 23:17:09 +0900 Subject: mruby/string.h: rename buf to ptr --- include/mruby/string.h | 8 ++-- src/class.c | 8 ++-- src/gc.c | 2 +- src/object.c | 6 +-- src/print.c | 2 +- src/string.c | 124 ++++++++++++++++++++++++------------------------- src/symbol.c | 8 ++-- 7 files changed, 79 insertions(+), 79 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby/string.h b/include/mruby/string.h index 91a59d92d..1449a2edf 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -27,7 +27,7 @@ extern const char mrb_digitmap[]; struct mrb_shared_string { int refcnt; - char *buf; + char *ptr; int len; }; @@ -38,15 +38,15 @@ struct RString { int capa; struct mrb_shared_string *shared; } aux; - char *buf; + char *ptr; }; #define mrb_str_ptr(s) ((struct RString*)((s).value.p)) #define RSTRING(s) ((struct RString*)((s).value.p)) -#define RSTRING_PTR(s) (RSTRING(s)->buf) +#define RSTRING_PTR(s) (RSTRING(s)->ptr) #define RSTRING_LEN(s) (RSTRING(s)->len) #define RSTRING_CAPA(s) (RSTRING(s)->aux.capa) -#define RSTRING_END(s) (RSTRING(s)->buf + RSTRING(s)->len) +#define RSTRING_END(s) (RSTRING(s)->ptr + RSTRING(s)->len) #define MRB_STR_SHARED 256 void mrb_str_decref(mrb_state*, struct mrb_shared_string*); diff --git a/src/class.c b/src/class.c index 594ed08bc..554f98550 100644 --- a/src/class.c +++ b/src/class.c @@ -449,7 +449,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) ss = to_str(mrb, *sp); s = mrb_str_ptr(ss); ps = va_arg(ap, char**); - *ps = s->buf; + *ps = s->ptr; pl = va_arg(ap, int*); *pl = s->len; i++; sp++; @@ -463,11 +463,11 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) ss = to_str(mrb, *sp); s = mrb_str_ptr(ss); - if (strlen(s->buf) != s->len) { + if (strlen(s->ptr) != s->len) { mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL"); } ps = va_arg(ap, char**); - *ps = s->buf; + *ps = s->ptr; i++; sp++; } break; @@ -959,7 +959,7 @@ mrb_class_name(mrb_state *mrb, struct RClass* c) { mrb_value path = mrb_class_path(mrb, c); if (mrb_nil_p(path)) return 0; - return mrb_str_ptr(path)->buf; + return mrb_str_ptr(path)->ptr; } const char* diff --git a/src/gc.c b/src/gc.c index b7c08de65..247c1ad85 100644 --- a/src/gc.c +++ b/src/gc.c @@ -472,7 +472,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj) if (obj->flags & MRB_STR_SHARED) mrb_str_decref(mrb, ((struct RString*)obj)->aux.shared); else - mrb_free(mrb, ((struct RString*)obj)->buf); + mrb_free(mrb, ((struct RString*)obj)->ptr); break; case MRB_TT_RANGE: diff --git a/src/object.c b/src/object.c index 81e3867a7..817137d8e 100644 --- a/src/object.c +++ b/src/object.c @@ -433,7 +433,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t) } else if (mrb_special_const_p(x)) { s = mrb_str_ptr(mrb_obj_as_string(mrb, x)); - etype = s->buf; + etype = s->ptr; } else { etype = mrb_obj_classname(mrb, x); @@ -471,8 +471,8 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj) str = mrb_str_new(mrb, 0, len); /* 6:tags 16:addr */ s = mrb_str_ptr(str); // snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj); - sprintf(s->buf, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); - s->len = strlen(s->buf); + sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); + s->len = strlen(s->ptr); return str; } diff --git a/src/print.c b/src/print.c index e6873913b..e27a723dc 100644 --- a/src/print.c +++ b/src/print.c @@ -17,7 +17,7 @@ printstr(mrb_state *mrb, mrb_value obj) if (mrb_type(obj) == MRB_TT_STRING) { str = mrb_str_ptr(obj); - s = str->buf; + s = str->ptr; len = str->len; while (len--) { putc(*s, stdout); diff --git a/src/string.c b/src/string.c index 805b52a28..e955b3f22 100644 --- a/src/string.c +++ b/src/string.c @@ -39,7 +39,7 @@ static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len); #define RESIZE_CAPA(s,capacity) do {\ - s->buf = mrb_realloc(mrb, s->buf, (capacity)+1);\ + s->ptr = mrb_realloc(mrb, s->ptr, (capacity)+1);\ s->aux.capa = capacity;\ } while (0) @@ -48,7 +48,7 @@ mrb_str_decref(mrb_state *mrb, struct mrb_shared_string *shared) { shared->refcnt--; if (shared->refcnt == 0) { - mrb_free(mrb, shared->buf); + mrb_free(mrb, shared->ptr); mrb_free(mrb, shared); } } @@ -59,8 +59,8 @@ str_modify(mrb_state *mrb, struct RString *s) if (s->flags & MRB_STR_SHARED) { struct mrb_shared_string *shared = s->aux.shared; - if (shared->refcnt == 1 && s->buf == shared->buf) { - s->buf = shared->buf; + if (shared->refcnt == 1 && s->ptr == shared->ptr) { + s->ptr = shared->ptr; s->aux.capa = shared->len; mrb_free(mrb, shared); } @@ -68,14 +68,14 @@ str_modify(mrb_state *mrb, struct RString *s) char *ptr, *p; long len; - p = s->buf; + p = s->ptr; len = s->len; ptr = mrb_malloc(mrb, len+1); if (p) { memcpy(ptr, p, len); } ptr[len] = 0; - s->buf = ptr; + s->ptr = ptr; s->aux.capa = len; mrb_str_decref(mrb, shared); } @@ -93,11 +93,11 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len) slen = s->len; if (len != slen) { if (slen < len || slen -len > 1024) { - s->buf = mrb_realloc(mrb, s->buf, len+1); + s->ptr = mrb_realloc(mrb, s->ptr, len+1); } s->aux.capa = len; s->len = len; - s->buf[len] = '\0'; /* sentinel */ + s->ptr[len] = '\0'; /* sentinel */ } return str; } @@ -107,7 +107,7 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len) { struct RString *s = mrb_str_ptr(str); - if (s->buf != p || s->len != len) { + if (s->ptr != p || s->len != len) { mrb_raise(mrb, mrb->eRuntimeError_class, "string modified"); } } @@ -122,7 +122,7 @@ str_alloc(mrb_state *mrb, struct RClass *c) s = mrb_obj_alloc_string(mrb); s->c = c; - s->buf = 0; + s->ptr = 0; s->len = 0; s->aux.capa = 0; @@ -143,11 +143,11 @@ str_new(mrb_state *mrb, const char *p, int len) s->len = len; s->aux.capa = len; - s->buf = mrb_malloc(mrb, len+1); + s->ptr = mrb_malloc(mrb, len+1); if (p) { - memcpy(s->buf, p, len); + memcpy(s->ptr, p, len); } - s->buf[len] = '\0'; + s->ptr[len] = '\0'; return s; } @@ -178,8 +178,8 @@ mrb_str_buf_new(mrb_state *mrb, int capa) } s->len = 0; s->aux.capa = capa; - s->buf = mrb_malloc(mrb, capa+1); - s->buf[0] = '\0'; + s->ptr = mrb_malloc(mrb, capa+1); + s->ptr[0] = '\0'; return mrb_obj_value(s); } @@ -190,8 +190,8 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) long capa, total, off = -1; str_modify(mrb, s); - if (ptr >= s->buf && ptr <= s->buf + s->len) { - off = ptr - s->buf; + if (ptr >= s->ptr && ptr <= s->ptr + s->len) { + off = ptr - s->ptr; } if (len == 0) return; capa = s->aux.capa; @@ -210,11 +210,11 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) RESIZE_CAPA(s, capa); } if (off != -1) { - ptr = s->buf + off; + ptr = s->ptr + off; } - memcpy(s->buf + s->len, ptr, len); + memcpy(s->ptr + s->len, ptr, len); s->len = total; - s->buf[total] = '\0'; /* sentinel */ + s->ptr[total] = '\0'; /* sentinel */ } mrb_value @@ -257,9 +257,9 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) int len = strlen(p); s = mrb_obj_alloc_string(mrb); - s->buf = mrb_malloc(mrb, len+1); - memcpy(s->buf, p, len); - s->buf[len] = 0; + s->ptr = mrb_malloc(mrb, len+1); + memcpy(s->ptr, p, len); + s->ptr[len] = 0; s->len = len; s->aux.capa = len; @@ -274,10 +274,10 @@ str_make_shared(mrb_state *mrb, struct RString *s) shared->refcnt = 1; if (s->aux.capa > s->len) { - s->buf = shared->buf = mrb_realloc(mrb, s->buf, s->len+1); + s->ptr = shared->ptr = mrb_realloc(mrb, s->ptr, s->len+1); } else { - shared->buf = s->buf; + shared->ptr = s->ptr; } shared->len = s->len; s->aux.shared = shared; @@ -305,7 +305,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str) } shared = orig->aux.shared; shared->refcnt++; - s->buf = shared->buf; + s->ptr = shared->ptr; s->len = shared->len; s->aux.shared = shared; s->flags |= MRB_STR_SHARED; @@ -325,7 +325,7 @@ mrb_str_body(mrb_value str, int *len_p) struct RString *s = mrb_str_ptr(str); *len_p = s->len; - return s->buf; + return s->ptr; } /* @@ -349,11 +349,11 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other) if (s1->aux.capa < len) { s1->aux.capa = len; - s1->buf = mrb_realloc(mrb, s1->buf, len+1); + s1->ptr = mrb_realloc(mrb, s1->ptr, len+1); } - memcpy(s1->buf+s1->len, s2->buf, s2->len); + memcpy(s1->ptr+s1->len, s2->ptr, s2->len); s1->len = len; - s1->buf[len] = 0; + s1->ptr[len] = 0; } /* @@ -370,8 +370,8 @@ mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b) struct RString *t; t = str_new(mrb, 0, s->len + s2->len); - memcpy(t->buf, s->buf, s->len); - memcpy(t->buf + s->len, s2->buf, s2->len); + memcpy(t->ptr, s->ptr, s->len); + memcpy(t->ptr + s->len, s2->ptr, s2->len); return mrb_obj_value(t); } @@ -446,7 +446,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self) len = RSTRING_LEN(self)*times; str2 = str_new(mrb, 0, len); str_with_class(mrb, str2, self); - p = str2->buf; + p = str2->ptr; if (len > 0) { n = RSTRING_LEN(self); memcpy(p, RSTRING_PTR(self), n); @@ -481,7 +481,7 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2) struct RString *s2 = mrb_str_ptr(str2); len = lesser(s1->len, s2->len); - retval = memcmp(s1->buf, s2->buf, len); + retval = memcmp(s1->ptr, s2->ptr, len); if (retval == 0) { if (s1->len == s2->len) return 0; if (s1->len > s2->len) return 1; @@ -725,7 +725,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str) /* should return shared string */ struct RString *s = mrb_str_ptr(str); - return mrb_str_new(mrb, s->buf, s->len); + return mrb_str_new(mrb, s->ptr, s->len); } static mrb_value @@ -871,8 +871,8 @@ mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str) struct RString *s = mrb_str_ptr(str); str_modify(mrb, s); - if (s->len == 0 || !s->buf) return mrb_nil_value(); - p = s->buf; pend = s->buf + s->len; + if (s->len == 0 || !s->ptr) return mrb_nil_value(); + p = s->ptr; pend = s->ptr + s->len; if (ISLOWER(*p)) { *p = toupper(*p); modify = 1; @@ -931,14 +931,14 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str) if (mrb_get_args(mrb, "|S", &rs) == 0) { if (len == 0) return mrb_nil_value(); smart_chomp: - if (s->buf[len-1] == '\n') { + if (s->ptr[len-1] == '\n') { s->len--; if (s->len > 0 && - s->buf[s->len-1] == '\r') { + s->ptr[s->len-1] == '\r') { s->len--; } } - else if (s->buf[len-1] == '\r') { + else if (s->ptr[len-1] == '\r') { s->len--; } else { @@ -948,7 +948,7 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str) } if (len == 0 || mrb_nil_p(rs)) return mrb_nil_value(); - p = s->buf; + p = s->ptr; rslen = RSTRING_LEN(rs); if (rslen == 0) { while (len>0 && p[len-1] == '\n') { @@ -1028,14 +1028,14 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str) if (s->len > 0) { int len; len = s->len - 1; - if (s->buf[len] == '\n') { + if (s->ptr[len] == '\n') { if (len > 0 && - s->buf[len-1] == '\r') { + s->ptr[len-1] == '\r') { len--; } } s->len = len; - s->buf[len] = '\0'; + s->ptr[len] = '\0'; return str; } return mrb_nil_value(); @@ -1083,8 +1083,8 @@ mrb_str_downcase_bang(mrb_state *mrb, mrb_value str) struct RString *s = mrb_str_ptr(str); str_modify(mrb, s); - p = s->buf; - pend = s->buf + s->len; + p = s->ptr; + pend = s->ptr + s->len; while (p < pend) { if (ISUPPER(*p)) { *p = tolower(*p); @@ -1206,7 +1206,7 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) str_make_shared(mrb, s); shared = s->aux.shared; s = mrb_obj_alloc_string(mrb); - s->buf = shared->buf + beg; + s->ptr = shared->ptr + beg; s->len = len; s->aux.shared = shared; s->flags |= MRB_STR_SHARED; @@ -1391,7 +1391,7 @@ mrb_str_hash(mrb_state *mrb, mrb_value str) /* 1-8-7 */ struct RString *s = mrb_str_ptr(str); long len = s->len; - char *p = s->buf; + char *p = s->ptr; mrb_int key = 0; while (len--) { @@ -1555,7 +1555,7 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) { if (s2->flags & MRB_STR_SHARED) { L_SHARE: - s1->buf = s2->buf; + s1->ptr = s2->ptr; s1->len = s2->len; s1->aux.shared = s2->aux.shared; s1->flags |= MRB_STR_SHARED; @@ -1567,13 +1567,13 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) else { if (s1->flags & MRB_STR_SHARED) { mrb_str_decref(mrb, s1->aux.shared); - s1->buf = mrb_malloc(mrb, s2->len+1); + s1->ptr = mrb_malloc(mrb, s2->len+1); } else { - s1->buf = mrb_realloc(mrb, s1->buf, s2->len+1); + s1->ptr = mrb_realloc(mrb, s1->ptr, s2->len+1); } - memcpy(s1->buf, s2->buf, s2->len); - s1->buf[s2->len] = 0; + memcpy(s1->ptr, s2->ptr, s2->len); + s1->ptr[s2->len] = 0; s1->len = s2->len; s2->aux.capa = s2->len; } @@ -1754,7 +1754,7 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str) s2 = str_new(mrb, 0, RSTRING(str)->len); str_with_class(mrb, s2, str); s = RSTRING_PTR(str); e = RSTRING_END(str) - 1; - p = s2->buf; + p = s2->ptr; while (e >= s) { *p++ = *e--; @@ -1778,7 +1778,7 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str) str_modify(mrb, s); if (s->len > 1) { - p = s->buf; + p = s->ptr; e = p + s->len - 1; while (p < e) { c = *p; @@ -1820,13 +1820,13 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) if (ps->len - pos < len) { pos = ps->len - len; } - sbeg = ps->buf; - s = ps->buf + pos; - t = psub->buf; + sbeg = ps->ptr; + s = ps->ptr + pos; + t = psub->ptr; if (len) { while (sbeg <= s) { if (memcmp(s, t, len) == 0) { - return s - ps->buf; + return s - ps->ptr; } s--; } @@ -2028,7 +2028,7 @@ mrb_str_scan(mrb_state *mrb, mrb_value str) mrb_int start = 0; mrb_value match = mrb_nil_value(); struct RString *ps = mrb_str_ptr(str); - char *p = ps->buf; + char *p = ps->ptr; long len = ps->len; mrb_get_args(mrb, "o&", &pat, &b); @@ -2513,7 +2513,7 @@ char * mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr) { struct RString *ps = mrb_str_ptr(*ptr); - char *s = ps->buf; + char *s = ps->ptr; if (!s || ps->len != strlen(s)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); @@ -2820,7 +2820,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) result = str_new(mrb, 0, len); str_with_class(mrb, result, str); p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); - q = result->buf; + q = result->ptr; *q++ = '"'; while (p < pend) { diff --git a/src/symbol.c b/src/symbol.c index 6754325a5..2658b35dc 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -331,11 +331,11 @@ sym_inspect(mrb_state *mrb, mrb_value sym) name = mrb_sym2name_len(mrb, id, &len); str = mrb_str_new(mrb, 0, len+1); - RSTRING(str)->buf[0] = ':'; - memcpy(RSTRING(str)->buf+1, name, len); + RSTRING(str)->ptr[0] = ':'; + memcpy(RSTRING(str)->ptr+1, name, len); if (!symname_p(name) || strlen(name) != len) { str = mrb_str_dump(mrb, str); - strncpy(RSTRING(str)->buf, ":\"", 2); + strncpy(RSTRING(str)->ptr, ":\"", 2); } return str; } @@ -352,7 +352,7 @@ mrb_sym2name(mrb_state *mrb, mrb_sym sym) } else { mrb_value str = mrb_str_dump(mrb, mrb_str_new(mrb, name, len)); - return RSTRING(str)->buf; + return RSTRING(str)->ptr; } } -- cgit v1.2.3 From 4c01f002fdd234aa0a03f1eeb3c216b9638ea170 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 5 Jun 2012 23:20:36 +0900 Subject: mruby/array.h: rename buf to ptr --- include/mruby/array.h | 6 +-- src/array.c | 126 +++++++++++++++++++++++++------------------------- src/class.c | 4 +- src/gc.c | 4 +- src/vm.c | 18 ++++---- 5 files changed, 79 insertions(+), 79 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby/array.h b/include/mruby/array.h index c6c35a4e4..f42146f3e 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -13,7 +13,7 @@ extern "C" { struct mrb_shared_array { int refcnt; - mrb_value *buf; + mrb_value *ptr; int len; }; @@ -24,7 +24,7 @@ struct RArray { int capa; struct mrb_shared_array *shared; } aux; - mrb_value *buf; + mrb_value *ptr; }; #define mrb_ary_ptr(v) ((struct RArray*)((v).value.p)) @@ -32,7 +32,7 @@ struct RArray { #define RARRAY(v) ((struct RArray*)((v).value.p)) #define RARRAY_LEN(a) (RARRAY(a)->len) -#define RARRAY_PTR(a) (RARRAY(a)->buf) +#define RARRAY_PTR(a) (RARRAY(a)->ptr) #define MRB_ARY_SHARED 256 void mrb_ary_decref(mrb_state*, struct mrb_shared_array*); diff --git a/src/array.c b/src/array.c index 8f2e4824e..2403a783d 100644 --- a/src/array.c +++ b/src/array.c @@ -46,8 +46,8 @@ ary_new_capa(mrb_state *mrb, int capa) } a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); - a->buf = mrb_malloc(mrb, blen); - memset(a->buf, 0, blen); + a->ptr = mrb_malloc(mrb, blen); + memset(a->ptr, 0, blen); a->aux.capa = capa; a->len = 0; @@ -75,7 +75,7 @@ mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals) ary = mrb_ary_new_capa(mrb, size); a = mrb_ary_ptr(ary); - memcpy(a->buf, vals, sizeof(mrb_value)*size); + memcpy(a->ptr, vals, sizeof(mrb_value)*size); a->len = size; return ary; @@ -91,12 +91,12 @@ mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr) } static void -ary_fill_with_nil(mrb_value *buf, int size) +ary_fill_with_nil(mrb_value *ptr, int size) { mrb_value nil = mrb_nil_value(); while((int)(size--)) { - *buf++ = nil; + *ptr++ = nil; } } @@ -106,8 +106,8 @@ ary_modify(mrb_state *mrb, struct RArray *a) if (a->flags & MRB_ARY_SHARED) { struct mrb_shared_array *shared = a->aux.shared; - if (shared->refcnt == 1 && a->buf == shared->buf) { - a->buf = shared->buf; + if (shared->refcnt == 1 && a->ptr == shared->ptr) { + a->ptr = shared->ptr; a->aux.capa = a->len; mrb_free(mrb, shared); } @@ -115,13 +115,13 @@ ary_modify(mrb_state *mrb, struct RArray *a) mrb_value *ptr, *p; int len; - p = a->buf; + p = a->ptr; len = a->len * sizeof(mrb_value); ptr = mrb_malloc(mrb, len); if (p) { memcpy(ptr, p, len); } - a->buf = ptr; + a->ptr = ptr; a->aux.capa = len; mrb_ary_decref(mrb, shared); } @@ -137,10 +137,10 @@ ary_make_shared(mrb_state *mrb, struct RArray *a) shared->refcnt = 1; if (a->aux.capa > a->len) { - a->buf = shared->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*a->len+1); + a->ptr = shared->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1); } else { - shared->buf = a->buf; + shared->ptr = a->ptr; } shared->len = a->len; a->aux.shared = shared; @@ -174,7 +174,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, int len) if (capa > a->aux.capa) { a->aux.capa = capa; - a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa); + a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); } } @@ -196,7 +196,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a) if (capa > a->len && capa < a->aux.capa) { a->aux.capa = capa; - a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa); + a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); } } @@ -211,13 +211,13 @@ mrb_ary_s_create(mrb_state *mrb, mrb_value self) } static void -ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, int blen) +ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *ptr, int blen) { int len = a->len + blen; ary_modify(mrb, a); if (a->aux.capa < len) ary_expand_capa(mrb, a, len); - memcpy(a->buf+a->len, buf, sizeof(mrb_value)*blen); + memcpy(a->ptr+a->len, ptr, sizeof(mrb_value)*blen); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; } @@ -227,17 +227,17 @@ mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other) { struct RArray *a2 = mrb_ary_ptr(other); - ary_concat(mrb, mrb_ary_ptr(self), a2->buf, a2->len); + ary_concat(mrb, mrb_ary_ptr(self), a2->ptr, a2->len); } mrb_value mrb_ary_concat_m(mrb_state *mrb, mrb_value self) { - mrb_value *buf; + mrb_value *ptr; int blen; - mrb_get_args(mrb, "a", &buf, &blen); - ary_concat(mrb, mrb_ary_ptr(self), buf, blen); + mrb_get_args(mrb, "a", &ptr, &blen); + ary_concat(mrb, mrb_ary_ptr(self), ptr, blen); return self; } @@ -247,14 +247,14 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self) struct RArray *a1 = mrb_ary_ptr(self); struct RArray *a2; mrb_value ary; - mrb_value *buf; + mrb_value *ptr; int blen; - mrb_get_args(mrb, "a", &buf, &blen); + mrb_get_args(mrb, "a", &ptr, &blen); ary = mrb_ary_new_capa(mrb, a1->len + blen); a2 = mrb_ary_ptr(ary); - memcpy(a2->buf, a1->buf, sizeof(mrb_value)*a1->len); - memcpy(a2->buf + a1->len, buf, sizeof(mrb_value)*blen); + memcpy(a2->ptr, a1->ptr, sizeof(mrb_value)*a1->len); + memcpy(a2->ptr + a1->len, ptr, sizeof(mrb_value)*blen); a2->len = a1->len + blen; return ary; @@ -289,7 +289,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1) mrb_get_args(mrb, "o", &ary2); if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_nil_value(); a1 = RARRAY(ary1); a2 = RARRAY(ary2); - if (a1->len == a2->len && a1->buf == a2->buf) return mrb_fixnum_value(0); + if (a1->len == a2->len && a1->ptr == a2->ptr) return mrb_fixnum_value(0); else { len = RARRAY_LEN(ary1); if (len > RARRAY_LEN(ary2)) { @@ -310,7 +310,7 @@ ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len) ary_modify(mrb, a); if (a->aux.capa < len) ary_expand_capa(mrb, a, len); - memcpy(a->buf, argv, sizeof(mrb_value)*len); + memcpy(a->ptr, argv, sizeof(mrb_value)*len); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; } @@ -320,7 +320,7 @@ mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other) { struct RArray *a2 = mrb_ary_ptr(other); - ary_replace(mrb, mrb_ary_ptr(self), a2->buf, a2->len); + ary_replace(mrb, mrb_ary_ptr(self), a2->ptr, a2->len); } mrb_value @@ -340,7 +340,7 @@ mrb_ary_times(mrb_state *mrb, mrb_value self) struct RArray *a1 = mrb_ary_ptr(self); struct RArray *a2; mrb_value ary; - mrb_value *buf; + mrb_value *ptr; mrb_int times; mrb_get_args(mrb, "i", ×); @@ -351,10 +351,10 @@ mrb_ary_times(mrb_state *mrb, mrb_value self) ary = mrb_ary_new_capa(mrb, a1->len * times); a2 = mrb_ary_ptr(ary); - buf = a2->buf; + ptr = a2->ptr; while(times--) { - memcpy(buf, a1->buf, sizeof(mrb_value)*(a1->len)); - buf += a1->len; + memcpy(ptr, a1->ptr, sizeof(mrb_value)*(a1->len)); + ptr += a1->len; a2->len += a1->len; } @@ -369,8 +369,8 @@ mrb_ary_reverse_bang(mrb_state *mrb, mrb_value self) if (a->len > 1) { mrb_value *p1, *p2; - p1 = a->buf; - p2 = a->buf + a->len - 1; + p1 = a->ptr; + p2 = a->ptr + a->len - 1; while(p1 < p2) { mrb_value tmp = *p1; @@ -392,9 +392,9 @@ mrb_ary_reverse(mrb_state *mrb, mrb_value self) if (a->len > 0) { mrb_value *p1, *p2, *e; - p1 = a->buf; + p1 = a->ptr; e = p1 + a->len; - p2 = b->buf + a->len - 1; + p2 = b->ptr + a->len - 1; while(p1 < e) { *p2-- = *p1++; } @@ -431,7 +431,7 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) /* mrb_ary_push */ ary_modify(mrb, a); if (a->len == a->aux.capa) ary_expand_capa(mrb, a, a->len + 1); - a->buf[a->len++] = elem; + a->ptr[a->len++] = elem; mrb_write_barrier(mrb, (struct RBasic*)a); } @@ -455,7 +455,7 @@ mrb_ary_pop(mrb_state *mrb, mrb_value ary) struct RArray *a = mrb_ary_ptr(ary); if (a->len == 0) return mrb_nil_value(); - return a->buf[--a->len]; + return a->ptr[--a->len]; } #define ARY_SHIFT_SHARED_MIN 10 @@ -469,8 +469,8 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self) if (a->len == 0) return mrb_nil_value(); if (a->flags & MRB_ARY_SHARED) { L_SHIFT: - val = a->buf[0]; - a->buf++; + val = a->ptr[0]; + a->ptr++; a->len--; return val; } @@ -479,13 +479,13 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self) goto L_SHIFT; } else { - mrb_value *buf = a->buf; + mrb_value *ptr = a->ptr; int size = a->len; - val = *buf; + val = *ptr; while((int)(--size)) { - *buf = *(buf+1); - ++buf; + *ptr = *(ptr+1); + ++ptr; } --a->len; } @@ -504,8 +504,8 @@ mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item) ary_modify(mrb, a); if (a->aux.capa < a->len + 1) ary_expand_capa(mrb, a, a->len + 1); - memmove(a->buf + 1, a->buf, sizeof(mrb_value)*a->len); - memcpy(a->buf, &item, sizeof(mrb_value)); + memmove(a->ptr + 1, a->ptr, sizeof(mrb_value)*a->len); + memcpy(a->ptr, &item, sizeof(mrb_value)); a->len += 1; mrb_write_barrier(mrb, (struct RBasic*)a); @@ -524,8 +524,8 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self) if (len == 0) return self; if (a->aux.capa < a->len + len) ary_expand_capa(mrb, a, a->len + len); - memmove(a->buf + len, a->buf, sizeof(mrb_value)*a->len); - memcpy(a->buf, vals, sizeof(mrb_value)*len); + memmove(a->ptr + len, a->ptr, sizeof(mrb_value)*a->len); + memcpy(a->ptr, vals, sizeof(mrb_value)*len); a->len += len; mrb_write_barrier(mrb, (struct RBasic*)a); @@ -541,7 +541,7 @@ mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n) if (n < 0) n += a->len; if (n < 0 || a->len <= (int)n) return mrb_nil_value(); - return a->buf[n]; + return a->ptr[n]; } void @@ -558,11 +558,11 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s if (a->len <= (int)n) { if (a->aux.capa <= (int)n) ary_expand_capa(mrb, a, n + 1); - ary_fill_with_nil(a->buf + a->len, n + 1 - a->len); + ary_fill_with_nil(a->ptr + a->len, n + 1 - a->len); a->len = n + 1; } - a->buf[n] = val; + a->ptr[n] = val; mrb_write_barrier(mrb, (struct RBasic*)a); } @@ -600,14 +600,14 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val ary_expand_capa(mrb, a, size); if (head > a->len) { - ary_fill_with_nil(a->buf + a->len, (int)(head - a->len)); + ary_fill_with_nil(a->ptr + a->len, (int)(head - a->len)); } else if (head < a->len) { - memmove(a->buf + head + argc, a->buf + tail, sizeof(mrb_value)*(a->len - tail)); + memmove(a->ptr + head + argc, a->ptr + tail, sizeof(mrb_value)*(a->len - tail)); } for(i = 0; i < argc; i++) { - *(a->buf + head + i) = *(argv + i); + *(a->ptr + head + i) = *(argv + i); } a->len = size; @@ -626,7 +626,7 @@ mrb_ary_decref(mrb_state *mrb, struct mrb_shared_array *shared) { shared->refcnt--; if (shared->refcnt == 0) { - mrb_free(mrb, shared->buf); + mrb_free(mrb, shared->ptr); mrb_free(mrb, shared); } } @@ -638,7 +638,7 @@ ary_subseq(mrb_state *mrb, struct RArray *a, int beg, int len) ary_make_shared(mrb, a); b = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); - b->buf = a->buf + beg; + b->ptr = a->ptr + beg; b->len = len; b->aux.shared = a->aux.shared; b->aux.shared->refcnt++; @@ -714,20 +714,20 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self) struct RArray *a = mrb_ary_ptr(self); mrb_int index; mrb_value val; - mrb_value *buf; + mrb_value *ptr; int len; mrb_get_args(mrb, "i", &index); if (index < 0) index += a->len; if (index < 0 || a->len <= (int)index) return mrb_nil_value(); - val = a->buf[index]; + val = a->ptr[index]; - buf = a->buf + index; + ptr = a->ptr + index; len = a->len - index; while((int)(--len)) { - *buf = *(buf+1); - ++buf; + *ptr = *(ptr+1); + ++ptr; } --a->len; @@ -743,14 +743,14 @@ mrb_ary_first(mrb_state *mrb, mrb_value self) int size; if (mrb_get_args(mrb, "|i", &size) == 0) { - return (a->len > 0)? a->buf[0]: mrb_nil_value(); + return (a->len > 0)? a->ptr[0]: mrb_nil_value(); } if (size > a->len) size = a->len; if (a->flags & MRB_ARY_SHARED) { return ary_subseq(mrb, a, 0, size); } - return mrb_ary_new_from_values(mrb, size, a->buf); + return mrb_ary_new_from_values(mrb, size, a->ptr); } mrb_value @@ -766,7 +766,7 @@ mrb_ary_last(mrb_state *mrb, mrb_value self) mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments"); } - if (len == 0) return (a->len > 0)? a->buf[a->len - 1]: mrb_nil_value(); + if (len == 0) return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value(); /* len == 1 */ size = mrb_fixnum(*vals); @@ -774,7 +774,7 @@ mrb_ary_last(mrb_state *mrb, mrb_value self) if ((a->flags & MRB_ARY_SHARED) || size > ARY_DEFAULT_LEN) { return ary_subseq(mrb, a, a->len - size, size); } - return mrb_ary_new_from_values(mrb, size, a->buf + a->len - size); + return mrb_ary_new_from_values(mrb, size, a->ptr + a->len - size); } mrb_value diff --git a/src/class.c b/src/class.c index 554f98550..b49ce00f8 100644 --- a/src/class.c +++ b/src/class.c @@ -389,7 +389,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) struct RArray *a = mrb_ary_ptr(mrb->stack[1]); argc = a->len; - sp = a->buf; + sp = a->ptr; } while ((c = *format++)) { switch (c) { @@ -481,7 +481,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) aa = to_ary(mrb, *sp); a = mrb_ary_ptr(aa); pb = va_arg(ap, mrb_value**); - *pb = a->buf; + *pb = a->ptr; pl = va_arg(ap, int*); *pl = a->len; i++; sp++; diff --git a/src/gc.c b/src/gc.c index 247c1ad85..6d22bf275 100644 --- a/src/gc.c +++ b/src/gc.c @@ -367,7 +367,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj) size_t i, e; for (i=0,e=a->len; ibuf[i]); + mrb_gc_mark_value(mrb, a->ptr[i]); } } break; @@ -460,7 +460,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj) if (obj->flags & MRB_ARY_SHARED) mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared); else - mrb_free(mrb, ((struct RArray*)obj)->buf); + mrb_free(mrb, ((struct RArray*)obj)->ptr); break; case MRB_TT_HASH: diff --git a/src/vm.c b/src/vm.c index 4f6deb877..f74315fb2 100644 --- a/src/vm.c +++ b/src/vm.c @@ -899,17 +899,17 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) if (stack[m1].tt == MRB_TT_ARRAY) { struct RArray *ary = mrb_ary_ptr(stack[m1]); - pp = ary->buf; + pp = ary->ptr; len = ary->len; } regs[a] = mrb_ary_new_capa(mrb, m1+len+m2); rest = mrb_ary_ptr(regs[a]); - memcpy(rest->buf, stack, sizeof(mrb_value)*m1); + memcpy(rest->ptr, stack, sizeof(mrb_value)*m1); if (len > 0) { - memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len); + memcpy(rest->ptr+m1, pp, sizeof(mrb_value)*len); } if (m2 > 0) { - memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2); + memcpy(rest->ptr+m1+len, stack+m1+1, sizeof(mrb_value)*m2); } rest->len = m1+len+m2; } @@ -936,7 +936,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) if (argc < 0) { struct RArray *ary = mrb_ary_ptr(regs[1]); - argv = ary->buf; + argv = ary->ptr; argc = ary->len; regs[len+2] = regs[1]; /* save argary in register */ } @@ -950,7 +950,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) } else if (len > 1 && argc == 1 && argv[0].tt == MRB_TT_ARRAY) { argc = mrb_ary_ptr(argv[0])->len; - argv = mrb_ary_ptr(argv[0])->buf; + argv = mrb_ary_ptr(argv[0])->ptr; } mrb->ci->argc = len; if (argc < len) { @@ -1398,15 +1398,15 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) int i; if (len > pre + post) { - regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre); + regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->ptr+pre); while (post--) { - regs[a++] = ary->buf[len-post-1]; + regs[a++] = ary->ptr[len-post-1]; } } else { regs[a++] = mrb_ary_new_capa(mrb, 0); for (i=0; i+prebuf[pre+i]; + regs[a+i] = ary->ptr[pre+i]; } while (i < post) { SET_NIL_VALUE(regs[a+i]); -- cgit v1.2.3 From 216a846bd9b6c0fa192ec9b3381e1a9143a180f2 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 18:32:05 +0900 Subject: mrb_get_args should honor optinal arguments --- src/class.c | 149 ++++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 84 insertions(+), 65 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index b49ce00f8..914785120 100644 --- a/src/class.c +++ b/src/class.c @@ -396,8 +396,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) case '|': case '*': case '&': break; default: - if (argc <= i) { - if (opt) continue; + if (argc <= i && !opt) { mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments"); } } @@ -408,8 +407,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_value *p; p = va_arg(ap, mrb_value*); - *p = *sp; - i++; sp++; + if (i < argc) { + *p = *sp++; + i++; + } } break; case 'S': @@ -417,8 +418,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_value *p; p = va_arg(ap, mrb_value*); - *p = to_str(mrb, *sp); - i++; sp++; + if (i < argc) { + *p = to_str(mrb, *sp++); + i++; + } } break; case 'A': @@ -426,8 +429,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_value *p; p = va_arg(ap, mrb_value*); - *p = to_ary(mrb, *sp); - i++; sp++; + if (i < argc) { + *p = to_ary(mrb, *sp++); + i++; + } } break; case 'H': @@ -435,8 +440,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_value *p; p = va_arg(ap, mrb_value*); - *p = to_hash(mrb, *sp); - i++; sp++; + if (i < argc) { + *p = to_hash(mrb, *sp++); + i++; + } } break; case 's': @@ -446,13 +453,15 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) char **ps = 0; int *pl = 0; - ss = to_str(mrb, *sp); - s = mrb_str_ptr(ss); ps = va_arg(ap, char**); - *ps = s->ptr; pl = va_arg(ap, int*); - *pl = s->len; - i++; sp++; + if (i < argc) { + ss = to_str(mrb, *sp++); + s = mrb_str_ptr(ss); + *ps = s->ptr; + *pl = s->len; + i++; + } } break; case 'z': @@ -461,14 +470,16 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) struct RString *s; char **ps; - ss = to_str(mrb, *sp); - s = mrb_str_ptr(ss); - if (strlen(s->ptr) != s->len) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL"); - } ps = va_arg(ap, char**); - *ps = s->ptr; - i++; sp++; + if (i < argc) { + ss = to_str(mrb, *sp++); + s = mrb_str_ptr(ss); + if (strlen(s->ptr) != s->len) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL"); + } + *ps = s->ptr; + i++; + } } break; case 'a': @@ -478,13 +489,15 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_value **pb; int *pl; - aa = to_ary(mrb, *sp); - a = mrb_ary_ptr(aa); pb = va_arg(ap, mrb_value**); - *pb = a->ptr; pl = va_arg(ap, int*); - *pl = a->len; - i++; sp++; + if (i < argc) { + aa = to_ary(mrb, *sp++); + a = mrb_ary_ptr(aa); + *pb = a->ptr; + *pl = a->len; + i++; + } } break; case 'f': @@ -492,26 +505,29 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_float *p; p = va_arg(ap, mrb_float*); - switch (sp->tt) { - case MRB_TT_FLOAT: - *p = mrb_float(*sp); - break; - case MRB_TT_FIXNUM: - *p = (mrb_float)mrb_fixnum(*sp); - break; - case MRB_TT_FALSE: - *p = 0.0; - break; - default: - { - mrb_value tmp; - - tmp = mrb_convert_type(mrb, *sp, MRB_TT_FLOAT, "Float", "to_f"); - *p = mrb_float(tmp); + if (i < argc) { + switch (sp->tt) { + case MRB_TT_FLOAT: + *p = mrb_float(*sp); + break; + case MRB_TT_FIXNUM: + *p = (mrb_float)mrb_fixnum(*sp); + break; + case MRB_TT_FALSE: + *p = 0.0; + break; + default: + { + mrb_value tmp; + + tmp = mrb_convert_type(mrb, *sp, MRB_TT_FLOAT, "Float", "to_f"); + *p = mrb_float(tmp); + } + break; } - break; - } - i++; sp++; + sp++; + i++; + } } break; case 'i': @@ -519,26 +535,29 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) mrb_int *p; p = va_arg(ap, mrb_int*); - switch (sp->tt) { - case MRB_TT_FIXNUM: - *p = mrb_fixnum(*sp); - break; - case MRB_TT_FLOAT: - *p = (mrb_int)mrb_float(*sp); - break; - case MRB_TT_FALSE: - *p = 0; - break; - default: - { - mrb_value tmp; - - tmp = mrb_convert_type(mrb, *sp, MRB_TT_FIXNUM, "Integer", "to_int"); - *p = mrb_fixnum(tmp); + if (i < argc) { + switch (sp->tt) { + case MRB_TT_FIXNUM: + *p = mrb_fixnum(*sp); + break; + case MRB_TT_FLOAT: + *p = (mrb_int)mrb_float(*sp); + break; + case MRB_TT_FALSE: + *p = 0; + break; + default: + { + mrb_value tmp; + + tmp = mrb_convert_type(mrb, *sp, MRB_TT_FIXNUM, "Integer", "to_int"); + *p = mrb_fixnum(tmp); + } + break; } - break; - } - i++; sp++; + sp++; + i++; + } } break; -- cgit v1.2.3 From 6bf63707812e17314a89eaff2bcb539fae6a09e4 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 13 Jun 2012 23:53:57 +0900 Subject: new mrb_get_args specifier "n" to retrieve a symbol (stands for "name") --- src/class.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 914785120..fe0a2b530 100644 --- a/src/class.c +++ b/src/class.c @@ -370,6 +370,7 @@ to_hash(mrb_state *mrb, mrb_value val) a: Array [mrb_value*,int] f: Float [mrb_float] i: Integer [mrb_int] + n: Symbol [mrb_sym] &: Block [mrb_value] *: rest argument [mrb_value*,int] |: optional @@ -560,6 +561,25 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; + case 'n': + { + mrb_sym *symp; + + symp = va_arg(ap, mrb_sym*); + if (i < argc) { + mrb_value ss; + + ss = *sp++; + if (mrb_type(ss) == MRB_TT_SYMBOL) { + *symp = mrb_symbol(ss); + } + else { + *symp = mrb_intern_str(mrb, to_str(mrb, ss)); + } + i++; + } + } + break; case '&': { -- cgit v1.2.3 From 6f670785c5deea79e78abd965de466a1d344e77a Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 14 Jun 2012 00:03:36 +0900 Subject: mrb_get_args(i) should check range of float values --- src/class.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index fe0a2b530..ee6cf78f4 100644 --- a/src/class.c +++ b/src/class.c @@ -542,7 +542,14 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) *p = mrb_fixnum(*sp); break; case MRB_TT_FLOAT: - *p = (mrb_int)mrb_float(*sp); + { + mrb_float f = mrb_float(*sp); + + if (!FIXABLE(f)) { + mrb_raise(mrb, E_RANGE_ERROR, "float too big for int"); + } + *p = (mrb_int)f; + } break; case MRB_TT_FALSE: *p = 0; -- cgit v1.2.3 From 90735a242fc67fdaffd9ccaef3c7e2ccbbbf1b1e Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 14 Jun 2012 01:00:34 +0900 Subject: mrb_define_{singleton,class}_method should prepare singleton class for the obejct --- src/class.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index ee6cf78f4..9d89aef61 100644 --- a/src/class.c +++ b/src/class.c @@ -708,15 +708,16 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v) } void -mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, int aspec) +mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, mrb_func_t func, int aspec) { - mrb_define_method_id(mrb, c->c, mrb_intern(mrb, name), func, aspec); + o->c = mrb_singleton_class_ptr(mrb, o->c); + mrb_define_method_id(mrb, o->c, mrb_intern(mrb, name), func, aspec); } void -mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, mrb_func_t func, int aspec) +mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, int aspec) { - mrb_define_method_id(mrb, mrb_singleton_class_ptr(mrb, o->c), mrb_intern(mrb, name), func, aspec); + mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec); } void -- cgit v1.2.3 From b023acb6296d7ee55ae5e7f7bc3e1bf53f4e48dd Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 19 Jun 2012 09:54:05 +0900 Subject: add ISO reference numbers --- src/class.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 9d89aef61..df02a832a 100644 --- a/src/class.c +++ b/src/class.c @@ -1300,19 +1300,19 @@ mrb_init_class(mrb_state *mrb) MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS); mrb_define_method(mrb, bob, "initialize", mrb_bob_init, ARGS_NONE()); mrb_define_method(mrb, bob, "!", mrb_bob_not, ARGS_NONE()); - mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, ARGS_ANY()); /* 15.3.1.3.30 */ + mrb_define_method(mrb, bob, "method_missing", mrb_bob_missing, ARGS_ANY()); /* 15.3.1.3.30 */ mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, ARGS_ANY()); - mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); - mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); + mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); /* 15.2.3.3.4 */ + mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); /* 15.2.3.3.3 */ mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1)); - mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); + mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); /* 15.2.2.4.27 */ mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, ARGS_NONE()); - mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, ARGS_ANY()); - mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, ARGS_ANY()); - mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, ARGS_REQ(1)); - mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, ARGS_REQ(1)); - mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, ARGS_REQ(2)); + mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, ARGS_ANY()); /* 15.2.2.4.8 */ + mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, ARGS_ANY()); /* 15.2.2.4.41 */ + mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, ARGS_REQ(1)); /* 15.2.2.4.20 */ + mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, ARGS_REQ(1)); /* 15.2.2.4.21 */ + mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, ARGS_REQ(2)); /* 15.2.2.4.23 */ mrb_define_method(mrb, mod, "===", mrb_mod_eqq, ARGS_REQ(1)); } -- cgit v1.2.3 From cd68190480785430b8e350d9a5d2127ab04e1074 Mon Sep 17 00:00:00 2001 From: crimsonwoods Date: Tue, 19 Jun 2012 23:00:29 +0900 Subject: split declaration and definition for 'khash_xxx'. --- include/mruby/khash.h | 63 +++++++++++++++++++++++++++++++++------------------ src/class.c | 3 --- src/hash.c | 3 ++- src/kernel.c | 3 --- src/khash.c | 5 ++++ src/symbol.c | 3 ++- src/variable.c | 2 -- 7 files changed, 50 insertions(+), 32 deletions(-) create mode 100644 src/khash.c (limited to 'src/class.c') diff --git a/include/mruby/khash.h b/include/mruby/khash.h index 22df48ebb..6cb2b383d 100644 --- a/include/mruby/khash.h +++ b/include/mruby/khash.h @@ -32,16 +32,14 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; #define __ac_iseither(e_flag, d_flag, i) (__ac_isempty(e_flag,d_flag,i)||__ac_isdel(e_flag,d_flag,i)) -/* struct kh_xxx +/* declare struct kh_xxx and kh_xxx_funcs name: ash name khkey_t: key data type khval_t: value data type kh_is_map: (not implemented / not used in RiteVM ) - __hash_func: hash function - __hash_equal: hash comparation function */ -#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ +#define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map) \ typedef struct kh_##name { \ khint_t n_buckets; \ khint_t size; \ @@ -55,7 +53,26 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; khint_t inc; \ mrb_state *mrb; \ } kh_##name##_t; \ - static void kh_alloc_##name(kh_##name##_t *h) \ + void kh_alloc_##name(kh_##name##_t *h); \ + kh_##name##_t *kh_init_##name(mrb_state *mrb); \ + void kh_destroy_##name(kh_##name##_t *h); \ + void kh_clear_##name(kh_##name##_t *h); \ + khint_t kh_get_##name(kh_##name##_t *h, khkey_t key); \ + khint_t kh_put_##name(kh_##name##_t *h, khkey_t key); \ + void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \ + void kh_del_##name(kh_##name##_t *h, khint_t x); \ + +/* define kh_xxx_funcs + + name: ash name + khkey_t: key data type + khval_t: value data type + kh_is_map: (not implemented / not used in RiteVM ) + __hash_func: hash function + __hash_equal: hash comparation function +*/ +#define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ + void kh_alloc_##name(kh_##name##_t *h) \ { \ khint_t sz = h->n_buckets; \ h->size = h->n_occupied = 0; \ @@ -69,14 +86,14 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; h->mask = sz-1; \ h->inc = sz/2-1; \ } \ - static inline kh_##name##_t *kh_init_##name(mrb_state *mrb){ \ + kh_##name##_t *kh_init_##name(mrb_state *mrb){ \ kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \ h->n_buckets = INITIAL_HASH_SIZE; \ h->mrb = mrb; \ kh_alloc_##name(h); \ return h; \ } \ - static inline void kh_destroy_##name(kh_##name##_t *h) \ + void kh_destroy_##name(kh_##name##_t *h) \ { \ if( h ){ \ mrb_free(h->mrb, h->keys); \ @@ -85,7 +102,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; mrb_free(h->mrb, h); \ } \ } \ - static inline void kh_clear_##name(kh_##name##_t *h) \ + void kh_clear_##name(kh_##name##_t *h) \ { \ if( h && h->e_flags ){ \ memset(h->e_flags, 0xff, h->n_buckets/8*sizeof(uint8_t)); \ @@ -93,7 +110,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; h->size = h->n_occupied = 0; \ } \ } \ - static inline khint_t kh_get_##name(kh_##name##_t *h, khkey_t key) \ + khint_t kh_get_##name(kh_##name##_t *h, khkey_t key) \ { \ khint_t k = __hash_func(h->mrb,key) & (h->mask); \ while( !__ac_isempty(h->e_flags, h->d_flags, k) ){ \ @@ -104,8 +121,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; } \ return h->n_buckets; \ } \ - static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key); \ - static void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ + void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \ { \ if( new_n_bucketse_flags; \ khkey_t *old_keys = h->keys; \ khval_t *old_vals = h->vals; \ @@ -124,17 +140,17 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; kh_alloc_##name(h); \ /* relocate */ \ for( i=0 ; imrb, old_e_flags); \ mrb_free(h->mrb, old_keys); \ mrb_free(h->mrb, old_vals); \ } \ } \ - static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key) \ + khint_t kh_put_##name(kh_##name##_t *h, khkey_t key) \ { \ khint_t k; \ if( h->n_occupied >= h->upper_bound ){ \ @@ -159,12 +175,13 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; } \ return k; \ } \ - static inline void kh_del_##name(kh_##name##_t *h, khint_t x) \ + void kh_del_##name(kh_##name##_t *h, khint_t x) \ { \ h->d_flags[x/8] |= __m[x%8]; \ h->size--; \ } + #define khash_t(name) kh_##name##_t #define kh_init(name,mrb) kh_init_##name(mrb) @@ -197,11 +214,13 @@ static inline khint_t __ac_X31_hash_string(const char *s) #define kh_str_hash_func(mrb,key) __ac_X31_hash_string(key) #define kh_str_hash_equal(mrb,a, b) (strcmp(a, b) == 0) -#define KHASH_MAP_INIT_INT(name, khval_t) \ - KHASH_INIT(name, uint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal) typedef const char *kh_cstr_t; -#define KHASH_MAP_INIT_STR(name, khval_t) \ - KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal) + +/* declare common hash types. */ +#include "mruby.h" + +KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1) +KHASH_DECLARE(iv, mrb_sym, mrb_value, 1) #if defined(__cplusplus) } /* extern "C" { */ diff --git a/src/class.c b/src/class.c index df02a832a..434ecb037 100644 --- a/src/class.c +++ b/src/class.c @@ -17,9 +17,6 @@ #include "mruby/khash.h" -KHASH_INIT(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal) -KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) - typedef struct fc_result { mrb_sym name; struct RClass * klass; diff --git a/src/hash.c b/src/hash.c index fe5336dc1..08f906800 100644 --- a/src/hash.c +++ b/src/hash.c @@ -31,7 +31,8 @@ mrb_hash_ht_hash_equal(mrb_state *mrb, mrb_value a, mrb_value b) return mrb_eql(mrb, a, b); } -KHASH_INIT(ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal); +KHASH_DECLARE(ht, mrb_value, mrb_value, 1); +KHASH_DEFINE (ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal); static void mrb_hash_modify(mrb_state *mrb, mrb_value hash); diff --git a/src/kernel.c b/src/kernel.c index b5bde628a..75c588a81 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -34,9 +34,6 @@ typedef enum { NOEX_RESPONDS = 0x80 } mrb_method_flag_t; -KHASH_INIT(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal) -KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) - struct obj_ivar_tag { mrb_value obj; int (*func)(mrb_sym key, mrb_value val, void * arg); diff --git a/src/khash.c b/src/khash.c new file mode 100644 index 000000000..7ea09cfe7 --- /dev/null +++ b/src/khash.c @@ -0,0 +1,5 @@ +#include "mruby/khash.h" + +KHASH_DEFINE(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal) +KHASH_DEFINE(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) + diff --git a/src/symbol.c b/src/symbol.c index b80174e7b..d2ae09655 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -36,7 +36,8 @@ sym_hash_func(mrb_state *mrb, const symbol_name s) } #define sym_hash_equal(mrb,a, b) (a.len == b.len && memcmp(a.name, b.name, a.len) == 0) -KHASH_INIT(n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal) +KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1) +KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal) /* ------------------------------------------------------ */ mrb_sym mrb_intern2(mrb_state *mrb, const char *name, int len) diff --git a/src/variable.c b/src/variable.c index b11143b02..d89e9d6bb 100644 --- a/src/variable.c +++ b/src/variable.c @@ -19,8 +19,6 @@ #include "st.h" #endif -KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) - static void mark_tbl(mrb_state *mrb, struct kh_iv *h) { -- cgit v1.2.3 From ea81146a41d730f951de452ffb9217e2aceba19d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 20 Jun 2012 13:43:26 +0900 Subject: add Module#define_method --- src/class.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index df02a832a..3445b1692 100644 --- a/src/class.c +++ b/src/class.c @@ -1209,6 +1209,21 @@ mrb_mod_undef(mrb_state *mrb, mrb_value mod) return mrb_nil_value(); } +static mrb_value +mod_define_method(mrb_state *mrb, mrb_value self) +{ + struct RClass *c = mrb_class_ptr(self); + mrb_sym mid; + mrb_value blk; + + mrb_get_args(mrb, "n&", &mid, &blk); + if (mrb_nil_p(blk)) { + /* raise */ + } + mrb_define_method_raw(mrb, c, mid, mrb_proc_ptr(blk)); + return blk; +} + static mrb_sym mrb_sym_value(mrb_state *mrb, mrb_value val) { @@ -1313,6 +1328,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, ARGS_REQ(1)); /* 15.2.2.4.20 */ mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, ARGS_REQ(1)); /* 15.2.2.4.21 */ mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, ARGS_REQ(2)); /* 15.2.2.4.23 */ + mrb_define_method(mrb, mod, "define_method", mod_define_method, ARGS_REQ(1)); mrb_define_method(mrb, mod, "===", mrb_mod_eqq, ARGS_REQ(1)); } -- cgit v1.2.3 From 396397bce17a0f03eab8ed6512651e665aa89c8a Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 21 Jun 2012 11:04:36 +0900 Subject: move KHASH_DECLARE to header files --- include/mruby/khash.h | 6 ------ include/mruby/proc.h | 3 +++ include/mruby/variable.h | 7 ++++++- src/class.c | 6 ++---- src/kernel.c | 37 +++++-------------------------------- src/variable.c | 47 ++++++++++++++++++++++++++++++++++++++++++++--- 6 files changed, 60 insertions(+), 46 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby/khash.h b/include/mruby/khash.h index 6cb2b383d..e236f0bea 100644 --- a/include/mruby/khash.h +++ b/include/mruby/khash.h @@ -216,12 +216,6 @@ static inline khint_t __ac_X31_hash_string(const char *s) typedef const char *kh_cstr_t; -/* declare common hash types. */ -#include "mruby.h" - -KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1) -KHASH_DECLARE(iv, mrb_sym, mrb_value, 1) - #if defined(__cplusplus) } /* extern "C" { */ #endif diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 52dc5a98e..8f178790e 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -50,6 +50,9 @@ struct RProc *mrb_proc_new(mrb_state*, mrb_irep*); struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t); struct RProc *mrb_closure_new(mrb_state*, mrb_irep*); +#include "mruby/khash.h" +KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1); + #if defined(__cplusplus) } /* extern "C" { */ #endif diff --git a/include/mruby/variable.h b/include/mruby/variable.h index fb686fd47..440c4cc8b 100644 --- a/include/mruby/variable.h +++ b/include/mruby/variable.h @@ -20,6 +20,7 @@ typedef struct global_variable { //int block_trace; //struct trace_var *trace; } global_variable; + struct global_entry { global_variable *var; mrb_sym id; @@ -41,7 +42,8 @@ mrb_value mrb_obj_iv_get(mrb_state*, struct RObject*, mrb_sym); void mrb_obj_iv_set(mrb_state*, struct RObject*, mrb_sym, mrb_value); const char * mrb_class2name(mrb_state *mrb, struct RClass* klass); mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym); -void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); /* mrb_iv_set */ +void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); +mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym); void mrb_copy_generic_ivar(mrb_value clone, mrb_value obj); int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id); mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self); @@ -55,6 +57,9 @@ void mrb_gc_mark_iv(mrb_state*, struct RObject*); size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*); void mrb_gc_free_iv(mrb_state*, struct RObject*); +#include "mruby/khash.h" +KHASH_DECLARE(iv, mrb_sym, mrb_value, 1) + #if defined(__cplusplus) } /* extern "C" { */ #endif diff --git a/src/class.c b/src/class.c index 72fef70aa..56ab8c06f 100644 --- a/src/class.c +++ b/src/class.c @@ -15,7 +15,8 @@ #include "mruby/array.h" #include "error.h" -#include "mruby/khash.h" +KHASH_DEFINE(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal); +KHASH_DEFINE(mt, mrb_sym, struct RProc*, 1, kh_int_hash_func, kh_int_hash_equal); typedef struct fc_result { mrb_sym name; @@ -25,9 +26,6 @@ typedef struct fc_result { struct fc_result *prev; } fcresult_t; -int kiv_lookup(khash_t(iv) *table, mrb_sym key, mrb_value *value); -extern struct kh_iv *mrb_class_tbl; - void mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c) { diff --git a/src/kernel.c b/src/kernel.c index a9f4792d7..fd0440e05 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -10,14 +10,12 @@ #include #include #include "mruby/proc.h" - #include "mruby/range.h" #include "mruby/array.h" #include "mruby/hash.h" #include "mruby/class.h" #include "mruby/struct.h" #include "mruby/variable.h" -#include "mruby/khash.h" #include "error.h" typedef enum { @@ -1057,39 +1055,14 @@ mrb_value mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self) { mrb_sym sym; - mrb_value name; - khash_t(iv) *h; - khiter_t k; mrb_value val; - mrb_value Qundef = mrb_undef_value(); - mrb_get_args(mrb, "o", &name); - sym = mrb_to_id(mrb, name); - //if (OBJ_FROZEN(obj)) mrb_error_frozen("object"); - //if (!mrb_is_instance_id(id)) { - // mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", mrb_sym2name(mrb, id)); - //} - switch (mrb_type(self)) { - case MRB_TT_OBJECT: - case MRB_TT_CLASS: - case MRB_TT_MODULE: - if (!mrb_obj_ptr(self)->iv) break; - h = mrb_obj_ptr(self)->iv; - if (!h) break; - k = kh_get(iv, h, sym); - if (k != kh_end(h)) { - val = kh_value(h, k); - if (!mrb_obj_equal(mrb, val, Qundef)) { - kh_value(h, k) = Qundef; - return val; - } - } - break; - default: - break; + mrb_get_args(mrb, "n", &sym); + val = mrb_iv_remove(mrb, self, sym); + if (UNDEF_P(val)) { + mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym)); } - mrb_name_error(mrb, sym, "instance variable %s not defined", mrb_sym2name(mrb, sym)); - return mrb_nil_value(); /* not reached */ + return val; } static inline int diff --git a/src/variable.c b/src/variable.c index d89e9d6bb..051c971d6 100644 --- a/src/variable.c +++ b/src/variable.c @@ -94,10 +94,28 @@ mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym) return ivget(mrb, obj->iv, sym); } +static int +obj_iv_p(mrb_value obj) +{ + switch (mrb_type(obj)) { + case MRB_TT_OBJECT: + case MRB_TT_CLASS: + case MRB_TT_MODULE: + case MRB_TT_HASH: + case MRB_TT_DATA: + return TRUE; + default: + return FALSE; + } +} + mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym) { - return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym); + if (obj_iv_p(obj)) { + return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym); + } + return mrb_nil_value(); } static void @@ -127,7 +145,30 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v) void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v) /* mrb_ivar_set */ { - mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v); + if (obj_iv_p(obj)) { + mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v); + } +} + +mrb_value +mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym) +{ + mrb_value val; + + if (obj_iv_p(obj)) { + khash_t(iv) *h = mrb_obj_ptr(obj)->iv; + khiter_t k; + + if (h) { + k = kh_get(iv, h, sym); + if (k != kh_end(h)) { + val = kh_value(h, k); + kh_del(iv, h, k); + return val; + } + } + } + return mrb_undef_value(); } mrb_value @@ -366,7 +407,7 @@ mrb_st_lookup(struct kh_iv *table, mrb_sym id, khiter_t *value) } } -int +static int kiv_lookup(khash_t(iv)* table, mrb_sym key, mrb_value *value) { khash_t(iv) *h=table; -- cgit v1.2.3 From f045e646751bfe0f399aae59746befa6384b96aa Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 23 Jun 2012 13:51:50 +0900 Subject: reduce calling mrb_str_new_cstr() to avoid strlen(); #301 --- src/class.c | 17 ++++++++++++----- src/codegen.c | 10 ++++++---- src/hash.c | 6 +++--- src/kernel.c | 2 +- src/object.c | 8 +++----- src/re.c | 13 +++++++------ src/sprintf.c | 10 ++++++---- src/string.c | 5 ++--- src/struct.c | 9 +++++---- src/time.c | 13 +++++++------ src/vm.c | 18 ++++++++++-------- 11 files changed, 62 insertions(+), 49 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 56ab8c06f..a9bf54a3b 100644 --- a/src/class.c +++ b/src/class.c @@ -972,15 +972,23 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) struct RClass *outer = mrb_class_outer_module(mrb, c); mrb_sym sym = class_sym(mrb, c, outer); if (outer && outer != mrb->object_class) { + char *name; + int len; + mrb_value base = mrb_class_path(mrb, outer); - path = mrb_str_plus(mrb, base, mrb_str_new_cstr(mrb, "::")); - mrb_str_concat(mrb, path, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym))); + path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2)); + name = mrb_sym2name_len(mrb, sym, &len); + mrb_str_concat(mrb, path, mrb_str_new(mrb, name, len)); } else if (sym == 0) { return mrb_nil_value(); } else { - path = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym)); + char *name; + int len; + + name = mrb_sym2name_len(mrb, sym, &len); + path = mrb_str_new(mrb, name, len); } mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"), path); } @@ -1114,9 +1122,8 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const static mrb_value mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { - //if (FL_TEST(klass, FL_SINGLETON)) { if (mrb_type(klass) == MRB_TT_SCLASS) { - mrb_value s = mrb_str_new_cstr(mrb, "#<"); + mrb_value s = mrb_str_new(mrb, "#<", 2); mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__")); mrb_str_cat2(mrb, s, "Class:"); diff --git a/src/codegen.c b/src/codegen.c index 72fc1097d..cbf401a1f 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1534,10 +1534,11 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_BACK_REF: { char buf[4]; + int len; int sym; - snprintf(buf, 3, "$%c", (int)(intptr_t)tree); - sym = new_sym(s, mrb_intern(s->mrb, buf)); + len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree); + sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); } @@ -1546,10 +1547,11 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_NTH_REF: { char buf[4]; + int len; int sym; - snprintf(buf, 3, "$%d", (int)(intptr_t)tree); - sym = new_sym(s, mrb_intern(s->mrb, buf)); + len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree); + sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); } diff --git a/src/hash.c b/src/hash.c index 0e06cd246..a87ca97d4 100644 --- a/src/hash.c +++ b/src/hash.c @@ -889,9 +889,9 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur) khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; - if (recur) return mrb_str_new_cstr(mrb, "{...}"); + if (recur) return mrb_str_new(mrb, "{...}", 5); - str = mrb_str_new_cstr(mrb, "{"); + str = mrb_str_new(mrb, "{", 1); if (h && kh_size(h) > 0) { for (k = kh_begin(h); k != kh_end(h); k++) { int ai; @@ -934,7 +934,7 @@ mrb_hash_inspect(mrb_state *mrb, mrb_value hash) khash_t(ht) *h = RHASH_TBL(hash); if (!h || kh_size(h) == 0) - return mrb_str_new_cstr(mrb, "{}"); + return mrb_str_new(mrb, "{}", 2); return inspect_hash(mrb, hash, 0); } diff --git a/src/kernel.c b/src/kernel.c index 8f2b15378..8da112ee5 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -117,7 +117,7 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj) return mrb_any_to_s(mrb, obj); } else if (mrb_nil_p(obj)) { - return mrb_str_new_cstr(mrb, "nil"); + return mrb_str_new(mrb, "nil", 3); } return mrb_funcall(mrb, obj, "to_s", 0, 0); } diff --git a/src/object.c b/src/object.c index a30e7c58a..eb63c1293 100644 --- a/src/object.c +++ b/src/object.c @@ -151,7 +151,7 @@ true_xor(mrb_state *mrb, mrb_value obj) static mrb_value true_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_cstr(mrb, "true"); + return mrb_str_new(mrb, "true", 4); } /* 15.2.5.3.4 */ @@ -264,7 +264,7 @@ false_or(mrb_state *mrb, mrb_value obj) static mrb_value false_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_cstr(mrb, "false"); + return mrb_str_new(mrb, "false", 5); } void @@ -462,9 +462,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj) len = strlen(cname)+6+16; str = mrb_str_new(mrb, 0, len); /* 6:tags 16:addr */ s = mrb_str_ptr(str); - // snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj); - sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); - s->len = strlen(s->ptr); + s->len = sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); return str; } diff --git a/src/re.c b/src/re.c index 12061eacf..a7552de11 100644 --- a/src/re.c +++ b/src/re.c @@ -354,10 +354,10 @@ mrb_reg_options(mrb_state *mrb, mrb_value re) static mrb_value mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re) { - mrb_value str = mrb_str_new_cstr(mrb, "/");//mrb_str_buf_new2("/"); + mrb_value str = mrb_str_new(mrb, "/", 1); mrb_reg_expr_str(mrb, str, s, len); - mrb_str_buf_cat(mrb, str, "/", sizeof("/")); + mrb_str_buf_cat(mrb, str, "/", 1); if (re.tt) { char opts[4]; mrb_reg_check(mrb, re); @@ -1688,9 +1688,10 @@ mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len) } else if (!ISSPACE(c)) { char b[8]; + int n; - snprintf(b, sizeof(b), "\\x%02X", c); - mrb_str_buf_cat(mrb, str, b, 4); + n = snprintf(b, sizeof(b), "\\x%02X", c); + mrb_str_buf_cat(mrb, str, b, n); } else { mrb_str_buf_cat(mrb, str, p, 1); @@ -1728,7 +1729,7 @@ mrb_reg_to_s(mrb_state *mrb, mrb_value re) const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND; long len; const UChar* ptr; - mrb_value str = mrb_str_new_cstr(mrb, "(?"); + mrb_value str = mrb_str_new(mrb, "(?", 2); char optbuf[5]; mrb_encoding *enc = mrb_enc_get(mrb, re); @@ -1918,7 +1919,7 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) onig_foreach_name(regexp->ptr, match_inspect_name_iter, names); - str = mrb_str_new_cstr(mrb, "#<");//mrb_str_buf_new2("#<"); + str = mrb_str_new(mrb, "#<", 2); mrb_str_buf_cat(mrb, str, cname, strlen(cname)); for (i = 0; i < num_regs; i++) { diff --git a/src/sprintf.c b/src/sprintf.c index e01bf572e..56141e482 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -1061,6 +1061,8 @@ static void fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) { char *end = buf + size; + int n; + *buf++ = '%'; if (flags & FSHARP) *buf++ = '#'; if (flags & FPLUS) *buf++ = '+'; @@ -1069,13 +1071,13 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) if (flags & FSPACE) *buf++ = ' '; if (flags & FWIDTH) { - snprintf(buf, end - buf, "%d", width); - buf += strlen(buf); + n = snprintf(buf, end - buf, "%d", width); + buf += n; } if (flags & FPREC) { - snprintf(buf, end - buf, ".%d", prec); - buf += strlen(buf); + n = snprintf(buf, end - buf, ".%d", prec); + buf += n; } *buf++ = c; diff --git a/src/string.c b/src/string.c index a943512c7..1ef0cdc33 100644 --- a/src/string.c +++ b/src/string.c @@ -2517,6 +2517,7 @@ bad: printf("Integer"); return mrb_fixnum_value(0); } + char * mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr) { @@ -2535,10 +2536,8 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck) char *s; int len; - //StringValue(str); mrb_string_value(mrb, &str); if (badcheck) { - //s = StringValueCStr(str); s = mrb_string_value_cstr(mrb, &str); } else { @@ -2949,7 +2948,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) { const char *p, *pend; char buf[CHAR_ESC_LEN + 1]; - mrb_value result = mrb_str_new_cstr(mrb, "\""); + mrb_value result = mrb_str_new(mrb, "\"", 1); p = RSTRING_PTR(str); pend = RSTRING_END(str); for (;p < pend; p++) { diff --git a/src/struct.c b/src/struct.c index 7e422f140..60a0edb5b 100644 --- a/src/struct.c +++ b/src/struct.c @@ -521,8 +521,11 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur) slot = ptr_members[i]; id = SYM2ID(slot); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { - //mrb_str_append(str, mrb_id2str(id)); - mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id))); + char *name; + int len; + + name = mrb_sym2name_len(mrb, id, &len); + mrb_str_append(mrb, str, mrb_str_new(mrb, name, len)); } else { mrb_str_append(mrb, str, mrb_inspect(mrb, slot)); @@ -804,9 +807,7 @@ mrb_init_struct(mrb_state *mrb) { struct RClass *st; st = mrb_define_class(mrb, "Struct", mrb->object_class); - //mrb_include_module(mrb_cStruct, rb_mEnumerable); - //mrb_undef_alloc_func(mrb_cStruct); mrb_define_class_method(mrb, st, "new", mrb_struct_s_def, ARGS_ANY()); /* 15.2.18.3.1 */ mrb_define_method(mrb, st, "==", mrb_struct_equal, ARGS_REQ(1)); /* 15.2.18.4.1 */ diff --git a/src/time.c b/src/time.c index 55060729b..28cc3c1a3 100644 --- a/src/time.c +++ b/src/time.c @@ -430,16 +430,17 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self) struct mrb_time *tm; struct tm *d; char buf[256]; + int len; tm = mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); d = &tm->datetime; - snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d", - wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, - d->tm_hour, d->tm_min, d->tm_sec, - tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "", - d->tm_year + 1900); - return mrb_str_new_cstr(mrb, buf); + len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d", + wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, + d->tm_hour, d->tm_min, d->tm_sec, + tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "", + d->tm_year + 1900); + return mrb_str_new(mrb, buf, len); } /* 15.2.19.7.6 */ diff --git a/src/vm.c b/src/vm.c index 04392891f..daba0acc6 100644 --- a/src/vm.c +++ b/src/vm.c @@ -292,10 +292,11 @@ static void localjump_error(mrb_state *mrb, const char *kind) { char buf[256]; + int len; mrb_value exc; - snprintf(buf, 256, "unexpected %s", kind); - exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, strlen(buf)); + len = snprintf(buf, 256, "unexpected %s", kind); + exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len); mrb->exc = (struct RObject*)mrb_object(exc); } @@ -303,18 +304,19 @@ static void argnum_error(mrb_state *mrb, int num) { char buf[256]; + int len; mrb_value exc; if (mrb->ci->mid) { - snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)", - mrb_sym2name(mrb, mrb->ci->mid), - mrb->ci->argc, num); + len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)", + mrb_sym2name(mrb, mrb->ci->mid), + mrb->ci->argc, num); } else { - snprintf(buf, 256, "wrong number of arguments (%d for %d)", - mrb->ci->argc, num); + len = snprintf(buf, 256, "wrong number of arguments (%d for %d)", + mrb->ci->argc, num); } - exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, strlen(buf)); + exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len); mrb->exc = (struct RObject*)mrb_object(exc); } -- cgit v1.2.3 From d657e26d35ef31314a97d42bacc3e5dc85689404 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 24 Jun 2012 01:12:05 +0900 Subject: pacify const assignment warning --- src/class.c | 8 ++------ src/struct.c | 2 +- 2 files changed, 3 insertions(+), 7 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index a9bf54a3b..881a0072e 100644 --- a/src/class.c +++ b/src/class.c @@ -966,15 +966,14 @@ mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c) { mrb_value path; + const char *name; + int len; path = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__")); if (mrb_nil_p(path)) { struct RClass *outer = mrb_class_outer_module(mrb, c); mrb_sym sym = class_sym(mrb, c, outer); if (outer && outer != mrb->object_class) { - char *name; - int len; - mrb_value base = mrb_class_path(mrb, outer); path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2)); name = mrb_sym2name_len(mrb, sym, &len); @@ -984,9 +983,6 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) return mrb_nil_value(); } else { - char *name; - int len; - name = mrb_sym2name_len(mrb, sym, &len); path = mrb_str_new(mrb, name, len); } diff --git a/src/struct.c b/src/struct.c index 60a0edb5b..855974182 100644 --- a/src/struct.c +++ b/src/struct.c @@ -521,7 +521,7 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur) slot = ptr_members[i]; id = SYM2ID(slot); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { - char *name; + const char *name; int len; name = mrb_sym2name_len(mrb, id, &len); -- cgit v1.2.3 From 1deb31320a480b1863885743ab344a602062c43a Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sun, 24 Jun 2012 15:15:55 +0900 Subject: Modify instance tt. --- src/class.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 881a0072e..53e603aeb 100644 --- a/src/class.c +++ b/src/class.c @@ -1050,6 +1050,9 @@ mrb_class_new(mrb_state *mrb, struct RClass *super) mrb_check_inheritable(mrb, super); } c = boot_defclass(mrb, super); + if (super){ + MRB_SET_INSTANCE_TT(c, MRB_INSTANCE_TT(super)); + } make_metaclass(mrb, c); return c; -- cgit v1.2.3 From 8121e0d354b83b3fa9d1363470e280dc98112289 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 24 Jun 2012 21:46:24 +0900 Subject: should mark child env from method (proc) objects --- src/class.c | 2 +- src/gc.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 881a0072e..16fb36617 100644 --- a/src/class.c +++ b/src/class.c @@ -37,7 +37,7 @@ mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c) if (kh_exist(h, k)){ struct RProc *m = kh_value(h, k); if (m) { - paint_black(m); + mrb_gc_mark(mrb, (struct RBasic*)m); } } } diff --git a/src/gc.c b/src/gc.c index a7537a015..42c4e3fdb 100644 --- a/src/gc.c +++ b/src/gc.c @@ -345,8 +345,8 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj) break; case MRB_TT_CLASS: - case MRB_TT_SCLASS: case MRB_TT_MODULE: + case MRB_TT_SCLASS: { struct RClass *c = (struct RClass*)obj; -- cgit v1.2.3 From 19638ded7367520333caf1b070b221ea18e4c352 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 25 Jun 2012 17:30:12 +0900 Subject: use mrb_intern_str instead of mrb_intern if possible --- src/class.c | 2 +- src/sprintf.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 16fb36617..cda7ce643 100644 --- a/src/class.c +++ b/src/class.c @@ -1226,7 +1226,7 @@ static mrb_sym mrb_sym_value(mrb_state *mrb, mrb_value val) { if(val.tt == MRB_TT_STRING) { - return mrb_intern(mrb, RSTRING_PTR(val)); + return mrb_intern_str(mrb, val); } else if(val.tt != MRB_TT_SYMBOL) { mrb_value obj = mrb_funcall(mrb, val, "inspect", 0); diff --git a/src/sprintf.c b/src/sprintf.c index 56141e482..86c3b66bc 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -613,7 +613,7 @@ retry: (int)(p - start + 1), start, mrb_sym2name(mrb, id)); } symname = mrb_str_new(mrb, start + 1, p - start - 1); - id = mrb_intern(mrb, RSTRING_PTR(symname)); + id = mrb_intern_str(mrb, symname); nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1)); if (UNDEF_P(nextvalue)) { mrb_raise(mrb, E_KEY_ERROR, "key%.*s not found", (int)(p - start + 1), start); -- cgit v1.2.3 From d534f26f16ba94c2182a44e4201352d1fb277af0 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Wed, 27 Jun 2012 10:36:39 +0900 Subject: Use sizeof to get char array sizes. --- src/class.c | 4 ++-- src/codegen.c | 4 ++-- src/error.c | 6 +++--- src/time.c | 2 +- src/vm.c | 6 +++--- 5 files changed, 11 insertions(+), 11 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 071d7aebe..599db9da5 100644 --- a/src/class.c +++ b/src/class.c @@ -1149,11 +1149,11 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) switch (mrb_type(klass)) { case MRB_TT_CLASS: - snprintf(buf, 256, "#", c); + snprintf(buf, sizeof(buf), "#", c); break; case MRB_TT_MODULE: - snprintf(buf, 256, "#", c); + snprintf(buf, sizeof(buf), "#", c); break; default: diff --git a/src/codegen.c b/src/codegen.c index cbf401a1f..fb0006625 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1537,7 +1537,7 @@ codegen(codegen_scope *s, node *tree, int val) int len; int sym; - len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree); + len = snprintf(buf, sizeof(buf), "$%c", (int)(intptr_t)tree); sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); @@ -1550,7 +1550,7 @@ codegen(codegen_scope *s, node *tree, int val) int len; int sym; - len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree); + len = snprintf(buf, sizeof(buf), "$%d", (int)(intptr_t)tree); sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); diff --git a/src/error.c b/src/error.c index 1183d8643..e46e37cbb 100644 --- a/src/error.c +++ b/src/error.c @@ -180,7 +180,7 @@ mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...) int n; va_start(args, fmt); - n = vsnprintf(buf, 256, fmt, args); + n = vsnprintf(buf, sizeof(buf), fmt, args); va_end(args); if (n < 0) { n = 0; @@ -197,7 +197,7 @@ mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...) int n; va_start(args, fmt); - n = vsnprintf(buf, 256, fmt, args); + n = vsnprintf(buf, sizeof(buf), fmt, args); va_end(args); if (n < 0) { n = 0; @@ -216,7 +216,7 @@ mrb_sprintf(mrb_state *mrb, const char *fmt, ...) int n; va_start(args, fmt); - n = vsnprintf(buf, 256, fmt, args); + n = vsnprintf(buf, sizeof(buf), fmt, args); va_end(args); if (n < 0) { n = 0; diff --git a/src/time.c b/src/time.c index 28cc3c1a3..3da824e82 100644 --- a/src/time.c +++ b/src/time.c @@ -435,7 +435,7 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self) tm = mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); d = &tm->datetime; - len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d", + len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d", wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, d->tm_hour, d->tm_min, d->tm_sec, tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "", diff --git a/src/vm.c b/src/vm.c index 136ece3bd..d69081c9c 100644 --- a/src/vm.c +++ b/src/vm.c @@ -295,7 +295,7 @@ localjump_error(mrb_state *mrb, const char *kind) int len; mrb_value exc; - len = snprintf(buf, 256, "unexpected %s", kind); + len = snprintf(buf, sizeof(buf), "unexpected %s", kind); exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len); mrb->exc = (struct RObject*)mrb_object(exc); } @@ -308,12 +308,12 @@ argnum_error(mrb_state *mrb, int num) mrb_value exc; if (mrb->ci->mid) { - len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)", + len = snprintf(buf, sizeof(buf), "'%s': wrong number of arguments (%d for %d)", mrb_sym2name(mrb, mrb->ci->mid), mrb->ci->argc, num); } else { - len = snprintf(buf, 256, "wrong number of arguments (%d for %d)", + len = snprintf(buf, sizeof(buf), "wrong number of arguments (%d for %d)", mrb->ci->argc, num); } exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len); -- cgit v1.2.3 From 6f9ed1c5b21ba6ef2230e15bd3b39535f2f7bde9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 27 Jun 2012 15:14:56 +0900 Subject: use return value from sprintf/snprintf --- src/class.c | 10 +++++----- src/re.c | 4 ++-- src/sprintf.c | 22 ++++++++++------------ src/string.c | 4 ++-- 4 files changed, 19 insertions(+), 21 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 071d7aebe..02fe9512a 100644 --- a/src/class.c +++ b/src/class.c @@ -1141,25 +1141,25 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) } else { struct RClass *c = mrb_class_ptr(klass); - const char *cn = mrb_class_name(mrb, c); + const char *cn = mrb_class_name(mrb, c); if (!cn) { char buf[256]; - + int n = 0; switch (mrb_type(klass)) { case MRB_TT_CLASS: - snprintf(buf, 256, "#", c); + n = snprintf(buf, 256, "#", c); break; case MRB_TT_MODULE: - snprintf(buf, 256, "#", c); + n = snprintf(buf, 256, "#", c); break; default: break; } - return mrb_str_dup(mrb, mrb_str_new_cstr(mrb, buf)); + return mrb_str_dup(mrb, mrb_str_new(mrb, buf, n)); } else { return mrb_str_dup(mrb, mrb_str_new_cstr(mrb, cn)); diff --git a/src/re.c b/src/re.c index a7552de11..c7b27eac2 100644 --- a/src/re.c +++ b/src/re.c @@ -1930,8 +1930,8 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) if (names[i].name) mrb_str_buf_cat(mrb, str, (const char*)names[i].name, names[i].len); else { - sprintf(buf, "%d", i); - mrb_str_buf_cat(mrb, str, (const char*)buf, strlen(buf)); + int n = sprintf(buf, "%d", i); + mrb_str_buf_cat(mrb, str, (const char*)buf, n); } mrb_str_buf_cat(mrb, str, ":", sizeof(":")); } diff --git a/src/sprintf.c b/src/sprintf.c index 68addef89..d6104ad48 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -496,7 +496,7 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt) char *buf; long blen, bsiz; mrb_value result; - + int n; int width, prec, flags = FNONE; int nextarg = 1; int posarg = 0; @@ -533,7 +533,6 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt) for (; p < end; p++) { const char *t; - int n; mrb_sym id = 0; for (t = p; t < end && *t != '%'; t++) ; @@ -669,7 +668,6 @@ retry: mrb_value val = GETARG(); mrb_value tmp; unsigned int c; - int n; tmp = mrb_check_string_type(mrb, val); if (!mrb_nil_p(tmp)) { @@ -984,6 +982,7 @@ bin_retry: fval = mrb_float(mrb_Float(mrb, val)); if (isnan(fval) || isinf(fval)) { const char *expr; + const int elen = 3; if (isnan(fval)) { expr = "NaN"; @@ -991,14 +990,14 @@ bin_retry: else { expr = "Inf"; } - need = (int)strlen(expr); + need = elen; if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS)) need++; if ((flags & FWIDTH) && need < width) need = width; CHECK(need + 1); - snprintf(&buf[blen], need + 1, "%*s", need, ""); + n = snprintf(&buf[blen], need + 1, "%*s", need, ""); if (flags & FMINUS) { if (!isnan(fval) && fval < 0.0) buf[blen++] = '-'; @@ -1006,17 +1005,16 @@ bin_retry: buf[blen++] = '+'; else if (flags & FSPACE) blen++; - memcpy(&buf[blen], expr, strlen(expr)); + memcpy(&buf[blen], expr, elen); } else { if (!isnan(fval) && fval < 0.0) - buf[blen + need - strlen(expr) - 1] = '-'; + buf[blen + need - elen - 1] = '-'; else if (flags & FPLUS) - buf[blen + need - strlen(expr) - 1] = '+'; + buf[blen + need - elen - 1] = '+'; else if ((flags & FSPACE) && need > width) blen++; - memcpy(&buf[blen + need - strlen(expr)], expr, - strlen(expr)); + memcpy(&buf[blen + need - elen], expr, elen); } blen += strlen(&buf[blen]); break; @@ -1036,8 +1034,8 @@ bin_retry: need += 20; CHECK(need); - snprintf(&buf[blen], need, fbuf, fval); - blen += strlen(&buf[blen]); + n = snprintf(&buf[blen], need, fbuf, fval); + blen += n; } break; } diff --git a/src/string.c b/src/string.c index c74dcedde..f01c08bce 100644 --- a/src/string.c +++ b/src/string.c @@ -2983,8 +2983,8 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) continue; } else { - sprintf(buf, "\\%03o", c & 0377); - mrb_str_buf_cat(mrb, result, buf, strlen(buf)); + int n = sprintf(buf, "\\%03o", c & 0377); + mrb_str_buf_cat(mrb, result, buf, n); continue; } } -- cgit v1.2.3 From 8746cb2ac12ae13a489830be541f6554bdba7516 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sun, 1 Jul 2012 18:34:22 +0900 Subject: Initialize mt of module with khash. --- src/class.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index b53c18590..0e7696972 100644 --- a/src/class.c +++ b/src/class.c @@ -1065,6 +1065,7 @@ struct RClass * mrb_module_new(mrb_state *mrb) { struct RClass *m = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_MODULE, mrb->module_class); + m->mt = kh_init(mt, mrb); return m; } -- cgit v1.2.3 From fbfef55152364b71df9eef8187fce94a5054ee5b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 5 Jul 2012 17:57:23 +0900 Subject: Module#include should also include included modules; close #340 --- src/class.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 0e7696972..7e0512322 100644 --- a/src/class.c +++ b/src/class.c @@ -646,6 +646,7 @@ mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m) { struct RClass *ic; + if (m->super) mrb_include_module(mrb, c, m->super); ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); ic->c = m; ic->mt = m->mt; -- cgit v1.2.3 From 9f814a4e6e6cadea676a875990786903e37b1a06 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sat, 7 Jul 2012 23:04:09 +0900 Subject: Improvement of Module#include. - Add some methods: append_features, included_methods and included. - Modify Module#include to call append_features and included. --- src/class.c | 87 ++++++++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 74 insertions(+), 13 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 7e0512322..9003c3bc5 100644 --- a/src/class.c +++ b/src/class.c @@ -641,32 +641,90 @@ boot_defclass(mrb_state *mrb, struct RClass *super) return c; } +static int +find_in_ancestors(struct RClass *c, struct RClass *m) +{ + while(c) { + if (c == m || c->mt == m->mt){ + return 1; + } + c = c->super; + } + return 0; +} + void mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m) { - struct RClass *ic; + struct RClass *ic, *ins_pos; - if (m->super) mrb_include_module(mrb, c, m->super); - ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); - ic->c = m; - ic->mt = m->mt; - ic->iv = m->iv; - ic->super = c->super; - c->super = ic; - mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)ic); + ins_pos = c; + while (m) { + if (!find_in_ancestors(c, m)) { + ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); + if (m->tt == MRB_TT_ICLASS) { + ic->c = m->c; + } + else { + ic->c = m; + } + ic->mt = m->mt; + ic->iv = m->iv; + ic->super = ins_pos->super; + ins_pos->super = ic; + mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic); + ins_pos = ic; + } + m = m->super; + } } static mrb_value -mrb_mod_include(mrb_state *mrb, mrb_value klass) +mrb_mod_append_features(mrb_state *mrb, mrb_value mod) { - mrb_value mod; + mrb_value klass; - mrb_get_args(mrb, "o", &mod); mrb_check_type(mrb, mod, MRB_TT_MODULE); + mrb_get_args(mrb, "o", &klass); mrb_include_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod)); return mod; } +static mrb_value +mrb_mod_include(mrb_state *mrb, mrb_value klass) +{ + mrb_value *argv; + int argc, i; + + mrb_get_args(mrb, "*", &argv, &argc); + for (i=0; itt == MRB_TT_ICLASS) { + mrb_ary_push(mrb, result, mrb_obj_value(c->c)); + } + c = c->super; + } + + return result; +} + static struct RClass * mrb_singleton_class_ptr(mrb_state *mrb, struct RClass *c) { @@ -1323,7 +1381,10 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); /* 15.2.3.3.4 */ mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); /* 15.2.3.3.3 */ mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1)); - mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_REQ(1)); /* 15.2.2.4.27 */ + mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_ANY()); /* 15.2.2.4.27 */ + mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, ARGS_REQ(1)); /* 15.2.2.4.10 */ + mrb_define_method(mrb, mod, "included", mrb_bob_init, ARGS_REQ(1)); /* 15.2.2.4.29 */ + mrb_define_method(mrb, mod, "included_modules", mrb_mod_included_modules, ARGS_NONE()); /* 15.2.2.4.30 */ mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, ARGS_NONE()); mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, ARGS_ANY()); /* 15.2.2.4.8 */ -- cgit v1.2.3 From bbec03bb7af3fb0277a267e4ec5d38b58aa5cb46 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 13 Jul 2012 14:35:18 +0900 Subject: add missing (empty) default for swtch; close #364 --- src/class.c | 3 +++ src/codegen.c | 4 ++++ src/parse.y | 7 ++++++- src/range.c | 4 ++++ src/symbol.c | 4 +++- tools/mrbc/mrbc.c | 2 ++ tools/mruby/mruby.c | 2 ++ 7 files changed, 24 insertions(+), 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 9003c3bc5..783627a7d 100644 --- a/src/class.c +++ b/src/class.c @@ -620,6 +620,9 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; + default: + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide argument specifier %c", c); + break; } } if (!c && argc > i) { diff --git a/src/codegen.c b/src/codegen.c index 00c6b566d..3ef52a0d4 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -207,6 +207,8 @@ genop_peep(codegen_scope *s, mrb_code i, int val) return; } break; + default: + break; } break; case OP_SETIV: @@ -240,6 +242,8 @@ genop_peep(codegen_scope *s, mrb_code i, int val) return; } break; + default: + break; } } genop(s, i); diff --git a/src/parse.y b/src/parse.y index 292e60cfa..13643f68e 100644 --- a/src/parse.y +++ b/src/parse.y @@ -3041,6 +3041,8 @@ backref_error(parser_state *p, node *n) case NODE_BACK_REF: yyerror_i(p, "can't set variable $%c", (int)(intptr_t)n->cdr); break; + default: + break; } } @@ -3722,7 +3724,7 @@ parser_yylex(parser_state *p) } if (isspace(c)) { if (!IS_ARG()) { - int c2 = 0; + int c2; switch (c) { case ' ': c2 = 's'; @@ -3742,6 +3744,9 @@ parser_yylex(parser_state *p) case '\f': c2 = 'f'; break; + default: + c2 = 0; + break; } if (c2) { char buf[256]; diff --git a/src/range.c b/src/range.c index b4d743e5f..703ad12aa 100644 --- a/src/range.c +++ b/src/range.c @@ -31,7 +31,11 @@ range_check(mrb_state *mrb, mrb_value a, mrb_value b) case MRB_TT_FIXNUM: case MRB_TT_FLOAT: return; + default: + break; } + default: + break; } mrb_p(mrb, a); diff --git a/src/symbol.c b/src/symbol.c index 91076e293..baab0fb3c 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -276,6 +276,7 @@ symname_p(const char *name) case '>': switch (*++m) { case '>': case '=': ++m; break; + default: break; } break; @@ -319,7 +320,8 @@ id: while (is_identchar(*m)) m += 1; if (localid) { switch (*m) { - case '!': case '?': case '=': ++m; + case '!': case '?': case '=': ++m; + default: break; } } break; diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c index 55e2fcf32..8da37832a 100644 --- a/tools/mrbc/mrbc.c +++ b/tools/mrbc/mrbc.c @@ -114,6 +114,8 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) } else return -3; return 0; + default: + break; } } else if (args->rfp == NULL) { diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index 3628e79c9..12cdc86e9 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -110,6 +110,8 @@ append_cmdline: } else return -3; return 0; + default: + break; } } -- cgit v1.2.3 From 8611f967775e251d98aa8ab7277f0eb75ccc70f0 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sat, 14 Jul 2012 23:02:48 +0900 Subject: Remove unnecessary mrb_const_set in class.c. --- src/class.c | 2 -- 1 file changed, 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 783627a7d..774b020a8 100644 --- a/src/class.c +++ b/src/class.c @@ -254,7 +254,6 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s } c = mrb_class_new(mrb, super); setup_class(mrb, mrb_obj_value(outer), c, id); - mrb_const_set(mrb, mrb_obj_value(outer), id, mrb_obj_value(c)); return c; } @@ -274,7 +273,6 @@ mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name) } c = mrb_module_new(mrb); setup_class(mrb, mrb_obj_value(outer), c, id); - mrb_const_set(mrb, mrb_obj_value(outer), id, mrb_obj_value(c)); return c; } -- cgit v1.2.3 From 234b8e853cc8b3bac2945832d589562e41da1456 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 15 Jul 2012 16:37:23 +0900 Subject: make class_from_sym static --- include/mruby.h | 1 - src/class.c | 27 +++++++++++++++++++-------- src/variable.c | 13 ------------- 3 files changed, 19 insertions(+), 22 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby.h b/include/mruby.h index 1124ba89c..137a1b94e 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -297,7 +297,6 @@ void mrb_undef_method(mrb_state*, struct RClass*, const char*); mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); struct RClass * mrb_module_new(mrb_state *mrb); -struct RClass * mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym name); struct RClass * mrb_class_get(mrb_state *mrb, const char *name); struct RClass * mrb_class_obj_get(mrb_state *mrb, const char *name); diff --git a/src/class.c b/src/class.c index 783627a7d..3985800d0 100644 --- a/src/class.c +++ b/src/class.c @@ -216,6 +216,23 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id return c; } +static struct RClass * +class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id) +{ + mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id); + + if (c.tt != MRB_TT_MODULE && c.tt != MRB_TT_CLASS) { + mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id)); + } + return mrb_class_ptr(c); +} + +struct RClass * +mrb_class_get(mrb_state *mrb, const char *name) +{ + return class_from_sym(mrb, mrb->object_class, mrb_intern(mrb, name)); +} + /*! * Defines a class under the namespace of \a outer. * \param outer a class which contains the new class. @@ -239,10 +256,7 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s mrb_sym id = mrb_intern(mrb, name); if (mrb_const_defined_at(mrb, outer, id)) { - c = mrb_class_from_sym(mrb, outer, id); - if (c->tt != MRB_TT_CLASS) { - mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class", mrb_sym2name(mrb, id)); - } + c = class_from_sym(mrb, outer, id); if (mrb_class_real(c->super) != super) { mrb_name_error(mrb, id, "%s is already defined", mrb_sym2name(mrb, id)); } @@ -266,10 +280,7 @@ mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name) mrb_sym id = mrb_intern(mrb, name); if (mrb_const_defined_at(mrb, outer, id)) { - c = mrb_class_from_sym(mrb, outer, id); - if (c->tt != MRB_TT_MODULE) { - mrb_raise(mrb, E_TYPE_ERROR, "%s is not a module", mrb_sym2name(mrb, id)); - } + c = class_from_sym(mrb, outer, id); return c; } c = mrb_module_new(mrb); diff --git a/src/variable.c b/src/variable.c index be686bf72..501bed5a6 100644 --- a/src/variable.c +++ b/src/variable.c @@ -495,19 +495,6 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id) return mrb_const_defined_0(mrb, klass, id, TRUE, FALSE); } -struct RClass * -mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id) -{ - mrb_value c = const_get(mrb, klass, id); - return mrb_class_ptr(c); -} - -struct RClass * -mrb_class_get(mrb_state *mrb, const char *name) -{ - return mrb_class_from_sym(mrb, mrb->object_class, mrb_intern(mrb, name)); -} - mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id) { -- cgit v1.2.3 From ba08a2b9dddf97c84a73ab72f708e2bfef2d6b82 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Tue, 17 Jul 2012 00:42:35 +0900 Subject: Add Module#extend_object and Module#extended. --- src/class.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 1409c0b33..338b01e3d 100644 --- a/src/class.c +++ b/src/class.c @@ -720,6 +720,17 @@ mrb_mod_include(mrb_state *mrb, mrb_value klass) return klass; } +static mrb_value +mrb_mod_extend_object(mrb_state *mrb, mrb_value mod) +{ + mrb_value obj; + + mrb_check_type(mrb, mod, MRB_TT_MODULE); + mrb_get_args(mrb, "o", &obj); + mrb_include_module(mrb, mrb_class_ptr(mrb_singleton_class(mrb, obj)), mrb_class_ptr(mod)); + return mod; +} + static mrb_value mrb_mod_included_modules(mrb_state *mrb, mrb_value self) { @@ -1393,6 +1404,8 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, ARGS_NONE()); /* 15.2.3.3.4 */ mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); /* 15.2.3.3.3 */ mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1)); + mrb_define_method(mrb, mod, "extend_object", mrb_mod_extend_object, ARGS_REQ(1)); /* 15.2.2.4.25 */ + mrb_define_method(mrb, mod, "extended", mrb_bob_init, ARGS_REQ(1)); /* 15.2.2.4.26 */ mrb_define_method(mrb, mod, "include", mrb_mod_include, ARGS_ANY()); /* 15.2.2.4.27 */ mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, ARGS_REQ(1)); /* 15.2.2.4.10 */ mrb_define_method(mrb, mod, "included", mrb_bob_init, ARGS_REQ(1)); /* 15.2.2.4.29 */ -- cgit v1.2.3 From 526dd09b7a7bbaaddfe4d73b5d407409d518742d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 17 Jul 2012 01:33:40 +0900 Subject: add Module#ancestors 15.2.2.4.9 --- src/class.c | 21 +++++++++++++++++++++ test/t/module.rb | 14 +++++++++----- 2 files changed, 30 insertions(+), 5 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 1409c0b33..976642224 100644 --- a/src/class.c +++ b/src/class.c @@ -720,6 +720,26 @@ mrb_mod_include(mrb_state *mrb, mrb_value klass) return klass; } +static mrb_value +mrb_mod_ancestors(mrb_state *mrb, mrb_value self) +{ + mrb_value result; + struct RClass *c = mrb_class_ptr(self); + + result = mrb_ary_new(mrb); + while (c) { + if (c->tt == MRB_TT_ICLASS) { + mrb_ary_push(mrb, result, mrb_obj_value(c->c)); + } + else { + mrb_ary_push(mrb, result, mrb_obj_value(c)); + } + c = c->super; + } + + return result; +} + static mrb_value mrb_mod_included_modules(mrb_state *mrb, mrb_value self) { @@ -1400,6 +1420,7 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, ARGS_NONE()); mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, ARGS_ANY()); /* 15.2.2.4.8 */ + mrb_define_method(mrb, mod, "ancestors", mrb_mod_ancestors, ARGS_NONE()); /* 15.2.2.4.9 */ mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, ARGS_ANY()); /* 15.2.2.4.41 */ mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, ARGS_REQ(1)); /* 15.2.2.4.20 */ mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, ARGS_REQ(1)); /* 15.2.2.4.21 */ diff --git a/test/t/module.rb b/test/t/module.rb index 63c2e7dc8..0e5abff81 100644 --- a/test/t/module.rb +++ b/test/t/module.rb @@ -13,6 +13,12 @@ end # TODO not implemented ATM assert('Module.nesting', '15.2.2.3.2') do +assert('Module#ancestors', '15.2.2.4.9') do + + r = String.ancestors + r.class == Array and r.include?(String) and r.include?(Object) +end + assert('Module#append_features', '15.2.2.4.10') do module Test4AppendFeatures def self.append_features(mod) @@ -100,14 +106,12 @@ assert('Module#included', '15.2.2.4.29') do end assert('Module#included_modules', '15.2.2.4.30') do - r1 = true module Test4includedModules - Const4Included = 42 end module Test4includedModules2 - r1 = included Test4includedModules + include Test4includedModules end - Test4includedModules2.included_modules.class == Array + r = Test4includedModules2.included_modules + r.class == Array and r.include?(Test4includedModules) end - -- cgit v1.2.3 From e8ade38104e006ca4b41332f1e61e4f4392162e6 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 17 Jul 2012 02:17:16 +0900 Subject: undef append_features for Classes --- src/class.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 2784327f3..e1a325b51 100644 --- a/src/class.c +++ b/src/class.c @@ -1441,4 +1441,5 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "define_method", mod_define_method, ARGS_REQ(1)); mrb_define_method(mrb, mod, "===", mrb_mod_eqq, ARGS_REQ(1)); + mrb_undef_method(mrb, cls, "append_features"); } -- cgit v1.2.3 From 8ce2af99f37caba9d5b8494195c2d096c652c3aa Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 17 Jul 2012 03:31:56 +0900 Subject: CRuby style inclusion order; close #377 --- src/class.c | 52 +++++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 25 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index e1a325b51..d0063529d 100644 --- a/src/class.c +++ b/src/class.c @@ -653,40 +653,42 @@ boot_defclass(mrb_state *mrb, struct RClass *super) return c; } -static int -find_in_ancestors(struct RClass *c, struct RClass *m) -{ - while(c) { - if (c == m || c->mt == m->mt){ - return 1; - } - c = c->super; - } - return 0; -} - void mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m) { - struct RClass *ic, *ins_pos; + struct RClass *ins_pos; ins_pos = c; while (m) { - if (!find_in_ancestors(c, m)) { - ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); - if (m->tt == MRB_TT_ICLASS) { - ic->c = m->c; + struct RClass *p = c, *ic; + int superclass_seen = 0; + + while(p) { + if (c != p && p->tt == MRB_TT_CLASS) { + superclass_seen = 1; } - else { - ic->c = m; + else if (p->mt == m->mt){ + if (p->tt == MRB_TT_ICLASS && !superclass_seen) { + ins_pos = p; + } + goto skip; } - ic->mt = m->mt; - ic->iv = m->iv; - ic->super = ins_pos->super; - ins_pos->super = ic; - mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic); - ins_pos = ic; + p = p->super; + } + ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class); + if (m->tt == MRB_TT_ICLASS) { + ic->c = m->c; + } + else { + ic->c = m; } + ic->mt = m->mt; + ic->iv = m->iv; + ic->super = ins_pos->super; + ins_pos->super = ic; + mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic); + ins_pos = ic; + skip: m = m->super; } } -- cgit v1.2.3 From 265aa0b885e330001b0bf3dd5c6468e5c74f3e59 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Wed, 18 Jul 2012 02:07:42 +0900 Subject: Undef Class#extend_object. --- src/class.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index d0063529d..027eceb10 100644 --- a/src/class.c +++ b/src/class.c @@ -1444,4 +1444,5 @@ mrb_init_class(mrb_state *mrb) mrb_define_method(mrb, mod, "===", mrb_mod_eqq, ARGS_REQ(1)); mrb_undef_method(mrb, cls, "append_features"); + mrb_undef_method(mrb, cls, "extend_object"); } -- cgit v1.2.3 From a0c4f8558b15f1b5de0cb22f2d45d215f15ecd08 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Wed, 18 Jul 2012 02:17:29 +0900 Subject: Kernel#respond_to? should return false if the method is undefined. --- src/class.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index d0063529d..8a58eb70e 100644 --- a/src/class.c +++ b/src/class.c @@ -1052,8 +1052,14 @@ mrb_obj_respond_to(struct RClass* c, mrb_sym mid) if (h) { k = kh_get(mt, h, mid); - if (k != kh_end(h)) - return 1; /* exist method */ + if (k != kh_end(h)) { + if (kh_value(h, k)) { + return 1; /* exist method */ + } + else { + return 0; + } + } } c = c->super; } -- cgit v1.2.3 From 7bb71a7d5826accc50a521e770b5b7afe283ad90 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Tue, 26 Jun 2012 16:02:38 +0900 Subject: Remove magic numbers in mrb_funcall() --- src/class.c | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 7f53b7a2b..bf63198dd 100644 --- a/src/class.c +++ b/src/class.c @@ -7,6 +7,7 @@ #include "mruby.h" #include #include +#include #include "mruby/class.h" #include "mruby/proc.h" #include "mruby/string.h" @@ -863,26 +864,31 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) } mrb_value -mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc,...) +mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) { - mrb_value args[16]; + mrb_value *args; + mrb_value result; va_list ap; int i; - if (argc == 0) { - for (i=0; i<5; i++) { - args[i] = mrb_nil_value(); - } - } - else { + if (argc != 0) { + args = mrb_malloc(mrb, sizeof(mrb_value) * argc); + assert(args != 0); + va_start(ap, argc); - // assert(argc < 16); - for (i=0; i Date: Wed, 18 Jul 2012 15:47:57 +0900 Subject: MRB_FUNCALL_ARGC_MAX support. (refs comments in #324). --- include/mrbconf.h | 4 ++++ src/class.c | 20 +++++++++++++++----- 2 files changed, 19 insertions(+), 5 deletions(-) (limited to 'src/class.c') diff --git a/include/mrbconf.h b/include/mrbconf.h index 5d307e66f..757192d89 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -23,6 +23,10 @@ #undef HAVE_UNISTD_H /* WINDOWS */ #define HAVE_UNISTD_H /* LINUX */ + +#define MRB_FUNCALL_ARGC_MAX 16U /* Allocate arrays using auto variable. */ +//#undef MRB_FUNCALL_ARGC_MAX /* Allocate arrays using mrb_malloc if undefned. */ + /* end of configuration */ #ifdef MRB_USE_FLOAT diff --git a/src/class.c b/src/class.c index bf63198dd..762fa1591 100644 --- a/src/class.c +++ b/src/class.c @@ -7,7 +7,6 @@ #include "mruby.h" #include #include -#include #include "mruby/class.h" #include "mruby/proc.h" #include "mruby/string.h" @@ -866,27 +865,38 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) mrb_value mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) { - mrb_value *args; +#if defined(MRB_FUNCALL_ARGC_MAX) + mrb_value args[MRB_FUNCALL_ARGC_MAX]; +#else + mrb_value *args = NULL; +#endif mrb_value result; va_list ap; int i; if (argc != 0) { +#if !defined(MRB_FUNCALL_ARGC_MAX) args = mrb_malloc(mrb, sizeof(mrb_value) * argc); - assert(args != 0); +#else + if (argc > MRB_FUNCALL_ARGC_MAX) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX); + } +#endif va_start(ap, argc); for (i = 0; i < argc; i++) { args[i] = va_arg(ap, mrb_value); } va_end(ap); - } else { - args = NULL; } + result = mrb_funcall_argv(mrb, self, name, argc, args); + +#if !defined(MRB_FUNCALL_ARGC_MAX) if (args != NULL) { mrb_free(mrb, args); } +#endif return result; } -- cgit v1.2.3 From 4b9ef5dabee09115edc15ecad05b335ecfaf598d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 19 Jul 2012 17:45:13 +0900 Subject: use no malloc in mrb_funcall; close #386 --- include/mrbconf.h | 5 ++--- src/class.c | 24 +++++------------------- 2 files changed, 7 insertions(+), 22 deletions(-) (limited to 'src/class.c') diff --git a/include/mrbconf.h b/include/mrbconf.h index 757192d89..cf8217b23 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -21,12 +21,11 @@ //#define DISABLE_STRUCT /* Struct class */ //#define DISABLE_STDIO /* use of stdio */ +//#define MRB_FUNCALL_ARGC_MAX 16 /* argv size in mrb_funcall */ + #undef HAVE_UNISTD_H /* WINDOWS */ #define HAVE_UNISTD_H /* LINUX */ -#define MRB_FUNCALL_ARGC_MAX 16U /* Allocate arrays using auto variable. */ -//#undef MRB_FUNCALL_ARGC_MAX /* Allocate arrays using mrb_malloc if undefned. */ - /* end of configuration */ #ifdef MRB_USE_FLOAT diff --git a/src/class.c b/src/class.c index 762fa1591..38eb5ea1f 100644 --- a/src/class.c +++ b/src/class.c @@ -862,26 +862,21 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) return m; } +#ifndef MRB_FUNCALL_ARGC_MAX +#define MRB_FUNCALL_ARGC_MAX 16 +#endif + mrb_value mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) { -#if defined(MRB_FUNCALL_ARGC_MAX) mrb_value args[MRB_FUNCALL_ARGC_MAX]; -#else - mrb_value *args = NULL; -#endif - mrb_value result; va_list ap; int i; if (argc != 0) { -#if !defined(MRB_FUNCALL_ARGC_MAX) - args = mrb_malloc(mrb, sizeof(mrb_value) * argc); -#else if (argc > MRB_FUNCALL_ARGC_MAX) { mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX); } -#endif va_start(ap, argc); for (i = 0; i < argc; i++) { @@ -889,16 +884,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) } va_end(ap); } - - result = mrb_funcall_argv(mrb, self, name, argc, args); - -#if !defined(MRB_FUNCALL_ARGC_MAX) - if (args != NULL) { - mrb_free(mrb, args); - } -#endif - - return result; + return mrb_funcall_argv(mrb, self, name, argc, args); } -- cgit v1.2.3 From a4c6b1c75edc7308a9751ebc1858d86774434542 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sun, 22 Jul 2012 00:35:49 +0900 Subject: Remove initialization of mt. --- src/class.c | 1 - 1 file changed, 1 deletion(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 38eb5ea1f..b8532cdcc 100644 --- a/src/class.c +++ b/src/class.c @@ -115,7 +115,6 @@ mrb_define_module_id(mrb_state *mrb, mrb_sym name) { struct RClass *m = mrb_module_new(mrb); - m->mt = kh_init(mt, mrb); mrb_obj_iv_set(mrb, (struct RObject*)mrb->object_class, name, mrb_obj_value(m)); mrb_name_class(mrb, m, name); -- cgit v1.2.3 From ea259129993cf7eb6ffc0b8bb76719913fea314c Mon Sep 17 00:00:00 2001 From: Max Anselm Date: Wed, 25 Jul 2012 18:22:26 -0400 Subject: Undefine new for class rather than instance. Applies to NilClass, TrueClass, FalseClass, Fixnum, and Float. Add mrb_undef_class_method for DRYness. --- include/mruby.h | 1 + src/class.c | 6 ++++++ src/numeric.c | 4 ++-- src/object.c | 6 +++--- src/re.c | 2 +- 5 files changed, 13 insertions(+), 6 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby.h b/include/mruby.h index 4fd7bccd5..6fcda4d35 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -296,6 +296,7 @@ void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_f void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t,int); void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value); void mrb_undef_method(mrb_state*, struct RClass*, const char*); +void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); struct RClass * mrb_module_new(mrb_state *mrb); diff --git a/src/class.c b/src/class.c index b8532cdcc..f0393c7ec 100644 --- a/src/class.c +++ b/src/class.c @@ -1307,6 +1307,12 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name) undef_method(mrb, c, mrb_intern(mrb, name)); } +void +mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name) +{ + mrb_undef_method(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name); +} + mrb_value mrb_mod_undef(mrb_state *mrb, mrb_value mod) { diff --git a/src/numeric.c b/src/numeric.c index ec3f97ca6..d294597ee 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1288,7 +1288,7 @@ mrb_init_numeric(mrb_state *mrb) integer = mrb_define_class(mrb, "Integer", numeric); fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer); - mrb_undef_method(mrb, fixnum, "new"); + mrb_undef_class_method(mrb, fixnum, "new"); mrb_define_method(mrb, fixnum, "+", fix_plus, ARGS_REQ(1)); /* 15.2.8.3.1 */ mrb_define_method(mrb, fixnum, "-", fix_minus, ARGS_REQ(1)); /* 15.2.8.3.2 */ mrb_define_method(mrb, fixnum, "-@", fix_uminus, ARGS_REQ(1)); /* 15.2.7.4.2 */ @@ -1316,7 +1316,7 @@ mrb_init_numeric(mrb_state *mrb) /* Float Class */ fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric); - mrb_undef_method(mrb, fl, "new"); + mrb_undef_class_method(mrb, fl, "new"); mrb_define_method(mrb, fl, "+", flo_plus, ARGS_REQ(1)); /* 15.2.9.3.1 */ mrb_define_method(mrb, fl, "-", flo_minus, ARGS_REQ(1)); /* 15.2.9.3.2 */ mrb_define_method(mrb, fl, "*", flo_mul, ARGS_REQ(1)); /* 15.2.9.3.3 */ diff --git a/src/object.c b/src/object.c index 29684b118..43e064fb0 100644 --- a/src/object.c +++ b/src/object.c @@ -275,7 +275,7 @@ mrb_init_object(mrb_state *mrb) struct RClass *f; n = mrb->nil_class = mrb_define_class(mrb, "NilClass", mrb->object_class); - mrb_undef_method(mrb, n, "new"); + mrb_undef_class_method(mrb, n, "new"); mrb_define_method(mrb, n, "&", false_and, ARGS_REQ(1)); /* 15.2.4.3.1 */ mrb_define_method(mrb, n, "^", false_xor, ARGS_REQ(1)); /* 15.2.4.3.2 */ mrb_define_method(mrb, n, "|", false_or, ARGS_REQ(1)); /* 15.2.4.3.3 */ @@ -283,14 +283,14 @@ mrb_init_object(mrb_state *mrb) mrb_define_method(mrb, n, "to_s", nil_to_s, ARGS_NONE()); /* 15.2.4.3.5 */ t = mrb->true_class = mrb_define_class(mrb, "TrueClass", mrb->object_class); - mrb_undef_method(mrb, n, "new"); + mrb_undef_class_method(mrb, t, "new"); mrb_define_method(mrb, t, "&", true_and, ARGS_REQ(1)); /* 15.2.5.3.1 */ mrb_define_method(mrb, t, "^", true_xor, ARGS_REQ(1)); /* 15.2.5.3.2 */ mrb_define_method(mrb, t, "to_s", true_to_s, ARGS_NONE()); /* 15.2.5.3.3 */ mrb_define_method(mrb, t, "|", true_or, ARGS_REQ(1)); /* 15.2.5.3.4 */ f = mrb->false_class = mrb_define_class(mrb, "FalseClass", mrb->object_class); - mrb_undef_method(mrb, n, "new"); + mrb_undef_class_method(mrb, f, "new"); mrb_define_method(mrb, f, "&", false_and, ARGS_REQ(1)); /* 15.2.6.3.1 */ mrb_define_method(mrb, f, "^", false_xor, ARGS_REQ(1)); /* 15.2.6.3.2 */ mrb_define_method(mrb, f, "to_s", false_to_s, ARGS_NONE()); /* 15.2.6.3.3 */ diff --git a/src/re.c b/src/re.c index 3639a41c6..f3cfea484 100644 --- a/src/re.c +++ b/src/re.c @@ -2041,7 +2041,7 @@ mrb_init_regexp(mrb_state *mrb) mrb_define_const(mrb, s, "FIXEDENCODING", mrb_fixnum_value(ARG_ENCODING_FIXED)); s = mrb_define_class(mrb, "MatchData", mrb->object_class); - //mrb_undef_method(CLASS_OF(rb_cMatch), "new"); + //mrb_undef_class_method(CLASS_OF(rb_cMatch), "new"); mrb_define_method(mrb, s, "[]", mrb_match_aref, ARGS_ANY()); /* 15.2.16.3.1 */ mrb_define_method(mrb, s, "begin", mrb_match_begin, ARGS_REQ(1)); /* 15.2.16.3.2 */ -- cgit v1.2.3 From 99e2035f42c0f29b316b335a91085ae6fbde5893 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sat, 14 Jul 2012 23:07:00 +0900 Subject: Modify mrb_vm_define_class. * Check mismatch of superclass. * Check constant value whose name is specified as a class's name. --- src/class.c | 37 +++++++++++++++++++++++-------------- 1 file changed, 23 insertions(+), 14 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index f0393c7ec..6efc9f5e7 100644 --- a/src/class.c +++ b/src/class.c @@ -187,30 +187,39 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super) struct RClass* mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id) { - struct RClass *c = 0; + struct RClass *c, *s; if (mrb_const_defined(mrb, outer, id)) { mrb_value v = mrb_const_get(mrb, outer, id); + mrb_check_type(mrb, v, MRB_TT_CLASS); c = mrb_class_ptr(v); - if (!mrb_nil_p(super) && (c->tt != MRB_TT_CLASS || c->super != mrb_class_ptr(super))) { - c = 0; + if (!mrb_nil_p(super)) { + if (mrb_type(super) != MRB_TT_CLASS) { + mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); + } + + if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) { + mrb_raise(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id)); + } } + + return c; } - if (!c) { - struct RClass *s = 0; - if (!mrb_nil_p(super)) { - mrb_check_type(mrb, super, MRB_TT_CLASS); - s = mrb_class_ptr(super); - } - if (!s) { - s = mrb->object_class; + if (!mrb_nil_p(super)) { + if (mrb_type(super) != MRB_TT_CLASS) { + mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); } - c = mrb_class_new(mrb, s); - setup_class(mrb, outer, c, id); - mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c)); + s = mrb_class_ptr(super); } + else { + s = mrb->object_class; + } + + c = mrb_class_new(mrb, s); + setup_class(mrb, outer, c, id); + mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c)); return c; } -- cgit v1.2.3 From d271bf0aa6e44a315802cf4246f5b92552be010a Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 1 Aug 2012 13:15:02 +0900 Subject: make mrb_funcall_argv and mrb_funcall_with_block to take mrb_sym as a method name --- include/mruby.h | 4 ++-- src/class.c | 36 ++++++++++++++++++++++++------------ src/error.c | 17 ++++++++++------- src/kernel.c | 2 +- src/re.c | 2 +- src/variable.c | 4 ++-- src/vm.c | 10 ++++++---- 7 files changed, 46 insertions(+), 29 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby.h b/include/mruby.h index 6fcda4d35..451b4eb8b 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -330,8 +330,8 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co int mrb_get_args(mrb_state *mrb, const char *format, ...); mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...); -mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*); -mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, mrb_value); +mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*); +mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value); mrb_sym mrb_intern(mrb_state*,const char*); mrb_sym mrb_intern2(mrb_state*,const char*,int); mrb_sym mrb_intern_str(mrb_state*,mrb_value); diff --git a/src/class.c b/src/class.c index 6efc9f5e7..50d0b6317 100644 --- a/src/class.c +++ b/src/class.c @@ -723,8 +723,8 @@ mrb_mod_include(mrb_state *mrb, mrb_value klass) mrb_check_type(mrb, argv[i], MRB_TT_MODULE); } while (argc--) { - mrb_funcall_argv(mrb, argv[argc], "append_features", 1, &klass); - mrb_funcall_argv(mrb, argv[argc], "included", 1, &klass); + mrb_funcall(mrb, argv[argc], "append_features", 1, klass); + mrb_funcall(mrb, argv[argc], "included", 1, klass); } return klass; @@ -877,29 +877,41 @@ mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid) mrb_value mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...) { - mrb_value args[MRB_FUNCALL_ARGC_MAX]; + mrb_sym mid = mrb_intern(mrb, name); va_list ap; int i; - if (argc != 0) { + if (argc == 0) { + return mrb_funcall_argv(mrb, self, mid, 0, 0); + } + else if (argc == 1) { + mrb_value v; + + va_start(ap, argc); + v = va_arg(ap, mrb_value); + va_end(ap); + return mrb_funcall_argv(mrb, self, mid, 1, &v); + } + else { + mrb_value argv[MRB_FUNCALL_ARGC_MAX]; + if (argc > MRB_FUNCALL_ARGC_MAX) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)\n", MRB_FUNCALL_ARGC_MAX); - } + mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=%d)", MRB_FUNCALL_ARGC_MAX); + } va_start(ap, argc); for (i = 0; i < argc; i++) { - args[i] = va_arg(ap, mrb_value); + argv[i] = va_arg(ap, mrb_value); } va_end(ap); + return mrb_funcall_argv(mrb, self, mid, argc, argv); } - return mrb_funcall_argv(mrb, self, name, argc, args); } - void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv) { - mrb_funcall_argv(mrb, obj, "initialize", argc, argv); + mrb_funcall_argv(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv); } /* @@ -938,7 +950,7 @@ mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass) c = (struct RClass*)mrb_obj_alloc(mrb, k->tt, k); c->super = k; obj = mrb_obj_value(c); - mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk); + mrb_funcall_with_block(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv, blk); return obj; } @@ -957,7 +969,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv) o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c); obj = mrb_obj_value(o); mrb_get_args(mrb, "*&", &argv, &argc, &blk); - mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk); + mrb_funcall_with_block(mrb, obj, mrb_intern(mrb, "initialize"), argc, argv, blk); return obj; } diff --git a/src/error.c b/src/error.c index e71245509..6fe839cb2 100644 --- a/src/error.c +++ b/src/error.c @@ -144,7 +144,7 @@ exc_equal(mrb_state *mrb, mrb_value exc) if (mrb_obj_equal(mrb, exc, obj)) return mrb_true_value(); if (mrb_obj_class(mrb, exc) != mrb_obj_class(mrb, obj)) { - if ( mrb_respond_to(mrb, obj, mrb_intern(mrb, "message")) ) { + if (mrb_respond_to(mrb, obj, mrb_intern(mrb, "message"))) { mesg = mrb_funcall(mrb, obj, "message", 0); } else @@ -306,12 +306,15 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr) case 3: n = 1; exception_call: - if (mrb_respond_to(mrb, argv[0], mrb_intern(mrb, "exception"))) { - mesg = mrb_funcall_argv(mrb, argv[0], "exception", n, argv+1); - } - else { - /* undef */ - mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected"); + { + mrb_sym exc = mrb_intern(mrb, "exception"); + if (mrb_respond_to(mrb, argv[0], exc)) { + mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1); + } + else { + /* undef */ + mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected"); + } } break; diff --git a/src/kernel.c b/src/kernel.c index 36dfbe769..740960f80 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -245,7 +245,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self) int argc; mrb_get_args(mrb, "n*&", &name, &argv, &argc, &block); - return mrb_funcall_with_block(mrb,self, mrb_sym2name(mrb, name), argc, argv, block); + return mrb_funcall_with_block(mrb,self, name, argc, argv, block); } /* 15.3.1.2.2 */ diff --git a/src/re.c b/src/re.c index f3cfea484..0022f9a9c 100644 --- a/src/re.c +++ b/src/re.c @@ -76,7 +76,7 @@ mrb_reg_s_new_instance(mrb_state *mrb, /*int argc, mrb_value *argv, */mrb_value re->ptr = 0; re->src = 0; re->usecnt = 0; - return mrb_funcall_argv(mrb, mrb_obj_value(re), "initialize", argc, argv); + return mrb_funcall_argv(mrb, mrb_obj_value(re), mrb_intern(mrb, "initialize"), argc, argv); } mrb_value diff --git a/src/variable.c b/src/variable.c index b81b292d9..a62e7e126 100644 --- a/src/variable.c +++ b/src/variable.c @@ -320,8 +320,8 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym) return kh_value(h, k); } if (mrb_respond_to(mrb, mrb_obj_value(c), cm)) { - mrb_value argv = mrb_symbol_value(sym); - return mrb_funcall_argv(mrb, mrb_obj_value(c), "const_missing", 1, &argv); + mrb_value name = mrb_symbol_value(sym); + return mrb_funcall(mrb, mrb_obj_value(c), "const_missing", 1, name); } } c = c->super; diff --git a/src/vm.c b/src/vm.c index 2a13f0ea4..130e56071 100644 --- a/src/vm.c +++ b/src/vm.c @@ -179,16 +179,18 @@ ecall(mrb_state *mrb, int i) } mrb_value -mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, mrb_value blk) +mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mrb_value *argv, mrb_value blk) { struct RProc *p; struct RClass *c; - mrb_sym mid = mrb_intern(mrb, name); mrb_sym undef = 0; mrb_callinfo *ci; int n = mrb->ci->nregs; mrb_value val; + if (argc < 0) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argc for funcall (%d)", argc); + } c = mrb_class(mrb, self); p = mrb_method_search_vm(mrb, &c, mid); if (!p) { @@ -232,9 +234,9 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int arg } mrb_value -mrb_funcall_argv(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv) +mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, mrb_value *argv) { - return mrb_funcall_with_block(mrb, self, name, argc, argv, mrb_nil_value()); + return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value()); } mrb_value -- cgit v1.2.3 From 6491693d00038f62f8b4f8f3c5cef93068f65956 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 2 Aug 2012 22:03:53 +0900 Subject: mrb_get_args("&") gave wrong value --- src/class.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 50d0b6317..d6c7a92fb 100644 --- a/src/class.c +++ b/src/class.c @@ -602,12 +602,15 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) case '&': { - mrb_value *p, *bp = mrb->stack + 1; + mrb_value *p, *bp; p = va_arg(ap, mrb_value*); - if (mrb->ci->argc > 0) { - bp += mrb->ci->argc; + if (mrb->ci->argc < 0) { + bp = mrb->stack + 2; } + else { + bp = mrb->stack + mrb->ci->argc + 1; + } *p = *bp; } break; -- cgit v1.2.3 From f121558f9379c92a20051e3d87489d4c8125e9f9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 3 Aug 2012 19:55:01 +0900 Subject: mrb_define_method_vm should update target_class --- src/class.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index d6c7a92fb..13c2d0469 100644 --- a/src/class.c +++ b/src/class.c @@ -328,10 +328,13 @@ mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value b { khash_t(mt) *h = c->mt; khiter_t k; + struct RProc *p; if (!h) h = c->mt = kh_init(mt, mrb); k = kh_put(mt, h, name); - kh_value(h, k) = mrb_proc_ptr(body); + p = mrb_proc_ptr(body); + if (p) p->target_class = c; + kh_value(h, k) = p; } static mrb_value -- cgit v1.2.3 From 77aa261f3bcb9ab93e1ea9a9d89f8cba51b98873 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 3 Aug 2012 19:56:14 +0900 Subject: mrb_singleton_class should raise TypeError for immediate objects --- src/class.c | 7 ++++++- src/kernel.c | 14 ++++++++++++-- 2 files changed, 18 insertions(+), 3 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index 13c2d0469..29ec18e13 100644 --- a/src/class.c +++ b/src/class.c @@ -807,11 +807,16 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v) switch (mrb_type(v)) { case MRB_TT_FALSE: + if (mrb_nil_p(v)) + return mrb_obj_value(mrb->nil_class); + return mrb_obj_value(mrb->false_class); case MRB_TT_TRUE: + return mrb_obj_value(mrb->true_class); case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: case MRB_TT_FLOAT: - return mrb_nil_value(); /* should raise TypeError */ + mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton"); + return mrb_nil_value(); /* not reached */ default: break; } diff --git a/src/kernel.c b/src/kernel.c index 740960f80..6327f967d 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -550,12 +550,22 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self) { mrb_value a, b; mrb_value cv; + struct RClass *c; if (mrb_get_args(mrb, "|S&", &a, &b) == 1) { mrb_raise(mrb, E_NOTIMP_ERROR, "instance_eval with string not implemented"); } - cv = mrb_singleton_class(mrb, self); - return mrb_yield_internal(mrb, b, 0, 0, self, mrb_class_ptr(cv)); + switch (mrb_type(self)) { + case MRB_TT_SYMBOL: + case MRB_TT_FIXNUM: + case MRB_TT_FLOAT: + c = 0; + break; + default: + cv = mrb_singleton_class(mrb, self); + c = mrb_class_ptr(cv); + } + return mrb_yield_internal(mrb, b, 0, 0, self, c); } int -- cgit v1.2.3 From 730f53045eb85cf995b0b675ea2818a682810a4f Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 3 Aug 2012 20:17:04 +0900 Subject: define_method to copy block body --- include/mruby/proc.h | 1 + src/class.c | 7 +++++-- src/proc.c | 10 +++++----- 3 files changed, 11 insertions(+), 7 deletions(-) (limited to 'src/class.c') diff --git a/include/mruby/proc.h b/include/mruby/proc.h index 8f178790e..f6bef23a5 100644 --- a/include/mruby/proc.h +++ b/include/mruby/proc.h @@ -49,6 +49,7 @@ struct RProc { struct RProc *mrb_proc_new(mrb_state*, mrb_irep*); struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t); struct RProc *mrb_closure_new(mrb_state*, mrb_irep*); +void mrb_proc_copy(struct RProc *a, struct RProc *b); #include "mruby/khash.h" KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1); diff --git a/src/class.c b/src/class.c index 29ec18e13..df42820e5 100644 --- a/src/class.c +++ b/src/class.c @@ -1364,14 +1364,17 @@ static mrb_value mod_define_method(mrb_state *mrb, mrb_value self) { struct RClass *c = mrb_class_ptr(self); + struct RProc *p; mrb_sym mid; mrb_value blk; mrb_get_args(mrb, "n&", &mid, &blk); if (mrb_nil_p(blk)) { - /* raise */ + mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given"); } - mrb_define_method_raw(mrb, c, mid, mrb_proc_ptr(blk)); + p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); + mrb_proc_copy(p, mrb_proc_ptr(blk)); + mrb_define_method_raw(mrb, c, mid, p); return blk; } diff --git a/src/proc.c b/src/proc.c index d223fa760..a1f8b180e 100644 --- a/src/proc.c +++ b/src/proc.c @@ -55,8 +55,8 @@ mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func) return p; } -static inline void -proc_copy(struct RProc *a, struct RProc *b) +void +mrb_proc_copy(struct RProc *a, struct RProc *b) { a->flags = b->flags; a->body = b->body; @@ -75,7 +75,7 @@ mrb_proc_initialize(mrb_state *mrb, mrb_value self) mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block"); } else { - proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(blk)); + mrb_proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(blk)); } return self; } @@ -89,7 +89,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self) if (mrb_type(proc) != MRB_TT_PROC) { mrb_raise(mrb, E_ARGUMENT_ERROR, "not a proc"); } - proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(proc)); + mrb_proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(proc)); return self; } @@ -133,7 +133,7 @@ proc_lambda(mrb_state *mrb, mrb_value self) p = mrb_proc_ptr(blk); if (!MRB_PROC_STRICT_P(p)) { struct RProc *p2 = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, p->c); - proc_copy(p2, p); + mrb_proc_copy(p2, p); p2->flags |= MRB_PROC_STRICT; return mrb_obj_value(p2); } -- cgit v1.2.3 From 472d214a71f69fe25e681d9fea6a04fa12e60fb0 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 4 Aug 2012 06:44:53 +0900 Subject: super look-up scheme fixed; close #415 --- src/class.c | 1 - src/proc.c | 2 +- src/vm.c | 5 ++--- 3 files changed, 3 insertions(+), 5 deletions(-) (limited to 'src/class.c') diff --git a/src/class.c b/src/class.c index df42820e5..7802c34bd 100644 --- a/src/class.c +++ b/src/class.c @@ -333,7 +333,6 @@ mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value b if (!h) h = c->mt = kh_init(mt, mrb); k = kh_put(mt, h, name); p = mrb_proc_ptr(body); - if (p) p->target_class = c; kh_value(h, k) = p; } diff --git a/src/proc.c b/src/proc.c index a1f8b180e..e5c233e1b 100644 --- a/src/proc.c +++ b/src/proc.c @@ -15,8 +15,8 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep) struct RProc *p; p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class); - p->body.irep = irep; p->target_class = (mrb->ci) ? mrb->ci->target_class : 0; + p->body.irep = irep; p->env = 0; return p; diff --git a/src/vm.c b/src/vm.c index c2b461fd0..be6ee3944 100644 --- a/src/vm.c +++ b/src/vm.c @@ -717,7 +717,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) ci->stackidx = mrb->stack - mrb->stbase; ci->argc = n; if (ci->argc == CALL_MAXARGS) ci->argc = -1; - ci->target_class = m->target_class; + ci->target_class = c; ci->pc = pc + 1; ci->acc = a; @@ -832,10 +832,9 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) int n = GETARG_C(i); recv = regs[0]; - c = mrb->ci->proc->target_class->super; + c = mrb->ci->target_class->super; m = mrb_method_search_vm(mrb, &c, mid); if (!m) { - c = mrb->ci->proc->target_class; mid = mrb_intern(mrb, "method_missing"); m = mrb_method_search_vm(mrb, &c, mid); if (n == CALL_MAXARGS) { -- cgit v1.2.3