From 49df2179578c34caefbe693a0eb74facb3ff9679 Mon Sep 17 00:00:00 2001 From: takahashim Date: Sat, 2 Jun 2012 01:14:45 +0900 Subject: use mrb_malloc instead of malloc --- src/struct.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index d06124b50..fbe018930 100644 --- a/src/struct.c +++ b/src/struct.c @@ -416,7 +416,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 = malloc(sizeof(mrb_value)*argc); + st->ptr = mrb_malloc(mrb, sizeof(mrb_value)*argc); st->len = n; memcpy(st->ptr, argv, sizeof(mrb_value)*argc); //if (n > argc) { -- cgit v1.2.3 From 34c049c63e4c4c011fe1cfcbe954f20438919439 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sat, 2 Jun 2012 21:34:10 +0900 Subject: remove unused mrb_mem_clear --- include/mruby/array.h | 1 - src/array.c | 8 -------- src/struct.c | 4 +--- 3 files changed, 1 insertion(+), 12 deletions(-) (limited to 'src/struct.c') diff --git a/include/mruby/array.h b/include/mruby/array.h index 192ad7c4c..21d50152f 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -43,7 +43,6 @@ mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item); mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts); mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr); mrb_value mrb_ary_entry(mrb_value ary, int offset); -void mrb_mem_clear(mrb_value *mem, int size); mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa); mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary); mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self); diff --git a/src/array.c b/src/array.c index 6d41c0c3c..ed207a2a2 100644 --- a/src/array.c +++ b/src/array.c @@ -769,14 +769,6 @@ mrb_ary_entry(mrb_value ary, int offset) return ary_elt(ary, offset); } -void -mrb_mem_clear(mrb_value *mem, int size) -{ - while (size--) { - *mem++ = mrb_nil_value(); - } -} - mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa) { diff --git a/src/struct.c b/src/struct.c index fbe018930..9f7010e0b 100644 --- a/src/struct.c +++ b/src/struct.c @@ -419,9 +419,7 @@ mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_val st->ptr = mrb_malloc(mrb, sizeof(mrb_value)*argc); st->len = n; memcpy(st->ptr, argv, sizeof(mrb_value)*argc); - //if (n > argc) { - // mrb_mem_clear(RSTRUCT_PTR(self)+argc, n-argc); - //} + return self; } -- cgit v1.2.3 From 80c8908c4e6672670a0fef426baa6e79d1dcd518 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 3 Jun 2012 17:59:59 +0900 Subject: remove mrb_exec_recursive --- src/range.c | 33 ++++++++++++--------------------- src/struct.c | 57 ++++++++++++++++++--------------------------------------- 2 files changed, 30 insertions(+), 60 deletions(-) (limited to 'src/struct.c') diff --git a/src/range.c b/src/range.c index c1fb580b5..b8b1d3926 100644 --- a/src/range.c +++ b/src/range.c @@ -29,9 +29,6 @@ #define RANGE_CLASS (mrb_class_obj_get(mrb, "Range")) -mrb_value mrb_exec_recursive_paired(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mrb_value, int), - mrb_value obj, mrb_value paired_obj, void* arg); - mrb_value mrb_range_new(mrb_state *mrb, mrb_value beg, mrb_value end, int excl) { @@ -397,23 +394,6 @@ range_inspect(mrb_state *mrb, mrb_value range) return inspect_range(mrb, range, range, 0); } -static mrb_value -recursive_eql(mrb_state *mrb, mrb_value range, mrb_value obj, int recur) -{ - struct RRange *r = mrb_range_ptr(range); - struct RRange *o = mrb_range_ptr(obj); - - if (recur) return mrb_true_value(); /* Subtle! */ - if (!mrb_eql(mrb, r->edges->beg, o->edges->beg)) - return mrb_false_value(); - if (!mrb_eql(mrb, r->edges->end, o->edges->end)) - return mrb_false_value(); - - if (r->excl != o->excl) - return mrb_false_value(); - return mrb_true_value(); -} - /* 15.2.14.4.14(x) */ /* * call-seq: @@ -433,13 +413,24 @@ static mrb_value range_eql(mrb_state *mrb, mrb_value range) { mrb_value obj; + struct RRange *r, *o; mrb_get_args(mrb, "o", &obj); if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value(); if (!mrb_obj_is_kind_of(mrb, obj, RANGE_CLASS)) return mrb_false_value(); - return mrb_exec_recursive_paired(mrb, recursive_eql, range, obj, &obj); + + r = mrb_range_ptr(range); + if (obj.tt != MRB_TT_RANGE) return mrb_false_value(); + o = mrb_range_ptr(obj); + if (!mrb_eql(mrb, r->edges->beg, o->edges->beg)) + return mrb_false_value(); + if (!mrb_eql(mrb, r->edges->end, o->edges->end)) + return mrb_false_value(); + if (r->excl != o->excl) + return mrb_false_value(); + return mrb_true_value(); } /* 15.2.14.4.15(x) */ diff --git a/src/struct.c b/src/struct.c index 9f7010e0b..e9266ad17 100644 --- a/src/struct.c +++ b/src/struct.c @@ -15,10 +15,6 @@ #ifdef INCLUDE_REGEXP #include "encoding.h" #endif -mrb_sym rb_frame_this_func(mrb_state *mrb); -mrb_sym mrb_frame_callee(mrb_state *mrb); -mrb_value mrb_exec_recursive_paired(mrb_state *mrb, mrb_value (*func) (mrb_state *, mrb_value, mrb_value, int), - mrb_value obj, mrb_value paired_obj, void* arg); #include "mruby/numeric.h" #include "mruby/hash.h" @@ -688,22 +684,6 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s) return RSTRUCT_PTR(s)[i] = val; } -static mrb_value -recursive_equal(mrb_state *mrb, mrb_value s, mrb_value s2, int recur) -{ - mrb_value *ptr, *ptr2; - long i, len; - - if (recur) return mrb_true_value(); /* Subtle! */ - ptr = RSTRUCT_PTR(s); - ptr2 = RSTRUCT_PTR(s2); - len = RSTRUCT_LEN(s); - for (i=0; i Date: Sun, 3 Jun 2012 23:05:31 +0900 Subject: make arrays to share bodies --- include/mruby/array.h | 14 ++- src/array.c | 231 ++++++++++++++++++++++++++++++++++---------------- src/gc.c | 5 +- src/struct.c | 2 +- 4 files changed, 175 insertions(+), 77 deletions(-) (limited to 'src/struct.c') diff --git a/include/mruby/array.h b/include/mruby/array.h index 21d50152f..c6c35a4e4 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -11,10 +11,19 @@ extern "C" { #endif +struct mrb_shared_array { + int refcnt; + mrb_value *buf; + int len; +}; + struct RArray { MRUBY_OBJECT_HEADER; int len; - int capa; + union { + int capa; + struct mrb_shared_array *shared; + } aux; mrb_value *buf; }; @@ -24,7 +33,9 @@ struct RArray { #define RARRAY_LEN(a) (RARRAY(a)->len) #define RARRAY_PTR(a) (RARRAY(a)->buf) +#define MRB_ARY_SHARED 256 +void mrb_ary_decref(mrb_state*, struct mrb_shared_array*); mrb_value mrb_ary_new_capa(mrb_state*, int); mrb_value mrb_ary_new(mrb_state *mrb); mrb_value mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts); @@ -43,7 +54,6 @@ mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item); mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts); mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr); mrb_value mrb_ary_entry(mrb_value ary, int offset); -mrb_value mrb_ary_tmp_new(mrb_state *mrb, int capa); mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary); mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self); diff --git a/src/array.c b/src/array.c index ed207a2a2..8f2e4824e 100644 --- a/src/array.c +++ b/src/array.c @@ -12,12 +12,12 @@ #define ARY_DEFAULT_LEN 4 #define ARY_SHRINK_RATIO 5 /* must be larger than 2 */ -#ifdef LONG_MAX -# define ARY_MAX_SIZE (LONG_MAX / sizeof(mrb_value)) +#ifdef INT_MAX +# define ARY_MAX_SIZE (INT_MAX / sizeof(mrb_value)) #endif static inline mrb_value -ary_elt(mrb_value ary, long offset) +ary_elt(mrb_value ary, int offset) { if (RARRAY_LEN(ary) == 0) return mrb_nil_value(); if (offset < 0 || RARRAY_LEN(ary) <= offset) { @@ -27,12 +27,12 @@ ary_elt(mrb_value ary, long offset) } static struct RArray* -ary_new_capa(mrb_state *mrb, size_t capa) +ary_new_capa(mrb_state *mrb, int capa) { struct RArray *a; - size_t blen; + int blen; -#ifdef LONG_MAX +#ifdef INT_MAX if (capa > ARY_MAX_SIZE) { mrb_raise(mrb, E_ARGUMENT_ERROR, "ary size too big"); } @@ -48,7 +48,7 @@ ary_new_capa(mrb_state *mrb, size_t capa) a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); a->buf = mrb_malloc(mrb, blen); memset(a->buf, 0, blen); - a->capa = capa; + a->aux.capa = capa; a->len = 0; return a; @@ -90,7 +90,7 @@ mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr) return mrb_ary_new_from_values(mrb, 2, arv); } -void +static void ary_fill_with_nil(mrb_value *buf, int size) { mrb_value nil = mrb_nil_value(); @@ -100,12 +100,60 @@ ary_fill_with_nil(mrb_value *buf, int size) } } -void -mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, int len) +static void +ary_modify(mrb_state *mrb, struct RArray *a) +{ + if (a->flags & MRB_ARY_SHARED) { + struct mrb_shared_array *shared = a->aux.shared; + + if (shared->refcnt == 1 && a->buf == shared->buf) { + a->buf = shared->buf; + a->aux.capa = a->len; + mrb_free(mrb, shared); + } + else { + mrb_value *ptr, *p; + int len; + + p = a->buf; + len = a->len * sizeof(mrb_value); + ptr = mrb_malloc(mrb, len); + if (p) { + memcpy(ptr, p, len); + } + a->buf = ptr; + a->aux.capa = len; + mrb_ary_decref(mrb, shared); + } + a->flags &= ~MRB_ARY_SHARED; + } +} + +static void +ary_make_shared(mrb_state *mrb, struct RArray *a) { - int capa = a->capa; + if (!(a->flags & MRB_ARY_SHARED)) { + struct mrb_shared_array *shared = mrb_malloc(mrb, sizeof(struct mrb_shared_array)); -#ifdef LONG_MAX + shared->refcnt = 1; + if (a->aux.capa > a->len) { + a->buf = shared->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*a->len+1); + } + else { + shared->buf = a->buf; + } + shared->len = a->len; + a->aux.shared = shared; + a->flags |= MRB_ARY_SHARED; + } +} + +static void +ary_expand_capa(mrb_state *mrb, struct RArray *a, int len) +{ + int capa = a->aux.capa; + +#ifdef INT_MAX if (len > ARY_MAX_SIZE) { mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); } @@ -120,20 +168,20 @@ mrb_ary_expand_capa(mrb_state *mrb, struct RArray *a, int len) } } -#ifdef LONG_MAX +#ifdef INT_MAX if (capa > ARY_MAX_SIZE) capa = ARY_MAX_SIZE; /* len <= capa <= ARY_MAX_SIZE */ #endif - if (capa > a->capa) { - a->capa = capa; + if (capa > a->aux.capa) { + a->aux.capa = capa; a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa); } } -void -mrb_ary_shrink_capa(mrb_state *mrb, struct RArray *a) +static void +ary_shrink_capa(mrb_state *mrb, struct RArray *a) { - int capa = a->capa; + int capa = a->aux.capa; if (capa < ARY_DEFAULT_LEN * 2) return; if (capa <= a->len * ARY_SHRINK_RATIO) return; @@ -146,8 +194,8 @@ mrb_ary_shrink_capa(mrb_state *mrb, struct RArray *a) } } while(capa > a->len * ARY_SHRINK_RATIO); - if (capa > a->len && capa < a->capa) { - a->capa = capa; + if (capa > a->len && capa < a->aux.capa) { + a->aux.capa = capa; a->buf = mrb_realloc(mrb, a->buf, sizeof(mrb_value)*capa); } } @@ -167,7 +215,8 @@ ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *buf, int blen) { int len = a->len + blen; - if (a->capa < len) mrb_ary_expand_capa(mrb, a, len); + ary_modify(mrb, a); + if (a->aux.capa < len) ary_expand_capa(mrb, a, len); memcpy(a->buf+a->len, buf, sizeof(mrb_value)*blen); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; @@ -235,7 +284,7 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1) mrb_value ary2; struct RArray *a1, *a2; mrb_value r = mrb_nil_value(); - long i, len; + int i, len; mrb_get_args(mrb, "o", &ary2); if (mrb_type(ary2) != MRB_TT_ARRAY) return mrb_nil_value(); @@ -258,7 +307,9 @@ mrb_ary_cmp(mrb_state *mrb, mrb_value ary1) static void ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, int len) { - if (a->capa < len) mrb_ary_expand_capa(mrb, a, len); + ary_modify(mrb, a); + if (a->aux.capa < len) + ary_expand_capa(mrb, a, len); memcpy(a->buf, argv, sizeof(mrb_value)*len); mrb_write_barrier(mrb, (struct RBasic*)a); a->len = len; @@ -377,21 +428,13 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) /* mrb_ary_push */ { struct RArray *a = mrb_ary_ptr(ary); - if (a->len == a->capa) mrb_ary_expand_capa(mrb, a, a->len + 1); + ary_modify(mrb, a); + if (a->len == a->aux.capa) + ary_expand_capa(mrb, a, a->len + 1); a->buf[a->len++] = elem; mrb_write_barrier(mrb, (struct RBasic*)a); } -mrb_value -mrb_ary_pop(mrb_state *mrb, mrb_value ary) -{ - struct RArray *a = mrb_ary_ptr(ary); - - if (a->len == 0) return mrb_nil_value(); - - return a->buf[--a->len]; -} - mrb_value mrb_ary_push_m(mrb_state *mrb, mrb_value self) { @@ -407,30 +450,45 @@ mrb_ary_push_m(mrb_state *mrb, mrb_value self) } mrb_value -mrb_ary_pop_m(mrb_state *mrb, mrb_value self) +mrb_ary_pop(mrb_state *mrb, mrb_value ary) { - struct RArray *a = mrb_ary_ptr(self); + struct RArray *a = mrb_ary_ptr(ary); - return ((a->len == 0)? mrb_nil_value(): mrb_ary_pop(mrb, self)); + if (a->len == 0) return mrb_nil_value(); + return a->buf[--a->len]; } +#define ARY_SHIFT_SHARED_MIN 10 + mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); - mrb_value *buf = a->buf; - int size = a->len; mrb_value val; - if (size == 0) return mrb_nil_value(); - - val = *buf; - while((int)(--size)) { - *buf = *(buf+1); - ++buf; + if (a->len == 0) return mrb_nil_value(); + if (a->flags & MRB_ARY_SHARED) { + L_SHIFT: + val = a->buf[0]; + a->buf++; + a->len--; + return val; } - --a->len; + if (a->len > ARY_SHIFT_SHARED_MIN) { + ary_make_shared(mrb, a); + goto L_SHIFT; + } + else { + mrb_value *buf = a->buf; + int size = a->len; + val = *buf; + while((int)(--size)) { + *buf = *(buf+1); + ++buf; + } + --a->len; + } return val; } @@ -443,7 +501,9 @@ mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item) { struct RArray *a = mrb_ary_ptr(self); - if (a->capa < a->len + 1) mrb_ary_expand_capa(mrb, a, a->len + 1); + ary_modify(mrb, a); + if (a->aux.capa < a->len + 1) + ary_expand_capa(mrb, a, a->len + 1); memmove(a->buf + 1, a->buf, sizeof(mrb_value)*a->len); memcpy(a->buf, &item, sizeof(mrb_value)); a->len += 1; @@ -459,9 +519,11 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self) mrb_value *vals; int len; + ary_modify(mrb, a); mrb_get_args(mrb, "*", &vals, &len); if (len == 0) return self; - if (a->capa < a->len + len) mrb_ary_expand_capa(mrb, a, a->len + len); + if (a->aux.capa < a->len + len) + ary_expand_capa(mrb, a, a->len + len); memmove(a->buf + len, a->buf, sizeof(mrb_value)*a->len); memcpy(a->buf, vals, sizeof(mrb_value)*len); a->len += len; @@ -487,13 +549,15 @@ mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) /* rb_ary_s { struct RArray *a = mrb_ary_ptr(ary); + ary_modify(mrb, a); /* range check */ if (n < 0) n += a->len; if (n < 0) { mrb_raise(mrb, E_INDEX_ERROR, "index %ld out of array", n - a->len); } if (a->len <= (int)n) { - if (a->capa <= (int)n) mrb_ary_expand_capa(mrb, a, n + 1); + if (a->aux.capa <= (int)n) + ary_expand_capa(mrb, a, n + 1); ary_fill_with_nil(a->buf + a->len, n + 1 - a->len); a->len = n + 1; } @@ -511,6 +575,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val mrb_value *argv; int i, argc; + ary_modify(mrb, a); /* range check */ if (head < 0) head += a->len; if (head < 0) { @@ -531,7 +596,8 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val if (tail < a->len) size += a->len - tail; - if (size > a->capa) mrb_ary_expand_capa(mrb, a, size); + if (size > a->aux.capa) + ary_expand_capa(mrb, a, size); if (head > a->len) { ary_fill_with_nil(a->buf + a->len, (int)(head - a->len)); @@ -555,6 +621,32 @@ mrb_ary_alen(mrb_state *mrb, mrb_value ary) return RARRAY_LEN(ary); } +void +mrb_ary_decref(mrb_state *mrb, struct mrb_shared_array *shared) +{ + shared->refcnt--; + if (shared->refcnt == 0) { + mrb_free(mrb, shared->buf); + mrb_free(mrb, shared); + } +} + +static mrb_value +ary_subseq(mrb_state *mrb, struct RArray *a, int beg, int len) +{ + struct RArray *b; + + ary_make_shared(mrb, a); + b = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class); + b->buf = a->buf + beg; + b->len = len; + b->aux.shared = a->aux.shared; + b->aux.shared->refcnt++; + b->flags |= MRB_ARY_SHARED; + + return mrb_obj_value(b); +} + mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self) { @@ -578,7 +670,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self) if ((len = mrb_fixnum(argv[0])) < 0) return mrb_nil_value(); if (a->len == (int)index) return mrb_ary_new(mrb); if ((int)len > a->len - index) len = a->len - index; - return mrb_ary_new_from_values(mrb, len, a->buf + index); + return ary_subseq(mrb, a, index, len); default: mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments"); @@ -639,7 +731,7 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self) } --a->len; - mrb_ary_shrink_capa(mrb, a); + ary_shrink_capa(mrb, a); return val; } @@ -649,19 +741,15 @@ mrb_ary_first(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self); int size; - mrb_value *vals; - int len; - mrb_get_args(mrb, "*", &vals, &len); - if (len > 1) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments"); + if (mrb_get_args(mrb, "|i", &size) == 0) { + return (a->len > 0)? a->buf[0]: mrb_nil_value(); } - if (len == 0) return (a->len > 0)? a->buf[0]: mrb_nil_value(); - - /* len == 1 */ - size = mrb_fixnum(*vals); if (size > a->len) size = a->len; + if (a->flags & MRB_ARY_SHARED) { + return ary_subseq(mrb, a, 0, size); + } return mrb_ary_new_from_values(mrb, size, a->buf); } @@ -683,6 +771,9 @@ mrb_ary_last(mrb_state *mrb, mrb_value self) /* len == 1 */ size = mrb_fixnum(*vals); if (size > a->len) size = a->len; + if ((a->flags & MRB_ARY_SHARED) || size > ARY_DEFAULT_LEN) { + return ary_subseq(mrb, a, a->len - size, size); + } return mrb_ary_new_from_values(mrb, size, a->buf + a->len - size); } @@ -690,7 +781,7 @@ mrb_value mrb_ary_index_m(mrb_state *mrb, mrb_value self) { mrb_value obj; - long i; + int i; mrb_get_args(mrb, "o", &obj); for (i = 0; i < RARRAY_LEN(self); i++) { @@ -705,7 +796,7 @@ mrb_value mrb_ary_rindex_m(mrb_state *mrb, mrb_value self) { mrb_value obj; - long i; + int i; mrb_get_args(mrb, "o", &obj); for (i = RARRAY_LEN(self) - 1; i >= 0; i--) { @@ -741,7 +832,7 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self) struct RArray *a = mrb_ary_ptr(self); a->len = 0; - mrb_ary_shrink_capa(mrb, a); + ary_shrink_capa(mrb, a); return self; } @@ -769,12 +860,6 @@ mrb_ary_entry(mrb_value ary, int offset) return ary_elt(ary, offset); } -mrb_value -mrb_ary_tmp_new(mrb_state *mrb, int capa) -{ - return mrb_ary_new_capa(mrb, capa); -} - static mrb_value inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list) { @@ -1013,13 +1098,13 @@ mrb_init_array(mrb_state *mrb) mrb_define_method(mrb, a, "concat", mrb_ary_concat_m, ARGS_REQ(1)); /* 15.2.12.5.8 */ mrb_define_method(mrb, a, "delete_at", mrb_ary_delete_at, ARGS_REQ(1)); /* 15.2.12.5.9 */ mrb_define_method(mrb, a, "empty?", mrb_ary_empty_p, ARGS_NONE()); /* 15.2.12.5.12 */ - mrb_define_method(mrb, a, "first", mrb_ary_first, ARGS_ANY()); /* 15.2.12.5.13 */ + mrb_define_method(mrb, a, "first", mrb_ary_first, ARGS_OPT(1)); /* 15.2.12.5.13 */ mrb_define_method(mrb, a, "index", mrb_ary_index_m, ARGS_REQ(1)); /* 15.2.12.5.14 */ mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.16 */ mrb_define_method(mrb, a, "join", mrb_ary_join_m, ARGS_ANY()); /* 15.2.12.5.17 */ mrb_define_method(mrb, a, "last", mrb_ary_last, ARGS_ANY()); /* 15.2.12.5.18 */ mrb_define_method(mrb, a, "length", mrb_ary_size, ARGS_NONE()); /* 15.2.12.5.19 */ - mrb_define_method(mrb, a, "pop", mrb_ary_pop_m, ARGS_NONE()); /* 15.2.12.5.21 */ + mrb_define_method(mrb, a, "pop", mrb_ary_pop, ARGS_NONE()); /* 15.2.12.5.21 */ mrb_define_method(mrb, a, "push", mrb_ary_push_m, ARGS_ANY()); /* 15.2.12.5.22 */ mrb_define_method(mrb, a, "replace", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.23 */ mrb_define_method(mrb, a, "reverse", mrb_ary_reverse, ARGS_NONE()); /* 15.2.12.5.24 */ @@ -1034,5 +1119,5 @@ mrb_init_array(mrb_state *mrb) mrb_define_alias(mrb, a, "to_s", "inspect"); /* 15.2.12.5.32 (x) */ mrb_define_method(mrb, a, "==", mrb_ary_equal, ARGS_REQ(1)); /* 15.2.12.5.33 (x) */ mrb_define_method(mrb, a, "eql?", mrb_ary_eql, ARGS_REQ(1)); /* 15.2.12.5.34 (x) */ - mrb_define_method(mrb, a, "<=>", mrb_ary_cmp, ARGS_REQ(1)); /* 15.2.12.5.36 (x) */ + mrb_define_method(mrb, a, "<=>", mrb_ary_cmp, ARGS_REQ(1)); /* 15.2.12.5.36 (x) */ } diff --git a/src/gc.c b/src/gc.c index b269ecfb4..b7c08de65 100644 --- a/src/gc.c +++ b/src/gc.c @@ -457,7 +457,10 @@ obj_free(mrb_state *mrb, struct RBasic *obj) break; case MRB_TT_ARRAY: - mrb_free(mrb, ((struct RArray*)obj)->buf); + if (obj->flags & MRB_ARY_SHARED) + mrb_ary_decref(mrb, ((struct RArray*)obj)->aux.shared); + else + mrb_free(mrb, ((struct RArray*)obj)->buf); break; case MRB_TT_HASH: diff --git a/src/struct.c b/src/struct.c index e9266ad17..2e2e0c10f 100644 --- a/src/struct.c +++ b/src/struct.c @@ -450,7 +450,7 @@ mrb_struct_new(mrb_state *mrb, struct RClass *klass, ...) size = mrb_long2int(num_members(mrb, klass)); if (size > numberof(tmpargs)) { - tmpargs[0] = mrb_ary_tmp_new(mrb, size); + tmpargs[0] = mrb_ary_new_capa(mrb, size); mem = RARRAY_PTR(tmpargs[0]); } va_start(args, klass); -- 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/struct.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 62fdd43d6599fc1c54c869aae075f1bb153314d6 Mon Sep 17 00:00:00 2001 From: Junji Sawada Date: Sun, 17 Jun 2012 21:35:32 +0900 Subject: RStruct.ptr must allocate members size --- src/struct.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index 5d759776f..8e9804cbc 100644 --- a/src/struct.c +++ b/src/struct.c @@ -412,7 +412,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_malloc(mrb, sizeof(mrb_value)*argc); + st->ptr = mrb_calloc(mrb, sizeof(mrb_value), n); st->len = n; memcpy(st->ptr, argv, sizeof(mrb_value)*argc); -- cgit v1.2.3 From ede3049f33f8c6cdb703784619fb4143bfe3b441 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 17 Jun 2012 23:36:34 +0900 Subject: allow disabling Struct class --- include/mrbconf.h | 4 ++++ src/init.c | 2 ++ src/struct.c | 2 ++ 3 files changed, 8 insertions(+) (limited to 'src/struct.c') diff --git a/include/mrbconf.h b/include/mrbconf.h index 4b778e6de..21b8fea18 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -18,6 +18,7 @@ #undef DISABLE_KERNEL_SPRINTF /* Kernel.sprintf method */ #undef DISABLE_MATH /* Math functions */ #undef DISABLE_TIME /* Time class */ +#undef DISABLE_STRUCT /* Struct class */ #undef HAVE_UNISTD_H /* WINDOWS */ #define HAVE_UNISTD_H /* LINUX */ @@ -46,6 +47,9 @@ typedef intptr_t mrb_sym; #ifndef DISABLE_TIME #define ENABLE_TIME #endif +#ifndef DISABLE_STRUCT +#define ENABLE_STRUCT +#endif #ifndef FALSE # define FALSE 0 diff --git a/src/init.c b/src/init.c index a515ee880..e2ab62339 100644 --- a/src/init.c +++ b/src/init.c @@ -49,7 +49,9 @@ mrb_init_core(mrb_state *mrb) mrb_init_hash(mrb); mrb_init_numeric(mrb); mrb_init_range(mrb); +#ifdef ENABLE_STRUCT mrb_init_struct(mrb); +#endif mrb_init_gc(mrb); #ifdef ENABLE_REGEXP mrb_init_regexp(mrb); diff --git a/src/struct.c b/src/struct.c index 8e9804cbc..c0af85d0e 100644 --- a/src/struct.c +++ b/src/struct.c @@ -5,6 +5,7 @@ */ #include "mruby.h" +#ifdef ENABLE_STRUCT #include #include "error.h" #include "mruby/struct.h" @@ -793,3 +794,4 @@ mrb_init_struct(mrb_state *mrb) mrb_define_method(mrb, st, "eql?", mrb_struct_eql, ARGS_REQ(1)); /* 15.2.18.4.12(x) */ } +#endif /* ENABLE_STRUCT */ -- cgit v1.2.3 From 4f4965a4a20b1fba002d7b428508632604fd0b38 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Mon, 18 Jun 2012 08:58:56 +0900 Subject: allow struct access; close #295 --- src/struct.c | 58 ++++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 38 insertions(+), 20 deletions(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index c0af85d0e..4d59be22d 100644 --- a/src/struct.c +++ b/src/struct.c @@ -183,33 +183,51 @@ mrb_struct_modify(mrb_value s) } mrb_sym -mrb_id_attrset(mrb_sym id) +mrb_id_attrset(mrb_state *mrb, mrb_sym id) { - //id &= ~ID_SCOPE_MASK; - //id |= ID_ATTRSET; - return id; + const char *name; + char *buf; + int len; + mrb_sym mid; + + name = mrb_sym2name_len(mrb, id, &len); + buf = mrb_malloc(mrb, len+2); + memcpy(buf, name, len); + buf[len] = '='; + buf[len+1] = '\0'; + + mid = mrb_intern2(mrb, buf, len+1); + mrb_free(mrb, buf); + return mid; } static mrb_value mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val) { - mrb_value members, slot, *ptr, *ptr_members; - long i, len; + const char *name; + int i, len; + mrb_sym mid; + mrb_value members, slot, *ptr, *ptr_members; - members = mrb_struct_members(mrb, obj); - ptr_members = RARRAY_PTR(members); - len = RARRAY_LEN(members); - mrb_struct_modify(obj); - ptr = RSTRUCT_PTR(obj); - for (i=0; ici->mid, &len); + mid = mrb_intern2(mrb, name, len-1); /* omit last "=" */ + + members = mrb_struct_members(mrb, obj); + ptr_members = RARRAY_PTR(members); + len = RARRAY_LEN(members); + mrb_struct_modify(obj); + ptr = RSTRUCT_PTR(obj); + for (i=0; itLAST_TOKEN) @@ -275,7 +293,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k else { mrb_define_method_id(mrb, c, id, mrb_struct_ref, 0); } - mrb_define_method_id(mrb, c, mrb_id_attrset(id), (mrb_func_t)mrb_struct_set, 1); + mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), (mrb_func_t)mrb_struct_set, 1); } } -- cgit v1.2.3 From f443a719a1cd86790ac823b519f51784e1ddeb22 Mon Sep 17 00:00:00 2001 From: Junji Sawada Date: Mon, 18 Jun 2012 22:20:28 +0900 Subject: Fix member access method definition --- src/struct.c | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index 4d59be22d..de0dbeeaa 100644 --- a/src/struct.c +++ b/src/struct.c @@ -131,7 +131,7 @@ mrb_struct_getmember(mrb_state *mrb, mrb_value obj, mrb_sym id) ptr = RSTRUCT_PTR(obj); members = mrb_struct_members(mrb, obj); ptr_members = RARRAY_PTR(members); - slot = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id)); + slot = mrb_symbol_value(id); len = RARRAY_LEN(members); for (i=0; ici->mid); } static mrb_value mrb_struct_ref0(mrb_state* mrb, mrb_value obj) {return RSTRUCT_PTR(obj)[0];} @@ -230,6 +229,15 @@ mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val) return mrb_nil_value(); /* not reached */ } +static mrb_value +mrb_struct_set_m(mrb_state *mrb, mrb_value obj) +{ + mrb_value val; + + mrb_get_args(mrb, "o", &val); + return mrb_struct_set(mrb, obj, val); +} + #define is_notop_id(id) (id)//((id)>tLAST_TOKEN) #define is_local_id(id) (is_notop_id(id))//&&((id)&ID_SCOPE_MASK)==ID_LOCAL) int @@ -288,12 +296,12 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k mrb_sym id = SYM2ID(ptr_members[i]); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { if (i < N_REF_FUNC) { - mrb_define_method_id(mrb, c, id, (mrb_func_t)ref_func[i], 0); + mrb_define_method_id(mrb, c, id, ref_func[i], ARGS_NONE()); } else { - mrb_define_method_id(mrb, c, id, mrb_struct_ref, 0); + mrb_define_method_id(mrb, c, id, mrb_struct_ref, ARGS_NONE()); } - mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), (mrb_func_t)mrb_struct_set, 1); + mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, ARGS_REQ(1)); } } @@ -314,7 +322,7 @@ mrb_struct_define(mrb_state *mrb, const char *name, ...) va_start(ar, name); while ((mem = va_arg(ar, char*)) != 0) { mrb_sym slot = mrb_intern(mrb, mem); - mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, slot))); + mrb_ary_push(mrb, ary, mrb_symbol_value(slot)); } va_end(ar); @@ -379,10 +387,6 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); } - for (i=0; i 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/struct.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 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/struct.c') diff --git a/src/class.c b/src/class.c index 56ab8c06f..a9bf54a3b 100644 --- a/src/class.c +++ b/src/class.c @@ -972,15 +972,23 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) struct RClass *outer = mrb_class_outer_module(mrb, c); mrb_sym sym = class_sym(mrb, c, outer); if (outer && outer != mrb->object_class) { + char *name; + int len; + mrb_value base = mrb_class_path(mrb, outer); - path = mrb_str_plus(mrb, base, mrb_str_new_cstr(mrb, "::")); - mrb_str_concat(mrb, path, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym))); + path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2)); + name = mrb_sym2name_len(mrb, sym, &len); + mrb_str_concat(mrb, path, mrb_str_new(mrb, name, len)); } else if (sym == 0) { return mrb_nil_value(); } else { - path = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym)); + char *name; + int len; + + name = mrb_sym2name_len(mrb, sym, &len); + path = mrb_str_new(mrb, name, len); } mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"), path); } @@ -1114,9 +1122,8 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const static mrb_value mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { - //if (FL_TEST(klass, FL_SINGLETON)) { if (mrb_type(klass) == MRB_TT_SCLASS) { - mrb_value s = mrb_str_new_cstr(mrb, "#<"); + mrb_value s = mrb_str_new(mrb, "#<", 2); mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__")); mrb_str_cat2(mrb, s, "Class:"); diff --git a/src/codegen.c b/src/codegen.c index 72fc1097d..cbf401a1f 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -1534,10 +1534,11 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_BACK_REF: { char buf[4]; + int len; int sym; - snprintf(buf, 3, "$%c", (int)(intptr_t)tree); - sym = new_sym(s, mrb_intern(s->mrb, buf)); + len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree); + sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); } @@ -1546,10 +1547,11 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_NTH_REF: { char buf[4]; + int len; int sym; - snprintf(buf, 3, "$%d", (int)(intptr_t)tree); - sym = new_sym(s, mrb_intern(s->mrb, buf)); + len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree); + sym = new_sym(s, mrb_intern2(s->mrb, buf, len)); genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym)); push(); } diff --git a/src/hash.c b/src/hash.c index 0e06cd246..a87ca97d4 100644 --- a/src/hash.c +++ b/src/hash.c @@ -889,9 +889,9 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur) khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; - if (recur) return mrb_str_new_cstr(mrb, "{...}"); + if (recur) return mrb_str_new(mrb, "{...}", 5); - str = mrb_str_new_cstr(mrb, "{"); + str = mrb_str_new(mrb, "{", 1); if (h && kh_size(h) > 0) { for (k = kh_begin(h); k != kh_end(h); k++) { int ai; @@ -934,7 +934,7 @@ mrb_hash_inspect(mrb_state *mrb, mrb_value hash) khash_t(ht) *h = RHASH_TBL(hash); if (!h || kh_size(h) == 0) - return mrb_str_new_cstr(mrb, "{}"); + return mrb_str_new(mrb, "{}", 2); return inspect_hash(mrb, hash, 0); } diff --git a/src/kernel.c b/src/kernel.c index 8f2b15378..8da112ee5 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -117,7 +117,7 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj) return mrb_any_to_s(mrb, obj); } else if (mrb_nil_p(obj)) { - return mrb_str_new_cstr(mrb, "nil"); + return mrb_str_new(mrb, "nil", 3); } return mrb_funcall(mrb, obj, "to_s", 0, 0); } diff --git a/src/object.c b/src/object.c index a30e7c58a..eb63c1293 100644 --- a/src/object.c +++ b/src/object.c @@ -151,7 +151,7 @@ true_xor(mrb_state *mrb, mrb_value obj) static mrb_value true_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_cstr(mrb, "true"); + return mrb_str_new(mrb, "true", 4); } /* 15.2.5.3.4 */ @@ -264,7 +264,7 @@ false_or(mrb_state *mrb, mrb_value obj) static mrb_value false_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_cstr(mrb, "false"); + return mrb_str_new(mrb, "false", 5); } void @@ -462,9 +462,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj) len = strlen(cname)+6+16; str = mrb_str_new(mrb, 0, len); /* 6:tags 16:addr */ s = mrb_str_ptr(str); - // snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj); - sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); - s->len = strlen(s->ptr); + s->len = sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p)); return str; } diff --git a/src/re.c b/src/re.c index 12061eacf..a7552de11 100644 --- a/src/re.c +++ b/src/re.c @@ -354,10 +354,10 @@ mrb_reg_options(mrb_state *mrb, mrb_value re) static mrb_value mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re) { - mrb_value str = mrb_str_new_cstr(mrb, "/");//mrb_str_buf_new2("/"); + mrb_value str = mrb_str_new(mrb, "/", 1); mrb_reg_expr_str(mrb, str, s, len); - mrb_str_buf_cat(mrb, str, "/", sizeof("/")); + mrb_str_buf_cat(mrb, str, "/", 1); if (re.tt) { char opts[4]; mrb_reg_check(mrb, re); @@ -1688,9 +1688,10 @@ mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len) } else if (!ISSPACE(c)) { char b[8]; + int n; - snprintf(b, sizeof(b), "\\x%02X", c); - mrb_str_buf_cat(mrb, str, b, 4); + n = snprintf(b, sizeof(b), "\\x%02X", c); + mrb_str_buf_cat(mrb, str, b, n); } else { mrb_str_buf_cat(mrb, str, p, 1); @@ -1728,7 +1729,7 @@ mrb_reg_to_s(mrb_state *mrb, mrb_value re) const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND; long len; const UChar* ptr; - mrb_value str = mrb_str_new_cstr(mrb, "(?"); + mrb_value str = mrb_str_new(mrb, "(?", 2); char optbuf[5]; mrb_encoding *enc = mrb_enc_get(mrb, re); @@ -1918,7 +1919,7 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match) onig_foreach_name(regexp->ptr, match_inspect_name_iter, names); - str = mrb_str_new_cstr(mrb, "#<");//mrb_str_buf_new2("#<"); + str = mrb_str_new(mrb, "#<", 2); mrb_str_buf_cat(mrb, str, cname, strlen(cname)); for (i = 0; i < num_regs; i++) { diff --git a/src/sprintf.c b/src/sprintf.c index e01bf572e..56141e482 100644 --- a/src/sprintf.c +++ b/src/sprintf.c @@ -1061,6 +1061,8 @@ static void fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) { char *end = buf + size; + int n; + *buf++ = '%'; if (flags & FSHARP) *buf++ = '#'; if (flags & FPLUS) *buf++ = '+'; @@ -1069,13 +1071,13 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) if (flags & FSPACE) *buf++ = ' '; if (flags & FWIDTH) { - snprintf(buf, end - buf, "%d", width); - buf += strlen(buf); + n = snprintf(buf, end - buf, "%d", width); + buf += n; } if (flags & FPREC) { - snprintf(buf, end - buf, ".%d", prec); - buf += strlen(buf); + n = snprintf(buf, end - buf, ".%d", prec); + buf += n; } *buf++ = c; diff --git a/src/string.c b/src/string.c index a943512c7..1ef0cdc33 100644 --- a/src/string.c +++ b/src/string.c @@ -2517,6 +2517,7 @@ bad: printf("Integer"); return mrb_fixnum_value(0); } + char * mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr) { @@ -2535,10 +2536,8 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck) char *s; int len; - //StringValue(str); mrb_string_value(mrb, &str); if (badcheck) { - //s = StringValueCStr(str); s = mrb_string_value_cstr(mrb, &str); } else { @@ -2949,7 +2948,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) { const char *p, *pend; char buf[CHAR_ESC_LEN + 1]; - mrb_value result = mrb_str_new_cstr(mrb, "\""); + mrb_value result = mrb_str_new(mrb, "\"", 1); p = RSTRING_PTR(str); pend = RSTRING_END(str); for (;p < pend; p++) { diff --git a/src/struct.c b/src/struct.c index 7e422f140..60a0edb5b 100644 --- a/src/struct.c +++ b/src/struct.c @@ -521,8 +521,11 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur) slot = ptr_members[i]; id = SYM2ID(slot); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { - //mrb_str_append(str, mrb_id2str(id)); - mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id))); + char *name; + int len; + + name = mrb_sym2name_len(mrb, id, &len); + mrb_str_append(mrb, str, mrb_str_new(mrb, name, len)); } else { mrb_str_append(mrb, str, mrb_inspect(mrb, slot)); @@ -804,9 +807,7 @@ mrb_init_struct(mrb_state *mrb) { struct RClass *st; st = mrb_define_class(mrb, "Struct", mrb->object_class); - //mrb_include_module(mrb_cStruct, rb_mEnumerable); - //mrb_undef_alloc_func(mrb_cStruct); mrb_define_class_method(mrb, st, "new", mrb_struct_s_def, ARGS_ANY()); /* 15.2.18.3.1 */ mrb_define_method(mrb, st, "==", mrb_struct_equal, ARGS_REQ(1)); /* 15.2.18.4.1 */ diff --git a/src/time.c b/src/time.c index 55060729b..28cc3c1a3 100644 --- a/src/time.c +++ b/src/time.c @@ -430,16 +430,17 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self) struct mrb_time *tm; struct tm *d; char buf[256]; + int len; tm = mrb_get_datatype(mrb, self, &mrb_time_type); if (!tm) return mrb_nil_value(); d = &tm->datetime; - snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d", - wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, - d->tm_hour, d->tm_min, d->tm_sec, - tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "", - d->tm_year + 1900); - return mrb_str_new_cstr(mrb, buf); + len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d", + wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, + d->tm_hour, d->tm_min, d->tm_sec, + tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "", + d->tm_year + 1900); + return mrb_str_new(mrb, buf, len); } /* 15.2.19.7.6 */ diff --git a/src/vm.c b/src/vm.c index 04392891f..daba0acc6 100644 --- a/src/vm.c +++ b/src/vm.c @@ -292,10 +292,11 @@ static void localjump_error(mrb_state *mrb, const char *kind) { char buf[256]; + int len; mrb_value exc; - snprintf(buf, 256, "unexpected %s", kind); - exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, strlen(buf)); + len = snprintf(buf, 256, "unexpected %s", kind); + exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len); mrb->exc = (struct RObject*)mrb_object(exc); } @@ -303,18 +304,19 @@ static void argnum_error(mrb_state *mrb, int num) { char buf[256]; + int len; mrb_value exc; if (mrb->ci->mid) { - snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)", - mrb_sym2name(mrb, mrb->ci->mid), - mrb->ci->argc, num); + len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)", + mrb_sym2name(mrb, mrb->ci->mid), + mrb->ci->argc, num); } else { - snprintf(buf, 256, "wrong number of arguments (%d for %d)", - mrb->ci->argc, num); + len = snprintf(buf, 256, "wrong number of arguments (%d for %d)", + mrb->ci->argc, num); } - exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, strlen(buf)); + exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len); mrb->exc = (struct RObject*)mrb_object(exc); } -- cgit v1.2.3 From d657e26d35ef31314a97d42bacc3e5dc85689404 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Sun, 24 Jun 2012 01:12:05 +0900 Subject: pacify const assignment warning --- src/class.c | 8 ++------ src/struct.c | 2 +- 2 files changed, 3 insertions(+), 7 deletions(-) (limited to 'src/struct.c') diff --git a/src/class.c b/src/class.c index a9bf54a3b..881a0072e 100644 --- a/src/class.c +++ b/src/class.c @@ -966,15 +966,14 @@ mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c) { mrb_value path; + const char *name; + int len; path = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__")); if (mrb_nil_p(path)) { struct RClass *outer = mrb_class_outer_module(mrb, c); mrb_sym sym = class_sym(mrb, c, outer); if (outer && outer != mrb->object_class) { - char *name; - int len; - mrb_value base = mrb_class_path(mrb, outer); path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2)); name = mrb_sym2name_len(mrb, sym, &len); @@ -984,9 +983,6 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) return mrb_nil_value(); } else { - char *name; - int len; - name = mrb_sym2name_len(mrb, sym, &len); path = mrb_str_new(mrb, name, len); } diff --git a/src/struct.c b/src/struct.c index 60a0edb5b..855974182 100644 --- a/src/struct.c +++ b/src/struct.c @@ -521,7 +521,7 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur) slot = ptr_members[i]; id = SYM2ID(slot); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { - char *name; + const char *name; int len; name = mrb_sym2name_len(mrb, id, &len); -- cgit v1.2.3 From 7a17377c644d421fae71bd8d61e6f7dc744faf62 Mon Sep 17 00:00:00 2001 From: Masamitsu MURASE Date: Sun, 24 Jun 2012 04:06:53 +0900 Subject: Fix Struct.new and Struct.[]. Instances of Struct's subclass should have MRB_TT_STRUCT. --- src/struct.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index 855974182..25cd02d3d 100644 --- a/src/struct.c +++ b/src/struct.c @@ -286,8 +286,8 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k nstr = mrb_obj_value(c); mrb_iv_set(mrb, nstr, mrb_intern(mrb, "__members__"), members); - mrb_define_class_method(mrb, c, "new", mrb_class_new_instance_m, ARGS_ANY()); - mrb_define_class_method(mrb, c, "[]", mrb_class_new_instance_m, ARGS_ANY()); + mrb_define_class_method(mrb, c, "new", mrb_instance_new, ARGS_ANY()); + mrb_define_class_method(mrb, c, "[]", mrb_instance_new, ARGS_ANY()); mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, ARGS_NONE()); //RSTRUCT(nstr)->basic.c->super = c->c; ptr_members = RARRAY_PTR(members); -- 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/struct.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/struct.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/struct.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 6f6e18ef825fbae10410c4c84460773e745ae056 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 2 Aug 2012 22:17:27 +0900 Subject: struct.c refactoring --- src/struct.c | 35 ++++------------------------------- 1 file changed, 4 insertions(+), 31 deletions(-) (limited to 'src/struct.c') diff --git a/src/struct.c b/src/struct.c index a133dc046..beb7c2f46 100644 --- a/src/struct.c +++ b/src/struct.c @@ -367,7 +367,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) name = mrb_nil_value(); rest = mrb_nil_value(); - mrb_get_args(mrb, "&*", &b, &argv, &argc); + mrb_get_args(mrb, "*&", &argv, &argc, &b); if (argc > 0) name = argv[0]; if (argc > 1) rest = argv[1]; if (mrb_type(rest) == MRB_TT_ARRAY) { @@ -400,7 +400,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) return st; } -static long +static int num_members(mrb_state *mrb, struct RClass *klass) { mrb_value members; @@ -418,7 +418,7 @@ static mrb_value mrb_struct_initialize_withArg(mrb_state *mrb, int argc, mrb_value *argv, mrb_value self) { struct RClass *klass = mrb_obj_class(mrb, self); - long n; + int n; struct RStruct *st; mrb_struct_modify(self); @@ -447,34 +447,7 @@ mrb_struct_initialize_m(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value mrb_value mrb_struct_initialize(mrb_state *mrb, mrb_value self, mrb_value values) { - return mrb_struct_initialize_withArg(mrb, RARRAY_LEN/*INT*/(values), RARRAY_PTR(values), self); -} - -mrb_value -mrb_struct_alloc(mrb_state *mrb, mrb_value klass, mrb_value values) -{ - return mrb_class_new_instance(mrb, RARRAY_LEN(values), RARRAY_PTR(values), mrb_class(mrb, klass)); -} - -mrb_value -mrb_struct_new(mrb_state *mrb, struct RClass *klass, ...) -{ - mrb_value tmpargs[N_REF_FUNC], *mem = tmpargs; - int size, i; - va_list args; - - size = mrb_long2int(num_members(mrb, klass)); - if (size > numberof(tmpargs)) { - tmpargs[0] = mrb_ary_new_capa(mrb, size); - mem = RARRAY_PTR(tmpargs[0]); - } - va_start(args, klass); - for (i=0; i