2018-06-07 17:40:39 +03:00
|
|
|
/* indent-tabs-mode: nil */
|
2019-12-04 11:16:30 +03:00
|
|
|
#include "internal.h"
|
2023-05-28 14:00:20 +03:00
|
|
|
#include "internal/ruby_parser.h"
|
2019-12-04 11:16:30 +03:00
|
|
|
#include "internal/symbol.h"
|
|
|
|
#include "internal/warnings.h"
|
|
|
|
#include "iseq.h"
|
|
|
|
#include "node.h"
|
2018-01-16 02:43:17 +03:00
|
|
|
#include "ruby.h"
|
|
|
|
#include "ruby/encoding.h"
|
2018-06-07 17:46:25 +03:00
|
|
|
#include "ruby/util.h"
|
2018-01-16 02:43:17 +03:00
|
|
|
#include "vm_core.h"
|
2019-12-04 11:16:30 +03:00
|
|
|
|
2019-11-07 12:29:20 +03:00
|
|
|
#include "builtin.h"
|
2018-01-16 02:43:17 +03:00
|
|
|
|
|
|
|
static VALUE rb_mAST;
|
|
|
|
static VALUE rb_cNode;
|
|
|
|
|
|
|
|
struct ASTNodeData {
|
|
|
|
rb_ast_t *ast;
|
2020-07-08 12:07:30 +03:00
|
|
|
const NODE *node;
|
2018-01-16 02:43:17 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
node_gc_mark(void *ptr)
|
|
|
|
{
|
|
|
|
struct ASTNodeData *data = (struct ASTNodeData *)ptr;
|
|
|
|
rb_gc_mark((VALUE)data->ast);
|
|
|
|
}
|
|
|
|
|
2019-07-23 10:18:40 +03:00
|
|
|
static size_t
|
|
|
|
node_memsize(const void *ptr)
|
|
|
|
{
|
|
|
|
struct ASTNodeData *data = (struct ASTNodeData *)ptr;
|
|
|
|
return rb_ast_memsize(data->ast);
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
static const rb_data_type_t rb_node_type = {
|
|
|
|
"AST/node",
|
2019-07-23 10:18:40 +03:00
|
|
|
{node_gc_mark, RUBY_TYPED_DEFAULT_FREE, node_memsize,},
|
2018-01-16 02:43:17 +03:00
|
|
|
0, 0,
|
|
|
|
RUBY_TYPED_FREE_IMMEDIATELY,
|
|
|
|
};
|
|
|
|
|
|
|
|
static VALUE rb_ast_node_alloc(VALUE klass);
|
|
|
|
|
|
|
|
static void
|
2020-07-08 12:07:30 +03:00
|
|
|
setup_node(VALUE obj, rb_ast_t *ast, const NODE *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
|
|
|
|
TypedData_Get_Struct(obj, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
data->ast = ast;
|
|
|
|
data->node = node;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2020-07-08 12:07:30 +03:00
|
|
|
ast_new_internal(rb_ast_t *ast, const NODE *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
VALUE obj;
|
|
|
|
|
|
|
|
obj = rb_ast_node_alloc(rb_cNode);
|
|
|
|
setup_node(obj, ast, node);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2022-09-23 16:40:02 +03:00
|
|
|
static VALUE rb_ast_parse_str(VALUE str, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens);
|
|
|
|
static VALUE rb_ast_parse_file(VALUE path, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens);
|
2018-11-09 16:39:35 +03:00
|
|
|
|
2018-11-10 14:16:36 +03:00
|
|
|
static VALUE
|
|
|
|
ast_parse_new(void)
|
|
|
|
{
|
|
|
|
return rb_parser_set_context(rb_parser_new(), NULL, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
ast_parse_done(rb_ast_t *ast)
|
|
|
|
{
|
|
|
|
if (!ast->body.root) {
|
|
|
|
rb_ast_dispose(ast);
|
|
|
|
rb_exc_raise(GET_EC()->errinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ast_new_internal(ast, (NODE *)ast->body.root);
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
ast_s_parse(rb_execution_context_t *ec, VALUE module, VALUE str, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-11-09 16:39:35 +03:00
|
|
|
{
|
2022-09-23 16:40:02 +03:00
|
|
|
return rb_ast_parse_str(str, keep_script_lines, error_tolerant, keep_tokens);
|
2018-11-09 16:39:35 +03:00
|
|
|
}
|
|
|
|
|
2018-11-11 03:55:19 +03:00
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
rb_ast_parse_str(VALUE str, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
rb_ast_t *ast = 0;
|
|
|
|
|
2019-01-06 08:07:10 +03:00
|
|
|
StringValue(str);
|
2021-06-17 17:43:08 +03:00
|
|
|
VALUE vparser = ast_parse_new();
|
2023-08-25 10:53:29 +03:00
|
|
|
if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser, Qtrue);
|
2022-09-25 11:53:44 +03:00
|
|
|
if (RTEST(error_tolerant)) rb_parser_error_tolerant(vparser);
|
2022-09-23 16:40:02 +03:00
|
|
|
if (RTEST(keep_tokens)) rb_parser_keep_tokens(vparser);
|
2021-06-17 17:43:08 +03:00
|
|
|
ast = rb_parser_compile_string_path(vparser, Qnil, str, 1);
|
2018-11-10 14:16:36 +03:00
|
|
|
return ast_parse_done(ast);
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
ast_s_parse_file(rb_execution_context_t *ec, VALUE module, VALUE path, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-11-09 16:39:35 +03:00
|
|
|
{
|
2022-09-23 16:40:02 +03:00
|
|
|
return rb_ast_parse_file(path, keep_script_lines, error_tolerant, keep_tokens);
|
2018-11-09 16:39:35 +03:00
|
|
|
}
|
|
|
|
|
2018-11-11 03:55:19 +03:00
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
rb_ast_parse_file(VALUE path, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
2018-11-10 14:16:36 +03:00
|
|
|
VALUE f;
|
2018-01-16 02:43:17 +03:00
|
|
|
rb_ast_t *ast = 0;
|
|
|
|
rb_encoding *enc = rb_utf8_encoding();
|
|
|
|
|
|
|
|
f = rb_file_open_str(path, "r");
|
|
|
|
rb_funcall(f, rb_intern("set_encoding"), 2, rb_enc_from_encoding(enc), rb_str_new_cstr("-"));
|
2021-06-17 17:43:08 +03:00
|
|
|
VALUE vparser = ast_parse_new();
|
2023-08-25 10:53:29 +03:00
|
|
|
if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser, Qtrue);
|
2022-09-25 11:53:44 +03:00
|
|
|
if (RTEST(error_tolerant)) rb_parser_error_tolerant(vparser);
|
2022-09-23 16:40:02 +03:00
|
|
|
if (RTEST(keep_tokens)) rb_parser_keep_tokens(vparser);
|
2021-06-17 17:43:08 +03:00
|
|
|
ast = rb_parser_compile_file_path(vparser, Qnil, f, 1);
|
2018-01-16 02:43:17 +03:00
|
|
|
rb_io_close(f);
|
2018-11-10 14:16:36 +03:00
|
|
|
return ast_parse_done(ast);
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
2018-11-11 03:55:19 +03:00
|
|
|
static VALUE
|
2018-11-10 14:40:33 +03:00
|
|
|
lex_array(VALUE array, int index)
|
|
|
|
{
|
|
|
|
VALUE str = rb_ary_entry(array, index);
|
|
|
|
if (!NIL_P(str)) {
|
|
|
|
StringValue(str);
|
|
|
|
if (!rb_enc_asciicompat(rb_enc_get(str))) {
|
|
|
|
rb_raise(rb_eArgError, "invalid source encoding");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2018-11-11 03:55:19 +03:00
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
rb_ast_parse_array(VALUE array, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-11-10 14:40:33 +03:00
|
|
|
{
|
|
|
|
rb_ast_t *ast = 0;
|
|
|
|
|
|
|
|
array = rb_check_array_type(array);
|
2021-06-17 17:43:08 +03:00
|
|
|
VALUE vparser = ast_parse_new();
|
2023-08-25 10:53:29 +03:00
|
|
|
if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser, Qtrue);
|
2022-09-25 11:53:44 +03:00
|
|
|
if (RTEST(error_tolerant)) rb_parser_error_tolerant(vparser);
|
2022-09-23 16:40:02 +03:00
|
|
|
if (RTEST(keep_tokens)) rb_parser_keep_tokens(vparser);
|
2021-06-17 17:43:08 +03:00
|
|
|
ast = rb_parser_compile_generic(vparser, lex_array, Qnil, array, 1);
|
2018-11-10 14:40:33 +03:00
|
|
|
return ast_parse_done(ast);
|
|
|
|
}
|
|
|
|
|
2020-07-08 12:07:30 +03:00
|
|
|
static VALUE node_children(rb_ast_t*, const NODE*);
|
2018-11-05 05:13:45 +03:00
|
|
|
|
|
|
|
static VALUE
|
|
|
|
node_find(VALUE self, const int node_id)
|
|
|
|
{
|
|
|
|
VALUE ary;
|
|
|
|
long i;
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
if (nd_node_id(data->node) == node_id) return self;
|
|
|
|
|
|
|
|
ary = node_children(data->ast, data->node);
|
|
|
|
|
|
|
|
for (i = 0; i < RARRAY_LEN(ary); i++) {
|
|
|
|
VALUE child = RARRAY_AREF(ary, i);
|
|
|
|
|
|
|
|
if (CLASS_OF(child) == rb_cNode) {
|
|
|
|
VALUE result = node_find(child, node_id);
|
|
|
|
if (RTEST(result)) return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2018-11-10 14:43:02 +03:00
|
|
|
extern VALUE rb_e_script;
|
|
|
|
|
2023-08-25 10:53:29 +03:00
|
|
|
VALUE
|
|
|
|
rb_script_lines_for(VALUE path, bool add)
|
2018-11-10 13:39:58 +03:00
|
|
|
{
|
|
|
|
VALUE hash, lines;
|
|
|
|
ID script_lines;
|
|
|
|
CONST_ID(script_lines, "SCRIPT_LINES__");
|
|
|
|
if (!rb_const_defined_at(rb_cObject, script_lines)) return Qnil;
|
|
|
|
hash = rb_const_get_at(rb_cObject, script_lines);
|
|
|
|
if (!RB_TYPE_P(hash, T_HASH)) return Qnil;
|
2023-08-25 10:53:29 +03:00
|
|
|
if (add) {
|
|
|
|
rb_hash_aset(hash, path, lines = rb_ary_new());
|
|
|
|
}
|
|
|
|
else if (!RB_TYPE_P((lines = rb_hash_lookup(hash, path)), T_ARRAY)) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
2018-11-10 13:39:58 +03:00
|
|
|
return lines;
|
|
|
|
}
|
2023-08-25 10:53:29 +03:00
|
|
|
static VALUE
|
|
|
|
script_lines(VALUE path)
|
|
|
|
{
|
|
|
|
return rb_script_lines_for(path, false);
|
|
|
|
}
|
2018-11-10 13:39:58 +03:00
|
|
|
|
2022-10-19 20:23:53 +03:00
|
|
|
static VALUE
|
|
|
|
node_id_for_backtrace_location(rb_execution_context_t *ec, VALUE module, VALUE location)
|
|
|
|
{
|
|
|
|
int node_id;
|
2022-12-26 11:45:44 +03:00
|
|
|
|
|
|
|
if (!rb_frame_info_p(location)) {
|
|
|
|
rb_raise(rb_eTypeError, "Thread::Backtrace::Location object expected");
|
|
|
|
}
|
|
|
|
|
2022-10-19 20:23:53 +03:00
|
|
|
node_id = rb_get_node_id_from_frame_info(location);
|
|
|
|
if (node_id == -1) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
|
|
|
return INT2NUM(node_id);
|
|
|
|
}
|
|
|
|
|
2018-11-05 05:13:45 +03:00
|
|
|
static VALUE
|
2022-09-23 16:40:02 +03:00
|
|
|
ast_s_of(rb_execution_context_t *ec, VALUE module, VALUE body, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
|
2018-11-05 05:13:45 +03:00
|
|
|
{
|
2021-12-26 13:41:42 +03:00
|
|
|
VALUE node, lines = Qnil;
|
2021-12-18 21:40:44 +03:00
|
|
|
const rb_iseq_t *iseq;
|
2018-11-05 05:13:45 +03:00
|
|
|
int node_id;
|
|
|
|
|
2021-06-08 11:34:08 +03:00
|
|
|
if (rb_frame_info_p(body)) {
|
2021-12-18 21:40:44 +03:00
|
|
|
iseq = rb_get_iseq_from_frame_info(body);
|
|
|
|
node_id = rb_get_node_id_from_frame_info(body);
|
2018-11-05 05:13:45 +03:00
|
|
|
}
|
|
|
|
else {
|
2021-12-18 21:40:44 +03:00
|
|
|
iseq = NULL;
|
2021-06-08 11:34:08 +03:00
|
|
|
|
|
|
|
if (rb_obj_is_proc(body)) {
|
|
|
|
iseq = vm_proc_iseq(body);
|
2018-11-05 05:13:45 +03:00
|
|
|
|
2021-06-08 11:34:08 +03:00
|
|
|
if (!rb_obj_is_iseq((VALUE)iseq)) return Qnil;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
iseq = rb_method_iseq(body);
|
|
|
|
}
|
2021-12-18 21:40:44 +03:00
|
|
|
if (iseq) {
|
2022-03-23 22:19:48 +03:00
|
|
|
node_id = ISEQ_BODY(iseq)->location.node_id;
|
2021-09-18 15:28:35 +03:00
|
|
|
}
|
2021-06-08 11:34:08 +03:00
|
|
|
}
|
2018-11-05 05:13:45 +03:00
|
|
|
|
2021-12-18 21:40:44 +03:00
|
|
|
if (!iseq) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
2022-03-23 22:19:48 +03:00
|
|
|
lines = ISEQ_BODY(iseq)->variable.script_lines;
|
2021-12-26 13:41:42 +03:00
|
|
|
|
|
|
|
VALUE path = rb_iseq_path(iseq);
|
|
|
|
int e_option = RSTRING_LEN(path) == 2 && memcmp(RSTRING_PTR(path), "-e", 2) == 0;
|
|
|
|
|
|
|
|
if (NIL_P(lines) && rb_iseq_from_eval_p(iseq) && !e_option) {
|
2021-12-18 21:40:44 +03:00
|
|
|
rb_raise(rb_eArgError, "cannot get AST for method defined in eval");
|
|
|
|
}
|
|
|
|
|
2021-10-25 19:58:01 +03:00
|
|
|
if (!NIL_P(lines) || !NIL_P(lines = script_lines(path))) {
|
2022-09-23 16:40:02 +03:00
|
|
|
node = rb_ast_parse_array(lines, keep_script_lines, error_tolerant, keep_tokens);
|
2018-11-10 13:39:58 +03:00
|
|
|
}
|
2021-12-26 13:41:42 +03:00
|
|
|
else if (e_option) {
|
2022-09-23 16:40:02 +03:00
|
|
|
node = rb_ast_parse_str(rb_e_script, keep_script_lines, error_tolerant, keep_tokens);
|
2018-11-10 14:43:02 +03:00
|
|
|
}
|
2018-11-10 13:39:58 +03:00
|
|
|
else {
|
2022-09-23 16:40:02 +03:00
|
|
|
node = rb_ast_parse_file(path, keep_script_lines, error_tolerant, keep_tokens);
|
2018-11-10 13:39:58 +03:00
|
|
|
}
|
2018-11-05 05:13:45 +03:00
|
|
|
|
|
|
|
return node_find(node, node_id);
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
static VALUE
|
|
|
|
rb_ast_node_alloc(VALUE klass)
|
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
VALUE obj = TypedData_Make_Struct(klass, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
2018-12-03 04:06:34 +03:00
|
|
|
node_type_to_str(const NODE *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
2023-05-24 11:24:41 +03:00
|
|
|
return (ruby_node_name(nd_type(node)) + rb_strlen_lit("NODE_"));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_type(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
2018-12-03 04:06:34 +03:00
|
|
|
return rb_sym_intern_ascii_cstr(node_type_to_str(data->node));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
2021-04-30 12:54:46 +03:00
|
|
|
static VALUE
|
2021-06-21 15:15:25 +03:00
|
|
|
ast_node_node_id(rb_execution_context_t *ec, VALUE self)
|
2021-04-30 12:54:46 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return INT2FIX(nd_node_id(data->node));
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
#define NEW_CHILD(ast, node) node ? ast_new_internal(ast, node) : Qnil
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_ary_new_from_node_args(rb_ast_t *ast, long n, ...)
|
|
|
|
{
|
|
|
|
va_list ar;
|
|
|
|
VALUE ary;
|
|
|
|
long i;
|
|
|
|
|
|
|
|
ary = rb_ary_new2(n);
|
|
|
|
|
|
|
|
va_start(ar, n);
|
|
|
|
for (i=0; i<n; i++) {
|
2018-06-06 09:14:21 +03:00
|
|
|
NODE *node;
|
|
|
|
node = va_arg(ar, NODE *);
|
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
va_end(ar);
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2023-08-22 04:26:38 +03:00
|
|
|
dump_block(rb_ast_t *ast, const struct RNode_BLOCK *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
VALUE ary = rb_ary_new();
|
|
|
|
do {
|
2018-06-06 09:14:21 +03:00
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node->nd_head));
|
2018-01-16 02:43:17 +03:00
|
|
|
} while (node->nd_next &&
|
2021-12-03 18:01:24 +03:00
|
|
|
nd_type_p(node->nd_next, NODE_BLOCK) &&
|
2023-08-22 04:26:38 +03:00
|
|
|
(node = RNODE_BLOCK(node->nd_next), 1));
|
2018-01-16 02:43:17 +03:00
|
|
|
if (node->nd_next) {
|
2018-06-06 09:14:21 +03:00
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node->nd_next));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2023-08-22 04:26:38 +03:00
|
|
|
dump_array(rb_ast_t *ast, const struct RNode_LIST *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
VALUE ary = rb_ary_new();
|
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node->nd_head));
|
|
|
|
|
2021-12-03 18:01:24 +03:00
|
|
|
while (node->nd_next && nd_type_p(node->nd_next, NODE_LIST)) {
|
2023-08-22 04:26:38 +03:00
|
|
|
node = RNODE_LIST(node->nd_next);
|
2018-06-06 09:14:21 +03:00
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node->nd_head));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, node->nd_next));
|
|
|
|
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:25 +03:00
|
|
|
static VALUE
|
|
|
|
var_name(ID id)
|
|
|
|
{
|
|
|
|
if (!id) return Qnil;
|
|
|
|
if (!rb_id2str(id)) return Qnil;
|
|
|
|
return ID2SYM(id);
|
|
|
|
}
|
|
|
|
|
2020-07-08 12:26:57 +03:00
|
|
|
static VALUE
|
|
|
|
no_name_rest(void)
|
|
|
|
{
|
|
|
|
ID rest;
|
|
|
|
CONST_ID(rest, "NODE_SPECIAL_NO_NAME_REST");
|
|
|
|
return ID2SYM(rest);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rest_arg(rb_ast_t *ast, const NODE *rest_arg)
|
|
|
|
{
|
|
|
|
return NODE_NAMED_REST_P(rest_arg) ? NEW_CHILD(ast, rest_arg) : no_name_rest();
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
static VALUE
|
2020-07-08 12:07:30 +03:00
|
|
|
node_children(rb_ast_t *ast, const NODE *node)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
2023-02-03 19:31:56 +03:00
|
|
|
char name[sizeof("$") + DECIMAL_SIZE_OF(long)];
|
2018-06-07 17:46:25 +03:00
|
|
|
|
2018-05-01 09:55:43 +03:00
|
|
|
enum node_type type = nd_type(node);
|
|
|
|
switch (type) {
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_BLOCK:
|
2023-08-22 04:26:38 +03:00
|
|
|
return dump_block(ast, RNODE_BLOCK(node));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_IF:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_IF(node)->nd_cond, RNODE_IF(node)->nd_body, RNODE_IF(node)->nd_else);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_UNLESS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_UNLESS(node)->nd_cond, RNODE_UNLESS(node)->nd_body, RNODE_UNLESS(node)->nd_else);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CASE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_CASE(node)->nd_head, RNODE_CASE(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CASE2:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_CASE2(node)->nd_head, RNODE_CASE2(node)->nd_body);
|
2019-04-17 09:48:03 +03:00
|
|
|
case NODE_CASE3:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_CASE3(node)->nd_head, RNODE_CASE3(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_WHEN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_WHEN(node)->nd_head, RNODE_WHEN(node)->nd_body, RNODE_WHEN(node)->nd_next);
|
2019-04-17 09:48:03 +03:00
|
|
|
case NODE_IN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_IN(node)->nd_head, RNODE_IN(node)->nd_body, RNODE_IN(node)->nd_next);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_WHILE:
|
|
|
|
case NODE_UNTIL:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_push(rb_ary_new_from_node_args(ast, 2, RNODE_WHILE(node)->nd_cond, RNODE_WHILE(node)->nd_body),
|
|
|
|
RBOOL(RNODE_WHILE(node)->nd_state));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ITER:
|
|
|
|
case NODE_FOR:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_ITER(node)->nd_iter, RNODE_ITER(node)->nd_body);
|
2018-01-16 10:24:53 +03:00
|
|
|
case NODE_FOR_MASGN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_FOR_MASGN(node)->nd_var);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_BREAK:
|
2023-10-05 05:26:48 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_BREAK(node)->nd_stts);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_NEXT:
|
2023-10-05 05:26:48 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_NEXT(node)->nd_stts);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_RETURN:
|
2023-10-05 05:26:48 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_RETURN(node)->nd_stts);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_REDO:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_RETRY:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_BEGIN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_BEGIN(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_RESCUE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_RESCUE(node)->nd_head, RNODE_RESCUE(node)->nd_resq, RNODE_RESCUE(node)->nd_else);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_RESBODY:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_RESBODY(node)->nd_args, RNODE_RESBODY(node)->nd_body, RNODE_RESBODY(node)->nd_head);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ENSURE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_ENSURE(node)->nd_head, RNODE_ENSURE(node)->nd_ensr);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_AND:
|
|
|
|
case NODE_OR:
|
2018-06-06 09:14:21 +03:00
|
|
|
{
|
|
|
|
VALUE ary = rb_ary_new();
|
|
|
|
|
|
|
|
while (1) {
|
2023-08-22 04:26:38 +03:00
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, RNODE_AND(node)->nd_1st));
|
|
|
|
if (!RNODE_AND(node)->nd_2nd || !nd_type_p(RNODE_AND(node)->nd_2nd, type))
|
2018-06-06 09:14:21 +03:00
|
|
|
break;
|
2023-08-22 04:26:38 +03:00
|
|
|
node = RNODE_AND(node)->nd_2nd;
|
2018-06-06 09:14:21 +03:00
|
|
|
}
|
2023-08-22 04:26:38 +03:00
|
|
|
rb_ary_push(ary, NEW_CHILD(ast, RNODE_AND(node)->nd_2nd));
|
2018-06-06 09:14:21 +03:00
|
|
|
return ary;
|
|
|
|
}
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_MASGN:
|
2023-08-22 04:26:38 +03:00
|
|
|
if (NODE_NAMED_REST_P(RNODE_MASGN(node)->nd_args)) {
|
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_MASGN(node)->nd_value, RNODE_MASGN(node)->nd_head, RNODE_MASGN(node)->nd_args);
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
2019-04-20 06:25:36 +03:00
|
|
|
else {
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_MASGN(node)->nd_value),
|
|
|
|
NEW_CHILD(ast, RNODE_MASGN(node)->nd_head),
|
2020-07-08 12:26:57 +03:00
|
|
|
no_name_rest());
|
2019-04-20 06:25:36 +03:00
|
|
|
}
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_LASGN:
|
2023-10-07 03:52:06 +03:00
|
|
|
if (NODE_REQUIRED_KEYWORD_P(RNODE_LASGN(node)->nd_value)) {
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_LASGN(node)->nd_vid), ID2SYM(rb_intern("NODE_SPECIAL_REQUIRED_KEYWORD")));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_LASGN(node)->nd_vid), NEW_CHILD(ast, RNODE_LASGN(node)->nd_value));
|
2023-10-07 04:37:33 +03:00
|
|
|
case NODE_DASGN:
|
|
|
|
if (NODE_REQUIRED_KEYWORD_P(RNODE_DASGN(node)->nd_value)) {
|
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_DASGN(node)->nd_vid), ID2SYM(rb_intern("NODE_SPECIAL_REQUIRED_KEYWORD")));
|
|
|
|
}
|
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_DASGN(node)->nd_vid), NEW_CHILD(ast, RNODE_DASGN(node)->nd_value));
|
|
|
|
case NODE_IASGN:
|
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_IASGN(node)->nd_vid), NEW_CHILD(ast, RNODE_IASGN(node)->nd_value));
|
|
|
|
case NODE_CVASGN:
|
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_CVASGN(node)->nd_vid), NEW_CHILD(ast, RNODE_CVASGN(node)->nd_value));
|
|
|
|
case NODE_GASGN:
|
|
|
|
return rb_ary_new_from_args(2, var_name(RNODE_GASGN(node)->nd_vid), NEW_CHILD(ast, RNODE_GASGN(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CDECL:
|
2023-08-22 04:26:38 +03:00
|
|
|
if (RNODE_CDECL(node)->nd_vid) {
|
|
|
|
return rb_ary_new_from_args(2, ID2SYM(RNODE_CDECL(node)->nd_vid), NEW_CHILD(ast, RNODE_CDECL(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_CDECL(node)->nd_else), ID2SYM(RNODE_COLON2(RNODE_CDECL(node)->nd_else)->nd_mid), NEW_CHILD(ast, RNODE_CDECL(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OP_ASGN1:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(4, NEW_CHILD(ast, RNODE_OP_ASGN1(node)->nd_recv),
|
|
|
|
ID2SYM(RNODE_OP_ASGN1(node)->nd_mid),
|
2023-10-18 17:59:34 +03:00
|
|
|
NEW_CHILD(ast, RNODE_OP_ASGN1(node)->nd_index),
|
|
|
|
NEW_CHILD(ast, RNODE_OP_ASGN1(node)->nd_rvalue));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OP_ASGN2:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(5, NEW_CHILD(ast, RNODE_OP_ASGN2(node)->nd_recv),
|
2023-09-27 15:58:16 +03:00
|
|
|
RBOOL(RNODE_OP_ASGN2(node)->nd_aid),
|
|
|
|
ID2SYM(RNODE_OP_ASGN2(node)->nd_vid),
|
|
|
|
ID2SYM(RNODE_OP_ASGN2(node)->nd_mid),
|
2023-08-22 04:26:38 +03:00
|
|
|
NEW_CHILD(ast, RNODE_OP_ASGN2(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OP_ASGN_AND:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_OP_ASGN_AND(node)->nd_head), ID2SYM(idANDOP),
|
|
|
|
NEW_CHILD(ast, RNODE_OP_ASGN_AND(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OP_ASGN_OR:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_OP_ASGN_OR(node)->nd_head), ID2SYM(idOROP),
|
|
|
|
NEW_CHILD(ast, RNODE_OP_ASGN_OR(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OP_CDECL:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_OP_CDECL(node)->nd_head),
|
|
|
|
ID2SYM(RNODE_OP_CDECL(node)->nd_aid),
|
|
|
|
NEW_CHILD(ast, RNODE_OP_CDECL(node)->nd_value));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CALL:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_CALL(node)->nd_recv),
|
|
|
|
ID2SYM(RNODE_CALL(node)->nd_mid),
|
|
|
|
NEW_CHILD(ast, RNODE_CALL(node)->nd_args));
|
2023-10-09 03:20:53 +03:00
|
|
|
case NODE_OPCALL:
|
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_OPCALL(node)->nd_recv),
|
|
|
|
ID2SYM(RNODE_OPCALL(node)->nd_mid),
|
|
|
|
NEW_CHILD(ast, RNODE_OPCALL(node)->nd_args));
|
|
|
|
case NODE_QCALL:
|
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_QCALL(node)->nd_recv),
|
|
|
|
ID2SYM(RNODE_QCALL(node)->nd_mid),
|
|
|
|
NEW_CHILD(ast, RNODE_QCALL(node)->nd_args));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_FCALL:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, ID2SYM(RNODE_FCALL(node)->nd_mid),
|
|
|
|
NEW_CHILD(ast, RNODE_FCALL(node)->nd_args));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_VCALL:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_VCALL(node)->nd_mid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_SUPER:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_SUPER(node)->nd_args);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ZSUPER:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2019-09-07 04:42:00 +03:00
|
|
|
case NODE_LIST:
|
2023-08-22 04:26:38 +03:00
|
|
|
return dump_array(ast, RNODE_LIST(node));
|
2019-09-07 04:42:00 +03:00
|
|
|
case NODE_ZLIST:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_HASH:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_HASH(node)->nd_head);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_YIELD:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_YIELD(node)->nd_head);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_LVAR:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(1, var_name(RNODE_LVAR(node)->nd_vid));
|
2023-10-09 03:27:24 +03:00
|
|
|
case NODE_DVAR:
|
|
|
|
return rb_ary_new_from_args(1, var_name(RNODE_DVAR(node)->nd_vid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_IVAR:
|
2023-10-09 03:27:24 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_IVAR(node)->nd_vid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CONST:
|
2023-10-09 03:27:24 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_CONST(node)->nd_vid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CVAR:
|
2023-10-09 03:27:24 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_CVAR(node)->nd_vid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_GVAR:
|
2023-10-09 03:27:24 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_GVAR(node)->nd_vid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_NTH_REF:
|
2023-08-22 04:26:38 +03:00
|
|
|
snprintf(name, sizeof(name), "$%ld", RNODE_NTH_REF(node)->nd_nth);
|
2018-06-07 17:46:25 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(rb_intern(name)));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_BACK_REF:
|
2018-06-07 17:46:25 +03:00
|
|
|
name[0] = '$';
|
2023-08-22 04:26:38 +03:00
|
|
|
name[1] = (char)RNODE_BACK_REF(node)->nd_nth;
|
2018-06-07 17:46:25 +03:00
|
|
|
name[2] = '\0';
|
|
|
|
return rb_ary_new_from_args(1, ID2SYM(rb_intern(name)));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_MATCH2:
|
2023-08-22 04:26:38 +03:00
|
|
|
if (RNODE_MATCH2(node)->nd_args) {
|
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value, RNODE_MATCH2(node)->nd_args);
|
2018-06-06 09:14:21 +03:00
|
|
|
}
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_MATCH3:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_MATCH3(node)->nd_recv, RNODE_MATCH3(node)->nd_value);
|
2020-06-11 06:00:43 +03:00
|
|
|
case NODE_MATCH:
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_LIT:
|
|
|
|
case NODE_STR:
|
|
|
|
case NODE_XSTR:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(1, RNODE_LIT(node)->nd_lit);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ONCE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_ONCE(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_DSTR:
|
|
|
|
case NODE_DXSTR:
|
|
|
|
case NODE_DREGX:
|
|
|
|
case NODE_DSYM:
|
2020-09-02 17:12:22 +03:00
|
|
|
{
|
2023-08-22 04:26:38 +03:00
|
|
|
struct RNode_LIST *n = RNODE_DSTR(node)->nd_next;
|
2020-09-02 17:12:22 +03:00
|
|
|
VALUE head = Qnil, next = Qnil;
|
|
|
|
if (n) {
|
|
|
|
head = NEW_CHILD(ast, n->nd_head);
|
|
|
|
next = NEW_CHILD(ast, n->nd_next);
|
|
|
|
}
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, RNODE_DSTR(node)->nd_lit, head, next);
|
2020-09-02 17:12:22 +03:00
|
|
|
}
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_EVSTR:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_EVSTR(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ARGSCAT:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_ARGSCAT(node)->nd_head, RNODE_ARGSCAT(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ARGSPUSH:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_ARGSPUSH(node)->nd_head, RNODE_ARGSPUSH(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_SPLAT:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_SPLAT(node)->nd_head);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_BLOCK_PASS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_BLOCK_PASS(node)->nd_head, RNODE_BLOCK_PASS(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_DEFN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, ID2SYM(RNODE_DEFN(node)->nd_mid), NEW_CHILD(ast, RNODE_DEFN(node)->nd_defn));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_DEFS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_DEFS(node)->nd_recv), ID2SYM(RNODE_DEFS(node)->nd_mid), NEW_CHILD(ast, RNODE_DEFS(node)->nd_defn));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ALIAS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_ALIAS(node)->nd_1st, RNODE_ALIAS(node)->nd_2nd);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_VALIAS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, ID2SYM(RNODE_VALIAS(node)->nd_alias), ID2SYM(RNODE_VALIAS(node)->nd_orig));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_UNDEF:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_UNDEF(node)->nd_undef);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_CLASS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 3, RNODE_CLASS(node)->nd_cpath, RNODE_CLASS(node)->nd_super, RNODE_CLASS(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_MODULE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_MODULE(node)->nd_cpath, RNODE_MODULE(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_SCLASS:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_SCLASS(node)->nd_recv, RNODE_SCLASS(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_COLON2:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(2, NEW_CHILD(ast, RNODE_COLON2(node)->nd_head), ID2SYM(RNODE_COLON2(node)->nd_mid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_COLON3:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(1, ID2SYM(RNODE_COLON3(node)->nd_mid));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_DOT2:
|
|
|
|
case NODE_DOT3:
|
|
|
|
case NODE_FLIP2:
|
|
|
|
case NODE_FLIP3:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_DOT2(node)->nd_beg, RNODE_DOT2(node)->nd_end);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_SELF:
|
2018-06-07 17:40:39 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_NIL:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_TRUE:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_FALSE:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ERRINFO:
|
2018-06-06 09:14:21 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_DEFINED:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_DEFINED(node)->nd_head);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_POSTEXE:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_POSTEXE(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ATTRASGN:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_args(3, NEW_CHILD(ast, RNODE_ATTRASGN(node)->nd_recv), ID2SYM(RNODE_ATTRASGN(node)->nd_mid), NEW_CHILD(ast, RNODE_ATTRASGN(node)->nd_args));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_LAMBDA:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 1, RNODE_LAMBDA(node)->nd_body);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_OPT_ARG:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_OPT_ARG(node)->nd_body, RNODE_OPT_ARG(node)->nd_next);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_KW_ARG:
|
2023-08-22 04:26:38 +03:00
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_KW_ARG(node)->nd_body, RNODE_KW_ARG(node)->nd_next);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_POSTARG:
|
2023-08-22 04:26:38 +03:00
|
|
|
if (NODE_NAMED_REST_P(RNODE_POSTARG(node)->nd_1st)) {
|
|
|
|
return rb_ary_new_from_node_args(ast, 2, RNODE_POSTARG(node)->nd_1st, RNODE_POSTARG(node)->nd_2nd);
|
2018-06-06 09:14:21 +03:00
|
|
|
}
|
2020-07-08 12:26:57 +03:00
|
|
|
return rb_ary_new_from_args(2, no_name_rest(),
|
2023-08-22 04:26:38 +03:00
|
|
|
NEW_CHILD(ast, RNODE_POSTARG(node)->nd_2nd));
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ARGS:
|
2018-06-07 17:46:25 +03:00
|
|
|
{
|
2023-10-29 18:19:43 +03:00
|
|
|
struct rb_args_info *ainfo = &RNODE_ARGS(node)->nd_ainfo;
|
2018-06-07 17:46:25 +03:00
|
|
|
return rb_ary_new_from_args(10,
|
|
|
|
INT2NUM(ainfo->pre_args_num),
|
|
|
|
NEW_CHILD(ast, ainfo->pre_init),
|
2023-09-30 11:18:50 +03:00
|
|
|
NEW_CHILD(ast, (NODE *)ainfo->opt_args),
|
2018-06-07 17:46:25 +03:00
|
|
|
var_name(ainfo->first_post_arg),
|
|
|
|
INT2NUM(ainfo->post_args_num),
|
|
|
|
NEW_CHILD(ast, ainfo->post_init),
|
2020-07-07 14:18:18 +03:00
|
|
|
(ainfo->rest_arg == NODE_SPECIAL_EXCESSIVE_COMMA
|
|
|
|
? ID2SYM(rb_intern("NODE_SPECIAL_EXCESSIVE_COMMA"))
|
|
|
|
: var_name(ainfo->rest_arg)),
|
2023-09-30 11:18:50 +03:00
|
|
|
(ainfo->no_kwarg ? Qfalse : NEW_CHILD(ast, (NODE *)ainfo->kw_args)),
|
2019-04-24 21:40:02 +03:00
|
|
|
(ainfo->no_kwarg ? Qfalse : NEW_CHILD(ast, ainfo->kw_rest_arg)),
|
2018-06-07 17:46:25 +03:00
|
|
|
var_name(ainfo->block_arg));
|
|
|
|
}
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_SCOPE:
|
2018-06-07 17:46:25 +03:00
|
|
|
{
|
2023-08-22 04:26:38 +03:00
|
|
|
rb_ast_id_table_t *tbl = RNODE_SCOPE(node)->nd_tbl;
|
2021-11-17 21:40:49 +03:00
|
|
|
int i, size = tbl ? tbl->size : 0;
|
2018-06-07 17:46:25 +03:00
|
|
|
VALUE locals = rb_ary_new_capa(size);
|
|
|
|
for (i = 0; i < size; i++) {
|
2021-11-17 21:40:49 +03:00
|
|
|
rb_ary_push(locals, var_name(tbl->ids[i]));
|
2018-06-07 17:46:25 +03:00
|
|
|
}
|
2023-09-30 16:05:10 +03:00
|
|
|
return rb_ary_new_from_args(3, locals, NEW_CHILD(ast, (NODE *)RNODE_SCOPE(node)->nd_args), NEW_CHILD(ast, RNODE_SCOPE(node)->nd_body));
|
2018-06-07 17:46:25 +03:00
|
|
|
}
|
2019-04-17 09:48:03 +03:00
|
|
|
case NODE_ARYPTN:
|
|
|
|
{
|
2023-09-28 14:44:45 +03:00
|
|
|
VALUE rest = rest_arg(ast, RNODE_ARYPTN(node)->rest_arg);
|
2019-04-17 09:48:03 +03:00
|
|
|
return rb_ary_new_from_args(4,
|
2023-08-22 04:26:38 +03:00
|
|
|
NEW_CHILD(ast, RNODE_ARYPTN(node)->nd_pconst),
|
2023-09-28 14:44:45 +03:00
|
|
|
NEW_CHILD(ast, RNODE_ARYPTN(node)->pre_args),
|
2019-04-20 06:37:22 +03:00
|
|
|
rest,
|
2023-09-28 14:44:45 +03:00
|
|
|
NEW_CHILD(ast, RNODE_ARYPTN(node)->post_args));
|
2019-04-17 09:48:03 +03:00
|
|
|
}
|
2020-06-14 03:24:36 +03:00
|
|
|
case NODE_FNDPTN:
|
|
|
|
{
|
2023-09-28 14:44:45 +03:00
|
|
|
VALUE pre_rest = rest_arg(ast, RNODE_FNDPTN(node)->pre_rest_arg);
|
|
|
|
VALUE post_rest = rest_arg(ast, RNODE_FNDPTN(node)->post_rest_arg);
|
2020-06-14 03:24:36 +03:00
|
|
|
return rb_ary_new_from_args(4,
|
2023-08-22 04:26:38 +03:00
|
|
|
NEW_CHILD(ast, RNODE_FNDPTN(node)->nd_pconst),
|
2020-06-14 03:24:36 +03:00
|
|
|
pre_rest,
|
2023-09-28 14:44:45 +03:00
|
|
|
NEW_CHILD(ast, RNODE_FNDPTN(node)->args),
|
2020-06-14 03:24:36 +03:00
|
|
|
post_rest);
|
|
|
|
}
|
2019-04-17 09:48:03 +03:00
|
|
|
case NODE_HSHPTN:
|
|
|
|
{
|
2023-08-22 04:26:38 +03:00
|
|
|
VALUE kwrest = RNODE_HSHPTN(node)->nd_pkwrestarg == NODE_SPECIAL_NO_REST_KEYWORD ? ID2SYM(rb_intern("NODE_SPECIAL_NO_REST_KEYWORD")) :
|
|
|
|
NEW_CHILD(ast, RNODE_HSHPTN(node)->nd_pkwrestarg);
|
2019-09-01 10:39:34 +03:00
|
|
|
|
2019-04-17 09:48:03 +03:00
|
|
|
return rb_ary_new_from_args(3,
|
2023-08-22 04:26:38 +03:00
|
|
|
NEW_CHILD(ast, RNODE_HSHPTN(node)->nd_pconst),
|
|
|
|
NEW_CHILD(ast, RNODE_HSHPTN(node)->nd_pkwargs),
|
2019-09-01 10:39:34 +03:00
|
|
|
kwrest);
|
2019-04-17 09:48:03 +03:00
|
|
|
}
|
2023-12-28 06:38:24 +03:00
|
|
|
case NODE_LINE:
|
|
|
|
return rb_ary_new_from_args(1, rb_node_line_lineno_val(node));
|
2022-10-01 11:44:28 +03:00
|
|
|
case NODE_ERROR:
|
|
|
|
return rb_ary_new_from_node_args(ast, 0);
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_ARGS_AUX:
|
2023-08-22 04:26:38 +03:00
|
|
|
case NODE_RIPPER:
|
|
|
|
case NODE_RIPPER_VALUES:
|
2018-01-16 02:43:17 +03:00
|
|
|
case NODE_LAST:
|
2018-06-06 09:14:21 +03:00
|
|
|
break;
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
2023-05-24 11:24:41 +03:00
|
|
|
rb_bug("node_children: unknown node: %s", ruby_node_name(type));
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_children(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return node_children(data->ast, data->node);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_first_lineno(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return INT2NUM(nd_first_lineno(data->node));
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_first_column(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return INT2NUM(nd_first_column(data->node));
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_last_lineno(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return INT2NUM(nd_last_lineno(data->node));
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_last_column(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return INT2NUM(nd_last_column(data->node));
|
|
|
|
}
|
|
|
|
|
2022-09-23 16:40:02 +03:00
|
|
|
static VALUE
|
|
|
|
ast_node_all_tokens(rb_execution_context_t *ec, VALUE self)
|
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
return rb_ast_tokens(data->ast);
|
|
|
|
}
|
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
static VALUE
|
2019-11-07 12:29:20 +03:00
|
|
|
ast_node_inspect(rb_execution_context_t *ec, VALUE self)
|
2018-01-16 02:43:17 +03:00
|
|
|
{
|
|
|
|
VALUE str;
|
|
|
|
VALUE cname;
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
|
|
|
|
cname = rb_class_path(rb_obj_class(self));
|
|
|
|
str = rb_str_new2("#<");
|
|
|
|
|
|
|
|
rb_str_append(str, cname);
|
2018-12-24 04:56:21 +03:00
|
|
|
rb_str_catf(str, ":%s@%d:%d-%d:%d>",
|
|
|
|
node_type_to_str(data->node),
|
|
|
|
nd_first_lineno(data->node), nd_first_column(data->node),
|
|
|
|
nd_last_lineno(data->node), nd_last_column(data->node));
|
2018-01-16 02:43:17 +03:00
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2021-06-17 17:43:08 +03:00
|
|
|
static VALUE
|
|
|
|
ast_node_script_lines(rb_execution_context_t *ec, VALUE self)
|
|
|
|
{
|
|
|
|
struct ASTNodeData *data;
|
|
|
|
TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
|
|
|
|
VALUE ret = data->ast->body.script_lines;
|
2021-06-17 19:31:50 +03:00
|
|
|
if (!RB_TYPE_P(ret, T_ARRAY)) return Qnil;
|
2021-06-17 17:43:08 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-11-08 10:24:24 +03:00
|
|
|
#include "ast.rbinc"
|
2019-11-07 12:29:20 +03:00
|
|
|
|
2018-01-16 02:43:17 +03:00
|
|
|
void
|
|
|
|
Init_ast(void)
|
|
|
|
{
|
2018-11-09 04:37:41 +03:00
|
|
|
rb_mAST = rb_define_module_under(rb_cRubyVM, "AbstractSyntaxTree");
|
2018-01-16 02:43:17 +03:00
|
|
|
rb_cNode = rb_define_class_under(rb_mAST, "Node", rb_cObject);
|
2018-08-03 09:53:14 +03:00
|
|
|
rb_undef_alloc_func(rb_cNode);
|
2018-01-16 02:43:17 +03:00
|
|
|
}
|