1 /* This is a wrapper for parse.y */
3 #include "internal/parse.h"
4 #include "internal/re.h"
5 #include "internal/ruby_parser.h"
8 #include "rubyparser.h"
9 #include "internal/error.h"
11 #ifdef UNIVERSAL_PARSER
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"
28 #include "ruby/ractor.h"
29 #include "ruby/ruby.h"
30 #include "ruby/util.h"
35 #define parser_encoding const void
38 is_ascii_string2(VALUE str
)
40 return is_ascii_string(str
);
43 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT
, 6, 0)
45 syntax_error_append(VALUE exc
, VALUE file
, int line
, int column
,
46 parser_encoding
*enc
, const char *fmt
, va_list args
)
48 return rb_syntax_error_append(exc
, file
, line
, column
, enc
, fmt
, args
);
52 local_defined(ID id
, const void *p
)
54 return rb_local_defined(id
, (const rb_iseq_t
*)p
);
58 dvar_defined(ID id
, const void *p
)
60 return rb_dvar_defined(id
, (const rb_iseq_t
*)p
);
64 is_usascii_enc(parser_encoding
*enc
)
66 return rb_is_usascii_enc(enc
);
72 return is_local_id(id
);
78 return is_attrset_id(id
);
84 return is_notop_id(id
);
88 enc_str_new(const char *ptr
, long len
, parser_encoding
*enc
)
90 return rb_enc_str_new(ptr
, len
, enc
);
94 enc_isalnum(OnigCodePoint c
, parser_encoding
*enc
)
96 return rb_enc_isalnum(c
, enc
);
100 enc_precise_mbclen(const char *p
, const char *e
, parser_encoding
*enc
)
102 return rb_enc_precise_mbclen(p
, e
, enc
);
106 mbclen_charfound_p(int len
)
108 return MBCLEN_CHARFOUND_P(len
);
112 mbclen_charfound_len(int len
)
114 return MBCLEN_CHARFOUND_LEN(len
);
118 enc_name(parser_encoding
*enc
)
120 return rb_enc_name(enc
);
124 enc_prev_char(const char *s
, const char *p
, const char *e
, parser_encoding
*enc
)
126 return rb_enc_prev_char(s
, p
, e
, enc
);
129 static parser_encoding
*
132 return rb_enc_get(obj
);
136 enc_asciicompat(parser_encoding
*enc
)
138 return rb_enc_asciicompat(enc
);
141 static parser_encoding
*
144 return rb_utf8_encoding();
148 enc_associate(VALUE obj
, parser_encoding
*enc
)
150 return rb_enc_associate(obj
, enc
);
153 static parser_encoding
*
154 ascii8bit_encoding(void)
156 return rb_ascii8bit_encoding();
160 enc_codelen(int c
, parser_encoding
*enc
)
162 return rb_enc_codelen(c
, enc
);
166 enc_mbcput(unsigned int c
, void *buf
, parser_encoding
*enc
)
168 return rb_enc_mbcput(c
, buf
, enc
);
171 static parser_encoding
*
172 enc_from_index(int idx
)
174 return rb_enc_from_index(idx
);
178 enc_isspace(OnigCodePoint c
, parser_encoding
*enc
)
180 return rb_enc_isspace(c
, enc
);
184 intern3(const char *name
, long len
, parser_encoding
*enc
)
186 return rb_intern3(name
, len
, enc
);
189 static parser_encoding
*
190 usascii_encoding(void)
192 return rb_usascii_encoding();
196 enc_symname_type(const char *name
, long len
, parser_encoding
*enc
, unsigned int allowed_attrset
)
198 return rb_enc_symname_type(name
, len
, enc
, allowed_attrset
);
202 struct parser_params
*parser
;
205 const rb_code_location_t
*loc
;
206 } reg_named_capture_assign_t
;
209 reg_named_capture_assign_iter(const OnigUChar
*name
, const OnigUChar
*name_end
,
210 int back_num
, int *back_refs
, OnigRegex regex
, void *arg0
)
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
;
219 return rb_reg_named_capture_assign_iter_impl(p
, s
, len
, enc
, &arg
->succ_block
, loc
);
223 reg_named_capture_assign(struct parser_params
* p
, VALUE regexp
, const rb_code_location_t
*loc
)
225 reg_named_capture_assign_t arg
;
228 arg
.enc
= rb_enc_get(regexp
);
231 onig_foreach_name(RREGEXP_PTR(regexp
), reg_named_capture_assign_iter
, &arg
);
233 if (!arg
.succ_block
) return 0;
234 return RNODE_BLOCK(arg
.succ_block
)->nd_next
;
240 return (int)RB_TEST(obj
);
246 return (int)NIL_P(obj
);
250 syntax_error_new(void)
252 return rb_class_new_instance(0, 0, rb_eSyntaxError
);
256 memmove2(void *dest
, const void *src
, size_t t
, size_t n
)
258 return memmove(dest
, src
, rbimpl_size_mul_or_raise(t
, n
));
262 nonempty_memcpy(void *dest
, const void *src
, size_t t
, size_t n
)
264 return ruby_nonempty_memcpy(dest
, src
, rbimpl_size_mul_or_raise(t
, n
));
276 return rb_errno_ptr();
280 zalloc(size_t elemsiz
)
282 return ruby_xcalloc(1, elemsiz
);
300 return (((VALUE
)(id
)<<RUBY_SPECIAL_SHIFT
)|SYMBOL_FLAG
);
304 str_coderange_scan_restartable(const char *s
, const char *e
, parser_encoding
*enc
, int *cr
)
306 return rb_str_coderange_scan_restartable(s
, e
, enc
, cr
);
310 enc_mbminlen(parser_encoding
*enc
)
312 return rb_enc_mbminlen(enc
);
316 enc_isascii(OnigCodePoint c
, parser_encoding
*enc
)
318 return rb_enc_isascii(c
, enc
);
322 enc_mbc_to_codepoint(const char *p
, const char *e
, parser_encoding
*enc
)
324 const OnigUChar
*up
= RBIMPL_CAST((const OnigUChar
*)p
);
325 const OnigUChar
*ue
= RBIMPL_CAST((const OnigUChar
*)e
);
327 return ONIGENC_MBC_TO_CODE((rb_encoding
*)enc
, up
, ue
);
330 extern VALUE rb_eArgError
;
332 static const rb_parser_config_t rb_global_parser_config
= {
333 .malloc
= ruby_xmalloc
,
334 .calloc
= ruby_xcalloc
,
335 .realloc
= ruby_xrealloc
,
337 .alloc_n
= ruby_xmalloc2
,
338 .alloc
= ruby_xmalloc
,
339 .realloc_n
= ruby_xrealloc2
,
341 .rb_memmove
= memmove2
,
342 .nonempty_memcpy
= nonempty_memcpy
,
343 .xmalloc_mul_add
= rb_xmalloc_mul_add
,
345 .compile_callback
= rb_suppress_tracing
,
346 .reg_named_capture_assign
= reg_named_capture_assign
,
348 .attr_get
= rb_attr_get
,
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
,
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
,
360 .id_attrset
= rb_id_attrset
,
362 .intern2
= rb_intern2
,
364 .intern_str
= rb_intern_str
,
365 .is_notop_id
= is_notop_id2
,
366 .enc_symname_type
= enc_symname_type
,
367 .id2name
= rb_id2name
,
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 .rb_sprintf
= rb_sprintf
,
385 .rstring_ptr
= RSTRING_PTR
,
386 .rstring_end
= RSTRING_END
,
387 .rstring_len
= RSTRING_LEN
,
388 .obj_as_string
= rb_obj_as_string
,
390 .int2num
= rb_int2num_inline
,
392 .stderr_tty_p
= rb_stderr_tty_p
,
393 .write_error_str
= rb_write_error_str
,
394 .io_write
= rb_io_write
,
395 .io_flush
= rb_io_flush
,
396 .io_puts
= rb_io_puts
,
398 .debug_output_stdout
= rb_ractor_stdout
,
399 .debug_output_stderr
= rb_ractor_stderr
,
401 .is_usascii_enc
= is_usascii_enc
,
402 .enc_isalnum
= enc_isalnum
,
403 .enc_precise_mbclen
= enc_precise_mbclen
,
404 .mbclen_charfound_p
= mbclen_charfound_p
,
405 .mbclen_charfound_len
= mbclen_charfound_len
,
406 .enc_name
= enc_name
,
407 .enc_prev_char
= enc_prev_char
,
409 .enc_asciicompat
= enc_asciicompat
,
410 .utf8_encoding
= utf8_encoding
,
411 .enc_associate
= enc_associate
,
412 .ascii8bit_encoding
= ascii8bit_encoding
,
413 .enc_codelen
= enc_codelen
,
414 .enc_mbcput
= enc_mbcput
,
415 .enc_find_index
= rb_enc_find_index
,
416 .enc_from_index
= enc_from_index
,
417 .enc_isspace
= enc_isspace
,
418 .enc_coderange_7bit
= ENC_CODERANGE_7BIT
,
419 .enc_coderange_unknown
= ENC_CODERANGE_UNKNOWN
,
420 .usascii_encoding
= usascii_encoding
,
421 .enc_coderange_broken
= ENC_CODERANGE_BROKEN
,
422 .enc_mbminlen
= enc_mbminlen
,
423 .enc_isascii
= enc_isascii
,
424 .enc_mbc_to_codepoint
= enc_mbc_to_codepoint
,
426 .local_defined
= local_defined
,
427 .dvar_defined
= dvar_defined
,
429 .syntax_error_append
= syntax_error_append
,
431 .syntax_error_new
= syntax_error_new
,
433 .errinfo
= rb_errinfo
,
434 .set_errinfo
= rb_set_errinfo
,
435 .exc_raise
= rb_exc_raise
,
436 .make_exception
= rb_make_exception
,
438 .sized_xfree
= ruby_sized_xfree
,
439 .sized_realloc_n
= ruby_sized_realloc_n
,
440 .gc_guard
= gc_guard
,
441 .gc_mark
= rb_gc_mark
,
443 .reg_compile
= rb_reg_compile
,
444 .reg_check_preprocess
= rb_reg_check_preprocess
,
445 .memcicmp
= rb_memcicmp
,
447 .compile_warn
= rb_compile_warn
,
448 .compile_warning
= rb_compile_warning
,
451 .verbose
= ruby_verbose2
,
452 .errno_ptr
= rb_errno_ptr2
,
454 .make_backtrace
= rb_make_backtrace
,
456 .scan_hex
= ruby_scan_hex
,
457 .scan_oct
= ruby_scan_oct
,
458 .scan_digits
= ruby_scan_digits
,
459 .strtod
= ruby_strtod
,
465 .eArgError
= arg_error
,
466 .long2int
= rb_long2int
,
469 .static_id2sym
= static_id2sym
,
470 .str_coderange_scan_restartable
= str_coderange_scan_restartable
,
482 rb_parser_t
*parser_params
;
485 struct lex_pointer_string lex_str
;
496 parser_mark(void *ptr
)
498 struct ruby_parser
*parser
= (struct ruby_parser
*)ptr
;
499 rb_ruby_parser_mark(parser
->parser_params
);
501 switch (parser
->type
) {
503 rb_gc_mark(parser
->data
.lex_str
.str
);
506 rb_gc_mark(parser
->data
.lex_io
.file
);
509 rb_gc_mark(parser
->data
.lex_array
.ary
);
511 case lex_type_generic
:
512 /* noop. Caller of rb_parser_compile_generic should mark the objects. */
518 parser_free(void *ptr
)
520 struct ruby_parser
*parser
= (struct ruby_parser
*)ptr
;
521 rb_ruby_parser_free(parser
->parser_params
);
526 parser_memsize(const void *ptr
)
528 struct ruby_parser
*parser
= (struct ruby_parser
*)ptr
;
529 return rb_ruby_parser_memsize(parser
->parser_params
);
532 static const rb_data_type_t ruby_parser_data_type
= {
539 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
542 #ifdef UNIVERSAL_PARSER
543 const rb_parser_config_t
*
544 rb_ruby_parser_config(void)
546 return &rb_global_parser_config
;
550 rb_parser_params_new(void)
552 return rb_ruby_parser_new(&rb_global_parser_config
);
556 rb_parser_params_new(void)
558 return rb_ruby_parser_new();
560 #endif /* UNIVERSAL_PARSER */
565 struct ruby_parser
*parser
;
566 rb_parser_t
*parser_params
;
569 * Create parser_params ahead of vparser because
570 * rb_ruby_parser_new can run GC so if create vparser
571 * first, parser_mark tries to mark not initialized parser_params.
573 parser_params
= rb_parser_params_new();
574 VALUE vparser
= TypedData_Make_Struct(0, struct ruby_parser
,
575 &ruby_parser_data_type
, parser
);
576 parser
->parser_params
= parser_params
;
582 rb_parser_set_options(VALUE vparser
, int print
, int loop
, int chomp
, int split
)
584 struct ruby_parser
*parser
;
586 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
587 rb_ruby_parser_set_options(parser
->parser_params
, print
, loop
, chomp
, split
);
591 rb_parser_set_context(VALUE vparser
, const struct rb_iseq_struct
*base
, int main
)
593 struct ruby_parser
*parser
;
595 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
596 rb_ruby_parser_set_context(parser
->parser_params
, base
, main
);
601 rb_parser_set_script_lines(VALUE vparser
)
603 struct ruby_parser
*parser
;
605 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
606 rb_ruby_parser_set_script_lines(parser
->parser_params
);
610 rb_parser_error_tolerant(VALUE vparser
)
612 struct ruby_parser
*parser
;
614 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
615 rb_ruby_parser_error_tolerant(parser
->parser_params
);
619 rb_parser_keep_tokens(VALUE vparser
)
621 struct ruby_parser
*parser
;
623 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
624 rb_ruby_parser_keep_tokens(parser
->parser_params
);
628 rb_parser_lex_get_str(struct parser_params
*p
, struct lex_pointer_string
*ptr_str
)
630 char *beg
, *end
, *start
;
632 VALUE s
= ptr_str
->str
;
634 beg
= RSTRING_PTR(s
);
635 len
= RSTRING_LEN(s
);
638 if (len
== ptr_str
->ptr
) return 0;
642 end
= memchr(beg
, '\n', len
);
643 if (end
) len
= ++end
- beg
;
645 return rb_str_to_parser_string(p
, rb_str_subseq(s
, beg
- start
, len
));
648 static rb_parser_string_t
*
649 lex_get_str(struct parser_params
*p
, rb_parser_input_data input
, int line_count
)
651 return rb_parser_lex_get_str(p
, (struct lex_pointer_string
*)input
);
654 static void parser_aset_script_lines_for(VALUE path
, rb_parser_ary_t
*lines
);
657 parser_compile(rb_parser_t
*p
, rb_parser_lex_gets_func
*gets
, VALUE fname
, rb_parser_input_data input
, int line
)
659 rb_ast_t
*ast
= rb_parser_compile(p
, gets
, fname
, input
, line
);
660 parser_aset_script_lines_for(fname
, ast
->body
.script_lines
);
665 parser_compile_string0(struct ruby_parser
*parser
, VALUE fname
, VALUE s
, int line
)
667 VALUE str
= rb_str_new_frozen(s
);
669 parser
->type
= lex_type_str
;
670 parser
->data
.lex_str
.str
= str
;
671 parser
->data
.lex_str
.ptr
= 0;
673 return parser_compile(parser
->parser_params
, lex_get_str
, fname
, (rb_parser_input_data
)&parser
->data
, line
);
677 must_be_ascii_compatible(VALUE s
)
679 rb_encoding
*enc
= rb_enc_get(s
);
680 if (!rb_enc_asciicompat(enc
)) {
681 rb_raise(rb_eArgError
, "invalid source encoding");
687 parser_compile_string_path(struct ruby_parser
*parser
, VALUE f
, VALUE s
, int line
)
689 must_be_ascii_compatible(s
);
690 return parser_compile_string0(parser
, f
, s
, line
);
694 parser_compile_string(struct ruby_parser
*parser
, const char *f
, VALUE s
, int line
)
696 return parser_compile_string_path(parser
, rb_filesystem_str_new_cstr(f
), s
, line
);
699 VALUE
rb_io_gets_internal(VALUE io
);
701 static rb_parser_string_t
*
702 lex_io_gets(struct parser_params
*p
, rb_parser_input_data input
, int line_count
)
704 VALUE io
= (VALUE
)input
;
705 VALUE line
= rb_io_gets_internal(io
);
706 if (NIL_P(line
)) return 0;
707 return rb_str_to_parser_string(p
, line
);
710 static rb_parser_string_t
*
711 lex_gets_array(struct parser_params
*p
, rb_parser_input_data data
, int index
)
713 VALUE array
= (VALUE
)data
;
714 VALUE str
= rb_ary_entry(array
, index
);
717 if (!rb_enc_asciicompat(rb_enc_get(str
))) {
718 rb_raise(rb_eArgError
, "invalid source encoding");
720 return rb_str_to_parser_string(p
, str
);
728 parser_compile_file_path(struct ruby_parser
*parser
, VALUE fname
, VALUE file
, int start
)
730 parser
->type
= lex_type_io
;
731 parser
->data
.lex_io
.file
= file
;
733 return parser_compile(parser
->parser_params
, lex_io_gets
, fname
, (rb_parser_input_data
)file
, start
);
737 parser_compile_array(struct ruby_parser
*parser
, VALUE fname
, VALUE array
, int start
)
739 parser
->type
= lex_type_array
;
740 parser
->data
.lex_array
.ary
= array
;
742 return parser_compile(parser
->parser_params
, lex_gets_array
, fname
, (rb_parser_input_data
)array
, start
);
746 parser_compile_generic(struct ruby_parser
*parser
, rb_parser_lex_gets_func
*lex_gets
, VALUE fname
, VALUE input
, int start
)
748 parser
->type
= lex_type_generic
;
750 return parser_compile(parser
->parser_params
, lex_gets
, fname
, (rb_parser_input_data
)input
, start
);
756 rb_ast_t
*ast
= (rb_ast_t
*)ptr
;
760 static const rb_data_type_t ast_data_type
= {
765 NULL
, // No dsize() because this object does not appear in ObjectSpace.
767 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
773 return TypedData_Wrap_Struct(0, &ast_data_type
, NULL
);
777 rb_parser_compile_file_path(VALUE vparser
, VALUE fname
, VALUE file
, int start
)
779 struct ruby_parser
*parser
;
780 VALUE ast_value
= ast_alloc();
782 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
783 DATA_PTR(ast_value
) = parser_compile_file_path(parser
, fname
, file
, start
);
784 RB_GC_GUARD(vparser
);
790 rb_parser_compile_array(VALUE vparser
, VALUE fname
, VALUE array
, int start
)
792 struct ruby_parser
*parser
;
793 VALUE ast_value
= ast_alloc();
795 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
796 DATA_PTR(ast_value
) = parser_compile_array(parser
, fname
, array
, start
);
797 RB_GC_GUARD(vparser
);
803 rb_parser_compile_generic(VALUE vparser
, rb_parser_lex_gets_func
*lex_gets
, VALUE fname
, VALUE input
, int start
)
805 struct ruby_parser
*parser
;
806 VALUE ast_value
= ast_alloc();
808 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
809 DATA_PTR(ast_value
) = parser_compile_generic(parser
, lex_gets
, fname
, input
, start
);
810 RB_GC_GUARD(vparser
);
816 rb_parser_compile_string(VALUE vparser
, const char *f
, VALUE s
, int line
)
818 struct ruby_parser
*parser
;
819 VALUE ast_value
= ast_alloc();
821 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
822 DATA_PTR(ast_value
) = parser_compile_string(parser
, f
, s
, line
);
823 RB_GC_GUARD(vparser
);
829 rb_parser_compile_string_path(VALUE vparser
, VALUE f
, VALUE s
, int line
)
831 struct ruby_parser
*parser
;
832 VALUE ast_value
= ast_alloc();
834 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
835 DATA_PTR(ast_value
) = parser_compile_string_path(parser
, f
, s
, line
);
836 RB_GC_GUARD(vparser
);
842 rb_parser_encoding(VALUE vparser
)
844 struct ruby_parser
*parser
;
846 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
847 return rb_enc_from_encoding(rb_ruby_parser_encoding(parser
->parser_params
));
851 rb_parser_end_seen_p(VALUE vparser
)
853 struct ruby_parser
*parser
;
855 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
856 return RBOOL(rb_ruby_parser_end_seen_p(parser
->parser_params
));
860 rb_parser_set_yydebug(VALUE vparser
, VALUE flag
)
862 struct ruby_parser
*parser
;
864 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
865 rb_ruby_parser_set_yydebug(parser
->parser_params
, RTEST(flag
));
870 rb_set_script_lines_for(VALUE vparser
, VALUE path
)
872 struct ruby_parser
*parser
;
875 CONST_ID(script_lines
, "SCRIPT_LINES__");
876 if (!rb_const_defined_at(rb_cObject
, script_lines
)) return;
877 hash
= rb_const_get_at(rb_cObject
, script_lines
);
878 if (RB_TYPE_P(hash
, T_HASH
)) {
879 rb_hash_aset(hash
, path
, Qtrue
);
880 TypedData_Get_Struct(vparser
, struct ruby_parser
, &ruby_parser_data_type
, parser
);
881 rb_ruby_parser_set_script_lines(parser
->parser_params
);
886 rb_parser_build_script_lines_from(rb_parser_ary_t
*lines
)
889 if (!lines
) return Qnil
;
890 if (lines
->data_type
!= PARSER_ARY_DATA_SCRIPT_LINE
) {
891 rb_bug("unexpected rb_parser_ary_data_type (%d) for script lines", lines
->data_type
);
893 VALUE script_lines
= rb_ary_new_capa(lines
->len
);
894 for (i
= 0; i
< lines
->len
; i
++) {
895 rb_parser_string_t
*str
= (rb_parser_string_t
*)lines
->data
[i
];
896 rb_ary_push(script_lines
, rb_enc_str_new(str
->ptr
, str
->len
, str
->enc
));
902 rb_str_new_parser_string(rb_parser_string_t
*str
)
904 VALUE string
= rb_enc_literal_str(str
->ptr
, str
->len
, str
->enc
);
905 rb_enc_str_coderange(string
);
910 rb_str_new_mutable_parser_string(rb_parser_string_t
*str
)
912 return rb_enc_str_new(str
->ptr
, str
->len
, str
->enc
);
916 negative_numeric(VALUE val
)
919 return LONG2FIX(-FIX2LONG(val
));
921 if (SPECIAL_CONST_P(val
)) {
924 return DBL2NUM(-RFLOAT_VALUE(val
));
929 switch (BUILTIN_TYPE(val
)) {
932 val
= rb_big_norm(val
);
935 RATIONAL_SET_NUM(val
, negative_numeric(RRATIONAL(val
)->num
));
938 RCOMPLEX_SET_REAL(val
, negative_numeric(RCOMPLEX(val
)->real
));
939 RCOMPLEX_SET_IMAG(val
, negative_numeric(RCOMPLEX(val
)->imag
));
942 val
= DBL2NUM(-RFLOAT_VALUE(val
));
946 rb_bug("unknown literal type (%s) passed to negative_numeric",
947 rb_builtin_class_name(val
));
954 integer_value(const char *val
, int base
)
956 return rb_cstr_to_inum(val
, base
, FALSE
);
960 rational_value(const char *node_val
, int base
, int seen_point
)
963 char* val
= strdup(node_val
);
964 if (seen_point
> 0) {
965 int len
= (int)(strlen(val
));
966 char *point
= &val
[seen_point
];
967 size_t fraclen
= len
-seen_point
-1;
968 memmove(point
, point
+1, fraclen
+1);
970 lit
= rb_rational_new(integer_value(val
, base
), rb_int_positive_pow(10, fraclen
));
973 lit
= rb_rational_raw1(integer_value(val
, base
));
982 rb_node_integer_literal_val(const NODE
*n
)
984 const rb_node_integer_t
*node
= RNODE_INTEGER(n
);
985 VALUE val
= integer_value(node
->val
, node
->base
);
987 val
= negative_numeric(val
);
993 rb_node_float_literal_val(const NODE
*n
)
995 const rb_node_float_t
*node
= RNODE_FLOAT(n
);
996 double d
= strtod(node
->val
, 0);
1000 VALUE val
= DBL2NUM(d
);
1005 rb_node_rational_literal_val(const NODE
*n
)
1008 const rb_node_rational_t
*node
= RNODE_RATIONAL(n
);
1010 lit
= rational_value(node
->val
, node
->base
, node
->seen_point
);
1013 lit
= negative_numeric(lit
);
1020 rb_node_imaginary_literal_val(const NODE
*n
)
1023 const rb_node_imaginary_t
*node
= RNODE_IMAGINARY(n
);
1025 enum rb_numeric_type type
= node
->type
;
1028 case integer_literal
:
1029 lit
= integer_value(node
->val
, node
->base
);
1031 case float_literal
:{
1032 double d
= strtod(node
->val
, 0);
1036 case rational_literal
:
1037 lit
= rational_value(node
->val
, node
->base
, node
->seen_point
);
1040 rb_bug("unreachable");
1043 lit
= rb_complex_raw(INT2FIX(0), lit
);
1046 lit
= negative_numeric(lit
);
1052 rb_node_str_string_val(const NODE
*node
)
1054 rb_parser_string_t
*str
= RNODE_STR(node
)->string
;
1055 return rb_str_new_parser_string(str
);
1059 rb_node_sym_string_val(const NODE
*node
)
1061 rb_parser_string_t
*str
= RNODE_SYM(node
)->string
;
1062 return ID2SYM(rb_intern3(str
->ptr
, str
->len
, str
->enc
));
1066 rb_node_dstr_string_val(const NODE
*node
)
1068 rb_parser_string_t
*str
= RNODE_DSTR(node
)->string
;
1069 return str
? rb_str_new_parser_string(str
) : Qnil
;
1073 rb_node_dregx_string_val(const NODE
*node
)
1075 rb_parser_string_t
*str
= RNODE_DREGX(node
)->string
;
1076 return rb_str_new_parser_string(str
);
1080 rb_node_regx_string_val(const NODE
*node
)
1082 rb_node_regx_t
*node_reg
= RNODE_REGX(node
);
1083 rb_parser_string_t
*string
= node_reg
->string
;
1084 VALUE str
= rb_enc_str_new(string
->ptr
, string
->len
, string
->enc
);
1086 return rb_reg_compile(str
, node_reg
->options
, NULL
, 0);
1090 rb_node_line_lineno_val(const NODE
*node
)
1092 return INT2FIX(node
->nd_loc
.beg_pos
.lineno
);
1096 rb_node_file_path_val(const NODE
*node
)
1098 return rb_str_new_parser_string(RNODE_FILE(node
)->path
);
1102 rb_node_encoding_val(const NODE
*node
)
1104 return rb_enc_from_encoding(RNODE_ENCODING(node
)->enc
);
1108 parser_aset_script_lines_for(VALUE path
, rb_parser_ary_t
*lines
)
1110 VALUE hash
, script_lines
;
1112 if (NIL_P(path
) || !lines
) return;
1113 CONST_ID(script_lines_id
, "SCRIPT_LINES__");
1114 if (!rb_const_defined_at(rb_cObject
, script_lines_id
)) return;
1115 hash
= rb_const_get_at(rb_cObject
, script_lines_id
);
1116 if (!RB_TYPE_P(hash
, T_HASH
)) return;
1117 if (rb_hash_lookup(hash
, path
) == Qnil
) return;
1118 script_lines
= rb_parser_build_script_lines_from(lines
);
1119 rb_hash_aset(hash
, path
, script_lines
);
1123 rb_ruby_ast_new(const NODE
*const root
)
1126 VALUE ast_value
= TypedData_Make_Struct(0, rb_ast_t
, &ast_data_type
, ast
);
1127 #ifdef UNIVERSAL_PARSER
1128 ast
->config
= &rb_global_parser_config
;
1130 ast
->body
= (rb_ast_body_t
){
1132 .frozen_string_literal
= -1,
1133 .coverage_enabled
= -1,
1134 .script_lines
= NULL
,
1141 rb_ruby_ast_data_get(VALUE ast_value
)
1144 if (NIL_P(ast_value
)) return NULL
;
1145 TypedData_Get_Struct(ast_value
, rb_ast_t
, &ast_data_type
, ast
);