summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--doc/mrbgems/README.md4
-rw-r--r--include/mruby.h18
-rw-r--r--include/mruby/string.h2
-rw-r--r--mrbgems/mruby-array-ext/mrblib/array.rb136
-rw-r--r--mrbgems/mruby-array-ext/test/array.rb50
-rw-r--r--mrbgems/mruby-fiber/src/fiber.c13
-rw-r--r--mrblib/array.rb7
-rw-r--r--mrblib/range.rb14
-rw-r--r--src/array.c21
-rw-r--r--src/backtrace.c6
-rw-r--r--src/class.c26
-rw-r--r--src/codegen.c7
-rw-r--r--src/debug.c2
-rw-r--r--src/dump.c42
-rw-r--r--src/kernel.c8
-rw-r--r--src/load.c12
-rw-r--r--src/string.c26
-rw-r--r--src/symbol.c3
-rw-r--r--src/vm.c18
19 files changed, 280 insertions, 135 deletions
diff --git a/doc/mrbgems/README.md b/doc/mrbgems/README.md
index 866198f79..863f7bd30 100644
--- a/doc/mrbgems/README.md
+++ b/doc/mrbgems/README.md
@@ -159,10 +159,6 @@ Its format is same as argument of method `MRuby::Build#gem`, expect that it can'
When a special version of depedency is required,
use `MRuby::Build#gem` in *build_config.rb* to override default gem.
-__ATTENTION:__
-The dependency system is currently (May 2013) under development and doesn't check
-or resolve dependencies!
-
In case your GEM has more complex build requirements you can use
the following options additionally inside of your GEM specification:
diff --git a/include/mruby.h b/include/mruby.h
index b74b1e466..9cf578836 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -194,7 +194,7 @@ void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_fun
void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
void mrb_undef_method(mrb_state*, struct RClass*, const char*);
void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
-mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, const mrb_value *argv);
+mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);
#define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv)
mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
@@ -242,7 +242,7 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
#define ARGS_ANY() MRB_ARGS_ANY()
#define ARGS_NONE() MRB_ARGS_NONE()
-int mrb_get_args(mrb_state *mrb, const char *format, ...);
+mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
/* `strlen` for character string literals (use with caution or `strlen` instead)
Adjacent string literals are concatenated in C/C++ in translation phase 6.
@@ -252,9 +252,9 @@ int mrb_get_args(mrb_state *mrb, const char *format, ...);
*/
#define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
-mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*, mrb_value);
+mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value);
mrb_sym mrb_intern_cstr(mrb_state*,const char*);
mrb_sym mrb_intern(mrb_state*,const char*,size_t);
mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
@@ -376,8 +376,8 @@ void mrb_print_error(mrb_state *mrb);
#define E_KEY_ERROR (mrb_class_get(mrb, "KeyError"))
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, const mrb_value *argv);
-mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
+mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
+mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const 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);
@@ -400,7 +400,7 @@ mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
/* fiber functions (you need to link mruby-fiber mrbgem to use) */
-mrb_value mrb_fiber_yield(mrb_state *mrb, int argc, const mrb_value *argv);
+mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
#define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
/* memory pool implementation */
@@ -415,8 +415,10 @@ void* mrb_alloca(mrb_state *mrb, size_t);
#ifdef MRB_DEBUG
#include <assert.h>
#define mrb_assert(p) assert(p)
+#define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
#else
#define mrb_assert(p) ((void)0)
+#define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
#endif
#if defined(__cplusplus)
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 3123b5b4f..e50e05e83 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -72,7 +72,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_value mrb_str_intern(mrb_state *mrb, mrb_value self);
-mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck);
+mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
diff --git a/mrbgems/mruby-array-ext/mrblib/array.rb b/mrbgems/mruby-array-ext/mrblib/array.rb
index 49d0db0d5..67f7e51a7 100644
--- a/mrbgems/mruby-array-ext/mrblib/array.rb
+++ b/mrbgems/mruby-array-ext/mrblib/array.rb
@@ -313,7 +313,7 @@ class Array
def fill(arg0=nil, arg1=nil, arg2=nil, &block)
if arg0 == nil && arg1 == nil && arg2 == nil && !block
- raise ArgumentError, "wrong number of arguments (0 for 1..3)"
+ raise ArgumentError, "wrong number of arguments (0 for 1..3)"
end
beg = len = 0
@@ -323,11 +323,13 @@ class Array
# ary.fill { |index| block } -> ary
beg = 0
len = self.size
- elsif arg0 != nil && arg0.respond_to?(:begin) && arg0.respond_to?(:end)
+ elsif arg0 != nil && arg0.kind_of?(Range)
# ary.fill(range) { |index| block } -> ary
beg = arg0.begin
beg += self.size if beg < 0
- len = arg0.end - beg + 1
+ len = arg0.end
+ len += self.size if len < 0
+ len += 1 unless arg0.exclude_end?
elsif arg0 != nil
# ary.fill(start [, length] ) { |index| block } -> ary
beg = arg0
@@ -342,20 +344,22 @@ class Array
if arg0 != nil && arg1 == nil && arg2 == nil
# ary.fill(obj) -> ary
beg = 0
- len = self.size
- elsif arg0 != nil && arg1 != nil && arg1.respond_to?(:begin) && arg1.respond_to?(:end)
- # ary.fill(obj, range ) -> ary
len = self.size
+ elsif arg0 != nil && arg1 != nil && arg1.kind_of?(Range)
+ # ary.fill(obj, range ) -> ary
beg = arg1.begin
- len = arg1.end - beg + 1
+ beg += self.size if beg < 0
+ len = arg1.end
+ len += self.size if len < 0
+ len += 1 unless arg1.exclude_end?
elsif arg0 != nil && arg1 != nil
# ary.fill(obj, start [, length]) -> ary
beg = arg1
beg += self.size if beg < 0
- if arg2 == nil
+ if arg2 == nil
len = self.size
else
- len = arg1 + arg2
+ len = beg + arg2
end
end
end
@@ -509,4 +513,118 @@ class Array
self[idx, 0] = args
self
end
+
+ ##
+ # call-seq:
+ # ary.bsearch {|x| block } -> elem
+ #
+ # By using binary search, finds a value from this array which meets
+ # the given condition in O(log n) where n is the size of the array.
+ #
+ # You can use this method in two use cases: a find-minimum mode and
+ # a find-any mode. In either case, the elements of the array must be
+ # monotone (or sorted) with respect to the block.
+ #
+ # In find-minimum mode (this is a good choice for typical use case),
+ # the block must return true or false, and there must be an index i
+ # (0 <= i <= ary.size) so that:
+ #
+ # - the block returns false for any element whose index is less than
+ # i, and
+ # - the block returns true for any element whose index is greater
+ # than or equal to i.
+ #
+ # This method returns the i-th element. If i is equal to ary.size,
+ # it returns nil.
+ #
+ # ary = [0, 4, 7, 10, 12]
+ # ary.bsearch {|x| x >= 4 } #=> 4
+ # ary.bsearch {|x| x >= 6 } #=> 7
+ # ary.bsearch {|x| x >= -1 } #=> 0
+ # ary.bsearch {|x| x >= 100 } #=> nil
+ #
+ # In find-any mode (this behaves like libc's bsearch(3)), the block
+ # must return a number, and there must be two indices i and j
+ # (0 <= i <= j <= ary.size) so that:
+ #
+ # - the block returns a positive number for ary[k] if 0 <= k < i,
+ # - the block returns zero for ary[k] if i <= k < j, and
+ # - the block returns a negative number for ary[k] if
+ # j <= k < ary.size.
+ #
+ # Under this condition, this method returns any element whose index
+ # is within i...j. If i is equal to j (i.e., there is no element
+ # that satisfies the block), this method returns nil.
+ #
+ # ary = [0, 4, 7, 10, 12]
+ # # try to find v such that 4 <= v < 8
+ # ary.bsearch {|x| 1 - (x / 4).truncate } #=> 4 or 7
+ # # try to find v such that 8 <= v < 10
+ # ary.bsearch {|x| 4 - (x / 2).truncate } #=> nil
+ #
+ # You must not mix the two modes at a time; the block must always
+ # return either true/false, or always return a number. It is
+ # undefined which value is actually picked up at each iteration.
+
+ def bsearch(&block)
+ return to_enum :bsearch unless block_given?
+
+ low = 0
+ high = self.size
+ satisfied = false
+ while low < high
+ mid = low + ((high - low) / 2).truncate
+ val = self[mid]
+ v = block.call(val)
+ if v.is_a?(Integer)
+ return val if v == 0
+ smaller = v < 0
+ elsif v == true
+ satisfied = true
+ smaller = true
+ elsif v == false || v == nil
+ smaller = false
+ end
+ if smaller
+ high = mid
+ else
+ low = mid + 1
+ end
+ end
+ return nil if low == self.size
+ return nil unless satisfied
+ self[low]
+ end
+
+ ##
+ # call-seq:
+ # ary.delete_if { |item| block } -> ary
+ # ary.delete_if -> Enumerator
+ #
+ # Deletes every element of +self+ for which block evaluates to +true+.
+ #
+ # The array is changed instantly every time the block is called, not after
+ # the iteration is over.
+ #
+ # See also Array#reject!
+ #
+ # If no block is given, an Enumerator is returned instead.
+ #
+ # scores = [ 97, 42, 75 ]
+ # scores.delete_if {|score| score < 80 } #=> [97]
+
+ def delete_if(&block)
+ return to_enum :delete_if unless block_given?
+
+ idx = 0
+ len = self.size
+ while idx < self.size do
+ if block.call(self[idx])
+ self.delete_at(idx)
+ else
+ idx += 1
+ end
+ end
+ self
+ end
end
diff --git a/mrbgems/mruby-array-ext/test/array.rb b/mrbgems/mruby-array-ext/test/array.rb
index d15ea2a64..47ffa00cf 100644
--- a/mrbgems/mruby-array-ext/test/array.rb
+++ b/mrbgems/mruby-array-ext/test/array.rb
@@ -125,14 +125,31 @@ end
assert("Array#fill") do
a = [ "a", "b", "c", "d" ]
assert_equal ["x", "x", "x", "x"], a.fill("x")
- assert_equal ["x", "x", "x", "w"], a.fill("w", -1)
+ assert_equal ["x", "x", "x", "w"], a.fill("w", -1)
assert_equal ["x", "x", "z", "z"], a.fill("z", 2, 2)
assert_equal ["y", "y", "z", "z"], a.fill("y", 0..1)
- assert_equal [0, 1, 4, 9], a.fill { |i| i*i }
+ assert_equal [0, 1, 4, 9], a.fill { |i| i*i }
assert_equal [0, 1, 8, 27], a.fill(-2) { |i| i*i*i }
assert_equal [0, 2, 3, 27], a.fill(1, 2) { |i| i+1 }
assert_equal [1, 2, 3, 27], a.fill(0..1) { |i| i+1 }
assert_raise(ArgumentError) { a.fill }
+
+ assert_equal([0, 1, 2, 3, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, -2, 1))
+ assert_equal([0, 1, 2, 3, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, -2, 3))
+ assert_equal([0, 1, 2, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3..4))
+ assert_equal([0, 1, 2, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3...4))
+ assert_equal([0, 1, -1, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2..-2))
+ assert_equal([0, 1, -1, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2...-2))
+ assert_equal([0, 1, 2, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(3..4){|i| i+10})
+ assert_equal([0, 1, 2, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(3...4){|i| i+10})
+ assert_equal([0, 1, 12, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(2..-2){|i| i+10})
+ assert_equal([0, 1, 12, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(2...-2){|i| i+10})
+
+ assert_equal [1, 2, 3, 4, 'x', 'x'], [1, 2, 3, 4, 5, 6].fill('x', -2..-1)
+ assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-1)
+ assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-2)
+ assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2..-2)
+ assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2..0)
end
assert("Array#reverse_each") do
@@ -206,3 +223,32 @@ assert("Array#insert") do
b = ["a", "b", "c", "d"]
assert_equal ["a", "b", "c", "d", nil, nil, 99], b.insert(6, 99)
end
+
+assert("Array#bsearch") do
+ # Find minimum mode
+ a = [0, 4, 7, 10, 12]
+ assert_include [4, 7], a.bsearch {|x| x >= 4 }
+ assert_equal 7, a.bsearch {|x| x >= 6 }
+ assert_equal 0, a.bsearch {|x| x >= -1 }
+ assert_nil a.bsearch {|x| x >= 100 }
+
+ # Find any mode
+ a = [0, 4, 7, 10, 12]
+ assert_include [4, 7], a.bsearch {|x| 1 - (x / 4).truncate }
+ assert_nil a.bsearch {|x| 4 - (x / 2).truncate }
+ assert_equal(nil, a.bsearch {|x| 1 })
+ assert_equal(nil, a.bsearch {|x| -1 })
+end
+
+assert("Array#delete_if") do
+ a = [1, 2, 3, 4, 5]
+ assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
+ assert_equal [1, 2, 3, 4, 5], a
+
+ a = [1, 2, 3, 4, 5]
+ assert_equal [], a.delete_if { true }
+ assert_equal [], a
+
+ a = [ 1, 2, 3, 4, 5 ]
+ assert_equal [1, 2, 3], a.delete_if { |val| val > 3 }
+end
diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c
index 12924c15c..927cccac7 100644
--- a/mrbgems/mruby-fiber/src/fiber.c
+++ b/mrbgems/mruby-fiber/src/fiber.c
@@ -126,7 +126,7 @@ fiber_check(mrb_state *mrb, mrb_value fib)
}
static mrb_value
-fiber_result(mrb_state *mrb, const mrb_value *a, int len)
+fiber_result(mrb_state *mrb, const mrb_value *a, mrb_int len)
{
if (len == 0) return mrb_nil_value();
if (len == 1) return a[0];
@@ -137,7 +137,7 @@ fiber_result(mrb_state *mrb, const mrb_value *a, int len)
#define MARK_CONTEXT_MODIFY(c) (c)->ci->target_class = NULL
static mrb_value
-fiber_switch(mrb_state *mrb, mrb_value self, int len, const mrb_value *a, mrb_bool resume)
+fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mrb_bool resume)
{
struct mrb_context *c = fiber_check(mrb, self);
mrb_callinfo *ci;
@@ -203,7 +203,8 @@ static mrb_value
fiber_resume(mrb_state *mrb, mrb_value self)
{
mrb_value *a;
- int len;
+ mrb_int len;
+
mrb_get_args(mrb, "*", &a, &len);
return fiber_switch(mrb, self, len, a, TRUE);
}
@@ -251,7 +252,7 @@ fiber_transfer(mrb_state *mrb, mrb_value self)
{
struct mrb_context *c = fiber_check(mrb, self);
mrb_value* a;
- int len;
+ mrb_int len;
mrb_get_args(mrb, "*", &a, &len);
@@ -271,7 +272,7 @@ fiber_transfer(mrb_state *mrb, mrb_value self)
}
mrb_value
-mrb_fiber_yield(mrb_state *mrb, int len, const mrb_value *a)
+mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a)
{
struct mrb_context *c = mrb->c;
mrb_callinfo *ci;
@@ -307,7 +308,7 @@ static mrb_value
fiber_yield(mrb_state *mrb, mrb_value self)
{
mrb_value *a;
- int len;
+ mrb_int len;
mrb_get_args(mrb, "*", &a, &len);
return mrb_fiber_yield(mrb, len, a);
diff --git a/mrblib/array.rb b/mrblib/array.rb
index 16e69d5d1..3218aa858 100644
--- a/mrblib/array.rb
+++ b/mrblib/array.rb
@@ -187,11 +187,8 @@ class Array
# internal method to convert multi-value to single value
def __svalue
- case self.size
- when 0
- return nil
- when 1
- self[0]
+ if self.size < 2
+ self.first
else
self
end
diff --git a/mrblib/range.rb b/mrblib/range.rb
index d587cab45..1ec9ac508 100644
--- a/mrblib/range.rb
+++ b/mrblib/range.rb
@@ -13,11 +13,23 @@ class Range
return to_enum :each unless block_given?
val = self.first
+ last = self.last
+
+ if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special
+ lim = last
+ lim += 1 unless exclude_end?
+ i = val
+ while i < lim
+ block.call(i)
+ i += 1
+ end
+ return self
+ end
+
unless val.respond_to? :succ
raise TypeError, "can't iterate"
end
- last = self.last
return self if (val <=> last) > 0
while((val <=> last) < 0)
diff --git a/src/array.c b/src/array.c
index c8e88e197..403a63807 100644
--- a/src/array.c
+++ b/src/array.c
@@ -235,12 +235,11 @@ static mrb_value
mrb_ary_s_create(mrb_state *mrb, mrb_value self)
{
mrb_value *vals;
- int len;
+ mrb_int len;
mrb_get_args(mrb, "*", &vals, &len);
- 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);
+ return mrb_ary_new_from_values(mrb, len, vals);
}
static void
@@ -409,7 +408,7 @@ static mrb_value
mrb_ary_push_m(mrb_state *mrb, mrb_value self)
{
mrb_value *argv;
- int len;
+ mrb_int len;
mrb_get_args(mrb, "*", &argv, &len);
while (len--) {
@@ -495,7 +494,7 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
{
struct RArray *a = mrb_ary_ptr(self);
mrb_value *vals;
- int len;
+ mrb_int len;
mrb_get_args(mrb, "*", &vals, &len);
if (ARY_SHARED_P(a)
@@ -825,18 +824,10 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
{
struct RArray *a = mrb_ary_ptr(self);
mrb_int size;
- mrb_value *vals;
- int len;
-
- mrb_get_args(mrb, "*", &vals, &len);
- if (len > 1) {
- mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
- }
- if (len == 0) return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
+ if (mrb_get_args(mrb, "|i", &size) == 0)
+ return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
- /* len == 1 */
- size = mrb_fixnum(*vals);
if (size < 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size");
}
diff --git a/src/backtrace.c b/src/backtrace.c
index c18a7cb95..e6a28d471 100644
--- a/src/backtrace.c
+++ b/src/backtrace.c
@@ -89,8 +89,8 @@ output_backtrace(mrb_state *mrb, mrb_int ciidx, mrb_code *pc0, output_stream_fun
else {
pc = pc0;
}
- filename = mrb_debug_get_filename(irep, pc - irep->iseq);
- lineno = mrb_debug_get_line(irep, pc - irep->iseq);
+ filename = mrb_debug_get_filename(irep, (uint32_t)(pc - irep->iseq));
+ lineno = mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq));
}
if (lineno == -1) continue;
if (ci->target_class == ci->proc->target_class)
@@ -169,7 +169,7 @@ mrb_get_backtrace(mrb_state *mrb)
mrb_value ary;
mrb_callinfo *ci = mrb->c->ci;
mrb_code *pc = ci->pc;
- mrb_int ciidx = ci - mrb->c->cibase - 1;
+ mrb_int ciidx = (mrb_int)(ci - mrb->c->cibase - 1);
if (ciidx < 0) ciidx = 0;
ary = mrb_ary_new(mrb);
diff --git a/src/class.c b/src/class.c
index caf5abf30..bb6a97c65 100644
--- a/src/class.c
+++ b/src/class.c
@@ -400,7 +400,7 @@ to_hash(mrb_state *mrb, mrb_value val)
S: String [mrb_value]
A: Array [mrb_value]
H: Hash [mrb_value]
- s: String [char*,int] Receive two arguments.
+ s: String [char*,mrb_int] Receive two arguments.
z: String [char*] NUL terminated string.
a: Array [mrb_value*,mrb_int] Receive two arguments.
f: Float [mrb_float]
@@ -409,11 +409,11 @@ to_hash(mrb_state *mrb, mrb_value val)
n: Symbol [mrb_sym]
d: Data [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified
&: Block [mrb_value]
- *: rest argument [mrb_value*,int] Receive the rest of the arguments as an array.
+ *: rest argument [mrb_value*,mrb_int] Receive the rest of the arguments as an array.
|: optional Next argument of '|' and later are optional.
?: optional given [mrb_bool] true if preceding argument (optional) is given.
*/
-int
+mrb_int
mrb_get_args(mrb_state *mrb, const char *format, ...)
{
char c;
@@ -519,10 +519,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
{
mrb_value ss;
char **ps = 0;
- int *pl = 0;
+ mrb_int *pl = 0;
ps = va_arg(ap, char**);
- pl = va_arg(ap, int*);
+ pl = va_arg(ap, mrb_int*);
if (i < argc) {
ss = to_str(mrb, *sp++);
*ps = RSTRING_PTR(ss);
@@ -683,10 +683,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
case '*':
{
mrb_value **var;
- int *pl;
+ mrb_int *pl;
var = va_arg(ap, mrb_value**);
- pl = va_arg(ap, int*);
+ pl = va_arg(ap, mrb_int*);
if (argc > i) {
*pl = argc-i;
if (*pl > 0) {
@@ -788,7 +788,7 @@ static mrb_value
mrb_mod_include(mrb_state *mrb, mrb_value klass)
{
mrb_value *argv;
- int argc, i;
+ mrb_int argc, i;
mrb_get_args(mrb, "*", &argv, &argc);
for (i=0; i<argc; i++) {
@@ -1082,7 +1082,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
{
mrb_value obj, blk;
mrb_value *argv;
- int argc;
+ mrb_int argc;
obj = mrb_instance_alloc(mrb, cv);
mrb_get_args(mrb, "*&", &argv, &argc, &blk);
@@ -1092,7 +1092,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
}
mrb_value
-mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, const mrb_value *argv)
+mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv)
{
mrb_value obj;
@@ -1183,7 +1183,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
{
mrb_sym name;
mrb_value *a;
- int alen;
+ mrb_int alen;
mrb_sym inspect;
mrb_value repr;
@@ -1498,7 +1498,7 @@ static mrb_value
mrb_mod_undef(mrb_state *mrb, mrb_value mod)
{
struct RClass *c = mrb_class_ptr(mod);
- int argc;
+ mrb_int argc;
mrb_value *argv;
mrb_get_args(mrb, "*", &argv, &argc);
@@ -1790,7 +1790,7 @@ remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
static mrb_value
mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
{
- int argc;
+ mrb_int argc;
mrb_value *argv;
mrb_get_args(mrb, "*", &argv, &argc);
diff --git a/src/codegen.c b/src/codegen.c
index f657c3a32..204ec64d0 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -719,7 +719,7 @@ attrsym(codegen_scope *s, mrb_sym a)
+ 1 /* '=' */
+ 1 /* '\0' */
);
- mrb_assert(len <= SIZE_MAX);
+ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
memcpy(name2, name, (size_t)len);
name2[len] = '=';
name2[len+1] = '\0';
@@ -2627,7 +2627,7 @@ static void
codedump(mrb_state *mrb, mrb_irep *irep)
{
#ifdef ENABLE_STDIO
- int i;
+ size_t i;
int ai;
mrb_code c;
@@ -2635,8 +2635,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d\n", irep,
irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen);
- mrb_assert(irep->ilen <= INT_MAX);
- for (i = 0; i < (int)(irep->ilen); i++) {
+ for (i = 0; i < irep->ilen; i++) {
ai = mrb_gc_arena_save(mrb);
printf("%03d ", i);
c = irep->iseq[i];
diff --git a/src/debug.c b/src/debug.c
index 0af0f48f7..ea1aa1ddc 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -95,7 +95,7 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
mrb_assert(f->lines.flat_map <= ret && ret < (f->lines.flat_map + f->line_entry_count));
/* check pc range */
mrb_assert(ret->start_pos <= pc &&
- pc < (((ret + 1 - f->lines.flat_map) < f->line_entry_count)
+ pc < (((uint32_t)(ret + 1 - f->lines.flat_map) < f->line_entry_count)
? (ret+1)->start_pos : irep->debug_info->pc_count));
return ret->line;
diff --git a/src/dump.c b/src/dump.c
index e3d1b779f..beaed7e7d 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -89,8 +89,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
{
mrb_int len = RSTRING_LEN(str);
- mrb_assert(len >= 0);
- mrb_assert(len <= SIZE_MAX);
+ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
size += (size_t)len;
}
break;
@@ -99,8 +98,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
{
int len;
len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no]));
- mrb_assert(len >= 0);
- mrb_assert(len <= SIZE_MAX);
+ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
size += (size_t)len;
}
break;
@@ -108,8 +106,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
case MRB_TT_STRING:
{
mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
- mrb_assert(len >= 0);
- mrb_assert(len <= SIZE_MAX);
+ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
size += (size_t)len;
}
break;
@@ -145,9 +142,9 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
char_ptr = RSTRING_PTR(str);
{
mrb_int tlen;
+
tlen = RSTRING_LEN(str);
- mrb_assert(tlen >= 0);
- mrb_assert(tlen <= INT16_MAX);
+ mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
len = (uint16_t)tlen;
}
break;
@@ -157,8 +154,7 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
int tlen;
tlen = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
- mrb_assert(tlen >= 0);
- mrb_assert(tlen <= INT16_MAX);
+ mrb_assert_int_fit(int, tlen, uint16_t, UINT16_MAX);
len = (uint16_t)tlen;
}
char_ptr = &char_buf[0];
@@ -169,9 +165,9 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
char_ptr = RSTRING_PTR(irep->pool[pool_no]);
{
mrb_int tlen;
+
tlen = RSTRING_LEN(irep->pool[pool_no]);
- mrb_assert(tlen >= 0);
- mrb_assert(tlen <= INT16_MAX);
+ mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
len = (uint16_t)tlen;
}
break;
@@ -225,7 +221,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
- mrb_assert(len <= UINT16_MAX);
+ mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
memcpy(cur, name, len); /* symbol name */
cur += (uint16_t)len;
@@ -318,7 +314,8 @@ write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin;
memcpy(header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(header->section_identify));
- mrb_assert(section_size <= UINT32_MAX);
+
+ mrb_assert_int_fit(size_t, section_size, uint32_t, UINT32_MAX);
uint32_to_bin((uint32_t)section_size, header->section_size);
memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version));
@@ -395,7 +392,7 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
} else {
filename_len = 0;
}
- mrb_assert(filename_len <= UINT16_MAX);
+ mrb_assert_int_fit(size_t, filename_len, uint16_t, UINT16_MAX);
cur += uint16_to_bin((uint16_t)filename_len, cur); /* filename size */
if (filename_len) {
@@ -404,7 +401,7 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
}
if (irep->lines) {
- mrb_assert(irep->ilen <= UINT32_MAX);
+ mrb_assert_int_fit(size_t, irep->ilen, uint32_t, UINT32_MAX);
cur += uint32_to_bin((uint32_t)(irep->ilen), cur); /* niseq */
for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */
@@ -415,12 +412,11 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
}
diff = cur - bin;
- mrb_assert(diff >= 0);
- mrb_assert(diff <= UINT32_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, uint32_t, UINT32_MAX);
uint32_to_bin((uint32_t)diff, bin); /* record size */
- mrb_assert(diff <= SIZE_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
return (size_t)diff;
}
@@ -568,8 +564,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
/* filename index */
filename_idx = find_filename_index(filenames, filenames_len,
file->filename_sym);
- mrb_assert(filename_idx >= 0);
- mrb_assert(filename_idx <= UINT16_MAX);
+ mrb_assert_int_fit(int, filename_idx, uint16_t, UINT16_MAX);
cur += uint16_to_bin((uint16_t)filename_idx, cur);
/* lines */
@@ -596,11 +591,10 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
}
ret = cur - bin;
- mrb_assert(ret >= 0);
- mrb_assert(ret <= UINT32_MAX);
+ mrb_assert_int_fit(ptrdiff_t, ret, uint32_t, UINT32_MAX);
uint32_to_bin(ret, bin);
- mrb_assert(ret <= SIZE_MAX);
+ mrb_assert_int_fit(ptrdiff_t, ret, size_t, SIZE_MAX);
return (size_t)ret;
}
diff --git a/src/kernel.c b/src/kernel.c
index 90007748c..4db8ad7ee 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -392,9 +392,9 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj)
}
static mrb_value
-mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
+mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
{
- int i;
+ mrb_int i;
if (argc == 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
@@ -438,7 +438,7 @@ static mrb_value
mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
{
mrb_value *argv;
- int argc;
+ mrb_int argc;
mrb_get_args(mrb, "*", &argv, &argc);
return mrb_obj_extend(mrb, argc, argv, self);
@@ -1014,7 +1014,7 @@ static mrb_value
obj_respond_to(mrb_state *mrb, mrb_value self)
{
mrb_value *argv;
- int argc;
+ mrb_int argc;
mrb_value mid, priv;
mrb_sym id, rtm_id;
mrb_bool respond_to_p = TRUE;
diff --git a/src/load.c b/src/load.c
index d97776a16..5e7245714 100644
--- a/src/load.c
+++ b/src/load.c
@@ -156,8 +156,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool all
irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen);
diff = src - bin;
- mrb_assert(diff >= 0);
- mrb_assert(diff <= SIZE_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*len = (size_t)diff;
return irep;
@@ -334,8 +333,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
}
diff = bin - start;
- mrb_assert(diff >= 0);
- mrb_assert(diff <= SIZE_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
if (record_size != (size_t)diff) {
return MRB_DUMP_GENERAL_FAILURE;
@@ -351,8 +349,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
}
diff = bin - start;
- mrb_assert(diff >= 0);
- mrb_assert(diff <= SIZE_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*record_len = (size_t)diff;
return MRB_DUMP_OK;
@@ -394,8 +391,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_boo
bin += len;
diff = bin - start;
- mrb_assert(diff >= 0);
- mrb_assert(diff <= UINT32_MAX);
+ mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
result = MRB_DUMP_GENERAL_FAILURE;
}
diff --git a/src/string.c b/src/string.c
index 1e3c7db3a..9c66ae18f 100644
--- a/src/string.c
+++ b/src/string.c
@@ -32,11 +32,11 @@
}\
} while (0)
#define RSTRING_EMBED_LEN(s) \
- (size_t)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+ (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
#define STR_EMBED_LEN(s)\
- (size_t)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+ (mrb_int)(((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) : (size_t)(s)->as.heap.len)
+#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (s)->as.heap.len)
const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
@@ -272,7 +272,7 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
ptr = STR_PTR(s) + off;
}
memcpy(STR_PTR(s) + STR_LEN(s), ptr, len);
- mrb_assert(total <= MRB_INT_MAX);
+ mrb_assert_int_fit(size_t, total, mrb_int, MRB_INT_MAX);
STR_SET_LEN(s, total);
STR_PTR(s)[total] = '\0'; /* sentinel */
}
@@ -1351,8 +1351,7 @@ static mrb_value
mrb_str_index_m(mrb_state *mrb, mrb_value str)
{
mrb_value *argv;
- int argc;
-
+ mrb_int argc;
mrb_value sub;
mrb_int pos;
@@ -1695,7 +1694,7 @@ static mrb_value
mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
{
mrb_value *argv;
- int argc;
+ mrb_int argc;
mrb_value sub;
mrb_value vpos;
mrb_int pos, len = RSTRING_LEN(str);
@@ -2104,7 +2103,7 @@ mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
}
mrb_value
-mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
+mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck)
{
char *s;
mrb_int len;
@@ -2150,16 +2149,9 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
static mrb_value
mrb_str_to_i(mrb_state *mrb, mrb_value self)
{
- mrb_value *argv;
- int argc;
- int base;
-
- mrb_get_args(mrb, "*", &argv, &argc);
- if (argc == 0)
- base = 10;
- else
- base = mrb_fixnum(argv[0]);
+ mrb_int base = 10;
+ mrb_get_args(mrb, "|i", &base);
if (base < 0) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %S", mrb_fixnum_value(base));
}
diff --git a/src/symbol.c b/src/symbol.c
index fd0b116bd..21bf1db7c 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -401,7 +401,8 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
sp = RSTRING_PTR(str);
RSTRING_PTR(str)[0] = ':';
memcpy(sp+1, name, len);
- if (!symname_p(name) || strlen(name) != len) {
+ mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
+ if (!symname_p(name) || strlen(name) != (size_t)len) {
str = mrb_str_dump(mrb, str);
sp = RSTRING_PTR(str);
sp[0] = ':';
diff --git a/src/vm.c b/src/vm.c
index 77910b1bf..717c927c8 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -288,7 +288,7 @@ ecall(mrb_state *mrb, int i)
#endif
mrb_value
-mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
+mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
{
mrb_sym mid = mrb_intern_cstr(mrb, name);
@@ -307,7 +307,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
else {
mrb_value argv[MRB_FUNCALL_ARGC_MAX];
va_list ap;
- int i;
+ mrb_int i;
if (argc > MRB_FUNCALL_ARGC_MAX) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" TO_STR(MRB_FUNCALL_ARGC_MAX) ")");
@@ -323,7 +323,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
}
mrb_value
-mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv, mrb_value blk)
+mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk)
{
mrb_value val;
@@ -413,7 +413,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, co
}
mrb_value
-mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv)
+mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv)
{
return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
}
@@ -442,7 +442,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
{
mrb_sym name;
mrb_value block, *argv, *regs;
- int argc, i, len;
+ mrb_int argc, i, len;
struct RProc *p;
struct RClass *c;
mrb_callinfo *ci;
@@ -487,7 +487,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
}
mrb_value
-mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv, mrb_value self, struct RClass *c)
+mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c)
{
struct RProc *p;
mrb_sym mid = mrb->c->ci->mid;
@@ -534,7 +534,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *arg
}
mrb_value
-mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv)
+mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv)
{
struct RProc *p = mrb_proc_ptr(b);
@@ -572,7 +572,7 @@ localjump_error(mrb_state *mrb, localjump_error_kind kind)
}
static void
-argnum_error(mrb_state *mrb, int num)
+argnum_error(mrb_state *mrb, mrb_int num)
{
mrb_value exc;
mrb_value str;
@@ -1114,7 +1114,7 @@ RETRY_TRY_BLOCK:
}
regs = mrb->c->stack;
regs[0] = m->env->stack[0];
- pc = m->body.irep->iseq;
+ pc = irep->iseq;
JUMP;
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-18 19:32:54 +0000