summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--build_config.rb5
-rw-r--r--include/mruby/string.h8
-rw-r--r--mrbgems/mruby-random/mrbgem.rake4
-rw-r--r--mrbgems/mruby-random/src/mt19937ar.c175
-rw-r--r--mrbgems/mruby-random/src/mt19937ar.h72
-rw-r--r--mrbgems/mruby-random/src/random.c140
-rw-r--r--mrbgems/mruby-random/src/random.h12
-rw-r--r--src/array.c7
-rw-r--r--src/class.c5
-rw-r--r--src/error.c16
-rw-r--r--src/hash.c2
-rw-r--r--src/string.c2
-rw-r--r--src/value_array.h27
-rw-r--r--src/variable.c4
-rw-r--r--src/vm.c22
15 files changed, 461 insertions, 40 deletions
diff --git a/build_config.rb b/build_config.rb
index 475ff27a8..c3f529656 100644
--- a/build_config.rb
+++ b/build_config.rb
@@ -39,7 +39,10 @@ MRuby::Build.new do |conf|
conf.gem "#{root}/mrbgems/mruby-hash-ext"
# No use eval method
- # conf.gem "#{root}/mrbgems/mruby-eval
+ # conf.gem "#{root}/mrbgems/mruby-eval"
+
+ # No use Random module
+ # conf.gem "#{root}/mrbgems/mruby-random"
# Generate binaries
# conf.bins = %w(mrbc mruby mirb)
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 613c6c6a7..3dc4094aa 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -56,7 +56,7 @@ char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr);
int mrb_str_offset(mrb_state *mrb, mrb_value str, int pos);
mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str); /* mrb_str_dup */
mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
-mrb_value mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr);
+mrb_value mrb_str_cat_cstr(mrb_state *, mrb_value, const char *);
mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck);
double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, int badcheck);
mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
@@ -71,6 +71,12 @@ mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
+/* For backward compatibility */
+static inline mrb_value
+mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr) {
+ return mrb_str_cat_cstr(mrb, str, ptr);
+}
+
#if defined(__cplusplus)
} /* extern "C" { */
#endif
diff --git a/mrbgems/mruby-random/mrbgem.rake b/mrbgems/mruby-random/mrbgem.rake
new file mode 100644
index 000000000..38e93e4b1
--- /dev/null
+++ b/mrbgems/mruby-random/mrbgem.rake
@@ -0,0 +1,4 @@
+MRuby::Gem::Specification.new('mruby-random') do |spec|
+ spec.license = 'MIT'
+ spec.authors = 'mruby developers'
+end
diff --git a/mrbgems/mruby-random/src/mt19937ar.c b/mrbgems/mruby-random/src/mt19937ar.c
new file mode 100644
index 000000000..211aefde9
--- /dev/null
+++ b/mrbgems/mruby-random/src/mt19937ar.c
@@ -0,0 +1,175 @@
+/*
+ A C-program for MT19937, with initialization improved 2002/1/26.
+ Coded by Takuji Nishimura and Makoto Matsumoto.
+
+ Before using, initialize the state by using init_genrand(seed)
+ or init_by_array(init_key, key_length).
+
+ Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ All rights reserved.
+ Copyright (C) 2005, Mutsuo Saito,
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ 3. The names of its contributors may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+ Any feedback is very welcome.
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+#include <stdio.h>
+#include "mt19937ar.h"
+
+/* Period parameters */
+#define N 624
+#define M 397
+#define MATRIX_A 0x9908b0dfUL /* constant vector a */
+#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
+#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
+
+static unsigned long mt[N]; /* the array for the state vector */
+static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
+
+/* initializes mt[N] with a seed */
+void init_genrand(unsigned long s)
+{
+ mt[0]= s & 0xffffffffUL;
+ for (mti=1; mti<N; mti++) {
+ mt[mti] =
+ (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
+ /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+ /* In the previous versions, MSBs of the seed affect */
+ /* only MSBs of the array mt[]. */
+ /* 2002/01/09 modified by Makoto Matsumoto */
+ mt[mti] &= 0xffffffffUL;
+ /* for >32 bit machines */
+ }
+}
+
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+void init_by_array(unsigned long init_key[], int key_length)
+{
+ int i, j, k;
+ init_genrand(19650218UL);
+ i=1; j=0;
+ k = (N>key_length ? N : key_length);
+ for (; k; k--) {
+ mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
+ + init_key[j] + j; /* non linear */
+ mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ i++; j++;
+ if (i>=N) { mt[0] = mt[N-1]; i=1; }
+ if (j>=key_length) j=0;
+ }
+ for (k=N-1; k; k--) {
+ mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
+ - i; /* non linear */
+ mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ i++;
+ if (i>=N) { mt[0] = mt[N-1]; i=1; }
+ }
+
+ mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
+}
+
+/* generates a random number on [0,0xffffffff]-interval */
+unsigned long genrand_int32(void)
+{
+ unsigned long y;
+ static unsigned long mag01[2]={0x0UL, MATRIX_A};
+ /* mag01[x] = x * MATRIX_A for x=0,1 */
+
+ if (mti >= N) { /* generate N words at one time */
+ int kk;
+
+ if (mti == N+1) /* if init_genrand() has not been called, */
+ init_genrand(5489UL); /* a default initial seed is used */
+
+ for (kk=0;kk<N-M;kk++) {
+ y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+ mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
+ }
+ for (;kk<N-1;kk++) {
+ y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+ mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
+ }
+ y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
+ mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
+
+ mti = 0;
+ }
+
+ y = mt[mti++];
+
+ /* Tempering */
+ y ^= (y >> 11);
+ y ^= (y << 7) & 0x9d2c5680UL;
+ y ^= (y << 15) & 0xefc60000UL;
+ y ^= (y >> 18);
+
+ return y;
+}
+
+/* generates a random number on [0,0x7fffffff]-interval */
+long genrand_int31(void)
+{
+ return (long)(genrand_int32()>>1);
+}
+
+/* generates a random number on [0,1]-real-interval */
+double genrand_real1(void)
+{
+ return genrand_int32()*(1.0/4294967295.0);
+ /* divided by 2^32-1 */
+}
+
+/* generates a random number on [0,1)-real-interval */
+double genrand_real2(void)
+{
+ return genrand_int32()*(1.0/4294967296.0);
+ /* divided by 2^32 */
+}
+
+/* generates a random number on (0,1)-real-interval */
+double genrand_real3(void)
+{
+ return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
+ /* divided by 2^32 */
+}
+
+/* generates a random number on [0,1) with 53-bit resolution*/
+double genrand_res53(void)
+{
+ unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
+ return(a*67108864.0+b)*(1.0/9007199254740992.0);
+}
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
diff --git a/mrbgems/mruby-random/src/mt19937ar.h b/mrbgems/mruby-random/src/mt19937ar.h
new file mode 100644
index 000000000..8b98b8a5b
--- /dev/null
+++ b/mrbgems/mruby-random/src/mt19937ar.h
@@ -0,0 +1,72 @@
+/*
+ A C-program for MT19937, with initialization improved 2002/1/26.
+ Coded by Takuji Nishimura and Makoto Matsumoto.
+
+ Before using, initialize the state by using init_genrand(seed)
+ or init_by_array(init_key, key_length).
+
+ Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ All rights reserved.
+ Copyright (C) 2005, Mutsuo Saito
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ 3. The names of its contributors may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+ Any feedback is very welcome.
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+/* initializes mt[N] with a seed */
+void init_genrand(unsigned long s);
+
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+void init_by_array(unsigned long init_key[], int key_length);
+
+/* generates a random number on [0,0xffffffff]-interval */
+unsigned long genrand_int32(void);
+
+/* generates a random number on [0,0x7fffffff]-interval */
+long genrand_int31(void);
+
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
+/* generates a random number on [0,1]-real-interval */
+double genrand_real1(void);
+
+/* generates a random number on [0,1)-real-interval */
+double genrand_real2(void);
+
+/* generates a random number on (0,1)-real-interval */
+double genrand_real3(void);
+
+/* generates a random number on [0,1) with 53-bit resolution*/
+double genrand_res53(void);
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
new file mode 100644
index 000000000..9b5858a76
--- /dev/null
+++ b/mrbgems/mruby-random/src/random.c
@@ -0,0 +1,140 @@
+/*
+** random.c - Random module
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include "mruby.h"
+#include "mruby/variable.h"
+#include "mt19937ar.h"
+
+#include <time.h>
+
+#define RAND_SEED_KEY "$mrb_ext_rand_seed"
+
+void mt_srand(unsigned long seed)
+{
+ init_genrand(seed);
+}
+
+unsigned long mt_rand()
+{
+ return genrand_int32();
+}
+
+double mt_rand_real()
+{
+ return genrand_real1();
+}
+
+mrb_value mrb_random_mt_srand(mrb_state *mrb, mrb_value seed)
+{
+ if (mrb_nil_p(seed)) {
+ seed = mrb_fixnum_value(time(NULL) + mt_rand());
+ if (mrb_fixnum(seed) < 0) {
+ seed = mrb_fixnum_value( 0 - mrb_fixnum(seed));
+ }
+ }
+
+ mt_srand((unsigned) mrb_fixnum(seed));
+
+ return seed;
+}
+
+mrb_value mrb_random_mt_rand(mrb_state *mrb, mrb_value max)
+{
+ mrb_value value;
+
+ if (mrb_fixnum(max) == 0) {
+ value = mrb_float_value(mt_rand_real());
+ } else {
+ value = mrb_fixnum_value(mt_rand() % mrb_fixnum(max));
+ }
+
+ return value;
+}
+
+static mrb_value mrb_random_rand(mrb_state *mrb, mrb_value self)
+{
+ mrb_value *argv;
+ mrb_int argc;
+ mrb_value max;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+
+ if (argc == 0) {
+ max = mrb_fixnum_value(0);
+ } else if (argc == 1) {
+ max = argv[0];
+ if (!mrb_nil_p(max) && !mrb_fixnum_p(max)) {
+ max = mrb_check_convert_type(mrb, max, MRB_TT_FIXNUM, "Fixnum", "to_int");
+ }
+ if (!mrb_nil_p(max) && mrb_fixnum(max) < 0) {
+ max = mrb_fixnum_value(0 - mrb_fixnum(max));
+ }
+
+ if (!mrb_fixnum_p(max)) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument type");
+ return mrb_nil_value();
+ }
+ } else {
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..1)", argc);
+ return mrb_nil_value();
+ }
+
+ mrb_value seed = mrb_gv_get(mrb, mrb_intern(mrb, RAND_SEED_KEY));
+ if (mrb_nil_p(seed))
+ mrb_random_mt_srand(mrb, mrb_nil_value());
+
+ return mrb_random_mt_rand(mrb, max);
+}
+
+static mrb_value mrb_random_srand(mrb_state *mrb, mrb_value self)
+{
+ mrb_int argc;
+ mrb_value *argv;
+ mrb_value seed;
+
+ mrb_get_args(mrb, "*", &argv, &argc);
+
+ if (argc == 0) {
+ seed = mrb_nil_value();
+ } else if (argc == 1) {
+ seed = argv[0];
+ if (!mrb_nil_p(seed) && !mrb_fixnum_p(seed)) {
+ seed = mrb_check_convert_type(mrb, seed, MRB_TT_FIXNUM, "Fixnum", "to_int");
+ }
+ if (!mrb_nil_p(seed) && mrb_fixnum(seed) < 0) {
+ seed = mrb_fixnum_value(0 - mrb_fixnum(seed));
+ }
+
+ if (!mrb_fixnum_p(seed)) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument type");
+ return mrb_nil_value();
+ }
+ } else {
+ mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 0..1)", argc);
+ return mrb_nil_value();
+ }
+
+ seed = mrb_random_mt_srand(mrb, seed);
+ mrb_value old_seed = mrb_gv_get(mrb, mrb_intern(mrb, RAND_SEED_KEY));
+ mrb_gv_set(mrb, mrb_intern(mrb, RAND_SEED_KEY), seed);
+
+ return old_seed;
+}
+
+void mrb_mruby_random_gem_init(mrb_state *mrb)
+{
+ struct RClass *random;
+
+ random = mrb_define_module(mrb, "Random");
+
+ mrb_define_class_method(mrb, random, "rand", mrb_random_rand, ARGS_ANY());
+ mrb_define_class_method(mrb, random, "srand", mrb_random_srand, ARGS_ANY());
+}
+
+void mrb_mruby_random_gem_final(mrb_state *mrb)
+{
+}
+
diff --git a/mrbgems/mruby-random/src/random.h b/mrbgems/mruby-random/src/random.h
new file mode 100644
index 000000000..3dc5d4e77
--- /dev/null
+++ b/mrbgems/mruby-random/src/random.h
@@ -0,0 +1,12 @@
+/*
+// random.h - Random module
+//
+// See Copyright Notice in mruby.h
+*/
+
+#ifndef RANDOM_H
+#define RANDOM_H
+
+void mrb_mruby_random_gem_init(mrb_state *mrb);
+
+#endif
diff --git a/src/array.c b/src/array.c
index bfdb1bb97..61b27a678 100644
--- a/src/array.c
+++ b/src/array.c
@@ -9,6 +9,7 @@
#include <string.h>
#include "mruby/string.h"
#include "mruby/class.h"
+#include "value_array.h"
/* SIZE_MAX is not supported by VC++. */
#ifndef SIZE_MAX
@@ -519,7 +520,7 @@ mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item)
ary_modify(mrb, a);
if (a->aux.capa < a->len + 1)
ary_expand_capa(mrb, a, a->len + 1);
- memmove(a->ptr + 1, a->ptr, sizeof(mrb_value)*a->len);
+ value_move(a->ptr + 1, a->ptr, a->len);
a->ptr[0] = item;
}
a->len++;
@@ -546,7 +547,7 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
if (len == 0) return self;
if (a->aux.capa < a->len + len)
ary_expand_capa(mrb, a, a->len + len);
- memmove(a->ptr + len, a->ptr, sizeof(mrb_value)*a->len);
+ value_move(a->ptr + len, a->ptr, a->len);
}
array_copy(a->ptr, vals, len);
a->len += len;
@@ -631,7 +632,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
ary_fill_with_nil(a->ptr + a->len, (int)(head - a->len));
}
else if (head < a->len) {
- memmove(a->ptr + head + argc, a->ptr + tail, sizeof(mrb_value)*(a->len - tail));
+ value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
}
for(i = 0; i < argc; i++) {
diff --git a/src/class.c b/src/class.c
index 63b9b39da..da898383d 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1354,7 +1354,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
mrb_value s = mrb_str_new(mrb, "#<", 2);
mrb_value v = mrb_iv_get(mrb, klass, mrb_intern2(mrb, "__attached__", 12));
- mrb_str_cat2(mrb, s, "Class:");
+ mrb_str_cat(mrb, s, "Class:", 6);
switch (mrb_type(v)) {
case MRB_TT_CLASS:
case MRB_TT_MODULE:
@@ -1365,7 +1365,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
mrb_str_append(mrb, s, mrb_any_to_s(mrb, v));
break;
}
- mrb_str_cat2(mrb, s, ">");
+ mrb_str_cat(mrb, s, ">", 1);
return s;
}
@@ -1803,6 +1803,7 @@ mrb_init_class(mrb_state *mrb)
mrb_define_method(mrb, cls, "new", mrb_instance_new, ARGS_ANY()); /* 15.2.3.3.3 */
mrb_define_method(mrb, cls, "inherited", mrb_bob_init, ARGS_REQ(1));
+ MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE);
mrb_define_method(mrb, mod, "class_variable_defined?", mrb_mod_cvar_defined, ARGS_REQ(1)); /* 15.2.2.4.16 */
mrb_define_method(mrb, mod, "class_variable_get", mrb_mod_cvar_get, ARGS_REQ(1)); /* 15.2.2.4.17 */
mrb_define_method(mrb, mod, "class_variable_set", mrb_mod_cvar_set, ARGS_REQ(2)); /* 15.2.2.4.18 */
diff --git a/src/error.c b/src/error.c
index 7cb6b53ef..f46887465 100644
--- a/src/error.c
+++ b/src/error.c
@@ -129,26 +129,26 @@ exc_inspect(mrb_state *mrb, mrb_value exc)
if (!mrb_nil_p(file) && !mrb_nil_p(line)) {
str = file;
- mrb_str_cat2(mrb, str, ":");
+ mrb_str_cat(mrb, str, ":", 1);
mrb_str_append(mrb, str, line);
- mrb_str_cat2(mrb, str, ": ");
+ mrb_str_cat(mrb, str, ": ", 2);
if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) {
mrb_str_append(mrb, str, mesg);
- mrb_str_cat2(mrb, str, " (");
+ mrb_str_cat(mrb, str, " (", 2);
}
- mrb_str_cat2(mrb, str, mrb_obj_classname(mrb, exc));
+ mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc));
if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) {
- mrb_str_cat2(mrb, str, ")");
+ mrb_str_cat(mrb, str, ")", 1);
}
}
else {
str = mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc));
if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) {
- mrb_str_cat2(mrb, str, ": ");
+ mrb_str_cat(mrb, str, ": ", 2);
mrb_str_append(mrb, str, mesg);
} else {
- mrb_str_cat2(mrb, str, ": ");
- mrb_str_cat2(mrb, str, mrb_obj_classname(mrb, exc));
+ mrb_str_cat(mrb, str, ": ", 2);
+ mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc));
}
}
return str;
diff --git a/src/hash.c b/src/hash.c
index 6976530e1..8de7b55c8 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -894,7 +894,7 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
ai = mrb_gc_arena_save(mrb);
- if (RSTRING_LEN(str) > 1) mrb_str_cat2(mrb, str, ", ");
+ if (RSTRING_LEN(str) > 1) mrb_str_cat(mrb, str, ", ", 2);
str2 = mrb_inspect(mrb, kh_key(h,k));
mrb_str_append(mrb, str, str2);
diff --git a/src/string.c b/src/string.c
index 97d53cd6c..165cdbccd 100644
--- a/src/string.c
+++ b/src/string.c
@@ -2548,7 +2548,7 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len)
}
mrb_value
-mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr)
+mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr)
{
return mrb_str_cat(mrb, str, ptr, strlen(ptr));
}
diff --git a/src/value_array.h b/src/value_array.h
new file mode 100644
index 000000000..cabd2426d
--- /dev/null
+++ b/src/value_array.h
@@ -0,0 +1,27 @@
+#ifndef MRB_VALUE_ARRAY_H__
+#define MRB_VALUE_ARRAY_H__
+
+#include "mruby.h"
+
+static inline void
+value_move(mrb_value *s1, const mrb_value *s2, size_t n)
+{
+ if (s1 > s2 && s1 < s2 + n)
+ {
+ s1 += n;
+ s2 += n;
+ while (n-- > 0) {
+ *--s1 = *--s2;
+ }
+ }
+ else if (s1 != s2) {
+ while (n-- > 0) {
+ *s1++ = *s2++;
+ }
+ }
+ else {
+ /* nothing to do. */
+ }
+}
+
+#endif /* MRB_VALUE_ARRAY_H__ */
diff --git a/src/variable.c b/src/variable.c
index 4345f49a7..df89397d7 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -525,10 +525,10 @@ inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
/* need not to show internal data */
if (RSTRING_PTR(str)[0] == '-') { /* first element */
RSTRING_PTR(str)[0] = '#';
- mrb_str_cat2(mrb, str, " ");
+ mrb_str_cat(mrb, str, " ", 1);
}
else {
- mrb_str_cat2(mrb, str, ", ");
+ mrb_str_cat(mrb, str, ", ", 2);
}
s = mrb_sym2name_len(mrb, sym, &len);
mrb_str_cat(mrb, str, s, len);
diff --git a/src/vm.c b/src/vm.c
index c18054a9c..7dd9d5d6d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -16,6 +16,7 @@
#include "mruby/class.h"
#include "mruby/numeric.h"
#include "error.h"
+#include "value_array.h"
#include <string.h>
#include <setjmp.h>
@@ -55,27 +56,6 @@ The value below allows about 60000 recursive calls in the simplest case. */
#endif
static inline void
-value_move(mrb_value *s1, const mrb_value *s2, size_t n)
-{
- if (s1 > s2 && s1 < s2 + n)
- {
- s1 += n;
- s2 += n;
- while (n-- > 0) {
- *--s1 = *--s2;
- }
- }
- else if (s1 != s2) {
- while (n-- > 0) {
- *s1++ = *s2++;
- }
- }
- else {
- /* nothing to do. */
- }
-}
-
-static inline void
stack_clear(mrb_value *from, size_t count)
{
const mrb_value mrb_value_zero = { { 0 } };
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-19 01:51:53 +0000