summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/mruby/hash.h8
-rw-r--r--include/mruby/irep.h6
-rw-r--r--include/mruby/proc.h4
-rw-r--r--include/mruby/string.h5
-rw-r--r--include/mruby/variable.h10
-rw-r--r--mrbgems/mruby-fiber/src/fiber.c2
-rw-r--r--mrbgems/mruby-string-utf8/src/string.c29
-rw-r--r--src/class.c4
-rw-r--r--src/codegen.c2
-rw-r--r--src/gc.c2
-rw-r--r--src/parse.y385
-rw-r--r--src/pool.c10
-rw-r--r--src/proc.c6
-rw-r--r--src/state.c2
-rw-r--r--src/string.c31
-rw-r--r--src/variable.c6
-rw-r--r--src/vm.c1
17 files changed, 268 insertions, 245 deletions
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index dbad3e1fc..5339312c6 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -21,7 +21,7 @@ struct RHash {
#define mrb_hash_value(p) mrb_obj_value((void*)(p))
MRB_API mrb_value mrb_hash_new_capa(mrb_state*, int);
-mrb_value mrb_hash_new(mrb_state *mrb);
+MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
@@ -43,9 +43,9 @@ MRB_API struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
#define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)
/* GC functions */
-MRB_API void mrb_gc_mark_hash(mrb_state*, struct RHash*);
-MRB_API size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
-MRB_API void mrb_gc_free_hash(mrb_state*, struct RHash*);
+void mrb_gc_mark_hash(mrb_state*, struct RHash*);
+size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
+void mrb_gc_free_hash(mrb_state*, struct RHash*);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 766431e2c..f4061bb54 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -49,9 +49,9 @@ typedef struct mrb_irep {
MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
-MRB_API void mrb_irep_free(mrb_state*, struct mrb_irep*);
-MRB_API void mrb_irep_incref(mrb_state*, struct mrb_irep*);
-MRB_API void mrb_irep_decref(mrb_state*, struct mrb_irep*);
+void mrb_irep_free(mrb_state*, struct mrb_irep*);
+void mrb_irep_incref(mrb_state*, struct mrb_irep*);
+void mrb_irep_decref(mrb_state*, struct mrb_irep*);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 9c25c9c46..6c2bf913c 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -54,10 +54,10 @@ struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
-MRB_API void mrb_proc_copy(struct RProc *a, struct RProc *b);
+void mrb_proc_copy(struct RProc *a, struct RProc *b);
/* implementation of #send method */
-mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+MRB_API mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
/* following functions are defined in mruby-proc-ext so please include it when using */
MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const mrb_value*);
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 0bd4cfc0f..5228dcbca 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -74,7 +74,7 @@ mrb_int mrb_str_strlen(mrb_state*, struct RString*);
#define MRB_STR_EMBED_LEN_MASK 0xf8
#define MRB_STR_EMBED_LEN_SHIFT 3
-MRB_API void mrb_gc_free_str(mrb_state*, struct RString*);
+void mrb_gc_free_str(mrb_state*, struct RString*);
MRB_API void mrb_str_modify(mrb_state*, struct RString*);
MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
MRB_API mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
@@ -107,6 +107,9 @@ mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
+void mrb_noregexp(mrb_state *mrb, mrb_value self);
+void mrb_regexp_check(mrb_state *mrb, mrb_value obj);
+
/* For backward compatibility */
#define mrb_str_cat2(mrb, str, ptr) mrb_str_cat_cstr(mrb, str, ptr)
#define mrb_str_buf_cat(mrb, str, ptr, len) mrb_str_cat(mrb, str, ptr, len)
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 0851a05bb..40b43972c 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -66,11 +66,11 @@ mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
mrb_sym mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer);
/* GC functions */
-MRB_API void mrb_gc_mark_gv(mrb_state*);
-MRB_API void mrb_gc_free_gv(mrb_state*);
-MRB_API void mrb_gc_mark_iv(mrb_state*, struct RObject*);
-MRB_API size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
-MRB_API void mrb_gc_free_iv(mrb_state*, struct RObject*);
+void mrb_gc_mark_gv(mrb_state*);
+void mrb_gc_free_gv(mrb_state*);
+void mrb_gc_mark_iv(mrb_state*, struct RObject*);
+size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
+void mrb_gc_free_iv(mrb_state*, struct RObject*);
#if defined(__cplusplus)
} /* extern "C" { */
diff --git a/mrbgems/mruby-fiber/src/fiber.c b/mrbgems/mruby-fiber/src/fiber.c
index 7b4ddfb11..de4901a87 100644
--- a/mrbgems/mruby-fiber/src/fiber.c
+++ b/mrbgems/mruby-fiber/src/fiber.c
@@ -291,7 +291,7 @@ fiber_transfer(mrb_state *mrb, mrb_value self)
return fiber_switch(mrb, self, len, a, FALSE);
}
-mrb_value
+MRB_API mrb_value
mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a)
{
struct mrb_context *c = mrb->c;
diff --git a/mrbgems/mruby-string-utf8/src/string.c b/mrbgems/mruby-string-utf8/src/string.c
index a1b779f95..b232df1c5 100644
--- a/mrbgems/mruby-string-utf8/src/string.c
+++ b/mrbgems/mruby-string-utf8/src/string.c
@@ -106,21 +106,6 @@ mrb_str_size(mrb_state *mrb, mrb_value str)
#define RSTRING_LEN_UTF8(s) mrb_utf8_strlen(s, -1)
-static mrb_value
-noregexp(mrb_state *mrb, mrb_value self)
-{
- mrb_raise(mrb, E_NOTIMP_ERROR, "Regexp class not implemented");
- return mrb_nil_value();
-}
-
-static void
-regexp_check(mrb_state *mrb, mrb_value obj)
-{
- if (mrb_regexp_p(mrb, obj)) {
- noregexp(mrb, obj);
- }
-}
-
static inline mrb_int
mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mrb_int n)
{
@@ -270,7 +255,7 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)
{
mrb_int idx;
- regexp_check(mrb, indx);
+ mrb_regexp_check(mrb, indx);
switch (mrb_type(indx)) {
case MRB_TT_FIXNUM:
idx = mrb_fixnum(indx);
@@ -315,7 +300,7 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str)
argc = mrb_get_args(mrb, "o|o", &a1, &a2);
if (argc == 2) {
- regexp_check(mrb, a1);
+ mrb_regexp_check(mrb, a1);
return str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
}
if (argc != 1) {
@@ -346,7 +331,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
sub = mrb_nil_value();
}
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
if (pos < 0) {
pos += RSTRING_LEN(str);
if (pos < 0) {
@@ -425,7 +410,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
if (pos < 0) {
pos += len;
if (pos < 0) {
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
return mrb_nil_value();
}
}
@@ -438,7 +423,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
else
sub = mrb_nil_value();
}
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
if (mrb_type(sub) == MRB_TT_FIXNUM) {
sub = mrb_fixnum_chr(mrb, sub);
@@ -548,7 +533,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
}
}
else {
- noregexp(mrb, str);
+ mrb_noregexp(mrb, str);
}
}
@@ -618,7 +603,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
beg = ptr - temp;
}
else {
- noregexp(mrb, str);
+ mrb_noregexp(mrb, str);
}
if (RSTRING_LEN(str) > 0 && (lim_p || RSTRING_LEN(str) > beg || lim < 0)) {
if (RSTRING_LEN(str) == beg) {
diff --git a/src/class.c b/src/class.c
index d3a2403f1..91ee711bc 100644
--- a/src/class.c
+++ b/src/class.c
@@ -958,7 +958,7 @@ mrb_mod_dummy_visibility(mrb_state *mrb, mrb_value mod)
return mod;
}
-mrb_value
+MRB_API mrb_value
mrb_singleton_class(mrb_state *mrb, mrb_value v)
{
struct RBasic *obj;
@@ -1409,7 +1409,7 @@ mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b)
* \param name1 a new name for the method
* \param name2 the original name of the method
*/
-void
+MRB_API void
mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2)
{
mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
diff --git a/src/codegen.c b/src/codegen.c
index f7d7625eb..031605eb7 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -3106,7 +3106,7 @@ mrb_codedump_all(mrb_state *mrb, struct RProc *proc)
codedump_recur(mrb, proc->body.irep);
}
-struct RProc*
+MRB_API struct RProc*
mrb_generate_code(mrb_state *mrb, parser_state *p)
{
codegen_scope *scope = scope_new(mrb, 0, 0);
diff --git a/src/gc.c b/src/gc.c
index 417375b34..4c50b11da 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -585,7 +585,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
}
}
-void
+MRB_API void
mrb_gc_mark(mrb_state *mrb, struct RBasic *obj)
{
if (obj == 0) return;
diff --git a/src/parse.y b/src/parse.y
index 0c0a9877f..7a3088f0e 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -62,6 +62,7 @@ typedef unsigned int stack_type;
#define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack)
#define SET_LINENO(c,n) ((c)->lineno = (n))
+#define NODE_LINENO(c,n) do {if (n) ((c)->lineno = (n)->lineno);} while (0)
#define sym(x) ((mrb_sym)(intptr_t)(x))
#define nsym(x) ((node*)(intptr_t)(x))
@@ -275,8 +276,9 @@ new_scope(parser_state *p, node *body)
static node*
new_begin(parser_state *p, node *body)
{
- if (body)
+ if (body) {
return list2((node*)NODE_BEGIN, body);
+ }
return cons((node*)NODE_BEGIN, 0);
}
@@ -391,14 +393,20 @@ new_self(parser_state *p)
static node*
new_call(parser_state *p, node *a, mrb_sym b, node *c)
{
- return list4((node*)NODE_CALL, a, nsym(b), c);
+ node *n = list4((node*)NODE_CALL, a, nsym(b), c);
+ NODE_LINENO(n, a);
+ return n;
}
/* (:fcall self mid args) */
static node*
new_fcall(parser_state *p, mrb_sym b, node *c)
{
- return list4((node*)NODE_FCALL, new_self(p), nsym(b), c);
+ node *n = new_self(p);
+ NODE_LINENO(n, c);
+ n = list4((node*)NODE_FCALL, n, nsym(b), c);
+ NODE_LINENO(n, c);
+ return n;
}
/* (:super . c) */
@@ -997,25 +1005,27 @@ heredoc_end(parser_state *p)
const struct vtable *vars;
}
-%token
+%token <num>
keyword_class
keyword_module
keyword_def
- keyword_undef
keyword_begin
+ keyword_if
+ keyword_unless
+ keyword_while
+ keyword_until
+ keyword_for
+
+%token
+ keyword_undef
keyword_rescue
keyword_ensure
keyword_end
- keyword_if
- keyword_unless
keyword_then
keyword_elsif
keyword_else
keyword_case
keyword_when
- keyword_while
- keyword_until
- keyword_for
keyword_break
keyword_next
keyword_redo
@@ -1155,6 +1165,7 @@ program : {
top_compstmt
{
p->tree = new_scope(p, $2);
+ NODE_LINENO(p->tree, $2);
}
;
@@ -1171,6 +1182,7 @@ top_stmts : none
| top_stmt
{
$$ = new_begin(p, $1);
+ NODE_LINENO($$, $1);
}
| top_stmts terms top_stmt
{
@@ -1202,6 +1214,7 @@ bodystmt : compstmt
{
if ($2) {
$$ = new_rescue(p, $1, $2, $3);
+ NODE_LINENO($$, $1);
}
else if ($3) {
yywarn(p, "else without rescue is useless");
@@ -1234,10 +1247,11 @@ stmts : none
| stmt
{
$$ = new_begin(p, $1);
+ NODE_LINENO($$, $1);
}
| stmts terms stmt
{
- $$ = push($1, newline_node($3));
+ $$ = push($1, newline_node($3));
}
| error stmt
{
@@ -1255,7 +1269,7 @@ stmt : keyword_alias fsym {p->lstate = EXPR_FNAME;} fsym
}
| stmt modifier_if expr_value
{
- $$ = new_if(p, cond($3), $1, 0);
+ $$ = new_if(p, cond($3), $1, 0);
}
| stmt modifier_unless expr_value
{
@@ -1887,6 +1901,7 @@ aref_args : none
| args trailer
{
$$ = $1;
+ NODE_LINENO($$, $1);
}
| args ',' assocs trailer
{
@@ -1895,6 +1910,7 @@ aref_args : none
| assocs trailer
{
$$ = cons(new_hash(p, $1), 0);
+ NODE_LINENO($$, $1);
}
;
@@ -1913,36 +1929,44 @@ opt_call_args : none
| args ','
{
$$ = cons($1,0);
+ NODE_LINENO($$, $1);
}
| args ',' assocs ','
{
$$ = cons(push($1, new_hash(p, $3)), 0);
+ NODE_LINENO($$, $1);
}
| assocs ','
{
$$ = cons(list1(new_hash(p, $1)), 0);
+ NODE_LINENO($$, $1);
}
;
call_args : command
{
$$ = cons(list1($1), 0);
+ NODE_LINENO($$, $1);
}
| args opt_block_arg
{
$$ = cons($1, $2);
+ NODE_LINENO($$, $1);
}
| assocs opt_block_arg
{
$$ = cons(list1(new_hash(p, $1)), $2);
+ NODE_LINENO($$, $1);
}
| args ',' assocs opt_block_arg
{
$$ = cons(push($1, new_hash(p, $3)), $4);
+ NODE_LINENO($$, $1);
}
| block_arg
{
$$ = cons(0, $1);
+ NODE_LINENO($$, $1);
}
;
@@ -1976,10 +2000,12 @@ opt_block_arg : ',' block_arg
args : arg_value
{
$$ = cons($1, 0);
+ NODE_LINENO($$, $1);
}
| tSTAR arg_value
{
$$ = cons(new_splat(p, $2), 0);
+ NODE_LINENO($$, $2);
}
| args ',' arg_value
{
@@ -2026,23 +2052,23 @@ primary : literal
}
| keyword_begin
{
- $<stack>1 = p->cmdarg_stack;
+ $<stack>$ = p->cmdarg_stack;
p->cmdarg_stack = 0;
}
bodystmt
keyword_end
{
- p->cmdarg_stack = $<stack>1;
+ p->cmdarg_stack = $<stack>2;
$$ = $3;
}
| tLPAREN_ARG
{
- $<stack>1 = p->cmdarg_stack;
+ $<stack>$ = p->cmdarg_stack;
p->cmdarg_stack = 0;
}
expr {p->lstate = EXPR_ENDARG;} rparen
{
- p->cmdarg_stack = $<stack>1;
+ p->cmdarg_stack = $<stack>2;
$$ = $3;
}
| tLPAREN_ARG {p->lstate = EXPR_ENDARG;} rparen
@@ -2064,10 +2090,12 @@ primary : literal
| tLBRACK aref_args ']'
{
$$ = new_array(p, $2);
+ NODE_LINENO($$, $2);
}
| tLBRACE assoc_list '}'
{
$$ = new_hash(p, $2);
+ NODE_LINENO($$, $2);
}
| keyword_return
{
@@ -2122,6 +2150,7 @@ primary : literal
keyword_end
{
$$ = new_if(p, cond($2), $4, $5);
+ SET_LINENO($$, $1);
}
| keyword_unless expr_value then
compstmt
@@ -2129,18 +2158,21 @@ primary : literal
keyword_end
{
$$ = new_unless(p, cond($2), $4, $5);
+ SET_LINENO($$, $1);
}
| keyword_while {COND_PUSH(1);} expr_value do {COND_POP();}
compstmt
keyword_end
{
$$ = new_while(p, cond($3), $6);
+ SET_LINENO($$, $1);
}
| keyword_until {COND_PUSH(1);} expr_value do {COND_POP();}
compstmt
keyword_end
{
$$ = new_until(p, cond($3), $6);
+ SET_LINENO($$, $1);
}
| keyword_case expr_value opt_terms
case_body
@@ -2160,11 +2192,9 @@ primary : literal
keyword_end
{
$$ = new_for(p, $2, $5, $8);
+ SET_LINENO($$, $1);
}
| keyword_class
- {
- $<num>$ = p->lineno;
- }
cpath superclass
{
if (p->in_def || p->in_single)
@@ -2174,14 +2204,11 @@ primary : literal
bodystmt
keyword_end
{
- $$ = new_class(p, $3, $4, $6);
- SET_LINENO($$, $<num>2);
- local_resume(p, $<nd>5);
+ $$ = new_class(p, $2, $3, $5);
+ SET_LINENO($$, $1);
+ local_resume(p, $<nd>4);
}
| keyword_class
- {
- $<num>$ = p->lineno;
- }
tLSHFT expr
{
$<num>$ = p->in_def;
@@ -2195,16 +2222,13 @@ primary : literal
bodystmt
keyword_end
{
- $$ = new_sclass(p, $4, $8);
- SET_LINENO($$, $<num>2);
- local_resume(p, $<nd>7->car);
- p->in_def = $<num>5;
- p->in_single = (int)(intptr_t)$<nd>7->cdr;
+ $$ = new_sclass(p, $3, $7);
+ SET_LINENO($$, $1);
+ local_resume(p, $<nd>6->car);
+ p->in_def = $<num>4;
+ p->in_single = (int)(intptr_t)$<nd>6->cdr;
}
| keyword_module
- {
- $<num>$ = p->lineno;
- }
cpath
{
if (p->in_def || p->in_single)
@@ -2214,42 +2238,50 @@ primary : literal
bodystmt
keyword_end
{
- $$ = new_module(p, $3, $5);
- SET_LINENO($$, $<num>2);
- local_resume(p, $<nd>4);
+ $$ = new_module(p, $2, $4);
+ SET_LINENO($$, $1);
+ local_resume(p, $<nd>3);
}
| keyword_def fname
{
+ $<stack>$ = p->cmdarg_stack;
+ p->cmdarg_stack = 0;
+ }
+ {
p->in_def++;
$<nd>$ = local_switch(p);
- $<stack>1 = p->cmdarg_stack;
- p->cmdarg_stack = 0;
}
f_arglist
bodystmt
keyword_end
{
- $$ = new_def(p, $2, $4, $5);
- local_resume(p, $<nd>3);
+ $$ = new_def(p, $2, $5, $6);
+ SET_LINENO($$, $1);
+ local_resume(p, $<nd>4);
p->in_def--;
- p->cmdarg_stack = $<stack>1;
+ p->cmdarg_stack = $<stack>3;
+ }
+ | keyword_def singleton dot_or_colon
+ {
+ p->lstate = EXPR_FNAME;
+ $<stack>$ = p->cmdarg_stack;
+ p->cmdarg_stack = 0;
}
- | keyword_def singleton dot_or_colon {p->lstate = EXPR_FNAME;} fname
+ fname
{
p->in_single++;
p->lstate = EXPR_ENDFN; /* force for args */
$<nd>$ = local_switch(p);
- $<stack>1 = p->cmdarg_stack;
- p->cmdarg_stack = 0;
}
f_arglist
bodystmt
keyword_end
{
$$ = new_sdef(p, $2, $5, $7, $8);
+ SET_LINENO($$, $1);
local_resume(p, $<nd>6);
p->in_single--;
- p->cmdarg_stack = $<stack>1;
+ p->cmdarg_stack = $<stack>4;
}
| keyword_break
{
@@ -3163,6 +3195,7 @@ assoc_list : none
assocs : assoc
{
$$ = list1($1);
+ NODE_LINENO($$, $1);
}
| assocs ',' assoc
{
@@ -5210,6 +5243,7 @@ parser_yylex(parser_state *p)
kw = mrb_reserved_word(tok(p), toklen(p));
if (kw) {
enum mrb_lex_state_enum state = p->lstate;
+ yylval.num = p->lineno;
p->lstate = kw->state;
if (state == EXPR_FNAME) {
yylval.id = intern_cstr(kw->name);
@@ -5324,7 +5358,7 @@ parser_update_cxt(parser_state *p, mrbc_context *cxt)
void mrb_codedump_all(mrb_state*, struct RProc*);
void mrb_parser_dump(mrb_state *mrb, node *tree, int offset);
-void
+MRB_API void
mrb_parser_parse(parser_state *p, mrbc_context *c)
{
struct mrb_jmpbuf buf;
@@ -5357,7 +5391,7 @@ mrb_parser_parse(parser_state *p, mrbc_context *c)
MRB_END_EXC(p->jmp);
}
-parser_state*
+MRB_API parser_state*
mrb_parser_new(mrb_state *mrb)
{
mrb_pool *pool;
@@ -5399,7 +5433,7 @@ mrb_parser_new(mrb_state *mrb)
return p;
}
-void
+MRB_API void
mrb_parser_free(parser_state *p) {
mrb_pool_close(p->pool);
}
@@ -5440,7 +5474,7 @@ mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*func)(struct mrb_parser
c->partial_data = data;
}
-void
+MRB_API void
mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
{
mrb_sym sym;
@@ -5468,7 +5502,7 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
p->filename_table[p->filename_table_length - 1] = sym;
}
-char const*
+MRB_API char const*
mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
if (idx >= p->filename_table_length) { return NULL; }
else {
@@ -5477,7 +5511,7 @@ mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
}
#ifdef ENABLE_STDIO
-parser_state*
+MRB_API parser_state*
mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
{
parser_state *p;
@@ -5492,7 +5526,7 @@ mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
}
#endif
-parser_state*
+MRB_API parser_state*
mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
{
parser_state *p;
@@ -5506,7 +5540,7 @@ mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
return p;
}
-parser_state*
+MRB_API parser_state*
mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
{
return mrb_parse_nstring(mrb, s, strlen(s), c);
@@ -5569,38 +5603,38 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
}
#ifdef ENABLE_STDIO
-mrb_value
+MRB_API mrb_value
mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
{
return load_exec(mrb, mrb_parse_file(mrb, f, c), c);
}
-mrb_value
+MRB_API mrb_value
mrb_load_file(mrb_state *mrb, FILE *f)
{
return mrb_load_file_cxt(mrb, f, NULL);
}
#endif
-mrb_value
+MRB_API mrb_value
mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
{
return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
}
-mrb_value
+MRB_API mrb_value
mrb_load_nstring(mrb_state *mrb, const char *s, int len)
{
return mrb_load_nstring_cxt(mrb, s, len, NULL);
}
-mrb_value
+MRB_API mrb_value
mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
{
return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
}
-mrb_value
+MRB_API mrb_value
mrb_load_string(mrb_state *mrb, const char *s)
{
return mrb_load_string_cxt(mrb, s, NULL);
@@ -5609,8 +5643,9 @@ mrb_load_string(mrb_state *mrb, const char *s)
#ifdef ENABLE_STDIO
static void
-dump_prefix(int offset)
+dump_prefix(node *tree, int offset)
{
+ printf("%05d ", tree->lineno);
while (offset--) {
putc(' ', stdout);
putc(' ', stdout);
@@ -5636,7 +5671,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
if (!tree) return;
again:
- dump_prefix(offset);
+ dump_prefix(tree, offset);
n = (int)(intptr_t)tree->car;
tree = tree->cdr;
switch (n) {
@@ -5648,7 +5683,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_RESCUE:
printf("NODE_RESCUE:\n");
if (tree->car) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
}
@@ -5656,22 +5691,22 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
if (tree->car) {
node *n2 = tree->car;
- dump_prefix(offset+1);
+ dump_prefix(n2, offset+1);
printf("rescue:\n");
while (n2) {
node *n3 = n2->car;
if (n3->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("handle classes:\n");
dump_recur(mrb, n3->car, offset+3);
}
if (n3->cdr->car) {
- dump_prefix(offset+2);
+ dump_prefix(n3, offset+2);
printf("exc_var:\n");
mrb_parser_dump(mrb, n3->cdr->car, offset+3);
}
if (n3->cdr->cdr->car) {
- dump_prefix(offset+2);
+ dump_prefix(n3, offset+2);
printf("rescue body:\n");
mrb_parser_dump(mrb, n3->cdr->cdr->car, offset+3);
}
@@ -5680,7 +5715,7 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
}
tree = tree->cdr;
if (tree->car) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("else:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
}
@@ -5688,10 +5723,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_ENSURE:
printf("NODE_ENSURE:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("ensure:\n");
mrb_parser_dump(mrb, tree->cdr->cdr, offset+2);
break;
@@ -5703,62 +5738,62 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_BLOCK:
block:
printf("NODE_BLOCK:\n");
- tree = tree->cdr;
- if (tree->car) {
- node *n = tree->car;
+ tree = tree->cdr;
+ if (tree->car) {
+ node *n = tree->car;
- if (n->car) {
- dump_prefix(offset+1);
- printf("mandatory args:\n");
- dump_recur(mrb, n->car, offset+2);
- }
- n = n->cdr;
- if (n->car) {
- dump_prefix(offset+1);
- printf("optional args:\n");
- {
- node *n2 = n->car;
+ if (n->car) {
+ dump_prefix(n, offset+1);
+ printf("mandatory args:\n");
+ dump_recur(mrb, n->car, offset+2);
+ }
+ n = n->cdr;
+ if (n->car) {
+ dump_prefix(n, offset+1);
+ printf("optional args:\n");
+ {
+ node *n2 = n->car;
- while (n2) {
- dump_prefix(offset+2);
- printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
- mrb_parser_dump(mrb, n2->car->cdr, 0);
- n2 = n2->cdr;
+ while (n2) {
+ dump_prefix(n2, offset+2);
+ printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
+ mrb_parser_dump(mrb, n2->car->cdr, 0);
+ n2 = n2->cdr;
+ }
}
}
+ n = n->cdr;
+ if (n->car) {
+ dump_prefix(n, offset+1);
+ printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
+ }
+ n = n->cdr;
+ if (n->car) {
+ dump_prefix(n, offset+1);
+ printf("post mandatory args:\n");
+ dump_recur(mrb, n->car, offset+2);
+ }
+ n = n->cdr;
+ if (n) {
+ dump_prefix(n, offset+1);
+ printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
+ }
}
- n = n->cdr;
- if (n->car) {
- dump_prefix(offset+1);
- printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
- }
- n = n->cdr;
- if (n->car) {
- dump_prefix(offset+1);
- printf("post mandatory args:\n");
- dump_recur(mrb, n->car, offset+2);
- }
- n = n->cdr;
- if (n) {
- dump_prefix(offset+1);
- printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
- }
- }
- dump_prefix(offset+1);
- printf("body:\n");
- mrb_parser_dump(mrb, tree->cdr->car, offset+2);
- break;
+ dump_prefix(tree, offset+1);
+ printf("body:\n");
+ mrb_parser_dump(mrb, tree->cdr->car, offset+2);
+ break;
case NODE_IF:
printf("NODE_IF:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("cond:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("then:\n");
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
if (tree->cdr->cdr->car) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("else:\n");
mrb_parser_dump(mrb, tree->cdr->cdr->car, offset+2);
}
@@ -5783,10 +5818,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
}
tree = tree->cdr;
while (tree) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("case:\n");
dump_recur(mrb, tree->car->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->car->cdr, offset+2);
tree = tree->cdr;
@@ -5795,47 +5830,47 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_WHILE:
printf("NODE_WHILE:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("cond:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
break;
case NODE_UNTIL:
printf("NODE_UNTIL:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("cond:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
break;
case NODE_FOR:
printf("NODE_FOR:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("var:\n");
{
node *n2 = tree->car;
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("pre:\n");
dump_recur(mrb, n2->car, offset+3);
}
n2 = n2->cdr;
if (n2) {
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("rest:\n");
mrb_parser_dump(mrb, n2->car, offset+3);
}
n2 = n2->cdr;
if (n2) {
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("post:\n");
dump_recur(mrb, n2->car, offset+3);
}
@@ -5843,11 +5878,11 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
}
}
tree = tree->cdr;
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("in:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
tree = tree->cdr;
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("do:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
break;
@@ -5859,9 +5894,9 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
mrb_bool first_lval = TRUE;
if (n2 && (n2->car || n2->cdr)) {
- dump_prefix(offset+1);
+ dump_prefix(n2, offset+1);
printf("local variables:\n");
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
while (n2) {
if (n2->car) {
if (!first_lval) printf(", ");
@@ -5881,17 +5916,17 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_CALL:
printf("NODE_CALL:\n");
mrb_parser_dump(mrb, tree->car, offset+1);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("method='%s' (%d)\n",
mrb_sym2name(mrb, sym(tree->cdr->car)),
(int)(intptr_t)tree->cdr->car);
tree = tree->cdr->cdr->car;
if (tree) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("args:\n");
dump_recur(mrb, tree->car, offset+2);
if (tree->cdr) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("block:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
}
@@ -5913,13 +5948,13 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_COLON2:
printf("NODE_COLON2:\n");
mrb_parser_dump(mrb, tree->car, offset+1);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree->cdr)));
break;
case NODE_COLON3:
printf("NODE_COLON3:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree)));
break;
@@ -5931,10 +5966,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_HASH:
printf("NODE_HASH:\n");
while (tree) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("key:\n");
mrb_parser_dump(mrb, tree->car->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("value:\n");
mrb_parser_dump(mrb, tree->car->cdr, offset+2);
tree = tree->cdr;
@@ -5948,33 +5983,33 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_ASGN:
printf("NODE_ASGN:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("lhs:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("rhs:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
break;
case NODE_MASGN:
printf("NODE_MASGN:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("mlhs:\n");
{
node *n2 = tree->car;
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(tree, offset+2);
printf("pre:\n");
dump_recur(mrb, n2->car, offset+3);
}
n2 = n2->cdr;
if (n2) {
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("rest:\n");
if (n2->car == (node*)-1) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("(empty)\n");
}
else {
@@ -5984,25 +6019,25 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
n2 = n2->cdr;
if (n2) {
if (n2->car) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("post:\n");
dump_recur(mrb, n2->car, offset+3);
}
}
}
}
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("rhs:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
break;
case NODE_OP_ASGN:
printf("NODE_OP_ASGN:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("lhs:\n");
mrb_parser_dump(mrb, tree->car, offset+2);
tree = tree->cdr;
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("op='%s' (%d)\n", mrb_sym2name(mrb, sym(tree->car)), (int)(intptr_t)tree->car);
tree = tree->cdr;
mrb_parser_dump(mrb, tree->car, offset+1);
@@ -6011,11 +6046,11 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_SUPER:
printf("NODE_SUPER:\n");
if (tree) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("args:\n");
dump_recur(mrb, tree->car, offset+2);
if (tree->cdr) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("block:\n");
mrb_parser_dump(mrb, tree->cdr, offset+2);
}
@@ -6076,10 +6111,10 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_MATCH:
printf("NODE_MATCH:\n");
- dump_prefix(offset + 1);
+ dump_prefix(tree, offset + 1);
printf("lhs:\n");
mrb_parser_dump(mrb, tree->car, offset + 2);
- dump_prefix(offset + 1);
+ dump_prefix(tree, offset + 1);
printf("rhs:\n");
mrb_parser_dump(mrb, tree->cdr, offset + 2);
break;
@@ -6139,9 +6174,9 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_DREGX:
printf("NODE_DREGX\n");
dump_recur(mrb, tree->car, offset+1);
- dump_prefix(offset);
+ dump_prefix(tree, offset);
printf("tail: %s\n", (char*)tree->cdr->cdr->car);
- dump_prefix(offset);
+ dump_prefix(tree, offset);
printf("opt: %s\n", (char*)tree->cdr->cdr->cdr);
break;
@@ -6186,24 +6221,24 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_CLASS:
printf("NODE_CLASS:\n");
if (tree->car->car == (node*)0) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
else if (tree->car->car == (node*)1) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
else {
mrb_parser_dump(mrb, tree->car->car, offset+1);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
if (tree->cdr->car) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("super:\n");
mrb_parser_dump(mrb, tree->cdr->car, offset+2);
}
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->cdr->cdr->car->cdr, offset+2);
break;
@@ -6211,19 +6246,19 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_MODULE:
printf("NODE_MODULE:\n");
if (tree->car->car == (node*)0) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
else if (tree->car->car == (node*)1) {
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
else {
mrb_parser_dump(mrb, tree->car->car, offset+1);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
}
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
break;
@@ -6231,14 +6266,14 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
case NODE_SCLASS:
printf("NODE_SCLASS:\n");
mrb_parser_dump(mrb, tree->car, offset+1);
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("body:\n");
mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
break;
case NODE_DEF:
printf("NODE_DEF:\n");
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf("%s\n", mrb_sym2name(mrb, sym(tree->car)));
tree = tree->cdr;
{
@@ -6246,9 +6281,9 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
mrb_bool first_lval = TRUE;
if (n2 && (n2->car || n2->cdr)) {
- dump_prefix(offset+1);
+ dump_prefix(n2, offset+1);
printf("local variables:\n");
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
while (n2) {
if (n2->car) {
if (!first_lval) printf(", ");
@@ -6265,19 +6300,19 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
node *n = tree->car;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("mandatory args:\n");
dump_recur(mrb, n->car, offset+2);
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("optional args:\n");
{
node *n2 = n->car;
while (n2) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
mrb_parser_dump(mrb, n2->car->cdr, 0);
n2 = n2->cdr;
@@ -6286,18 +6321,18 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("post mandatory args:\n");
dump_recur(mrb, n->car, offset+2);
}
n = n->cdr;
if (n) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
}
}
@@ -6308,26 +6343,26 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
printf("NODE_SDEF:\n");
mrb_parser_dump(mrb, tree->car, offset+1);
tree = tree->cdr;
- dump_prefix(offset+1);
+ dump_prefix(tree, offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(tree->car)));
tree = tree->cdr->cdr;
if (tree->car) {
node *n = tree->car;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("mandatory args:\n");
dump_recur(mrb, n->car, offset+2);
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("optional args:\n");
{
node *n2 = n->car;
while (n2) {
- dump_prefix(offset+2);
+ dump_prefix(n2, offset+2);
printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
mrb_parser_dump(mrb, n2->car->cdr, 0);
n2 = n2->cdr;
@@ -6336,18 +6371,18 @@ mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
}
n = n->cdr;
if (n->car) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("post mandatory args:\n");
dump_recur(mrb, n->car, offset+2);
}
n = n->cdr;
if (n) {
- dump_prefix(offset+1);
+ dump_prefix(n, offset+1);
printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
}
}
diff --git a/src/pool.c b/src/pool.c
index ffddd2552..60670ad4a 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -47,7 +47,7 @@ struct mrb_pool {
# define ALIGN_PADDING(x) (0)
#endif
-mrb_pool*
+MRB_API mrb_pool*
mrb_pool_open(mrb_state *mrb)
{
mrb_pool *pool = (mrb_pool *)mrb_malloc_simple(mrb, sizeof(mrb_pool));
@@ -60,7 +60,7 @@ mrb_pool_open(mrb_state *mrb)
return pool;
}
-void
+MRB_API void
mrb_pool_close(mrb_pool *pool)
{
struct mrb_pool_page *page, *tmp;
@@ -91,7 +91,7 @@ page_alloc(mrb_pool *pool, size_t len)
return page;
}
-void*
+MRB_API void*
mrb_pool_alloc(mrb_pool *pool, size_t len)
{
struct mrb_pool_page *page;
@@ -119,7 +119,7 @@ mrb_pool_alloc(mrb_pool *pool, size_t len)
return page->last;
}
-mrb_bool
+MRB_API mrb_bool
mrb_pool_can_realloc(mrb_pool *pool, void *p, size_t len)
{
struct mrb_pool_page *page;
@@ -140,7 +140,7 @@ mrb_pool_can_realloc(mrb_pool *pool, void *p, size_t len)
return FALSE;
}
-void*
+MRB_API void*
mrb_pool_realloc(mrb_pool *pool, void *p, size_t oldlen, size_t newlen)
{
struct mrb_pool_page *page;
diff --git a/src/proc.c b/src/proc.c
index 0b776ea80..f4fc2e310 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -41,7 +41,7 @@ closure_setup(mrb_state *mrb, struct RProc *p, int nlocals)
if (!mrb->c->ci->env) {
e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)mrb->c->ci->proc->env);
- MRB_ENV_STACK_LEN(e) = (unsigned int)nlocals+1; /* add space for receiver */
+ MRB_ENV_STACK_LEN(e) = (unsigned int)nlocals;
e->mid = mrb->c->ci->mid;
e->cioff = mrb->c->ci - mrb->c->cibase;
e->stack = mrb->c->stack;
@@ -62,7 +62,7 @@ mrb_closure_new(mrb_state *mrb, mrb_irep *irep)
return p;
}
-struct RProc *
+MRB_API struct RProc *
mrb_proc_new_cfunc(mrb_state *mrb, mrb_func_t func)
{
struct RProc *p;
@@ -84,7 +84,7 @@ mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
return p;
}
-void
+MRB_API void
mrb_proc_copy(struct RProc *a, struct RProc *b)
{
a->flags = b->flags;
diff --git a/src/state.c b/src/state.c
index 8d6993b6f..2efd34334 100644
--- a/src/state.c
+++ b/src/state.c
@@ -256,7 +256,7 @@ mrb_close(mrb_state *mrb)
mrb_free(mrb, mrb);
}
-mrb_irep*
+MRB_API mrb_irep*
mrb_add_irep(mrb_state *mrb)
{
static const mrb_irep mrb_irep_zero = { 0 };
diff --git a/src/string.c b/src/string.c
index a0a069c06..84e92df37 100644
--- a/src/string.c
+++ b/src/string.c
@@ -393,7 +393,7 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
*
* Returns a new string object containing a copy of <i>str</i>.
*/
-mrb_value
+MRB_API mrb_value
mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b)
{
struct RString *s = mrb_str_ptr(a);
@@ -615,7 +615,7 @@ mrb_str_equal_m(mrb_state *mrb, mrb_value str1)
return mrb_bool_value(mrb_str_equal(mrb, str1, str2));
}
/* ---------------------------------- */
-mrb_value
+MRB_API mrb_value
mrb_str_to_str(mrb_state *mrb, mrb_value str)
{
mrb_value s;
@@ -637,18 +637,17 @@ mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr)
return RSTRING_PTR(str);
}
-static mrb_value
-noregexp(mrb_state *mrb, mrb_value self)
+void
+mrb_noregexp(mrb_state *mrb, mrb_value self)
{
mrb_raise(mrb, E_NOTIMP_ERROR, "Regexp class not implemented");
- return mrb_nil_value();
}
-static void
-regexp_check(mrb_state *mrb, mrb_value obj)
+void
+mrb_regexp_check(mrb_state *mrb, mrb_value obj)
{
if (mrb_regexp_p(mrb, obj)) {
- noregexp(mrb, obj);
+ mrb_noregexp(mrb, obj);
}
}
@@ -738,7 +737,7 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)
{
mrb_int idx;
- regexp_check(mrb, indx);
+ mrb_regexp_check(mrb, indx);
switch (mrb_type(indx)) {
case MRB_TT_FIXNUM:
idx = mrb_fixnum(indx);
@@ -820,7 +819,7 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str)
argc = mrb_get_args(mrb, "o|o", &a1, &a2);
if (argc == 2) {
- regexp_check(mrb, a1);
+ mrb_regexp_check(mrb, a1);
return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
}
if (argc != 1) {
@@ -1159,7 +1158,7 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
return mrb_obj_value(s);
}
-mrb_value
+MRB_API mrb_value
mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
{
if (len < 0) return mrb_nil_value();
@@ -1284,7 +1283,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
else
sub = mrb_nil_value();
}
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
if (pos < 0) {
pos += RSTRING_LEN(str);
if (pos < 0) {
@@ -1623,7 +1622,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
if (pos < 0) {
pos += len;
if (pos < 0) {
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
return mrb_nil_value();
}
}
@@ -1636,7 +1635,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
else
sub = mrb_nil_value();
}
- regexp_check(mrb, sub);
+ mrb_regexp_check(mrb, sub);
switch (mrb_type(sub)) {
case MRB_TT_FIXNUM: {
@@ -1746,7 +1745,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
}
}
else {
- noregexp(mrb, str);
+ mrb_noregexp(mrb, str);
}
}
@@ -1815,7 +1814,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
beg = ptr - temp;
}
else {
- noregexp(mrb, str);
+ mrb_noregexp(mrb, str);
}
if (RSTRING_LEN(str) > 0 && (lim_p || RSTRING_LEN(str) > beg || lim < 0)) {
if (RSTRING_LEN(str) == beg) {
diff --git a/src/variable.c b/src/variable.c
index a50256353..6318d97fc 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -809,7 +809,7 @@ mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
return mrb_mod_cv_defined(mrb, mrb_class_ptr(mod), sym);
}
-MRB_API mrb_value
+mrb_value
mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
{
struct RClass *c = mrb->c->ci->proc->target_class;
@@ -819,7 +819,7 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
return mrb_mod_cv_get(mrb, c, sym);
}
-MRB_API void
+void
mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
{
struct RClass *c = mrb->c->ci->proc->target_class;
@@ -1093,7 +1093,7 @@ mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id)
return mrb_const_defined_0(mrb, klass, id, TRUE, FALSE);
}
-mrb_value
+MRB_API mrb_value
mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
{
return mrb_iv_get(mrb, obj, id);
diff --git a/src/vm.c b/src/vm.c
index 236d33a12..f13945d9a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -253,6 +253,7 @@ cipop(mrb_state *mrb)
stack_copy(p, e->stack, len);
}
e->stack = p;
+ mrb_write_barrier(mrb, (struct RBasic *)e);
}
c->ci--;
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-19 01:14:35 +0000