summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/mruby.h16
-rw-r--r--include/mruby/khash.h2
-rw-r--r--include/mruby/string.h8
-rw-r--r--mrbgems/mruby-enum-ext/mrblib/enum.rb18
-rw-r--r--mrbgems/mruby-enum-ext/test/enum.rb19
-rw-r--r--mrbgems/mruby-enumerator/test/enumerator.rb4
-rw-r--r--mrbgems/mruby-fiber/src/fiber.c26
-rw-r--r--mrbgems/mruby-fiber/test/fiber.rb40
-rw-r--r--mrbgems/mruby-object-ext/src/object.c5
-rw-r--r--mrbgems/mruby-struct/src/struct.c2
-rw-r--r--mrblib/enum.rb2
-rw-r--r--mrblib/kernel.rb2
-rw-r--r--src/array.c20
-rw-r--r--src/class.c4
-rw-r--r--src/codegen.c2
-rw-r--r--src/debug.c16
-rw-r--r--src/dump.c4
-rw-r--r--src/gc.c3
-rw-r--r--src/kernel.c4
-rw-r--r--src/load.c14
-rw-r--r--src/numeric.c6
-rw-r--r--src/parse.y4
-rw-r--r--src/string.c59
-rw-r--r--src/symbol.c10
-rw-r--r--src/vm.c6
25 files changed, 197 insertions, 99 deletions
diff --git a/include/mruby.h b/include/mruby.h
index 3c38308ab..ca75d2984 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -70,6 +70,7 @@ typedef struct {
enum mrb_fiber_state {
MRB_FIBER_CREATED = 0,
MRB_FIBER_RUNNING,
+ MRB_FIBER_RESUMING,
MRB_FIBER_SUSPENDED,
MRB_FIBER_TERMINATED,
};
@@ -244,12 +245,12 @@ mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
mrb_sym mrb_intern_cstr(mrb_state*,const char*);
-mrb_sym mrb_intern(mrb_state*,const char*,mrb_int);
-mrb_sym mrb_intern_static(mrb_state*,const char*,mrb_int);
-#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, (mrb_int)mrb_strlen_lit(lit))
+mrb_sym mrb_intern(mrb_state*,const char*,size_t);
+mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
mrb_sym mrb_intern_str(mrb_state*,mrb_value);
mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
-mrb_value mrb_check_intern(mrb_state*,const char*,mrb_int);
+mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
const char *mrb_sym2name(mrb_state*,mrb_sym);
const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*);
@@ -263,10 +264,10 @@ void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memory availa
struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
void mrb_free(mrb_state*, void*);
-mrb_value mrb_str_new(mrb_state *mrb, const char *p, mrb_int len);
+mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
mrb_value mrb_str_new_cstr(mrb_state*, const char*);
-mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len);
-#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), (mrb_int)mrb_strlen_lit(lit))
+mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
+#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
mrb_state* mrb_open(void);
mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
@@ -364,6 +365,7 @@ void mrb_print_error(mrb_state *mrb);
mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
+mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 1fbb569c3..a19505e91 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -209,7 +209,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
for (k = kh_begin(h); k != kh_end(h); k++) { \
if (kh_exist(h, k)) { \
k2 = kh_put_##name(mrb, h2, kh_key(h, k)); \
- if(kh_is_map) kh_value(h2, k2) = kh_value(h, k); \
+ if (kh_is_map) kh_value(h2, k2) = kh_value(h, k); \
} \
} \
return h2; \
diff --git a/include/mruby/string.h b/include/mruby/string.h
index d6ce88a9e..d19e0d493 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -65,8 +65,8 @@ mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
mrb_value mrb_string_type(mrb_state *mrb, mrb_value str);
mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
-mrb_value mrb_str_buf_new(mrb_state *mrb, mrb_int capa);
-mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len);
+mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
+mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr);
char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr);
@@ -81,9 +81,9 @@ mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
-mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len);
+mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr);
-#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, (mrb_int)mrb_strlen_lit(lit))
+#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
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);
diff --git a/mrbgems/mruby-enum-ext/mrblib/enum.rb b/mrbgems/mruby-enum-ext/mrblib/enum.rb
index 90f321596..e54e0de2e 100644
--- a/mrbgems/mruby-enum-ext/mrblib/enum.rb
+++ b/mrbgems/mruby-enum-ext/mrblib/enum.rb
@@ -208,4 +208,22 @@ module Enumerable
a
end
end
+
+ def count(v=NONE, &block)
+ count = 0
+ if block
+ self.each do |e|
+ count += 1 if block.call(e)
+ end
+ else
+ if v == NONE
+ self.each { count += 1 }
+ else
+ self.each do |e|
+ count += 1 if e == v
+ end
+ end
+ end
+ count
+ end
end
diff --git a/mrbgems/mruby-enum-ext/test/enum.rb b/mrbgems/mruby-enum-ext/test/enum.rb
index a7762231b..065ef7f5f 100644
--- a/mrbgems/mruby-enum-ext/test/enum.rb
+++ b/mrbgems/mruby-enum-ext/test/enum.rb
@@ -41,3 +41,22 @@ assert("Enumerable#group_by") do
assert_equal [1, 4], r[1]
assert_equal [2, 5], r[2]
end
+
+assert("Enumerable#sort_by") do
+ assert_equal ["car", "train", "bicycle"], %w{car bicycle train}.sort_by {|e| e.length}
+end
+
+assert("Enumerable#first") do
+ a = [1, 2, 3]
+ assert_equal 1, a.first
+ assert_equal [1, 2], a.first(2)
+ assert_equal [1, 2, 3], a.first(10)
+ assert_nil [].first
+end
+
+assert("Enumerable#count") do
+ a = [1, 2, 4, 2]
+ assert_equal 4, a.count
+ assert_equal 2, a.count(2)
+ assert_equal 3, a.count{|x| x % 2 == 0}
+end
diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb
index c7a0a3a9d..c2b4c09ab 100644
--- a/mrbgems/mruby-enumerator/test/enumerator.rb
+++ b/mrbgems/mruby-enumerator/test/enumerator.rb
@@ -438,6 +438,10 @@ assert 'Integral#times' do
assert_equal [0,1,2], c
end
+assert 'Enumerable#each_with_index' do
+ assert_equal [['a',0],['b',1],['c',2]], ['a','b','c'].each_with_index.to_a
+end
+
assert 'Enumerable#map' do
a = [1,2,3]
b = a.map
diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c
index a2ce52954..0a6e0cdd5 100644
--- a/mrbgems/mruby-fiber/src/fiber.c
+++ b/mrbgems/mruby-fiber/src/fiber.c
@@ -3,6 +3,8 @@
#include "mruby/class.h"
#include "mruby/proc.h"
+#define fiber_ptr(o) ((struct RFiber*)mrb_ptr(o))
+
#define FIBER_STACK_INIT_SIZE 64
#define FIBER_CI_INIT_SIZE 8
@@ -62,7 +64,7 @@ static mrb_value
fiber_init(mrb_state *mrb, mrb_value self)
{
static const struct mrb_context mrb_context_zero = { 0 };
- struct RFiber *f = (struct RFiber*)mrb_ptr(self);
+ struct RFiber *f = fiber_ptr(self);
struct mrb_context *c;
struct RProc *p;
mrb_callinfo *ci;
@@ -114,8 +116,9 @@ fiber_init(mrb_state *mrb, mrb_value self)
static struct mrb_context*
fiber_check(mrb_state *mrb, mrb_value fib)
{
- struct RFiber *f = (struct RFiber*)mrb_ptr(fib);
+ struct RFiber *f = fiber_ptr(fib);
+ mrb_assert(f->tt == MRB_TT_FIBER);
if (!f->cxt) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized Fiber");
}
@@ -161,13 +164,14 @@ fiber_resume(mrb_state *mrb, mrb_value self)
mrb_raise(mrb, E_ARGUMENT_ERROR, "can't cross C function boundary");
}
}
- if (c->status == MRB_FIBER_RUNNING) {
+ if (c->status == MRB_FIBER_RUNNING || c->status == MRB_FIBER_RESUMING) {
mrb_raise(mrb, E_RUNTIME_ERROR, "double resume");
}
if (c->status == MRB_FIBER_TERMINATED) {
mrb_raise(mrb, E_RUNTIME_ERROR, "resuming dead fiber");
}
mrb_get_args(mrb, "*", &a, &len);
+ mrb->c->status = MRB_FIBER_RESUMING;
if (c->status == MRB_FIBER_CREATED) {
mrb_value *b = c->stack+1;
mrb_value *e = b + len;
@@ -180,7 +184,6 @@ fiber_resume(mrb_state *mrb, mrb_value self)
if (c->prev->fib)
mrb_field_write_barrier(mrb, (struct RBasic*)c->fib, (struct RBasic*)c->prev->fib);
mrb_write_barrier(mrb, (struct RBasic*)c->fib);
- mrb->c->status = MRB_FIBER_SUSPENDED;
c->status = MRB_FIBER_RUNNING;
mrb->c = c;
@@ -192,7 +195,6 @@ fiber_resume(mrb_state *mrb, mrb_value self)
if (c->prev->fib)
mrb_field_write_barrier(mrb, (struct RBasic*)c->fib, (struct RBasic*)c->prev->fib);
mrb_write_barrier(mrb, (struct RBasic*)c->fib);
- mrb->c->status = MRB_FIBER_SUSPENDED;
c->status = MRB_FIBER_RUNNING;
mrb->c = c;
return fiber_result(mrb, a, len);
@@ -212,6 +214,19 @@ fiber_alive_p(mrb_state *mrb, mrb_value self)
return mrb_bool_value(c->status != MRB_FIBER_TERMINATED);
}
+static mrb_value
+fiber_eq(mrb_state *mrb, mrb_value self)
+{
+ mrb_value other;
+ mrb_get_args(mrb, "o", &other);
+
+ if (mrb_type(other) != MRB_TT_FIBER) {
+ return mrb_false_value();
+ }
+ return mrb_bool_value(fiber_ptr(self) == fiber_ptr(other));
+}
+
+
mrb_value
mrb_fiber_yield(mrb_state *mrb, int len, mrb_value *a)
{
@@ -286,6 +301,7 @@ mrb_mruby_fiber_gem_init(mrb_state* mrb)
mrb_define_method(mrb, c, "initialize", fiber_init, MRB_ARGS_NONE());
mrb_define_method(mrb, c, "resume", fiber_resume, MRB_ARGS_ANY());
mrb_define_method(mrb, c, "alive?", fiber_alive_p, MRB_ARGS_NONE());
+ mrb_define_method(mrb, c, "==", fiber_eq, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, c, "yield", fiber_yield, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "current", fiber_current, MRB_ARGS_NONE());
diff --git a/mrbgems/mruby-fiber/test/fiber.rb b/mrbgems/mruby-fiber/test/fiber.rb
index 216ad5572..c09b49925 100644
--- a/mrbgems/mruby-fiber/test/fiber.rb
+++ b/mrbgems/mruby-fiber/test/fiber.rb
@@ -17,6 +17,19 @@ assert('Fiber#alive?') {
r1 == true and r2 == false
}
+assert('Fiber#==') do
+ root = Fiber.current
+ assert_equal root, root
+ assert_equal root, Fiber.current
+ assert_false root != Fiber.current
+ f = Fiber.new {
+ assert_false root == Fiber.current
+ }
+ f.resume
+ assert_false f == root
+ assert_true f != root
+end
+
assert('Fiber.yield') {
f = Fiber.new{|x| Fiber.yield(x == 3)}
f.resume(3)
@@ -75,3 +88,30 @@ assert('Double resume of Fiber') do
assert_false f1.alive?
assert_false f2.alive?
end
+
+assert('Recursive resume of Fiber') do
+ f1, f2 = nil, nil
+ f1 = Fiber.new { assert_raise(RuntimeError) { f2.resume } }
+ f2 = Fiber.new {
+ f1.resume
+ Fiber.yield 0
+ }
+ f3 = Fiber.new {
+ f2.resume
+ }
+ assert_equal 0, f3.resume
+ f2.resume
+ assert_false f1.alive?
+ assert_false f2.alive?
+ assert_false f3.alive?
+end
+
+assert('Root fiber resume') do
+ root = Fiber.current
+ assert_raise(RuntimeError) { root.resume }
+ f = Fiber.new {
+ assert_raise(RuntimeError) { root.resume }
+ }
+ f.resume
+ assert_false f.alive?
+end
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
index 927a23d66..2bc9cbf4f 100644
--- a/mrbgems/mruby-object-ext/src/object.c
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -59,9 +59,6 @@ nil_to_i(mrb_state *mrb, mrb_value obj)
* k.instance_exec(5) {|x| @secret+x } #=> 104
*/
-mrb_value
-mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
-
static mrb_value
mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
{
@@ -87,7 +84,7 @@ mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
break;
}
- return mrb_yield_internal(mrb, blk, argc, argv, self, c);
+ return mrb_yield_with_class(mrb, blk, argc, argv, self, c);
}
void
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index 34db4c40f..f8c1d12da 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -382,7 +382,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass)
}
st = make_struct(mrb, name, rest, struct_class(mrb));
if (!mrb_nil_p(b)) {
- mrb_funcall(mrb, b, "call", 1, st);
+ mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(klass));
}
return st;
diff --git a/mrblib/enum.rb b/mrblib/enum.rb
index aacc35651..38c51aa21 100644
--- a/mrblib/enum.rb
+++ b/mrblib/enum.rb
@@ -108,6 +108,8 @@ module Enumerable
#
# ISO 15.3.2.2.5
def each_with_index(&block)
+ return to_enum :each_with_index unless block_given?
+
i = 0
self.each{|*val|
block.call(val.__svalue, i)
diff --git a/mrblib/kernel.rb b/mrblib/kernel.rb
index fd4dc04ac..81d7acf5d 100644
--- a/mrblib/kernel.rb
+++ b/mrblib/kernel.rb
@@ -45,7 +45,7 @@ module Kernel
while(true)
yield
end
- rescue => StopIteration
+ rescue StopIteration
nil
end
diff --git a/src/array.c b/src/array.c
index 90a608b70..5dba7c691 100644
--- a/src/array.c
+++ b/src/array.c
@@ -79,9 +79,9 @@ mrb_ary_new(mrb_state *mrb)
*
*/
static inline void
-array_copy(mrb_value *dst, const mrb_value *src, size_t size)
+array_copy(mrb_value *dst, const mrb_value *src, mrb_int size)
{
- size_t i;
+ mrb_int i;
for (i = 0; i < size; i++) {
dst[i] = src[i];
@@ -238,7 +238,9 @@ mrb_ary_s_create(mrb_state *mrb, mrb_value self)
int len;
mrb_get_args(mrb, "*", &vals, &len);
- return mrb_ary_new_from_values(mrb, len, vals);
+ mrb_assert(len <= MRB_INT_MAX); /* A rare case. So choosed assert() not raise(). */
+
+ return mrb_ary_new_from_values(mrb, (mrb_int)len, vals);
}
static void
@@ -641,7 +643,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
}
- for(i = 0; i < argc; i++) {
+ for (i = 0; i < argc; i++) {
*(a->ptr + head + i) = *(argv + i);
}
@@ -991,7 +993,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
char tail[] = { ']' };
/* check recursive */
- for(i=0; i<RARRAY_LEN(list); i++) {
+ for (i=0; i<RARRAY_LEN(list); i++) {
if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) {
return mrb_str_new_lit(mrb, "[...]");
}
@@ -1002,7 +1004,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
arystr = mrb_str_buf_new(mrb, 64);
mrb_str_buf_cat(mrb, arystr, head, sizeof(head));
- for(i=0; i<RARRAY_LEN(ary); i++) {
+ for (i=0; i<RARRAY_LEN(ary); i++) {
int ai = mrb_gc_arena_save(mrb);
if (i > 0) {
@@ -1047,7 +1049,7 @@ join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
mrb_value result, val, tmp;
/* check recursive */
- for(i=0; i<RARRAY_LEN(list); i++) {
+ for (i=0; i<RARRAY_LEN(list); i++) {
if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "recursive array join");
}
@@ -1057,13 +1059,13 @@ join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
result = mrb_str_buf_new(mrb, 64);
- for(i=0; i<RARRAY_LEN(ary); i++) {
+ for (i=0; i<RARRAY_LEN(ary); i++) {
if (i > 0 && !mrb_nil_p(sep)) {
mrb_str_buf_cat(mrb, result, RSTRING_PTR(sep), RSTRING_LEN(sep));
}
val = RARRAY_PTR(ary)[i];
- switch(mrb_type(val)) {
+ switch (mrb_type(val)) {
case MRB_TT_ARRAY:
ary_join:
val = join_ary(mrb, val, sep, list);
diff --git a/src/class.c b/src/class.c
index 1a55009e4..30d376648 100644
--- a/src/class.c
+++ b/src/class.c
@@ -943,8 +943,6 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
return mrb_class_instance_method_list(mrb, recur, c, 0);
}
-mrb_value mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
-
/* 15.2.2.4.35 */
/*
* call-seq:
@@ -966,7 +964,7 @@ mrb_mod_module_eval(mrb_state *mrb, mrb_value mod)
mrb_raise(mrb, E_NOTIMP_ERROR, "module_eval/class_eval with string not implemented");
}
c = mrb_class_ptr(mod);
- return mrb_yield_internal(mrb, b, 0, 0, mod, c);
+ return mrb_yield_with_class(mrb, b, 0, 0, mod, c);
}
mrb_value
diff --git a/src/codegen.c b/src/codegen.c
index 60da17f2b..317ce6232 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -2447,7 +2447,7 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
/* debug setting */
p->debug_start_pos = 0;
- if(p->filename) {
+ if (p->filename) {
mrb_debug_info_alloc(mrb, p->irep);
p->irep->filename = p->filename;
p->irep->lines = p->lines;
diff --git a/src/debug.c b/src/debug.c
index ae7705610..0af0f48f7 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -9,7 +9,7 @@ get_file(mrb_irep_debug_info *info, uint32_t pc)
mrb_irep_debug_info_file **ret;
int32_t count;
- if(pc >= info->pc_count) { return NULL; }
+ if (pc >= info->pc_count) { return NULL; }
/* get upper bound */
ret = info->files;
count = info->flen;
@@ -71,7 +71,7 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
return irep->lines? irep->lines[pc] : -1;
}
else if ((f = get_file(irep->debug_info, pc))) {
- switch(f->line_type) {
+ switch (f->line_type) {
case mrb_debug_line_ary:
mrb_assert(f->start_pos <= pc && pc < (f->start_pos + f->line_entry_count));
return f->lines.ary[pc - f->start_pos];
@@ -162,11 +162,11 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
ret->line_type = select_line_type(irep->lines + start_pos, end_pos - start_pos);
ret->lines.ptr = NULL;
- switch(ret->line_type) {
+ switch (ret->line_type) {
case mrb_debug_line_ary:
ret->line_entry_count = file_pc_count;
ret->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
- for(i = 0; i < file_pc_count; ++i) {
+ for (i = 0; i < file_pc_count; ++i) {
ret->lines.ary[i] = irep->lines[start_pos + i];
}
break;
@@ -176,8 +176,8 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
mrb_irep_debug_info_line m;
ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
ret->line_entry_count = 0;
- for(i = 0; i < file_pc_count; ++i) {
- if(irep->lines[start_pos + i] == prev_line) { continue; }
+ for (i = 0; i < file_pc_count; ++i) {
+ if (irep->lines[start_pos + i] == prev_line) { continue; }
ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
mrb, ret->lines.flat_map,
@@ -203,9 +203,9 @@ mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d)
{
uint32_t i;
- if(!d) { return; }
+ if (!d) { return; }
- for(i = 0; i < d->flen; ++i) {
+ for (i = 0; i < d->flen; ++i) {
mrb_assert(d->files[i]);
mrb_free(mrb, d->files[i]->lines.ptr);
mrb_free(mrb, d->files[i]);
diff --git a/src/dump.c b/src/dump.c
index 559d26030..f551b01c0 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -482,7 +482,7 @@ get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
/* lines */
ret += sizeof(uint32_t); /* entry count */
ret += sizeof(uint8_t); /* line type */
- switch(file->line_type) {
+ switch (file->line_type) {
case mrb_debug_line_ary:
ret += sizeof(uint16_t) * (size_t)(file->line_entry_count);
break;
@@ -575,7 +575,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
/* lines */
cur += uint32_to_bin(file->line_entry_count, cur);
cur += uint8_to_bin(file->line_type, cur);
- switch(file->line_type) {
+ switch (file->line_type) {
case mrb_debug_line_ary: {
uint32_t l;
for (l = 0; l < file->line_entry_count; ++l) {
diff --git a/src/gc.c b/src/gc.c
index e87ed3f06..81b234d6f 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -697,6 +697,9 @@ root_scan_phase(mrb_state *mrb)
mrb_gc_mark(mrb, (struct RBasic*)mrb->exc);
mark_context(mrb, mrb->root_c);
+ if (mrb->root_c->fib) {
+ mrb_gc_mark(mrb, (struct RBasic*)mrb->root_c->fib);
+ }
if (mrb->root_c != mrb->c) {
mark_context(mrb, mrb->c);
}
diff --git a/src/kernel.c b/src/kernel.c
index b805c3c47..f4ee6bd9d 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -455,8 +455,6 @@ mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
return self;
}
-mrb_value mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c);
-
/* 15.3.1.3.18 */
/*
* call-seq:
@@ -499,7 +497,7 @@ mrb_obj_instance_eval(mrb_state *mrb, mrb_value self)
c = mrb_class_ptr(cv);
break;
}
- return mrb_yield_internal(mrb, b, 0, 0, self, c);
+ return mrb_yield_with_class(mrb, b, 0, 0, self, c);
}
mrb_bool
diff --git a/src/load.c b/src/load.c
index badd76a1c..65c1695b0 100644
--- a/src/load.c
+++ b/src/load.c
@@ -285,7 +285,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
size_t record_size, i;
uint16_t f_idx;
- if(irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
+ if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info));
irep->debug_info->pc_count = irep->ilen;
@@ -320,12 +320,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
bin += sizeof(uint32_t);
file->line_type = (mrb_debug_line_type)bin_to_uint8(bin);
bin += sizeof(uint8_t);
- switch(file->line_type) {
+ switch (file->line_type) {
case mrb_debug_line_ary: {
uint32_t l;
file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count));
- for(l = 0; l < file->line_entry_count; ++l) {
+ for (l = 0; l < file->line_entry_count; ++l) {
file->lines.ary[l] = bin_to_uint16(bin);
bin += sizeof(uint16_t);
}
@@ -336,7 +336,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(
mrb, sizeof(mrb_irep_debug_info_line) * (size_t)(file->line_entry_count));
- for(l = 0; l < file->line_entry_count; ++l) {
+ for (l = 0; l < file->line_entry_count; ++l) {
file->lines.flat_map[l].start_pos = bin_to_uint32(bin);
bin += sizeof(uint32_t);
file->lines.flat_map[l].line = bin_to_uint16(bin);
@@ -352,7 +352,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
mrb_assert(diff >= 0);
mrb_assert((size_t)diff <= SIZE_MAX);
- if(record_size != (size_t)diff) {
+ if (record_size != (size_t)diff) {
return MRB_DUMP_GENERAL_FAILURE;
}
@@ -392,7 +392,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_boo
filenames_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)filenames_len);
- for(i = 0; i < filenames_len; ++i) {
+ for (i = 0; i < filenames_len; ++i) {
uint16_t f_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
if (alloc) {
@@ -703,7 +703,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
uint8_t* const bin = (uint8_t*)mrb_malloc(mrb, section_size);
fseek(fp, fpos, SEEK_SET);
- if(fread((char*)bin, section_size, 1, fp) != 1) {
+ if (fread((char*)bin, section_size, 1, fp) != 1) {
mrb_free(mrb, bin);
return NULL;
}
diff --git a/src/numeric.c b/src/numeric.c
index b0b80c523..6adfff344 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -962,8 +962,9 @@ fix_xor(mrb_state *mrb, mrb_value x)
#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
static mrb_value
-lshift(mrb_state *mrb, mrb_int val, size_t width)
+lshift(mrb_state *mrb, mrb_int val, mrb_int width)
{
+ mrb_assert(width >= 0);
if (width > NUMERIC_SHIFT_WIDTH_MAX) {
mrb_raisef(mrb, E_RANGE_ERROR, "width(%S) > (%S:MRB_INT_BIT-1)",
mrb_fixnum_value(width),
@@ -974,8 +975,9 @@ lshift(mrb_state *mrb, mrb_int val, size_t width)
}
static mrb_value
-rshift(mrb_int val, size_t width)
+rshift(mrb_int val, mrb_int width)
{
+ mrb_assert(width >= 0);
if (width >= NUMERIC_SHIFT_WIDTH_MAX) {
if (val < 0) {
val = -1;
diff --git a/src/parse.y b/src/parse.y
index 52bb06e73..8e7056b75 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -5315,8 +5315,8 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
p->filename = mrb_sym2name_len(p->mrb, sym, NULL);
p->lineno = (p->filename_table_length > 0)? 0 : 1;
- for(i = 0; i < p->filename_table_length; ++i) {
- if(p->filename_table[i] == sym) {
+ for (i = 0; i < p->filename_table_length; ++i) {
+ if (p->filename_table[i] == sym) {
p->current_filename_index = i;
return;
}
diff --git a/src/string.c b/src/string.c
index 0f057ef24..9d6e6a04b 100644
--- a/src/string.c
+++ b/src/string.c
@@ -20,7 +20,7 @@
#define STR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
#define STR_UNSET_EMBED_FLAG(s) ((s)->flags &= ~(MRB_STR_EMBED|MRB_STR_EMBED_LEN_MASK))
#define STR_SET_EMBED_LEN(s, n) do {\
- mrb_int tmp_n = (n);\
+ size_t tmp_n = (n);\
s->flags &= ~MRB_STR_EMBED_LEN_MASK;\
s->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
} while (0)
@@ -28,15 +28,16 @@
if (STR_EMBED_P(s)) {\
STR_SET_EMBED_LEN((s),(n));\
} else {\
- s->as.heap.len = (n);\
+ mrb_assert((n) <= MRB_INT_MAX);\
+ s->as.heap.len = (mrb_int)(n);\
}\
} while (0)
#define RSTRING_EMBED_LEN(s) \
- (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+ (size_t)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
#define STR_EMBED_LEN(s)\
- (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+ (size_t)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
#define STR_PTR(s) ((STR_EMBED_P(s)) ? (s)->as.ary : (s)->as.heap.ptr)
-#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (s)->as.heap.len)
+#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (size_t)(s)->as.heap.len)
const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
@@ -170,7 +171,7 @@ mrb_str_offset(mrb_state *mrb, mrb_value str, int pos)
}
static struct RString*
-str_new(mrb_state *mrb, const char *p, mrb_int len)
+str_new(mrb_state *mrb, const char *p, size_t len)
{
struct RString *s;
@@ -182,9 +183,12 @@ str_new(mrb_state *mrb, const char *p, mrb_int len)
memcpy(s->as.ary, p, len);
}
} else {
+ if (len >= MRB_INT_MAX) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
+ }
s->as.heap.len = len;
s->as.heap.aux.capa = len;
- s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
+ s->as.heap.ptr = (char *)mrb_malloc(mrb, len+1);
if (p) {
memcpy(s->as.heap.ptr, p, len);
}
@@ -213,12 +217,15 @@ mrb_str_new_empty(mrb_state *mrb, mrb_value str)
#endif
mrb_value
-mrb_str_buf_new(mrb_state *mrb, mrb_int capa)
+mrb_str_buf_new(mrb_state *mrb, size_t capa)
{
struct RString *s;
s = mrb_obj_alloc_string(mrb);
+ if (capa >= MRB_INT_MAX) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "string capacity size too big");
+ }
if (capa < MRB_STR_BUF_MIN_SIZE) {
capa = MRB_STR_BUF_MIN_SIZE;
}
@@ -231,17 +238,17 @@ mrb_str_buf_new(mrb_state *mrb, mrb_int capa)
}
static void
-str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, mrb_int len)
+str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
{
- mrb_int capa;
- mrb_int total;
+ size_t capa;
+ size_t total;
ptrdiff_t off = -1;
+ if (len == 0) return;
mrb_str_modify(mrb, s);
- if (ptr >= STR_PTR(s) && ptr <= STR_PTR(s) + STR_LEN(s)) {
+ if (ptr >= STR_PTR(s) && ptr <= STR_PTR(s) + (size_t)STR_LEN(s)) {
off = ptr - STR_PTR(s);
}
- if (len == 0) return;
if (STR_EMBED_P(s))
capa = RSTRING_EMBED_LEN_MAX;
@@ -249,7 +256,7 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, mrb_int len)
capa = s->as.heap.aux.capa;
if (STR_LEN(s) >= MRB_INT_MAX - (mrb_int)len) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big");
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
}
total = STR_LEN(s)+len;
if (capa <= total) {
@@ -271,7 +278,7 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, mrb_int len)
}
mrb_value
-mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len)
+mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len)
{
if (len == 0) return str;
str_buf_cat(mrb, mrb_str_ptr(str), ptr, len);
@@ -279,12 +286,9 @@ mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len)
}
mrb_value
-mrb_str_new(mrb_state *mrb, const char *p, mrb_int len)
+mrb_str_new(mrb_state *mrb, const char *p, size_t len)
{
struct RString *s;
- if (len < 0) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");
- }
s = str_new(mrb, p, len);
return mrb_obj_value(s);
@@ -305,28 +309,24 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p)
if (p) {
len = strlen(p);
- if ((mrb_int)len < 0) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big");
- }
}
else {
len = 0;
}
- s = str_new(mrb, p, (mrb_int)len);
+ s = str_new(mrb, p, len);
return mrb_obj_value(s);
}
mrb_value
-mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len)
+mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
{
struct RString *s;
- if (len < 0) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");
+ if (len >= MRB_INT_MAX) {
+ mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
}
-
s = mrb_obj_alloc_string(mrb);
s->as.heap.len = len;
s->as.heap.aux.capa = 0; /* nofree */
@@ -2453,11 +2453,8 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
}
mrb_value
-mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len)
+mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len)
{
- if ((mrb_int)len < 0) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");
- }
str_buf_cat(mrb, mrb_str_ptr(str), ptr, len);
return str;
}
diff --git a/src/symbol.c b/src/symbol.c
index deb6155d0..e5db48858 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -35,7 +35,7 @@ KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1)
KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal)
/* ------------------------------------------------------ */
static mrb_sym
-sym_intern(mrb_state *mrb, const char *name, mrb_int len, mrb_bool lit)
+sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name sname;
@@ -70,13 +70,13 @@ sym_intern(mrb_state *mrb, const char *name, mrb_int len, mrb_bool lit)
}
mrb_sym
-mrb_intern(mrb_state *mrb, const char *name, mrb_int len)
+mrb_intern(mrb_state *mrb, const char *name, size_t len)
{
return sym_intern(mrb, name, len, FALSE);
}
mrb_sym
-mrb_intern_static(mrb_state *mrb, const char *name, mrb_int len)
+mrb_intern_static(mrb_state *mrb, const char *name, size_t len)
{
return sym_intern(mrb, name, len, TRUE);
}
@@ -84,7 +84,7 @@ mrb_intern_static(mrb_state *mrb, const char *name, mrb_int len)
mrb_sym
mrb_intern_cstr(mrb_state *mrb, const char *name)
{
- return mrb_intern(mrb, name, (mrb_int)strlen(name));
+ return mrb_intern(mrb, name, strlen(name));
}
mrb_sym
@@ -94,7 +94,7 @@ mrb_intern_str(mrb_state *mrb, mrb_value str)
}
mrb_value
-mrb_check_intern(mrb_state *mrb, const char *name, mrb_int len)
+mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name sname = { 0 };
diff --git a/src/vm.c b/src/vm.c
index dc32ae7c8..2ed82a27b 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -487,7 +487,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
}
mrb_value
-mrb_yield_internal(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c)
+mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self, struct RClass *c)
{
struct RProc *p;
mrb_sym mid = mrb->c->ci->mid;
@@ -537,7 +537,7 @@ mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv)
{
struct RProc *p = mrb_proc_ptr(b);
- return mrb_yield_internal(mrb, b, argc, argv, p->env->stack[0], p->target_class);
+ return mrb_yield_with_class(mrb, b, argc, argv, p->env->stack[0], p->target_class);
}
mrb_value
@@ -545,7 +545,7 @@ mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg)
{
struct RProc *p = mrb_proc_ptr(b);
- return mrb_yield_internal(mrb, b, 1, &arg, p->env->stack[0], p->target_class);
+ return mrb_yield_with_class(mrb, b, 1, &arg, p->env->stack[0], p->target_class);
}
typedef enum {
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-18 22:12:29 +0000