admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

mruby-compiler: simplify node allocation in parse.y with helper

Browse Source 
introduce new_node() helper and NEW_NODE() macro to eliminate repetitive
allocation and header initialization pattern across 64 new_* functions.

before: each function required 2-3 lines for allocation:
  struct mrb_ast_xxx_node *n = (...)parser_palloc(p, sizeof(...));
  init_var_header(&n->header, p, NODE_XXX);

after: single line with type-safe macro:
  struct mrb_ast_xxx_node *n = NEW_NODE(xxx, NODE_XXX);

saves approximately 128 lines while maintaining readability and providing
central point for future allocation logic changes.

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Yukihiro "Matz" Matsumoto
2025-10-01 09:53:04 +09:00
parent 149dd03619
commit 2495cd3c52
2 changed files with 1234 additions and 1374 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mrbgems/mruby-compiler/core/parse.y
+76 -146
View File
@@ -158,6 +158,19 @@ init_var_header(struct mrb_ast_var_header *header, parser_state *p, enum node_ty
}
}
/* Combined allocate + init header helper */
static inline void*
new_node(parser_state *p, size_t size, enum node_type type)
{
void *n = parser_palloc(p, size);
init_var_header((struct mrb_ast_var_header*)n, p, type);
return n;
}
/* Type-safe macro wrapper for node allocation */
#define NEW_NODE(type_name, node_type) \
(struct mrb_ast_##type_name##_node*)new_node(p, sizeof(struct mrb_ast_##type_name##_node), node_type)
static node*
list1_gen(parser_state *p, node *a)
{
@@ -395,8 +408,7 @@ nvars_unnest(parser_state *p)
static node*
new_scope(parser_state *p, node *body)
{
struct mrb_ast_scope_node *scope_node = (struct mrb_ast_scope_node*)parser_palloc(p, sizeof(struct mrb_ast_scope_node));
init_var_header(&scope_node->header, p, NODE_SCOPE);
struct mrb_ast_scope_node *scope_node = NEW_NODE(scope, NODE_SCOPE);
scope_node->locals = locals_node(p);
scope_node->body = body;
return (node*)scope_node;
@@ -406,9 +418,7 @@ new_scope(parser_state *p, node *body)
static node*
new_stmts(parser_state *p, node *body)
{
struct mrb_ast_stmts_node *n = (struct mrb_ast_stmts_node*)parser_palloc(p, sizeof(struct mrb_ast_stmts_node));
init_var_header(&n->header, p, NODE_STMTS);
struct mrb_ast_stmts_node *n = NEW_NODE(stmts, NODE_STMTS);
n->stmts = body ? list1(body) : 0; /* Wrap single statement in cons-list */
return (node*)n;
@@ -418,8 +428,7 @@ new_stmts(parser_state *p, node *body)
static node*
new_begin(parser_state *p, node *body)
{
struct mrb_ast_begin_node *begin_node = (struct mrb_ast_begin_node*)parser_palloc(p, sizeof(struct mrb_ast_begin_node));
init_var_header(&begin_node->header, p, NODE_BEGIN);
struct mrb_ast_begin_node *begin_node = NEW_NODE(begin, NODE_BEGIN);
begin_node->body = body;
return (node*)begin_node;
}
@@ -430,8 +439,7 @@ new_begin(parser_state *p, node *body)
static node*
new_rescue(parser_state *p, node *body, node *resq, node *els)
{
struct mrb_ast_rescue_node *n = (struct mrb_ast_rescue_node*)parser_palloc(p, sizeof(struct mrb_ast_rescue_node));
init_var_header(&n->header, p, NODE_RESCUE);
struct mrb_ast_rescue_node *n = NEW_NODE(rescue, NODE_RESCUE);
n->body = body;
n->rescue_clauses = resq;
n->else_clause = els;
@@ -449,8 +457,7 @@ new_mod_rescue(parser_state *p, node *body, node *resq)
static node*
new_ensure(parser_state *p, node *a, node *b)
{
struct mrb_ast_ensure_node *ensure_node = (struct mrb_ast_ensure_node*)parser_palloc(p, sizeof(struct mrb_ast_ensure_node));
init_var_header(&ensure_node->header, p, NODE_ENSURE);
struct mrb_ast_ensure_node *ensure_node = NEW_NODE(ensure, NODE_ENSURE);
ensure_node->body = a;
ensure_node->ensure_clause = b;
return (node*)ensure_node;
@@ -460,8 +467,7 @@ new_ensure(parser_state *p, node *a, node *b)
static node*
new_nil(parser_state *p)
{
struct mrb_ast_nil_node *n = (struct mrb_ast_nil_node*)parser_palloc(p, sizeof(struct mrb_ast_nil_node));
init_var_header(&n->header, p, NODE_NIL);
struct mrb_ast_nil_node *n = NEW_NODE(nil, NODE_NIL);
return (node*)n;
}
@@ -470,8 +476,7 @@ new_nil(parser_state *p)
static node*
new_true(parser_state *p)
{
struct mrb_ast_true_node *n = (struct mrb_ast_true_node*)parser_palloc(p, sizeof(struct mrb_ast_true_node));
init_var_header(&n->header, p, NODE_TRUE);
struct mrb_ast_true_node *n = NEW_NODE(true, NODE_TRUE);
return (node*)n;
}
@@ -480,8 +485,7 @@ new_true(parser_state *p)
static node*
new_false(parser_state *p)
{
struct mrb_ast_false_node *n = (struct mrb_ast_false_node*)parser_palloc(p, sizeof(struct mrb_ast_false_node));
init_var_header(&n->header, p, NODE_FALSE);
struct mrb_ast_false_node *n = NEW_NODE(false, NODE_FALSE);
return (node*)n;
}
@@ -490,8 +494,7 @@ new_false(parser_state *p)
static node*
new_alias(parser_state *p, mrb_sym a, mrb_sym b)
{
struct mrb_ast_alias_node *alias_node = (struct mrb_ast_alias_node*)parser_palloc(p, sizeof(struct mrb_ast_alias_node));
init_var_header(&alias_node->header, p, NODE_ALIAS);
struct mrb_ast_alias_node *alias_node = NEW_NODE(alias, NODE_ALIAS);
alias_node->new_name = a;
alias_node->old_name = b;
return (node*)alias_node;
@@ -503,10 +506,7 @@ new_if(parser_state *p, node *condition, node *then_body, node *else_body)
{
void_expr_error(p, condition);
struct mrb_ast_if_node *n;
n = (struct mrb_ast_if_node*)parser_palloc(p, sizeof(struct mrb_ast_if_node));
init_var_header(&n->header, p, NODE_IF);
struct mrb_ast_if_node *n = NEW_NODE(if, NODE_IF);
n->condition = condition;
n->then_body = then_body;
n->else_body = else_body;
@@ -520,10 +520,7 @@ new_while(parser_state *p, node *condition, node *body)
{
void_expr_error(p, condition);
struct mrb_ast_while_node *n;
n = (struct mrb_ast_while_node*)parser_palloc(p, sizeof(struct mrb_ast_if_node));
init_var_header(&n->header, p, NODE_WHILE);
struct mrb_ast_while_node *n = NEW_NODE(while, NODE_WHILE);
n->condition = condition;
n->body = body;
@@ -536,10 +533,7 @@ new_until(parser_state *p, node *condition, node *body)
{
void_expr_error(p, condition);
struct mrb_ast_until_node *n;
n = (struct mrb_ast_until_node*)parser_palloc(p, sizeof(struct mrb_ast_if_node));
init_var_header(&n->header, p, NODE_UNTIL);
struct mrb_ast_until_node *n = NEW_NODE(until, NODE_UNTIL);
n->condition = condition;
n->body = body;
@@ -573,8 +567,7 @@ new_for(parser_state *p, node *v, node *o, node *b)
{
void_expr_error(p, o);
struct mrb_ast_for_node *n = (struct mrb_ast_for_node*)parser_palloc(p, sizeof(struct mrb_ast_for_node));
init_var_header(&n->header, p, NODE_FOR);
struct mrb_ast_for_node *n = NEW_NODE(for, NODE_FOR);
n->var = v;
n->iterable = o;
n->body = b;
@@ -588,9 +581,7 @@ new_case(parser_state *p, node *a, node *b)
{
void_expr_error(p, a);
struct mrb_ast_case_node *n = (struct mrb_ast_case_node*)parser_palloc(p, sizeof(struct mrb_ast_case_node));
init_var_header(&n->header, p, NODE_CASE);
struct mrb_ast_case_node *n = NEW_NODE(case, NODE_CASE);
n->value = a;
n->body = b;
@@ -601,8 +592,7 @@ new_case(parser_state *p, node *a, node *b)
static node*
new_postexe(parser_state *p, node *a)
{
struct mrb_ast_postexe_node *postexe_node = (struct mrb_ast_postexe_node*)parser_palloc(p, sizeof(struct mrb_ast_postexe_node));
init_var_header(&postexe_node->header, p, NODE_POSTEXE);
struct mrb_ast_postexe_node *postexe_node = NEW_NODE(postexe, NODE_POSTEXE);
postexe_node->body = a;
return (node*)postexe_node;
}
@@ -611,8 +601,7 @@ new_postexe(parser_state *p, node *a)
static node*
new_self(parser_state *p)
{
struct mrb_ast_self_node *n = (struct mrb_ast_self_node*)parser_palloc(p, sizeof(struct mrb_ast_self_node));
init_var_header(&n->header, p, NODE_SELF);
struct mrb_ast_self_node *n = NEW_NODE(self, NODE_SELF);
return (node*)n;
}
@@ -621,8 +610,7 @@ new_self(parser_state *p)
static node*
new_call(parser_state *p, node *receiver, mrb_sym method, node *args, int pass)
{
/* Calculate size needed (fixed size now) */ struct mrb_ast_call_node *n = (struct mrb_ast_call_node*)parser_palloc(p, sizeof(struct mrb_ast_call_node));
init_var_header(&n->header, p, NODE_CALL);
/* Calculate size needed (fixed size now) */ struct mrb_ast_call_node *n = NEW_NODE(call, NODE_CALL);
n->receiver = receiver;
n->method_name = method;
n->safe_call = (pass == 0); /* pass == 0 means safe call (&.) */
@@ -661,8 +649,7 @@ new_callargs(parser_state *p, node *a, node *b, node *c)
static node*
new_super(parser_state *p, node *c)
{
struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_palloc(p, sizeof(struct mrb_ast_super_node));
init_var_header(&n->header, p, NODE_SUPER);
struct mrb_ast_super_node *n = NEW_NODE(super, NODE_SUPER);
n->args = c;
return (node*)n;
@@ -672,8 +659,7 @@ new_super(parser_state *p, node *c)
static node*
new_zsuper(parser_state *p)
{
struct mrb_ast_super_node *n = (struct mrb_ast_super_node*)parser_palloc(p, sizeof(struct mrb_ast_super_node));
init_var_header(&n->header, p, NODE_ZSUPER);
struct mrb_ast_super_node *n = NEW_NODE(super, NODE_ZSUPER);
n->args = NULL; /* zsuper initially has no args, but may be added by call_with_block */
return (node*)n;
}
@@ -688,8 +674,7 @@ new_yield(parser_state *p, node *c)
if (callargs->block_arg) {
yyerror(NULL, p, "both block arg and actual block given");
}
} struct mrb_ast_yield_node *n = (struct mrb_ast_yield_node*)parser_palloc(p, sizeof(struct mrb_ast_yield_node));
init_var_header(&n->header, p, NODE_YIELD);
} struct mrb_ast_yield_node *n = NEW_NODE(yield, NODE_YIELD);
n->args = c;
return (node*)n;
@@ -699,8 +684,7 @@ new_yield(parser_state *p, node *c)
static node*
new_return(parser_state *p, node *c)
{
struct mrb_ast_return_node *n = (struct mrb_ast_return_node*)parser_palloc(p, sizeof(struct mrb_ast_return_node));
init_var_header(&n->header, p, NODE_RETURN);
struct mrb_ast_return_node *n = NEW_NODE(return, NODE_RETURN);
n->args = c;
return (node*)n;
@@ -710,8 +694,7 @@ new_return(parser_state *p, node *c)
static node*
new_break(parser_state *p, node *c)
{
struct mrb_ast_break_node *n = (struct mrb_ast_break_node*)parser_palloc(p, sizeof(struct mrb_ast_break_node));
init_var_header(&n->header, p, NODE_BREAK);
struct mrb_ast_break_node *n = NEW_NODE(break, NODE_BREAK);
n->value = c;
return (node*)n;
}
@@ -720,8 +703,7 @@ new_break(parser_state *p, node *c)
static node*
new_next(parser_state *p, node *c)
{
struct mrb_ast_next_node *n = (struct mrb_ast_next_node*)parser_palloc(p, sizeof(struct mrb_ast_next_node));
init_var_header(&n->header, p, NODE_NEXT);
struct mrb_ast_next_node *n = NEW_NODE(next, NODE_NEXT);
n->value = c;
return (node*)n;
}
@@ -730,8 +712,7 @@ new_next(parser_state *p, node *c)
static node*
new_redo(parser_state *p)
{
struct mrb_ast_redo_node *n = (struct mrb_ast_redo_node*)parser_palloc(p, sizeof(struct mrb_ast_redo_node));
init_var_header(&n->header, p, NODE_REDO);
struct mrb_ast_redo_node *n = NEW_NODE(redo, NODE_REDO);
return (node*)n;
}
@@ -739,8 +720,7 @@ new_redo(parser_state *p)
static node*
new_retry(parser_state *p)
{
struct mrb_ast_retry_node *n = (struct mrb_ast_retry_node*)parser_palloc(p, sizeof(struct mrb_ast_retry_node));
init_var_header(&n->header, p, NODE_RETRY);
struct mrb_ast_retry_node *n = NEW_NODE(retry, NODE_RETRY);
return (node*)n;
}
@@ -748,8 +728,7 @@ new_retry(parser_state *p)
static node*
new_dot2(parser_state *p, node *a, node *b)
{
struct mrb_ast_dot2_node *n = (struct mrb_ast_dot2_node*)parser_palloc(p, sizeof(struct mrb_ast_dot2_node));
init_var_header(&n->header, p, NODE_DOT2);
struct mrb_ast_dot2_node *n = NEW_NODE(dot2, NODE_DOT2);
n->left = a;
n->right = b;
@@ -760,8 +739,7 @@ new_dot2(parser_state *p, node *a, node *b)
static node*
new_dot3(parser_state *p, node *a, node *b)
{
struct mrb_ast_dot3_node *n = (struct mrb_ast_dot3_node*)parser_palloc(p, sizeof(struct mrb_ast_dot3_node));
init_var_header(&n->header, p, NODE_DOT3);
struct mrb_ast_dot3_node *n = NEW_NODE(dot3, NODE_DOT3);
n->left = a;
n->right = b;
@@ -774,8 +752,7 @@ new_colon2(parser_state *p, node *b, mrb_sym c)
{
void_expr_error(p, b);
struct mrb_ast_colon2_node *colon2_node = (struct mrb_ast_colon2_node*)parser_palloc(p, sizeof(struct mrb_ast_colon2_node));
init_var_header(&colon2_node->header, p, NODE_COLON2);
struct mrb_ast_colon2_node *colon2_node = NEW_NODE(colon2, NODE_COLON2);
colon2_node->base = b;
colon2_node->name = c;
return (node*)colon2_node;
@@ -785,8 +762,7 @@ new_colon2(parser_state *p, node *b, mrb_sym c)
static node*
new_colon3(parser_state *p, mrb_sym c)
{
struct mrb_ast_colon3_node *colon3_node = (struct mrb_ast_colon3_node*)parser_palloc(p, sizeof(struct mrb_ast_colon3_node));
init_var_header(&colon3_node->header, p, NODE_COLON3);
struct mrb_ast_colon3_node *colon3_node = NEW_NODE(colon3, NODE_COLON3);
colon3_node->name = c;
return (node*)colon3_node;
}
@@ -797,8 +773,7 @@ new_and(parser_state *p, node *a, node *b)
{
void_expr_error(p, a);
struct mrb_ast_and_node *n = (struct mrb_ast_and_node*)parser_palloc(p, sizeof(struct mrb_ast_and_node));
init_var_header(&n->header, p, NODE_AND);
struct mrb_ast_and_node *n = NEW_NODE(and, NODE_AND);
n->left = a;
n->right = b;
@@ -811,8 +786,7 @@ new_or(parser_state *p, node *a, node *b)
{
void_expr_error(p, a);
struct mrb_ast_or_node *n = (struct mrb_ast_or_node*)parser_palloc(p, sizeof(struct mrb_ast_or_node));
init_var_header(&n->header, p, NODE_OR);
struct mrb_ast_or_node *n = NEW_NODE(or, NODE_OR);
n->left = a;
n->right = b;
@@ -823,9 +797,7 @@ new_or(parser_state *p, node *a, node *b)
static node*
new_array(parser_state *p, node *a)
{
struct mrb_ast_array_node *n = (struct mrb_ast_array_node*)parser_palloc(p, sizeof(struct mrb_ast_array_node));
init_var_header(&n->header, p, NODE_ARRAY);
struct mrb_ast_array_node *n = NEW_NODE(array, NODE_ARRAY);
n->elements = a;
return (node*)n;
@@ -837,8 +809,7 @@ new_splat(parser_state *p, node *a)
{
void_expr_error(p, a);
struct mrb_ast_splat_node *splat_node = (struct mrb_ast_splat_node*)parser_palloc(p, sizeof(struct mrb_ast_splat_node));
init_var_header(&splat_node->header, p, NODE_SPLAT);
struct mrb_ast_splat_node *splat_node = NEW_NODE(splat, NODE_SPLAT);
splat_node->value = a;
return (node*)splat_node;
}
@@ -847,9 +818,7 @@ new_splat(parser_state *p, node *a)
static node*
new_hash(parser_state *p, node *a)
{
struct mrb_ast_hash_node *n = (struct mrb_ast_hash_node*)parser_palloc(p, sizeof(struct mrb_ast_hash_node));
init_var_header(&n->header, p, NODE_HASH);
struct mrb_ast_hash_node *n = NEW_NODE(hash, NODE_HASH);
n->pairs = a;
return (node*)n;
@@ -860,11 +829,7 @@ new_hash(parser_state *p, node *a)
static node*
new_sym(parser_state *p, mrb_sym sym)
{
size_t size = sizeof(struct mrb_ast_sym_node);
struct mrb_ast_sym_node *n = (struct mrb_ast_sym_node*)parser_palloc(p, size);
init_var_header(&n->header, p, NODE_SYM);
struct mrb_ast_sym_node *n = NEW_NODE(sym, NODE_SYM);
n->symbol = sym;
return (node*)n;
@@ -873,11 +838,7 @@ new_sym(parser_state *p, mrb_sym sym)
static node*
new_xvar(parser_state *p, mrb_sym sym, enum node_type type)
{
size_t size = sizeof(struct mrb_ast_var_node);
struct mrb_ast_var_node *n = (struct mrb_ast_var_node*)parser_palloc(p, size);
init_var_header(&n->header, p, type);
struct mrb_ast_var_node *n = NEW_NODE(var, type);
n->symbol = sym;
return (node*)n;
@@ -920,8 +881,7 @@ new_nvar(parser_state *p, int num)
else {
p->nvars->car = int_to_node(nvar > num ? nvar : num);
}
struct mrb_ast_nvar_node *n = (struct mrb_ast_nvar_node*)parser_palloc(p, sizeof(struct mrb_ast_nvar_node));
init_var_header(&n->header, p, NODE_NVAR);
struct mrb_ast_nvar_node *n = NEW_NODE(nvar, NODE_NVAR);
n->num = num;
return (node*)n;
}
@@ -930,8 +890,7 @@ new_nvar(parser_state *p, int num)
static node*
new_const(parser_state *p, mrb_sym sym)
{
struct mrb_ast_const_node *n = (struct mrb_ast_const_node*)parser_palloc(p, sizeof(struct mrb_ast_const_node));
init_var_header(&n->header, p, NODE_CONST);
struct mrb_ast_const_node *n = NEW_NODE(const, NODE_CONST);
n->symbol = sym;
return (node*)n;
@@ -941,8 +900,7 @@ new_const(parser_state *p, mrb_sym sym)
static node*
new_undef(parser_state *p, node *syms)
{
struct mrb_ast_undef_node *undef_node = (struct mrb_ast_undef_node*)parser_palloc(p, sizeof(struct mrb_ast_undef_node));
init_var_header(&undef_node->header, p, NODE_UNDEF);
struct mrb_ast_undef_node *undef_node = NEW_NODE(undef, NODE_UNDEF);
undef_node->syms = syms;
return (node*)undef_node;
}
@@ -953,8 +911,7 @@ new_class(parser_state *p, node *c, node *s, node *b)
{
void_expr_error(p, s);
struct mrb_ast_class_node *n = (struct mrb_ast_class_node*)parser_palloc(p, sizeof(struct mrb_ast_class_node));
init_var_header(&n->header, p, NODE_CLASS);
struct mrb_ast_class_node *n = NEW_NODE(class, NODE_CLASS);
n->name = c;
n->superclass = s;
n->body = cons(locals_node(p), b);
@@ -968,8 +925,7 @@ new_sclass(parser_state *p, node *o, node *b)
{
void_expr_error(p, o);
struct mrb_ast_sclass_node *n = (struct mrb_ast_sclass_node*)parser_palloc(p, sizeof(struct mrb_ast_sclass_node));
init_var_header(&n->header, p, NODE_SCLASS);
struct mrb_ast_sclass_node *n = NEW_NODE(sclass, NODE_SCLASS);
n->obj = o;
n->body = cons(locals_node(p), b);
@@ -980,8 +936,7 @@ new_sclass(parser_state *p, node *o, node *b)
static node*
new_module(parser_state *p, node *m, node *b)
{
struct mrb_ast_module_node *n = (struct mrb_ast_module_node*)parser_palloc(p, sizeof(struct mrb_ast_module_node));
init_var_header(&n->header, p, NODE_MODULE);
struct mrb_ast_module_node *n = NEW_NODE(module, NODE_MODULE);
n->name = m;
n->body = cons(locals_node(p), b);
@@ -992,8 +947,7 @@ new_module(parser_state *p, node *m, node *b)
static node*
new_def(parser_state *p, mrb_sym name)
{
struct mrb_ast_def_node *n = (struct mrb_ast_def_node*)parser_palloc(p, sizeof(struct mrb_ast_def_node));
init_var_header(&n->header, p, NODE_DEF);
struct mrb_ast_def_node *n = NEW_NODE(def, NODE_DEF);
n->name = name;
n->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
n->locals = local_switch(p);
@@ -1021,8 +975,7 @@ new_sdef(parser_state *p, node *o, mrb_sym name)
{
void_expr_error(p, o);
struct mrb_ast_sdef_node *sdef_node = (struct mrb_ast_sdef_node*)parser_palloc(p, sizeof(struct mrb_ast_sdef_node));
init_var_header(&sdef_node->header, p, NODE_SDEF);
struct mrb_ast_sdef_node *sdef_node = NEW_NODE(sdef, NODE_SDEF);
sdef_node->obj = o;
sdef_node->name = name;
sdef_node->args = (struct mrb_ast_args *)int_to_node(p->cmdarg_stack);
@@ -1182,8 +1135,7 @@ new_args_dots(parser_state *p, node *m)
static node*
new_block_arg(parser_state *p, node *a)
{
struct mrb_ast_block_arg_node *block_arg_node = (struct mrb_ast_block_arg_node*)parser_palloc(p, sizeof(struct mrb_ast_block_arg_node));
init_var_header(&block_arg_node->header, p, NODE_BLOCK_ARG);
struct mrb_ast_block_arg_node *block_arg_node = NEW_NODE(block_arg, NODE_BLOCK_ARG);
block_arg_node->value = a;
return (node*)block_arg_node;
}
@@ -1224,8 +1176,7 @@ setup_numparams(parser_state *p, node *a)
static node*
new_block(parser_state *p, node *a, node *b)
{
a = setup_numparams(p, a); struct mrb_ast_block_node *n = (struct mrb_ast_block_node*)parser_palloc(p, sizeof(struct mrb_ast_block_node));
init_var_header(&n->header, p, NODE_BLOCK);
a = setup_numparams(p, a); struct mrb_ast_block_node *n = NEW_NODE(block, NODE_BLOCK);
n->locals = locals_node(p);
n->args = (struct mrb_ast_args *)a;
n->body = b;
@@ -1237,8 +1188,7 @@ new_block(parser_state *p, node *a, node *b)
static node*
new_lambda(parser_state *p, node *a, node *b)
{
a = setup_numparams(p, a); struct mrb_ast_lambda_node *lambda_node = (struct mrb_ast_lambda_node*)parser_palloc(p, sizeof(struct mrb_ast_lambda_node));
init_var_header(&lambda_node->header, p, NODE_LAMBDA);
a = setup_numparams(p, a); struct mrb_ast_lambda_node *lambda_node = NEW_NODE(lambda, NODE_LAMBDA);
lambda_node->locals = locals_node(p);
lambda_node->args = (struct mrb_ast_args *)a;
lambda_node->body = b;
@@ -1251,8 +1201,7 @@ new_asgn(parser_state *p, node *a, node *b)
{
void_expr_error(p, b);
struct mrb_ast_asgn_node *n = (struct mrb_ast_asgn_node*)parser_palloc(p, sizeof(struct mrb_ast_asgn_node));
init_var_header(&n->header, p, NODE_ASGN);
struct mrb_ast_asgn_node *n = NEW_NODE(asgn, NODE_ASGN);
n->lhs = a;
n->rhs = b;
@@ -1263,8 +1212,7 @@ new_asgn(parser_state *p, node *a, node *b)
static node*
new_masgn_helper(parser_state *p, node *a, node *b, enum node_type node_type)
{
struct mrb_ast_masgn_node *n = (struct mrb_ast_masgn_node*)parser_palloc(p, sizeof(struct mrb_ast_masgn_node));
init_var_header(&n->header, p, node_type);
struct mrb_ast_masgn_node *n = NEW_NODE(masgn, node_type);
/* Extract pre, rest, post from cons list structure (a b c) */
if (a) {
@@ -1317,8 +1265,7 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
{
void_expr_error(p, b);
struct mrb_ast_op_asgn_node *n = (struct mrb_ast_op_asgn_node*)parser_palloc(p, sizeof(struct mrb_ast_op_asgn_node));
init_var_header(&n->header, p, NODE_OP_ASGN);
struct mrb_ast_op_asgn_node *n = NEW_NODE(op_asgn, NODE_OP_ASGN);
n->lhs = a;
n->op = op;
n->rhs = b;
@@ -1328,10 +1275,7 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
static node*
new_int_n(parser_state *p, int32_t val)
{
size_t size = sizeof(struct mrb_ast_int_node);
struct mrb_ast_int_node *n = (struct mrb_ast_int_node*)parser_palloc(p, size);
init_var_header(&n->header, p, NODE_INT);
struct mrb_ast_int_node *n = NEW_NODE(int, NODE_INT);
n->value = val;
return (node*)n;
@@ -1437,10 +1381,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
}
else {
/* Big integer - create NODE_BIGINT */
size_t size = sizeof(struct mrb_ast_bigint_node);
struct mrb_ast_bigint_node *n = (struct mrb_ast_bigint_node*)parser_palloc(p, size);
init_var_header(&n->header, p, NODE_BIGINT);
struct mrb_ast_bigint_node *n = NEW_NODE(bigint, NODE_BIGINT);
n->string = strdup(s);
n->base = base;
@@ -1463,8 +1404,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
static node*
new_float(parser_state *p, const char *s, int suffix)
{
struct mrb_ast_float_node *n = (struct mrb_ast_float_node*)parser_palloc(p, sizeof(struct mrb_ast_float_node));
init_var_header(&n->header, p, NODE_FLOAT);
struct mrb_ast_float_node *n = NEW_NODE(float, NODE_FLOAT);
n->value = strdup(s);
node* result = (node*)n;
@@ -1484,8 +1424,7 @@ new_float(parser_state *p, const char *s, int suffix)
static node*
new_str(parser_state *p, node *a)
{
struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_palloc(p, sizeof(struct mrb_ast_str_node));
init_var_header(&n->header, p, NODE_STR);
struct mrb_ast_str_node *n = NEW_NODE(str, NODE_STR);
n->list = a;
return (node*)n;
@@ -1495,8 +1434,7 @@ new_str(parser_state *p, node *a)
static node*
new_xstr(parser_state *p, node *a)
{
struct mrb_ast_xstr_node *n = (struct mrb_ast_xstr_node*)parser_palloc(p, sizeof(struct mrb_ast_xstr_node));
init_var_header(&n->header, p, NODE_XSTR);
struct mrb_ast_xstr_node *n = NEW_NODE(xstr, NODE_XSTR);
n->list = a;
return (node*)n;
}
@@ -1505,8 +1443,7 @@ new_xstr(parser_state *p, node *a)
static node*
new_dsym(parser_state *p, node *a)
{
struct mrb_ast_str_node *n = (struct mrb_ast_str_node*)parser_palloc(p, sizeof(struct mrb_ast_str_node));
init_var_header(&n->header, p, NODE_DSYM);
struct mrb_ast_str_node *n = NEW_NODE(str, NODE_DSYM);
n->list = a;
return (node*)n;
}
@@ -1515,8 +1452,7 @@ new_dsym(parser_state *p, node *a)
static node*
new_regx(parser_state *p, node *list, const char *flags, const char *encoding)
{
struct mrb_ast_regx_node *n = (struct mrb_ast_regx_node*)parser_palloc(p, sizeof(struct mrb_ast_regx_node));
init_var_header(&n->header, p, NODE_REGX);
struct mrb_ast_regx_node *n = NEW_NODE(regx, NODE_REGX);
n->list = list;
n->flags = flags;
n->encoding = encoding;
@@ -1527,8 +1463,7 @@ new_regx(parser_state *p, node *list, const char *flags, const char *encoding)
static node*
new_back_ref(parser_state *p, int n)
{
struct mrb_ast_back_ref_node *backref_node = (struct mrb_ast_back_ref_node*)parser_palloc(p, sizeof(struct mrb_ast_back_ref_node));
init_var_header(&backref_node->header, p, NODE_BACK_REF);
struct mrb_ast_back_ref_node *backref_node = NEW_NODE(back_ref, NODE_BACK_REF);
backref_node->type = n;
return (node*)backref_node;
}
@@ -1537,8 +1472,7 @@ new_back_ref(parser_state *p, int n)
static node*
new_nth_ref(parser_state *p, int n)
{
struct mrb_ast_nth_ref_node *nthref_node = (struct mrb_ast_nth_ref_node*)parser_palloc(p, sizeof(struct mrb_ast_nth_ref_node));
init_var_header(&nthref_node->header, p, NODE_NTH_REF);
struct mrb_ast_nth_ref_node *nthref_node = NEW_NODE(nth_ref, NODE_NTH_REF);
nthref_node->nth = n;
return (node*)nthref_node;
}
@@ -1547,8 +1481,7 @@ new_nth_ref(parser_state *p, int n)
static node*
new_heredoc(parser_state *p, struct mrb_parser_heredoc_info **infop)
{
struct mrb_ast_heredoc_node *n = (struct mrb_ast_heredoc_node*)parser_palloc(p, sizeof(struct mrb_ast_heredoc_node));
init_var_header(&n->header, p, NODE_HEREDOC);
struct mrb_ast_heredoc_node *n = NEW_NODE(heredoc, NODE_HEREDOC);
/* Initialize embedded heredoc info struct */
n->info.allow_indent = FALSE;
@@ -1603,8 +1536,7 @@ new_str_empty(parser_state *p)
static node*
new_words(parser_state *p, node *a)
{
struct mrb_ast_words_node *words_node = (struct mrb_ast_words_node*)parser_palloc(p, sizeof(struct mrb_ast_words_node));
init_var_header(&words_node->header, p, NODE_WORDS);
struct mrb_ast_words_node *words_node = NEW_NODE(words, NODE_WORDS);
words_node->args = a;
return (node*)words_node;
}
@@ -1613,8 +1545,7 @@ new_words(parser_state *p, node *a)
static node*
new_symbols(parser_state *p, node *a)
{
struct mrb_ast_symbols_node *symbols_node = (struct mrb_ast_symbols_node*)parser_palloc(p, sizeof(struct mrb_ast_symbols_node));
init_var_header(&symbols_node->header, p, NODE_SYMBOLS);
struct mrb_ast_symbols_node *symbols_node = NEW_NODE(symbols, NODE_SYMBOLS);
symbols_node->args = a;
return (node*)symbols_node;
}
@@ -1749,8 +1680,7 @@ call_with_block(parser_state *p, node *a, node *b)
static node*
new_negate(parser_state *p, node *n)
{
struct mrb_ast_negate_node *negate_node = (struct mrb_ast_negate_node*)parser_palloc(p, sizeof(struct mrb_ast_negate_node));
init_var_header(&negate_node->header, p, NODE_NEGATE);
struct mrb_ast_negate_node *negate_node = NEW_NODE(negate, NODE_NEGATE);
negate_node->operand = n;
return (node*)negate_node;
}
mrbgems/mruby-compiler/core/y.tab.c
+1158 -1228
View File
File diff suppressed because it is too large Load Diff