ruby_parser.c

   1 /* This is a wrapper for parse.y */
   2 #ifdef UNIVERSAL_PARSER
   3
   4 #include "internal.h"
   5 #include "internal/array.h"
   6 #include "internal/bignum.h"
   7 #include "internal/compile.h"
   8 #include "internal/complex.h"
   9 #include "internal/encoding.h"
  10 #include "internal/error.h"
  11 #include "internal/gc.h"
  12 #include "internal/hash.h"
  13 #include "internal/io.h"
  14 #include "internal/parse.h"
  15 #include "internal/rational.h"
  16 #include "internal/re.h"
  17 #include "internal/ruby_parser.h"
  18 #include "internal/string.h"
  19 #include "internal/symbol.h"
  20 #include "internal/thread.h"
  21
  22 #include "ruby/ractor.h"
  23 #include "ruby/ruby.h"
  24 #include "ruby/util.h"
  25 #include "node.h"
  26 #include "internal.h"
  27 #include "vm_core.h"
  28 #include "symbol.h"
  29
  30 struct ruby_parser {
  31     rb_parser_t *parser_params;
  32 };
  33
  34 static void
  35 parser_mark(void *ptr)
  36 {
  37     struct ruby_parser *parser = (struct ruby_parser*)ptr;
  38     rb_ruby_parser_mark(parser->parser_params);
  39 }
  40
  41 static void
  42 parser_free(void *ptr)
  43 {
  44     struct ruby_parser *parser = (struct ruby_parser*)ptr;
  45     rb_ruby_parser_free(parser->parser_params);
  46 }
  47
  48 static size_t
  49 parser_memsize(const void *ptr)
  50 {
  51     struct ruby_parser *parser = (struct ruby_parser*)ptr;
  52     return rb_ruby_parser_memsize(parser->parser_params);
  53 }
  54
  55 static const rb_data_type_t ruby_parser_data_type = {
  56     "parser",
  57     {
  58         parser_mark,
  59         parser_free,
  60         parser_memsize,
  61     },
  62     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
  63 };
  64
  65 static void
  66 bignum_negate(VALUE b)
  67 {
  68     BIGNUM_NEGATE(b);
  69 }
  70
  71 static int
  72 is_ascii_string2(VALUE str)
  73 {
  74     return is_ascii_string(str);
  75 }
  76
  77 static void
  78 rational_set_num(VALUE r, VALUE n)
  79 {
  80     RATIONAL_SET_NUM(r, n);
  81 }
  82
  83 static VALUE
  84 rational_get_num(VALUE obj)
  85 {
  86     return RRATIONAL(obj)->num;
  87 }
  88
  89 static void
  90 rcomplex_set_real(VALUE cmp, VALUE r)
  91 {
  92     RCOMPLEX_SET_REAL(cmp, r);
  93 }
  94
  95 static void
  96 rcomplex_set_imag(VALUE cmp, VALUE i)
  97 {
  98     RCOMPLEX_SET_IMAG(cmp, i);
  99 }
 100
 101 static VALUE
 102 rcomplex_get_real(VALUE obj)
 103 {
 104     return RCOMPLEX(obj)->real;
 105 }
 106
 107 static VALUE
 108 rcomplex_get_imag(VALUE obj)
 109 {
 110     return RCOMPLEX(obj)->imag;
 111 }
 112
 113 static VALUE
 114 syntax_error_append(VALUE exc, VALUE file, int line, int column,
 115                        void *enc, const char *fmt, va_list args)
 116 {
 117     return rb_syntax_error_append(exc, file, line, column, (rb_encoding *)enc, fmt, args);
 118 }
 119
 120 static int
 121 local_defined(ID id, const void *p)
 122 {
 123     return rb_local_defined(id, (const rb_iseq_t *)p);
 124 }
 125
 126 static int
 127 dvar_defined(ID id, const void *p)
 128 {
 129     return rb_dvar_defined(id, (const rb_iseq_t *)p);
 130 }
 131
 132 static bool
 133 hash_literal_key_p(VALUE k)
 134 {
 135     switch (OBJ_BUILTIN_TYPE(k)) {
 136       case T_NODE:
 137         return false;
 138       default:
 139         return true;
 140     }
 141 }
 142
 143 static int
 144 literal_cmp(VALUE val, VALUE lit)
 145 {
 146     if (val == lit) return 0;
 147     if (!hash_literal_key_p(val) || !hash_literal_key_p(lit)) return -1;
 148     return rb_iseq_cdhash_cmp(val, lit);
 149 }
 150
 151 static st_index_t
 152 literal_hash(VALUE a)
 153 {
 154     if (!hash_literal_key_p(a)) return (st_index_t)a;
 155     return rb_iseq_cdhash_hash(a);
 156 }
 157
 158 static int
 159 is_usascii_enc(void *enc)
 160 {
 161     return rb_is_usascii_enc((rb_encoding *)enc);
 162 }
 163
 164 static int
 165 is_local_id2(ID id)
 166 {
 167     return is_local_id(id);
 168 }
 169
 170 static int
 171 is_attrset_id2(ID id)
 172 {
 173     return is_attrset_id(id);
 174 }
 175
 176 static int
 177 is_notop_id2(ID id)
 178 {
 179     return is_notop_id(id);
 180 }
 181
 182 static VALUE
 183 enc_str_new(const char *ptr, long len, void *enc)
 184 {
 185     return rb_enc_str_new(ptr, len, (rb_encoding *)enc);
 186 }
 187
 188 static int
 189 enc_isalnum(OnigCodePoint c, void *enc)
 190 {
 191     return rb_enc_isalnum(c, (rb_encoding *)enc);
 192 }
 193
 194 static int
 195 enc_precise_mbclen(const char *p, const char *e, void *enc)
 196 {
 197     return rb_enc_precise_mbclen(p, e, (rb_encoding *)enc);
 198 }
 199
 200 static int
 201 mbclen_charfound_p(int len)
 202 {
 203     return MBCLEN_CHARFOUND_P(len);
 204 }
 205
 206 static const char *
 207 enc_name(void *enc)
 208 {
 209     return rb_enc_name((rb_encoding *)enc);
 210 }
 211
 212 static char *
 213 enc_prev_char(const char *s, const char *p, const char *e, void *enc)
 214 {
 215     return rb_enc_prev_char(s, p, e, (rb_encoding *)enc);
 216 }
 217
 218 static void *
 219 enc_get(VALUE obj)
 220 {
 221     return (void *)rb_enc_get(obj);
 222 }
 223
 224 static int
 225 enc_asciicompat(void *enc)
 226 {
 227     return rb_enc_asciicompat((rb_encoding *)enc);
 228 }
 229
 230 static void *
 231 utf8_encoding(void)
 232 {
 233     return (void *)rb_utf8_encoding();
 234 }
 235
 236 static VALUE
 237 enc_associate(VALUE obj, void *enc)
 238 {
 239     return rb_enc_associate(obj, (rb_encoding *)enc);
 240 }
 241
 242 static void *
 243 ascii8bit_encoding(void)
 244 {
 245     return (void *)rb_ascii8bit_encoding();
 246 }
 247
 248 static int
 249 enc_codelen(int c, void *enc)
 250 {
 251     return rb_enc_codelen(c, (rb_encoding *)enc);
 252 }
 253
 254 static VALUE
 255 enc_str_buf_cat(VALUE str, const char *ptr, long len, void *enc)
 256 {
 257     return rb_enc_str_buf_cat(str, ptr, len, (rb_encoding *)enc);
 258 }
 259
 260 static int
 261 enc_mbcput(unsigned int c, void *buf, void *enc)
 262 {
 263     return rb_enc_mbcput(c, buf, (rb_encoding *)enc);
 264 }
 265
 266 static void *
 267 enc_from_index(int idx)
 268 {
 269     return (void *)rb_enc_from_index(idx);
 270 }
 271
 272 static int
 273 enc_isspace(OnigCodePoint c, void *enc)
 274 {
 275     return rb_enc_isspace(c, (rb_encoding *)enc);
 276 }
 277
 278 static ID
 279 intern3(const char *name, long len, void *enc)
 280 {
 281     return rb_intern3(name, len, (rb_encoding *)enc);
 282 }
 283
 284 static void *
 285 enc_compatible(VALUE str1, VALUE str2)
 286 {
 287     return (void *)rb_enc_compatible(str1, str2);
 288 }
 289
 290 static VALUE
 291 enc_from_encoding(void *enc)
 292 {
 293     return rb_enc_from_encoding((rb_encoding *)enc);
 294 }
 295
 296 static int
 297 encoding_get(VALUE obj)
 298 {
 299     return ENCODING_GET(obj);
 300 }
 301
 302 static void
 303 encoding_set(VALUE obj, int encindex)
 304 {
 305     ENCODING_SET(obj, encindex);
 306 }
 307
 308 static int
 309 encoding_is_ascii8bit(VALUE obj)
 310 {
 311     return ENCODING_IS_ASCII8BIT(obj);
 312 }
 313
 314 static void *
 315 usascii_encoding(void)
 316 {
 317     return (void *)rb_usascii_encoding();
 318 }
 319
 320 static int
 321 enc_symname_type(const char *name, long len, void *enc, unsigned int allowed_attrset)
 322 {
 323     return rb_enc_symname_type(name, len, (rb_encoding *)enc, allowed_attrset);
 324 }
 325
 326 typedef struct {
 327     struct parser_params *parser;
 328     rb_encoding *enc;
 329     NODE *succ_block;
 330     const rb_code_location_t *loc;
 331 } reg_named_capture_assign_t;
 332
 333 static int
 334 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
 335           int back_num, int *back_refs, OnigRegex regex, void *arg0)
 336 {
 337     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
 338     struct parser_params* p = arg->parser;
 339     rb_encoding *enc = arg->enc;
 340     const rb_code_location_t *loc = arg->loc;
 341     long len = name_end - name;
 342     const char *s = (const char *)name;
 343
 344     return rb_reg_named_capture_assign_iter_impl(p, s, len, (void *)enc, &arg->succ_block, loc);
 345 }
 346
 347 static NODE *
 348 reg_named_capture_assign(struct parser_params* p, VALUE regexp, const rb_code_location_t *loc)
 349 {
 350     reg_named_capture_assign_t arg;
 351
 352     arg.parser = p;
 353     arg.enc = rb_enc_get(regexp);
 354     arg.succ_block = 0;
 355     arg.loc = loc;
 356     onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
 357
 358     if (!arg.succ_block) return 0;
 359     return RNODE_BLOCK(arg.succ_block)->nd_next;
 360 }
 361
 362 static VALUE
 363 rbool(VALUE v)
 364 {
 365     return RBOOL(v);
 366 }
 367
 368 static int
 369 undef_p(VALUE v)
 370 {
 371     return RB_UNDEF_P(v);
 372 }
 373
 374 static int
 375 rtest(VALUE obj)
 376 {
 377     return (int)RB_TEST(obj);
 378 }
 379
 380 static int
 381 nil_p(VALUE obj)
 382 {
 383     return (int)NIL_P(obj);
 384 }
 385
 386 static int
 387 flonum_p(VALUE obj)
 388 {
 389     return (int)RB_FLONUM_P(obj);
 390 }
 391
 392 static VALUE
 393 int2fix(long i)
 394 {
 395     return INT2FIX(i);
 396 }
 397
 398 static VALUE
 399 syntax_error_new(void)
 400 {
 401     return rb_class_new_instance(0, 0, rb_eSyntaxError);
 402 }
 403
 404 static int
 405 obj_frozen(VALUE obj)
 406 {
 407     return (int)RB_OBJ_FROZEN(obj);
 408 }
 409
 410 static VALUE
 411 obj_write(VALUE old, VALUE *slot, VALUE young)
 412 {
 413     return RB_OBJ_WRITE(old, slot, young);
 414 }
 415
 416 static VALUE
 417 obj_written(VALUE old, VALUE slot, VALUE young)
 418 {
 419     return RB_OBJ_WRITTEN(old, slot, young);
 420 }
 421
 422 static VALUE
 423 default_rs(void)
 424 {
 425     return rb_default_rs;
 426 }
 427
 428 static VALUE
 429 rational_raw1(VALUE x)
 430 {
 431     return rb_rational_raw1(x);
 432 }
 433
 434 static void *
 435 memmove2(void *dest, const void *src, size_t t, size_t n)
 436 {
 437     return memmove(dest, src, rbimpl_size_mul_or_raise(t, n));
 438 }
 439
 440 static void *
 441 nonempty_memcpy(void *dest, const void *src, size_t t, size_t n)
 442 {
 443     return ruby_nonempty_memcpy(dest, src, rbimpl_size_mul_or_raise(t, n));
 444 }
 445
 446 static VALUE
 447 ruby_verbose2(void)
 448 {
 449     return ruby_verbose;
 450 }
 451
 452 static int
 453 type_p(VALUE obj, int t)
 454 {
 455     return (int)RB_TYPE_P(obj, t);
 456 }
 457
 458 static int
 459 fixnum_p(VALUE obj)
 460 {
 461     return (int)RB_FIXNUM_P(obj);
 462 }
 463
 464 static int
 465 symbol_p(VALUE obj)
 466 {
 467     return (int)RB_SYMBOL_P(obj);
 468 }
 469
 470 static void *
 471 zalloc(size_t elemsiz)
 472 {
 473     return ruby_xcalloc(1, elemsiz);
 474 }
 475
 476 static void
 477 gc_guard(VALUE obj)
 478 {
 479     RB_GC_GUARD(obj);
 480 }
 481
 482 static rb_imemo_tmpbuf_t *
 483 tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt)
 484 {
 485     return rb_imemo_tmpbuf_parser_heap(buf, old_heap, cnt);
 486 }
 487
 488 static int
 489 special_const_p(VALUE obj)
 490 {
 491     return (int)RB_SPECIAL_CONST_P(obj);
 492 }
 493
 494 static int
 495 builtin_type(VALUE obj)
 496 {
 497     return (int)RB_BUILTIN_TYPE(obj);
 498 }
 499
 500 static rb_ast_t *
 501 ast_new(VALUE nb)
 502 {
 503     rb_ast_t *ast = (rb_ast_t *)rb_imemo_new(imemo_ast, 0, 0, 0, nb);
 504     return ast;
 505 }
 506
 507 static VALUE
 508 static_id2sym(ID id)
 509 {
 510     return (((VALUE)(id)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG);
 511 }
 512
 513 static long
 514 str_coderange_scan_restartable(const char *s, const char *e, void *enc, int *cr)
 515 {
 516     return rb_str_coderange_scan_restartable(s, e, (rb_encoding *)enc, cr);
 517 }
 518
 519 VALUE rb_io_gets_internal(VALUE io);
 520 extern VALUE rb_mRubyVMFrozenCore;
 521 VALUE rb_node_case_when_optimizable_literal(const NODE *const node);
 522
 523 void
 524 rb_parser_config_initialize(rb_parser_config_t *config)
 525 {
 526     config->counter = 0;
 527
 528     config->malloc   = ruby_xmalloc;
 529     config->calloc   = ruby_xcalloc;
 530     config->realloc  = ruby_xrealloc;
 531     config->free     = ruby_xfree;
 532     config->alloc_n  = ruby_xmalloc2;
 533     config->alloc    = ruby_xmalloc;
 534     config->realloc_n = ruby_xrealloc2;
 535     config->zalloc = zalloc;
 536     config->rb_memmove = memmove2;
 537     config->nonempty_memcpy = nonempty_memcpy;
 538     config->xmalloc_mul_add = rb_xmalloc_mul_add;
 539
 540     config->tmpbuf_parser_heap = tmpbuf_parser_heap;
 541     config->ast_new = ast_new;
 542
 543     config->compile_callback         = rb_suppress_tracing;
 544     config->reg_named_capture_assign = reg_named_capture_assign;
 545
 546     config->obj_freeze = rb_obj_freeze;
 547     config->obj_hide = rb_obj_hide;
 548     config->obj_frozen = obj_frozen;
 549     config->type_p = type_p;
 550     config->obj_freeze_raw = OBJ_FREEZE_RAW;
 551
 552     config->fixnum_p = fixnum_p;
 553     config->symbol_p = symbol_p;
 554
 555     config->attr_get = rb_attr_get;
 556
 557     config->ary_new           = rb_ary_new;
 558     config->ary_push          = rb_ary_push;
 559     config->ary_new_from_args = rb_ary_new_from_args;
 560     config->ary_pop           = rb_ary_pop;
 561     config->ary_last          = rb_ary_last;
 562     config->ary_unshift       = rb_ary_unshift;
 563     config->ary_new2          = rb_ary_new2;
 564     config->ary_entry         = rb_ary_entry;
 565     config->ary_join          = rb_ary_join;
 566     config->ary_reverse       = rb_ary_reverse;
 567     config->ary_clear         = rb_ary_clear;
 568     config->array_len         = rb_array_len;
 569     config->array_aref        = RARRAY_AREF;
 570
 571     config->sym_intern_ascii_cstr = rb_sym_intern_ascii_cstr;
 572     config->make_temporary_id     = rb_make_temporary_id;
 573     config->is_local_id           = is_local_id2;
 574     config->is_attrset_id         = is_attrset_id2;
 575     config->is_global_name_punct  = is_global_name_punct;
 576     config->id_type               = id_type;
 577     config->id_attrset            = rb_id_attrset;
 578     config->intern                = rb_intern;
 579     config->intern2               = rb_intern2;
 580     config->intern3               = intern3;
 581     config->intern_str            = rb_intern_str;
 582     config->is_notop_id           = is_notop_id2;
 583     config->enc_symname_type      = enc_symname_type;
 584     config->str_intern            = rb_str_intern;
 585     config->id2name               = rb_id2name;
 586     config->id2str                = rb_id2str;
 587     config->id2sym                = rb_id2sym;
 588     config->sym2id                = rb_sym2id;
 589
 590     config->str_catf        = rb_str_catf;
 591     config->str_cat_cstr    = rb_str_cat_cstr;
 592     config->str_subseq      = rb_str_subseq;
 593     config->str_dup         = rb_str_dup;
 594     config->str_new_frozen  = rb_str_new_frozen;
 595     config->str_buf_new     = rb_str_buf_new;
 596     config->str_buf_cat     = rb_str_buf_cat;
 597     config->str_modify      = rb_str_modify;
 598     config->str_set_len     = rb_str_set_len;
 599     config->str_cat         = rb_str_cat;
 600     config->str_resize      = rb_str_resize;
 601     config->str_new         = rb_str_new;
 602     config->str_new_cstr    = rb_str_new_cstr;
 603     config->fstring         = rb_fstring;
 604     config->is_ascii_string = is_ascii_string2;
 605     config->enc_str_new     = enc_str_new;
 606     config->enc_str_buf_cat = enc_str_buf_cat;
 607     config->str_buf_append  = rb_str_buf_append;
 608     config->str_vcatf       = rb_str_vcatf;
 609     config->string_value_cstr = rb_string_value_cstr;
 610     config->rb_sprintf      = rb_sprintf;
 611     config->rstring_ptr     = RSTRING_PTR;
 612     config->rstring_end     = RSTRING_END;
 613     config->rstring_len     = RSTRING_LEN;
 614     config->filesystem_str_new_cstr = rb_filesystem_str_new_cstr;
 615     config->obj_as_string = rb_obj_as_string;
 616
 617     config->hash_clear     = rb_hash_clear;
 618     config->hash_new       = rb_hash_new;
 619     config->hash_aset      = rb_hash_aset;
 620     config->hash_lookup    = rb_hash_lookup;
 621     config->hash_delete    = rb_hash_delete;
 622     config->ident_hash_new = rb_ident_hash_new;
 623
 624     config->int2fix = int2fix;
 625
 626     config->bignum_negate = bignum_negate;
 627     config->big_norm      = rb_big_norm;
 628     config->cstr_to_inum  = rb_cstr_to_inum;
 629
 630     config->float_new   = rb_float_new;
 631     config->float_value = rb_float_value;
 632
 633     config->num2int          = rb_num2int_inline;
 634     config->int_positive_pow = rb_int_positive_pow;
 635     config->int2num          = rb_int2num_inline;
 636     config->fix2long         = rb_fix2long;
 637
 638     config->rational_new     = rb_rational_new;
 639     config->rational_raw1    = rational_raw1;
 640     config->rational_set_num = rational_set_num;
 641     config->rational_get_num = rational_get_num;
 642
 643     config->complex_raw       = rb_complex_raw;
 644     config->rcomplex_set_real = rcomplex_set_real;
 645     config->rcomplex_set_imag = rcomplex_set_imag;
 646     config->rcomplex_get_real = rcomplex_get_real;
 647     config->rcomplex_get_imag = rcomplex_get_imag;
 648
 649     config->stderr_tty_p    = rb_stderr_tty_p;
 650     config->write_error_str = rb_write_error_str;
 651     config->default_rs = default_rs;
 652     config->io_write = rb_io_write;
 653     config->io_flush = rb_io_flush;
 654     config->io_puts = rb_io_puts;
 655     config->io_gets_internal= rb_io_gets_internal;
 656
 657     config->debug_output_stdout = rb_ractor_stdout;
 658     config->debug_output_stderr = rb_ractor_stderr;
 659
 660     config->is_usascii_enc        = is_usascii_enc;
 661     config->enc_isalnum           = enc_isalnum;
 662     config->enc_precise_mbclen    = enc_precise_mbclen;
 663     config->mbclen_charfound_p    = mbclen_charfound_p;
 664     config->enc_name              = enc_name;
 665     config->enc_prev_char         = enc_prev_char;
 666     config->enc_get               = enc_get;
 667     config->enc_asciicompat       = enc_asciicompat;
 668     config->utf8_encoding         = utf8_encoding;
 669     config->enc_associate         = enc_associate;
 670     config->ascii8bit_encoding    = ascii8bit_encoding;
 671     config->enc_codelen           = enc_codelen;
 672     config->enc_mbcput            = enc_mbcput;
 673     config->char_to_option_kcode  = rb_char_to_option_kcode;
 674     config->ascii8bit_encindex    = rb_ascii8bit_encindex;
 675     config->enc_find_index        = rb_enc_find_index;
 676     config->enc_from_index        = enc_from_index;
 677     config->enc_associate_index   = rb_enc_associate_index;
 678     config->enc_isspace           = enc_isspace;
 679     config->enc_coderange_7bit    = ENC_CODERANGE_7BIT;
 680     config->enc_coderange_unknown = ENC_CODERANGE_UNKNOWN;
 681     config->enc_compatible        = enc_compatible;
 682     config->enc_from_encoding     = enc_from_encoding;
 683     config->encoding_get          = encoding_get;
 684     config->encoding_set          = encoding_set;
 685     config->encoding_is_ascii8bit = encoding_is_ascii8bit;
 686     config->usascii_encoding      = usascii_encoding;
 687
 688     config->ractor_make_shareable = rb_ractor_make_shareable;
 689
 690     config->local_defined        = local_defined;
 691     config->dvar_defined         = dvar_defined;
 692
 693     config->literal_cmp  = literal_cmp;
 694     config->literal_hash = literal_hash;
 695
 696     config->builtin_class_name = rb_builtin_class_name;
 697     config->syntax_error_append = syntax_error_append;
 698     config->raise = rb_raise;
 699     config->syntax_error_new = syntax_error_new;
 700
 701     config->errinfo = rb_errinfo;
 702     config->set_errinfo = rb_set_errinfo;
 703     config->exc_raise = rb_exc_raise;
 704     config->make_exception = rb_make_exception;
 705
 706     config->sized_xfree = ruby_sized_xfree;
 707     config->sized_realloc_n = ruby_sized_realloc_n;
 708     config->obj_write = obj_write;
 709     config->obj_written = obj_written;
 710     config->gc_register_mark_object = rb_gc_register_mark_object;
 711     config->gc_guard = gc_guard;
 712     config->gc_mark = rb_gc_mark;
 713     config->gc_mark_movable = rb_gc_mark_movable;
 714     config->gc_location = rb_gc_location;
 715
 716     config->reg_compile = rb_reg_compile;
 717     config->reg_check_preprocess = rb_reg_check_preprocess;
 718     config->memcicmp = rb_memcicmp;
 719
 720     config->compile_warn    = rb_compile_warn;
 721     config->compile_warning = rb_compile_warning;
 722     config->bug             = rb_bug;
 723     config->fatal           = rb_fatal;
 724     config->verbose         = ruby_verbose2;
 725
 726     config->make_backtrace = rb_make_backtrace;
 727
 728     config->scan_hex    = ruby_scan_hex;
 729     config->scan_oct    = ruby_scan_oct;
 730     config->scan_digits = ruby_scan_digits;
 731     config->strtod      = ruby_strtod;
 732
 733     config->rbool = rbool;
 734     config->undef_p = undef_p;
 735     config->rtest = rtest;
 736     config->nil_p = nil_p;
 737     config->flonum_p = flonum_p;
 738     config->qnil  = Qnil;
 739     config->qtrue = Qtrue;
 740     config->qfalse = Qfalse;
 741     config->qundef = Qundef;
 742     config->eArgError = rb_eArgError;
 743     config->mRubyVMFrozenCore = rb_mRubyVMFrozenCore;
 744     config->long2int = rb_long2int;
 745     config->special_const_p = special_const_p;
 746     config->builtin_type = builtin_type;
 747
 748     config->node_case_when_optimizable_literal = rb_node_case_when_optimizable_literal;
 749
 750     /* For Ripper */
 751     config->static_id2sym = static_id2sym;
 752     config->str_coderange_scan_restartable = str_coderange_scan_restartable;
 753 }
 754
 755 VALUE
 756 rb_parser_new(void)
 757 {
 758     struct ruby_parser *parser;
 759     rb_parser_config_t *config;
 760     rb_parser_t *parser_params;
 761
 762     config = rb_ruby_parser_config_new(ruby_xmalloc);
 763     rb_parser_config_initialize(config);
 764
 765     /*
 766      * Create parser_params ahead of vparser because
 767      * rb_ruby_parser_new can run GC so if create vparser
 768      * first, parser_mark tries to mark not initialized parser_params.
 769      */
 770     parser_params = rb_ruby_parser_new(config);
 771     VALUE vparser = TypedData_Make_Struct(0, struct ruby_parser,
 772                                          &ruby_parser_data_type, parser);
 773     parser->parser_params = parser_params;
 774
 775     return vparser;
 776 }
 777
 778 void
 779 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
 780 {
 781     struct ruby_parser *parser;
 782
 783     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 784     rb_ruby_parser_set_options(parser->parser_params, print, loop, chomp, split);
 785 }
 786
 787 VALUE
 788 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
 789 {
 790     struct ruby_parser *parser;
 791
 792     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 793     rb_ruby_parser_set_context(parser->parser_params, base, main);
 794     return vparser;
 795 }
 796
 797 void
 798 rb_parser_set_script_lines(VALUE vparser, VALUE lines)
 799 {
 800     struct ruby_parser *parser;
 801
 802     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 803     rb_ruby_parser_set_script_lines(parser->parser_params, lines);
 804 }
 805
 806 void
 807 rb_parser_error_tolerant(VALUE vparser)
 808 {
 809     struct ruby_parser *parser;
 810
 811     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 812     rb_ruby_parser_error_tolerant(parser->parser_params);
 813 }
 814
 815 rb_ast_t*
 816 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
 817 {
 818     struct ruby_parser *parser;
 819     rb_ast_t *ast;
 820
 821     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 822     ast = rb_ruby_parser_compile_file_path(parser->parser_params, fname, file, start);
 823     RB_GC_GUARD(vparser);
 824
 825     return ast;
 826 }
 827
 828 void
 829 rb_parser_keep_tokens(VALUE vparser)
 830 {
 831     struct ruby_parser *parser;
 832
 833     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 834     rb_ruby_parser_keep_tokens(parser->parser_params);
 835 }
 836
 837 rb_ast_t*
 838 rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
 839 {
 840     struct ruby_parser *parser;
 841     rb_ast_t *ast;
 842
 843     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 844     ast = rb_ruby_parser_compile_generic(parser->parser_params, lex_gets, fname, input, start);
 845     RB_GC_GUARD(vparser);
 846
 847     return ast;
 848 }
 849
 850 rb_ast_t*
 851 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
 852 {
 853     struct ruby_parser *parser;
 854     rb_ast_t *ast;
 855
 856     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 857     ast = rb_ruby_parser_compile_string(parser->parser_params, f, s, line);
 858     RB_GC_GUARD(vparser);
 859
 860     return ast;
 861 }
 862
 863 rb_ast_t*
 864 rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
 865 {
 866     struct ruby_parser *parser;
 867     rb_ast_t *ast;
 868
 869     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 870     ast = rb_ruby_parser_compile_string_path(parser->parser_params, f, s, line);
 871     RB_GC_GUARD(vparser);
 872
 873     return ast;
 874 }
 875
 876 VALUE
 877 rb_parser_encoding(VALUE vparser)
 878 {
 879     struct ruby_parser *parser;
 880
 881     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 882     return rb_ruby_parser_encoding(parser->parser_params);
 883 }
 884
 885 VALUE
 886 rb_parser_end_seen_p(VALUE vparser)
 887 {
 888     struct ruby_parser *parser;
 889
 890     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 891     return RBOOL(rb_ruby_parser_end_seen_p(parser->parser_params));
 892 }
 893
 894 VALUE
 895 rb_parser_set_yydebug(VALUE vparser, VALUE flag)
 896 {
 897     struct ruby_parser *parser;
 898
 899     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 900     rb_ruby_parser_set_yydebug(parser->parser_params, RTEST(flag));
 901     return flag;
 902 }
 903
 904 #else
 905
 906 /* For "ISO C requires a translation unit to contain at least one declaration" */
 907 void
 908 rb_parser_dummy(void)
 909 {}
 910 #endif