From ee80a2ef268d99dc37be7b1d8ad743c753b77b22 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 30 Sep 2025 22:48:50 +0900 Subject: [PATCH] mruby-compiler: replace accessor macros with direct member access replaced all *_NODE_* accessor macros (e.g., SYM_NODE_VALUE, INT_NODE_VALUE, CALL_NODE_METHOD) with direct member access using casting macros (e.g., sym_node(n)->symbol, int_node(n)->value, call_node(n)->method_name). this eliminates an unnecessary abstraction layer and improves code readability by making field access explicit. the accessor macros simply wrapped cast_func(n)->field, providing no real benefit. direct member access makes it clear what field is being accessed and reduces macro indirection. affected files: - node.h: removed ~100 accessor macro definitions - codegen.c: replaced 19 macro uses with direct access - parse.y: replaced 152 macro uses with direct access Co-authored-by: Claude --- mrbgems/mruby-compiler/core/codegen.c | 36 +-- mrbgems/mruby-compiler/core/node.h | 145 ------------ mrbgems/mruby-compiler/core/parse.y | 304 +++++++++++++------------- mrbgems/mruby-compiler/core/y.tab.c | 304 +++++++++++++------------- 4 files changed, 322 insertions(+), 467 deletions(-) diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index a99c78770..d997c12b5 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2940,7 +2940,7 @@ gen_assignment(codegen_scope *s, node *tree, node *rhs, int sp, int val) return; case NODE_LVAR: { - mrb_sym sym = VAR_NODE_SYMBOL(tree); + mrb_sym sym = var_node(tree)->symbol; if (rhs) { codegen(s, rhs, VAL); pop(); @@ -3782,7 +3782,7 @@ static mrb_bool callargs_empty(node *n) { if (!n) return TRUE; - return (CALLARGS_NODE_REGULAR(n) == 0 && CALLARGS_NODE_KEYWORDS(n) == 0 && CALLARGS_NODE_BLOCK(n) == 0); + return (callargs_node(n)->regular_args == 0 && callargs_node(n)->keyword_args == 0 && callargs_node(n)->block_arg == 0); } static void @@ -4792,8 +4792,8 @@ codegen_str(codegen_scope *s, node *varnode, int val) static void codegen_dot2(codegen_scope *s, node *varnode, int val) { - node *left = DOT2_NODE_LEFT(varnode); - node *right = DOT2_NODE_RIGHT(varnode); + node *left = dot2_node(varnode)->left; + node *right = dot2_node(varnode)->right; codegen(s, left, val); codegen(s, right, val); @@ -4806,8 +4806,8 @@ codegen_dot2(codegen_scope *s, node *varnode, int val) static void codegen_dot3(codegen_scope *s, node *varnode, int val) { - node *left = DOT3_NODE_LEFT(varnode); - node *right = DOT3_NODE_RIGHT(varnode); + node *left = dot3_node(varnode)->left; + node *right = dot3_node(varnode)->right; codegen(s, left, val); codegen(s, right, val); @@ -5218,7 +5218,7 @@ codegen_negate(codegen_scope *s, node *varnode, int val) case NODE_INT: if (val) { - int32_t value = INT_NODE_VALUE(tree); + int32_t value = int_node(tree)->value; if (value == INT32_MIN) { /* -INT32_MIN overflows, use bigint */ int off = new_litbint(s, "2147483648", -10); @@ -5233,8 +5233,8 @@ codegen_negate(codegen_scope *s, node *varnode, int val) case NODE_BIGINT: if (val) { - char *str = BIGINT_NODE_STRING(tree); - int base = BIGINT_NODE_BASE(tree); + char *str = bigint_node(tree)->string; + int base = bigint_node(tree)->base; /* Negate base to indicate negative number */ int off = new_litbint(s, str, -base); genop_2(s, OP_LOADL, cursp(), off); @@ -5459,7 +5459,7 @@ static void codegen_stmts(codegen_scope *s, node *varnode, int val) { struct mrb_ast_stmts_node *stmts = stmts_node(varnode); - node *tree = STMTS_NODE_STMTS(stmts); + node *tree = stmts_node(stmts)->stmts; if (val && !tree) { gen_load_nil(s, 1); @@ -5577,15 +5577,15 @@ codegen(codegen_scope *s, node *tree, int val) switch (var_type) { case NODE_INT: if (val) { - gen_int(s, cursp(), INT_NODE_VALUE(tree)); + gen_int(s, cursp(), int_node(tree)->value); push(); } break; case NODE_BIGINT: if (val) { - char *str = BIGINT_NODE_STRING(tree); - int base = BIGINT_NODE_BASE(tree); + char *str = bigint_node(tree)->string; + int base = bigint_node(tree)->base; int off = new_litbint(s, str, base); genop_2(s, OP_LOADL, cursp(), off); push(); @@ -5594,25 +5594,25 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_SYM: { - int i = new_sym(s, SYM_NODE_VALUE(tree)); + int i = new_sym(s, sym_node(tree)->symbol); gen_load_op2(s, OP_LOADSYM, i, val); } break; case NODE_LVAR: - gen_lvar(s, VAR_NODE_SYMBOL(tree), val); + gen_lvar(s, var_node(tree)->symbol, val); break; case NODE_GVAR: - gen_xvar(s, VAR_NODE_SYMBOL(tree), val, OP_GETGV); + gen_xvar(s, var_node(tree)->symbol, val, OP_GETGV); break; case NODE_IVAR: - gen_xvar(s, VAR_NODE_SYMBOL(tree), val, OP_GETIV); + gen_xvar(s, var_node(tree)->symbol, val, OP_GETIV); break; case NODE_CVAR: - gen_xvar(s, VAR_NODE_SYMBOL(tree), val, OP_GETCV); + gen_xvar(s, var_node(tree)->symbol, val, OP_GETCV); break; case NODE_CALL: diff --git a/mrbgems/mruby-compiler/core/node.h b/mrbgems/mruby-compiler/core/node.h index 1bd07fcfb..a1b42d832 100644 --- a/mrbgems/mruby-compiler/core/node.h +++ b/mrbgems/mruby-compiler/core/node.h @@ -379,85 +379,6 @@ struct mrb_ast_super_node { #define yield_node(n) ((struct mrb_ast_yield_node*)(n)) #define super_node(n) ((struct mrb_ast_super_node*)(n)) -/* Phase 1 value access macros */ -#define SYM_NODE_VALUE(n) (sym_node(n)->symbol) -#define INT_NODE_VALUE(n) (int_node(n)->value) -#define BIGINT_NODE_STRING(n) (bigint_node(n)->string) -#define BIGINT_NODE_BASE(n) (bigint_node(n)->base) -#define VAR_NODE_SYMBOL(n) (var_node(n)->symbol) - -/* Phase 2 value access macros */ -#define CALL_NODE_RECEIVER(n) (call_node(n)->receiver) -#define CALL_NODE_METHOD(n) (call_node(n)->method_name) -#define CALL_NODE_ARGS(n) (call_node(n)->args) -#define CALL_NODE_SAFE(n) (call_node(n)->safe_call) - -#define ARRAY_NODE_ELEMENTS(n) (array_node(n)->elements) - -#define HASH_NODE_PAIRS(n) (hash_node(n)->pairs) - -/* Phase 3 value access macros */ -#define IF_NODE_CONDITION(n) (if_node(n)->condition) -#define IF_NODE_THEN(n) (if_node(n)->then_body) -#define IF_NODE_ELSE(n) (if_node(n)->else_body) - -#define WHILE_NODE_CONDITION(n) (while_node(n)->condition) -#define WHILE_NODE_BODY(n) (while_node(n)->body) - -#define UNTIL_NODE_CONDITION(n) (until_node(n)->condition) -#define UNTIL_NODE_BODY(n) (until_node(n)->body) - -#define CASE_NODE_VALUE(n) (case_node(n)->value) -#define CASE_NODE_BODY(n) (case_node(n)->body) - -#define FOR_NODE_VAR(n) (for_node(n)->var) -#define FOR_NODE_ITERABLE(n) (for_node(n)->iterable) -#define FOR_NODE_BODY(n) (for_node(n)->body) - -/* Definition node value access macros */ -#define DEF_NODE_NAME(n) (def_node(n)->name) -#define DEF_NODE_ARGS(n) (def_node(n)->args) -#define DEF_NODE_BODY(n) (def_node(n)->body) -#define DEF_NODE_LOCALS(n) (def_node(n)->locals) -#define SDEF_NODE_NAME(n) (sdef_node(n)->name) -#define SDEF_NODE_ARGS(n) (sdef_node(n)->args) -#define SDEF_NODE_BODY(n) (sdef_node(n)->body) -#define SDEF_NODE_LOCALS(n) (sdef_node(n)->locals) -#define SDEF_NODE_OBJ(n) (sdef_node(n)->obj) -#define CLASS_NODE_NAME(n) (class_node(n)->name) -#define CLASS_NODE_SUPERCLASS(n) (class_node(n)->superclass) -#define CLASS_NODE_BODY(n) (class_node(n)->body) - -#define MODULE_NODE_NAME(n) (module_node(n)->name) -#define MODULE_NODE_BODY(n) (module_node(n)->body) - -#define SCLASS_NODE_OBJ(n) (sclass_node(n)->obj) -#define SCLASS_NODE_BODY(n) (sclass_node(n)->body) - -/* Assignment node value access macros */ -#define ASGN_NODE_LHS(n) (asgn_node(n)->lhs) -#define ASGN_NODE_RHS(n) (asgn_node(n)->rhs) - -#define MASGN_NODE_PRE(n) (masgn_node(n)->pre) -#define MASGN_NODE_REST(n) (masgn_node(n)->rest) -#define MASGN_NODE_POST(n) (masgn_node(n)->post) -#define MASGN_NODE_RHS(n) (masgn_node(n)->rhs) - -#define OP_ASGN_NODE_LHS(n) (op_asgn_node(n)->lhs) -#define OP_ASGN_NODE_OP(n) (op_asgn_node(n)->op) -#define OP_ASGN_NODE_RHS(n) (op_asgn_node(n)->rhs) - -/* Expression node value access macros */ -#define AND_NODE_LEFT(n) (and_node(n)->left) -#define AND_NODE_RIGHT(n) (and_node(n)->right) - -#define OR_NODE_LEFT(n) (or_node(n)->left) -#define OR_NODE_RIGHT(n) (or_node(n)->right) - -#define RETURN_NODE_ARGS(n) (return_node(n)->args) -#define YIELD_NODE_ARGS(n) (yield_node(n)->args) -#define SUPER_NODE_ARGS(n) (super_node(n)->args) - /* Variable-sized literal node structures */ struct mrb_ast_dot2_node { @@ -482,17 +403,6 @@ struct mrb_ast_float_node { #define dot3_node(n) ((struct mrb_ast_dot3_node*)(n)) #define float_node(n) ((struct mrb_ast_float_node*)(n)) -/* Literal node value access macros */ -#define STR_NODE_LIST(n) (str_node(n)->list) - -#define DOT2_NODE_LEFT(n) (dot2_node(n)->left) -#define DOT2_NODE_RIGHT(n) (dot2_node(n)->right) - -#define DOT3_NODE_LEFT(n) (dot3_node(n)->left) -#define DOT3_NODE_RIGHT(n) (dot3_node(n)->right) - -#define FLOAT_NODE_VALUE(n) (float_node(n)->value) - /* Variable-sized simple node structures */ struct mrb_ast_self_node { struct mrb_ast_var_header header; @@ -522,9 +432,6 @@ struct mrb_ast_const_node { #define false_node(n) ((struct mrb_ast_false_node*)(n)) #define const_node(n) ((struct mrb_ast_const_node*)(n)) -/* Simple node value access macros */ -#define CONST_NODE_SYMBOL(n) (const_node(n)->symbol) - /* Variable-sized advanced node structures */ struct mrb_ast_rescue_node { struct mrb_ast_var_header header; @@ -566,19 +473,6 @@ struct mrb_ast_callargs { #define block_node(n) ((struct mrb_ast_block_node*)(n)) #define callargs_node(n) ((struct mrb_ast_callargs*)(n)) -/* Advanced node value access macros */ -#define RESCUE_NODE_BODY(n) (rescue_node(n)->body) -#define RESCUE_NODE_RESCUE_CLAUSES(n) (rescue_node(n)->rescue_clauses) -#define RESCUE_NODE_ELSE_CLAUSE(n) (rescue_node(n)->else_clause) - -#define BLOCK_NODE_LOCALS(n) (block_node(n)->locals) -#define BLOCK_NODE_ARGS(n) (block_node(n)->args) -#define BLOCK_NODE_BODY(n) (block_node(n)->body) - -#define CALLARGS_NODE_REGULAR(n) (callargs_node(n)->regular_args) -#define CALLARGS_NODE_KEYWORDS(n) (callargs_node(n)->keyword_args) -#define CALLARGS_NODE_BLOCK(n) (callargs_node(n)->block_arg) - // Group 8: Control Flow Statements struct mrb_ast_break_node { struct mrb_ast_var_header header; @@ -602,8 +496,6 @@ struct mrb_ast_retry_node { #define next_node(n) ((struct mrb_ast_next_node*)(n)) #define redo_node(n) ((struct mrb_ast_redo_node*)(n)) #define retry_node(n) ((struct mrb_ast_retry_node*)(n)) -#define BREAK_NODE_VALUE(n) (break_node(n)->value) -#define NEXT_NODE_VALUE(n) (next_node(n)->value) // Group 9: String and Regex Variants struct mrb_ast_xstr_node { @@ -628,12 +520,6 @@ struct mrb_ast_heredoc_node { #define heredoc_node(n) ((struct mrb_ast_heredoc_node*)(n)) #define dsym_node(n) ((struct mrb_ast_str_node*)(n)) -#define XSTR_NODE_LIST(n) (xstr_node(n)->list) -#define REGX_NODE_LIST(n) (regx_node(n)->list) -#define REGX_NODE_FLAGS(n) (regx_node(n)->flags) -#define REGX_NODE_ENCODING(n) (regx_node(n)->encoding) -#define DSYM_NODE_LIST(n) (str_node(n)->list) - // Group 10: References and Variables struct mrb_ast_nth_ref_node { struct mrb_ast_var_header header; @@ -660,11 +546,6 @@ struct mrb_ast_dvar_node { #define nvar_node(n) ((struct mrb_ast_nvar_node*)(n)) #define dvar_node(n) ((struct mrb_ast_dvar_node*)(n)) -#define NTH_REF_NODE_NTH(n) (nth_ref_node(n)->nth) -#define BACK_REF_NODE_TYPE(n) (back_ref_node(n)->type) -#define NVAR_NODE_NUM(n) (nvar_node(n)->num) -#define DVAR_NODE_NAME(n) (dvar_node(n)->name) - // Group 11: Operators and Expressions struct mrb_ast_not_node { struct mrb_ast_var_header header; @@ -698,13 +579,6 @@ struct mrb_ast_defined_node { #define colon3_node(n) ((struct mrb_ast_colon3_node*)(n)) #define defined_node(n) ((struct mrb_ast_defined_node*)(n)) -#define NOT_NODE_OPERAND(n) (not_node(n)->operand) -#define NEGATE_NODE_OPERAND(n) (negate_node(n)->operand) -#define COLON2_NODE_BASE(n) (colon2_node(n)->base) -#define COLON2_NODE_NAME(n) (colon2_node(n)->name) -#define COLON3_NODE_NAME(n) (colon3_node(n)->name) -#define DEFINED_NODE_EXPR(n) (defined_node(n)->expr) - // Group 12: Function Calls and Special Forms struct mrb_ast_lambda_node { struct mrb_ast_var_header header; @@ -813,23 +687,4 @@ struct mrb_ast_postexe_node { #define postexe_node(n) ((struct mrb_ast_postexe_node*)(n)) #define sdef_node(n) ((struct mrb_ast_sdef_node*)(n)) -#define LAMBDA_NODE_LOCALS(n) (lambda_node(n)->locals) -#define LAMBDA_NODE_ARGS(n) (lambda_node(n)->args) -#define LAMBDA_NODE_BODY(n) (lambda_node(n)->body) -#define WORDS_NODE_ARGS(n) (words_node(n)->args) -#define SYMBOLS_NODE_ARGS(n) (symbols_node(n)->args) -#define SPLAT_NODE_VALUE(n) (splat_node(n)->value) -#define BLOCK_ARG_NODE_VALUE(n) (block_arg_node(n)->value) -#define SCOPE_NODE_LOCALS(n) (scope_node(n)->locals) -#define SCOPE_NODE_BODY(n) (scope_node(n)->body) -#define STMTS_NODE_STMTS(n) (stmts_node(n)->stmts) -#define BEGIN_NODE_BODY(n) (begin_node(n)->body) -#define ENSURE_NODE_BODY(n) (ensure_node(n)->body) -#define ENSURE_NODE_ENSURE_CLAUSE(n) (ensure_node(n)->ensure_clause) -#define ITER_NODE_VARS(n) (iter_node(n)->vars) -#define ITER_NODE_BODY(n) (iter_node(n)->body) -#define WHEN_NODE_COND(n) (when_node(n)->cond) -#define WHEN_NODE_BODY(n) (when_node(n)->body) -#define WHEN_NODE_NEXT_WHEN(n) (when_node(n)->next_when) - #endif /* MRUBY_COMPILER_NODE_H */ diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index d19a10efe..957aa7b10 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -1724,7 +1724,7 @@ call_with_block(parser_state *p, node *a, node *b) { struct mrb_ast_call_node *call = call_node(a); - if (call->args && CALLARGS_NODE_BLOCK(call->args)) { + if (call->args && callargs_node(call->args)->block_arg) { yyerror(NULL, p, "both block arg and actual block given"); return; } @@ -1780,7 +1780,7 @@ assignable(parser_state *p, node *lhs) { switch (get_node_type(lhs)) { case NODE_LVAR: - local_add(p, VAR_NODE_SYMBOL(lhs)); + local_add(p, var_node(lhs)->symbol); break; case NODE_CONST: if (p->in_def) @@ -1797,7 +1797,7 @@ var_reference(parser_state *p, node *lhs) { /* Check if this is a variable-sized node */ if (node_type_p(lhs, NODE_LVAR)) { - mrb_sym sym = VAR_NODE_SYMBOL(lhs); + mrb_sym sym = var_node(lhs)->symbol; if (!local_var_p(p, sym)) { node *n = new_fcall(p, sym, 0); /* Don't free variable-sized nodes - they're managed by the parser allocator */ @@ -2205,7 +2205,7 @@ stmts : none | stmts terms stmt { /* Update the cons-list inside the existing variable-sized node */ - STMTS_NODE_STMTS($1) = push(STMTS_NODE_STMTS($1), newline_node($3)); + stmts_node($1)->stmts = push(stmts_node($1)->stmts, newline_node($3)); $$ = $1; } | error stmt @@ -7731,61 +7731,61 @@ dump_node(mrb_state *mrb, node *tree, int offset) /* Variable-sized node cases */ case NODE_SCOPE: printf("NODE_SCOPE:\n"); - if (SCOPE_NODE_LOCALS(tree)) { - dump_locals(mrb, SCOPE_NODE_LOCALS(tree), offset+1, lineno); + if (scope_node(tree)->locals) { + dump_locals(mrb, scope_node(tree)->locals, offset+1, lineno); } - if (SCOPE_NODE_BODY(tree)) { + if (scope_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SCOPE_NODE_BODY(tree), offset+2); + dump_node(mrb, scope_node(tree)->body, offset+2); } break; case NODE_INT: - printf("NODE_INT: %d\n", INT_NODE_VALUE(tree)); + printf("NODE_INT: %d\n", int_node(tree)->value); break; case NODE_BIGINT: - printf("NODE_BIGINT: %s (base %d)\n", BIGINT_NODE_STRING(tree), BIGINT_NODE_BASE(tree)); + printf("NODE_BIGINT: %s (base %d)\n", bigint_node(tree)->string, bigint_node(tree)->base); break; case NODE_FLOAT: - printf("NODE_FLOAT: %s\n", FLOAT_NODE_VALUE(tree)); + printf("NODE_FLOAT: %s\n", float_node(tree)->value); break; case NODE_STR: printf("NODE_STR:\n"); - dump_str(mrb, STR_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, str_node(tree)->list, offset+1, lineno); break; case NODE_XSTR: printf("NODE_XSTR:\n"); - dump_str(mrb, XSTR_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, xstr_node(tree)->list, offset+1, lineno); break; case NODE_SYM: - printf("NODE_SYM: %s\n", mrb_sym_dump(mrb, SYM_NODE_VALUE(tree))); + printf("NODE_SYM: %s\n", mrb_sym_dump(mrb, sym_node(tree)->symbol)); break; case NODE_DSYM: printf("NODE_DSYM:\n"); - dump_str(mrb, DSYM_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, str_node(tree)->list, offset+1, lineno); break; case NODE_LVAR: - printf("NODE_LVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_LVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_GVAR: - printf("NODE_GVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_GVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_IVAR: - printf("NODE_IVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_IVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_CVAR: - printf("NODE_CVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_CVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_NVAR: @@ -7793,25 +7793,25 @@ dump_node(mrb_state *mrb, node *tree, int offset) break; case NODE_CONST: - printf("NODE_CONST: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_CONST: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_CALL: - printf("NODE_CALL: %s\n", mrb_sym_dump(mrb, CALL_NODE_METHOD(tree))); - if (CALL_NODE_RECEIVER(tree)) { + printf("NODE_CALL: %s\n", mrb_sym_dump(mrb, call_node(tree)->method_name)); + if (call_node(tree)->receiver) { dump_prefix(offset+1, lineno); printf("receiver:\n"); - dump_node(mrb, CALL_NODE_RECEIVER(tree), offset+2); + dump_node(mrb, call_node(tree)->receiver, offset+2); } - if (CALL_NODE_ARGS(tree)) { - dump_callargs(mrb, CALL_NODE_ARGS(tree), offset, lineno); + if (call_node(tree)->args) { + dump_callargs(mrb, call_node(tree)->args, offset, lineno); } break; case NODE_ARRAY: printf("NODE_ARRAY:\n"); - if (ARRAY_NODE_ELEMENTS(tree)) { - dump_recur(mrb, ARRAY_NODE_ELEMENTS(tree), offset+1); + if (array_node(tree)->elements) { + dump_recur(mrb, array_node(tree)->elements, offset+1); } break; @@ -7833,49 +7833,49 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_IF: printf("NODE_IF:\n"); - if (IF_NODE_CONDITION(tree)) { + if (if_node(tree)->condition) { dump_prefix(offset+1, lineno); printf("cond:\n"); - dump_node(mrb, IF_NODE_CONDITION(tree), offset+2); + dump_node(mrb, if_node(tree)->condition, offset+2); } - if (IF_NODE_THEN(tree)) { + if (if_node(tree)->then_body) { dump_prefix(offset+1, lineno); printf("then:\n"); - dump_node(mrb, IF_NODE_THEN(tree), offset+2); + dump_node(mrb, if_node(tree)->then_body, offset+2); } - if (IF_NODE_ELSE(tree)) { + if (if_node(tree)->else_body) { dump_prefix(offset+1, lineno); printf("else:\n"); - dump_node(mrb, IF_NODE_ELSE(tree), offset+2); + dump_node(mrb, if_node(tree)->else_body, offset+2); } break; case NODE_DEF: - printf("NODE_DEF: %s\n", mrb_sym_dump(mrb, DEF_NODE_NAME(tree))); - if (DEF_NODE_ARGS(tree)) { - dump_args(mrb, SDEF_NODE_ARGS(tree), offset+1, lineno); + printf("NODE_DEF: %s\n", mrb_sym_dump(mrb, def_node(tree)->name)); + if (def_node(tree)->args) { + dump_args(mrb, sdef_node(tree)->args, offset+1, lineno); } - if (DEF_NODE_LOCALS(tree)) { - dump_locals(mrb, DEF_NODE_LOCALS(tree), offset+1, lineno); + if (def_node(tree)->locals) { + dump_locals(mrb, def_node(tree)->locals, offset+1, lineno); } - if (DEF_NODE_BODY(tree)) { + if (def_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, DEF_NODE_BODY(tree), offset+2); + dump_node(mrb, def_node(tree)->body, offset+2); } break; case NODE_ASGN: printf("NODE_ASGN:\n"); - if (ASGN_NODE_LHS(tree)) { + if (asgn_node(tree)->lhs) { dump_prefix(offset+1, lineno); printf("lhs:\n"); - dump_node(mrb, ASGN_NODE_LHS(tree), offset+2); + dump_node(mrb, asgn_node(tree)->lhs, offset+2); } - if (ASGN_NODE_RHS(tree)) { + if (asgn_node(tree)->rhs) { dump_prefix(offset+1, lineno); printf("rhs:\n"); - dump_node(mrb, ASGN_NODE_RHS(tree), offset+2); + dump_node(mrb, asgn_node(tree)->rhs, offset+2); } break; @@ -7883,93 +7883,93 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_MARG: printf("%s:\n", get_node_type(tree) == NODE_MASGN ? "NODE_MASGN" : "NODE_MARG"); /* Handle pre-splat variables */ - if (MASGN_NODE_PRE(tree)) { + if (masgn_node(tree)->pre) { dump_prefix(offset+1, lineno); printf("pre:\n"); - dump_recur(mrb, MASGN_NODE_PRE(tree), offset+2); + dump_recur(mrb, masgn_node(tree)->pre, offset+2); } /* Handle splat variable (can be -1 sentinel for anonymous splat) */ - if (MASGN_NODE_REST(tree)) { - if ((intptr_t)MASGN_NODE_REST(tree) == -1) { + if (masgn_node(tree)->rest) { + if ((intptr_t)masgn_node(tree)->rest == -1) { dump_prefix(offset+1, lineno); printf("rest: *\n"); } else { dump_prefix(offset+1, lineno); printf("rest:\n"); - dump_node(mrb, MASGN_NODE_REST(tree), offset+2); + dump_node(mrb, masgn_node(tree)->rest, offset+2); } } /* Handle post-splat variables */ - if (MASGN_NODE_POST(tree)) { + if (masgn_node(tree)->post) { dump_prefix(offset+1, lineno); printf("post:\n"); - dump_recur(mrb, MASGN_NODE_POST(tree), offset+2); + dump_recur(mrb, masgn_node(tree)->post, offset+2); } - if (MASGN_NODE_RHS(tree)) { + if (masgn_node(tree)->rhs) { dump_prefix(offset+1, lineno); printf("rhs:\n"); - dump_node(mrb, MASGN_NODE_RHS(tree), offset+2); + dump_node(mrb, masgn_node(tree)->rhs, offset+2); } break; case NODE_RETURN: printf("NODE_RETURN:\n"); - if (RETURN_NODE_ARGS(tree)) { - dump_node(mrb, RETURN_NODE_ARGS(tree), offset); + if (return_node(tree)->args) { + dump_node(mrb, return_node(tree)->args, offset); } break; case NODE_BREAK: printf("NODE_BREAK:\n"); - if (BREAK_NODE_VALUE(tree)) { + if (break_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, BREAK_NODE_VALUE(tree), offset+2); + dump_node(mrb, break_node(tree)->value, offset+2); } break; case NODE_NEXT: printf("NODE_NEXT:\n"); - if (NEXT_NODE_VALUE(tree)) { + if (next_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, NEXT_NODE_VALUE(tree), offset+2); + dump_node(mrb, next_node(tree)->value, offset+2); } break; case NODE_NEGATE: printf("NODE_NEGATE:\n"); - if (NEGATE_NODE_OPERAND(tree)) { + if (negate_node(tree)->operand) { dump_prefix(offset+1, lineno); printf("operand:\n"); - dump_node(mrb, NEGATE_NODE_OPERAND(tree), offset+2); + dump_node(mrb, negate_node(tree)->operand, offset+2); } break; case NODE_STMTS: printf("NODE_STMTS:\n"); - if (STMTS_NODE_STMTS(tree)) { - dump_recur(mrb, STMTS_NODE_STMTS(tree), offset+1); + if (stmts_node(tree)->stmts) { + dump_recur(mrb, stmts_node(tree)->stmts, offset+1); } break; case NODE_BEGIN: printf("NODE_BEGIN:\n"); - if (BEGIN_NODE_BODY(tree)) { - dump_node(mrb, BEGIN_NODE_BODY(tree), offset+1); + if (begin_node(tree)->body) { + dump_node(mrb, begin_node(tree)->body, offset+1); } break; case NODE_RESCUE: printf("NODE_RESCUE:\n"); - if (RESCUE_NODE_BODY(tree)) { + if (rescue_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, RESCUE_NODE_BODY(tree), offset+2); + dump_node(mrb, rescue_node(tree)->body, offset+2); } - if (RESCUE_NODE_RESCUE_CLAUSES(tree)) { - node *n2 = RESCUE_NODE_RESCUE_CLAUSES(tree); + if (rescue_node(tree)->rescue_clauses) { + node *n2 = rescue_node(tree)->rescue_clauses; dump_prefix(offset+1, lineno); printf("rescue:\n"); while (n2) { @@ -7992,24 +7992,24 @@ dump_node(mrb_state *mrb, node *tree, int offset) n2 = n2->cdr; } } - if (RESCUE_NODE_ELSE_CLAUSE(tree)) { + if (rescue_node(tree)->else_clause) { dump_prefix(offset+1, lineno); printf("else:\n"); - dump_node(mrb, RESCUE_NODE_ELSE_CLAUSE(tree), offset+2); + dump_node(mrb, rescue_node(tree)->else_clause, offset+2); } break; case NODE_ENSURE: printf("NODE_ENSURE:\n"); - if (ENSURE_NODE_BODY(tree)) { + if (ensure_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, ENSURE_NODE_BODY(tree), offset+2); + dump_node(mrb, ensure_node(tree)->body, offset+2); } - if (ENSURE_NODE_ENSURE_CLAUSE(tree)) { + if (ensure_node(tree)->ensure_clause) { dump_prefix(offset+1, lineno); printf("ensure:\n"); - dump_node(mrb, ENSURE_NODE_ENSURE_CLAUSE(tree), offset+2); + dump_node(mrb, ensure_node(tree)->ensure_clause, offset+2); } break; @@ -8020,38 +8020,38 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_BLOCK: printf("NODE_BLOCK:\n"); block: - if (BLOCK_NODE_LOCALS(tree)) { - dump_locals(mrb, BLOCK_NODE_LOCALS(tree), offset+1, lineno); + if (block_node(tree)->locals) { + dump_locals(mrb, block_node(tree)->locals, offset+1, lineno); } - if (BLOCK_NODE_ARGS(tree)) { - dump_args(mrb, BLOCK_NODE_ARGS(tree), offset+1, lineno); + if (block_node(tree)->args) { + dump_args(mrb, block_node(tree)->args, offset+1, lineno); } dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, BLOCK_NODE_BODY(tree), offset+2); + dump_node(mrb, block_node(tree)->body, offset+2); break; case NODE_AND: printf("NODE_AND:\n"); - dump_node(mrb, AND_NODE_LEFT(tree), offset+1); - dump_node(mrb, AND_NODE_RIGHT(tree), offset+1); + dump_node(mrb, and_node(tree)->left, offset+1); + dump_node(mrb, and_node(tree)->right, offset+1); break; case NODE_OR: printf("NODE_OR:\n"); - dump_node(mrb, OR_NODE_LEFT(tree), offset+1); - dump_node(mrb, OR_NODE_RIGHT(tree), offset+1); + dump_node(mrb, or_node(tree)->left, offset+1); + dump_node(mrb, or_node(tree)->right, offset+1); break; case NODE_CASE: printf("NODE_CASE:\n"); - if (CASE_NODE_VALUE(tree)) { + if (case_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, CASE_NODE_VALUE(tree), offset+2); + dump_node(mrb, case_node(tree)->value, offset+2); } - if (CASE_NODE_BODY(tree)) { - node *when_node = CASE_NODE_BODY(tree); + if (case_node(tree)->body) { + node *when_node = case_node(tree)->body; while (when_node) { dump_prefix(offset+1, lineno); printf("when:\n"); @@ -8086,22 +8086,22 @@ dump_node(mrb_state *mrb, node *tree, int offset) dump_loop_node: dump_prefix(offset+1, lineno); printf("cond:\n"); - dump_node(mrb, WHILE_NODE_CONDITION(tree), offset+2); + dump_node(mrb, while_node(tree)->condition, offset+2); dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, WHILE_NODE_BODY(tree), offset+2); + dump_node(mrb, while_node(tree)->body, offset+2); break; case NODE_FOR: printf("NODE_FOR:\n"); - if (FOR_NODE_VAR(tree)) { + if (for_node(tree)->var) { dump_prefix(offset+1, lineno); printf("var:\n"); /* FOR_NODE_VAR structure: * var_list->car: cons-list of pre-splat variables * var_list->cdr->car: splat varnode (not a cons-list) * var_list->cdr->cdr->car: cons-list of post-splat variables */ - node *var_list = FOR_NODE_VAR(tree); + node *var_list = for_node(tree)->var; if (var_list) { dump_recur(mrb, var_list->car, offset+2); if (var_list && var_list->cdr) { @@ -8118,30 +8118,30 @@ dump_node(mrb_state *mrb, node *tree, int offset) } } } - if (FOR_NODE_ITERABLE(tree)) { + if (for_node(tree)->iterable) { dump_prefix(offset+1, lineno); printf("iterable:\n"); - dump_node(mrb, FOR_NODE_ITERABLE(tree), offset+2); + dump_node(mrb, for_node(tree)->iterable, offset+2); } - if (FOR_NODE_BODY(tree)) { + if (for_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, FOR_NODE_BODY(tree), offset+2); + dump_node(mrb, for_node(tree)->body, offset+2); } break; case NODE_DOT2: printf("NODE_DOT2:\n"); { - if (DOT2_NODE_LEFT(tree)) { + if (dot2_node(tree)->left) { dump_prefix(offset+1, lineno); printf("left:\n"); - dump_node(mrb, DOT2_NODE_LEFT(tree), offset+2); + dump_node(mrb, dot2_node(tree)->left, offset+2); } - if (DOT2_NODE_RIGHT(tree)) { + if (dot2_node(tree)->right) { dump_prefix(offset+1, lineno); printf("right:\n"); - dump_node(mrb, DOT2_NODE_RIGHT(tree), offset+2); + dump_node(mrb, dot2_node(tree)->right, offset+2); } } break; @@ -8149,37 +8149,37 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_DOT3: printf("NODE_DOT3:\n"); { - if (DOT3_NODE_LEFT(tree)) { + if (dot3_node(tree)->left) { dump_prefix(offset+1, lineno); printf("left:\n"); - dump_node(mrb, DOT3_NODE_LEFT(tree), offset+2); + dump_node(mrb, dot3_node(tree)->left, offset+2); } - if (DOT3_NODE_RIGHT(tree)) { + if (dot3_node(tree)->right) { dump_prefix(offset+1, lineno); printf("right:\n"); - dump_node(mrb, DOT3_NODE_RIGHT(tree), offset+2); + dump_node(mrb, dot3_node(tree)->right, offset+2); } } break; case NODE_COLON2: printf("NODE_COLON2:\n"); - if (COLON2_NODE_BASE(tree)) { + if (colon2_node(tree)->base) { dump_prefix(offset+1, lineno); printf("base:\n"); - dump_node(mrb, COLON2_NODE_BASE(tree), offset+2); + dump_node(mrb, colon2_node(tree)->base, offset+2); } dump_prefix(offset+1, lineno); - printf("name: %s\n", mrb_sym_name(mrb, COLON2_NODE_NAME(tree))); + printf("name: %s\n", mrb_sym_name(mrb, colon2_node(tree)->name)); break; case NODE_COLON3: - printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, COLON3_NODE_NAME(tree))); + printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, colon3_node(tree)->name)); break; case NODE_HASH: printf("NODE_HASH:\n"); - node *pairs = HASH_NODE_PAIRS(tree); + node *pairs = hash_node(tree)->pairs; while (pairs) { dump_prefix(offset+1, lineno); printf("key:\n"); @@ -8199,37 +8199,37 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_SPLAT: printf("NODE_SPLAT:\n"); - dump_node(mrb, SPLAT_NODE_VALUE(tree), offset+1); + dump_node(mrb, splat_node(tree)->value, offset+1); break; case NODE_OP_ASGN: printf("NODE_OP_ASGN:\n"); dump_prefix(offset+1, lineno); printf("lhs:\n"); - dump_node(mrb, OP_ASGN_NODE_LHS(tree), offset+2); + dump_node(mrb, op_asgn_node(tree)->lhs, offset+2); dump_prefix(offset+1, lineno); - printf("op='%s' (%d)\n", mrb_sym_name(mrb, OP_ASGN_NODE_OP(tree)), (int)OP_ASGN_NODE_OP(tree)); - dump_node(mrb, OP_ASGN_NODE_RHS(tree), offset+1); + printf("op='%s' (%d)\n", mrb_sym_name(mrb, op_asgn_node(tree)->op), (int)op_asgn_node(tree)->op); + dump_node(mrb, op_asgn_node(tree)->rhs, offset+1); break; case NODE_SUPER: printf("NODE_SUPER:\n"); - if (SUPER_NODE_ARGS(tree)) { - dump_callargs(mrb, SUPER_NODE_ARGS(tree), offset, lineno); + if (super_node(tree)->args) { + dump_callargs(mrb, super_node(tree)->args, offset, lineno); } break; case NODE_ZSUPER: printf("NODE_ZSUPER:\n"); - if (SUPER_NODE_ARGS(tree)) { - dump_callargs(mrb, SUPER_NODE_ARGS(tree), offset, lineno); + if (super_node(tree)->args) { + dump_callargs(mrb, super_node(tree)->args, offset, lineno); } break; case NODE_YIELD: printf("NODE_YIELD:\n"); - if (YIELD_NODE_ARGS(tree)) { - dump_callargs(mrb, YIELD_NODE_ARGS(tree), offset, lineno); + if (yield_node(tree)->args) { + dump_callargs(mrb, yield_node(tree)->args, offset, lineno); } break; @@ -8256,23 +8256,23 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_REGX: printf("NODE_REGX:\n"); - if (REGX_NODE_LIST(tree)) { - dump_str(mrb, REGX_NODE_LIST(tree), offset+1, lineno); + if (regx_node(tree)->list) { + dump_str(mrb, regx_node(tree)->list, offset+1, lineno); } - if (REGX_NODE_FLAGS(tree)) { + if (regx_node(tree)->flags) { dump_prefix(offset+1, lineno); - printf("flags: %s\n", REGX_NODE_FLAGS(tree)); + printf("flags: %s\n", regx_node(tree)->flags); } - if (REGX_NODE_ENCODING(tree)) { + if (regx_node(tree)->encoding) { dump_prefix(offset+1, lineno); - printf("encoding: %s\n", REGX_NODE_ENCODING(tree)); + printf("encoding: %s\n", regx_node(tree)->encoding); } break; case NODE_WORDS: printf("NODE_WORDS:\n"); - if (WORDS_NODE_ARGS(tree)) { - node *list = WORDS_NODE_ARGS(tree); + if (words_node(tree)->args) { + node *list = words_node(tree)->args; while (list && list->car) { node *item = list->car; if (item->car == 0 && item->cdr == 0) { @@ -8293,8 +8293,8 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_SYMBOLS: printf("NODE_SYMBOLS:\n"); - if (SYMBOLS_NODE_ARGS(tree)) { - node *list = SYMBOLS_NODE_ARGS(tree); + if (symbols_node(tree)->args) { + node *list = symbols_node(tree)->args; while (list && list->car) { node *item = list->car; if (item->car == 0 && item->cdr == 0) { @@ -8332,64 +8332,64 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_CLASS: printf("NODE_CLASS:\n"); - if (CLASS_NODE_NAME(tree)) { - dump_cpath(mrb, MODULE_NODE_NAME(tree), offset+1, lineno); + if (class_node(tree)->name) { + dump_cpath(mrb, module_node(tree)->name, offset+1, lineno); } - if (CLASS_NODE_SUPERCLASS(tree)) { + if (class_node(tree)->superclass) { dump_prefix(offset+1, lineno); printf("super:\n"); - dump_node(mrb, CLASS_NODE_SUPERCLASS(tree), offset+2); + dump_node(mrb, class_node(tree)->superclass, offset+2); } - if (CLASS_NODE_BODY(tree)) { + if (class_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, CLASS_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, class_node(tree)->body->cdr, offset+2); } break; case NODE_MODULE: printf("NODE_MODULE:\n"); - if (MODULE_NODE_NAME(tree)) { - dump_cpath(mrb, MODULE_NODE_NAME(tree), offset+1, lineno); + if (module_node(tree)->name) { + dump_cpath(mrb, module_node(tree)->name, offset+1, lineno); } - if (MODULE_NODE_BODY(tree)) { + if (module_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, MODULE_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, module_node(tree)->body->cdr, offset+2); } break; case NODE_SCLASS: printf("NODE_SCLASS:\n"); - if (SCLASS_NODE_OBJ(tree)) { + if (sclass_node(tree)->obj) { dump_prefix(offset+1, lineno); printf("obj:\n"); - dump_node(mrb, SCLASS_NODE_OBJ(tree), offset+2); + dump_node(mrb, sclass_node(tree)->obj, offset+2); } - if (SCLASS_NODE_BODY(tree)) { + if (sclass_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SCLASS_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, sclass_node(tree)->body->cdr, offset+2); } break; case NODE_SDEF: - printf("NODE_SDEF: %s\n", mrb_sym_dump(mrb, DEF_NODE_NAME(tree))); - if (SDEF_NODE_OBJ(tree)) { + printf("NODE_SDEF: %s\n", mrb_sym_dump(mrb, def_node(tree)->name)); + if (sdef_node(tree)->obj) { dump_prefix(offset+1, lineno); printf("recv:\n"); - dump_node(mrb, SDEF_NODE_OBJ(tree), offset+2); + dump_node(mrb, sdef_node(tree)->obj, offset+2); } - if (SDEF_NODE_ARGS(tree)) { - dump_args(mrb, SDEF_NODE_ARGS(tree), offset+1, lineno); + if (sdef_node(tree)->args) { + dump_args(mrb, sdef_node(tree)->args, offset+1, lineno); } - if (SDEF_NODE_LOCALS(tree)) { - dump_locals(mrb, SDEF_NODE_LOCALS(tree), offset+1, lineno); + if (sdef_node(tree)->locals) { + dump_locals(mrb, sdef_node(tree)->locals, offset+1, lineno); } - if (SDEF_NODE_BODY(tree)) { + if (sdef_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SDEF_NODE_BODY(tree), offset+2); + dump_node(mrb, sdef_node(tree)->body, offset+2); } break; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index b24a4ffcb..b5d4f08a8 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -1786,7 +1786,7 @@ call_with_block(parser_state *p, node *a, node *b) { struct mrb_ast_call_node *call = call_node(a); - if (call->args && CALLARGS_NODE_BLOCK(call->args)) { + if (call->args && callargs_node(call->args)->block_arg) { yyerror(NULL, p, "both block arg and actual block given"); return; } @@ -1842,7 +1842,7 @@ assignable(parser_state *p, node *lhs) { switch (get_node_type(lhs)) { case NODE_LVAR: - local_add(p, VAR_NODE_SYMBOL(lhs)); + local_add(p, var_node(lhs)->symbol); break; case NODE_CONST: if (p->in_def) @@ -1859,7 +1859,7 @@ var_reference(parser_state *p, node *lhs) { /* Check if this is a variable-sized node */ if (node_type_p(lhs, NODE_LVAR)) { - mrb_sym sym = VAR_NODE_SYMBOL(lhs); + mrb_sym sym = var_node(lhs)->symbol; if (!local_var_p(p, sym)) { node *n = new_fcall(p, sym, 0); /* Don't free variable-sized nodes - they're managed by the parser allocator */ @@ -7317,7 +7317,7 @@ yyreduce: #line 2206 "mrbgems/mruby-compiler/core/parse.y" { /* Update the cons-list inside the existing variable-sized node */ - STMTS_NODE_STMTS((yyvsp[-2].nd)) = push(STMTS_NODE_STMTS((yyvsp[-2].nd)), newline_node((yyvsp[0].nd))); + stmts_node((yyvsp[-2].nd))->stmts = push(stmts_node((yyvsp[-2].nd))->stmts, newline_node((yyvsp[0].nd))); (yyval.nd) = (yyvsp[-2].nd); } #line 7324 "mrbgems/mruby-compiler/core/y.tab.c" @@ -14560,61 +14560,61 @@ dump_node(mrb_state *mrb, node *tree, int offset) /* Variable-sized node cases */ case NODE_SCOPE: printf("NODE_SCOPE:\n"); - if (SCOPE_NODE_LOCALS(tree)) { - dump_locals(mrb, SCOPE_NODE_LOCALS(tree), offset+1, lineno); + if (scope_node(tree)->locals) { + dump_locals(mrb, scope_node(tree)->locals, offset+1, lineno); } - if (SCOPE_NODE_BODY(tree)) { + if (scope_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SCOPE_NODE_BODY(tree), offset+2); + dump_node(mrb, scope_node(tree)->body, offset+2); } break; case NODE_INT: - printf("NODE_INT: %d\n", INT_NODE_VALUE(tree)); + printf("NODE_INT: %d\n", int_node(tree)->value); break; case NODE_BIGINT: - printf("NODE_BIGINT: %s (base %d)\n", BIGINT_NODE_STRING(tree), BIGINT_NODE_BASE(tree)); + printf("NODE_BIGINT: %s (base %d)\n", bigint_node(tree)->string, bigint_node(tree)->base); break; case NODE_FLOAT: - printf("NODE_FLOAT: %s\n", FLOAT_NODE_VALUE(tree)); + printf("NODE_FLOAT: %s\n", float_node(tree)->value); break; case NODE_STR: printf("NODE_STR:\n"); - dump_str(mrb, STR_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, str_node(tree)->list, offset+1, lineno); break; case NODE_XSTR: printf("NODE_XSTR:\n"); - dump_str(mrb, XSTR_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, xstr_node(tree)->list, offset+1, lineno); break; case NODE_SYM: - printf("NODE_SYM: %s\n", mrb_sym_dump(mrb, SYM_NODE_VALUE(tree))); + printf("NODE_SYM: %s\n", mrb_sym_dump(mrb, sym_node(tree)->symbol)); break; case NODE_DSYM: printf("NODE_DSYM:\n"); - dump_str(mrb, DSYM_NODE_LIST(tree), offset+1, lineno); + dump_str(mrb, str_node(tree)->list, offset+1, lineno); break; case NODE_LVAR: - printf("NODE_LVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_LVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_GVAR: - printf("NODE_GVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_GVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_IVAR: - printf("NODE_IVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_IVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_CVAR: - printf("NODE_CVAR: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_CVAR: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_NVAR: @@ -14622,25 +14622,25 @@ dump_node(mrb_state *mrb, node *tree, int offset) break; case NODE_CONST: - printf("NODE_CONST: %s\n", mrb_sym_dump(mrb, VAR_NODE_SYMBOL(tree))); + printf("NODE_CONST: %s\n", mrb_sym_dump(mrb, var_node(tree)->symbol)); break; case NODE_CALL: - printf("NODE_CALL: %s\n", mrb_sym_dump(mrb, CALL_NODE_METHOD(tree))); - if (CALL_NODE_RECEIVER(tree)) { + printf("NODE_CALL: %s\n", mrb_sym_dump(mrb, call_node(tree)->method_name)); + if (call_node(tree)->receiver) { dump_prefix(offset+1, lineno); printf("receiver:\n"); - dump_node(mrb, CALL_NODE_RECEIVER(tree), offset+2); + dump_node(mrb, call_node(tree)->receiver, offset+2); } - if (CALL_NODE_ARGS(tree)) { - dump_callargs(mrb, CALL_NODE_ARGS(tree), offset, lineno); + if (call_node(tree)->args) { + dump_callargs(mrb, call_node(tree)->args, offset, lineno); } break; case NODE_ARRAY: printf("NODE_ARRAY:\n"); - if (ARRAY_NODE_ELEMENTS(tree)) { - dump_recur(mrb, ARRAY_NODE_ELEMENTS(tree), offset+1); + if (array_node(tree)->elements) { + dump_recur(mrb, array_node(tree)->elements, offset+1); } break; @@ -14662,49 +14662,49 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_IF: printf("NODE_IF:\n"); - if (IF_NODE_CONDITION(tree)) { + if (if_node(tree)->condition) { dump_prefix(offset+1, lineno); printf("cond:\n"); - dump_node(mrb, IF_NODE_CONDITION(tree), offset+2); + dump_node(mrb, if_node(tree)->condition, offset+2); } - if (IF_NODE_THEN(tree)) { + if (if_node(tree)->then_body) { dump_prefix(offset+1, lineno); printf("then:\n"); - dump_node(mrb, IF_NODE_THEN(tree), offset+2); + dump_node(mrb, if_node(tree)->then_body, offset+2); } - if (IF_NODE_ELSE(tree)) { + if (if_node(tree)->else_body) { dump_prefix(offset+1, lineno); printf("else:\n"); - dump_node(mrb, IF_NODE_ELSE(tree), offset+2); + dump_node(mrb, if_node(tree)->else_body, offset+2); } break; case NODE_DEF: - printf("NODE_DEF: %s\n", mrb_sym_dump(mrb, DEF_NODE_NAME(tree))); - if (DEF_NODE_ARGS(tree)) { - dump_args(mrb, SDEF_NODE_ARGS(tree), offset+1, lineno); + printf("NODE_DEF: %s\n", mrb_sym_dump(mrb, def_node(tree)->name)); + if (def_node(tree)->args) { + dump_args(mrb, sdef_node(tree)->args, offset+1, lineno); } - if (DEF_NODE_LOCALS(tree)) { - dump_locals(mrb, DEF_NODE_LOCALS(tree), offset+1, lineno); + if (def_node(tree)->locals) { + dump_locals(mrb, def_node(tree)->locals, offset+1, lineno); } - if (DEF_NODE_BODY(tree)) { + if (def_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, DEF_NODE_BODY(tree), offset+2); + dump_node(mrb, def_node(tree)->body, offset+2); } break; case NODE_ASGN: printf("NODE_ASGN:\n"); - if (ASGN_NODE_LHS(tree)) { + if (asgn_node(tree)->lhs) { dump_prefix(offset+1, lineno); printf("lhs:\n"); - dump_node(mrb, ASGN_NODE_LHS(tree), offset+2); + dump_node(mrb, asgn_node(tree)->lhs, offset+2); } - if (ASGN_NODE_RHS(tree)) { + if (asgn_node(tree)->rhs) { dump_prefix(offset+1, lineno); printf("rhs:\n"); - dump_node(mrb, ASGN_NODE_RHS(tree), offset+2); + dump_node(mrb, asgn_node(tree)->rhs, offset+2); } break; @@ -14712,93 +14712,93 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_MARG: printf("%s:\n", get_node_type(tree) == NODE_MASGN ? "NODE_MASGN" : "NODE_MARG"); /* Handle pre-splat variables */ - if (MASGN_NODE_PRE(tree)) { + if (masgn_node(tree)->pre) { dump_prefix(offset+1, lineno); printf("pre:\n"); - dump_recur(mrb, MASGN_NODE_PRE(tree), offset+2); + dump_recur(mrb, masgn_node(tree)->pre, offset+2); } /* Handle splat variable (can be -1 sentinel for anonymous splat) */ - if (MASGN_NODE_REST(tree)) { - if ((intptr_t)MASGN_NODE_REST(tree) == -1) { + if (masgn_node(tree)->rest) { + if ((intptr_t)masgn_node(tree)->rest == -1) { dump_prefix(offset+1, lineno); printf("rest: *\n"); } else { dump_prefix(offset+1, lineno); printf("rest:\n"); - dump_node(mrb, MASGN_NODE_REST(tree), offset+2); + dump_node(mrb, masgn_node(tree)->rest, offset+2); } } /* Handle post-splat variables */ - if (MASGN_NODE_POST(tree)) { + if (masgn_node(tree)->post) { dump_prefix(offset+1, lineno); printf("post:\n"); - dump_recur(mrb, MASGN_NODE_POST(tree), offset+2); + dump_recur(mrb, masgn_node(tree)->post, offset+2); } - if (MASGN_NODE_RHS(tree)) { + if (masgn_node(tree)->rhs) { dump_prefix(offset+1, lineno); printf("rhs:\n"); - dump_node(mrb, MASGN_NODE_RHS(tree), offset+2); + dump_node(mrb, masgn_node(tree)->rhs, offset+2); } break; case NODE_RETURN: printf("NODE_RETURN:\n"); - if (RETURN_NODE_ARGS(tree)) { - dump_node(mrb, RETURN_NODE_ARGS(tree), offset); + if (return_node(tree)->args) { + dump_node(mrb, return_node(tree)->args, offset); } break; case NODE_BREAK: printf("NODE_BREAK:\n"); - if (BREAK_NODE_VALUE(tree)) { + if (break_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, BREAK_NODE_VALUE(tree), offset+2); + dump_node(mrb, break_node(tree)->value, offset+2); } break; case NODE_NEXT: printf("NODE_NEXT:\n"); - if (NEXT_NODE_VALUE(tree)) { + if (next_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, NEXT_NODE_VALUE(tree), offset+2); + dump_node(mrb, next_node(tree)->value, offset+2); } break; case NODE_NEGATE: printf("NODE_NEGATE:\n"); - if (NEGATE_NODE_OPERAND(tree)) { + if (negate_node(tree)->operand) { dump_prefix(offset+1, lineno); printf("operand:\n"); - dump_node(mrb, NEGATE_NODE_OPERAND(tree), offset+2); + dump_node(mrb, negate_node(tree)->operand, offset+2); } break; case NODE_STMTS: printf("NODE_STMTS:\n"); - if (STMTS_NODE_STMTS(tree)) { - dump_recur(mrb, STMTS_NODE_STMTS(tree), offset+1); + if (stmts_node(tree)->stmts) { + dump_recur(mrb, stmts_node(tree)->stmts, offset+1); } break; case NODE_BEGIN: printf("NODE_BEGIN:\n"); - if (BEGIN_NODE_BODY(tree)) { - dump_node(mrb, BEGIN_NODE_BODY(tree), offset+1); + if (begin_node(tree)->body) { + dump_node(mrb, begin_node(tree)->body, offset+1); } break; case NODE_RESCUE: printf("NODE_RESCUE:\n"); - if (RESCUE_NODE_BODY(tree)) { + if (rescue_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, RESCUE_NODE_BODY(tree), offset+2); + dump_node(mrb, rescue_node(tree)->body, offset+2); } - if (RESCUE_NODE_RESCUE_CLAUSES(tree)) { - node *n2 = RESCUE_NODE_RESCUE_CLAUSES(tree); + if (rescue_node(tree)->rescue_clauses) { + node *n2 = rescue_node(tree)->rescue_clauses; dump_prefix(offset+1, lineno); printf("rescue:\n"); while (n2) { @@ -14821,24 +14821,24 @@ dump_node(mrb_state *mrb, node *tree, int offset) n2 = n2->cdr; } } - if (RESCUE_NODE_ELSE_CLAUSE(tree)) { + if (rescue_node(tree)->else_clause) { dump_prefix(offset+1, lineno); printf("else:\n"); - dump_node(mrb, RESCUE_NODE_ELSE_CLAUSE(tree), offset+2); + dump_node(mrb, rescue_node(tree)->else_clause, offset+2); } break; case NODE_ENSURE: printf("NODE_ENSURE:\n"); - if (ENSURE_NODE_BODY(tree)) { + if (ensure_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, ENSURE_NODE_BODY(tree), offset+2); + dump_node(mrb, ensure_node(tree)->body, offset+2); } - if (ENSURE_NODE_ENSURE_CLAUSE(tree)) { + if (ensure_node(tree)->ensure_clause) { dump_prefix(offset+1, lineno); printf("ensure:\n"); - dump_node(mrb, ENSURE_NODE_ENSURE_CLAUSE(tree), offset+2); + dump_node(mrb, ensure_node(tree)->ensure_clause, offset+2); } break; @@ -14849,38 +14849,38 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_BLOCK: printf("NODE_BLOCK:\n"); block: - if (BLOCK_NODE_LOCALS(tree)) { - dump_locals(mrb, BLOCK_NODE_LOCALS(tree), offset+1, lineno); + if (block_node(tree)->locals) { + dump_locals(mrb, block_node(tree)->locals, offset+1, lineno); } - if (BLOCK_NODE_ARGS(tree)) { - dump_args(mrb, BLOCK_NODE_ARGS(tree), offset+1, lineno); + if (block_node(tree)->args) { + dump_args(mrb, block_node(tree)->args, offset+1, lineno); } dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, BLOCK_NODE_BODY(tree), offset+2); + dump_node(mrb, block_node(tree)->body, offset+2); break; case NODE_AND: printf("NODE_AND:\n"); - dump_node(mrb, AND_NODE_LEFT(tree), offset+1); - dump_node(mrb, AND_NODE_RIGHT(tree), offset+1); + dump_node(mrb, and_node(tree)->left, offset+1); + dump_node(mrb, and_node(tree)->right, offset+1); break; case NODE_OR: printf("NODE_OR:\n"); - dump_node(mrb, OR_NODE_LEFT(tree), offset+1); - dump_node(mrb, OR_NODE_RIGHT(tree), offset+1); + dump_node(mrb, or_node(tree)->left, offset+1); + dump_node(mrb, or_node(tree)->right, offset+1); break; case NODE_CASE: printf("NODE_CASE:\n"); - if (CASE_NODE_VALUE(tree)) { + if (case_node(tree)->value) { dump_prefix(offset+1, lineno); printf("value:\n"); - dump_node(mrb, CASE_NODE_VALUE(tree), offset+2); + dump_node(mrb, case_node(tree)->value, offset+2); } - if (CASE_NODE_BODY(tree)) { - node *when_node = CASE_NODE_BODY(tree); + if (case_node(tree)->body) { + node *when_node = case_node(tree)->body; while (when_node) { dump_prefix(offset+1, lineno); printf("when:\n"); @@ -14915,22 +14915,22 @@ dump_node(mrb_state *mrb, node *tree, int offset) dump_loop_node: dump_prefix(offset+1, lineno); printf("cond:\n"); - dump_node(mrb, WHILE_NODE_CONDITION(tree), offset+2); + dump_node(mrb, while_node(tree)->condition, offset+2); dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, WHILE_NODE_BODY(tree), offset+2); + dump_node(mrb, while_node(tree)->body, offset+2); break; case NODE_FOR: printf("NODE_FOR:\n"); - if (FOR_NODE_VAR(tree)) { + if (for_node(tree)->var) { dump_prefix(offset+1, lineno); printf("var:\n"); /* FOR_NODE_VAR structure: * var_list->car: cons-list of pre-splat variables * var_list->cdr->car: splat varnode (not a cons-list) * var_list->cdr->cdr->car: cons-list of post-splat variables */ - node *var_list = FOR_NODE_VAR(tree); + node *var_list = for_node(tree)->var; if (var_list) { dump_recur(mrb, var_list->car, offset+2); if (var_list && var_list->cdr) { @@ -14947,30 +14947,30 @@ dump_node(mrb_state *mrb, node *tree, int offset) } } } - if (FOR_NODE_ITERABLE(tree)) { + if (for_node(tree)->iterable) { dump_prefix(offset+1, lineno); printf("iterable:\n"); - dump_node(mrb, FOR_NODE_ITERABLE(tree), offset+2); + dump_node(mrb, for_node(tree)->iterable, offset+2); } - if (FOR_NODE_BODY(tree)) { + if (for_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, FOR_NODE_BODY(tree), offset+2); + dump_node(mrb, for_node(tree)->body, offset+2); } break; case NODE_DOT2: printf("NODE_DOT2:\n"); { - if (DOT2_NODE_LEFT(tree)) { + if (dot2_node(tree)->left) { dump_prefix(offset+1, lineno); printf("left:\n"); - dump_node(mrb, DOT2_NODE_LEFT(tree), offset+2); + dump_node(mrb, dot2_node(tree)->left, offset+2); } - if (DOT2_NODE_RIGHT(tree)) { + if (dot2_node(tree)->right) { dump_prefix(offset+1, lineno); printf("right:\n"); - dump_node(mrb, DOT2_NODE_RIGHT(tree), offset+2); + dump_node(mrb, dot2_node(tree)->right, offset+2); } } break; @@ -14978,37 +14978,37 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_DOT3: printf("NODE_DOT3:\n"); { - if (DOT3_NODE_LEFT(tree)) { + if (dot3_node(tree)->left) { dump_prefix(offset+1, lineno); printf("left:\n"); - dump_node(mrb, DOT3_NODE_LEFT(tree), offset+2); + dump_node(mrb, dot3_node(tree)->left, offset+2); } - if (DOT3_NODE_RIGHT(tree)) { + if (dot3_node(tree)->right) { dump_prefix(offset+1, lineno); printf("right:\n"); - dump_node(mrb, DOT3_NODE_RIGHT(tree), offset+2); + dump_node(mrb, dot3_node(tree)->right, offset+2); } } break; case NODE_COLON2: printf("NODE_COLON2:\n"); - if (COLON2_NODE_BASE(tree)) { + if (colon2_node(tree)->base) { dump_prefix(offset+1, lineno); printf("base:\n"); - dump_node(mrb, COLON2_NODE_BASE(tree), offset+2); + dump_node(mrb, colon2_node(tree)->base, offset+2); } dump_prefix(offset+1, lineno); - printf("name: %s\n", mrb_sym_name(mrb, COLON2_NODE_NAME(tree))); + printf("name: %s\n", mrb_sym_name(mrb, colon2_node(tree)->name)); break; case NODE_COLON3: - printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, COLON3_NODE_NAME(tree))); + printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, colon3_node(tree)->name)); break; case NODE_HASH: printf("NODE_HASH:\n"); - node *pairs = HASH_NODE_PAIRS(tree); + node *pairs = hash_node(tree)->pairs; while (pairs) { dump_prefix(offset+1, lineno); printf("key:\n"); @@ -15028,37 +15028,37 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_SPLAT: printf("NODE_SPLAT:\n"); - dump_node(mrb, SPLAT_NODE_VALUE(tree), offset+1); + dump_node(mrb, splat_node(tree)->value, offset+1); break; case NODE_OP_ASGN: printf("NODE_OP_ASGN:\n"); dump_prefix(offset+1, lineno); printf("lhs:\n"); - dump_node(mrb, OP_ASGN_NODE_LHS(tree), offset+2); + dump_node(mrb, op_asgn_node(tree)->lhs, offset+2); dump_prefix(offset+1, lineno); - printf("op='%s' (%d)\n", mrb_sym_name(mrb, OP_ASGN_NODE_OP(tree)), (int)OP_ASGN_NODE_OP(tree)); - dump_node(mrb, OP_ASGN_NODE_RHS(tree), offset+1); + printf("op='%s' (%d)\n", mrb_sym_name(mrb, op_asgn_node(tree)->op), (int)op_asgn_node(tree)->op); + dump_node(mrb, op_asgn_node(tree)->rhs, offset+1); break; case NODE_SUPER: printf("NODE_SUPER:\n"); - if (SUPER_NODE_ARGS(tree)) { - dump_callargs(mrb, SUPER_NODE_ARGS(tree), offset, lineno); + if (super_node(tree)->args) { + dump_callargs(mrb, super_node(tree)->args, offset, lineno); } break; case NODE_ZSUPER: printf("NODE_ZSUPER:\n"); - if (SUPER_NODE_ARGS(tree)) { - dump_callargs(mrb, SUPER_NODE_ARGS(tree), offset, lineno); + if (super_node(tree)->args) { + dump_callargs(mrb, super_node(tree)->args, offset, lineno); } break; case NODE_YIELD: printf("NODE_YIELD:\n"); - if (YIELD_NODE_ARGS(tree)) { - dump_callargs(mrb, YIELD_NODE_ARGS(tree), offset, lineno); + if (yield_node(tree)->args) { + dump_callargs(mrb, yield_node(tree)->args, offset, lineno); } break; @@ -15085,23 +15085,23 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_REGX: printf("NODE_REGX:\n"); - if (REGX_NODE_LIST(tree)) { - dump_str(mrb, REGX_NODE_LIST(tree), offset+1, lineno); + if (regx_node(tree)->list) { + dump_str(mrb, regx_node(tree)->list, offset+1, lineno); } - if (REGX_NODE_FLAGS(tree)) { + if (regx_node(tree)->flags) { dump_prefix(offset+1, lineno); - printf("flags: %s\n", REGX_NODE_FLAGS(tree)); + printf("flags: %s\n", regx_node(tree)->flags); } - if (REGX_NODE_ENCODING(tree)) { + if (regx_node(tree)->encoding) { dump_prefix(offset+1, lineno); - printf("encoding: %s\n", REGX_NODE_ENCODING(tree)); + printf("encoding: %s\n", regx_node(tree)->encoding); } break; case NODE_WORDS: printf("NODE_WORDS:\n"); - if (WORDS_NODE_ARGS(tree)) { - node *list = WORDS_NODE_ARGS(tree); + if (words_node(tree)->args) { + node *list = words_node(tree)->args; while (list && list->car) { node *item = list->car; if (item->car == 0 && item->cdr == 0) { @@ -15122,8 +15122,8 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_SYMBOLS: printf("NODE_SYMBOLS:\n"); - if (SYMBOLS_NODE_ARGS(tree)) { - node *list = SYMBOLS_NODE_ARGS(tree); + if (symbols_node(tree)->args) { + node *list = symbols_node(tree)->args; while (list && list->car) { node *item = list->car; if (item->car == 0 && item->cdr == 0) { @@ -15161,64 +15161,64 @@ dump_node(mrb_state *mrb, node *tree, int offset) case NODE_CLASS: printf("NODE_CLASS:\n"); - if (CLASS_NODE_NAME(tree)) { - dump_cpath(mrb, MODULE_NODE_NAME(tree), offset+1, lineno); + if (class_node(tree)->name) { + dump_cpath(mrb, module_node(tree)->name, offset+1, lineno); } - if (CLASS_NODE_SUPERCLASS(tree)) { + if (class_node(tree)->superclass) { dump_prefix(offset+1, lineno); printf("super:\n"); - dump_node(mrb, CLASS_NODE_SUPERCLASS(tree), offset+2); + dump_node(mrb, class_node(tree)->superclass, offset+2); } - if (CLASS_NODE_BODY(tree)) { + if (class_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, CLASS_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, class_node(tree)->body->cdr, offset+2); } break; case NODE_MODULE: printf("NODE_MODULE:\n"); - if (MODULE_NODE_NAME(tree)) { - dump_cpath(mrb, MODULE_NODE_NAME(tree), offset+1, lineno); + if (module_node(tree)->name) { + dump_cpath(mrb, module_node(tree)->name, offset+1, lineno); } - if (MODULE_NODE_BODY(tree)) { + if (module_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, MODULE_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, module_node(tree)->body->cdr, offset+2); } break; case NODE_SCLASS: printf("NODE_SCLASS:\n"); - if (SCLASS_NODE_OBJ(tree)) { + if (sclass_node(tree)->obj) { dump_prefix(offset+1, lineno); printf("obj:\n"); - dump_node(mrb, SCLASS_NODE_OBJ(tree), offset+2); + dump_node(mrb, sclass_node(tree)->obj, offset+2); } - if (SCLASS_NODE_BODY(tree)) { + if (sclass_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SCLASS_NODE_BODY(tree)->cdr, offset+2); + dump_node(mrb, sclass_node(tree)->body->cdr, offset+2); } break; case NODE_SDEF: - printf("NODE_SDEF: %s\n", mrb_sym_dump(mrb, DEF_NODE_NAME(tree))); - if (SDEF_NODE_OBJ(tree)) { + printf("NODE_SDEF: %s\n", mrb_sym_dump(mrb, def_node(tree)->name)); + if (sdef_node(tree)->obj) { dump_prefix(offset+1, lineno); printf("recv:\n"); - dump_node(mrb, SDEF_NODE_OBJ(tree), offset+2); + dump_node(mrb, sdef_node(tree)->obj, offset+2); } - if (SDEF_NODE_ARGS(tree)) { - dump_args(mrb, SDEF_NODE_ARGS(tree), offset+1, lineno); + if (sdef_node(tree)->args) { + dump_args(mrb, sdef_node(tree)->args, offset+1, lineno); } - if (SDEF_NODE_LOCALS(tree)) { - dump_locals(mrb, SDEF_NODE_LOCALS(tree), offset+1, lineno); + if (sdef_node(tree)->locals) { + dump_locals(mrb, sdef_node(tree)->locals, offset+1, lineno); } - if (SDEF_NODE_BODY(tree)) { + if (sdef_node(tree)->body) { dump_prefix(offset+1, lineno); printf("body:\n"); - dump_node(mrb, SDEF_NODE_BODY(tree), offset+2); + dump_node(mrb, sdef_node(tree)->body, offset+2); } break;