ruby_parser.c

   1 /* This is a wrapper for parse.y */
   2
   3 #include "internal/parse.h"
   4 #include "internal/re.h"
   5 #include "internal/ruby_parser.h"
   6
   7 #include "node.h"
   8 #include "rubyparser.h"
   9 #include "internal/error.h"
  10
  11 #ifdef UNIVERSAL_PARSER
  12
  13 #include "internal.h"
  14 #include "internal/array.h"
  15 #include "internal/bignum.h"
  16 #include "internal/compile.h"
  17 #include "internal/complex.h"
  18 #include "internal/encoding.h"
  19 #include "internal/gc.h"
  20 #include "internal/hash.h"
  21 #include "internal/io.h"
  22 #include "internal/rational.h"
  23 #include "internal/re.h"
  24 #include "internal/string.h"
  25 #include "internal/symbol.h"
  26 #include "internal/thread.h"
  27
  28 #include "ruby/ractor.h"
  29 #include "ruby/ruby.h"
  30 #include "ruby/util.h"
  31 #include "internal.h"
  32 #include "vm_core.h"
  33 #include "symbol.h"
  34
  35 #define parser_encoding const void
  36
  37 static int
  38 is_ascii_string2(VALUE str)
  39 {
  40     return is_ascii_string(str);
  41 }
  42
  43 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
  44 static VALUE
  45 syntax_error_append(VALUE exc, VALUE file, int line, int column,
  46                     parser_encoding *enc, const char *fmt, va_list args)
  47 {
  48     return rb_syntax_error_append(exc, file, line, column, enc, fmt, args);
  49 }
  50
  51 static int
  52 local_defined(ID id, const void *p)
  53 {
  54     return rb_local_defined(id, (const rb_iseq_t *)p);
  55 }
  56
  57 static int
  58 dvar_defined(ID id, const void *p)
  59 {
  60     return rb_dvar_defined(id, (const rb_iseq_t *)p);
  61 }
  62
  63 static int
  64 is_usascii_enc(parser_encoding *enc)
  65 {
  66     return rb_is_usascii_enc(enc);
  67 }
  68
  69 static int
  70 is_local_id2(ID id)
  71 {
  72     return is_local_id(id);
  73 }
  74
  75 static int
  76 is_attrset_id2(ID id)
  77 {
  78     return is_attrset_id(id);
  79 }
  80
  81 static int
  82 is_notop_id2(ID id)
  83 {
  84     return is_notop_id(id);
  85 }
  86
  87 static VALUE
  88 enc_str_new(const char *ptr, long len, parser_encoding *enc)
  89 {
  90     return rb_enc_str_new(ptr, len, enc);
  91 }
  92
  93 static int
  94 enc_isalnum(OnigCodePoint c, parser_encoding *enc)
  95 {
  96     return rb_enc_isalnum(c, enc);
  97 }
  98
  99 static int
 100 enc_precise_mbclen(const char *p, const char *e, parser_encoding *enc)
 101 {
 102     return rb_enc_precise_mbclen(p, e, enc);
 103 }
 104
 105 static int
 106 mbclen_charfound_p(int len)
 107 {
 108     return MBCLEN_CHARFOUND_P(len);
 109 }
 110
 111 static int
 112 mbclen_charfound_len(int len)
 113 {
 114     return MBCLEN_CHARFOUND_LEN(len);
 115 }
 116
 117 static const char *
 118 enc_name(parser_encoding *enc)
 119 {
 120     return rb_enc_name(enc);
 121 }
 122
 123 static char *
 124 enc_prev_char(const char *s, const char *p, const char *e, parser_encoding *enc)
 125 {
 126     return rb_enc_prev_char(s, p, e, enc);
 127 }
 128
 129 static parser_encoding *
 130 enc_get(VALUE obj)
 131 {
 132     return rb_enc_get(obj);
 133 }
 134
 135 static int
 136 enc_asciicompat(parser_encoding *enc)
 137 {
 138     return rb_enc_asciicompat(enc);
 139 }
 140
 141 static parser_encoding *
 142 utf8_encoding(void)
 143 {
 144     return rb_utf8_encoding();
 145 }
 146
 147 static VALUE
 148 enc_associate(VALUE obj, parser_encoding *enc)
 149 {
 150     return rb_enc_associate(obj, enc);
 151 }
 152
 153 static parser_encoding *
 154 ascii8bit_encoding(void)
 155 {
 156     return rb_ascii8bit_encoding();
 157 }
 158
 159 static int
 160 enc_codelen(int c, parser_encoding *enc)
 161 {
 162     return rb_enc_codelen(c, enc);
 163 }
 164
 165 static int
 166 enc_mbcput(unsigned int c, void *buf, parser_encoding *enc)
 167 {
 168     return rb_enc_mbcput(c, buf, enc);
 169 }
 170
 171 static parser_encoding *
 172 enc_from_index(int idx)
 173 {
 174     return rb_enc_from_index(idx);
 175 }
 176
 177 static int
 178 enc_isspace(OnigCodePoint c, parser_encoding *enc)
 179 {
 180     return rb_enc_isspace(c, enc);
 181 }
 182
 183 static ID
 184 intern3(const char *name, long len, parser_encoding *enc)
 185 {
 186     return rb_intern3(name, len, enc);
 187 }
 188
 189 static parser_encoding *
 190 usascii_encoding(void)
 191 {
 192     return rb_usascii_encoding();
 193 }
 194
 195 static int
 196 enc_symname_type(const char *name, long len, parser_encoding *enc, unsigned int allowed_attrset)
 197 {
 198     return rb_enc_symname_type(name, len, enc, allowed_attrset);
 199 }
 200
 201 typedef struct {
 202     struct parser_params *parser;
 203     rb_encoding *enc;
 204     NODE *succ_block;
 205     const rb_code_location_t *loc;
 206 } reg_named_capture_assign_t;
 207
 208 static int
 209 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
 210           int back_num, int *back_refs, OnigRegex regex, void *arg0)
 211 {
 212     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
 213     struct parser_params* p = arg->parser;
 214     rb_encoding *enc = arg->enc;
 215     const rb_code_location_t *loc = arg->loc;
 216     long len = name_end - name;
 217     const char *s = (const char *)name;
 218
 219     return rb_reg_named_capture_assign_iter_impl(p, s, len, enc, &arg->succ_block, loc);
 220 }
 221
 222 static NODE *
 223 reg_named_capture_assign(struct parser_params* p, VALUE regexp, const rb_code_location_t *loc)
 224 {
 225     reg_named_capture_assign_t arg;
 226
 227     arg.parser = p;
 228     arg.enc = rb_enc_get(regexp);
 229     arg.succ_block = 0;
 230     arg.loc = loc;
 231     onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
 232
 233     if (!arg.succ_block) return 0;
 234     return RNODE_BLOCK(arg.succ_block)->nd_next;
 235 }
 236
 237 static int
 238 rtest(VALUE obj)
 239 {
 240     return (int)RB_TEST(obj);
 241 }
 242
 243 static int
 244 nil_p(VALUE obj)
 245 {
 246     return (int)NIL_P(obj);
 247 }
 248
 249 static VALUE
 250 syntax_error_new(void)
 251 {
 252     return rb_class_new_instance(0, 0, rb_eSyntaxError);
 253 }
 254
 255 static void *
 256 memmove2(void *dest, const void *src, size_t t, size_t n)
 257 {
 258     return memmove(dest, src, rbimpl_size_mul_or_raise(t, n));
 259 }
 260
 261 static void *
 262 nonempty_memcpy(void *dest, const void *src, size_t t, size_t n)
 263 {
 264     return ruby_nonempty_memcpy(dest, src, rbimpl_size_mul_or_raise(t, n));
 265 }
 266
 267 static VALUE
 268 ruby_verbose2(void)
 269 {
 270     return ruby_verbose;
 271 }
 272
 273 static int *
 274 rb_errno_ptr2(void)
 275 {
 276     return rb_errno_ptr();
 277 }
 278
 279 static void *
 280 zalloc(size_t elemsiz)
 281 {
 282     return ruby_xcalloc(1, elemsiz);
 283 }
 284
 285 static void
 286 gc_guard(VALUE obj)
 287 {
 288     RB_GC_GUARD(obj);
 289 }
 290
 291 static VALUE
 292 arg_error(void)
 293 {
 294     return rb_eArgError;
 295 }
 296
 297 static VALUE
 298 static_id2sym(ID id)
 299 {
 300     return (((VALUE)(id)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG);
 301 }
 302
 303 static long
 304 str_coderange_scan_restartable(const char *s, const char *e, parser_encoding *enc, int *cr)
 305 {
 306     return rb_str_coderange_scan_restartable(s, e, enc, cr);
 307 }
 308
 309 static int
 310 enc_mbminlen(parser_encoding *enc)
 311 {
 312     return rb_enc_mbminlen(enc);
 313 }
 314
 315 static bool
 316 enc_isascii(OnigCodePoint c, parser_encoding *enc)
 317 {
 318     return rb_enc_isascii(c, enc);
 319 }
 320
 321 static OnigCodePoint
 322 enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
 323 {
 324     const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
 325     const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
 326
 327     return ONIGENC_MBC_TO_CODE((rb_encoding *)enc, up, ue);
 328 }
 329
 330 extern VALUE rb_eArgError;
 331
 332 static const rb_parser_config_t rb_global_parser_config = {
 333     .malloc = ruby_xmalloc,
 334     .calloc = ruby_xcalloc,
 335     .realloc = ruby_xrealloc,
 336     .free = ruby_xfree,
 337     .alloc_n = ruby_xmalloc2,
 338     .alloc = ruby_xmalloc,
 339     .realloc_n = ruby_xrealloc2,
 340     .zalloc = zalloc,
 341     .rb_memmove = memmove2,
 342     .nonempty_memcpy = nonempty_memcpy,
 343     .xmalloc_mul_add = rb_xmalloc_mul_add,
 344
 345     .compile_callback = rb_suppress_tracing,
 346     .reg_named_capture_assign = reg_named_capture_assign,
 347
 348     .attr_get = rb_attr_get,
 349
 350     .ary_new = rb_ary_new,
 351     .ary_push = rb_ary_push,
 352     .ary_new_from_args = rb_ary_new_from_args,
 353     .ary_unshift = rb_ary_unshift,
 354
 355     .make_temporary_id = rb_make_temporary_id,
 356     .is_local_id = is_local_id2,
 357     .is_attrset_id = is_attrset_id2,
 358     .is_global_name_punct = is_global_name_punct,
 359     .id_type = id_type,
 360     .id_attrset = rb_id_attrset,
 361     .intern = rb_intern,
 362     .intern2 = rb_intern2,
 363     .intern3 = intern3,
 364     .intern_str = rb_intern_str,
 365     .is_notop_id = is_notop_id2,
 366     .enc_symname_type = enc_symname_type,
 367     .id2name = rb_id2name,
 368     .id2str = rb_id2str,
 369     .id2sym = rb_id2sym,
 370     .sym2id = rb_sym2id,
 371
 372     .str_catf = rb_str_catf,
 373     .str_cat_cstr = rb_str_cat_cstr,
 374     .str_modify = rb_str_modify,
 375     .str_set_len = rb_str_set_len,
 376     .str_cat = rb_str_cat,
 377     .str_resize = rb_str_resize,
 378     .str_new = rb_str_new,
 379     .str_new_cstr = rb_str_new_cstr,
 380     .str_to_interned_str = rb_str_to_interned_str,
 381     .is_ascii_string = is_ascii_string2,
 382     .enc_str_new = enc_str_new,
 383     .str_vcatf = rb_str_vcatf,
 384     .string_value_cstr = rb_string_value_cstr,
 385     .rb_sprintf = rb_sprintf,
 386     .rstring_ptr = RSTRING_PTR,
 387     .rstring_end = RSTRING_END,
 388     .rstring_len = RSTRING_LEN,
 389     .obj_as_string = rb_obj_as_string,
 390
 391     .int2num = rb_int2num_inline,
 392
 393     .stderr_tty_p = rb_stderr_tty_p,
 394     .write_error_str = rb_write_error_str,
 395     .io_write = rb_io_write,
 396     .io_flush = rb_io_flush,
 397     .io_puts = rb_io_puts,
 398
 399     .debug_output_stdout = rb_ractor_stdout,
 400     .debug_output_stderr = rb_ractor_stderr,
 401
 402     .is_usascii_enc = is_usascii_enc,
 403     .enc_isalnum = enc_isalnum,
 404     .enc_precise_mbclen = enc_precise_mbclen,
 405     .mbclen_charfound_p = mbclen_charfound_p,
 406     .mbclen_charfound_len = mbclen_charfound_len,
 407     .enc_name = enc_name,
 408     .enc_prev_char = enc_prev_char,
 409     .enc_get = enc_get,
 410     .enc_asciicompat = enc_asciicompat,
 411     .utf8_encoding = utf8_encoding,
 412     .enc_associate = enc_associate,
 413     .ascii8bit_encoding = ascii8bit_encoding,
 414     .enc_codelen = enc_codelen,
 415     .enc_mbcput = enc_mbcput,
 416     .enc_find_index = rb_enc_find_index,
 417     .enc_from_index = enc_from_index,
 418     .enc_isspace = enc_isspace,
 419     .enc_coderange_7bit = ENC_CODERANGE_7BIT,
 420     .enc_coderange_unknown = ENC_CODERANGE_UNKNOWN,
 421     .usascii_encoding = usascii_encoding,
 422     .enc_coderange_broken = ENC_CODERANGE_BROKEN,
 423     .enc_mbminlen = enc_mbminlen,
 424     .enc_isascii = enc_isascii,
 425     .enc_mbc_to_codepoint = enc_mbc_to_codepoint,
 426
 427     .local_defined = local_defined,
 428     .dvar_defined = dvar_defined,
 429
 430     .syntax_error_append = syntax_error_append,
 431     .raise = rb_raise,
 432     .syntax_error_new = syntax_error_new,
 433
 434     .errinfo = rb_errinfo,
 435     .set_errinfo = rb_set_errinfo,
 436     .exc_raise = rb_exc_raise,
 437     .make_exception = rb_make_exception,
 438
 439     .sized_xfree = ruby_sized_xfree,
 440     .sized_realloc_n = ruby_sized_realloc_n,
 441     .gc_guard = gc_guard,
 442     .gc_mark = rb_gc_mark,
 443
 444     .reg_compile = rb_reg_compile,
 445     .reg_check_preprocess = rb_reg_check_preprocess,
 446     .memcicmp = rb_memcicmp,
 447
 448     .compile_warn = rb_compile_warn,
 449     .compile_warning = rb_compile_warning,
 450     .bug = rb_bug,
 451     .fatal = rb_fatal,
 452     .verbose = ruby_verbose2,
 453     .errno_ptr = rb_errno_ptr2,
 454
 455     .make_backtrace = rb_make_backtrace,
 456
 457     .scan_hex = ruby_scan_hex,
 458     .scan_oct = ruby_scan_oct,
 459     .scan_digits = ruby_scan_digits,
 460     .strtod = ruby_strtod,
 461
 462     .rtest = rtest,
 463     .nil_p = nil_p,
 464     .qnil = Qnil,
 465     .qfalse = Qfalse,
 466     .eArgError = arg_error,
 467     .long2int = rb_long2int,
 468
 469     /* For Ripper */
 470     .static_id2sym = static_id2sym,
 471     .str_coderange_scan_restartable = str_coderange_scan_restartable,
 472 };
 473 #endif
 474
 475 enum lex_type {
 476     lex_type_str,
 477     lex_type_io,
 478     lex_type_array,
 479     lex_type_generic,
 480 };
 481
 482 struct ruby_parser {
 483     rb_parser_t *parser_params;
 484     enum lex_type type;
 485     union {
 486         struct lex_pointer_string lex_str;
 487         struct {
 488             VALUE file;
 489         } lex_io;
 490         struct {
 491             VALUE ary;
 492         } lex_array;
 493     } data;
 494 };
 495
 496 static void
 497 parser_mark(void *ptr)
 498 {
 499     struct ruby_parser *parser = (struct ruby_parser*)ptr;
 500     rb_ruby_parser_mark(parser->parser_params);
 501
 502     switch (parser->type) {
 503       case lex_type_str:
 504         rb_gc_mark(parser->data.lex_str.str);
 505         break;
 506       case lex_type_io:
 507         rb_gc_mark(parser->data.lex_io.file);
 508         break;
 509       case lex_type_array:
 510         rb_gc_mark(parser->data.lex_array.ary);
 511         break;
 512       case lex_type_generic:
 513         /* noop. Caller of rb_parser_compile_generic should mark the objects. */
 514         break;
 515     }
 516 }
 517
 518 static void
 519 parser_free(void *ptr)
 520 {
 521     struct ruby_parser *parser = (struct ruby_parser*)ptr;
 522     rb_ruby_parser_free(parser->parser_params);
 523     xfree(parser);
 524 }
 525
 526 static size_t
 527 parser_memsize(const void *ptr)
 528 {
 529     struct ruby_parser *parser = (struct ruby_parser*)ptr;
 530     return rb_ruby_parser_memsize(parser->parser_params);
 531 }
 532
 533 static const rb_data_type_t ruby_parser_data_type = {
 534     "parser",
 535     {
 536         parser_mark,
 537         parser_free,
 538         parser_memsize,
 539     },
 540     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 541 };
 542
 543 #ifdef UNIVERSAL_PARSER
 544 const rb_parser_config_t *
 545 rb_ruby_parser_config(void)
 546 {
 547     return &rb_global_parser_config;
 548 }
 549
 550 rb_parser_t *
 551 rb_parser_params_new(void)
 552 {
 553     return rb_ruby_parser_new(&rb_global_parser_config);
 554 }
 555 #else
 556 rb_parser_t *
 557 rb_parser_params_new(void)
 558 {
 559     return rb_ruby_parser_new();
 560 }
 561 #endif /* UNIVERSAL_PARSER */
 562
 563 VALUE
 564 rb_parser_new(void)
 565 {
 566     struct ruby_parser *parser;
 567     rb_parser_t *parser_params;
 568
 569     /*
 570      * Create parser_params ahead of vparser because
 571      * rb_ruby_parser_new can run GC so if create vparser
 572      * first, parser_mark tries to mark not initialized parser_params.
 573      */
 574     parser_params = rb_parser_params_new();
 575     VALUE vparser = TypedData_Make_Struct(0, struct ruby_parser,
 576                                          &ruby_parser_data_type, parser);
 577     parser->parser_params = parser_params;
 578
 579     return vparser;
 580 }
 581
 582 void
 583 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
 584 {
 585     struct ruby_parser *parser;
 586
 587     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 588     rb_ruby_parser_set_options(parser->parser_params, print, loop, chomp, split);
 589 }
 590
 591 VALUE
 592 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
 593 {
 594     struct ruby_parser *parser;
 595
 596     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 597     rb_ruby_parser_set_context(parser->parser_params, base, main);
 598     return vparser;
 599 }
 600
 601 void
 602 rb_parser_set_script_lines(VALUE vparser)
 603 {
 604     struct ruby_parser *parser;
 605
 606     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 607     rb_ruby_parser_set_script_lines(parser->parser_params);
 608 }
 609
 610 void
 611 rb_parser_error_tolerant(VALUE vparser)
 612 {
 613     struct ruby_parser *parser;
 614
 615     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 616     rb_ruby_parser_error_tolerant(parser->parser_params);
 617 }
 618
 619 void
 620 rb_parser_keep_tokens(VALUE vparser)
 621 {
 622     struct ruby_parser *parser;
 623
 624     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 625     rb_ruby_parser_keep_tokens(parser->parser_params);
 626 }
 627
 628 rb_parser_string_t *
 629 rb_parser_lex_get_str(struct parser_params *p, struct lex_pointer_string *ptr_str)
 630 {
 631     char *beg, *end, *start;
 632     long len;
 633     VALUE s = ptr_str->str;
 634
 635     beg = RSTRING_PTR(s);
 636     len = RSTRING_LEN(s);
 637     start = beg;
 638     if (ptr_str->ptr) {
 639         if (len == ptr_str->ptr) return 0;
 640         beg += ptr_str->ptr;
 641         len -= ptr_str->ptr;
 642     }
 643     end = memchr(beg, '\n', len);
 644     if (end) len = ++end - beg;
 645     ptr_str->ptr += len;
 646     return rb_str_to_parser_string(p, rb_str_subseq(s, beg - start, len));
 647 }
 648
 649 static rb_parser_string_t *
 650 lex_get_str(struct parser_params *p, rb_parser_input_data input, int line_count)
 651 {
 652     return rb_parser_lex_get_str(p, (struct lex_pointer_string *)input);
 653 }
 654
 655 static void parser_aset_script_lines_for(VALUE path, rb_parser_ary_t *lines);
 656
 657 static rb_ast_t*
 658 parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, VALUE fname, rb_parser_input_data input, int line)
 659 {
 660     rb_ast_t *ast = rb_parser_compile(p, gets, fname, input, line);
 661     parser_aset_script_lines_for(fname, ast->body.script_lines);
 662     return ast;
 663 }
 664
 665 static rb_ast_t*
 666 parser_compile_string0(struct ruby_parser *parser, VALUE fname, VALUE s, int line)
 667 {
 668     VALUE str = rb_str_new_frozen(s);
 669
 670     parser->type = lex_type_str;
 671     parser->data.lex_str.str = str;
 672     parser->data.lex_str.ptr = 0;
 673
 674     return parser_compile(parser->parser_params, lex_get_str, fname, (rb_parser_input_data)&parser->data, line);
 675 }
 676
 677 static rb_encoding *
 678 must_be_ascii_compatible(VALUE s)
 679 {
 680     rb_encoding *enc = rb_enc_get(s);
 681     if (!rb_enc_asciicompat(enc)) {
 682         rb_raise(rb_eArgError, "invalid source encoding");
 683     }
 684     return enc;
 685 }
 686
 687 static rb_ast_t*
 688 parser_compile_string_path(struct ruby_parser *parser, VALUE f, VALUE s, int line)
 689 {
 690     must_be_ascii_compatible(s);
 691     return parser_compile_string0(parser, f, s, line);
 692 }
 693
 694 static rb_ast_t*
 695 parser_compile_string(struct ruby_parser *parser, const char *f, VALUE s, int line)
 696 {
 697     return parser_compile_string_path(parser, rb_filesystem_str_new_cstr(f), s, line);
 698 }
 699
 700 VALUE rb_io_gets_internal(VALUE io);
 701
 702 static rb_parser_string_t *
 703 lex_io_gets(struct parser_params *p, rb_parser_input_data input, int line_count)
 704 {
 705     VALUE io = (VALUE)input;
 706     VALUE line = rb_io_gets_internal(io);
 707     if (NIL_P(line)) return 0;
 708     return rb_str_to_parser_string(p, line);
 709 }
 710
 711 static rb_parser_string_t *
 712 lex_gets_array(struct parser_params *p, rb_parser_input_data data, int index)
 713 {
 714     VALUE array = (VALUE)data;
 715     VALUE str = rb_ary_entry(array, index);
 716     if (!NIL_P(str)) {
 717         StringValue(str);
 718         if (!rb_enc_asciicompat(rb_enc_get(str))) {
 719             rb_raise(rb_eArgError, "invalid source encoding");
 720         }
 721         return rb_str_to_parser_string(p, str);
 722     }
 723     else {
 724         return 0;
 725     }
 726 }
 727
 728 static rb_ast_t*
 729 parser_compile_file_path(struct ruby_parser *parser, VALUE fname, VALUE file, int start)
 730 {
 731     parser->type = lex_type_io;
 732     parser->data.lex_io.file = file;
 733
 734     return parser_compile(parser->parser_params, lex_io_gets, fname, (rb_parser_input_data)file, start);
 735 }
 736
 737 static rb_ast_t*
 738 parser_compile_array(struct ruby_parser *parser, VALUE fname, VALUE array, int start)
 739 {
 740     parser->type = lex_type_array;
 741     parser->data.lex_array.ary = array;
 742
 743     return parser_compile(parser->parser_params, lex_gets_array, fname, (rb_parser_input_data)array, start);
 744 }
 745
 746 static rb_ast_t*
 747 parser_compile_generic(struct ruby_parser *parser, rb_parser_lex_gets_func *lex_gets, VALUE fname, VALUE input, int start)
 748 {
 749     parser->type = lex_type_generic;
 750
 751     return parser_compile(parser->parser_params, lex_gets, fname, (rb_parser_input_data)input, start);
 752 }
 753
 754 static void
 755 ast_free(void *ptr)
 756 {
 757     rb_ast_t *ast = (rb_ast_t *)ptr;
 758     rb_ast_free(ast);
 759 }
 760
 761 static const rb_data_type_t ast_data_type = {
 762     "AST",
 763     {
 764         NULL,
 765         ast_free,
 766         NULL, // No dsize() because this object does not appear in ObjectSpace.
 767     },
 768     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 769 };
 770
 771 static VALUE
 772 ast_alloc(void)
 773 {
 774     return TypedData_Wrap_Struct(0, &ast_data_type, NULL);
 775 }
 776
 777 VALUE
 778 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
 779 {
 780     struct ruby_parser *parser;
 781     VALUE ast_value = ast_alloc();
 782
 783     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 784     DATA_PTR(ast_value) = parser_compile_file_path(parser, fname, file, start);
 785     RB_GC_GUARD(vparser);
 786
 787     return ast_value;
 788 }
 789
 790 VALUE
 791 rb_parser_compile_array(VALUE vparser, VALUE fname, VALUE array, int start)
 792 {
 793     struct ruby_parser *parser;
 794     VALUE ast_value = ast_alloc();
 795
 796     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 797     DATA_PTR(ast_value) = parser_compile_array(parser, fname, array, start);
 798     RB_GC_GUARD(vparser);
 799
 800     return ast_value;
 801 }
 802
 803 VALUE
 804 rb_parser_compile_generic(VALUE vparser, rb_parser_lex_gets_func *lex_gets, VALUE fname, VALUE input, int start)
 805 {
 806     struct ruby_parser *parser;
 807     VALUE ast_value = ast_alloc();
 808
 809     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 810     DATA_PTR(ast_value) = parser_compile_generic(parser, lex_gets, fname, input, start);
 811     RB_GC_GUARD(vparser);
 812
 813     return ast_value;
 814 }
 815
 816 VALUE
 817 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
 818 {
 819     struct ruby_parser *parser;
 820     VALUE ast_value = ast_alloc();
 821
 822     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 823     DATA_PTR(ast_value) = parser_compile_string(parser, f, s, line);
 824     RB_GC_GUARD(vparser);
 825
 826     return ast_value;
 827 }
 828
 829 VALUE
 830 rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
 831 {
 832     struct ruby_parser *parser;
 833     VALUE ast_value = ast_alloc();
 834
 835     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 836     DATA_PTR(ast_value) = parser_compile_string_path(parser, f, s, line);
 837     RB_GC_GUARD(vparser);
 838
 839     return ast_value;
 840 }
 841
 842 VALUE
 843 rb_parser_encoding(VALUE vparser)
 844 {
 845     struct ruby_parser *parser;
 846
 847     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 848     return rb_enc_from_encoding(rb_ruby_parser_encoding(parser->parser_params));
 849 }
 850
 851 VALUE
 852 rb_parser_end_seen_p(VALUE vparser)
 853 {
 854     struct ruby_parser *parser;
 855
 856     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 857     return RBOOL(rb_ruby_parser_end_seen_p(parser->parser_params));
 858 }
 859
 860 VALUE
 861 rb_parser_set_yydebug(VALUE vparser, VALUE flag)
 862 {
 863     struct ruby_parser *parser;
 864
 865     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 866     rb_ruby_parser_set_yydebug(parser->parser_params, RTEST(flag));
 867     return flag;
 868 }
 869
 870 void
 871 rb_set_script_lines_for(VALUE vparser, VALUE path)
 872 {
 873     struct ruby_parser *parser;
 874     VALUE hash;
 875     ID script_lines;
 876     CONST_ID(script_lines, "SCRIPT_LINES__");
 877     if (!rb_const_defined_at(rb_cObject, script_lines)) return;
 878     hash = rb_const_get_at(rb_cObject, script_lines);
 879     if (RB_TYPE_P(hash, T_HASH)) {
 880         rb_hash_aset(hash, path, Qtrue);
 881         TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 882         rb_ruby_parser_set_script_lines(parser->parser_params);
 883     }
 884 }
 885
 886 VALUE
 887 rb_parser_build_script_lines_from(rb_parser_ary_t *lines)
 888 {
 889     int i;
 890     if (!lines) return Qnil;
 891     if (lines->data_type != PARSER_ARY_DATA_SCRIPT_LINE) {
 892         rb_bug("unexpected rb_parser_ary_data_type (%d) for script lines", lines->data_type);
 893     }
 894     VALUE script_lines = rb_ary_new_capa(lines->len);
 895     for (i = 0; i < lines->len; i++) {
 896         rb_parser_string_t *str = (rb_parser_string_t *)lines->data[i];
 897         rb_ary_push(script_lines, rb_enc_str_new(str->ptr, str->len, str->enc));
 898     }
 899     return script_lines;
 900 }
 901
 902 VALUE
 903 rb_str_new_parser_string(rb_parser_string_t *str)
 904 {
 905     VALUE string = rb_enc_literal_str(str->ptr, str->len, str->enc);
 906     rb_enc_str_coderange(string);
 907     return string;
 908 }
 909
 910 VALUE
 911 rb_str_new_mutable_parser_string(rb_parser_string_t *str)
 912 {
 913     return rb_enc_str_new(str->ptr, str->len, str->enc);
 914 }
 915
 916 static VALUE
 917 negative_numeric(VALUE val)
 918 {
 919     if (FIXNUM_P(val)) {
 920         return LONG2FIX(-FIX2LONG(val));
 921     }
 922     if (SPECIAL_CONST_P(val)) {
 923 #if USE_FLONUM
 924         if (FLONUM_P(val)) {
 925             return DBL2NUM(-RFLOAT_VALUE(val));
 926         }
 927 #endif
 928         goto unknown;
 929     }
 930     switch (BUILTIN_TYPE(val)) {
 931       case T_BIGNUM:
 932         BIGNUM_NEGATE(val);
 933         val = rb_big_norm(val);
 934         break;
 935       case T_RATIONAL:
 936         RATIONAL_SET_NUM(val, negative_numeric(RRATIONAL(val)->num));
 937         break;
 938       case T_COMPLEX:
 939         RCOMPLEX_SET_REAL(val, negative_numeric(RCOMPLEX(val)->real));
 940         RCOMPLEX_SET_IMAG(val, negative_numeric(RCOMPLEX(val)->imag));
 941         break;
 942       case T_FLOAT:
 943         val = DBL2NUM(-RFLOAT_VALUE(val));
 944         break;
 945       unknown:
 946       default:
 947         rb_bug("unknown literal type (%s) passed to negative_numeric",
 948                rb_builtin_class_name(val));
 949         break;
 950     }
 951     return val;
 952 }
 953
 954 static VALUE
 955 integer_value(const char *val, int base)
 956 {
 957     return rb_cstr_to_inum(val, base, FALSE);
 958 }
 959
 960 static VALUE
 961 rational_value(const char *node_val, int base, int seen_point)
 962 {
 963     VALUE lit;
 964     char* val = strdup(node_val);
 965     if (seen_point > 0) {
 966         int len = (int)(strlen(val));
 967         char *point = &val[seen_point];
 968         size_t fraclen = len-seen_point-1;
 969         memmove(point, point+1, fraclen+1);
 970
 971         lit = rb_rational_new(integer_value(val, base), rb_int_positive_pow(10, fraclen));
 972     }
 973     else {
 974         lit = rb_rational_raw1(integer_value(val, base));
 975     }
 976
 977     free(val);
 978
 979     return lit;
 980 }
 981
 982 VALUE
 983 rb_node_integer_literal_val(const NODE *n)
 984 {
 985     const rb_node_integer_t *node = RNODE_INTEGER(n);
 986     VALUE val = integer_value(node->val, node->base);
 987     if (node->minus) {
 988         val = negative_numeric(val);
 989     }
 990     return val;
 991 }
 992
 993 VALUE
 994 rb_node_float_literal_val(const NODE *n)
 995 {
 996     const rb_node_float_t *node = RNODE_FLOAT(n);
 997     double d = strtod(node->val, 0);
 998     if (node->minus) {
 999         d = -d;
1000     }
1001     VALUE val = DBL2NUM(d);
1002     return val;
1003 }
1004
1005 VALUE
1006 rb_node_rational_literal_val(const NODE *n)
1007 {
1008     VALUE lit;
1009     const rb_node_rational_t *node = RNODE_RATIONAL(n);
1010
1011     lit = rational_value(node->val, node->base, node->seen_point);
1012
1013     if (node->minus) {
1014         lit = negative_numeric(lit);
1015     }
1016
1017     return lit;
1018 }
1019
1020 VALUE
1021 rb_node_imaginary_literal_val(const NODE *n)
1022 {
1023     VALUE lit;
1024     const rb_node_imaginary_t *node = RNODE_IMAGINARY(n);
1025
1026     enum rb_numeric_type type = node->type;
1027
1028     switch (type) {
1029       case integer_literal:
1030         lit = integer_value(node->val, node->base);
1031         break;
1032       case float_literal:{
1033         double d = strtod(node->val, 0);
1034         lit = DBL2NUM(d);
1035         break;
1036       }
1037       case rational_literal:
1038         lit = rational_value(node->val, node->base, node->seen_point);
1039         break;
1040       default:
1041         rb_bug("unreachable");
1042     }
1043
1044     lit = rb_complex_raw(INT2FIX(0), lit);
1045
1046     if (node->minus) {
1047         lit = negative_numeric(lit);
1048     }
1049     return lit;
1050 }
1051
1052 VALUE
1053 rb_node_str_string_val(const NODE *node)
1054 {
1055     rb_parser_string_t *str = RNODE_STR(node)->string;
1056     return rb_str_new_parser_string(str);
1057 }
1058
1059 VALUE
1060 rb_node_sym_string_val(const NODE *node)
1061 {
1062     rb_parser_string_t *str = RNODE_SYM(node)->string;
1063     return ID2SYM(rb_intern3(str->ptr, str->len, str->enc));
1064 }
1065
1066 VALUE
1067 rb_node_dstr_string_val(const NODE *node)
1068 {
1069     rb_parser_string_t *str = RNODE_DSTR(node)->string;
1070     return str ? rb_str_new_parser_string(str) : Qnil;
1071 }
1072
1073 VALUE
1074 rb_node_dregx_string_val(const NODE *node)
1075 {
1076     rb_parser_string_t *str = RNODE_DREGX(node)->string;
1077     return rb_str_new_parser_string(str);
1078 }
1079
1080 VALUE
1081 rb_node_regx_string_val(const NODE *node)
1082 {
1083     rb_node_regx_t *node_reg = RNODE_REGX(node);
1084     rb_parser_string_t *string = node_reg->string;
1085     VALUE str = rb_enc_str_new(string->ptr, string->len, string->enc);
1086
1087     return rb_reg_compile(str, node_reg->options, NULL, 0);
1088 }
1089
1090 VALUE
1091 rb_node_line_lineno_val(const NODE *node)
1092 {
1093     return INT2FIX(node->nd_loc.beg_pos.lineno);
1094 }
1095
1096 VALUE
1097 rb_node_file_path_val(const NODE *node)
1098 {
1099     return rb_str_new_parser_string(RNODE_FILE(node)->path);
1100 }
1101
1102 VALUE
1103 rb_node_encoding_val(const NODE *node)
1104 {
1105     return rb_enc_from_encoding(RNODE_ENCODING(node)->enc);
1106 }
1107
1108 static void
1109 parser_aset_script_lines_for(VALUE path, rb_parser_ary_t *lines)
1110 {
1111     VALUE hash, script_lines;
1112     ID script_lines_id;
1113     if (NIL_P(path) || !lines) return;
1114     CONST_ID(script_lines_id, "SCRIPT_LINES__");
1115     if (!rb_const_defined_at(rb_cObject, script_lines_id)) return;
1116     hash = rb_const_get_at(rb_cObject, script_lines_id);
1117     if (!RB_TYPE_P(hash, T_HASH)) return;
1118     if (rb_hash_lookup(hash, path) == Qnil) return;
1119     script_lines = rb_parser_build_script_lines_from(lines);
1120     rb_hash_aset(hash, path, script_lines);
1121 }
1122
1123 VALUE
1124 rb_ruby_ast_new(const NODE *const root)
1125 {
1126     rb_ast_t *ast;
1127     VALUE ast_value = TypedData_Make_Struct(0, rb_ast_t, &ast_data_type, ast);
1128 #ifdef UNIVERSAL_PARSER
1129     ast->config = &rb_global_parser_config;
1130 #endif
1131     ast->body = (rb_ast_body_t){
1132         .root = root,
1133         .frozen_string_literal = -1,
1134         .coverage_enabled = -1,
1135         .script_lines = NULL,
1136         .line_count = 0,
1137     };
1138     return ast_value;
1139 }
1140
1141 rb_ast_t *
1142 rb_ruby_ast_data_get(VALUE ast_value)
1143 {
1144     rb_ast_t *ast;
1145     if (NIL_P(ast_value)) return NULL;
1146     TypedData_Get_Struct(ast_value, rb_ast_t, &ast_data_type, ast);
1147     return ast;
1148 }