summaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-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
13 files changed, 76 insertions, 76 deletions
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-19 01:02:28 +0000