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: replace accessor macros with direct member access

Browse Source 
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 <noreply@anthropic.com>
This commit is contained in:
Yukihiro "Matz" Matsumoto
2025-09-30 22:48:50 +09:00
parent f6edae0918
commit ee80a2ef26
4 changed files with 322 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mrbgems/mruby-compiler/core/codegen.c
+18 -18
View File
@@ -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:
mrbgems/mruby-compiler/core/node.h
-145
View File
@@ -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 */
mrbgems/mruby-compiler/core/parse.y
+152 -152
View File
@@ -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: *<anonymous>\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;
mrbgems/mruby-compiler/core/y.tab.c
+152 -152
View File
@@ -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: *<anonymous>\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;