Ruby
2.7.0p0(2019-12-25revision647ee6f091eafcce70ffb75ddf7e121e192ab217)
|
Go to the documentation of this file.
15 #define NODE_BUF_DEFAULT_LEN 16
17 #define A(str) rb_str_cat2(buf, (str))
18 #define AR(str) rb_str_concat(buf, (str))
20 #define A_INDENT add_indent(buf, indent)
21 #define D_INDENT rb_str_cat2(indent, next_indent)
22 #define D_DEDENT rb_str_resize(indent, RSTRING_LEN(indent) - 4)
23 #define A_ID(id) add_id(buf, (id))
24 #define A_INT(val) rb_str_catf(buf, "%d", (val))
25 #define A_LONG(val) rb_str_catf(buf, "%ld", (val))
26 #define A_LIT(lit) AR(rb_inspect(lit))
27 #define A_NODE_HEADER(node, term) \
28 rb_str_catf(buf, "@ %s (line: %d, location: (%d,%d)-(%d,%d))%s"term, \
29 ruby_node_name(nd_type(node)), nd_line(node), \
30 nd_first_lineno(node), nd_first_column(node), \
31 nd_last_lineno(node), nd_last_column(node), \
32 (node->flags & NODE_FL_NEWLINE ? "*" : ""))
33 #define A_FIELD_HEADER(len, name, term) \
34 rb_str_catf(buf, "+- %.*s:"term, (len), (name))
35 #define D_FIELD_HEADER(len, name, term) (A_INDENT, A_FIELD_HEADER(len, name, term))
37 #define D_NULL_NODE (A_INDENT, A("(null node)\n"))
38 #define D_NODE_HEADER(node) (A_INDENT, A_NODE_HEADER(node, "\n"))
40 #define COMPOUND_FIELD(len, name) \
41 FIELD_BLOCK((D_FIELD_HEADER((len), (name), "\n"), D_INDENT), D_DEDENT)
43 #define COMPOUND_FIELD1(name, ann) \
44 COMPOUND_FIELD(FIELD_NAME_LEN(name, ann), \
45 FIELD_NAME_DESC(name, ann))
47 #define FIELD_NAME_DESC(name, ann) name " (" ann ")"
48 #define FIELD_NAME_LEN(name, ann) (int)( \
50 rb_strlen_lit(FIELD_NAME_DESC(name, ann)) : \
52 #define SIMPLE_FIELD(len, name) \
53 FIELD_BLOCK(D_FIELD_HEADER((len), (name), " "), A("\n"))
55 #define FIELD_BLOCK(init, reset) \
56 for (init, field_flag = 1; \
58 reset, field_flag = 0)
60 #define SIMPLE_FIELD1(name, ann) SIMPLE_FIELD(FIELD_NAME_LEN(name, ann), FIELD_NAME_DESC(name, ann))
61 #define F_CUSTOM1(name, ann) SIMPLE_FIELD1(#name, ann)
62 #define F_ID(name, ann) SIMPLE_FIELD1(#name, ann) A_ID(node->name)
63 #define F_GENTRY(name, ann) SIMPLE_FIELD1(#name, ann) A_ID((node->name)->id)
64 #define F_INT(name, ann) SIMPLE_FIELD1(#name, ann) A_INT(node->name)
65 #define F_LONG(name, ann) SIMPLE_FIELD1(#name, ann) A_LONG(node->name)
66 #define F_LIT(name, ann) SIMPLE_FIELD1(#name, ann) A_LIT(node->name)
67 #define F_MSG(name, ann, desc) SIMPLE_FIELD1(#name, ann) A(desc)
69 #define F_NODE(name, ann) \
70 COMPOUND_FIELD1(#name, ann) {dump_node(buf, indent, comment, node->name);}
74 A_INDENT; A("| # " ann "\n"); \
77 #define LAST_NODE (next_indent = " ")
108 static const char default_indent[] =
"| ";
114 const char *next_indent = default_indent;
118 node = node->nd_next;
130 const char *next_indent = default_indent;
143 ANN(
"statement sequence");
144 ANN(
"format: [nd_head]; ...; [nd_next]");
145 ANN(
"example: foo; bar");
150 comment ?
"statement #" :
"", ++
i);
153 dump_node(
buf, indent, comment, node->nd_head);
155 }
while (node->nd_next &&
157 (node = node->nd_next, 1));
166 ANN(
"format: if [nd_cond] then [nd_body] else [nd_else] end");
167 ANN(
"example: if x == 1 then foo else bar end");
175 ANN(
"unless statement");
176 ANN(
"format: unless [nd_cond] then [nd_body] else [nd_else] end");
177 ANN(
"example: unless x == 1 then foo else bar end");
185 ANN(
"case statement");
186 ANN(
"format: case [nd_head]; [nd_body]; end");
187 ANN(
"example: case x; when 1; foo; when 2; bar; else baz; end");
193 ANN(
"case statement with no head");
194 ANN(
"format: case; [nd_body]; end");
195 ANN(
"example: case; when 1; foo; when 2; bar; else baz; end");
201 ANN(
"case statement (pattern matching)");
202 ANN(
"format: case [nd_head]; [nd_body]; end");
203 ANN(
"example: case x; in 1; foo; in 2; bar; else baz; end");
211 ANN(
"format: when [nd_head]; [nd_body]; (when or else) [nd_next]");
212 ANN(
"example: case x; when 1; foo; when 2; bar; else baz; end");
221 ANN(
"format: in [nd_head]; [nd_body]; (in or else) [nd_next]");
222 ANN(
"example: case x; in 1; foo; in 2; bar; else baz; end");
230 ANN(
"while statement");
231 ANN(
"format: while [nd_cond]; [nd_body]; end");
232 ANN(
"example: while x == 1; foo; end");
235 ANN(
"until statement");
236 ANN(
"format: until [nd_cond]; [nd_body]; end");
237 ANN(
"example: until x == 1; foo; end");
240 A_INT((
int)node->nd_state);
241 A((node->nd_state == 1) ?
" (while-end)" :
" (begin-end-while)");
249 ANN(
"method call with block");
250 ANN(
"format: [nd_iter] { [nd_body] }");
251 ANN(
"example: 3.times { foo }");
254 ANN(
"for statement");
255 ANN(
"format: for * in [nd_iter] do [nd_body] end");
256 ANN(
"example: for i in 1..3 do foo end");
264 ANN(
"vars of for statement with masgn");
265 ANN(
"format: for [nd_var] in ... do ... end");
266 ANN(
"example: for x, y in 1..3 do foo end");
272 ANN(
"break statement");
273 ANN(
"format: break [nd_stts]");
274 ANN(
"example: break 1");
277 ANN(
"next statement");
278 ANN(
"format: next [nd_stts]");
279 ANN(
"example: next 1");
282 ANN(
"return statement");
283 ANN(
"format: return [nd_stts]");
284 ANN(
"example: return 1");
291 ANN(
"redo statement");
293 ANN(
"example: redo");
297 ANN(
"retry statement");
298 ANN(
"format: retry");
299 ANN(
"example: retry");
303 ANN(
"begin statement");
304 ANN(
"format: begin; [nd_body]; end");
305 ANN(
"example: begin; 1; end");
311 ANN(
"rescue clause");
312 ANN(
"format: begin; [nd_body]; (rescue) [nd_resq]; else [nd_else]; end");
313 ANN(
"example: begin; foo; rescue; bar; else; baz; end");
321 ANN(
"rescue clause (cont'd)");
322 ANN(
"format: rescue [nd_args]; [nd_body]; (rescue) [nd_head]");
323 ANN(
"example: begin; foo; rescue; bar; else; baz; end");
331 ANN(
"ensure clause");
332 ANN(
"format: begin; [nd_head]; ensure; [nd_ensr]; end");
333 ANN(
"example: begin; foo; ensure; bar; end");
341 ANN(
"format: [nd_1st] && [nd_2nd]");
342 ANN(
"example: foo && bar");
346 ANN(
"format: [nd_1st] || [nd_2nd]");
347 ANN(
"example: foo || bar");
351 if (!node->nd_2nd ||
nd_type(node->nd_2nd) != (
int)
type)
360 ANN(
"multiple assignment");
361 ANN(
"format: [nd_head], [nd_args] = [nd_value]");
362 ANN(
"example: a, b = foo");
370 F_MSG(
nd_args,
"splatn",
"NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
375 ANN(
"local variable assignment");
376 ANN(
"format: [nd_vid](lvar) = [nd_value]");
377 ANN(
"example: x = foo");
380 F_MSG(
nd_value,
"rvalue",
"NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)");
388 ANN(
"dynamic variable assignment (out of current scope)");
389 ANN(
"format: [nd_vid](dvar) = [nd_value]");
390 ANN(
"example: x = nil; 1.times { x = foo }");
396 ANN(
"dynamic variable assignment (in current scope)");
397 ANN(
"format: [nd_vid](current dvar) = [nd_value]");
398 ANN(
"example: 1.times { x = foo }");
401 F_MSG(
nd_value,
"rvalue",
"NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)");
409 ANN(
"instance variable assignment");
410 ANN(
"format: [nd_vid](ivar) = [nd_value]");
411 ANN(
"example: @x = foo");
417 ANN(
"class variable assignment");
418 ANN(
"format: [nd_vid](cvar) = [nd_value]");
419 ANN(
"example: @@x = foo");
425 ANN(
"global variable assignment");
426 ANN(
"format: [nd_entry](gvar) = [nd_value]");
427 ANN(
"example: $x = foo");
434 ANN(
"constant declaration");
435 ANN(
"format: [nd_else]::[nd_vid](constant) = [nd_value]");
436 ANN(
"example: X = foo");
442 F_MSG(
nd_vid,
"constant",
"0 (see extension field)");
450 ANN(
"array assignment with operator");
451 ANN(
"format: [nd_recv] [ [nd_args->nd_head] ] [nd_mid]= [nd_args->nd_body]");
452 ANN(
"example: ary[1] += foo");
461 ANN(
"attr assignment with operator");
462 ANN(
"format: [nd_recv].[attr] [nd_next->nd_mid]= [nd_value]");
463 ANN(
" where [attr]: [nd_next->nd_vid]");
464 ANN(
"example: struct.field += foo");
467 if (node->nd_next->nd_aid)
A(
"? ");
468 A_ID(node->nd_next->nd_vid);
476 ANN(
"assignment with && operator");
477 ANN(
"format: [nd_head] &&= [nd_value]");
478 ANN(
"example: foo &&= bar");
481 ANN(
"assignment with || operator");
482 ANN(
"format: [nd_head] ||= [nd_value]");
483 ANN(
"example: foo ||= bar");
491 ANN(
"constant declaration with operator");
492 ANN(
"format: [nd_head](constant) [nd_aid]= [nd_value]");
493 ANN(
"example: A::B ||= 1");
501 ANN(
"method invocation");
502 ANN(
"format: [nd_recv].[nd_mid]([nd_args])");
503 ANN(
"example: obj.foo(1)");
511 ANN(
"method invocation");
512 ANN(
"format: [nd_recv] [nd_mid] [nd_args]");
513 ANN(
"example: foo + bar");
521 ANN(
"function call");
522 ANN(
"format: [nd_mid]([nd_args])");
523 ANN(
"example: foo(1)");
530 ANN(
"function call with no argument");
531 ANN(
"format: [nd_mid]");
537 ANN(
"safe method invocation");
538 ANN(
"format: [nd_recv]&.[nd_mid]([nd_args])");
539 ANN(
"example: obj&.foo(1)");
547 ANN(
"super invocation");
548 ANN(
"format: super [nd_args]");
549 ANN(
"example: super 1");
555 ANN(
"super invocation with no argument");
556 ANN(
"format: super");
557 ANN(
"example: super");
561 ANN(
"list constructor");
562 ANN(
"format: [ [nd_head], [nd_next].. ] (length: [nd_alen])");
563 ANN(
"example: [1, 2, 3]");
566 ANN(
"return arguments");
567 ANN(
"format: [ [nd_head], [nd_next].. ] (length: [nd_alen])");
568 ANN(
"example: return 1, 2, 3");
570 dump_array(
buf, indent, comment, node);
574 ANN(
"empty list constructor");
580 if (!node->nd_brace) {
581 ANN(
"keyword arguments");
582 ANN(
"format: nd_head");
583 ANN(
"example: a: 1, b: 2");
586 ANN(
"hash constructor");
587 ANN(
"format: { [nd_head] }");
588 ANN(
"example: { 1 => 2, 3 => 4 }");
591 switch (node->nd_brace) {
592 case 0:
A(
"0 (keyword argument)");
break;
593 case 1:
A(
"1 (hash literal)");
break;
601 ANN(
"yield invocation");
602 ANN(
"format: yield [nd_head]");
603 ANN(
"example: yield 1");
609 ANN(
"local variable reference");
610 ANN(
"format: [nd_vid](lvar)");
615 ANN(
"dynamic variable reference");
616 ANN(
"format: [nd_vid](dvar)");
617 ANN(
"example: 1.times { x = 1; x }");
621 ANN(
"instance variable reference");
622 ANN(
"format: [nd_vid](ivar)");
627 ANN(
"constant reference");
628 ANN(
"format: [nd_vid](constant)");
633 ANN(
"class variable reference");
634 ANN(
"format: [nd_vid](cvar)");
640 ANN(
"global variable reference");
641 ANN(
"format: [nd_entry](gvar)");
647 ANN(
"nth special variable reference");
648 ANN(
"format: $[nd_nth]");
649 ANN(
"example: $1, $2, ..");
654 ANN(
"back special variable reference");
655 ANN(
"format: $[nd_nth]");
656 ANN(
"example: $&, $`, $', $+");
667 ANN(
"match expression (against $_ implicitly)");
668 ANN(
"format: [nd_lit] (in condition)");
669 ANN(
"example: if /foo/; foo; end");
674 ANN(
"match expression (regexp first)");
675 ANN(
"format: [nd_recv] =~ [nd_value]");
676 ANN(
"example: /foo/ =~ 'foo'");
687 ANN(
"match expression (regexp second)");
688 ANN(
"format: [nd_recv] =~ [nd_value]");
689 ANN(
"example: 'foo' =~ /foo/");
697 ANN(
"format: [nd_lit]");
698 ANN(
"example: 1, /foo/");
701 ANN(
"string literal");
702 ANN(
"format: [nd_lit]");
703 ANN(
"example: 'foo'");
706 ANN(
"xstring literal");
707 ANN(
"format: [nd_lit]");
708 ANN(
"example: `foo`");
714 ANN(
"once evaluation");
715 ANN(
"format: [nd_body]");
716 ANN(
"example: /foo#{ bar }baz/o");
721 ANN(
"string literal with interpolation");
722 ANN(
"format: [nd_lit]");
723 ANN(
"example: \"foo#{ bar }baz\"");
726 ANN(
"xstring literal with interpolation");
727 ANN(
"format: [nd_lit]");
728 ANN(
"example: `foo#{ bar }baz`");
731 ANN(
"regexp literal with interpolation");
732 ANN(
"format: [nd_lit]");
733 ANN(
"example: /foo#{ bar }baz/");
736 ANN(
"symbol literal with interpolation");
737 ANN(
"format: [nd_lit]");
738 ANN(
"example: :\"foo#{ bar }baz\"");
747 ANN(
"interpolation expression");
748 ANN(
"format: \"..#{ [nd_lit] }..\"");
749 ANN(
"example: \"foo#{ bar }baz\"");
755 ANN(
"splat argument following arguments");
756 ANN(
"format: ..(*[nd_head], [nd_body..])");
757 ANN(
"example: foo(*ary, post_arg1, post_arg2)");
764 ANN(
"splat argument following one argument");
765 ANN(
"format: ..(*[nd_head], [nd_body])");
766 ANN(
"example: foo(*ary, post_arg)");
773 ANN(
"splat argument");
774 ANN(
"format: *[nd_head]");
775 ANN(
"example: foo(*ary)");
781 ANN(
"arguments with block argument");
782 ANN(
"format: ..([nd_head], &[nd_body])");
783 ANN(
"example: foo(x, &blk)");
790 ANN(
"method definition");
791 ANN(
"format: def [nd_mid] [nd_defn]; end");
792 ANN(
"example: def foo; bar; end");
799 ANN(
"singleton method definition");
800 ANN(
"format: def [nd_recv].[nd_mid] [nd_defn]; end");
801 ANN(
"example: def obj.foo; bar; end");
809 ANN(
"method alias statement");
810 ANN(
"format: alias [nd_1st] [nd_2nd]");
811 ANN(
"example: alias bar foo");
818 ANN(
"global variable alias statement");
819 ANN(
"format: alias [nd_alias](gvar) [nd_orig](gvar)");
820 ANN(
"example: alias $y $x");
826 ANN(
"method undef statement");
827 ANN(
"format: undef [nd_undef]");
828 ANN(
"example: undef foo");
834 ANN(
"class definition");
835 ANN(
"format: class [nd_cpath] < [nd_super]; [nd_body]; end");
836 ANN(
"example: class C2 < C; ..; end");
844 ANN(
"module definition");
845 ANN(
"format: module [nd_cpath]; [nd_body]; end");
846 ANN(
"example: module M; ..; end");
853 ANN(
"singleton class definition");
854 ANN(
"format: class << [nd_recv]; [nd_body]; end");
855 ANN(
"example: class << obj; ..; end");
862 ANN(
"scoped constant reference");
863 ANN(
"format: [nd_head]::[nd_mid]");
864 ANN(
"example: M::C");
871 ANN(
"top-level constant reference");
872 ANN(
"format: ::[nd_mid]");
873 ANN(
"example: ::Object");
878 ANN(
"range constructor (incl.)");
879 ANN(
"format: [nd_beg]..[nd_end]");
880 ANN(
"example: 1..5");
883 ANN(
"range constructor (excl.)");
884 ANN(
"format: [nd_beg]...[nd_end]");
885 ANN(
"example: 1...5");
888 ANN(
"flip-flop condition (incl.)");
889 ANN(
"format: [nd_beg]..[nd_end]");
890 ANN(
"example: if (x==1)..(x==5); foo; end");
893 ANN(
"flip-flop condition (excl.)");
894 ANN(
"format: [nd_beg]...[nd_end]");
895 ANN(
"example: if (x==1)...(x==5); foo; end");
905 ANN(
"example: self");
917 ANN(
"example: true");
922 ANN(
"format: false");
923 ANN(
"example: false");
927 ANN(
"virtual reference to $!");
928 ANN(
"format: rescue => id");
929 ANN(
"example: rescue => id");
933 ANN(
"defined? expression");
934 ANN(
"format: defined?([nd_head])");
935 ANN(
"example: defined?(foo)");
940 ANN(
"post-execution");
941 ANN(
"format: END { [nd_body] }");
942 ANN(
"example: END { foo }");
948 ANN(
"attr assignment");
949 ANN(
"format: [nd_recv].[nd_mid] = [nd_args]");
950 ANN(
"example: struct.field = foo");
958 ANN(
"lambda expression");
959 ANN(
"format: -> [nd_body]");
960 ANN(
"example: -> { foo }");
966 ANN(
"optional arguments");
967 ANN(
"format: def method_name([nd_body=some], [nd_next..])");
968 ANN(
"example: def foo(a, b=1, c); end");
975 ANN(
"keyword arguments");
976 ANN(
"format: def method_name([nd_body=some], [nd_next..])");
977 ANN(
"example: def foo(a:1, b:2); end");
984 ANN(
"post arguments");
985 ANN(
"format: *[nd_1st], [nd_2nd..] = ..");
986 ANN(
"example: a, *rest, z = foo");
991 F_MSG(
nd_1st,
"rest argument",
"NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
998 ANN(
"method parameters");
999 ANN(
"format: def method_name(.., [nd_opt=some], *[nd_rest], [nd_pid], .., &[nd_body])");
1000 ANN(
"example: def foo(a, b, opt1=1, opt2=2, *rest, y, z, &blk); end");
1001 F_INT(
nd_ainfo->pre_args_num,
"count of mandatory (pre-)arguments");
1003 F_INT(
nd_ainfo->post_args_num,
"count of mandatory post-arguments");
1008 A(
"1 (excessed comma)");
1011 A_ID(node->nd_ainfo->rest_arg);
1023 ANN(
"format: [nd_tbl]: local table, [nd_args]: arguments, [nd_body]: body");
1025 ID *tbl = node->nd_tbl;
1027 int size = tbl ? (
int)*tbl++ : 0;
1028 if (
size == 0)
A(
"(empty)");
1039 ANN(
"array pattern");
1040 ANN(
"format: [nd_pconst]([pre_args], ..., *[rest_arg], [post_args], ...)");
1047 F_MSG(
nd_apinfo->rest_arg,
"rest argument",
"NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
1054 ANN(
"hash pattern");
1055 ANN(
"format: [nd_pconst]([nd_pkwargs], ..., **[nd_pkwrestarg])");
1060 F_MSG(
nd_pkwrestarg,
"keyword rest argument",
"NODE_SPECIAL_NO_REST_KEYWORD (**nil)");
1079 "###########################################################\n"
1080 "## Do NOT use this node dump for any purpose other than ##\n"
1081 "## debug and research. Compatibility is not guaranteed. ##\n"
1082 "###########################################################\n\n"
1102 n->nd_loc.beg_pos.lineno = 0;
1103 n->nd_loc.beg_pos.column = 0;
1104 n->nd_loc.end_pos.lineno = 0;
1105 n->nd_loc.end_pos.column = 0;
1137 rb_node_buffer_new(
void)
1140 const size_t alloc_size =
sizeof(
node_buffer_t) + (bucket_size * 2);
1147 init_node_buffer_list(&nb->markable, (
node_buffer_elem_t*)((
size_t)nb->unmarkable.head + bucket_size));
1148 nb->mark_hash =
Qnil;
1157 while (nbe != nb->
last) {
1167 node_buffer_list_free(&nb->unmarkable);
1168 node_buffer_list_free(&nb->markable);
1175 if (nb->
idx >= nb->
len) {
1176 long n = nb->
len * 2;
1204 return ast_newnode_in_bucket(&nb->markable);
1206 return ast_newnode_in_bucket(&nb->unmarkable);
1232 for (cursor = 0; cursor <
len; cursor++) {
1233 func(ctx, &nbe->
buf[cursor]);
1243 iterate_buffer_elements(nbe, nb->
idx, func, ctx);
1247 iterate_buffer_elements(nbe, nbe->
len, func, ctx);
1253 mark_ast_value(
void *ctx,
NODE * node)
1258 ID *
buf = node->nd_tbl;
1293 update_ast_value(
void *ctx,
NODE * node)
1298 ID *
buf = node->nd_tbl;
1337 iterate_node_values(&nb->markable, update_ast_value,
NULL);
1349 iterate_node_values(&nb->markable, mark_ast_value,
NULL);
1367 while (nbe != nb->
last) {
1382 size += buffer_list_size(&nb->unmarkable);
1383 size += buffer_list_size(&nb->markable);
const char * ruby_node_name(int node)
struct node_buffer_elem_struct * next
NODE * rb_ast_newnode(rb_ast_t *ast, enum node_type type)
#define F_GENTRY(name, ann)
VALUE rb_ident_hash_new(void)
void node_itr_t(void *ctx, NODE *node)
#define NODE_SPECIAL_EXCESSIVE_COMMA
node_buffer_elem_t * last
void rb_ast_dispose(rb_ast_t *ast)
void * ruby_xmalloc(size_t size)
node_buffer_list_t unmarkable
#define NODE_BUF_DEFAULT_LEN
#define offsetof(p_type, field)
void * rb_xmalloc_mul_add(size_t x, size_t y, size_t z)
VALUE rb_gc_location(VALUE value)
void rb_ast_mark(rb_ast_t *ast)
#define NODE_SPECIAL_NO_REST_KEYWORD
rb_ast_t * rb_ast_new(void)
#define F_LONG(name, ann)
node_buffer_t * node_buffer
#define F_MSG(name, ann, desc)
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
void rb_ast_delete_node(rb_ast_t *ast, NODE *n)
#define F_CUSTOM1(name, ann)
VALUE rb_parser_dump_tree(const NODE *node, int comment)
node_buffer_list_t markable
void rb_node_init(NODE *n, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
struct node_buffer_elem_struct node_buffer_elem_t
size_t rb_ast_memsize(const rb_ast_t *ast)
void rb_ast_update_references(rb_ast_t *ast)
#define nd_set_type(n, t)
void rb_ast_add_mark_object(rb_ast_t *ast, VALUE obj)
void rb_ast_free(rb_ast_t *ast)
void rb_gc_mark_movable(VALUE ptr)
#define RB_OBJ_WRITE(a, slot, b)
node_buffer_elem_t * head
unsigned char buf[MIME_BUF_SIZE]
void rb_bug(const char *fmt,...)
#define STATIC_ASSERT(name, expr)
#define D_NODE_HEADER(node)
#define NODE_NAMED_REST_P(node)
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
void rb_gc_mark(VALUE ptr)
VALUE rb_str_catf(VALUE str, const char *format,...)
#define F_NODE(name, ann)
#define NODE_REQUIRED_KEYWORD_P(node)
typedefRUBY_SYMBOL_EXPORT_BEGIN struct node_buffer_struct node_buffer_t
VALUE type(ANYARGS)
ANYARGS-ed function type.