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_modify = rb_ary_modify,
 439     .array_len = rb_array_len,
 440     .array_aref = RARRAY_AREF,
 441
 442     .make_temporary_id = rb_make_temporary_id,
 443     .is_local_id = is_local_id2,
 444     .is_attrset_id = is_attrset_id2,
 445     .is_global_name_punct = is_global_name_punct,
 446     .id_type = id_type,
 447     .id_attrset = rb_id_attrset,
 448     .intern = rb_intern,
 449     .intern2 = rb_intern2,
 450     .intern3 = intern3,
 451     .intern_str = rb_intern_str,
 452     .is_notop_id = is_notop_id2,
 453     .enc_symname_type = enc_symname_type,
 454     .id2name = rb_id2name,
 455     .id2str = rb_id2str,
 456     .id2sym = rb_id2sym,
 457     .sym2id = rb_sym2id,
 458
 459     .str_catf = rb_str_catf,
 460     .str_cat_cstr = rb_str_cat_cstr,
 461     .str_subseq = rb_str_subseq,
 462     .str_new_frozen = rb_str_new_frozen,
 463     .str_buf_new = rb_str_buf_new,
 464     .str_buf_cat = rb_str_buf_cat,
 465     .str_modify = rb_str_modify,
 466     .str_set_len = rb_str_set_len,
 467     .str_cat = rb_str_cat,
 468     .str_resize = rb_str_resize,
 469     .str_new = rb_str_new,
 470     .str_new_cstr = rb_str_new_cstr,
 471     .str_to_interned_str = rb_str_to_interned_str,
 472     .is_ascii_string = is_ascii_string2,
 473     .enc_str_new = enc_str_new,
 474     .enc_str_buf_cat = enc_str_buf_cat,
 475     .str_buf_append = rb_str_buf_append,
 476     .str_vcatf = rb_str_vcatf,
 477     .string_value_cstr = rb_string_value_cstr,
 478     .rb_sprintf = rb_sprintf,
 479     .rstring_ptr = RSTRING_PTR,
 480     .rstring_end = RSTRING_END,
 481     .rstring_len = RSTRING_LEN,
 482     .filesystem_str_new_cstr = rb_filesystem_str_new_cstr,
 483     .obj_as_string = rb_obj_as_string,
 484
 485     .int2num = rb_int2num_inline,
 486
 487     .stderr_tty_p = rb_stderr_tty_p,
 488     .write_error_str = rb_write_error_str,
 489     .default_rs = default_rs,
 490     .io_write = rb_io_write,
 491     .io_flush = rb_io_flush,
 492     .io_puts = rb_io_puts,
 493     .io_gets_internal = rb_io_gets_internal,
 494
 495     .debug_output_stdout = rb_ractor_stdout,
 496     .debug_output_stderr = rb_ractor_stderr,
 497
 498     .is_usascii_enc = is_usascii_enc,
 499     .enc_isalnum = enc_isalnum,
 500     .enc_precise_mbclen = enc_precise_mbclen,
 501     .mbclen_charfound_p = mbclen_charfound_p,
 502     .mbclen_charfound_len = mbclen_charfound_len,
 503     .enc_name = enc_name,
 504     .enc_prev_char = enc_prev_char,
 505     .enc_get = enc_get,
 506     .enc_asciicompat = enc_asciicompat,
 507     .utf8_encoding = utf8_encoding,
 508     .enc_associate = enc_associate,
 509     .ascii8bit_encoding = ascii8bit_encoding,
 510     .enc_codelen = enc_codelen,
 511     .enc_mbcput = enc_mbcput,
 512     .enc_find_index = rb_enc_find_index,
 513     .enc_from_index = enc_from_index,
 514     .enc_associate_index = rb_enc_associate_index,
 515     .enc_isspace = enc_isspace,
 516     .enc_coderange_7bit = ENC_CODERANGE_7BIT,
 517     .enc_coderange_unknown = ENC_CODERANGE_UNKNOWN,
 518     .enc_compatible = enc_compatible,
 519     .enc_from_encoding = enc_from_encoding,
 520     .encoding_is_ascii8bit = encoding_is_ascii8bit,
 521     .usascii_encoding = usascii_encoding,
 522     .enc_coderange_broken = ENC_CODERANGE_BROKEN,
 523     .enc_mbminlen = enc_mbminlen,
 524     .enc_isascii = enc_isascii,
 525     .enc_mbc_to_codepoint = enc_mbc_to_codepoint,
 526
 527     .local_defined = local_defined,
 528     .dvar_defined = dvar_defined,
 529
 530     .syntax_error_append = syntax_error_append,
 531     .raise = rb_raise,
 532     .syntax_error_new = syntax_error_new,
 533
 534     .errinfo = rb_errinfo,
 535     .set_errinfo = rb_set_errinfo,
 536     .exc_raise = rb_exc_raise,
 537     .make_exception = rb_make_exception,
 538
 539     .sized_xfree = ruby_sized_xfree,
 540     .sized_realloc_n = ruby_sized_realloc_n,
 541     .obj_write = obj_write,
 542     .gc_guard = gc_guard,
 543     .gc_mark = rb_gc_mark,
 544     .gc_mark_and_move = rb_gc_mark_and_move,
 545
 546     .reg_compile = rb_reg_compile,
 547     .reg_check_preprocess = rb_reg_check_preprocess,
 548     .memcicmp = rb_memcicmp,
 549
 550     .compile_warn = rb_compile_warn,
 551     .compile_warning = rb_compile_warning,
 552     .bug = rb_bug,
 553     .fatal = rb_fatal,
 554     .verbose = ruby_verbose2,
 555     .errno_ptr = rb_errno_ptr2,
 556
 557     .make_backtrace = rb_make_backtrace,
 558
 559     .scan_hex = ruby_scan_hex,
 560     .scan_oct = ruby_scan_oct,
 561     .scan_digits = ruby_scan_digits,
 562     .strtod = ruby_strtod,
 563
 564     .rbool = rbool,
 565     .rtest = rtest,
 566     .nil_p = nil_p,
 567     .qnil = Qnil,
 568     .qtrue = Qtrue,
 569     .qfalse = Qfalse,
 570     .eArgError = arg_error,
 571     .long2int = rb_long2int,
 572
 573     /* For Ripper */
 574     .static_id2sym = static_id2sym,
 575     .str_coderange_scan_restartable = str_coderange_scan_restartable,
 576 };
 577
 578 const rb_parser_config_t *
 579 rb_ruby_parser_config(void)
 580 {
 581     return &rb_global_parser_config;
 582 }
 583
 584 rb_parser_t *
 585 rb_parser_params_allocate(void)
 586 {
 587     return rb_ruby_parser_allocate(&rb_global_parser_config);
 588 }
 589
 590 rb_parser_t *
 591 rb_parser_params_new(void)
 592 {
 593     return rb_ruby_parser_new(&rb_global_parser_config);
 594 }
 595
 596 VALUE
 597 rb_parser_new(void)
 598 {
 599     struct ruby_parser *parser;
 600     rb_parser_t *parser_params;
 601
 602     /*
 603      * Create parser_params ahead of vparser because
 604      * rb_ruby_parser_new can run GC so if create vparser
 605      * first, parser_mark tries to mark not initialized parser_params.
 606      */
 607     parser_params = rb_parser_params_new();
 608     VALUE vparser = TypedData_Make_Struct(0, struct ruby_parser,
 609                                          &ruby_parser_data_type, parser);
 610     parser->parser_params = parser_params;
 611
 612     return vparser;
 613 }
 614
 615 void
 616 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
 617 {
 618     struct ruby_parser *parser;
 619
 620     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 621     rb_ruby_parser_set_options(parser->parser_params, print, loop, chomp, split);
 622 }
 623
 624 VALUE
 625 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
 626 {
 627     struct ruby_parser *parser;
 628
 629     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 630     rb_ruby_parser_set_context(parser->parser_params, base, main);
 631     return vparser;
 632 }
 633
 634 void
 635 rb_parser_set_script_lines(VALUE vparser, VALUE lines)
 636 {
 637     struct ruby_parser *parser;
 638
 639     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 640     rb_ruby_parser_set_script_lines(parser->parser_params, lines);
 641 }
 642
 643 void
 644 rb_parser_error_tolerant(VALUE vparser)
 645 {
 646     struct ruby_parser *parser;
 647
 648     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 649     rb_ruby_parser_error_tolerant(parser->parser_params);
 650 }
 651
 652 rb_ast_t*
 653 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
 654 {
 655     struct ruby_parser *parser;
 656     rb_ast_t *ast;
 657
 658     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 659     ast = rb_ruby_parser_compile_file_path(parser->parser_params, fname, file, start);
 660     RB_GC_GUARD(vparser);
 661
 662     return ast;
 663 }
 664
 665 void
 666 rb_parser_keep_tokens(VALUE vparser)
 667 {
 668     struct ruby_parser *parser;
 669
 670     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 671     rb_ruby_parser_keep_tokens(parser->parser_params);
 672 }
 673
 674 rb_ast_t*
 675 rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
 676 {
 677     struct ruby_parser *parser;
 678     rb_ast_t *ast;
 679
 680     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 681     ast = rb_ruby_parser_compile_generic(parser->parser_params, lex_gets, fname, input, start);
 682     RB_GC_GUARD(vparser);
 683
 684     return ast;
 685 }
 686
 687 rb_ast_t*
 688 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
 689 {
 690     struct ruby_parser *parser;
 691     rb_ast_t *ast;
 692
 693     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 694     ast = rb_ruby_parser_compile_string(parser->parser_params, f, s, line);
 695     RB_GC_GUARD(vparser);
 696
 697     return ast;
 698 }
 699
 700 rb_ast_t*
 701 rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
 702 {
 703     struct ruby_parser *parser;
 704     rb_ast_t *ast;
 705
 706     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 707     ast = rb_ruby_parser_compile_string_path(parser->parser_params, f, s, line);
 708     RB_GC_GUARD(vparser);
 709
 710     return ast;
 711 }
 712
 713 VALUE
 714 rb_parser_encoding(VALUE vparser)
 715 {
 716     struct ruby_parser *parser;
 717
 718     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 719     return rb_ruby_parser_encoding(parser->parser_params);
 720 }
 721
 722 VALUE
 723 rb_parser_end_seen_p(VALUE vparser)
 724 {
 725     struct ruby_parser *parser;
 726
 727     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 728     return RBOOL(rb_ruby_parser_end_seen_p(parser->parser_params));
 729 }
 730
 731 VALUE
 732 rb_parser_set_yydebug(VALUE vparser, VALUE flag)
 733 {
 734     struct ruby_parser *parser;
 735
 736     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
 737     rb_ruby_parser_set_yydebug(parser->parser_params, RTEST(flag));
 738     return flag;
 739 }
 740 #endif
 741
 742 VALUE
 743 rb_str_new_parser_string(rb_parser_string_t *str)
 744 {
 745     VALUE string = rb_enc_interned_str(str->ptr, str->len, str->enc);
 746     rb_enc_str_coderange(string);
 747     return string;
 748 }
 749
 750 VALUE
 751 rb_str_new_mutable_parser_string(rb_parser_string_t *str)
 752 {
 753     return rb_enc_str_new(str->ptr, str->len, str->enc);
 754 }
 755
 756 static VALUE
 757 negative_numeric(VALUE val)
 758 {
 759     if (FIXNUM_P(val)) {
 760         return LONG2FIX(-FIX2LONG(val));
 761     }
 762     if (SPECIAL_CONST_P(val)) {
 763 #if USE_FLONUM
 764         if (FLONUM_P(val)) {
 765             return DBL2NUM(-RFLOAT_VALUE(val));
 766         }
 767 #endif
 768         goto unknown;
 769     }
 770     switch (BUILTIN_TYPE(val)) {
 771       case T_BIGNUM:
 772         BIGNUM_NEGATE(val);
 773         val = rb_big_norm(val);
 774         break;
 775       case T_RATIONAL:
 776         RATIONAL_SET_NUM(val, negative_numeric(RRATIONAL(val)->num));
 777         break;
 778       case T_COMPLEX:
 779         RCOMPLEX_SET_REAL(val, negative_numeric(RCOMPLEX(val)->real));
 780         RCOMPLEX_SET_IMAG(val, negative_numeric(RCOMPLEX(val)->imag));
 781         break;
 782       case T_FLOAT:
 783         val = DBL2NUM(-RFLOAT_VALUE(val));
 784         break;
 785       unknown:
 786       default:
 787         rb_bug("unknown literal type (%s) passed to negative_numeric",
 788                rb_builtin_class_name(val));
 789         break;
 790     }
 791     return val;
 792 }
 793
 794 static VALUE
 795 integer_value(const char *val, int base)
 796 {
 797     return rb_cstr_to_inum(val, base, FALSE);
 798 }
 799
 800 static VALUE
 801 rational_value(const char *node_val, int base, int seen_point)
 802 {
 803     VALUE lit;
 804     char* val = strdup(node_val);
 805     if (seen_point > 0) {
 806         int len = (int)(strlen(val));
 807         char *point = &val[seen_point];
 808         size_t fraclen = len-seen_point-1;
 809         memmove(point, point+1, fraclen+1);
 810
 811         lit = rb_rational_new(integer_value(val, base), rb_int_positive_pow(10, fraclen));
 812     }
 813     else {
 814         lit = rb_rational_raw1(integer_value(val, base));
 815     }
 816
 817     free(val);
 818
 819     return lit;
 820 }
 821
 822 VALUE
 823 rb_node_integer_literal_val(const NODE *n)
 824 {
 825     const rb_node_integer_t *node = RNODE_INTEGER(n);
 826     VALUE val = integer_value(node->val, node->base);
 827     if (node->minus) {
 828         val = negative_numeric(val);
 829     }
 830     return val;
 831 }
 832
 833 VALUE
 834 rb_node_float_literal_val(const NODE *n)
 835 {
 836     const rb_node_float_t *node = RNODE_FLOAT(n);
 837     double d = strtod(node->val, 0);
 838     if (node->minus) {
 839         d = -d;
 840     }
 841     VALUE val = DBL2NUM(d);
 842     return val;
 843 }
 844
 845 VALUE
 846 rb_node_rational_literal_val(const NODE *n)
 847 {
 848     VALUE lit;
 849     const rb_node_rational_t *node = RNODE_RATIONAL(n);
 850
 851     lit = rational_value(node->val, node->base, node->seen_point);
 852
 853     if (node->minus) {
 854         lit = negative_numeric(lit);
 855     }
 856
 857     return lit;
 858 }
 859
 860 VALUE
 861 rb_node_imaginary_literal_val(const NODE *n)
 862 {
 863     VALUE lit;
 864     const rb_node_imaginary_t *node = RNODE_IMAGINARY(n);
 865
 866     enum rb_numeric_type type = node->type;
 867
 868     switch (type) {
 869       case integer_literal:
 870         lit = integer_value(node->val, node->base);
 871         break;
 872       case float_literal:{
 873         double d = strtod(node->val, 0);
 874         lit = DBL2NUM(d);
 875         break;
 876       }
 877       case rational_literal:
 878         lit = rational_value(node->val, node->base, node->seen_point);
 879         break;
 880       default:
 881         rb_bug("unreachable");
 882     }
 883
 884     lit = rb_complex_raw(INT2FIX(0), lit);
 885
 886     if (node->minus) {
 887         lit = negative_numeric(lit);
 888     }
 889     return lit;
 890 }
 891
 892 VALUE
 893 rb_node_str_string_val(const NODE *node)
 894 {
 895     rb_parser_string_t *str = RNODE_STR(node)->string;
 896     return rb_str_new_parser_string(str);
 897 }
 898
 899 VALUE
 900 rb_node_sym_string_val(const NODE *node)
 901 {
 902     rb_parser_string_t *str = RNODE_SYM(node)->string;
 903     return ID2SYM(rb_intern3(str->ptr, str->len, str->enc));
 904 }
 905
 906 VALUE
 907 rb_node_dstr_string_val(const NODE *node)
 908 {
 909     rb_parser_string_t *str = RNODE_DSTR(node)->string;
 910     return str ? rb_str_new_parser_string(str) : Qnil;
 911 }
 912
 913 VALUE
 914 rb_node_dregx_string_val(const NODE *node)
 915 {
 916     rb_parser_string_t *str = RNODE_DREGX(node)->string;
 917     return rb_str_new_parser_string(str);
 918 }
 919
 920 VALUE
 921 rb_node_regx_string_val(const NODE *node)
 922 {
 923     rb_node_regx_t *node_reg = RNODE_REGX(node);
 924     rb_parser_string_t *string = node_reg->string;
 925     VALUE str = rb_enc_str_new(string->ptr, string->len, string->enc);
 926
 927     return rb_reg_compile(str, node_reg->options, NULL, 0);
 928 }
 929
 930 VALUE
 931 rb_node_line_lineno_val(const NODE *node)
 932 {
 933     return INT2FIX(node->nd_loc.beg_pos.lineno);
 934 }
 935
 936 VALUE
 937 rb_node_file_path_val(const NODE *node)
 938 {
 939     return rb_str_new_parser_string(RNODE_FILE(node)->path);
 940 }
 941
 942 VALUE
 943 rb_node_encoding_val(const NODE *node)
 944 {
 945     return rb_enc_from_encoding(RNODE_ENCODING(node)->enc);
 946 }
 947
 948 VALUE
 949 rb_script_lines_for(VALUE path)
 950 {
 951     VALUE hash, lines;
 952     ID script_lines;
 953     CONST_ID(script_lines, "SCRIPT_LINES__");
 954     if (!rb_const_defined_at(rb_cObject, script_lines)) return Qnil;
 955     hash = rb_const_get_at(rb_cObject, script_lines);
 956     if (!RB_TYPE_P(hash, T_HASH)) return Qnil;
 957     rb_hash_aset(hash, path, lines = rb_ary_new());
 958     return lines;
 959 }