From 12d75223d62ed90f334980c3a15e96618250fe90 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 07:55:39 +0900 Subject: make shared string to reference-counted C structure to reduce GC pressure --- src/string.c | 53 ++++++++++++++++++++++++++++------------------------- 1 file changed, 28 insertions(+), 25 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 26ed7b052..3d59948f3 100644 --- a/src/string.c +++ b/src/string.c @@ -49,6 +49,7 @@ str_modify(mrb_state *mrb, struct RString *s) if (s->flags & MRB_STR_SHARED) { char *ptr, *p; long len; + struct mrb_shared_string *shared = s->aux.shared; p = s->buf; len = s->len; @@ -61,6 +62,12 @@ str_modify(mrb_state *mrb, struct RString *s) s->len = len; s->aux.capa = len; s->flags &= ~MRB_STR_SHARED; + + shared->refcnt--; + if (shared->refcnt == 0) { + mrb_free(mrb, shared->buf); + mrb_free(mrb, shared); + } } } @@ -76,9 +83,7 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len) if (slen < len || slen -len > 1024) { s->buf = mrb_realloc(mrb, s->buf, len+1); } - if (!(s->flags & MRB_STR_SHARED)) { - s->aux.capa = len; - } + s->aux.capa = len; s->len = len; s->buf[len] = '\0'; /* sentinel */ } @@ -178,13 +183,13 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) } if (len == 0) return; capa = s->aux.capa; - if (s->len >= LONG_MAX - len) { + if (s->len >= INT_MAX - len) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big"); } total = s->len+len; if (capa <= total) { while (total > capa) { - if (capa + 1 >= LONG_MAX / 2) { + if (capa + 1 >= INT_MAX / 2) { capa = (total + 4095) / 4096; break; } @@ -258,12 +263,16 @@ str_make_shared(mrb_state *mrb, mrb_value str) str_with_class(mrb, s, str); orig = mrb_str_ptr(str); if (!(orig->flags & MRB_STR_SHARED)) { - struct RString *shared = mrb_obj_alloc_string(mrb); + struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string)); - shared->buf = orig->buf; + shared->refcnt = 1; + if (orig->aux.capa > orig->len) { + shared->buf = mrb_realloc(mrb, shared->buf, orig->len+1); + } + else { + shared->buf = orig->buf; + } shared->len = orig->len; - shared->aux.capa = orig->aux.capa; - orig->aux.shared = shared; orig->flags |= MRB_STR_SHARED; } @@ -285,16 +294,19 @@ str_make_shared(mrb_state *mrb, mrb_value str) mrb_value mrb_str_literal(mrb_state *mrb, mrb_value str) { - struct RString *orig, *s; + struct RString *s, *orig; + struct mrb_shared_string *shared; s = str_new(mrb, 0, 0); orig = mrb_str_ptr(str); - while (orig->flags & MRB_STR_SHARED) { - orig = orig->aux.shared; + if (!(orig->flags & MRB_STR_SHARED)) { + str_make_shared(mrb, str); } - s->buf = orig->buf; - s->len = orig->len; - s->aux.shared = orig; + shared = orig->aux.shared; + shared->refcnt++; + s->buf = shared->buf; + s->len = shared->len; + s->aux.shared = shared; s->flags |= MRB_STR_SHARED; return mrb_obj_value(s); @@ -2849,19 +2861,10 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len) { - struct RString *s = mrb_str_ptr(str); - if (len < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)"); } - if (0/*STR_ASSOC_P(str)*/) { - mrb_realloc(mrb, s->buf, s->len+len+1); - memcpy(s->buf + s->len, ptr, len); - s->len += len; - s->buf[s->len] = '\0'; /* sentinel */ - return str; - } - str_buf_cat(mrb, s, ptr, len); + str_buf_cat(mrb, mrb_str_ptr(str), ptr, len); return str; } -- cgit v1.2.3 From 52fdeb02253b31616f92ec4e5bdcd365998c21bd Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 09:05:09 +0900 Subject: str_make_shared not to return new string --- src/string.c | 39 +++++++++++++++++---------------------- 1 file changed, 17 insertions(+), 22 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 3d59948f3..6d37597d8 100644 --- a/src/string.c +++ b/src/string.c @@ -36,7 +36,7 @@ const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote); #endif //INCLUDE_REGEXP static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2); -static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, long beg, long len); +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);\ @@ -254,34 +254,26 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) return mrb_obj_value(s); } -static struct RString* +static void str_make_shared(mrb_state *mrb, mrb_value str) { - struct RString *orig, *s; + struct RString *s; - s = str_new(mrb, 0, 0); - str_with_class(mrb, s, str); - orig = mrb_str_ptr(str); - if (!(orig->flags & MRB_STR_SHARED)) { + s = mrb_str_ptr(str); + if (!(s->flags & MRB_STR_SHARED)) { struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string)); shared->refcnt = 1; - if (orig->aux.capa > orig->len) { - shared->buf = mrb_realloc(mrb, shared->buf, orig->len+1); + if (s->aux.capa > s->len) { + shared->buf = mrb_realloc(mrb, shared->buf, s->len+1); } else { - shared->buf = orig->buf; + shared->buf = s->buf; } - shared->len = orig->len; - orig->aux.shared = shared; - orig->flags |= MRB_STR_SHARED; + shared->len = s->len; + s->aux.shared = shared; + s->flags |= MRB_STR_SHARED; } - s->buf = orig->buf; - s->len = orig->len; - s->aux.shared = orig->aux.shared; - s->flags |= MRB_STR_SHARED; - - return s; } /* @@ -1196,12 +1188,15 @@ mrb_str_eql(mrb_state *mrb, mrb_value self) } static mrb_value -mrb_str_subseq(mrb_state *mrb, mrb_value str, long beg, long len) +mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) { struct RString *s; + struct mrb_shared_string *shared; - s = str_make_shared(mrb, str); - s->buf += beg; + str_make_shared(mrb, str); + shared = RSTRING(str)->aux.shared; + s = mrb_obj_alloc_string(mrb); + s->buf = shared->buf + beg; s->len = len; return mrb_obj_value(s); -- cgit v1.2.3 From 6c2c5540e2cb549579836d9a80417b18a296344c Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 09:09:40 +0900 Subject: should initialize shared->buf as well as s->buf --- src/string.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 6d37597d8..8bc299987 100644 --- a/src/string.c +++ b/src/string.c @@ -265,7 +265,7 @@ str_make_shared(mrb_state *mrb, mrb_value str) shared->refcnt = 1; if (s->aux.capa > s->len) { - shared->buf = mrb_realloc(mrb, shared->buf, s->len+1); + s->buf = shared->buf = mrb_realloc(mrb, s->buf, s->len+1); } else { shared->buf = s->buf; -- cgit v1.2.3 From 28b9619bb4c1a560392e0f958a5a5d9cedf12bc7 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 15:45:06 +0900 Subject: should decref shared string body on gc_free --- include/mruby/string.h | 1 + src/gc.c | 4 +++- src/string.c | 16 +++++++++++----- 3 files changed, 15 insertions(+), 6 deletions(-) (limited to 'src/string.c') diff --git a/include/mruby/string.h b/include/mruby/string.h index 852c5ff02..91a59d92d 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -49,6 +49,7 @@ struct RString { #define RSTRING_END(s) (RSTRING(s)->buf + RSTRING(s)->len) #define MRB_STR_SHARED 256 +void mrb_str_decref(mrb_state*, struct mrb_shared_string*); mrb_value mrb_str_literal(mrb_state*, mrb_value); void mrb_str_concat(mrb_state*, mrb_value, mrb_value); mrb_value mrb_obj_to_str(mrb_state*, mrb_value); diff --git a/src/gc.c b/src/gc.c index 03428765c..cce35efa4 100644 --- a/src/gc.c +++ b/src/gc.c @@ -460,7 +460,9 @@ obj_free(mrb_state *mrb, struct RBasic *obj) break; case MRB_TT_STRING: - if (!(obj->flags & MRB_STR_SHARED)) + if (obj->flags & MRB_STR_SHARED) + mrb_str_decref(mrb, ((struct RString*)obj)->aux.shared); + else mrb_free(mrb, ((struct RString*)obj)->buf); break; diff --git a/src/string.c b/src/string.c index 8bc299987..6eba9cb20 100644 --- a/src/string.c +++ b/src/string.c @@ -43,6 +43,16 @@ static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) s->aux.capa = capacity;\ } while (0) +void +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); + } +} + static void str_modify(mrb_state *mrb, struct RString *s) { @@ -63,11 +73,7 @@ str_modify(mrb_state *mrb, struct RString *s) s->aux.capa = len; s->flags &= ~MRB_STR_SHARED; - shared->refcnt--; - if (shared->refcnt == 0) { - mrb_free(mrb, shared->buf); - mrb_free(mrb, shared); - } + mrb_str_decref(mrb, shared); } } -- cgit v1.2.3 From 361d0ca75d33b8618ea6e35f75eb64e4cfc8936d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 20:59:33 +0900 Subject: strig.c should properly decref shared entities --- src/string.c | 45 +++++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 6eba9cb20..2d5c67655 100644 --- a/src/string.c +++ b/src/string.c @@ -261,11 +261,8 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) } static void -str_make_shared(mrb_state *mrb, mrb_value str) +str_make_shared(mrb_state *mrb, struct RString *s) { - struct RString *s; - - s = mrb_str_ptr(str); if (!(s->flags & MRB_STR_SHARED)) { struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string)); @@ -298,7 +295,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str) s = str_new(mrb, 0, 0); orig = mrb_str_ptr(str); if (!(orig->flags & MRB_STR_SHARED)) { - str_make_shared(mrb, str); + str_make_shared(mrb, mrb_str_ptr(str)); } shared = orig->aux.shared; shared->refcnt++; @@ -1199,8 +1196,9 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) struct RString *s; struct mrb_shared_string *shared; - str_make_shared(mrb, str); - shared = RSTRING(str)->aux.shared; + s = mrb_str_ptr(str); + str_make_shared(mrb, s); + shared = s->aux.shared; s = mrb_obj_alloc_string(mrb); s->buf = shared->buf + beg; s->len = len; @@ -1541,16 +1539,35 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) return mrb_fixnum_value(pos); } +#define STR_REPLACE_SHARED_MIN 10 + static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) { - int len = s2->len; - - str_modify(mrb, s1); - s1->buf = mrb_realloc(mrb, s1->buf, len); - memcpy(s1->buf, s2->buf, len); - s1->len = s2->len; - s2->aux.capa = s2->len; + if (s2->flags & MRB_STR_SHARED) { + L_SHARE: + s1->buf = s2->buf; + s1->len = s2->len; + s1->aux.shared = s2->aux.shared; + s1->flags |= MRB_STR_SHARED; + } + else if (s2->len > STR_REPLACE_SHARED_MIN) { + str_make_shared(mrb, s2); + goto L_SHARE; + } + else { + if (s1->flags & MRB_STR_SHARED) { + mrb_str_decref(mrb, s1->aux.shared); + s1->buf = mrb_malloc(mrb, s2->len+1); + } + else { + s1->buf = mrb_realloc(mrb, s1->buf, s2->len+1); + } + memcpy(s1->buf, s2->buf, s2->len); + s1->buf[s2->len] = 0; + s1->len = s2->len; + s2->aux.capa = s2->len; + } return mrb_obj_value(s1); } -- cgit v1.2.3 From dece49750d161d74992854fb18d64d50bdaad0a9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 21:06:04 +0900 Subject: string.subseq should update shared refcnt --- src/string.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 2d5c67655..d7749c27b 100644 --- a/src/string.c +++ b/src/string.c @@ -1202,6 +1202,9 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) s = mrb_obj_alloc_string(mrb); s->buf = shared->buf + beg; s->len = len; + s->aux.shared = shared; + s->flags |= MRB_STR_SHARED; + shared->refcnt++; return mrb_obj_value(s); } -- cgit v1.2.3 From 3be1c8890774c04d65bbed87914e9453d1496eed Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 22:59:40 +0900 Subject: str_modify() revives string buffer kept in shared structure if refcnt == 1 --- src/string.c | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index d7749c27b..d09d8942b 100644 --- a/src/string.c +++ b/src/string.c @@ -57,23 +57,29 @@ static void str_modify(mrb_state *mrb, struct RString *s) { if (s->flags & MRB_STR_SHARED) { - char *ptr, *p; - long len; struct mrb_shared_string *shared = s->aux.shared; - p = s->buf; - len = s->len; - ptr = mrb_malloc(mrb, sizeof(char)*(len+1)); - if (p) { - memcpy(ptr, p, len); + if (shared->refcnt == 1 && s->buf == shared->buf) { + s->buf = shared->buf; + s->aux.capa = shared->len; + mrb_free(mrb, shared); + } + else { + char *ptr, *p; + long len; + + p = s->buf; + len = s->len; + ptr = mrb_malloc(mrb, len+1); + if (p) { + memcpy(ptr, p, len); + } + ptr[len] = 0; + s->buf = ptr; + s->aux.capa = len; + mrb_str_decref(mrb, shared); } - ptr[len] = 0; - s->buf = ptr; - s->len = len; - s->aux.capa = len; s->flags &= ~MRB_STR_SHARED; - - mrb_str_decref(mrb, shared); } } -- cgit v1.2.3 From b2e6a0fc04f6237f5118bf6c2f404a0d8fa4d2c4 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 4 Jun 2012 20:34:43 +0900 Subject: symbol can contain non printable characters --- include/mruby.h | 2 ++ src/string.c | 8 +---- src/symbol.c | 110 +++++++++++++++++++++++++++++++++++++++++--------------- 3 files changed, 85 insertions(+), 35 deletions(-) (limited to 'src/string.c') diff --git a/include/mruby.h b/include/mruby.h index 3dc160535..0ce4926a8 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -332,6 +332,8 @@ 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_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); const char *mrb_sym2name(mrb_state*,mrb_sym); mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value); diff --git a/src/string.c b/src/string.c index d09d8942b..805b52a28 100644 --- a/src/string.c +++ b/src/string.c @@ -1616,12 +1616,6 @@ mrb_str_init(mrb_state *mrb, mrb_value self) return self; } -mrb_sym -mrb_intern_str(mrb_state *mrb, mrb_value str) -{ - return mrb_intern(mrb, RSTRING_PTR(str)); -} - /* 15.2.10.5.25 */ /* 15.2.10.5.41 */ /* @@ -2817,7 +2811,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) len++; } else { - len += 4; /* \xNN */ + len += 4; /* \NNN */ } break; } diff --git a/src/symbol.c b/src/symbol.c index d09833689..fffe2fae9 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -17,59 +17,94 @@ #include /* ------------------------------------------------------ */ -KHASH_INIT(s2n, mrb_sym, const char*, 1, kh_int_hash_func, kh_int_hash_equal) -KHASH_MAP_INIT_STR(n2s, mrb_sym); +typedef struct symbol_name { + int len; + const char *name; +} symbol_name; + +static inline khint_t +sym_hash_func(mrb_state *mrb, const symbol_name s) +{ + khint_t h = 0; + size_t i; + const char *p = s.name; + + for (i=0; iname2sym; - khash_t(s2n) *rh = mrb->sym2name; + symbol_name sname; khiter_t k; - size_t len; - char *p; mrb_sym sym; + char *p; - k = kh_get(n2s, h, name); + sname.len = len; + sname.name = name; + k = kh_get(n2s, h, sname); if (k != kh_end(h)) return kh_value(h, k); sym = ++mrb->symidx; - len = strlen(name); p = mrb_malloc(mrb, len+1); memcpy(p, name, len); p[len] = 0; - k = kh_put(n2s, h, p); + sname.name = (const char*)p; + k = kh_put(n2s, h, sname); kh_value(h, k) = sym; - k = kh_put(s2n, rh, sym); - kh_value(rh, k) = p; - return sym; } -const char* -mrb_sym2name(mrb_state *mrb, mrb_sym sym) +mrb_sym +mrb_intern(mrb_state *mrb, const char *name) +{ + return mrb_intern2(mrb, name, strlen(name)); +} + +mrb_sym +mrb_intern_str(mrb_state *mrb, mrb_value str) +{ + return mrb_intern2(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); +} + +static const char* +sym2name_len(mrb_state *mrb, mrb_sym sym, int *lenp) { - khash_t(s2n) *h = mrb->sym2name; + khash_t(n2s) *h = mrb->name2sym; khiter_t k; + symbol_name sname; - k = kh_get(s2n, h, sym); + for (k = kh_begin(h); k != kh_end(h); k++) { + if (kh_exist(h, k)) { + if (kh_value(h, k) == sym) break; + } + } if (k == kh_end(h)) { - return NULL; /* missing */ + *lenp = 0; + return NULL; /* missing */ } - return kh_value(h, k); + sname = kh_key(h, k); + *lenp = sname.len; + return sname.name; } void mrb_free_symtbls(mrb_state *mrb) { - khash_t(s2n) *h = mrb->sym2name; + khash_t(n2s) *h = mrb->name2sym; khiter_t k; - for (k = kh_begin(h); k != kh_end(h); ++k) - if (kh_exist(h, k)) mrb_free(mrb, (char*)kh_value(h, k)); - kh_destroy(s2n,mrb->sym2name); + for (k = kh_begin(h); k != kh_end(h); k++) + if (kh_exist(h, k)) mrb_free(mrb, (char*)kh_key(h, k).name); kh_destroy(n2s,mrb->name2sym); } @@ -77,7 +112,6 @@ void mrb_init_symtbl(mrb_state *mrb) { mrb->name2sym = kh_init(n2s, mrb); - mrb->sym2name = kh_init(s2n, mrb); } /********************************************************************** @@ -148,8 +182,11 @@ mrb_value mrb_sym_to_s(mrb_state *mrb, mrb_value sym) { mrb_sym id = SYM2ID(sym); + const char *p; + int len; - return mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id)); + p = sym2name_len(mrb, id, &len); + return mrb_str_new(mrb, p, len); } /* 15.2.11.3.4 */ @@ -287,19 +324,36 @@ sym_inspect(mrb_state *mrb, mrb_value sym) { mrb_value str; const char *name; + int len; mrb_sym id = SYM2ID(sym); - name = mrb_sym2name(mrb, id); //mrb_id2name(id); - str = mrb_str_new(mrb, 0, strlen(name)+1); + name = sym2name_len(mrb, id, &len); + str = mrb_str_new(mrb, 0, len+1); RSTRING(str)->buf[0] = ':'; - strcpy(RSTRING(str)->buf+1, name); - if (!symname_p(name)) { + memcpy(RSTRING(str)->buf+1, name, len); + if (!symname_p(name) || strlen(name) != len) { str = mrb_str_dump(mrb, str); strncpy(RSTRING(str)->buf, ":\"", 2); } return str; } +const char* +mrb_sym2name(mrb_state *mrb, mrb_sym sym) +{ + int len; + const char *name = sym2name_len(mrb, sym, &len); + + if (!name) return NULL; + if (symname_p(name) && strlen(name) == len) { + return name; + } + else { + mrb_value str = mrb_str_dump(mrb, mrb_str_new(mrb, name, len)); + return RSTRING(str)->buf; + } +} + void mrb_init_symbols(mrb_state *mrb) -- 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/string.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 3bb09f99284d6da3ee5192fb4636ad73981ad1f1 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Mon, 11 Jun 2012 01:56:46 +0900 Subject: string.subseq should create new string based on 'ptr' not on 'aux.shared'. --- src/string.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index e955b3f22..67cc32137 100644 --- a/src/string.c +++ b/src/string.c @@ -1199,14 +1199,14 @@ mrb_str_eql(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) { - struct RString *s; + struct RString *orig, *s; struct mrb_shared_string *shared; - s = mrb_str_ptr(str); - str_make_shared(mrb, s); - shared = s->aux.shared; + orig = mrb_str_ptr(str); + str_make_shared(mrb, orig); + shared = orig->aux.shared; s = mrb_obj_alloc_string(mrb); - s->ptr = shared->ptr + beg; + s->ptr = orig->ptr + beg; s->len = len; s->aux.shared = shared; s->flags |= MRB_STR_SHARED; -- cgit v1.2.3 From dd550ca0d494e35efc60142606976a5a41acd5be Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 11 Jun 2012 14:33:01 +0900 Subject: should increment p on every iteration; close #254 --- src/string.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 67cc32137..1de0d9592 100644 --- a/src/string.c +++ b/src/string.c @@ -2945,11 +2945,11 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) p = RSTRING_PTR(str); pend = RSTRING_END(str); prev = p; - while (p < pend) { + for (;p < pend; p++) { unsigned int c, cc; int n; - c = *p++; + c = *p; n = 1; if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p, pend))) { buf[0] = '\\'; buf[1] = c; @@ -2988,9 +2988,6 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) continue; } } -#ifdef INCLUDE_ENCODING - if (p > prev) mrb_str_buf_cat(mrb, result, prev, p - prev); -#endif mrb_str_buf_cat(mrb, result, "\"", strlen("\"")); return result; -- cgit v1.2.3 From 6987ba02f8ea14531d55a8a44f8d68667076ebe8 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 09:51:10 +0900 Subject: String#split now understands string sep --- src/string.c | 43 ++++++++++++++++++++++++------------------- test/t/string.rb | 4 +++- 2 files changed, 27 insertions(+), 20 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 1de0d9592..340402e26 100644 --- a/src/string.c +++ b/src/string.c @@ -2122,27 +2122,16 @@ static const char isspacetable[256] = { static mrb_value mrb_str_split_m(mrb_state *mrb, mrb_value str) { - mrb_value *argv; int argc; mrb_value spat = mrb_nil_value(); - mrb_value limit; enum {awk, string, regexp} split_type = string; long beg, end, i = 0; - int lim = 0; + int lim = -1; mrb_value result, tmp; - mrb_get_args(mrb, "*", &argv, &argc); - if (argc > 0) - spat = argv[0]; - if (argc > 1) - limit = argv[1]; - else - limit = mrb_nil_value(); - + argc = mrb_get_args(mrb, "|oi", &spat, &lim); if (argc == 2) { - lim = mrb_fixnum(limit); - if (lim <= 0) limit = mrb_nil_value(); - else if (lim == 1) { + if (lim == 1) { if (RSTRING_LEN(str) == 0) return mrb_ary_new_capa(mrb, 0); return mrb_ary_new_from_values(mrb, 1, &str); @@ -2201,20 +2190,36 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) else { end = ptr - bptr; skip = 0; - if (!mrb_nil_p(limit) && lim <= i) break; + if (lim >= 0 && lim <= i) break; } } else if (ascii_isspace(c)) { mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, end-beg)); skip = 1; beg = ptr - bptr; - if (!mrb_nil_p(limit)) ++i; + if (lim >= 0) ++i; } else { end = ptr - bptr; } } } + else if (split_type == string) { + char *ptr = RSTRING_PTR(str); + char *temp = ptr; + char *eptr = RSTRING_END(str); + char *sptr = RSTRING_PTR(spat); + long slen = RSTRING_LEN(spat); + + while (ptr < eptr && + (end = mrb_memsearch(sptr, slen, ptr, eptr - ptr)) >= 0) { + /* Check we are at the start of a char */ + mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr - temp, end)); + ptr += end + slen; + if (lim >= 0 && lim <= ++i) break; + } + beg = ptr - temp; + } else { #ifdef INCLUDE_REGEXP char *ptr = RSTRING_PTR(str); @@ -2258,20 +2263,20 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) tmp = mrb_str_subseq(mrb, str, BEG(idx), END(idx)-BEG(idx)); mrb_ary_push(mrb, result, tmp); } - if (!mrb_nil_p(limit) && lim <= ++i) break; + if (lim >= 0 && lim <= ++i) break; } #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); #endif //INCLUDE_REGEXP } - if (RSTRING_LEN(str) > 0 && (!mrb_nil_p(limit) || RSTRING_LEN(str) > beg || lim < 0)) { + if (RSTRING_LEN(str) > 0 && (lim >= 0 || RSTRING_LEN(str) > beg || lim < 0)) { if (RSTRING_LEN(str) == beg) tmp = mrb_str_new_empty(mrb, str); else tmp = mrb_str_subseq(mrb, str, beg, RSTRING_LEN(str)-beg); mrb_ary_push(mrb, result, tmp); } - if (mrb_nil_p(limit) && lim == 0) { + if (lim < 0) { long len; while ((len = RARRAY_LEN(result)) > 0 && (tmp = RARRAY_PTR(result)[len-1], RSTRING_LEN(tmp) == 0)) diff --git a/test/t/string.rb b/test/t/string.rb index d7182fc38..718b005a9 100644 --- a/test/t/string.rb +++ b/test/t/string.rb @@ -276,8 +276,10 @@ end assert('String#split', '15.2.10.5.35') do # without RegExp behavior is actually unspecified a = 'abc abc abc'.split + b = 'a,b,c,,d'.split(',') - a == ['abc', 'abc', 'abc'] + a == ['abc', 'abc', 'abc'] and + b == ["a", "b", "c", "", "d"] end # TODO ATM broken assert('String#sub', '15.2.10.5.36') do -- cgit v1.2.3 From debf296843ff21324d710163a0e49a074c85d4b3 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 10:22:56 +0900 Subject: remove obsolete comment --- src/string.c | 1 - 1 file changed, 1 deletion(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 340402e26..172b8422c 100644 --- a/src/string.c +++ b/src/string.c @@ -2213,7 +2213,6 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) while (ptr < eptr && (end = mrb_memsearch(sptr, slen, ptr, eptr - ptr)) >= 0) { - /* Check we are at the start of a char */ mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr - temp, end)); ptr += end + slen; if (lim >= 0 && lim <= ++i) break; -- cgit v1.2.3 From 5937c29281d9bf51ca85b79c8f3dea204909a073 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 12:29:20 +0900 Subject: s.split(nil) should work like s.split() --- src/string.c | 2 +- test/t/string.rb | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 172b8422c..fae3392cf 100644 --- a/src/string.c +++ b/src/string.c @@ -2139,7 +2139,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) i = 1; } - if (argc == 0) { + if (argc == 0 || mrb_nil_p(spat)) { split_type = awk; } else { diff --git a/test/t/string.rb b/test/t/string.rb index 718b005a9..c422133e3 100644 --- a/test/t/string.rb +++ b/test/t/string.rb @@ -277,9 +277,11 @@ assert('String#split', '15.2.10.5.35') do # without RegExp behavior is actually unspecified a = 'abc abc abc'.split b = 'a,b,c,,d'.split(',') + c = 'abc abc abc'.split(nil) a == ['abc', 'abc', 'abc'] and - b == ["a", "b", "c", "", "d"] + b == ["a", "b", "c", "", "d"] and + c == ['abc', 'abc', 'abc'] end # TODO ATM broken assert('String#sub', '15.2.10.5.36') do -- cgit v1.2.3 From ff4925b804cc70aa8571e9aed2793114ef0223f6 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 12:56:21 +0900 Subject: corrupted String#inspect on backslash escapes --- src/string.c | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index fae3392cf..fcd68a2f2 100644 --- a/src/string.c +++ b/src/string.c @@ -2943,18 +2943,15 @@ mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2) mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str) { - const char *p, *pend, *prev; + const char *p, *pend; char buf[CHAR_ESC_LEN + 1]; mrb_value result = mrb_str_new_cstr(mrb, "\""); p = RSTRING_PTR(str); pend = RSTRING_END(str); - prev = p; for (;p < pend; p++) { unsigned int c, cc; - int n; c = *p; - n = 1; if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p, pend))) { buf[0] = '\\'; buf[1] = c; mrb_str_buf_cat(mrb, result, buf, 2); @@ -2977,18 +2974,14 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) default: cc = 0; break; } if (cc) { - if (p - n > prev) mrb_str_buf_cat(mrb, result, prev, p - n - prev); buf[0] = '\\'; buf[1] = (char)cc; mrb_str_buf_cat(mrb, result, buf, 2); - prev = p; continue; } else { - if (p - n > prev) mrb_str_buf_cat(mrb, result, prev, p - n - prev); sprintf(buf, "\\%03o", c & 0377); mrb_str_buf_cat(mrb, result, buf, strlen(buf)); - prev = p; continue; } } -- cgit v1.2.3 From 30a062c165f31f31f8be65bd51d313a2d25f0bd9 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Tue, 12 Jun 2012 12:58:49 +0900 Subject: String#split("") should split per character (byte for now) --- src/string.c | 22 ++++++++++++++++------ test/t/string.rb | 11 ++++------- 2 files changed, 20 insertions(+), 13 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index fcd68a2f2..14041127a 100644 --- a/src/string.c +++ b/src/string.c @@ -2208,14 +2208,24 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) char *ptr = RSTRING_PTR(str); char *temp = ptr; char *eptr = RSTRING_END(str); - char *sptr = RSTRING_PTR(spat); long slen = RSTRING_LEN(spat); - while (ptr < eptr && - (end = mrb_memsearch(sptr, slen, ptr, eptr - ptr)) >= 0) { - mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr - temp, end)); - ptr += end + slen; - if (lim >= 0 && lim <= ++i) break; + if (slen == 0) { + while (ptr < eptr) { + mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr-temp, 1)); + ptr++; + if (lim >= 0 && lim <= ++i) break; + } + } + else { + char *sptr = RSTRING_PTR(spat); + + while (ptr < eptr && + (end = mrb_memsearch(sptr, slen, ptr, eptr - ptr)) >= 0) { + mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr - temp, end)); + ptr += end + slen; + if (lim >= 0 && lim <= ++i) break; + } } beg = ptr - temp; } diff --git a/test/t/string.rb b/test/t/string.rb index c422133e3..3338e4318 100644 --- a/test/t/string.rb +++ b/test/t/string.rb @@ -275,13 +275,10 @@ end # TODO Broken ATM assert('String#split', '15.2.10.5.35') do # without RegExp behavior is actually unspecified - a = 'abc abc abc'.split - b = 'a,b,c,,d'.split(',') - c = 'abc abc abc'.split(nil) - - a == ['abc', 'abc', 'abc'] and - b == ["a", "b", "c", "", "d"] and - c == ['abc', 'abc', 'abc'] + 'abc abc abc'.split == ['abc', 'abc', 'abc'] and + 'a,b,c,,d'.split(',') == ["a", "b", "c", "", "d"] and + 'abc abc abc'.split(nil) == ['abc', 'abc', 'abc'] and + 'abc'.split("") == ['a', 'b', 'c'] end # TODO ATM broken assert('String#sub', '15.2.10.5.36') do -- cgit v1.2.3 From f564ec7e822c55e8ef6973170818263675b2499f Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Fri, 15 Jun 2012 00:56:00 +0900 Subject: Remove some redundant code. --- src/codegen.c | 12 ------------ src/error.c | 30 ------------------------------ src/error.h | 1 - src/etc.c | 8 -------- src/hash.c | 8 -------- src/kernel.c | 13 ------------- src/load.c | 8 -------- src/object.c | 8 -------- src/parse.y | 8 -------- src/range.c | 8 -------- src/string.c | 2 +- src/variable.c | 8 -------- 12 files changed, 1 insertion(+), 113 deletions(-) (limited to 'src/string.c') diff --git a/src/codegen.c b/src/codegen.c index 1bdc2d21c..b64a18b96 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -298,20 +298,8 @@ push_(codegen_scope *s) s->sp++; nregs_update; } -#if 0 -static void -push_n_(codegen_scope *s, int n) -{ - if (s->sp + n > 511) { - codegen_error(s, "too complex expression"); - } - s->sp += n; - nregs_update; -} -#endif #define push() push_(s) -#define push_n(n) push_n_(s, n) #define pop() (s->sp--) #define pop_n(n) (s->sp-=(n)) #define cursp() (s->sp) diff --git a/src/error.c b/src/error.c index bb334322f..e6ccdf096 100644 --- a/src/error.c +++ b/src/error.c @@ -20,14 +20,6 @@ #define warn_printf printf -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len) { @@ -300,28 +292,6 @@ sysexit_status(mrb_state *mrb, mrb_value err) return mrb_fixnum(st); } -void -error_pos(void) -{ -#if 0 - const char *sourcefile = mrb_sourcefile(); - int sourceline = mrb_sourceline(); - - if (sourcefile) { - if (sourceline == 0) { - warn_printf("%s", sourcefile); - } - else if (mrb_frame_callee()) { - warn_printf("%s:%d:in `%s'", sourcefile, sourceline, - mrb_sym2name(mrb, mrb_frame_callee())); - } - else { - warn_printf("%s:%d", sourcefile, sourceline); - } - } -#endif -} - static void set_backtrace(mrb_state *mrb, mrb_value info, mrb_value bt) { diff --git a/src/error.h b/src/error.h index 8a86e7d3d..e4d6acb6c 100644 --- a/src/error.h +++ b/src/error.h @@ -14,7 +14,6 @@ struct RException { void mrb_sys_fail(mrb_state *mrb, const char *mesg); void mrb_bug_errno(const char*, int); int sysexit_status(mrb_state *mrb, mrb_value err); -void error_pos(void); mrb_value mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str); mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr); mrb_value mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv); diff --git a/src/etc.c b/src/etc.c index 5d70c8bc7..40a00c1f5 100644 --- a/src/etc.c +++ b/src/etc.c @@ -10,14 +10,6 @@ #include "mruby/numeric.h" #include "mruby/data.h" -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - struct RData* mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const struct mrb_data_type *type) { diff --git a/src/hash.c b/src/hash.c index 4a85fcec3..fe5336dc1 100644 --- a/src/hash.c +++ b/src/hash.c @@ -33,14 +33,6 @@ mrb_hash_ht_hash_equal(mrb_state *mrb, mrb_value a, mrb_value b) KHASH_INIT(ht, mrb_value, mrb_value, 1, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal); -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - static void mrb_hash_modify(mrb_state *mrb, mrb_value hash); static inline mrb_value diff --git a/src/kernel.c b/src/kernel.c index 4856af7ad..6dfe6be19 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -34,22 +34,9 @@ typedef enum { NOEX_RESPONDS = 0x80 } mrb_method_flag_t; -#ifdef INCLUDE_REGEXP -#include "re.h" -#include "regint.h" -#endif - 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) -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - struct obj_ivar_tag { mrb_value obj; int (*func)(mrb_sym key, mrb_value val, void * arg); diff --git a/src/load.c b/src/load.c index 053ec2d7e..1f853df00 100644 --- a/src/load.c +++ b/src/load.c @@ -13,14 +13,6 @@ #endif #include "mruby/irep.h" -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - typedef struct _RiteFILE { FILE* fp; diff --git a/src/object.c b/src/object.c index c9ea3f8eb..a30e7c58a 100644 --- a/src/object.c +++ b/src/object.c @@ -11,14 +11,6 @@ #include "mruby/class.h" #include "mruby/numeric.h" -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - int mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) { diff --git a/src/parse.y b/src/parse.y index 7ca0cda80..5e44dd85a 100644 --- a/src/parse.y +++ b/src/parse.y @@ -41,14 +41,6 @@ static void backref_error(parser_state *p, node *n); #define identchar(c) (isalnum(c) || (c) == '_' || !isascii(c)) -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - typedef unsigned int stack_type; #define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1)) diff --git a/src/range.c b/src/range.c index acec1514e..a158dd920 100644 --- a/src/range.c +++ b/src/range.c @@ -15,14 +15,6 @@ #include #include -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - #ifndef OTHER #define OTHER 2 #endif diff --git a/src/string.c b/src/string.c index 14041127a..a9e155c72 100644 --- a/src/string.c +++ b/src/string.c @@ -763,7 +763,7 @@ num_index: len = RSTRING_LEN(str); switch (mrb_range_beg_len(mrb, indx, &beg, &len, len, 0)) { - case 0/*FLASE*/: + case FALSE: break; case 2/*OTHER*/: return mrb_nil_value(); diff --git a/src/variable.c b/src/variable.c index b8957fb6a..47029da28 100644 --- a/src/variable.c +++ b/src/variable.c @@ -21,14 +21,6 @@ KHASH_INIT(iv, mrb_sym, mrb_value, 1, kh_int_hash_func, kh_int_hash_equal) -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - static void mark_tbl(mrb_state *mrb, struct kh_iv *h) { -- cgit v1.2.3 From 76f7aecff326666543d9bac31fe13e0cab8e05f4 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 15 Jun 2012 15:34:49 +0900 Subject: use ENABLE/DISABLE instead of INCLUDE for configuration macro names --- include/mrbconf.h | 50 ++++++++++++++++---------------- include/mruby/class.h | 9 +----- src/dump.c | 6 ++-- src/gc.c | 8 +++--- src/init.c | 6 ++-- src/load.c | 4 +-- src/math.c | 4 +-- src/parse.y | 6 ---- src/re.c | 8 +++--- src/regcomp.c | 8 +++--- src/regerror.c | 4 +-- src/regexec.c | 4 +-- src/regparse.c | 8 +++--- src/string.c | 80 +++++++++++++++++++++++++-------------------------- src/struct.c | 2 +- src/time.c | 3 +- src/variable.c | 2 +- 17 files changed, 98 insertions(+), 114 deletions(-) (limited to 'src/string.c') diff --git a/include/mrbconf.h b/include/mrbconf.h index f4f3ccaef..4b778e6de 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -8,8 +8,21 @@ #define MRUBYCONF_H #include + +/* configuration options: */ +/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */ #undef MRB_USE_FLOAT +/* -DDISABLE_XXXX to change to drop the feature */ +#define DISABLE_REGEXP /* regular expression classes */ +#undef DISABLE_KERNEL_SPRINTF /* Kernel.sprintf method */ +#undef DISABLE_MATH /* Math functions */ +#undef DISABLE_TIME /* Time class */ + +#undef HAVE_UNISTD_H /* WINDOWS */ +#define HAVE_UNISTD_H /* LINUX */ +/* end of configuration */ + #ifdef MRB_USE_FLOAT typedef float mrb_float; #else @@ -20,34 +33,19 @@ typedef double mrb_float; typedef int mrb_int; typedef intptr_t mrb_sym; -//#define PARSER_DUMP /* print out parser state */ -#undef PARSER_DUMP /* do not print out parser state */ - -//#define INCLUDE_ENCODING /* use UTF-8 encoding classes */ -#undef INCLUDE_ENCODING /* not use encoding classes (ascii only) */ - -//#define INCLUDE_REGEXP /* use regular expression classes */ -#undef INCLUDE_REGEXP /* not use regular expression classes */ - -#ifdef INCLUDE_REGEXP -# define INCLUDE_ENCODING /* Regexp depends Encoding */ +/* define ENABLE_XXXX from DISABLE_XXX */ +#ifndef DISABLE_REGEXP +#define ENABLE_REGEXP #endif - -#define INCLUDE_KERNEL_SPRINTF /* not use Kernel.sprintf method */ -//#undef INCLUDE_KERNEL_SPRINTF /* not use Kernel.sprintf method */ - -#define INCLUDE_MATH /* use (non ISO) Math module */ -//#undef INCLUDE_MATH /* not use (non ISO) Math module */ - -#define INCLUDE_TIME /* use Time module */ -//#undef INCLUDE_TIME /* not use Time module */ - -#ifdef MRUBY_DEBUG_BUILD -# define PARSER_DUMP +#ifndef DISABLE_KERNEL_SPRINTF +#define ENABLE_KERNEL_SPRINTF +#endif +#ifndef DISABLE_MATH +#define ENABLE_MATH +#endif +#ifndef DISABLE_TIME +#define ENABLE_TIME #endif - -#undef HAVE_UNISTD_H /* WINDOWS */ -#define HAVE_UNISTD_H /* LINUX */ #ifndef FALSE # define FALSE 0 diff --git a/include/mruby/class.h b/include/mruby/class.h index 35dd0ec1d..2cc90310e 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -40,14 +40,7 @@ mrb_class(mrb_state *mrb, mrb_value v) case MRB_TT_FLOAT: return mrb->float_class; -#ifdef INCLUDE_REGEXP -// case MRB_TT_REGEX: -// return mrb->regex_class; -// case MRB_TT_MATCH: -// return mrb->match_class; -// case MRB_TT_DATA: -// return mrb->encode_class; -#else +#ifdef ENABLE_REGEXP case MRB_TT_REGEX: case MRB_TT_MATCH: mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given", diff --git a/src/dump.c b/src/dump.c index 7b2199a02..daf2868f1 100644 --- a/src/dump.c +++ b/src/dump.c @@ -8,7 +8,7 @@ #include "mruby/dump.h" #include "mruby/string.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "re.h" #endif #include "mruby/irep.h" @@ -237,7 +237,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type) nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); size += nlen; break; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP case MRB_TT_REGEX: str = mrb_reg_to_s(mrb, irep->pool[pool_no]); nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); @@ -365,7 +365,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type); break; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP case MRB_TT_REGEX: str = mrb_reg_to_s(mrb, irep->pool[pool_no]); nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); diff --git a/src/gc.c b/src/gc.c index 1b4b3eed4..c07c9b13b 100644 --- a/src/gc.c +++ b/src/gc.c @@ -71,7 +71,7 @@ */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "re.h" #endif @@ -92,7 +92,7 @@ typedef struct { struct RRange range; struct RStruct structdata; struct RProc procdata; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP struct RMatch match; struct RRegexp regexp; #endif @@ -412,7 +412,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj) } break; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP case MRB_TT_MATCH: { struct RMatch *m = (struct RMatch*)obj; @@ -611,7 +611,7 @@ gc_gray_mark(mrb_state *mrb, struct RBasic *obj) children+=2; break; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP case MRB_TT_MATCH: children+=2; break; diff --git a/src/init.c b/src/init.c index 351874b32..a515ee880 100644 --- a/src/init.c +++ b/src/init.c @@ -51,15 +51,15 @@ mrb_init_core(mrb_state *mrb) mrb_init_range(mrb); mrb_init_struct(mrb); mrb_init_gc(mrb); -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_init_regexp(mrb); #endif mrb_init_exception(mrb); mrb_init_print(mrb); -#ifdef INCLUDE_TIME +#ifdef ENABLE_TIME mrb_init_time(mrb); #endif -#ifdef INCLUDE_MATH +#ifdef ENABLE_MATH mrb_init_math(mrb); #endif diff --git a/src/load.c b/src/load.c index 1f853df00..d3766da9d 100644 --- a/src/load.c +++ b/src/load.c @@ -8,7 +8,7 @@ #include "mruby/dump.h" #include "mruby/string.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "re.h" #endif #include "mruby/irep.h" @@ -418,7 +418,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 irep->pool[i] = mrb_str_new(mrb, buf, pdl); break; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP case MRB_TT_REGEX: str = mrb_str_new(mrb, buf, pdl); irep->pool[i] = mrb_reg_quote(mrb, str); diff --git a/src/math.c b/src/math.c index f3a2dc12c..cf9a20489 100644 --- a/src/math.c +++ b/src/math.c @@ -6,7 +6,7 @@ #include "mruby.h" -#ifdef INCLUDE_MATH +#ifdef ENABLE_MATH #include #define domain_error(msg) \ @@ -681,4 +681,4 @@ mrb_init_math(mrb_state *mrb) mrb_define_module_function(mrb, mrb_math, "erf", math_erf, ARGS_REQ(1)); mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, ARGS_REQ(1)); } -#endif /* INCLUDE_MATH */ +#endif /* ENABLE_MATH */ diff --git a/src/parse.y b/src/parse.y index 5e44dd85a..b7eaaa4e4 100644 --- a/src/parse.y +++ b/src/parse.y @@ -4776,9 +4776,6 @@ mrb_compile_file(mrb_state * mrb, FILE *f) if (!p) return -1; if (!p->tree) return -1; if (p->nerr) return -1; -#ifdef PARSER_DUMP - parser_dump(mrb, p->tree, 0); -#endif n = mrb_generate_code(mrb, p->tree); mrb_pool_close(p->pool); @@ -4795,9 +4792,6 @@ mrb_compile_nstring(mrb_state *mrb, char *s, size_t len) if (!p) return -1; if (!p->tree) return -1; if (p->nerr) return -1; -#ifdef PARSER_DUMP - parser_dump(mrb, p->tree, 0); -#endif n = mrb_generate_code(mrb, p->tree); mrb_pool_close(p->pool); diff --git a/src/re.c b/src/re.c index b4134c81c..17b4f3da7 100644 --- a/src/re.c +++ b/src/re.c @@ -13,7 +13,7 @@ #include "regint.h" #include "mruby/class.h" #include "error.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #define REGEX_CLASS (mrb_class_obj_get(mrb, "Regexp")) #define MATCH_CLASS (mrb_class_obj_get(mrb, "MatchData")) @@ -2318,7 +2318,7 @@ mrb_backref_set(mrb_state *mrb, mrb_value val) { vm_svar_set(mrb, 1, val); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP #ifdef INCLUDE_ENCODING static inline long @@ -2421,7 +2421,7 @@ mrb_memsearch(mrb_state *mrb, const void *x0, int m, const void *y0, int n, mrb_ } #endif //INCLUDE_ENCODING -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_value mrb_reg_init_str(mrb_state *mrb, mrb_value re, mrb_value s, int options) { @@ -2469,7 +2469,7 @@ re_adjust_startpos(struct re_pattern_buffer *bufp, const char *string, int size, }*/ return startpos; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP #ifdef INCLUDE_ENCODING static const unsigned char mbctab_ascii[] = { diff --git a/src/regcomp.c b/src/regcomp.c index 523124b26..b8c652999 100644 --- a/src/regcomp.c +++ b/src/regcomp.c @@ -30,7 +30,7 @@ #include "mruby.h" #include #include "regparse.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP OnigCaseFoldType OnigDefaultCaseFoldFlag = ONIGENC_CASE_FOLD_MIN; @@ -5628,7 +5628,7 @@ onig_end(void) THREAD_SYSTEM_END; return 0; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP #ifdef INCLUDE_ENCODING extern int @@ -5653,7 +5653,7 @@ onig_is_in_code_range(const UChar* p, OnigCodePoint code) } #endif //INCLUDE_ENCODING -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP extern int onig_is_code_in_cc_len(int elen, OnigCodePoint code, CClassNode* cc) { @@ -6285,4 +6285,4 @@ print_tree(FILE* f, Node* node) print_indent_tree(f, node, 0); } #endif -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP diff --git a/src/regerror.c b/src/regerror.c index 2ba879f78..df60b49cc 100644 --- a/src/regerror.c +++ b/src/regerror.c @@ -28,7 +28,7 @@ */ #include "mruby.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include #include "regint.h" #include /* for vsnprintf() */ @@ -372,4 +372,4 @@ onig_snprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc, pat, pat_end, fmt, args); va_end(args); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP diff --git a/src/regexec.c b/src/regexec.c index 4d8950b73..d265cc803 100644 --- a/src/regexec.c +++ b/src/regexec.c @@ -28,7 +28,7 @@ */ #include "mruby.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include #include "regint.h" @@ -3754,4 +3754,4 @@ onig_copy_encoding(OnigEncoding to, OnigEncoding from) { *to = *from; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP diff --git a/src/regparse.c b/src/regparse.c index 509740ac3..f7bb23306 100644 --- a/src/regparse.c +++ b/src/regparse.c @@ -32,7 +32,7 @@ #include #include "regparse.h" #include -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #define WARN_BUFSIZE 256 @@ -298,7 +298,7 @@ strcat_capa_from_static(UChar* dest, UChar* dest_end, onig_strcpy(r + (dest_end - dest), src, src_end); return r; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP #ifdef INCLUDE_ENCODING #ifdef USE_ST_LIBRARY @@ -393,7 +393,7 @@ onig_st_insert_strend(hash_table_type* table, const UChar* str_key, #endif /* USE_ST_LIBRARY */ #endif //INCLUDE_ENCODING -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #ifdef USE_NAMED_GROUP #define INIT_NAME_BACKREFS_ALLOC_NUM 8 @@ -5597,4 +5597,4 @@ onig_scan_env_set_error_string(ScanEnv* env, int ecode ARG_UNUSED, env->error = arg; env->error_end = arg_end; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP diff --git a/src/string.c b/src/string.c index a9e155c72..566c056cf 100644 --- a/src/string.c +++ b/src/string.c @@ -17,10 +17,10 @@ #include "mruby/variable.h" #include #include "re.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "regex.h" #include "st.h" -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP #ifndef FALSE #define FALSE 0 @@ -32,9 +32,9 @@ const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2); static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len); @@ -743,12 +743,12 @@ num_index: return str; case MRB_TT_REGEX: -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP return mrb_str_subpat(mrb, str, indx, 0); //mrb_str_subpat(str, indx, INT2FIX(0)); #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); return mrb_nil_value(); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP case MRB_TT_STRING: if (mrb_str_index(mrb, str, indx, 0) != -1) @@ -835,12 +835,12 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str) argc = mrb_get_args(mrb, "o|o", &a1, &a2); if (argc == 2) { if (mrb_type(a1) == MRB_TT_REGEX) { -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP return mrb_str_subpat(mrb, str, argv[0], mrb_fixnum(argv[1])); #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); return mrb_nil_value(); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP } return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2)); } @@ -1246,7 +1246,7 @@ mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2) return str; } -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) { @@ -1383,7 +1383,7 @@ mrb_str_gsub_bang(mrb_state *mrb, mrb_value self) str_modify(mrb, s); return str_gsub(mrb, s, 1); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str) @@ -1506,7 +1506,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_REGEX: -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP if (pos > RSTRING_LEN(str)) return mrb_nil_value(); pos = mrb_str_offset(mrb, str, pos); @@ -1514,7 +1514,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) pos = mrb_str_sublen(mrb, str, pos); #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP break; case MRB_TT_FIXNUM: { @@ -1668,7 +1668,7 @@ mrb_check_string_type(mrb_state *mrb, mrb_value str) return mrb_check_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str"); } -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote) { @@ -1696,7 +1696,7 @@ get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote) return mrb_reg_regcomp(mrb, pat); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP /* 15.2.10.5.27 */ /* @@ -1711,7 +1711,7 @@ get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote) * 'hello'.match(/(.)\1/)[0] #=> "ll" * 'hello'.match('xx') #=> nil */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value mrb_str_match_m(mrb_state *mrb, mrb_value self) { @@ -1731,7 +1731,7 @@ mrb_str_match_m(mrb_state *mrb, mrb_value self) } return result; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP /* ---------------------------------- */ /* 15.2.10.5.29 */ @@ -1883,11 +1883,11 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) pos += len; if (pos < 0) { if (mrb_type(sub) == MRB_TT_REGEX) { -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_backref_set(mrb, mrb_nil_value()); #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP } return mrb_nil_value(); } @@ -1904,7 +1904,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_REGEX: -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP pos = mrb_str_offset(mrb, str, pos); if (!RREGEXP(sub)->ptr || RREGEXP_SRC_LEN(sub)) { pos = mrb_reg_search(mrb, sub, str, pos, 1); @@ -1913,7 +1913,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) if (pos >= 0) return mrb_fixnum_value(pos); #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP break; case MRB_TT_FIXNUM: { @@ -1947,7 +1947,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) return mrb_nil_value(); } -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) { @@ -1986,7 +1986,7 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) } return mrb_nil_value(); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP /* 15.2.10.5.32 */ /* @@ -2019,7 +2019,7 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) * <> <> * rceu lowlr */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value mrb_str_scan(mrb_state *mrb, mrb_value str) { @@ -2053,7 +2053,7 @@ mrb_str_scan(mrb_state *mrb, mrb_value str) mrb_backref_set(mrb, match); return str; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP static const char isspacetable[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, @@ -2146,28 +2146,28 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) //fs_set: if (mrb_type(spat) == MRB_TT_STRING) { split_type = string; -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP if (RSTRING_LEN(spat) == 0) { /* Special case - split into chars */ spat = mrb_reg_regcomp(mrb, spat); split_type = regexp; } else { -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP if (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){ split_type = awk; } -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP } else { -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP spat = get_pat(mrb, spat, 1); split_type = regexp; #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP } } @@ -2230,7 +2230,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) beg = ptr - temp; } else { -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP char *ptr = RSTRING_PTR(str); long len = RSTRING_LEN(str); long start = beg; @@ -2276,7 +2276,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) } #else mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP } if (RSTRING_LEN(str) > 0 && (lim >= 0 || RSTRING_LEN(str) > beg || lim < 0)) { if (RSTRING_LEN(str) == beg) @@ -2314,14 +2314,14 @@ mrb_block_given_p() * returning str, or nil if no substitutions were * performed. */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value mrb_str_sub_bang(mrb_state *mrb, mrb_value str) { str_modify(mrb, str); return mrb_nil_value(); } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP /* 15.2.10.5.36 */ @@ -2362,7 +2362,7 @@ mrb_str_sub_bang(mrb_state *mrb, mrb_value str) * #=> "Is /bin/bash your preferred shell?" */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP static mrb_value mrb_str_sub(mrb_state *mrb, mrb_value self) { @@ -2371,7 +2371,7 @@ mrb_str_sub(mrb_state *mrb, mrb_value self) mrb_str_sub_bang(mrb, str); return str; } -#endif //INCLUDE_REGEXP +#endif //ENABLE_REGEXP mrb_value mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) @@ -3030,7 +3030,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "each_line", mrb_str_each_line, ARGS_REQ(1)); /* 15.2.10.5.15 */ mrb_define_method(mrb, s, "empty?", mrb_str_empty_p, ARGS_NONE()); /* 15.2.10.5.16 */ mrb_define_method(mrb, s, "eql?", mrb_str_eql, ARGS_REQ(1)); /* 15.2.10.5.17 */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_define_method(mrb, s, "gsub", mrb_str_gsub, ARGS_REQ(1)); /* 15.2.10.5.18 */ mrb_define_method(mrb, s, "gsub!", mrb_str_gsub_bang, ARGS_REQ(1)); /* 15.2.10.5.19 */ #endif @@ -3040,19 +3040,19 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "initialize", mrb_str_init, ARGS_REQ(1)); /* 15.2.10.5.23 */ mrb_define_method(mrb, s, "initialize_copy", mrb_str_replace, ARGS_REQ(1)); /* 15.2.10.5.24 */ mrb_define_method(mrb, s, "intern", mrb_str_intern, ARGS_NONE()); /* 15.2.10.5.25 */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_define_method(mrb, s, "match", mrb_str_match_m, ARGS_REQ(1)); /* 15.2.10.5.27 */ #endif mrb_define_method(mrb, s, "replace", mrb_str_replace, ARGS_REQ(1)); /* 15.2.10.5.28 */ mrb_define_method(mrb, s, "reverse", mrb_str_reverse, ARGS_NONE()); /* 15.2.10.5.29 */ mrb_define_method(mrb, s, "reverse!", mrb_str_reverse_bang, ARGS_NONE()); /* 15.2.10.5.30 */ mrb_define_method(mrb, s, "rindex", mrb_str_rindex_m, ARGS_ANY()); /* 15.2.10.5.31 */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_define_method(mrb, s, "scan", mrb_str_scan, ARGS_REQ(1)); /* 15.2.10.5.32 */ #endif mrb_define_method(mrb, s, "slice", mrb_str_aref_m, ARGS_ANY()); /* 15.2.10.5.34 */ mrb_define_method(mrb, s, "split", mrb_str_split_m, ARGS_ANY()); /* 15.2.10.5.35 */ -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP mrb_define_method(mrb, s, "sub", mrb_str_sub, ARGS_REQ(1)); /* 15.2.10.5.36 */ mrb_define_method(mrb, s, "sub!", mrb_str_sub_bang, ARGS_REQ(1)); /* 15.2.10.5.37 */ #endif diff --git a/src/struct.c b/src/struct.c index 2e2e0c10f..5d759776f 100644 --- a/src/struct.c +++ b/src/struct.c @@ -12,7 +12,7 @@ #include //#include "defines.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "encoding.h" #endif diff --git a/src/time.c b/src/time.c index 1acde8ed9..55060729b 100644 --- a/src/time.c +++ b/src/time.c @@ -6,7 +6,7 @@ #include "mruby.h" -#ifdef INCLUDE_TIME +#ifdef ENABLE_TIME #include #include #include @@ -744,4 +744,3 @@ mrb_init_time(mrb_state *mrb) */ } #endif - diff --git a/src/variable.c b/src/variable.c index 47029da28..b11143b02 100644 --- a/src/variable.c +++ b/src/variable.c @@ -14,7 +14,7 @@ #include "error.h" #include "mruby/array.h" -#ifdef INCLUDE_REGEXP +#ifdef ENABLE_REGEXP #include "re.h" #include "st.h" #endif -- cgit v1.2.3 From 2c93fab066c55a64e77bb5a7b593553a4ae61075 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Fri, 15 Jun 2012 16:55:49 +0900 Subject: Remove TRUE/FALSE definition in C sources. (Reported by #282 but not applied.) --- src/re.c | 8 -------- src/regenc.c | 8 -------- src/string.c | 8 -------- 3 files changed, 24 deletions(-) (limited to 'src/string.c') diff --git a/src/re.c b/src/re.c index 17b4f3da7..70e7c59b6 100644 --- a/src/re.c +++ b/src/re.c @@ -26,14 +26,6 @@ #define MKARG_B(c) (((c) & 0xff) << 16) #define MKARG_C(c) (((c) & 0xff) << 8) -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - #define ARG_REG_OPTION_MASK \ (ONIG_OPTION_IGNORECASE|ONIG_OPTION_MULTILINE|ONIG_OPTION_EXTEND) #define ARG_ENCODING_FIXED 16 diff --git a/src/regenc.c b/src/regenc.c index 3764a694f..4cc496782 100644 --- a/src/regenc.c +++ b/src/regenc.c @@ -32,14 +32,6 @@ #include #include "regint.h" -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - OnigEncoding OnigEncDefaultCharEncoding = ONIG_ENCODING_INIT_DEFAULT; extern int diff --git a/src/string.c b/src/string.c index 566c056cf..6392b504c 100644 --- a/src/string.c +++ b/src/string.c @@ -22,14 +22,6 @@ #include "st.h" #endif //ENABLE_REGEXP -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; #ifdef ENABLE_REGEXP -- cgit v1.2.3 From ef50e63a63c9b3759a2030816c9e2c5ec4e14cd0 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 20 Jun 2012 20:43:27 +0900 Subject: remove RuntimeError from mrb_state --- include/mruby.h | 2 +- src/error.c | 8 ++++---- src/gc.c | 2 +- src/kernel.c | 6 +++--- src/re.c | 2 +- src/string.c | 2 +- src/vm.c | 2 +- 7 files changed, 12 insertions(+), 12 deletions(-) (limited to 'src/string.c') diff --git a/include/mruby.h b/include/mruby.h index ef742cef4..aadd56e94 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -279,7 +279,6 @@ typedef struct mrb_state { struct RClass *eException_class; struct RClass *eStandardError_class; - struct RClass *eRuntimeError_class; void *ud; /* auxiliary data */ } mrb_state; @@ -430,6 +429,7 @@ void rb_raise(struct RClass *c, const char *fmt, ...); void mrb_warn(const char *fmt, ...); void mrb_bug(const char *fmt, ...); +#define E_RUNTIME_ERROR (mrb_class_obj_get(mrb, "RuntimeError")) #define E_TYPE_ERROR (mrb_class_obj_get(mrb, "TypeError")) #define E_ARGUMENT_ERROR (mrb_class_obj_get(mrb, "ArgumentError")) #define E_INDEX_ERROR (mrb_class_obj_get(mrb, "IndexError")) diff --git a/src/error.c b/src/error.c index b2d9a8c8d..1183d8643 100644 --- a/src/error.c +++ b/src/error.c @@ -301,7 +301,7 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr) if (isstr) { mesg = mrb_check_string_type(mrb, argv[0]); if (!mrb_nil_p(mesg)) { - mesg = mrb_exc_new3(mrb, mrb->eRuntimeError_class, mesg); + mesg = mrb_exc_new3(mrb, E_RUNTIME_ERROR, mesg); break; } } @@ -352,7 +352,7 @@ mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv) void mrb_sys_fail(mrb_state *mrb, const char *mesg) { - mrb_raise(mrb, mrb->eRuntimeError_class, "%s", mesg); + mrb_raise(mrb, E_RUNTIME_ERROR, "%s", mesg); } void @@ -369,6 +369,6 @@ mrb_init_exception(mrb_state *mrb) mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE()); mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE()); - mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */ - mrb->eRuntimeError_class = mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */ + mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */ + mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */ } diff --git a/src/gc.c b/src/gc.c index c07c9b13b..a7537a015 100644 --- a/src/gc.c +++ b/src/gc.c @@ -277,7 +277,7 @@ gc_protect(mrb_state *mrb, struct RBasic *p) if (mrb->arena_idx > MRB_ARENA_SIZE) { /* arena overflow error */ mrb->arena_idx = MRB_ARENA_SIZE - 4; /* force room in arena */ - mrb_raise(mrb, mrb->eRuntimeError_class, "arena overflow error"); + mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error"); } mrb->arena[mrb->arena_idx++] = p; } diff --git a/src/kernel.c b/src/kernel.c index 5b65714b6..209eaa91d 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -573,7 +573,7 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self) mrb_value a, b; if (mrb_get_args(mrb, "|S&", &a, &b) == 1) { - mrb_raise(mrb, mrb->eRuntimeError_class, "instance_eval with string not implemented"); + mrb_raise(mrb, E_RUNTIME_ERROR, "instance_eval with string not implemented"); } return mrb_yield_with_self(mrb, b, 0, 0, self); } @@ -1019,13 +1019,13 @@ mrb_f_raise(mrb_state *mrb, mrb_value self) argc = mrb_get_args(mrb, "|oo", &a[0], &a[1]); switch (argc) { case 0: - mrb_raise(mrb, mrb->eRuntimeError_class, ""); + mrb_raise(mrb, E_RUNTIME_ERROR, ""); break; case 1: a[1] = mrb_check_string_type(mrb, a[0]); if (!mrb_nil_p(a[1])) { argc = 2; - a[0] = mrb_obj_value(mrb->eRuntimeError_class); + a[0] = mrb_obj_value(E_RUNTIME_ERROR); } /* fall through */ default: diff --git a/src/re.c b/src/re.c index 70e7c59b6..b821d2e71 100644 --- a/src/re.c +++ b/src/re.c @@ -2143,7 +2143,7 @@ mrb_reg_regsub(mrb_state *mrb, mrb_value str, mrb_value src, struct re_registers break; } else { - mrb_raise(mrb, mrb->eRuntimeError_class, "invalid group name reference format"); + mrb_raise(mrb, E_RUNTIME_ERROR, "invalid group name reference format"); } } diff --git a/src/string.c b/src/string.c index 6392b504c..585edf8a3 100644 --- a/src/string.c +++ b/src/string.c @@ -100,7 +100,7 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len) struct RString *s = mrb_str_ptr(str); if (s->ptr != p || s->len != len) { - mrb_raise(mrb, mrb->eRuntimeError_class, "string modified"); + mrb_raise(mrb, E_RUNTIME_ERROR, "string modified"); } } diff --git a/src/vm.c b/src/vm.c index c78799c6d..f3e5a497a 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1604,7 +1604,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) CASE(OP_ERR) { /* Bx raise RuntimeError with message Lit(Bx) */ mrb_value msg = pool[GETARG_Bx(i)]; - mrb_value exc = mrb_exc_new3(mrb, mrb->eRuntimeError_class, msg); + mrb_value exc = mrb_exc_new3(mrb, E_RUNTIME_ERROR, msg); mrb->exc = (struct RObject*)mrb_object(exc); goto L_RAISE; -- cgit v1.2.3 From a70c4e0c790b9ddb4dbca143cffa585b3841b9f6 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 21 Jun 2012 16:22:29 +0900 Subject: reduce calling of strlen(); #301 --- src/codegen.c | 7 ++++--- src/dump.c | 8 +++++--- src/hash.c | 4 ++-- src/re.c | 19 +++++++++---------- src/sprintf.c | 8 ++++---- src/string.c | 2 +- 6 files changed, 25 insertions(+), 23 deletions(-) (limited to 'src/string.c') diff --git a/src/codegen.c b/src/codegen.c index 3374b2e7f..27fd20ee4 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -542,16 +542,17 @@ nosplat(node *t) static mrb_sym attrsym(codegen_scope *s, mrb_sym a) { - const char *name = mrb_sym2name(s->mrb, a); + const char *name; + int len; char *name2; - size_t len = strlen(name); + name = mrb_sym2name(s->mrb, a, &len); name2 = codegen_palloc(s, len+1); strcpy(name2, name); name2[len] = '='; name2[len+1] = '\0'; - return mrb_intern(s->mrb, name2); + return mrb_intern2(s->mrb, name2, len+1); } static int diff --git a/src/dump.c b/src/dump.c index daf2868f1..e1ebe2027 100644 --- a/src/dump.c +++ b/src/dump.c @@ -415,15 +415,17 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) uint16_t nlen =0; if (irep->syms[sym_no] != 0) { - name = mrb_sym2name(mrb, irep->syms[sym_no]); - nlen = str_dump_len((char*)name, strlen(name), type); + int len; + + name = mrb_sym2name(mrb, irep->syms[sym_no], &len); + nlen = str_dump_len((char*)name, len, type); if ( nlen > buf_size - 1) { buf_size = nlen + 1; if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; } memset(char_buf, 0, buf_size); - str_dump((char*)name, char_buf, strlen(name), type); + str_dump((char*)name, char_buf, len, type); buf += uint16_dump(nlen, buf, type); /* length of symbol name */ memcpy(buf, char_buf, nlen); /* symbol name */ diff --git a/src/hash.c b/src/hash.c index 08f906800..7b9ae6a8a 100644 --- a/src/hash.c +++ b/src/hash.c @@ -904,14 +904,14 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur) str2 = mrb_inspect(mrb, kh_key(h,k)); mrb_str_append(mrb, str, str2); - mrb_str_buf_cat(mrb, str, "=>", strlen("=>")); + mrb_str_buf_cat(mrb, str, "=>", sizeof("=>")); str2 = mrb_inspect(mrb, kh_value(h,k)); mrb_str_append(mrb, str, str2); mrb_gc_arena_restore(mrb, ai); } } - mrb_str_buf_cat(mrb, str, "}", strlen("}"));//mrb_str_buf_cat2(str, "}"); + mrb_str_buf_cat(mrb, str, "}", sizeof("}")); return str; } diff --git a/src/re.c b/src/re.c index b821d2e71..12061eacf 100644 --- a/src/re.c +++ b/src/re.c @@ -357,14 +357,14 @@ 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_reg_expr_str(mrb, str, s, len); - mrb_str_buf_cat(mrb, str, "/", strlen("/")); + mrb_str_buf_cat(mrb, str, "/", sizeof("/")); if (re.tt) { char opts[4]; mrb_reg_check(mrb, re); if (*option_to_str(opts, RREGEXP(re)->ptr->options)) mrb_str_buf_cat(mrb, str, opts, strlen(opts));//mrb_str_buf_cat2(str, opts); if (RBASIC(re)->flags & REG_ENCODING_NONE) - mrb_str_buf_cat(mrb, str, "n", strlen("n"));//mrb_str_buf_cat2(str, "n"); + mrb_str_buf_cat(mrb, str, "n", sizeof("n")); } return str; @@ -1796,9 +1796,9 @@ again: mrb_str_buf_cat(mrb, str, optbuf, strlen(optbuf)); } - mrb_str_buf_cat(mrb, str, ":", strlen(":")); + mrb_str_buf_cat(mrb, str, ":", sizeof(":")); mrb_reg_expr_str(mrb, str, (char*)ptr, len); - mrb_str_buf_cat(mrb, str, ")", strlen(")")); + mrb_str_buf_cat(mrb, str, ")", sizeof(")")); return str; } @@ -1919,29 +1919,28 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) match_inspect_name_iter, names); str = mrb_str_new_cstr(mrb, "#<");//mrb_str_buf_new2("#<"); - mrb_str_buf_cat(mrb, str, cname, strlen(cname));//mrb_str_buf_cat2(str, cname); + mrb_str_buf_cat(mrb, str, cname, strlen(cname)); for (i = 0; i < num_regs; i++) { char buf[sizeof(num_regs)*3+1]; mrb_value v; - mrb_str_buf_cat(mrb, str, " ", strlen(" "));//mrb_str_buf_cat2(str, " "); + mrb_str_buf_cat(mrb, str, " ", sizeof(" ")); if (0 < i) { if (names[i].name) mrb_str_buf_cat(mrb, str, (const char*)names[i].name, names[i].len); else { - //mrb_str_catf(mrb, str, "%d", i); sprintf(buf, "%d", i); mrb_str_buf_cat(mrb, str, (const char*)buf, strlen(buf)); } - mrb_str_buf_cat(mrb, str, ":", strlen(":"));//mrb_str_buf_cat2(str, ":"); + mrb_str_buf_cat(mrb, str, ":", sizeof(":")); } v = mrb_reg_nth_match(mrb, i, match); if (mrb_nil_p(v)) - mrb_str_buf_cat(mrb, str, "nil", strlen("nil"));//mrb_str_buf_cat2(str, "nil"); + mrb_str_buf_cat(mrb, str, "nil", sizeof("nil")); else mrb_str_buf_append(mrb, str, mrb_str_inspect(mrb, v)); } - mrb_str_buf_cat(mrb, str, ">", strlen(">"));//mrb_str_buf_cat2(str, ">"); + mrb_str_buf_cat(mrb, str, ">", sizeof(">")); return str; } diff --git a/src/sprintf.c b/src/sprintf.c index b4d460c83..c23969792 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -1069,13 +1069,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); + snprintf(buf, end - buf, "%d", width); + buf += strlen(buf); } if (flags & FPREC) { - snprintf(buf, end - buf, ".%d", prec); - buf += strlen(buf); + snprintf(buf, end - buf, ".%d", prec); + buf += strlen(buf); } *buf++ = c; diff --git a/src/string.c b/src/string.c index 585edf8a3..894342463 100644 --- a/src/string.c +++ b/src/string.c @@ -2987,7 +2987,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) continue; } } - mrb_str_buf_cat(mrb, result, "\"", strlen("\"")); + mrb_str_buf_cat(mrb, result, "\"", sizeof("\"")); return result; } -- cgit v1.2.3 From 21f2e5364b5c6cda244001d779aa67d86a22e6e7 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Fri, 22 Jun 2012 16:46:37 +0900 Subject: Use mrb_str_new() instead of mrb_str_new2() as possible. --- src/array.c | 4 ++-- src/numeric.c | 23 +++++++++++++++-------- src/range.c | 7 ++++++- src/sprintf.c | 2 +- src/string.c | 7 +++++-- src/struct.c | 4 ++-- 6 files changed, 31 insertions(+), 16 deletions(-) (limited to 'src/string.c') diff --git a/src/array.c b/src/array.c index ca111bc0e..981da7afb 100644 --- a/src/array.c +++ b/src/array.c @@ -887,7 +887,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list) /* check recursive */ for(i=0; i #include #include +#include #if defined(__FreeBSD__) && __FreeBSD__ < 4 #include @@ -186,15 +187,21 @@ static mrb_value flo_to_s(mrb_state *mrb, mrb_value flt) { char buf[32]; + int n; mrb_float value = mrb_float(flt); - if (isinf(value)) - return mrb_str_new2(mrb, value < 0 ? "-inf" : "inf"); - else if(isnan(value)) - return mrb_str_new2(mrb, "NaN"); - - sprintf(buf, "%.14g", value); - return mrb_str_new2(mrb, buf); + if (isinf(value)) { + static const char s[2][5] = { "-inf", "inf" }; + static const int n[] = { 4, 3 }; + int idx; + idx = (value < 0) ? 0 : 1; + return mrb_str_new(mrb, s[idx], n[idx]); + } else if(isnan(value)) + return mrb_str_new(mrb, "NaN", 3); + + n = sprintf(buf, "%.14g", value); + assert(n >= 0); + return mrb_str_new(mrb, buf, n); } /* 15.2.9.3.2 */ @@ -1158,7 +1165,7 @@ mrb_fix2str(mrb_state *mrb, mrb_value x, int base) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base); } if (val == 0) { - return mrb_str_new2(mrb, "0"); + return mrb_str_new(mrb, "0", 1); } if (val < 0) { val = -val; diff --git a/src/range.c b/src/range.c index 826481e93..859bb277e 100644 --- a/src/range.c +++ b/src/range.c @@ -343,7 +343,12 @@ inspect_range(mrb_state *mrb, mrb_value range, mrb_value dummy, int recur) struct RRange *r = mrb_range_ptr(range); if (recur) { - return mrb_str_new2(mrb, r->excl ? "(... ... ...)" : "(... .. ...)"); + static const char s[2][14] = { "(... ... ...)", "(... .. ...)" }; + static const int n[] = { 13, 12 }; + int idx; + + idx = (r->excl) ? 0 : 1; + return mrb_str_new(mrb, s[idx], n[idx]); } str = mrb_inspect(mrb, r->edges->beg); str2 = mrb_inspect(mrb, r->edges->end); diff --git a/src/sprintf.c b/src/sprintf.c index c23969792..e01bf572e 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -89,7 +89,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) val &= 0x3ff; if (val == 0) { - return mrb_str_new2(mrb, "0"); + return mrb_str_new(mrb, "0", 1); } *--b = '\0'; do { diff --git a/src/string.c b/src/string.c index 894342463..6b2df1590 100644 --- a/src/string.c +++ b/src/string.c @@ -21,6 +21,7 @@ #include "regex.h" #include "st.h" #endif //ENABLE_REGEXP +#include const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; @@ -220,7 +221,9 @@ mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, int len) mrb_value mrb_str_new(mrb_state *mrb, const char *p, int len) { - struct RString *s = str_new(mrb, p, len); + struct RString *s; + assert(!(!p && len)); + s = str_new(mrb, p, len); return mrb_obj_value(s); } @@ -1969,7 +1972,7 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) if (regs->num_regs == 1) { return mrb_reg_nth_match(mrb, 0, match); } - result = mrb_ary_new_capa(mrb, regs->num_regs);//mrb_ary_new2(regs->num_regs); + result = mrb_ary_new_capa(mrb, regs->num_regs); for (i=1; i < regs->num_regs; i++) { mrb_ary_push(mrb, result, mrb_reg_nth_match(mrb, i, match)); } diff --git a/src/struct.c b/src/struct.c index de0dbeeaa..7e422f140 100644 --- a/src/struct.c +++ b/src/struct.c @@ -93,7 +93,7 @@ mrb_struct_s_members_m(mrb_state *mrb, mrb_value klass) mrb_value *p, *pend; members = mrb_struct_s_members(mrb, klass); - ary = mrb_ary_new_capa(mrb, RARRAY_LEN(members));//mrb_ary_new2(RARRAY_LEN(members)); + ary = mrb_ary_new_capa(mrb, RARRAY_LEN(members)); p = RARRAY_PTR(members); pend = p + RARRAY_LEN(members); while (p < pend) { mrb_ary_push(mrb, ary, *p); @@ -493,7 +493,7 @@ static mrb_value inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur) { const char *cn = mrb_class_name(mrb, mrb_obj_class(mrb, s)); - mrb_value members, str = mrb_str_new2(mrb, "# Date: Sat, 23 Jun 2012 09:49:14 +0900 Subject: remove assertion for false assumption; mrb_str_new(0, len) where len > 0 can be used to allocate an unintialized string --- src/string.c | 3 +-- src/vm.c | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 6b2df1590..a943512c7 100644 --- a/src/string.c +++ b/src/string.c @@ -21,7 +21,6 @@ #include "regex.h" #include "st.h" #endif //ENABLE_REGEXP -#include const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; @@ -222,7 +221,7 @@ mrb_value mrb_str_new(mrb_state *mrb, const char *p, int len) { struct RString *s; - assert(!(!p && len)); + s = str_new(mrb, p, len); return mrb_obj_value(s); } diff --git a/src/vm.c b/src/vm.c index f3e5a497a..04392891f 100644 --- a/src/vm.c +++ b/src/vm.c @@ -393,7 +393,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) mrb_code i; int ai = mrb->arena_idx; jmp_buf c_jmp; - jmp_buf *prev_jmp = NULL; + volatile jmp_buf *prev_jmp = NULL; #ifdef DIRECT_THREADED static void *optable[] = { -- 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/string.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 c152c194a181d38cf5b6ccae45a703bbc47db440 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Tue, 26 Jun 2012 01:34:41 +0900 Subject: Prevent memory leak when string literal is created. --- src/string.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 1ef0cdc33..c74dcedde 100644 --- a/src/string.c +++ b/src/string.c @@ -292,7 +292,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str) struct RString *s, *orig; struct mrb_shared_string *shared; - s = str_new(mrb, 0, 0); + s = str_alloc(mrb, mrb->string_class); orig = mrb_str_ptr(str); if (!(orig->flags & MRB_STR_SHARED)) { str_make_shared(mrb, mrb_str_ptr(str)); -- 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/string.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 0a88499f32f38b5608d50da59fc7d22132767c0d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Wed, 27 Jun 2012 15:19:40 +0900 Subject: sizeof("a") is bigger by one than strlen("a") --- src/hash.c | 4 ++-- src/re.c | 14 +++++++------- src/string.c | 2 +- 3 files changed, 10 insertions(+), 10 deletions(-) (limited to 'src/string.c') diff --git a/src/hash.c b/src/hash.c index a87ca97d4..888a1917e 100644 --- a/src/hash.c +++ b/src/hash.c @@ -904,14 +904,14 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur) str2 = mrb_inspect(mrb, kh_key(h,k)); mrb_str_append(mrb, str, str2); - mrb_str_buf_cat(mrb, str, "=>", sizeof("=>")); + mrb_str_buf_cat(mrb, str, "=>", 2); str2 = mrb_inspect(mrb, kh_value(h,k)); mrb_str_append(mrb, str, str2); mrb_gc_arena_restore(mrb, ai); } } - mrb_str_buf_cat(mrb, str, "}", sizeof("}")); + mrb_str_buf_cat(mrb, str, "}", 1); return str; } diff --git a/src/re.c b/src/re.c index c7b27eac2..3639a41c6 100644 --- a/src/re.c +++ b/src/re.c @@ -364,7 +364,7 @@ mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re) if (*option_to_str(opts, RREGEXP(re)->ptr->options)) mrb_str_buf_cat(mrb, str, opts, strlen(opts));//mrb_str_buf_cat2(str, opts); if (RBASIC(re)->flags & REG_ENCODING_NONE) - mrb_str_buf_cat(mrb, str, "n", sizeof("n")); + mrb_str_buf_cat(mrb, str, "n", 1); } return str; @@ -1797,9 +1797,9 @@ again: mrb_str_buf_cat(mrb, str, optbuf, strlen(optbuf)); } - mrb_str_buf_cat(mrb, str, ":", sizeof(":")); + mrb_str_buf_cat(mrb, str, ":", 1); mrb_reg_expr_str(mrb, str, (char*)ptr, len); - mrb_str_buf_cat(mrb, str, ")", sizeof(")")); + mrb_str_buf_cat(mrb, str, ")", 1); return str; } @@ -1925,7 +1925,7 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) for (i = 0; i < num_regs; i++) { char buf[sizeof(num_regs)*3+1]; mrb_value v; - mrb_str_buf_cat(mrb, str, " ", sizeof(" ")); + mrb_str_buf_cat(mrb, str, " ", 1); if (0 < i) { if (names[i].name) mrb_str_buf_cat(mrb, str, (const char*)names[i].name, names[i].len); @@ -1933,15 +1933,15 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) int n = sprintf(buf, "%d", i); mrb_str_buf_cat(mrb, str, (const char*)buf, n); } - mrb_str_buf_cat(mrb, str, ":", sizeof(":")); + mrb_str_buf_cat(mrb, str, ":", 1); } v = mrb_reg_nth_match(mrb, i, match); if (mrb_nil_p(v)) - mrb_str_buf_cat(mrb, str, "nil", sizeof("nil")); + mrb_str_buf_cat(mrb, str, "nil", 3); else mrb_str_buf_append(mrb, str, mrb_str_inspect(mrb, v)); } - mrb_str_buf_cat(mrb, str, ">", sizeof(">")); + mrb_str_buf_cat(mrb, str, ">", 1); return str; } diff --git a/src/string.c b/src/string.c index f01c08bce..8e61e6bb9 100644 --- a/src/string.c +++ b/src/string.c @@ -2988,7 +2988,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) continue; } } - mrb_str_buf_cat(mrb, result, "\"", sizeof("\"")); + mrb_str_buf_cat(mrb, result, "\"", 1); return result; } -- cgit v1.2.3 From 866f797125093cca9563c753716e3cede1cc5a3f Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Thu, 28 Jun 2012 01:01:56 +0900 Subject: Fix str_replace in string.c - Increment refcnt of shared string. - Free buffer before replacing. - Clear MRB_STR_SHARED after decref is called. - Fix target of aux.capa. --- src/string.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 8e61e6bb9..02f71ef96 100644 --- a/src/string.c +++ b/src/string.c @@ -1549,10 +1549,17 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) { if (s2->flags & MRB_STR_SHARED) { L_SHARE: + if (s1->flags & MRB_STR_SHARED){ + mrb_str_decref(mrb, s1->aux.shared); + } + else { + mrb_free(mrb, s1->ptr); + } s1->ptr = s2->ptr; s1->len = s2->len; s1->aux.shared = s2->aux.shared; s1->flags |= MRB_STR_SHARED; + s1->aux.shared->refcnt++; } else if (s2->len > STR_REPLACE_SHARED_MIN) { str_make_shared(mrb, s2); @@ -1561,6 +1568,7 @@ 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->flags &= ~MRB_STR_SHARED; s1->ptr = mrb_malloc(mrb, s2->len+1); } else { @@ -1569,7 +1577,7 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) memcpy(s1->ptr, s2->ptr, s2->len); s1->ptr[s2->len] = 0; s1->len = s2->len; - s2->aux.capa = s2->len; + s1->aux.capa = s2->len; } return mrb_obj_value(s1); } -- cgit v1.2.3 From 4406a08d58f55f1d3d32c98a78bd7dc61a242c8d Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 6 Jul 2012 19:46:27 +0900 Subject: remove debug printf; close #345 --- src/string.c | 36 +++++++++++++++--------------------- 1 file changed, 15 insertions(+), 21 deletions(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 02f71ef96..b2cdc1212 100644 --- a/src/string.c +++ b/src/string.c @@ -2381,17 +2381,10 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) #define BDIGIT unsigned int #define BDIGIT_DBL unsigned long -// const char *s = str; char *end; char sign = 1; -// char nondigit = 0; int c; -// BDIGIT_DBL num; long len; -// long blen = 1; -// long i; -// mrb_value z; -// BDIGIT *zds; unsigned long val; #undef ISDIGIT @@ -2508,21 +2501,22 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) } len *= strlen(str)*sizeof(char); - val = strtoul((char*)str, &end, base); + val = strtoul((char*)str, &end, base); - if (badcheck) { - if (end == str) goto bad; /* no number */ - while (*end && ISSPACE(*end)) end++; - if (*end) goto bad; /* trailing garbage */ - } + if (badcheck) { + if (end == str) goto bad; /* no number */ + while (*end && ISSPACE(*end)) end++; + if (*end) goto bad; /* trailing garbage */ + } - if (sign) return mrb_fixnum_value(val); - else { - long result = -(long)val; - return mrb_fixnum_value(result); - } + if (sign) return mrb_fixnum_value(val); + else { + long result = -(long)val; + return mrb_fixnum_value(result); + } bad: - printf("Integer"); + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for number(%s)", str); + /* not reached */ return mrb_fixnum_value(0); } @@ -2631,8 +2625,8 @@ mrb_cstr_to_dbl(mrb_state *mrb, const char * p, int badcheck) if (p == end) { if (badcheck) { bad: - //mrb_invalid_str(q, "Float()"); - printf("Float()\n"); + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalide string for float(%s)", p); + /* not reached */ } return d; } -- cgit v1.2.3 From ae2cd24afbf69e6e4c98ac8e642cb078e9d3750b Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 13 Jul 2012 00:24:44 +0900 Subject: remove st.h inclusion --- src/parse.y | 1 - src/re.h | 1 + src/string.c | 1 - src/variable.c | 1 - 4 files changed, 1 insertion(+), 3 deletions(-) (limited to 'src/string.c') diff --git a/src/parse.y b/src/parse.y index fe8752ec2..292e60cfa 100644 --- a/src/parse.y +++ b/src/parse.y @@ -22,7 +22,6 @@ #include "mruby/compile.h" #include "mruby/proc.h" #include "node.h" -#include "st.h" #include #include diff --git a/src/re.h b/src/re.h index 238b4e408..91bd1abc1 100644 --- a/src/re.h +++ b/src/re.h @@ -13,6 +13,7 @@ #include "node.h" #include "regex.h" #include "encoding.h" +#include "st.h" #define BEG(no) regs->beg[no] #define END(no) regs->end[no] diff --git a/src/string.c b/src/string.c index b2cdc1212..2b7bdb454 100644 --- a/src/string.c +++ b/src/string.c @@ -19,7 +19,6 @@ #include "re.h" #ifdef ENABLE_REGEXP #include "regex.h" -#include "st.h" #endif //ENABLE_REGEXP const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; diff --git a/src/variable.c b/src/variable.c index e785d56b7..33c9c0249 100644 --- a/src/variable.c +++ b/src/variable.c @@ -16,7 +16,6 @@ #ifdef ENABLE_REGEXP #include "re.h" -#include "st.h" #endif static void -- cgit v1.2.3 From 48c73ac630c2bfb3326d608d3c00e544dcfbcfea Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Fri, 13 Jul 2012 10:13:47 +0900 Subject: less --- src/etc.c | 1 - src/gc.c | 1 - src/hash.c | 1 - src/kernel.c | 1 - src/pool.c | 1 - src/range.c | 2 -- src/string.c | 2 +- src/symbol.c | 1 - src/variable.c | 1 - 9 files changed, 1 insertion(+), 10 deletions(-) (limited to 'src/string.c') diff --git a/src/etc.c b/src/etc.c index 73cf31087..7e9381d16 100644 --- a/src/etc.c +++ b/src/etc.c @@ -126,7 +126,6 @@ mrb_block_proc(void) return mrb_nil_value();//proc_new(mrb_cProc, FALSE); } -#include static mrb_int float_id(mrb_float f) { diff --git a/src/gc.c b/src/gc.c index 78d8ee6a9..ada0bf31f 100644 --- a/src/gc.c +++ b/src/gc.c @@ -13,7 +13,6 @@ #include "mruby/range.h" #include "mruby/khash.h" #include -#include #include "mruby/struct.h" #include "mruby/proc.h" #include "mruby/data.h" diff --git a/src/hash.c b/src/hash.c index 888a1917e..ed8b70270 100644 --- a/src/hash.c +++ b/src/hash.c @@ -12,7 +12,6 @@ #include "mruby/string.h" #include "mruby/variable.h" #include -#include static inline khint_t mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key) diff --git a/src/kernel.c b/src/kernel.c index d230305da..1040dbe05 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -7,7 +7,6 @@ #include "mruby.h" #include "mruby/string.h" #include -#include #include #include "mruby/proc.h" #include "mruby/range.h" diff --git a/src/pool.c b/src/pool.c index 612bbe647..0f1baa776 100644 --- a/src/pool.c +++ b/src/pool.c @@ -35,7 +35,6 @@ struct mrb_pool { #undef TEST_POOL #ifdef TEST_POOL -#include #define mrb_malloc(m,s) malloc(s) #define mrb_free(m,p) free(p) diff --git a/src/range.c b/src/range.c index 1514313f1..b4d743e5f 100644 --- a/src/range.c +++ b/src/range.c @@ -11,8 +11,6 @@ #include "error.h" #include "mruby/numeric.h" #include "mruby/string.h" - -#include #include #ifndef OTHER diff --git a/src/string.c b/src/string.c index 2b7bdb454..14da83c51 100644 --- a/src/string.c +++ b/src/string.c @@ -16,8 +16,8 @@ #include "mruby/class.h" #include "mruby/variable.h" #include -#include "re.h" #ifdef ENABLE_REGEXP +#include "re.h" #include "regex.h" #endif //ENABLE_REGEXP diff --git a/src/symbol.c b/src/symbol.c index d2ae09655..91076e293 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -14,7 +14,6 @@ #include #include "mruby/class.h" #include "mruby/variable.h" -#include /* ------------------------------------------------------ */ typedef struct symbol_name { diff --git a/src/variable.c b/src/variable.c index 33c9c0249..e2f3a7d08 100644 --- a/src/variable.c +++ b/src/variable.c @@ -4,7 +4,6 @@ ** See Copyright Notice in mruby.h */ -#include #include "mruby.h" #include "mruby/class.h" #include "mruby/khash.h" -- cgit v1.2.3 From 96366117ea4bd91bccf00110469765ebc1ebaa8c Mon Sep 17 00:00:00 2001 From: Junji Sawada Date: Sat, 14 Jul 2012 11:39:25 +0900 Subject: Remove unnecessary header inclusion --- include/mruby/khash.h | 1 - src/cdump.c | 1 - src/codegen.c | 3 --- src/error.c | 5 ----- src/gc.c | 3 +-- src/hash.c | 1 - src/kernel.c | 5 ----- src/numeric.c | 4 ---- src/proc.c | 1 - src/range.c | 3 --- src/sprintf.c | 1 - src/string.c | 3 +-- src/struct.c | 4 ---- src/symbol.c | 4 ---- src/variable.c | 2 -- 15 files changed, 2 insertions(+), 39 deletions(-) (limited to 'src/string.c') diff --git a/include/mruby/khash.h b/include/mruby/khash.h index 0803521b7..09b23f6af 100644 --- a/include/mruby/khash.h +++ b/include/mruby/khash.h @@ -12,7 +12,6 @@ extern "C" { #endif #include -#include #include typedef uint32_t khint_t; diff --git a/src/cdump.c b/src/cdump.c index 16c1dc8ae..a4a2ac5e1 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -10,7 +10,6 @@ #include "mruby/irep.h" #include "mruby/string.h" -#include "re.h" #define MRB_CDUMP_LINE_LEN 128 diff --git a/src/codegen.c b/src/codegen.c index 6db09f310..9166b7144 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -10,15 +10,12 @@ #include "mruby.h" #include "mruby/string.h" #include "mruby/irep.h" -#include "mruby/proc.h" #include "mruby/compile.h" #include "mruby/numeric.h" #include "opcode.h" #include "node.h" #include #include -#include -#include #include typedef mrb_ast_node node; diff --git a/src/error.c b/src/error.c index e46e37cbb..5bfbc4319 100644 --- a/src/error.c +++ b/src/error.c @@ -6,14 +6,9 @@ #include "mruby.h" #include -#include #include #include #include "error.h" -#include "opcode.h" -#include "mruby/irep.h" -#include "mruby/proc.h" -#include "mruby/numeric.h" #include "mruby/variable.h" #include "mruby/string.h" #include "mruby/class.h" diff --git a/src/gc.c b/src/gc.c index ada0bf31f..3c00bb015 100644 --- a/src/gc.c +++ b/src/gc.c @@ -11,12 +11,10 @@ #include "mruby/string.h" #include "mruby/hash.h" #include "mruby/range.h" -#include "mruby/khash.h" #include #include "mruby/struct.h" #include "mruby/proc.h" #include "mruby/data.h" -#include "mruby/numeric.h" #include "mruby/variable.h" /* @@ -101,6 +99,7 @@ typedef struct { } RVALUE; #ifdef GC_PROFILE +#include #include static double program_invoke_time = 0; diff --git a/src/hash.c b/src/hash.c index ed8b70270..dacef4713 100644 --- a/src/hash.c +++ b/src/hash.c @@ -11,7 +11,6 @@ #include "mruby/array.h" #include "mruby/string.h" #include "mruby/variable.h" -#include static inline khint_t mrb_hash_ht_hash_func(mrb_state *mrb, mrb_value key) diff --git a/src/kernel.c b/src/kernel.c index 240c0dcb3..f5a1f3d53 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -6,14 +6,9 @@ #include "mruby.h" #include "mruby/string.h" -#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 "error.h" diff --git a/src/numeric.c b/src/numeric.c index 6638cf62c..ec3f97ca6 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -8,11 +8,7 @@ #include "mruby/numeric.h" #include "mruby/string.h" #include "mruby/array.h" -#include -#include "mruby/class.h" -#include "mruby/variable.h" -#include #include #include #include diff --git a/src/proc.c b/src/proc.c index 98f753ac6..3e9bf1f67 100644 --- a/src/proc.c +++ b/src/proc.c @@ -6,7 +6,6 @@ #include "mruby.h" #include "mruby/proc.h" -#include "mruby/array.h" #include "mruby/class.h" #include "opcode.h" diff --git a/src/range.c b/src/range.c index 703ad12aa..b05836914 100644 --- a/src/range.c +++ b/src/range.c @@ -7,9 +7,6 @@ #include "mruby.h" #include "mruby/class.h" #include "mruby/range.h" -#include "mruby/variable.h" -#include "error.h" -#include "mruby/numeric.h" #include "mruby/string.h" #include diff --git a/src/sprintf.c b/src/sprintf.c index b597ff343..519e40b4b 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -15,7 +15,6 @@ #include "mruby/hash.h" #include "mruby/numeric.h" #include -#include #include #ifdef HAVE_IEEEFP_H diff --git a/src/string.c b/src/string.c index 14da83c51..e41116ebc 100644 --- a/src/string.c +++ b/src/string.c @@ -10,11 +10,10 @@ #include #include "mruby/string.h" #include -#include "mruby/numeric.h" +#include #include "mruby/range.h" #include "mruby/array.h" #include "mruby/class.h" -#include "mruby/variable.h" #include #ifdef ENABLE_REGEXP #include "re.h" diff --git a/src/struct.c b/src/struct.c index 25cd02d3d..6d8ce057f 100644 --- a/src/struct.c +++ b/src/struct.c @@ -17,13 +17,9 @@ #include "encoding.h" #endif -#include "mruby/numeric.h" -#include "mruby/hash.h" #include "mruby/string.h" #include "mruby/class.h" #include "mruby/variable.h" -#include "mruby/range.h" -#include "error.h" //#include "defines.h" #define mrb_long2int(n) ((int)(n)) diff --git a/src/symbol.c b/src/symbol.c index baab0fb3c..40484d4b5 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -8,12 +8,8 @@ #include "mruby/khash.h" #include -#include -#include #include "mruby/string.h" #include -#include "mruby/class.h" -#include "mruby/variable.h" /* ------------------------------------------------------ */ typedef struct symbol_name { diff --git a/src/variable.c b/src/variable.c index e2f3a7d08..be686bf72 100644 --- a/src/variable.c +++ b/src/variable.c @@ -8,8 +8,6 @@ #include "mruby/class.h" #include "mruby/khash.h" #include "mruby/variable.h" -#include "mruby/string.h" -#include "mruby/range.h" #include "error.h" #include "mruby/array.h" -- cgit v1.2.3 From b2fc62f3a917e9ab1d562b49312f8d7dd2e057c5 Mon Sep 17 00:00:00 2001 From: Masaki Muranaka Date: Sun, 29 Jul 2012 15:25:14 +0900 Subject: Remove commented out code. --- src/error.c | 9 ------- src/etc.c | 5 ---- src/hash.c | 8 +++---- src/kernel.c | 76 ++++++++++++++++------------------------------------------ src/object.c | 1 - src/range.c | 1 - src/string.c | 9 ------- src/struct.c | 9 ------- src/variable.c | 5 ---- 9 files changed, 24 insertions(+), 99 deletions(-) (limited to 'src/string.c') diff --git a/src/error.c b/src/error.c index 5bfbc4319..e71245509 100644 --- a/src/error.c +++ b/src/error.c @@ -29,7 +29,6 @@ mrb_exc_new3(mrb_state *mrb, struct RClass* c, mrb_value str) return mrb_funcall(mrb, mrb_obj_value(c), "new", 1, str); } -//mrb_value make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr); /* * call-seq: * Exception.new(msg = nil) -> exception @@ -307,14 +306,6 @@ make_exception(mrb_state *mrb, int argc, mrb_value *argv, int isstr) case 3: n = 1; exception_call: - //if (argv[0] == sysstack_error) return argv[0]; - - //CONST_ID(mrb, exception, "exception"); - //mesg = mrb_check_funcall(mrb, argv[0], exception, n, argv+1); - //if (mrb_nil_p(mesg)) { - // /* undef */ - // mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected"); - //} if (mrb_respond_to(mrb, argv[0], mrb_intern(mrb, "exception"))) { mesg = mrb_funcall_argv(mrb, argv[0], "exception", n, argv+1); } diff --git a/src/etc.c b/src/etc.c index 7e9381d16..d14498d9c 100644 --- a/src/etc.c +++ b/src/etc.c @@ -52,11 +52,6 @@ mrb_check_datatype(mrb_state *mrb, mrb_value obj, const struct mrb_data_type *ty mrb_value mrb_lastline_get(mrb_state *mrb) { - //mrb_value *var = mrb_svar(0); - //if (var) { - // return *var; - //} - //return mrb_nil_value(); mrb_value *argv; int argc; diff --git a/src/hash.c b/src/hash.c index 04e8c60be..5d3835019 100644 --- a/src/hash.c +++ b/src/hash.c @@ -1339,9 +1339,9 @@ mrb_init_hash(mrb_state *mrb) mrb_define_method(mrb, h, "default_proc", mrb_hash_default_proc,ARGS_NONE()); /* 15.2.13.4.7 */ mrb_define_method(mrb, h, "default_proc=", mrb_hash_set_default_proc,ARGS_REQ(1)); /* 15.2.13.4.7 */ mrb_define_method(mrb, h, "__delete", mrb_hash_delete, ARGS_REQ(1)); /* core of 15.2.13.4.8 */ -//mrb_define_method(mrb, h, "each", mrb_hash_each_pair, ARGS_NONE()); /* 15.2.13.4.9 */ /* move to mrblib\hash.rb */ -//mrb_define_method(mrb, h, "each_key", mrb_hash_each_key, ARGS_NONE()); /* 15.2.13.4.10 */ /* move to mrblib\hash.rb */ -//mrb_define_method(mrb, h, "each_value", mrb_hash_each_value, ARGS_NONE()); /* 15.2.13.4.11 */ /* move to mrblib\hash.rb */ +// "each" 15.2.13.4.9 move to mrblib/hash.rb +// "each_key" 15.2.13.4.10 move to mrblib/hash.rb +// "each_value" 15.2.13.4.11 move to mrblib/hash.rb mrb_define_method(mrb, h, "empty?", mrb_hash_empty_p, ARGS_NONE()); /* 15.2.13.4.12 */ mrb_define_method(mrb, h, "has_key?", mrb_hash_has_key, ARGS_REQ(1)); /* 15.2.13.4.13 */ mrb_define_method(mrb, h, "has_value?", mrb_hash_has_value, ARGS_REQ(1)); /* 15.2.13.4.14 */ @@ -1352,7 +1352,7 @@ mrb_init_hash(mrb_state *mrb) mrb_define_method(mrb, h, "keys", mrb_hash_keys, ARGS_NONE()); /* 15.2.13.4.19 */ mrb_define_method(mrb, h, "length", mrb_hash_size_m, ARGS_NONE()); /* 15.2.13.4.20 */ mrb_define_method(mrb, h, "member?", mrb_hash_has_key, ARGS_REQ(1)); /* 15.2.13.4.21 */ -//mrb_define_method(mrb, h, "merge", mrb_hash_merge, ARGS_REQ(1)); /* 15.2.13.4.22 */ /* move to mrblib\hash.rb */ +// "merge" 15.2.13.4.22 move to mrblib/hash.rb mrb_define_method(mrb, h, "replace", mrb_hash_replace, ARGS_REQ(1)); /* 15.2.13.4.23 */ mrb_define_method(mrb, h, "shift", mrb_hash_shift, ARGS_NONE()); /* 15.2.13.4.24 */ mrb_define_method(mrb, h, "size", mrb_hash_size_m, ARGS_NONE()); /* 15.2.13.4.25 */ diff --git a/src/kernel.c b/src/kernel.c index 468891b23..8aba1a808 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -72,9 +72,6 @@ inspect_obj(mrb_state *mrb, mrb_value obj, mrb_value str, int recur) int mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj) { - //const mrb_method_entry_t *me = mrb_method_entry(CLASS_OF(obj), mrb_intern("to_s")); - //if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC && - //me->def->body.cfunc.func == mrb_any_to_s) struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern(mrb, "to_s")); if (me && MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s)) return 1; @@ -314,52 +311,38 @@ mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj) { struct RClass *klass = RBASIC(obj)->c; - //if (!FL_TEST(klass, FL_SINGLETON)) - //return klass; if (klass->tt != MRB_TT_SCLASS) return klass; else { - //struct clone_method_data data; - /* copy singleton(unnamed) class */ - //VALUE clone = class_alloc(RBASIC(klass)->flags, 0); + /* copy singleton(unnamed) class */ struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class); - //clone->super = objklass->super; - if ((mrb_type(obj) == MRB_TT_CLASS) || - (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */ - clone->c = clone; - } - else { - clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass)); - } + if ((mrb_type(obj) == MRB_TT_CLASS) || + (mrb_type(obj) == MRB_TT_SCLASS)) { /* BUILTIN_TYPE(obj) == T_CLASS */ + clone->c = clone; + } + else { + clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass)); + } - clone->super = klass->super; - if (klass->iv) { - clone->iv = klass->iv; - } - if (klass->mt) { - clone->mt = kh_copy(mt, mrb, klass->mt); - } - else { - clone->mt = kh_init(mt, mrb); - } - clone->tt = MRB_TT_SCLASS; - return clone; + clone->super = klass->super; + if (klass->iv) { + clone->iv = klass->iv; + } + if (klass->mt) { + clone->mt = kh_copy(mt, mrb, klass->mt); + } + else { + clone->mt = kh_init(mt, mrb); + } + clone->tt = MRB_TT_SCLASS; + return clone; } } static void init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj) { - //if (OBJ_FROZEN(dest)) { - // rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest)); - //} - //RBASIC(dest)->flags &= ~(T_MASK|FL_EXIVAR); - //RBASIC(dest)->flags |= RBASIC(obj)->flags & (T_MASK|FL_EXIVAR|FL_TAINT); - //if (FL_TEST(obj, FL_EXIVAR)) { - // mrb_copy_generic_ivar(dest, obj); - //} - //mrb_gc_copy_finalizer(dest, obj); switch (mrb_type(obj)) { case MRB_TT_OBJECT: case MRB_TT_CLASS: @@ -416,8 +399,6 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self) clone = (struct RObject*)mrb_obj_alloc(mrb, self.tt, mrb_obj_class(mrb, self)); clone->c = mrb_singleton_class_clone(mrb, self); init_copy(mrb, mrb_obj_value(clone), self); - //1-9-2 no bug mrb_funcall(mrb, clone, "initialize_clone", 1, self); - //RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE; return mrb_obj_value(clone); } @@ -466,7 +447,6 @@ mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj) mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)"); } for (i = 0; i < argc; i++) { - //Check_Type(argv[i], T_MODULE); mrb_check_type(mrb, argv[i], MRB_TT_MODULE); } while (argc--) { @@ -511,19 +491,6 @@ mrb_obj_extend_m(mrb_state *mrb, mrb_value self) return mrb_obj_extend(mrb, argc, argv, self); } -/* 15.3.1.2.4 */ -/* 15.3.1.3.14 */ -/* - * call-seq: - * global_variables -> array - * - * Returns an array of the names of global variables. - * - * global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr] - */ -//mrb_value -//mrb_f_global_variables(mrb_state *mrb, mrb_value self) - /* 15.3.1.3.15 */ /* * call-seq: @@ -824,7 +791,6 @@ mrb_obj_singleton_methods(mrb_state *mrb, int argc, mrb_value *argv, mrb_value o recur = mrb_true_value(); } else { - //mrb_scan_args(argc, argv, "01", &recur); recur = argv[0]; } klass = mrb_class(mrb, obj); @@ -853,7 +819,6 @@ retry: else { mrb_value recur; - //mrb_scan_args(argc, argv, "1", &recur); recur = argv[0]; if (mrb_test(recur)) { argc = 0; @@ -1073,7 +1038,6 @@ obj_respond_to(mrb_state *mrb, mrb_value self) mrb_sym id; mrb_get_args(mrb, "*", &argv, &argc); - //mrb_scan_args(argc, argv, "11", &mid, &priv); mid = argv[0]; if (argc > 1) priv = argv[1]; else priv = mrb_nil_value(); diff --git a/src/object.c b/src/object.c index 43e064fb0..4f5fb1d28 100644 --- a/src/object.c +++ b/src/object.c @@ -516,7 +516,6 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method) mrb_value v; if (FIXNUM_P(val)) return val; - //if (TYPE(val) == T_BIGNUM) return val; v = convert_type(mrb, val, "Integer", method, TRUE); if (!mrb_obj_is_kind_of(mrb, v, mrb->fixnum_class)) { const char *cname = mrb_obj_classname(mrb, val); diff --git a/src/range.c b/src/range.c index 14fa2a6a3..9113a810a 100644 --- a/src/range.c +++ b/src/range.c @@ -412,7 +412,6 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy) mrb_get_args(mrb, "o", &src); if (mrb_obj_equal(mrb, copy, src)) return copy; - //mrb_check_frozen(copy); if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) { mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class"); } diff --git a/src/string.c b/src/string.c index e41116ebc..0a5dee88e 100644 --- a/src/string.c +++ b/src/string.c @@ -1354,7 +1354,6 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) static mrb_value mrb_str_gsub(mrb_state *mrb, mrb_value self) { - //return str_gsub(argc, argv, self, 0); return str_gsub(mrb, self, 0); } @@ -1469,10 +1468,8 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) int argc; mrb_value sub; - //mrb_value initpos; mrb_int pos; - //if (mrb_scan_args(argc, argv, "11", &sub, &initpos) == 2) { mrb_get_args(mrb, "*", &argv, &argc); if (argc == 2) { pos = mrb_fixnum(argv[1]); @@ -1959,7 +1956,6 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) if (mrb_reg_search(mrb, pat, str, *start, 0) >= 0) { match = mrb_backref_get(mrb); - //regs = RMATCH(match)->regs; pmatch = mrb_match_ptr(match); regs = &pmatch->rmatch->regs; if (regs->beg[0] == regs->end[0]) { @@ -2143,7 +2139,6 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) split_type = awk; } else { -//fs_set: if (mrb_type(spat) == MRB_TT_STRING) { split_type = string; #ifdef ENABLE_REGEXP @@ -2546,7 +2541,6 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck) if (s) { len = RSTRING_LEN(str); if (s[len]) { /* no sentinel somehow */ - //char *p = ALLOCA_N(char, len+1); char *p = mrb_malloc(mrb, len+1); //MEMCPY(p, s, char, len); @@ -2584,10 +2578,8 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self) { mrb_value *argv; int argc; - //mrb_value b; int base; - //mrb_scan_args(argc, *argv, "01", &b); mrb_get_args(mrb, "*", &argv, &argc); if (argc == 0) base = 10; @@ -2710,7 +2702,6 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck) static mrb_value mrb_str_to_f(mrb_state *mrb, mrb_value self) { - //return mrb_float_new(mrb_str_to_dbl(self, 0/*Qfalse*/)); return mrb_float_value(mrb_str_to_dbl(mrb, self, 0/*Qfalse*/)); } diff --git a/src/struct.c b/src/struct.c index 6d8ce057f..0a95f9e49 100644 --- a/src/struct.c +++ b/src/struct.c @@ -38,8 +38,6 @@ struct_ivar_get(mrb_state *mrb, mrb_value c, mrb_sym id) mrb_value ans; for (;;) { - //if (mrb_ivar_defined(c, id)) - // return mrb_iv_get(mrb, c, id); ans = mrb_iv_get(mrb, c, id); if (!mrb_nil_p(ans)) return ans; kclass = RCLASS_SUPER(c); @@ -260,19 +258,15 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k //OBJ_FREEZE(members); if (mrb_nil_p(name)) { c = mrb_class_new(mrb, klass); - //mrb_make_metaclass(nstr, RBASIC(klass)->c); - //mrb_class_inherited(klass, nstr); } else { /* old style: should we warn? */ name = mrb_str_to_str(mrb, name); id = mrb_to_id(mrb, name); if (!mrb_is_const_id(id)) { - //mrb_name_error(id, "identifier %s needs to be constant", StringValuePtr(name)); mrb_name_error(mrb, id, "identifier %s needs to be constant", mrb_string_value_ptr(mrb, name)); } if (mrb_const_defined_at(mrb, klass, id)) { - //mrb_warn("redefining constant Struct::%s", StringValuePtr(name)); mrb_warn("redefining constant Struct::%s", mrb_string_value_ptr(mrb, name)); //?rb_mod_remove_const(klass, mrb_sym2name(mrb, id)); } @@ -376,7 +370,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) mrb_get_args(mrb, "&*", &b, &argv, &argc); if (argc > 0) name = argv[0]; if (argc > 1) rest = argv[1]; - //mrb_scan_args(argc, argv, "1*", &name, &rest); if (mrb_type(rest) == MRB_TT_ARRAY) { if (!mrb_nil_p(name) && SYMBOL_P(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ @@ -389,7 +382,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) argcnt = argc-1; if (!mrb_nil_p(name) && SYMBOL_P(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ - //mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); pargv = &argv[0]; argcnt++; @@ -557,7 +549,6 @@ mrb_struct_init_copy(mrb_state *mrb, mrb_value copy) mrb_get_args(mrb, "o", &s); if (mrb_obj_equal(mrb, copy, s)) return copy; - //mrb_check_frozen(copy); if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) { mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class"); } diff --git a/src/variable.c b/src/variable.c index a1a7f2e82..04e5ad9f7 100644 --- a/src/variable.c +++ b/src/variable.c @@ -460,10 +460,6 @@ kiv_lookup(khash_t(iv)* table, mrb_sym key, mrb_value *value) khash_t(iv) *h=table; khiter_t k; - // you must check(iv==0), before you call this function. - //if (!obj->iv) { - // return 0; - //} k = kh_get(iv, h, key); if (k != kh_end(h)) { *value = kh_value(h, k); @@ -505,7 +501,6 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id) mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id) { - //return ivar_get(obj, id, FALSE); return mrb_iv_get(mrb, obj, id); } -- cgit v1.2.3 From 5a4beeed2d0c229a3a558650f03c8390da2d556c Mon Sep 17 00:00:00 2001 From: Max Anselm Date: Sun, 29 Jul 2012 19:45:27 -0400 Subject: Make all(?) void casts explicit for C++ --- src/array.c | 12 +++++------ src/cdump.c | 4 ++-- src/codegen.c | 26 ++++++++++++------------ src/dump.c | 14 ++++++------- src/gc.c | 2 +- src/kernel.c | 2 +- src/load.c | 22 ++++++++++---------- src/math.c | 1 + src/pool.c | 4 ++-- src/proc.c | 4 ++-- src/range.c | 2 +- src/st.c | 12 +++++------ src/state.c | 6 +++--- src/string.c | 30 ++++++++++++++-------------- src/struct.c | 4 ++-- src/symbol.c | 2 +- src/time.c | 64 +++++++++++++++++++++++++++++------------------------------ src/vm.c | 16 +++++++-------- 18 files changed, 114 insertions(+), 113 deletions(-) (limited to 'src/string.c') diff --git a/src/array.c b/src/array.c index ccd22674e..c385fe99b 100644 --- a/src/array.c +++ b/src/array.c @@ -46,7 +46,7 @@ ary_new_capa(mrb_state *mrb, int capa) } a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); - a->ptr = mrb_calloc(mrb, blen, 1); + a->ptr = (mrb_value *)mrb_calloc(mrb, blen, 1); a->aux.capa = capa; a->len = 0; @@ -116,7 +116,7 @@ ary_modify(mrb_state *mrb, struct RArray *a) p = a->ptr; len = a->len * sizeof(mrb_value); - ptr = mrb_malloc(mrb, len); + ptr = (mrb_value *)mrb_malloc(mrb, len); if (p) { memcpy(ptr, p, len); } @@ -132,11 +132,11 @@ static void ary_make_shared(mrb_state *mrb, struct RArray *a) { if (!(a->flags & MRB_ARY_SHARED)) { - struct mrb_shared_array *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_array)); + struct mrb_shared_array *shared = (struct mrb_shared_array *)mrb_malloc(mrb, sizeof(struct mrb_shared_array)); shared->refcnt = 1; if (a->aux.capa > a->len) { - a->ptr = shared->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1); + a->ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1); } else { shared->ptr = a->ptr; @@ -173,7 +173,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, int len) if (capa > a->aux.capa) { a->aux.capa = capa; - a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); + a->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); } } @@ -195,7 +195,7 @@ ary_shrink_capa(mrb_state *mrb, struct RArray *a) if (capa > a->len && capa < a->aux.capa) { a->aux.capa = capa; - a->ptr = mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); + a->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa); } } diff --git a/src/cdump.c b/src/cdump.c index a4a2ac5e1..32982e6fe 100644 --- a/src/cdump.c +++ b/src/cdump.c @@ -107,7 +107,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) return -1; buf_len = MRB_CDUMP_LINE_LEN; - if ((buf = mrb_malloc(mrb, buf_len)) == 0 ) { + if ((buf = (char *)mrb_malloc(mrb, buf_len)) == 0 ) { return MRB_CDUMP_GENERAL_FAILURE; } @@ -144,7 +144,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f) str_len = str_format_len(irep->pool[n]) + 1; if ( str_len > buf_len ) { buf_len = str_len; - if ((buf = mrb_realloc(mrb, buf, buf_len)) == 0 ) { + if ((buf = (char *)mrb_realloc(mrb, buf, buf_len)) == 0 ) { return MRB_CDUMP_GENERAL_FAILURE; } } diff --git a/src/codegen.c b/src/codegen.c index 3bf0e496c..2e8104fdd 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -136,7 +136,7 @@ genop(codegen_scope *s, mrb_code i) { if (s->pc == s->icapa) { s->icapa *= 2; - s->iseq = codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa); + s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa); } s->iseq[s->pc] = i; s->pc++; @@ -323,7 +323,7 @@ new_lit(codegen_scope *s, mrb_value val) } if (s->plen == s->pcapa) { s->pcapa *= 2; - s->pool = codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa); + s->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->pcapa); } s->pool[s->plen] = val; return s->plen++; @@ -357,7 +357,7 @@ new_sym(codegen_scope *s, mrb_sym sym) if (s->syms[i] == sym) return i; } if (s->slen > 125 && s->slen < 256) { - s->syms = codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536); + s->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*65536); memset(s->syms+s->slen, 0, sizeof(mrb_sym)*(256-s->slen)); s->slen = 256; } @@ -556,7 +556,7 @@ attrsym(codegen_scope *s, mrb_sym a) char *name2; name = mrb_sym2name_len(s->mrb, a, &len); - name2 = codegen_palloc(s, len+1); + name2 = (char *)codegen_palloc(s, len+1); memcpy(name2, name, len); name2[len] = '='; name2[len+1] = '\0'; @@ -1927,7 +1927,7 @@ static codegen_scope* scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) { mrb_pool *pool = mrb_pool_open(mrb); - codegen_scope *p = mrb_pool_alloc(pool, sizeof(codegen_scope)); + codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope)); if (!p) return 0; memset(p, 0, sizeof(codegen_scope)); @@ -1940,12 +1940,12 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv) p->mrb = prev->mrb; p->icapa = 1024; - p->iseq = mrb_malloc(mrb, sizeof(mrb_code)*p->icapa); + p->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa); p->pcapa = 32; - p->pool = mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa); + p->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa); - p->syms = mrb_malloc(mrb, sizeof(mrb_sym)*256); + p->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym)*256); p->lv = lv; p->sp += node_len(lv)+2; @@ -1964,20 +1964,20 @@ scope_finish(codegen_scope *s, int idx) mrb_irep *irep; mrb_add_irep(mrb, idx); - irep = mrb->irep[idx] = mrb_malloc(mrb, sizeof(mrb_irep)); + irep = mrb->irep[idx] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep)); irep->idx = idx; irep->flags = 0; if (s->iseq) { - irep->iseq = codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc); + irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc); irep->ilen = s->pc; } if (s->pool) { - irep->pool = codegen_realloc(s, s->pool, sizeof(mrb_value)*s->plen); + irep->pool = (mrb_value *)codegen_realloc(s, s->pool, sizeof(mrb_value)*s->plen); irep->plen = s->plen; } if (s->syms) { - irep->syms = codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->slen); + irep->syms = (mrb_sym *)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->slen); irep->slen = s->slen; } @@ -1991,7 +1991,7 @@ scope_finish(codegen_scope *s, int idx) static struct loopinfo* loop_push(codegen_scope *s, enum looptype t) { - struct loopinfo *p = codegen_palloc(s, sizeof(struct loopinfo)); + struct loopinfo *p = (struct loopinfo *)codegen_palloc(s, sizeof(struct loopinfo)); p->type = t; p->pc1 = p->pc2 = p->pc3 = 0; diff --git a/src/dump.c b/src/dump.c index d8768f771..230ba9bba 100644 --- a/src/dump.c +++ b/src/dump.c @@ -335,7 +335,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) int len; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) goto error_exit; buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */ @@ -360,7 +360,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type); if ( nlen > buf_size - 1) { buf_size = nlen + 1; - if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; memset(char_buf, 0, buf_size); } @@ -409,7 +409,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) uint16_t buf_size =0; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) goto error_exit; buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */ @@ -425,7 +425,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) nlen = str_dump_len((char*)name, len, type); if ( nlen > buf_size - 1) { buf_size = nlen + 1; - if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; } memset(char_buf, 0, buf_size); @@ -461,7 +461,7 @@ calc_crc_section(mrb_state *mrb, mrb_irep *irep, uint16_t *crc, int section) default: return MRB_DUMP_GENERAL_FAILURE; } - if ((buf = mrb_calloc(mrb, 1, buf_size)) == 0) + if ((buf = (char *)mrb_calloc(mrb, 1, buf_size)) == 0) return MRB_DUMP_GENERAL_FAILURE; buf_top = buf; @@ -598,7 +598,7 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen) if (irep_record_size == 0) return MRB_DUMP_GENERAL_FAILURE; - if ((buf = mrb_calloc(mrb, 1, irep_record_size)) == 0) + if ((buf = (char *)mrb_calloc(mrb, 1, irep_record_size)) == 0) return MRB_DUMP_GENERAL_FAILURE; if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK) { @@ -690,7 +690,7 @@ mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname) buf_size += get_irep_record_size(mrb, irep_no, DUMP_TYPE_BIN); buf_size += MRB_DUMP_SIZE_OF_LONG; /* end of file */ - if ((buf = mrb_malloc(mrb, buf_size)) == 0) + if ((buf = (char *)mrb_malloc(mrb, buf_size)) == 0) return MRB_DUMP_GENERAL_FAILURE; rc = mrb_write_irep(mrb, n, buf); diff --git a/src/gc.c b/src/gc.c index c0d4e1599..59a6b7eb4 100644 --- a/src/gc.c +++ b/src/gc.c @@ -248,7 +248,7 @@ unlink_free_heap_page(mrb_state *mrb, struct heap_page *page) static void add_heap(mrb_state *mrb) { - struct heap_page *page = mrb_calloc(mrb, 1, sizeof(struct heap_page)); + struct heap_page *page = (struct heap_page *)mrb_calloc(mrb, 1, sizeof(struct heap_page)); RVALUE *p, *e; struct RBasic *prev = NULL; diff --git a/src/kernel.c b/src/kernel.c index 8aba1a808..36dfbe769 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -853,7 +853,7 @@ mrb_obj_methods_m(mrb_state *mrb, mrb_value self) int argc; mrb_get_args(mrb, "*", &argv, &argc); - return mrb_obj_methods(mrb, argc, argv, self, 0); /* everything but private */ + return mrb_obj_methods(mrb, argc, argv, self, (mrb_method_flag_t)0); /* everything but private */ } /* 15.3.1.3.32 */ diff --git a/src/load.c b/src/load.c index c1c0a7eed..cee985f43 100644 --- a/src/load.c +++ b/src/load.c @@ -143,7 +143,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ uint16_t buf_size =0; buf_size = MRB_DUMP_DEFAULT_STR_LEN; - if ((char_buf = mrb_malloc(mrb, buf_size)) == 0) + if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0) goto error_exit; pStart = dst; @@ -192,7 +192,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ if ( pdl > buf_size - 1) { buf_size = pdl + 1; - if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; } memset(char_buf, '\0', buf_size); @@ -219,7 +219,7 @@ load_rite_irep_record(mrb_state *mrb, RiteFILE* rfp, unsigned char* dst, uint32_ if ( snl > buf_size - 1) { buf_size = snl + 1; - if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0) + if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0) goto error_exit; } memset(char_buf, '\0', buf_size); @@ -262,7 +262,7 @@ mrb_load_irep(mrb_state *mrb, FILE* fp) return ret; len = sizeof(rite_binary_header) + bin_to_uint32(bin_header.rbds); - if ((rite_dst = mrb_malloc(mrb, len)) == NULL) + if ((rite_dst = (unsigned char *)mrb_malloc(mrb, len)) == NULL) return MRB_DUMP_GENERAL_FAILURE; dst = rite_dst; @@ -331,7 +331,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 int ai = mrb_gc_arena_save(mrb); recordStart = src; - buf = mrb_malloc(mrb, bufsize); + buf = (char *)mrb_malloc(mrb, bufsize); if (buf == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; @@ -359,7 +359,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 irep->ilen = bin_to_uint32(src); //iseq length src += MRB_DUMP_SIZE_OF_LONG; if (irep->ilen > 0) { - if ((irep->iseq = mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) { + if ((irep->iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code) * irep->ilen)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } @@ -380,7 +380,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 irep->plen = bin_to_uint32(src); //pool length src += MRB_DUMP_SIZE_OF_LONG; if (irep->plen > 0) { - irep->pool = mrb_malloc(mrb, sizeof(mrb_value) * irep->plen); + irep->pool = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value) * irep->plen); if (irep->pool == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; @@ -394,7 +394,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 if (pdl > bufsize - 1) { mrb_free(mrb, buf); bufsize = pdl + 1; - if ((buf = mrb_malloc(mrb, bufsize)) == NULL) { + if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } @@ -443,7 +443,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 irep->slen = bin_to_uint32(src); //syms length src += MRB_DUMP_SIZE_OF_LONG; if (irep->slen > 0) { - if ((irep->syms = mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) { + if ((irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen)) == NULL) { ret = MRB_DUMP_INVALID_IREP; goto error_exit; } @@ -461,7 +461,7 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32 if (snl > bufsize - 1) { mrb_free(mrb, buf); bufsize = snl + 1; - if ((buf = mrb_malloc(mrb, bufsize)) == NULL) { + if ((buf = (char *)mrb_malloc(mrb, bufsize)) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } @@ -509,7 +509,7 @@ mrb_read_irep(mrb_state *mrb, const char *bin) mrb_add_irep(mrb, sirep + nirep); for (n=0,i=sirep; nirep[i] = mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) { + if ((mrb->irep[i] = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep))) == NULL) { ret = MRB_DUMP_GENERAL_FAILURE; goto error_exit; } diff --git a/src/math.c b/src/math.c index cf9a20489..ecf9fbf43 100644 --- a/src/math.c +++ b/src/math.c @@ -5,6 +5,7 @@ */ #include "mruby.h" +#include "mruby/array.h" #ifdef ENABLE_MATH #include diff --git a/src/pool.c b/src/pool.c index 0f1baa776..36c6fa8eb 100644 --- a/src/pool.c +++ b/src/pool.c @@ -49,7 +49,7 @@ struct mrb_pool { mrb_pool* mrb_pool_open(mrb_state *mrb) { - mrb_pool *pool = mrb_malloc(mrb, sizeof(mrb_pool)); + mrb_pool *pool = (mrb_pool *)mrb_malloc(mrb, sizeof(mrb_pool)); if (pool) { pool->mrb = mrb; @@ -81,7 +81,7 @@ page_alloc(mrb_pool *pool, size_t len) if (len < POOL_PAGE_SIZE) len = POOL_PAGE_SIZE; - page = mrb_malloc(pool->mrb, sizeof(struct mrb_pool_page)+len-1); + page = (struct mrb_pool_page *)mrb_malloc(pool->mrb, sizeof(struct mrb_pool_page)+len-1); if (page) { page->offset = 0; page->len = len; diff --git a/src/proc.c b/src/proc.c index e27d5d578..d223fa760 100644 --- a/src/proc.c +++ b/src/proc.c @@ -144,8 +144,8 @@ void mrb_init_proc(mrb_state *mrb) { struct RProc *m; - mrb_code *call_iseq = mrb_malloc(mrb, sizeof(mrb_code)); - mrb_irep *call_irep = mrb_calloc(mrb, sizeof(mrb_irep), 1); + mrb_code *call_iseq = (mrb_code *)mrb_malloc(mrb, sizeof(mrb_code)); + mrb_irep *call_irep = (mrb_irep *)mrb_calloc(mrb, sizeof(mrb_irep), 1); if ( call_iseq == NULL || call_irep == NULL ) return; diff --git a/src/range.c b/src/range.c index 9113a810a..db17c7d40 100644 --- a/src/range.c +++ b/src/range.c @@ -43,7 +43,7 @@ mrb_range_new(mrb_state *mrb, mrb_value beg, mrb_value end, int excl) struct RRange *r; r = (struct RRange*)mrb_obj_alloc(mrb, MRB_TT_RANGE, RANGE_CLASS); - r->edges = mrb_malloc(mrb, sizeof(struct mrb_range_edges)); + r->edges = (struct mrb_range_edges *)mrb_malloc(mrb, sizeof(struct mrb_range_edges)); range_check(mrb, beg, end); r->edges->beg = beg; r->edges->end = end; diff --git a/src/st.c b/src/st.c index 257da7e2b..c3c20c80a 100644 --- a/src/st.c +++ b/src/st.c @@ -24,21 +24,21 @@ static int numcmp(long, long); static st_index_t numhash(long); static struct st_hash_type type_numhash = { - numcmp, - numhash, + (int (*)(ANYARGS))numcmp, + (st_index_t (*)(ANYARGS))numhash, }; /* extern int strcmp(const char *, const char *); */ static st_index_t strhash(const char*); static struct st_hash_type type_strhash = { - strcmp, - strhash, + (int (*)(ANYARGS))strcmp, + (st_index_t (*)(ANYARGS))strhash, }; static st_index_t strcasehash(st_data_t); static const struct st_hash_type type_strcasehash = { - st_strcasecmp, - strcasehash, + (int (*)(ANYARGS))st_strcasecmp, + (st_index_t (*)(ANYARGS))strcasehash, }; static void rehash(st_table*); diff --git a/src/state.c b/src/state.c index 0d236e660..26e7dff4a 100644 --- a/src/state.c +++ b/src/state.c @@ -15,7 +15,7 @@ void mrb_init_ext(mrb_state*); mrb_state* mrb_open_allocf(mrb_allocf f) { - mrb_state *mrb = (f)(NULL, NULL, sizeof(mrb_state)); + mrb_state *mrb = (mrb_state *)(f)(NULL, NULL, sizeof(mrb_state)); if (mrb == NULL) return NULL; memset(mrb, 0, sizeof(mrb_state)); @@ -76,14 +76,14 @@ mrb_add_irep(mrb_state *mrb, int idx) int max = 256; if (idx > max) max = idx+1; - mrb->irep = mrb_calloc(mrb, max, sizeof(mrb_irep*)); + mrb->irep = (mrb_irep **)mrb_calloc(mrb, max, sizeof(mrb_irep*)); mrb->irep_capa = max; } else if (mrb->irep_capa <= idx) { while (mrb->irep_capa <= idx) { mrb->irep_capa *= 2; } - mrb->irep = mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa); + mrb->irep = (mrb_irep **)mrb_realloc(mrb, mrb->irep, sizeof(mrb_irep*)*mrb->irep_capa); } } diff --git a/src/string.c b/src/string.c index 0a5dee88e..11990c22d 100644 --- a/src/string.c +++ b/src/string.c @@ -29,7 +29,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->ptr = mrb_realloc(mrb, s->ptr, (capacity)+1);\ + s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\ s->aux.capa = capacity;\ } while (0) @@ -60,7 +60,7 @@ str_modify(mrb_state *mrb, struct RString *s) p = s->ptr; len = s->len; - ptr = mrb_malloc(mrb, len+1); + ptr = (char *)mrb_malloc(mrb, len+1); if (p) { memcpy(ptr, p, len); } @@ -83,7 +83,7 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, int len) slen = s->len; if (len != slen) { if (slen < len || slen -len > 1024) { - s->ptr = mrb_realloc(mrb, s->ptr, len+1); + s->ptr = (char *)mrb_realloc(mrb, s->ptr, len+1); } s->aux.capa = len; s->len = len; @@ -133,7 +133,7 @@ str_new(mrb_state *mrb, const char *p, int len) s->len = len; s->aux.capa = len; - s->ptr = mrb_malloc(mrb, len+1); + s->ptr = (char *)mrb_malloc(mrb, len+1); if (p) { memcpy(s->ptr, p, len); } @@ -168,7 +168,7 @@ mrb_str_buf_new(mrb_state *mrb, int capa) } s->len = 0; s->aux.capa = capa; - s->ptr = mrb_malloc(mrb, capa+1); + s->ptr = (char *)mrb_malloc(mrb, capa+1); s->ptr[0] = '\0'; return mrb_obj_value(s); @@ -249,7 +249,7 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) int len = strlen(p); s = mrb_obj_alloc_string(mrb); - s->ptr = mrb_malloc(mrb, len+1); + s->ptr = (char *)mrb_malloc(mrb, len+1); memcpy(s->ptr, p, len); s->ptr[len] = 0; s->len = len; @@ -262,11 +262,11 @@ static void str_make_shared(mrb_state *mrb, struct RString *s) { if (!(s->flags & MRB_STR_SHARED)) { - struct mrb_shared_string *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_string)); + struct mrb_shared_string *shared = (struct mrb_shared_string *)mrb_malloc(mrb, sizeof(struct mrb_shared_string)); shared->refcnt = 1; if (s->aux.capa > s->len) { - s->ptr = shared->ptr = mrb_realloc(mrb, s->ptr, s->len+1); + s->ptr = shared->ptr = (char *)mrb_realloc(mrb, s->ptr, s->len+1); } else { shared->ptr = s->ptr; @@ -341,7 +341,7 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other) if (s1->aux.capa < len) { s1->aux.capa = len; - s1->ptr = mrb_realloc(mrb, s1->ptr, len+1); + s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, len+1); } memcpy(s1->ptr+s1->len, s2->ptr, s2->len); s1->len = len; @@ -664,7 +664,7 @@ mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long static int mrb_memsearch(const void *x0, int m, const void *y0, int n) { - const unsigned char *x = x0, *y = y0; + const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0; if (m > n) return -1; else if (m == n) { @@ -681,7 +681,7 @@ mrb_memsearch(const void *x0, int m, const void *y0, int n) } return -1; } - return mrb_memsearch_qs(x0, m, y0, n); + return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n); } static mrb_int @@ -1564,10 +1564,10 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2) if (s1->flags & MRB_STR_SHARED) { mrb_str_decref(mrb, s1->aux.shared); s1->flags &= ~MRB_STR_SHARED; - s1->ptr = mrb_malloc(mrb, s2->len+1); + s1->ptr = (char *)mrb_malloc(mrb, s2->len+1); } else { - s1->ptr = mrb_realloc(mrb, s1->ptr, s2->len+1); + s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, s2->len+1); } memcpy(s1->ptr, s2->ptr, s2->len); s1->ptr[s2->len] = 0; @@ -2541,7 +2541,7 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck) if (s) { len = RSTRING_LEN(str); if (s[len]) { /* no sentinel somehow */ - char *p = mrb_malloc(mrb, len+1); + char *p = (char *)mrb_malloc(mrb, len+1); //MEMCPY(p, s, char, len); memcpy(p, s, sizeof(char)*len); @@ -2675,7 +2675,7 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck) mrb_raise(mrb, E_ARGUMENT_ERROR, "string for Float contains null byte"); } if (s[len]) { /* no sentinel somehow */ - char *p = mrb_malloc(mrb, len+1); + char *p = (char *)mrb_malloc(mrb, len+1); memcpy(p, s, sizeof(char)*len); p[len] = '\0'; diff --git a/src/struct.c b/src/struct.c index 0a95f9e49..a133dc046 100644 --- a/src/struct.c +++ b/src/struct.c @@ -184,7 +184,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id) mrb_sym mid; name = mrb_sym2name_len(mrb, id, &len); - buf = mrb_malloc(mrb, len+2); + buf = (char *)mrb_malloc(mrb, len+2); memcpy(buf, name, len); buf[len] = '='; buf[len+1] = '\0'; @@ -427,7 +427,7 @@ mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_val mrb_raise(mrb, E_ARGUMENT_ERROR, "struct size differs"); } st = RSTRUCT(self); - st->ptr = mrb_calloc(mrb, sizeof(mrb_value), n); + st->ptr = (mrb_value *)mrb_calloc(mrb, sizeof(mrb_value), n); st->len = n; memcpy(st->ptr, argv, sizeof(mrb_value)*argc); diff --git a/src/symbol.c b/src/symbol.c index 6e92fb6c7..b81296929 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -50,7 +50,7 @@ mrb_intern2(mrb_state *mrb, const char *name, int len) return kh_value(h, k); sym = ++mrb->symidx; - p = mrb_malloc(mrb, len+1); + p = (char *)mrb_malloc(mrb, len+1); memcpy(p, name, len); p[len] = 0; sname.name = (const char*)p; diff --git a/src/time.c b/src/time.c index c988d0fd0..e71fc17fe 100644 --- a/src/time.c +++ b/src/time.c @@ -164,7 +164,7 @@ mrb_time_alloc(mrb_state *mrb, mrb_float sec, mrb_float usec, enum mrb_timezone { struct mrb_time *tm; - tm = mrb_malloc(mrb, sizeof(struct mrb_time)); + tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time)); tm->sec = (time_t)sec; tm->usec = (sec - tm->sec) * 1.0e6 + usec; while (tm->usec < 0) { @@ -192,7 +192,7 @@ current_mrb_time(mrb_state *mrb) { struct mrb_time *tm; - tm = mrb_malloc(mrb, sizeof(*tm)); + tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm)); #ifdef NO_GETTIMEOFDAY { static time_t last_sec = 0, last_usec = 0; @@ -304,8 +304,8 @@ mrb_time_eq(mrb_state *mrb, mrb_value self) struct mrb_time *tm1, *tm2; mrb_get_args(mrb, "o", &other); - tm1 = mrb_get_datatype(mrb, self, &mrb_time_type); - tm2 = mrb_get_datatype(mrb, other, &mrb_time_type); + tm1 = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); + tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type); if (!tm1 || !tm2) return mrb_false_value(); if (tm1->sec == tm2->sec && tm1->usec == tm2->usec) { return mrb_true_value(); @@ -320,8 +320,8 @@ mrb_time_cmp(mrb_state *mrb, mrb_value self) struct mrb_time *tm1, *tm2; mrb_get_args(mrb, "o", &other); - tm1 = mrb_get_datatype(mrb, self, &mrb_time_type); - tm2 = mrb_get_datatype(mrb, other, &mrb_time_type); + tm1 = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); + tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type); if (!tm1 || !tm2) return mrb_nil_value(); if (tm1->sec > tm2->sec) { return mrb_fixnum_value(1); @@ -346,7 +346,7 @@ mrb_time_plus(mrb_state *mrb, mrb_value self) struct mrb_time *tm; mrb_get_args(mrb, "f", &f); - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_time_make(mrb, mrb_obj_class(mrb, self), tm->sec+f, tm->usec, tm->timezone); } @@ -359,10 +359,10 @@ mrb_time_minus(mrb_state *mrb, mrb_value self) struct mrb_time *tm, *tm2; mrb_get_args(mrb, "o", &other); - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); - tm2 = mrb_get_datatype(mrb, other, &mrb_time_type); + tm2 = (struct mrb_time *)mrb_get_datatype(mrb, other, &mrb_time_type); if (tm2) { f = (mrb_float)(tm->sec - tm2->sec) + (mrb_float)(tm->usec - tm2->usec) / 1.0e6; @@ -381,7 +381,7 @@ mrb_time_wday(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_wday); } @@ -393,7 +393,7 @@ mrb_time_yday(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_check_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_check_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_yday); } @@ -405,7 +405,7 @@ mrb_time_year(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_year + 1900); } @@ -417,7 +417,7 @@ mrb_time_zone(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); if (tm->timezone <= MRB_TIMEZONE_NONE) return mrb_nil_value(); if (tm->timezone >= MRB_TIMEZONE_LAST) return mrb_nil_value(); @@ -434,7 +434,7 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self) char buf[256]; int len; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); d = &tm->datetime; len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d", @@ -452,7 +452,7 @@ mrb_time_day(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_mday); } @@ -465,7 +465,7 @@ mrb_time_dstp(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_bool_value(tm->datetime.tm_isdst); } @@ -478,9 +478,9 @@ mrb_time_getutc(mrb_state *mrb, mrb_value self) { struct mrb_time *tm, *tm2; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return self; - tm2 = mrb_malloc(mrb, sizeof(*tm)); + tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm)); *tm2 = *tm; tm2->timezone = MRB_TIMEZONE_UTC; mrb_time_update_datetime(tm2); @@ -494,9 +494,9 @@ mrb_time_getlocal(mrb_state *mrb, mrb_value self) { struct mrb_time *tm, *tm2; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return self; - tm2 = mrb_malloc(mrb, sizeof(*tm)); + tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm)); *tm2 = *tm; tm2->timezone = MRB_TIMEZONE_LOCAL; mrb_time_update_datetime(tm2); @@ -510,7 +510,7 @@ mrb_time_hour(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_hour); } @@ -524,7 +524,7 @@ mrb_time_initialize(mrb_state *mrb, mrb_value self) amin = 0, asec = 0, ausec = 0; struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (tm) { mrb_time_free(mrb, tm); } @@ -568,7 +568,7 @@ mrb_time_localtime(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return self; tm->timezone = MRB_TIMEZONE_LOCAL; mrb_time_update_datetime(tm); @@ -582,7 +582,7 @@ mrb_time_mday(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_mday); } @@ -594,7 +594,7 @@ mrb_time_min(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_min); } @@ -606,7 +606,7 @@ mrb_time_mon(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_mon + 1); } @@ -618,7 +618,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->datetime.tm_sec); } @@ -631,7 +631,7 @@ mrb_time_to_f(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_float_value((mrb_float)tm->sec + (mrb_float)tm->usec/1.0e6); } @@ -643,7 +643,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->sec); } @@ -655,7 +655,7 @@ mrb_time_usec(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_fixnum_value(tm->usec); } @@ -667,7 +667,7 @@ mrb_time_utc(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (tm) { tm->timezone = MRB_TIMEZONE_UTC; mrb_time_update_datetime(tm); @@ -681,7 +681,7 @@ static mrb_value mrb_time_utcp(mrb_state *mrb, mrb_value self) { struct mrb_time *tm; - tm = mrb_get_datatype(mrb, self, &mrb_time_type); + tm = (struct mrb_time *)mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); return mrb_bool_value(tm->timezone == MRB_TIMEZONE_UTC); } diff --git a/src/vm.c b/src/vm.c index e8dcf1b80..5e14ff139 100644 --- a/src/vm.c +++ b/src/vm.c @@ -28,12 +28,12 @@ static void stack_init(mrb_state *mrb) { /* assert(mrb->stack == NULL); */ - mrb->stbase = mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value)); + mrb->stbase = (mrb_value *)mrb_calloc(mrb, STACK_INIT_SIZE, sizeof(mrb_value)); mrb->stend = mrb->stbase + STACK_INIT_SIZE; mrb->stack = mrb->stbase; /* assert(mrb->ci == NULL); */ - mrb->cibase = mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo)); + mrb->cibase = (mrb_callinfo *)mrb_calloc(mrb, CALLINFO_INIT_SIZE, sizeof(mrb_callinfo)); mrb->ciend = mrb->cibase + CALLINFO_INIT_SIZE; mrb->ci = mrb->cibase; mrb->ci->target_class = mrb->object_class; @@ -70,7 +70,7 @@ stack_extend(mrb_state *mrb, int room, int keep) size *= 2; else size += room; - mrb->stbase = mrb_realloc(mrb, mrb->stbase, sizeof(mrb_value) * size); + mrb->stbase = (mrb_value *)mrb_realloc(mrb, mrb->stbase, sizeof(mrb_value) * size); mrb->stack = mrb->stbase + off; mrb->stend = mrb->stbase + size; envadjust(mrb, oldbase, mrb->stbase); @@ -127,7 +127,7 @@ cipush(mrb_state *mrb) if (mrb->ci + 1 == mrb->ciend) { size_t size = mrb->ci - mrb->cibase; - mrb->cibase = mrb_realloc(mrb, mrb->cibase, sizeof(mrb_callinfo)*size*2); + mrb->cibase = (mrb_callinfo *)mrb_realloc(mrb, mrb->cibase, sizeof(mrb_callinfo)*size*2); mrb->ci = mrb->cibase + size; mrb->ciend = mrb->cibase + size * 2; } @@ -145,7 +145,7 @@ cipop(mrb_state *mrb) if (mrb->ci->env) { struct REnv *e = mrb->ci->env; int len = (int)e->flags; - mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len); + mrb_value *p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len); e->cioff = -1; memcpy(p, e->stack, sizeof(mrb_value)*len); @@ -395,7 +395,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) mrb_value *regs = NULL; mrb_code i; int ai = mrb->arena_idx; - jmp_buf *prev_jmp = mrb->jmp; + jmp_buf *prev_jmp = (jmp_buf *)mrb->jmp; jmp_buf c_jmp; #ifdef DIRECT_THREADED @@ -620,7 +620,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) if (mrb->rsize <= mrb->ci->ridx) { if (mrb->rsize == 0) mrb->rsize = 16; else mrb->rsize *= 2; - mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize); + mrb->rescue = (mrb_code **)mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize); } mrb->rescue[mrb->ci->ridx++] = pc + GETARG_sBx(i); NEXT; @@ -657,7 +657,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) if (mrb->esize <= mrb->ci->eidx) { if (mrb->esize == 0) mrb->esize = 16; else mrb->esize *= 2; - mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize); + mrb->ensure = (struct RProc **)mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize); } mrb->ensure[mrb->ci->eidx++] = p; NEXT; -- cgit v1.2.3 From bd035bcbb6b6ed79501b073111ca2c5ea8b29dee Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 30 Jul 2012 09:40:41 +0900 Subject: do not use INT32_MAX; close #407 --- src/string.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/string.c') diff --git a/src/string.c b/src/string.c index 0a5dee88e..aab8c9616 100644 --- a/src/string.c +++ b/src/string.c @@ -431,7 +431,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self) if (times < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument"); } - if (times && INT32_MAX/times < RSTRING_LEN(self)) { + if (times && INT_MAX/times < RSTRING_LEN(self)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big"); } -- cgit v1.2.3