ruby_parser.c

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