From ad6c58972cefd5c0193b0693ceab83f5bc2e23fa Mon Sep 17 00:00:00 2001 From: KOBAYASHI Shuji Date: Thu, 31 Oct 2019 22:04:56 +0900 Subject: Set `MRB_STR_ASCII` flag to some stringize methods - `Fixnum#to_s`, `Fixnum#inspect` - `Float#to_s`, `Float#inspect` - `NilClass#to_s`, `NilClass#inspect` - `FalseClass#to_s`, `FalseClass#inspect` - `TrueClass#to_s`, `TrueClass#inspect` - `Time#to_s`, `Time#inspect` --- src/numeric.c | 27 +++++++++++++++++++-------- src/object.c | 16 ++++++++++++---- 2 files changed, 31 insertions(+), 12 deletions(-) (limited to 'src') diff --git a/src/numeric.c b/src/numeric.c index 60925841f..306b6ef4d 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -210,26 +210,30 @@ static mrb_value flo_to_s(mrb_state *mrb, mrb_value flt) { mrb_float f = mrb_float(flt); + mrb_value str; if (isinf(f)) { - return f < 0 ? mrb_str_new_lit(mrb, "-Infinity") - : mrb_str_new_lit(mrb, "Infinity"); + str = f < 0 ? mrb_str_new_lit(mrb, "-Infinity") + : mrb_str_new_lit(mrb, "Infinity"); + goto exit; } else if (isnan(f)) { - return mrb_str_new_lit(mrb, "NaN"); + str = mrb_str_new_lit(mrb, "NaN"); + goto exit; } else { char fmt[] = "%." MRB_STRINGIZE(FLO_TO_STR_PREC) "g"; - mrb_value str = mrb_float_to_str(mrb, flt, fmt); mrb_int len; char *begp, *p, *endp; + str = mrb_float_to_str(mrb, flt, fmt); + insert_dot_zero: begp = RSTRING_PTR(str); len = RSTRING_LEN(str); for (p = begp, endp = p + len; p < endp; ++p) { if (*p == '.') { - return str; + goto exit; } else if (*p == 'e') { ptrdiff_t e_pos = p - begp; @@ -237,7 +241,7 @@ flo_to_s(mrb_state *mrb, mrb_value flt) p = RSTRING_PTR(str) + e_pos; memmove(p + 2, p, len - e_pos); memcpy(p, ".0", 2); - return str; + goto exit; } } @@ -247,8 +251,12 @@ flo_to_s(mrb_state *mrb, mrb_value flt) goto insert_dot_zero; } - return str; + goto exit; } + + exit: + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } /* 15.2.9.3.2 */ @@ -1383,6 +1391,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) char buf[MRB_INT_BIT+1]; char *b = buf + sizeof buf; mrb_int val = mrb_fixnum(x); + mrb_value str; if (base < 2 || 36 < base) { mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base); @@ -1403,7 +1412,9 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) } while (val /= base); } - return mrb_str_new(mrb, b, buf + sizeof(buf) - b); + str = mrb_str_new(mrb, b, buf + sizeof(buf) - b); + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } /* 15.2.8.3.25 */ diff --git a/src/object.c b/src/object.c index 33d570331..8de42a641 100644 --- a/src/object.c +++ b/src/object.c @@ -83,13 +83,17 @@ mrb_true(mrb_state *mrb, mrb_value obj) static mrb_value nil_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_frozen(mrb, 0, 0); + mrb_value str = mrb_str_new_frozen(mrb, 0, 0); + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } static mrb_value nil_inspect(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_lit_frozen(mrb, "nil"); + mrb_value str = mrb_str_new_lit_frozen(mrb, "nil"); + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } /*********************************************************************** @@ -150,7 +154,9 @@ true_xor(mrb_state *mrb, mrb_value obj) static mrb_value true_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_lit_frozen(mrb, "true"); + mrb_value str = mrb_str_new_lit_frozen(mrb, "true"); + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } /* 15.2.5.3.4 */ @@ -257,7 +263,9 @@ false_or(mrb_state *mrb, mrb_value obj) static mrb_value false_to_s(mrb_state *mrb, mrb_value obj) { - return mrb_str_new_lit_frozen(mrb, "false"); + mrb_value str = mrb_str_new_lit_frozen(mrb, "false"); + RSTR_SET_ASCII_FLAG(mrb_str_ptr(str)); + return str; } void -- cgit v1.2.3 From ccd84851117dbd9da97845fa6accc7102e8a2b04 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 11 Apr 2020 21:18:57 +0900 Subject: Add missing `MRB_API` --- src/fmt_fp.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/fmt_fp.c b/src/fmt_fp.c index b77abe7b5..558976e63 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -359,7 +359,7 @@ fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) } } -mrb_value +MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) { struct fmt_args f; @@ -375,7 +375,7 @@ mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) #include #include -mrb_value +MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) { char buf[25]; -- cgit v1.2.3 From 8ce3664305cdd585a0c961f9146aa58c37806a70 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 11 Apr 2020 20:28:59 +0900 Subject: Supports width specifier with `mrb_float_to_str()` Based on src/stdio/vfprintf.c in git://git.musl-libc.org/musl --- src/fmt_fp.c | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 558976e63..8b1b01559 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -92,7 +92,7 @@ typedef char compiler_defines_long_double_incorrectly[9-(int)sizeof(long double) #endif static int -fmt_fp(struct fmt_args *f, long double y, ptrdiff_t p, uint8_t fl, int t) +fmt_fp(struct fmt_args *f, long double y, ptrdiff_t w, ptrdiff_t p, uint8_t fl, int t) { uint32_t big[(LDBL_MANT_DIG+28)/29 + 1 // mantissa expansion + (LDBL_MAX_EXP+LDBL_MANT_DIG+28+8)/9]; // exponent expansion @@ -117,11 +117,11 @@ fmt_fp(struct fmt_args *f, long double y, ptrdiff_t p, uint8_t fl, int t) if (!isfinite(y)) { const char *ss = (t&32)?"inf":"INF"; if (y!=y) ss=(t&32)?"nan":"NAN"; - pad(f, ' ', 0, 3+pl, fl&~ZERO_PAD); + pad(f, ' ', w, 3+pl, fl&~ZERO_PAD); out(f, prefix, pl); out(f, ss, 3); - pad(f, ' ', 0, 3+pl, fl^LEFT_ADJ); - return 3+(int)pl; + pad(f, ' ', w, 3+pl, fl^LEFT_ADJ); + return MAX(w, 3+(int)pl); } y = frexp((double)y, &e2) * 2; @@ -169,14 +169,14 @@ fmt_fp(struct fmt_args *f, long double y, ptrdiff_t p, uint8_t fl, int t) else l = (s-buf) + (ebuf-estr); - pad(f, ' ', 0, pl+l, fl); + pad(f, ' ', w, pl+l, fl); out(f, prefix, pl); - pad(f, '0', 0, pl+l, fl^ZERO_PAD); + pad(f, '0', w, pl+l, fl^ZERO_PAD); out(f, buf, s-buf); pad(f, '0', l-(ebuf-estr)-(s-buf), 0, 0); out(f, estr, ebuf-estr); - pad(f, ' ', 0, pl+l, fl^LEFT_ADJ); - return (int)pl+(int)l; + pad(f, ' ', w, pl+l, fl^LEFT_ADJ); + return MAX(w, (int)pl+(int)l); } if (p<0) p=6; @@ -288,9 +288,9 @@ fmt_fp(struct fmt_args *f, long double y, ptrdiff_t p, uint8_t fl, int t) l += ebuf-estr; } - pad(f, ' ', 0, pl+l, fl); + pad(f, ' ', w, pl+l, fl); out(f, prefix, pl); - pad(f, '0', 0, pl+l, fl^ZERO_PAD); + pad(f, '0', w, pl+l, fl^ZERO_PAD); if ((t|32)=='f') { if (a>r) a=r; @@ -325,21 +325,25 @@ fmt_fp(struct fmt_args *f, long double y, ptrdiff_t p, uint8_t fl, int t) out(f, estr, ebuf-estr); } - pad(f, ' ', 0, pl+l, fl^LEFT_ADJ); + pad(f, ' ', w, pl+l, fl^LEFT_ADJ); - return (int)pl+(int)l; + return MAX(w, (int)pl+(int)l); } static int fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) { - ptrdiff_t p; + ptrdiff_t w, p; if (*fmt != '%') { return -1; } ++fmt; + for (w = 0; ISDIGIT(*fmt); ++fmt) { + w = 10 * w + (*fmt - '0'); + } + if (*fmt == '.') { ++fmt; for (p = 0; ISDIGIT(*fmt); ++fmt) { @@ -353,7 +357,7 @@ fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) switch (*fmt) { case 'e': case 'f': case 'g': case 'a': case 'E': case 'F': case 'G': case 'A': - return fmt_fp(f, flo, p, 0, *fmt); + return fmt_fp(f, flo, w, p, 0, *fmt); default: return -1; } -- cgit v1.2.3 From 2ceab2d27084f033538f2f817249a7979134c816 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 11 Apr 2020 21:19:19 +0900 Subject: Supports some specifier flags with `mrb_float_to_str()` Changed to understand `#`, `0`, `-`, ` ` and `+`. Based on src/stdio/vfprintf.c in git://git.musl-libc.org/musl --- mrbgems/mruby-sprintf/test/sprintf.rb | 5 +++++ src/fmt_fp.c | 16 +++++++++++++--- 2 files changed, 18 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/mrbgems/mruby-sprintf/test/sprintf.rb b/mrbgems/mruby-sprintf/test/sprintf.rb index 137812ae7..24d01c9be 100644 --- a/mrbgems/mruby-sprintf/test/sprintf.rb +++ b/mrbgems/mruby-sprintf/test/sprintf.rb @@ -8,6 +8,11 @@ assert('String#%') do assert_equal 15, ("%b" % (1<<14)).size skip unless Object.const_defined?(:Float) assert_equal "1.0", "%3.1f" % 1.01 + assert_equal " 123456789.12", "% 4.2f" % 123456789.123456789 + assert_equal "123456789.12", "%-4.2f" % 123456789.123456789 + assert_equal "+123456789.12", "%+4.2f" % 123456789.123456789 + assert_equal "123456789.12", "%04.2f" % 123456789.123456789 + assert_equal "00000000123456789.12", "%020.2f" % 123456789.123456789 end assert('String#% with inf') do diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 8b1b01559..99ba1e5ff 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -54,6 +54,8 @@ struct fmt_args { #define PAD_POS (1U<<(' '-' ')) #define MARK_POS (1U<<('+'-' ')) +#define FLAGMASK (ALT_FORM|ZERO_PAD|LEFT_ADJ|PAD_POS|MARK_POS) + static void out(struct fmt_args *f, const char *s, size_t l) { @@ -62,7 +64,7 @@ out(struct fmt_args *f, const char *s, size_t l) #define PAD_SIZE 256 static void -pad(struct fmt_args *f, char c, ptrdiff_t w, ptrdiff_t l, uint8_t fl) +pad(struct fmt_args *f, char c, ptrdiff_t w, ptrdiff_t l, uint32_t fl) { char pad[PAD_SIZE]; if (fl & (LEFT_ADJ | ZERO_PAD) || l >= w) return; @@ -92,7 +94,7 @@ typedef char compiler_defines_long_double_incorrectly[9-(int)sizeof(long double) #endif static int -fmt_fp(struct fmt_args *f, long double y, ptrdiff_t w, ptrdiff_t p, uint8_t fl, int t) +fmt_fp(struct fmt_args *f, long double y, ptrdiff_t w, ptrdiff_t p, uint32_t fl, int t) { uint32_t big[(LDBL_MANT_DIG+28)/29 + 1 // mantissa expansion + (LDBL_MAX_EXP+LDBL_MANT_DIG+28+8)/9]; // exponent expansion @@ -334,12 +336,20 @@ static int fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) { ptrdiff_t w, p; + uint32_t fl; if (*fmt != '%') { return -1; } ++fmt; + /* Read modifier flags */ + for (fl=0; (unsigned)*fmt-' '<32 && (FLAGMASK&(1U<<(*fmt-' '))); fmt++) + fl |= 1U<<(*fmt-' '); + + /* - and 0 flags are mutually exclusive */ + if (fl & LEFT_ADJ) fl &= ~ZERO_PAD; + for (w = 0; ISDIGIT(*fmt); ++fmt) { w = 10 * w + (*fmt - '0'); } @@ -357,7 +367,7 @@ fmt_core(struct fmt_args *f, const char *fmt, mrb_float flo) switch (*fmt) { case 'e': case 'f': case 'g': case 'a': case 'E': case 'F': case 'G': case 'A': - return fmt_fp(f, flo, w, p, 0, *fmt); + return fmt_fp(f, flo, w, p, fl, *fmt); default: return -1; } -- cgit v1.2.3 From d9832699085d60e21002e4ba76e3e3fd0480d9e8 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 11 Apr 2020 20:30:03 +0900 Subject: Add `mrb_float_to_cstr()` MRB_API function In order to share the same operation with `mrb_float_to_str()`, the internal structure is modified. --- include/mruby/numeric.h | 1 + src/fmt_fp.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 68 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index a176d96cd..06a33cc6f 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -37,6 +37,7 @@ MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base); /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */ #ifndef MRB_WITHOUT_FLOAT MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt); +MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f); MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x); MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f); #endif diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 99ba1e5ff..9ae5dd177 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -37,9 +37,19 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include +struct fmt_args; + +typedef void output_func(struct fmt_args *f, const char *s, size_t l); + struct fmt_args { mrb_state *mrb; - mrb_value str; + output_func *output; + void *opaque; +}; + +struct mrb_cstr { + char *buf; + size_t len; }; #define MAX(a,b) ((a)>(b) ? (a) : (b)) @@ -56,10 +66,37 @@ struct fmt_args { #define FLAGMASK (ALT_FORM|ZERO_PAD|LEFT_ADJ|PAD_POS|MARK_POS) +static output_func strcat_value; +static output_func strcat_cstr; + +static void +strcat_value(struct fmt_args *f, const char *s, size_t l) +{ + mrb_value str = *(mrb_value*)f->opaque; + mrb_str_cat(f->mrb, str, s, l); +} + +static void +strcat_cstr(struct fmt_args *f, const char *s, size_t l) +{ + struct mrb_cstr *cstr = (struct mrb_cstr*)f->opaque; + + if (l > cstr->len) { + mrb_state *mrb = f->mrb; + + mrb_raise(mrb, E_ARGUMENT_ERROR, "string buffer too small"); + } + + memcpy(cstr->buf, s, l); + + cstr->buf += l; + cstr->len -= l; +} + static void out(struct fmt_args *f, const char *s, size_t l) { - mrb_str_cat(f->mrb, f->str, s, l); + f->output(f, s, l); } #define PAD_SIZE 256 @@ -377,13 +414,33 @@ MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) { struct fmt_args f; + mrb_value str = mrb_str_new_capa(mrb, 24); f.mrb = mrb; - f.str = mrb_str_new_capa(mrb, 24); + f.output = strcat_value; + f.opaque = (void*)&str; if (fmt_core(&f, fmt, mrb_float(flo)) < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format string"); } - return f.str; + return str; +} + +MRB_API int +mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float fval) +{ + struct fmt_args f; + struct mrb_cstr cstr; + + cstr.buf = buf; + cstr.len = len - 1; /* reserve NUL terminator */ + f.mrb = mrb; + f.output = strcat_cstr; + f.opaque = (void*)&cstr; + if (fmt_core(&f, fmt, fval) < 0) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid format string"); + } + *cstr.buf = '\0'; + return cstr.buf - buf; } #else /* MRB_DISABLE_STDIO || _WIN32 || _WIN64 */ #include @@ -397,5 +454,11 @@ mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt) snprintf(buf, sizeof(buf), fmt, mrb_float(flo)); return mrb_str_new_cstr(mrb, buf); } + +MRB_API int +mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float fval) +{ + return snprintf(buf, len, fmt, fval); +} #endif /* MRB_DISABLE_STDIO || _WIN32 || _WIN64 */ #endif -- cgit v1.2.3 From d0501c69b0892208309dcbb8aa7fc1b8d75f3c8e Mon Sep 17 00:00:00 2001 From: dearblue Date: Mon, 13 Apr 2020 22:32:16 +0900 Subject: Fix `MRB_TT_CPTR` object with `MRB_NAN_BOXING` Previously, if `MRB_NAN_BOXING` is defined, for example, `mrb_cptr_value()` could not keep an odd address. If it is `MRB_32BIT`, it can be embedded in `NaN` as it is. If it is `MRB_64BIT`, some operations are shared with `MRB_WORD_BOXING`. In this case, the MRB_API function `mrb_nan_boxing_cptr_value()` is defined. --- include/mruby/boxing_nan.h | 13 +++++++++++-- include/mruby/boxing_word.h | 5 ----- include/mruby/value.h | 7 +++++++ src/etc.c | 17 +++++++++++++---- 4 files changed, 31 insertions(+), 11 deletions(-) (limited to 'src') diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index e7bc9331c..fae3b7630 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -44,6 +44,9 @@ typedef struct mrb_value { }; ) }; +#ifdef MRB_64BIT + struct RCptr *vp; +#endif } value; }; } mrb_value; @@ -54,13 +57,15 @@ typedef struct mrb_value { #define mrb_type(o) (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT) #define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2)) #define mrb_float(o) (o).f -#define mrb_cptr(o) mrb_ptr(o) #define mrb_fixnum(o) (o).value.i #define mrb_symbol(o) (o).value.sym #ifdef MRB_64BIT +MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*); +#define mrb_cptr(o) (((struct RCptr*)mrb_ptr(o))->p) #define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff) #else +#define mrb_cptr(o) ((o).value.p) #define BOXNAN_SHIFT_LONG_POINTER(v) 0 #endif @@ -90,7 +95,11 @@ typedef struct mrb_value { #define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n)) #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v)) #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v)) -#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_OBJ_VALUE(r, MRB_TT_CPTR, v) +#ifdef MRB_64BIT +#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_nan_boxing_cptr_value(mrb, v)) +#else +#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, value.p, v) +#endif #define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0) #endif /* MRUBY_BOXING_NAN_H */ diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index 1388bb9f6..c0d7087e0 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -18,11 +18,6 @@ struct RFloat { }; #endif -struct RCptr { - MRB_OBJECT_HEADER; - void *p; -}; - enum mrb_special_consts { MRB_Qnil = 0, MRB_Qfalse = 4, diff --git a/include/mruby/value.h b/include/mruby/value.h index 232beb1dc..33c70f15a 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -149,6 +149,13 @@ typedef void mrb_value; #endif +#if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT)) +struct RCptr { + MRB_OBJECT_HEADER; + void *p; +}; +#endif + #if defined(MRB_NAN_BOXING) #include "boxing_nan.h" #elif defined(MRB_WORD_BOXING) diff --git a/src/etc.c b/src/etc.c index 607e82ca1..6e1533e3d 100644 --- a/src/etc.c +++ b/src/etc.c @@ -140,7 +140,13 @@ mrb_obj_id(mrb_value obj) } } +#if defined(MRB_NAN_BOXING) && defined(MRB_64BIT) +#define mrb_xxx_boxing_cptr_value mrb_nan_boxing_cptr_value +#endif + #ifdef MRB_WORD_BOXING +#define mrb_xxx_boxing_cptr_value mrb_word_boxing_cptr_value + #ifndef MRB_WITHOUT_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) @@ -164,17 +170,20 @@ mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f) return mrb_obj_value(nf); } #endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_WORD_BOXING */ +#if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT)) MRB_API mrb_value -mrb_word_boxing_cptr_value(mrb_state *mrb, void *p) +mrb_xxx_boxing_cptr_value(mrb_state *mrb, void *p) { mrb_value v; + struct RCptr *cptr = (struct RCptr*)mrb_obj_alloc(mrb, MRB_TT_CPTR, mrb->object_class); - v.value.p = mrb_obj_alloc(mrb, MRB_TT_CPTR, mrb->object_class); - v.value.vp->p = p; + SET_OBJ_VALUE(v, cptr); + cptr->p = p; return v; } -#endif /* MRB_WORD_BOXING */ +#endif #if defined _MSC_VER && _MSC_VER < 1900 -- cgit v1.2.3 From c181d89c9dca0e722a525b871a82cbd75c59bb80 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 21 Apr 2020 13:14:10 +0900 Subject: `Kernel#clone` and `Kernel#dup` no longer raise `TypeError`; fix #4974 In ISO, those methods should raise `TypeError`, but the spec has been changed. The change was discussed in [Feature#12979]. --- src/kernel.c | 4 ++-- test/t/kernel.rb | 11 ----------- 2 files changed, 2 insertions(+), 13 deletions(-) (limited to 'src') diff --git a/src/kernel.c b/src/kernel.c index 8bb837eca..ae9617686 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -325,7 +325,7 @@ mrb_obj_clone(mrb_state *mrb, mrb_value self) mrb_value clone; if (mrb_immediate_p(self)) { - mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %v", self); + return self; } if (mrb_sclass_p(self)) { mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class"); @@ -366,7 +366,7 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj) mrb_value dup; if (mrb_immediate_p(obj)) { - mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %v", obj); + return obj; } if (mrb_sclass_p(obj)) { mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class"); diff --git a/test/t/kernel.rb b/test/t/kernel.rb index c2eeee1a5..aac6373fa 100644 --- a/test/t/kernel.rb +++ b/test/t/kernel.rb @@ -197,17 +197,6 @@ assert('Kernel#dup', '15.3.1.3.9') do a.set(2) c = a.dup - immutables = [ 1, :foo, true, false, nil ] - error_count = 0 - immutables.each do |i| - begin - i.dup - rescue TypeError - error_count += 1 - end - end - - assert_equal immutables.size, error_count assert_equal 2, a.get assert_equal 1, b.get assert_equal 2, c.get -- cgit v1.2.3 From ed0038fdf298750abeb9cf582f9576b3071e9411 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 21 Apr 2020 15:43:35 +0900 Subject: Simplified `mrb_obj_instance_eval`; ref #4973 --- src/vm.c | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) (limited to 'src') diff --git a/src/vm.c b/src/vm.c index d7826230e..bcd846025 100644 --- a/src/vm.c +++ b/src/vm.c @@ -730,19 +730,8 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self) if (mrb_get_args(mrb, "|S&", &a, &b) == 1) { mrb_raise(mrb, E_NOTIMP_ERROR, "instance_eval with string not implemented"); } - switch (mrb_type(self)) { - case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT - case MRB_TT_FLOAT: -#endif - c = 0; - break; - default: - cv = mrb_singleton_class(mrb, self); - c = mrb_class_ptr(cv); - break; - } + cv = mrb_singleton_class(mrb, self); + c = mrb_class_ptr(cv); return eval_under(mrb, self, b, c); } -- cgit v1.2.3 From 61c6832b486ec4fc01353109c8c4085c88fa8f76 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 21 Apr 2020 15:44:21 +0900 Subject: Fix the bug by `#instance_eval` called via a method object; fix #4973 The tranpoline code in 6a0b68f8b was wrong; reverted. --- src/vm.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'src') diff --git a/src/vm.c b/src/vm.c index bcd846025..f8f4609bf 100644 --- a/src/vm.c +++ b/src/vm.c @@ -648,8 +648,7 @@ eval_under(mrb_state *mrb, mrb_value self, mrb_value blk, struct RClass *c) } ci = mrb->c->ci; if (ci->acc == CI_ACC_DIRECT) { - ci->target_class = c; - return mrb_yield_cont(mrb, blk, self, 1, &self); + return mrb_yield_with_class(mrb, blk, 1, &self, self, c); } ci->target_class = c; p = mrb_proc_ptr(blk); -- cgit v1.2.3 From 87d1bbe94794304d92fc9a4af5cf17eab5d1534c Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 22 Apr 2020 16:44:39 +0900 Subject: Add new function `mrb_singleton_class_ptr()`; ref #4973 The difference between `mrb_singleton_class` and `mrb_singleton_class_ptr`: - `mrb_singleton_class_ptr` returns `struct RClass*`. - `mrb_singleton_class_ptr` returns `NULL` on immediate values where `mrb_singleton_class` raises exceptions. --- include/mruby.h | 2 ++ src/class.c | 30 +++++++++++++++++++++--------- 2 files changed, 23 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/include/mruby.h b/include/mruby.h index 7419618fd..4b7a673f3 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -317,7 +317,9 @@ MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct * @return [struct RClass *] Reference to the newly defined module. */ MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name); + MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val); +MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val); /** * Include a module in another class or module. diff --git a/src/class.c b/src/class.c index c49f0f474..b0af74e74 100644 --- a/src/class.c +++ b/src/class.c @@ -1242,33 +1242,45 @@ mrb_mod_dummy_visibility(mrb_state *mrb, mrb_value mod) return mod; } -MRB_API mrb_value -mrb_singleton_class(mrb_state *mrb, mrb_value v) +/* returns mrb_class_ptr(mrb_singleton_class()) */ +/* except that it return NULL for immediate values */ +MRB_API struct RClass* +mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) { struct RBasic *obj; switch (mrb_type(v)) { case MRB_TT_FALSE: if (mrb_nil_p(v)) - return mrb_obj_value(mrb->nil_class); - return mrb_obj_value(mrb->false_class); + return mrb->nil_class; + return mrb->false_class; case MRB_TT_TRUE: - return mrb_obj_value(mrb->true_class); + return mrb->true_class; case MRB_TT_CPTR: - return mrb_obj_value(mrb->object_class); + return mrb->object_class; case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: #ifndef MRB_WITHOUT_FLOAT case MRB_TT_FLOAT: #endif - mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton"); - return mrb_nil_value(); /* not reached */ + return NULL; default: break; } obj = mrb_basic_ptr(v); prepare_singleton_class(mrb, obj); - return mrb_obj_value(obj->c); + return obj->c; +} + +MRB_API mrb_value +mrb_singleton_class(mrb_state *mrb, mrb_value v) +{ + struct RClass *c = mrb_singleton_class_ptr(mrb, v); + + if (c == NULL) { + mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton"); + } + return mrb_obj_value(c); } MRB_API void -- cgit v1.2.3 From ab508e1e7f66d8e4eb6dd5f6a9cdf37c8c9e5005 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 22 Apr 2020 16:47:26 +0900 Subject: Make `mrb_obj_instance_eval` to use `mrb_singleton_class_ptr`; #4973 --- src/vm.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) (limited to 'src') diff --git a/src/vm.c b/src/vm.c index f8f4609bf..85f28584c 100644 --- a/src/vm.c +++ b/src/vm.c @@ -723,15 +723,11 @@ mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self) { mrb_value a, b; - mrb_value cv; - struct RClass *c; if (mrb_get_args(mrb, "|S&", &a, &b) == 1) { mrb_raise(mrb, E_NOTIMP_ERROR, "instance_eval with string not implemented"); } - cv = mrb_singleton_class(mrb, self); - c = mrb_class_ptr(cv); - return eval_under(mrb, self, b, c); + return eval_under(mrb, self, b, mrb_singleton_class_ptr(mrb, self)); } MRB_API mrb_value -- cgit v1.2.3 From 26eb29547b6e2c5b94ec1bf4b0e90a7821b04be1 Mon Sep 17 00:00:00 2001 From: dearblue Date: Fri, 24 Apr 2020 21:15:34 +0900 Subject: Support `undef` for `mrb_ary_splice()` instead of `[]` When removing elements from an array, it is possible to avoid creating an empty array. Before this patch: ```c mrb_ary_splice(mrb, ary, head, len, mrb_ary_new(mrb)); ``` After this patch: ```c mrb_ary_splice(mrb, ary, head, len, mrb_undef_value()); ``` --- include/mruby/array.h | 1 + src/array.c | 4 ++++ 2 files changed, 5 insertions(+) (limited to 'src') diff --git a/include/mruby/array.h b/include/mruby/array.h index e2dd9bb1c..fd4094a02 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -239,6 +239,7 @@ MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset); * @param head Beginning position of a replacement subsequence. * @param len Length of a replacement subsequence. * @param rpl The array of replacement elements. + * It is possible to pass `mrb_undef_value()` instead of an empty array. * @return The receiver array. */ MRB_API mrb_value mrb_ary_splice(mrb_state *mrb, mrb_value self, mrb_int head, mrb_int len, mrb_value rpl); diff --git a/src/array.c b/src/array.c index 8547cfff4..6e73bcd8e 100644 --- a/src/array.c +++ b/src/array.c @@ -732,6 +732,10 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val argv = ARY_PTR(r); } } + else if (mrb_undef_p(rpl)) { + argc = 0; + argv = NULL; + } else { argc = 1; argv = &rpl; -- cgit v1.2.3 From 2c32154115fc4fe753eff0075d6a204d899f1cb6 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 28 Apr 2020 11:59:20 +0900 Subject: Fix UTF-8 boundary check; ref #4982 --- src/string.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/string.c b/src/string.c index 9ea19d107..2ef1ad95a 100644 --- a/src/string.c +++ b/src/string.c @@ -463,7 +463,7 @@ str_index_str_by_char_search(mrb_state *mrb, const char *p, const char *pend, co } pivot = p + qstable[(unsigned char)p[slen - 1]]; - if (pivot > pend || pivot < p /* overflowed */) { return -1; } + if (pivot >= pend || pivot < p /* overflowed */) { return -1; } do { p += utf8len(p, pend); -- cgit v1.2.3 From a395f8e2c829706eb7c9e0dccaab077f189ddb6e Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 28 Apr 2020 13:16:27 +0900 Subject: Rename (and expose) UTF-8 related functions; ref #4712 - mrb_utf8len() - returns the size of a UTF-8 char (in bytes) - mrb_utf8_strlen() - returns the length of a UTF-8 string (in char) --- include/mruby/string.h | 3 ++- mrbgems/mruby-symbol-ext/src/symbol.c | 2 +- src/string.c | 26 +++++++++++++------------- 3 files changed, 16 insertions(+), 15 deletions(-) (limited to 'src') diff --git a/include/mruby/string.h b/include/mruby/string.h index a518d9147..93c94ef5d 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -465,7 +465,8 @@ mrb_bool mrb_str_beg_len(mrb_int str_len, mrb_int *begp, mrb_int *lenp); mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); #ifdef MRB_UTF8_STRING -mrb_int mrb_utf8_len(const char *str, mrb_int byte_len); +mrb_int mrb_utf8len(const char *str, const char *end); +mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len); #endif MRB_END_DECL diff --git a/mrbgems/mruby-symbol-ext/src/symbol.c b/mrbgems/mruby-symbol-ext/src/symbol.c index 87f8381b1..ad922ad2f 100644 --- a/mrbgems/mruby-symbol-ext/src/symbol.c +++ b/mrbgems/mruby-symbol-ext/src/symbol.c @@ -47,7 +47,7 @@ mrb_sym_length(mrb_state *mrb, mrb_value self) #ifdef MRB_UTF8_STRING mrb_int byte_len; const char *name = mrb_sym_name_len(mrb, mrb_symbol(self), &byte_len); - len = mrb_utf8_len(name, byte_len); + len = mrb_utf8_strlen(name, byte_len); #else mrb_sym_name_len(mrb, mrb_symbol(self), &len); #endif diff --git a/src/string.c b/src/string.c index 2ef1ad95a..458c511dc 100644 --- a/src/string.c +++ b/src/string.c @@ -301,8 +301,8 @@ static const char utf8len_codepage[256] = 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1, }; -static mrb_int -utf8len(const char* p, const char* e) +mrb_int +mrb_utf8len(const char* p, const char* e) { mrb_int len; mrb_int i; @@ -318,14 +318,14 @@ utf8len(const char* p, const char* e) } mrb_int -mrb_utf8_len(const char *str, mrb_int byte_len) +mrb_utf8_strlen(const char *str, mrb_int byte_len) { mrb_int total = 0; const char *p = str; const char *e = p + byte_len; while (p < e) { - p += utf8len(p, e); + p += mrb_utf8len(p, e); total++; } return total; @@ -341,7 +341,7 @@ utf8_strlen(mrb_value str) return byte_len; } else { - mrb_int utf8_len = mrb_utf8_len(RSTR_PTR(s), byte_len); + mrb_int utf8_len = mrb_utf8_strlen(RSTR_PTR(s), byte_len); if (byte_len == utf8_len) RSTR_SET_ASCII_FLAG(s); return utf8_len; } @@ -362,7 +362,7 @@ chars2bytes(mrb_value s, mrb_int off, mrb_int idx) const char *e = RSTRING_END(s); for (b=i=0; p beg) { p --; if ((*p & 0xc0) != 0x80) { - int clen = utf8len(p, end); + int clen = mrb_utf8len(p, end); if (clen > ptr - p) return p; break; } @@ -466,7 +466,7 @@ str_index_str_by_char_search(mrb_state *mrb, const char *p, const char *pend, co if (pivot >= pend || pivot < p /* overflowed */) { return -1; } do { - p += utf8len(p, pend); + p += mrb_utf8len(p, pend); off ++; } while (p < pivot); } @@ -485,7 +485,7 @@ str_index_str_by_char(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) for (; pos > 0; pos --) { if (pend - p < 1) { return -1; } - p += utf8len(p, pend); + p += mrb_utf8len(p, pend); } if (slen < 1) { return off; } @@ -1362,7 +1362,7 @@ str_escape(mrb_state *mrb, mrb_value str, mrb_bool inspect) unsigned char c, cc; #ifdef MRB_UTF8_STRING if (inspect) { - mrb_int clen = utf8len(p, pend); + mrb_int clen = mrb_utf8len(p, pend); if (clen > 1) { mrb_int i; @@ -1665,7 +1665,7 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str) const char* t = RSTR_PTR(s), *p = t; const char* e = p + RSTR_LEN(s); while (p=e) break; p += clen; } @@ -2037,7 +2037,7 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str) p = RSTR_PTR(s); e = p + RSTR_LEN(s); while (p Date: Wed, 29 Apr 2020 16:57:25 +0900 Subject: Makes `mrb_any_to_s()` accept an object whose class is `NULL` When using `mrb_any_to_s()` for debugging purposes, giving an object whose class is `NULL` no longer causes a SIGSEGV and no crash. This is achieved by making `mrb_class_name()` and `mrb_str_cat_cstr()` null safe. --- src/class.c | 5 ++++- src/string.c | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/class.c b/src/class.c index b0af74e74..d30edd41e 100644 --- a/src/class.c +++ b/src/class.c @@ -1728,7 +1728,10 @@ mrb_class_real(struct RClass* cl) MRB_API const char* mrb_class_name(mrb_state *mrb, struct RClass* c) { - mrb_value name = class_name_str(mrb, c); + mrb_value name; + + if (c == NULL) return NULL; + name = class_name_str(mrb, c); return RSTRING_PTR(name); } diff --git a/src/string.c b/src/string.c index 458c511dc..44e3c9069 100644 --- a/src/string.c +++ b/src/string.c @@ -2759,7 +2759,7 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) MRB_API mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr) { - return mrb_str_cat(mrb, str, ptr, strlen(ptr)); + return mrb_str_cat(mrb, str, ptr, ptr ? strlen(ptr) : 0); } MRB_API mrb_value -- cgit v1.2.3 From c143d87e7ce55092aa7b3578be3d525d5b311384 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 6 May 2020 15:49:06 +0900 Subject: Remove `mrb_run` from `MRB_API`; #4488 `mrb_run` requires to push callinfo stack before calling, which is very hard from outside of `vm.c`. So there should be virtually no correct usage of the function, hence the cause of #4488. We removed it. You can use `mrb_top_run(mrb, proc, self, 0)` instead of `mrb_run(mrb, proc self)`. --- include/mruby.h | 1 - src/vm.c | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/include/mruby.h b/include/mruby.h index eca7eb9cf..af7503375 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1150,7 +1150,6 @@ MRB_API void mrb_close(mrb_state *mrb); MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*); MRB_API mrb_value mrb_top_self(mrb_state *mrb); -MRB_API mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self); MRB_API mrb_value mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep); MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep); MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *iseq); diff --git a/src/vm.c b/src/vm.c index 85f28584c..ea1bb5087 100644 --- a/src/vm.c +++ b/src/vm.c @@ -324,6 +324,7 @@ cipop(mrb_state *mrb) } void mrb_exc_set(mrb_state *mrb, mrb_value exc); +static mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self); static void ecall(mrb_state *mrb) @@ -2808,7 +2809,7 @@ RETRY_TRY_BLOCK: MRB_END_EXC(&c_jmp); } -MRB_API mrb_value +static mrb_value mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) { if (mrb->c->ci->argc < 0) { -- cgit v1.2.3 From fa8668c77d181a5075dc56fb63d6fa087ab4b1d3 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 17 Jan 2020 09:28:21 +0900 Subject: Add a new instruction `OP_LOADI16`. Which loads 16bit integer to the register. The instruction number should be reorder on massive instruction refactoring. The instruction is added for `mruby/c` which had performance issue with `OP_EXT`. With this instruction, `mruby/c` VM can just raise errors on `OP_EXT` extension instructions. --- include/mruby/ops.h | 1 + mrbgems/mruby-compiler/core/codegen.c | 21 ++++++++++++++++----- src/codedump.c | 4 ++++ src/vm.c | 5 +++++ 4 files changed, 26 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/include/mruby/ops.h b/include/mruby/ops.h index 2327c33fd..c8990ae43 100644 --- a/include/mruby/ops.h +++ b/include/mruby/ops.h @@ -115,3 +115,4 @@ OPCODE(EXT1, Z) /* make 1st operand 16bit */ OPCODE(EXT2, Z) /* make 2nd operand 16bit */ OPCODE(EXT3, Z) /* make 1st and 2nd operands 16bit */ OPCODE(STOP, Z) /* stop VM */ +OPCODE(LOADI16, BS) /* R(a) = mrb_int(b) */ diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 717d9eb9a..162666eb9 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2440,12 +2440,20 @@ codegen(codegen_scope *s, node *tree, int val) else #endif { - if (i == -1) genop_1(s, OP_LOADI__1, cursp()); - else if (i < 0) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i); + if (i < 0) { + if (i == -1) genop_1(s, OP_LOADI__1, cursp()); + else if (i >= -0xff) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i); + else if (i >= -0x8000) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); + else goto lit_int; + } else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, cursp()); - else if (i <= 0xffff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i); + else if (i <= 0xff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i); + else if (i <= 0xffff) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); else { - int off = new_lit(s, mrb_fixnum_value(i)); + int off; + + lit_int: + off = new_lit(s, mrb_fixnum_value(i)); genop_2(s, OP_LOADL, cursp(), off); } } @@ -2501,9 +2509,12 @@ codegen(codegen_scope *s, node *tree, int val) else { #endif if (i == -1) genop_1(s, OP_LOADI__1, cursp()); - else if (i >= -0xffff) { + else if (i >= -0xff) { genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i); } + else if (i >= -0x8000) { + genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); + } else { int off = new_lit(s, mrb_fixnum_value(i)); genop_2(s, OP_LOADL, cursp(), off); diff --git a/src/codedump.c b/src/codedump.c index 7faa39360..649be176b 100644 --- a/src/codedump.c +++ b/src/codedump.c @@ -130,6 +130,10 @@ codedump(mrb_state *mrb, mrb_irep *irep) printf("OP_LOADI\tR%d\t-%d\t", a, b); print_lv_a(mrb, irep, a); break; + CASE(OP_LOADI16, BS): + printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b); + print_lv_a(mrb, irep, a); + break; CASE(OP_LOADI__1, B): printf("OP_LOADI__1\tR%d\t\t", a); print_lv_a(mrb, irep, a); diff --git a/src/vm.c b/src/vm.c index ea1bb5087..26da5831e 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1047,6 +1047,11 @@ RETRY_TRY_BLOCK: NEXT; } + CASE(OP_LOADI16, BS) { + SET_INT_VALUE(regs[a], (mrb_int)(int16_t)b); + NEXT; + } + CASE(OP_LOADSYM, BB) { SET_SYM_VALUE(regs[a], syms[b]); NEXT; -- cgit v1.2.3 From 87576b819e704492f4690027ad41543637cabb16 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 1 May 2020 14:13:16 +0900 Subject: Remove endian information/flags from compiled binary format. Since `mruby 2.0`, compiled bytecode no longer depends on the endian of the machine. --- include/mruby/dump.h | 16 ------------- src/dump.c | 65 +++------------------------------------------------- src/load.c | 20 ++-------------- 3 files changed, 5 insertions(+), 96 deletions(-) (limited to 'src') diff --git a/include/mruby/dump.h b/include/mruby/dump.h index 2da5eb28d..db3e287d3 100644 --- a/include/mruby/dump.h +++ b/include/mruby/dump.h @@ -17,10 +17,6 @@ MRB_BEGIN_DECL #define DUMP_DEBUG_INFO 1 -#define DUMP_ENDIAN_BIG 2 -#define DUMP_ENDIAN_LIL 4 -#define DUMP_ENDIAN_NAT 6 -#define DUMP_ENDIAN_MASK 6 int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size); #ifndef MRB_DISABLE_STDIO @@ -52,7 +48,6 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t); /* Rite Binary File header */ #define RITE_BINARY_IDENT "RITE" -#define RITE_BINARY_IDENT_LIL "ETIR" #define RITE_BINARY_FORMAT_VER "0007" #define RITE_COMPILER_NAME "MATZ" #define RITE_COMPILER_VERSION "0000" @@ -106,17 +101,6 @@ struct rite_binary_footer { RITE_SECTION_HEADER; }; -static inline int -bigendian_p() -{ - int i; - char *p; - - i = 1; - p = (char*)&i; - return p[0]?0:1; -} - static inline size_t uint8_to_bin(uint8_t s, uint8_t *bin) { diff --git a/src/dump.c b/src/dump.c index 183f3b67d..95fe1ac82 100644 --- a/src/dump.c +++ b/src/dump.c @@ -709,22 +709,7 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8 uint16_t crc; uint32_t offset; - switch (flags & DUMP_ENDIAN_NAT) { - endian_big: - case DUMP_ENDIAN_BIG: - memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)); - break; - endian_little: - case DUMP_ENDIAN_LIL: - memcpy(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)); - break; - - case DUMP_ENDIAN_NAT: - if (bigendian_p()) goto endian_big; - goto endian_little; - break; - } - + memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)); memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)); memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name)); memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version)); @@ -764,21 +749,6 @@ lv_defined_p(mrb_irep *irep) return FALSE; } -static uint8_t -dump_flags(uint8_t flags, uint8_t native) -{ - if (native == FLAG_BYTEORDER_NATIVE) { - if ((flags & DUMP_ENDIAN_NAT) == 0) { - return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_NAT; - } - return flags; - } - if ((flags & DUMP_ENDIAN_NAT) == 0) { - return (flags & DUMP_DEBUG_INFO) | DUMP_ENDIAN_BIG; - } - return flags; -} - static int dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) { @@ -870,7 +840,7 @@ error_exit: int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size) { - return dump_irep(mrb, irep, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), bin, bin_size); + return dump_irep(mrb, irep, flags, bin, bin_size); } #ifndef MRB_DISABLE_STDIO @@ -886,7 +856,7 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp) return MRB_DUMP_INVALID_ARGUMENT; } - result = dump_irep(mrb, irep, dump_flags(flags, FLAG_BYTEORDER_NONATIVE), &bin, &bin_size); + result = dump_irep(mrb, irep, flags, &bin, &bin_size); if (result == MRB_DUMP_OK) { if (fwrite(bin, sizeof(bin[0]), bin_size, fp) != bin_size) { result = MRB_DUMP_WRITE_FAULT; @@ -897,20 +867,6 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp) return result; } -static mrb_bool -dump_bigendian_p(uint8_t flags) -{ - switch (flags & DUMP_ENDIAN_NAT) { - case DUMP_ENDIAN_BIG: - return TRUE; - case DUMP_ENDIAN_LIL: - return FALSE; - default: - case DUMP_ENDIAN_NAT: - return bigendian_p(); - } -} - int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname) { @@ -921,23 +877,8 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, con if (fp == NULL || initname == NULL || initname[0] == '\0') { return MRB_DUMP_INVALID_ARGUMENT; } - flags = dump_flags(flags, FLAG_BYTEORDER_NATIVE); result = dump_irep(mrb, irep, flags, &bin, &bin_size); if (result == MRB_DUMP_OK) { - if (!dump_bigendian_p(flags)) { - if (fprintf(fp, "/* dumped in little endian order.\n" - " use `mrbc -E` option for big endian CPU. */\n") < 0) { - mrb_free(mrb, bin); - return MRB_DUMP_WRITE_FAULT; - } - } - else { - if (fprintf(fp, "/* dumped in big endian order.\n" - " use `mrbc -e` option for better performance on little endian CPU. */\n") < 0) { - mrb_free(mrb, bin); - return MRB_DUMP_WRITE_FAULT; - } - } if (fprintf(fp, "#include \n") < 0) { /* for uint8_t under at least Darwin */ mrb_free(mrb, bin); return MRB_DUMP_WRITE_FAULT; diff --git a/src/load.c b/src/load.c index e624c52d5..2a118c922 100644 --- a/src/load.c +++ b/src/load.c @@ -19,9 +19,6 @@ # error size_t must be at least 32 bits wide #endif -#define FLAG_BYTEORDER_BIG 2 -#define FLAG_BYTEORDER_LIL 4 -#define FLAG_BYTEORDER_NATIVE 8 #define FLAG_SRC_MALLOC 1 #define FLAG_SRC_STATIC 0 @@ -94,8 +91,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) { return NULL; } - if ((flags & FLAG_SRC_MALLOC) == 0 && - (flags & FLAG_BYTEORDER_NATIVE)) { + if ((flags & FLAG_SRC_MALLOC) == 0) { irep->iseq = (mrb_code*)src; src += sizeof(mrb_code) * irep->ilen; irep->flags |= MRB_ISEQ_NO_FREE; @@ -464,19 +460,7 @@ read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint16_ return MRB_DUMP_READ_FAULT; } - if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) == 0) { - if (bigendian_p()) - *flags |= FLAG_BYTEORDER_NATIVE; - else - *flags |= FLAG_BYTEORDER_BIG; - } - else if (memcmp(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)) == 0) { - if (bigendian_p()) - *flags |= FLAG_BYTEORDER_LIL; - else - *flags |= FLAG_BYTEORDER_NATIVE; - } - else { + if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) != 0) { return MRB_DUMP_INVALID_FILE_HEADER; } -- cgit v1.2.3 From e82b8b7bf89ae8c69098eaf8bdcae632e7b9c41a Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Sun, 3 May 2020 17:14:26 +0900 Subject: Update `cmpnum` document. `cmpnum` function may return `nil` on error. --- src/numeric.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/numeric.c b/src/numeric.c index 6cfd64280..d1fa47fd0 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1474,13 +1474,14 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) /* 15.2.9.3.6 */ /* * call-seq: - * self.f <=> other.f => -1, 0, +1 + * self.f <=> other.f => -1, 0, +1, or nil * < => -1 * = => 0 * > => +1 * Comparison---Returns -1, 0, or +1 depending on whether fix is * less than, equal to, or greater than numeric. This is the - * basis for the tests in Comparable. + * basis for the tests in Comparable. When the operands are + * not comparable, it returns nil instead of raising an exception. */ static mrb_value integral_cmp(mrb_state *mrb, mrb_value self) -- cgit v1.2.3 From f6c2662632faa8b4f2d8f0cf07f3727a34a36015 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sat, 9 May 2020 22:30:05 +0900 Subject: Remove byteorder constants; ref 87576b8 The `FLAG_BYTEORDER_NATIVE` and `FLAG_BYTEORDER_NONATIVE` are no longer needed. --- src/dump.c | 3 --- 1 file changed, 3 deletions(-) (limited to 'src') diff --git a/src/dump.c b/src/dump.c index 95fe1ac82..a6bbe68f3 100644 --- a/src/dump.c +++ b/src/dump.c @@ -13,9 +13,6 @@ #include #include -#define FLAG_BYTEORDER_NATIVE 2 -#define FLAG_BYTEORDER_NONATIVE 0 - #ifndef MRB_WITHOUT_FLOAT #ifdef MRB_USE_FLOAT #define MRB_FLOAT_FMT "%.9g" -- cgit v1.2.3 From bd60ad98eb3ed48fc7bbe52ad5b879189c582bbd Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 10 May 2020 20:15:55 +0900 Subject: Get an irep symbol if it's `OP_GETSV` or `OP_SETSV` --- src/vm.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/vm.c b/src/vm.c index 26da5831e..7bb153910 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1089,13 +1089,13 @@ RETRY_TRY_BLOCK: } CASE(OP_GETSV, BB) { - mrb_value val = mrb_vm_special_get(mrb, b); + mrb_value val = mrb_vm_special_get(mrb, syms[b]); regs[a] = val; NEXT; } CASE(OP_SETSV, BB) { - mrb_vm_special_set(mrb, b, regs[a]); + mrb_vm_special_set(mrb, syms[b], regs[a]); NEXT; } -- cgit v1.2.3 From bc929656fb1c675fde9b1652c10f7cd42d2f63fa Mon Sep 17 00:00:00 2001 From: KOBAYASHI Shuji Date: Fri, 15 May 2020 21:17:24 +0900 Subject: Unify `eql?` receiver in `Hash` according to Ruby ### Example ```ruby # example.rb class A def eql?(o) p self.class super end def hash 1 end end class B < A; end h = {A.new => 1} h[B.new] ``` #### Before this patch: ```console $ bin/mruby example.rb A ``` #### After this patch (same as Ruby) ```console $ bin/mruby example.rb B ``` --- src/hash.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/hash.c b/src/hash.c index 8e7f97147..ec79a3def 100644 --- a/src/hash.c +++ b/src/hash.c @@ -373,7 +373,7 @@ ht_put(mrb_state *mrb, htable *t, mrb_value key, mrb_value val) deleted++; continue; } - if (ht_hash_equal(mrb, t, k, key)) { + if (ht_hash_equal(mrb, t, key, k)) { seg->e[i].val = val; return; } @@ -454,7 +454,7 @@ ht_get(mrb_state *mrb, htable *t, mrb_value key, mrb_value *vp) return FALSE; } if (mrb_undef_p(k)) continue; - if (ht_hash_equal(mrb, t, k, key)) { + if (ht_hash_equal(mrb, t, key, k)) { if (vp) *vp = seg->e[i].val; return TRUE; } -- cgit v1.2.3 From 6f4c585bd73fc43fb9e34a70d74b5a50852600ea Mon Sep 17 00:00:00 2001 From: Yusuke Endoh Date: Sun, 24 May 2020 01:25:03 +0900 Subject: Do not destruct rest arguments for __send__ Formerly, `__send__(*args)` modified `args` with `Array#shift`. This bug affects optcarrot. This changeset avoids the array destruction by using `args = args[1, len-1]`. --- include/mruby/array.h | 3 +++ src/array.c | 7 +++++++ src/vm.c | 2 +- test/t/kernel.rb | 4 ++++ 4 files changed, 15 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/include/mruby/array.h b/include/mruby/array.h index fd4094a02..92c86a8c5 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -292,6 +292,9 @@ MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep); */ MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len); +/* helper functions */ +mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len); + MRB_END_DECL #endif /* MRUBY_ARRAY_H */ diff --git a/src/array.c b/src/array.c index 6e73bcd8e..ad0d5b8db 100644 --- a/src/array.c +++ b/src/array.c @@ -808,6 +808,13 @@ ary_subseq(mrb_state *mrb, struct RArray *a, mrb_int beg, mrb_int len) return mrb_obj_value(b); } +mrb_value +mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len) +{ + struct RArray *a = mrb_ary_ptr(ary); + return ary_subseq(mrb, a, beg, len); +} + static mrb_int aget_index(mrb_state *mrb, mrb_value index) { diff --git a/src/vm.c b/src/vm.c index 7bb153910..bd54f3f00 100644 --- a/src/vm.c +++ b/src/vm.c @@ -625,7 +625,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self) ci->argc--; } else { /* variable length arguments */ - mrb_ary_shift(mrb, regs[0]); + regs[0] = mrb_ary_subseq(mrb, regs[0], 1, RARRAY_LEN(regs[0]) - 1); } if (MRB_METHOD_CFUNC_P(m)) { diff --git a/test/t/kernel.rb b/test/t/kernel.rb index aac6373fa..e3b9fe8ab 100644 --- a/test/t/kernel.rb +++ b/test/t/kernel.rb @@ -100,6 +100,10 @@ assert('Kernel#__send__', '15.3.1.3.4') do assert_true __send__(:respond_to?, :nil?) # test without argument and without block assert_equal String, __send__(:to_s).class + + args = [:respond_to?, :nil?] + assert_true __send__(*args) + assert_equal [:respond_to?, :nil?], args end assert('Kernel#block_given?', '15.3.1.3.6') do -- cgit v1.2.3 From d5cca2bdb2a0352e3253cf3ba2a79157dde5f163 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 28 May 2020 18:43:20 +0900 Subject: Check `c->eidx` before decrement in `ecall()`; close #4977 --- src/vm.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/vm.c b/src/vm.c index bd54f3f00..a280026f8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -336,10 +336,12 @@ ecall(mrb_state *mrb) struct REnv *env; ptrdiff_t cioff; int ai = mrb_gc_arena_save(mrb); - uint16_t i = --c->eidx; + uint16_t i; int nregs; - if (i<0) return; + if (c->eidx == 0) return; + i = --c->eidx; + /* restrict total call depth of ecall() */ if (++mrb->ecall_nest > MRB_ECALL_DEPTH_MAX) { mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err)); -- cgit v1.2.3