kanayago 0.2.0 → 0.4.0

data/ext/kanayago/internal/numeric.h

@@ -1,275 +0,0 @@
-#ifndef INTERNAL_NUMERIC_H                               /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_NUMERIC_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Numeric.
- */
-#include "internal/bignum.h"    /* for BIGNUM_POSITIVE_P */
-#include "internal/bits.h"      /* for RUBY_BIT_ROTL */
-#include "internal/fixnum.h"    /* for FIXNUM_POSITIVE_P */
-#include "internal/vm.h"        /* for rb_method_basic_definition_p */
-#include "ruby/intern.h"        /* for rb_cmperr */
-#include "ruby/ruby.h"          /* for USE_FLONUM */
-
-#define ROUND_TO(mode, even, up, down) \
-    ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
-     (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
-#define ROUND_FUNC(mode, name) \
-    ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
-#define ROUND_CALL(mode, name, args) \
-    ROUND_TO(mode, name##_half_even args, \
-             name##_half_up args, name##_half_down args)
-
-#ifndef ROUND_DEFAULT
-# define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
-#endif
-
-enum ruby_num_rounding_mode {
-    RUBY_NUM_ROUND_HALF_UP,
-    RUBY_NUM_ROUND_HALF_EVEN,
-    RUBY_NUM_ROUND_HALF_DOWN,
-    RUBY_NUM_ROUND_DEFAULT = ROUND_DEFAULT,
-};
-
-/* same as internal.h */
-#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
-#define roomof(x, y) (((x) + (y) - 1) / (y))
-#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
-
-#if SIZEOF_DOUBLE <= SIZEOF_VALUE
-typedef double rb_float_value_type;
-#else
-typedef struct {
-    VALUE values[roomof(SIZEOF_DOUBLE, SIZEOF_VALUE)];
-} rb_float_value_type;
-#endif
-
-struct RFloat {
-    struct RBasic basic;
-    rb_float_value_type float_value;
-};
-
-#define RFLOAT(obj)  ((struct RFloat *)(obj))
-
-/* numeric.c */
-int rb_num_to_uint(VALUE val, unsigned int *ret);
-VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
-double ruby_float_step_size(double beg, double end, double unit, int excl);
-int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless);
-int rb_num_negative_p(VALUE);
-VALUE rb_int_succ(VALUE num);
-VALUE rb_float_uminus(VALUE num);
-VALUE rb_int_plus(VALUE x, VALUE y);
-VALUE rb_float_plus(VALUE x, VALUE y);
-VALUE rb_int_minus(VALUE x, VALUE y);
-VALUE rb_float_minus(VALUE x, VALUE y);
-VALUE rb_int_mul(VALUE x, VALUE y);
-VALUE rb_float_mul(VALUE x, VALUE y);
-VALUE rb_float_div(VALUE x, VALUE y);
-VALUE rb_int_idiv(VALUE x, VALUE y);
-VALUE rb_int_modulo(VALUE x, VALUE y);
-VALUE rb_int2str(VALUE num, int base);
-VALUE rb_fix_plus(VALUE x, VALUE y);
-VALUE rb_int_gt(VALUE x, VALUE y);
-VALUE rb_float_gt(VALUE x, VALUE y);
-VALUE rb_int_ge(VALUE x, VALUE y);
-enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts);
-double rb_int_fdiv_double(VALUE x, VALUE y);
-VALUE rb_int_pow(VALUE x, VALUE y);
-VALUE rb_float_pow(VALUE x, VALUE y);
-VALUE rb_int_cmp(VALUE x, VALUE y);
-VALUE rb_int_equal(VALUE x, VALUE y);
-VALUE rb_int_divmod(VALUE x, VALUE y);
-VALUE rb_int_and(VALUE x, VALUE y);
-VALUE rb_int_xor(VALUE x, VALUE y);
-VALUE rb_int_lshift(VALUE x, VALUE y);
-VALUE rb_int_rshift(VALUE x, VALUE y);
-VALUE rb_int_div(VALUE x, VALUE y);
-int rb_int_positive_p(VALUE num);
-int rb_int_negative_p(VALUE num);
-VALUE rb_check_integer_type(VALUE);
-VALUE rb_num_pow(VALUE x, VALUE y);
-VALUE rb_float_ceil(VALUE num, int ndigits);
-VALUE rb_float_floor(VALUE x, int ndigits);
-VALUE rb_float_abs(VALUE flt);
-static inline VALUE rb_num_compare_with_zero(VALUE num, ID mid);
-static inline int rb_num_positive_int_p(VALUE num);
-static inline int rb_num_negative_int_p(VALUE num);
-static inline double rb_float_flonum_value(VALUE v);
-static inline double rb_float_noflonum_value(VALUE v);
-static inline double rb_float_value_inline(VALUE v);
-static inline VALUE rb_float_new_inline(double d);
-static inline bool INT_POSITIVE_P(VALUE num);
-static inline bool INT_NEGATIVE_P(VALUE num);
-static inline bool FLOAT_ZERO_P(VALUE num);
-#define rb_float_value rb_float_value_inline
-#define rb_float_new   rb_float_new_inline
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* numeric.c (export) */
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_flo_div_flo(VALUE x, VALUE y);
-double ruby_float_mod(double x, double y);
-VALUE rb_float_equal(VALUE x, VALUE y);
-int rb_float_cmp(VALUE x, VALUE y);
-VALUE rb_float_eql(VALUE x, VALUE y);
-VALUE rb_fix_aref(VALUE fix, VALUE idx);
-VALUE rb_int_zero_p(VALUE num);
-VALUE rb_int_even_p(VALUE num);
-VALUE rb_int_odd_p(VALUE num);
-VALUE rb_int_abs(VALUE num);
-VALUE rb_int_bit_length(VALUE num);
-VALUE rb_int_uminus(VALUE num);
-VALUE rb_int_comp(VALUE num);
-
-static inline bool
-INT_POSITIVE_P(VALUE num)
-{
-    if (FIXNUM_P(num)) {
-        return FIXNUM_POSITIVE_P(num);
-    }
-    else {
-        return BIGNUM_POSITIVE_P(num);
-    }
-}
-
-static inline bool
-INT_NEGATIVE_P(VALUE num)
-{
-    if (FIXNUM_P(num)) {
-        return FIXNUM_NEGATIVE_P(num);
-    }
-    else {
-        return BIGNUM_NEGATIVE_P(num);
-    }
-}
-
-static inline bool
-FLOAT_ZERO_P(VALUE num)
-{
-    return RFLOAT_VALUE(num) == 0.0;
-}
-
-static inline VALUE
-rb_num_compare_with_zero(VALUE num, ID mid)
-{
-    VALUE zero = INT2FIX(0);
-    VALUE r = rb_check_funcall(num, mid, 1, &zero);
-    if (RB_UNDEF_P(r)) {
-        rb_cmperr(num, zero);
-    }
-    return r;
-}
-
-static inline int
-rb_num_positive_int_p(VALUE num)
-{
-    const ID mid = '>';
-
-    if (FIXNUM_P(num)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return FIXNUM_POSITIVE_P(num);
-    }
-    else if (RB_TYPE_P(num, T_BIGNUM)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return BIGNUM_POSITIVE_P(num);
-    }
-    return RTEST(rb_num_compare_with_zero(num, mid));
-}
-
-static inline int
-rb_num_negative_int_p(VALUE num)
-{
-    const ID mid = '<';
-
-    if (FIXNUM_P(num)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return FIXNUM_NEGATIVE_P(num);
-    }
-    else if (RB_TYPE_P(num, T_BIGNUM)) {
-        if (rb_method_basic_definition_p(rb_cInteger, mid))
-            return BIGNUM_NEGATIVE_P(num);
-    }
-    return RTEST(rb_num_compare_with_zero(num, mid));
-}
-
-static inline double
-rb_float_flonum_value(VALUE v)
-{
-#if USE_FLONUM
-    if (v != (VALUE)0x8000000000000002) { /* LIKELY */
-        union {
-            double d;
-            VALUE v;
-        } t;
-
-        VALUE b63 = (v >> 63);
-        /* e: xx1... -> 011... */
-        /*    xx0... -> 100... */
-        /*      ^b63           */
-        t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
-        return t.d;
-    }
-#endif
-    return 0.0;
-}
-
-static inline double
-rb_float_noflonum_value(VALUE v)
-{
-#if SIZEOF_DOUBLE <= SIZEOF_VALUE
-    return RFLOAT(v)->float_value;
-#else
-    union {
-        rb_float_value_type v;
-        double d;
-    } u = {RFLOAT(v)->float_value};
-    return u.d;
-#endif
-}
-
-static inline double
-rb_float_value_inline(VALUE v)
-{
-    if (FLONUM_P(v)) {
-        return rb_float_flonum_value(v);
-    }
-    return rb_float_noflonum_value(v);
-}
-
-static inline VALUE
-rb_float_new_inline(double d)
-{
-#if USE_FLONUM
-    union {
-        double d;
-        VALUE v;
-    } t;
-    int bits;
-
-    t.d = d;
-    bits = (int)((VALUE)(t.v >> 60) & 0x7);
-    /* bits contains 3 bits of b62..b60. */
-    /* bits - 3 = */
-    /*   b011 -> b000 */
-    /*   b100 -> b001 */
-
-    if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
-        !((bits-3) & ~0x01)) {
-        return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
-    }
-    else if (t.v == (VALUE)0) {
-        /* +0.0 */
-        return 0x8000000000000002;
-    }
-    /* out of range */
-#endif
-    return rb_float_new_in_heap(d);
-}
-
-#endif /* INTERNAL_NUMERIC_H */

data/ext/kanayago/internal/parse.h

@@ -1,131 +0,0 @@
-#ifndef INTERNAL_PARSE_H                                 /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_PARSE_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for the parser.
- */
-#include <limits.h>
-#include "rubyparser.h"
-#include "internal/static_assert.h"
-
-// The default parser to use for Ruby code.
-typedef enum {
-    RB_DEFAULT_PARSER_PARSE_Y,
-    RB_DEFAULT_PARSER_PRISM,
-} ruby_default_parser_enum;
-
-ruby_default_parser_enum rb_ruby_default_parser(void);
-void rb_ruby_default_parser_set(ruby_default_parser_enum parser);
-
-#define rb_ruby_prism_p() (rb_ruby_default_parser() == RB_DEFAULT_PARSER_PRISM)
-
-#ifdef UNIVERSAL_PARSER
-#define rb_encoding const void
-#endif
-
-struct rb_iseq_struct;          /* in vm_core.h */
-
-/* structs for managing terminator of string literal and heredocment */
-typedef struct rb_strterm_literal_struct {
-    long nest;
-    int func;	    /* STR_FUNC_* (e.g., STR_FUNC_ESCAPE and STR_FUNC_EXPAND) */
-    int paren;	    /* '(' of `%q(...)` */
-    int term;	    /* ')' of `%q(...)` */
-} rb_strterm_literal_t;
-
-typedef struct rb_strterm_heredoc_struct {
-    rb_parser_string_t *lastline;	/* the string of line that contains `<<"END"` */
-    long offset;	/* the column of END in `<<"END"` */
-    int sourceline;	/* lineno of the line that contains `<<"END"` */
-    unsigned length;	/* the length of END in `<<"END"` */
-    uint8_t quote;
-    uint8_t func;
-} rb_strterm_heredoc_t;
-
-#define HERETERM_LENGTH_MAX UINT_MAX
-
-typedef struct rb_strterm_struct {
-    bool heredoc;
-    union {
-        rb_strterm_literal_t literal;
-        rb_strterm_heredoc_t heredoc;
-    } u;
-} rb_strterm_t;
-
-/* parse.y */
-void rb_ruby_parser_mark(void *ptr);
-size_t rb_ruby_parser_memsize(const void *ptr);
-
-void rb_ruby_parser_set_options(rb_parser_t *p, int print, int loop, int chomp, int split);
-rb_parser_t *rb_ruby_parser_set_context(rb_parser_t *p, const struct rb_iseq_struct *base, int main);
-void rb_ruby_parser_set_script_lines(rb_parser_t *p);
-void rb_ruby_parser_error_tolerant(rb_parser_t *p);
-void rb_ruby_parser_keep_tokens(rb_parser_t *p);
-typedef rb_parser_string_t*(rb_parser_lex_gets_func)(struct parser_params*, rb_parser_input_data, int);
-rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, VALUE fname, rb_parser_input_data input, int line);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-
-rb_encoding *rb_ruby_parser_encoding(rb_parser_t *p);
-int rb_ruby_parser_end_seen_p(rb_parser_t *p);
-int rb_ruby_parser_set_yydebug(rb_parser_t *p, int flag);
-rb_parser_string_t *rb_str_to_parser_string(rb_parser_t *p, VALUE str);
-void rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str);
-
-int rb_parser_dvar_defined_ref(struct parser_params*, ID, ID**);
-ID rb_parser_internal_id(struct parser_params*);
-typedef void (*rb_parser_reg_fragment_error_func)(struct parser_params *, VALUE);
-int rb_parser_reg_fragment_check(struct parser_params*, rb_parser_string_t*, int, rb_parser_reg_fragment_error_func);
-int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc, rb_parser_assignable_func assignable);
-int rb_parser_local_defined(struct parser_params *p, ID id, const struct rb_iseq_struct *iseq);
-NODE *rb_parser_assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc);
-
-RUBY_SYMBOL_EXPORT_END
-
-#ifndef UNIVERSAL_PARSER
-rb_parser_t *rb_ruby_parser_allocate(void);
-rb_parser_t *rb_ruby_parser_new(void);
-#endif
-
-#ifdef RIPPER
-void ripper_parser_mark(void *ptr);
-void ripper_parser_free(void *ptr);
-size_t ripper_parser_memsize(const void *ptr);
-void ripper_error(struct parser_params *p);
-VALUE ripper_value(struct parser_params *p);
-int rb_ruby_parser_get_yydebug(rb_parser_t *p);
-void rb_ruby_parser_set_value(rb_parser_t *p, VALUE value);
-int rb_ruby_parser_error_p(rb_parser_t *p);
-VALUE rb_ruby_parser_debug_output(rb_parser_t *p);
-void rb_ruby_parser_set_debug_output(rb_parser_t *p, VALUE output);
-VALUE rb_ruby_parser_parsing_thread(rb_parser_t *p);
-void rb_ruby_parser_set_parsing_thread(rb_parser_t *p, VALUE parsing_thread);
-void rb_ruby_parser_ripper_initialize(rb_parser_t *p, rb_parser_lex_gets_func *gets, rb_parser_input_data input, VALUE sourcefile_string, const char *sourcefile, int sourceline);
-VALUE rb_ruby_parser_result(rb_parser_t *p);
-rb_encoding *rb_ruby_parser_enc(rb_parser_t *p);
-VALUE rb_ruby_parser_ruby_sourcefile_string(rb_parser_t *p);
-int rb_ruby_parser_ruby_sourceline(rb_parser_t *p);
-int rb_ruby_parser_lex_state(rb_parser_t *p);
-void rb_ruby_ripper_parse0(rb_parser_t *p);
-int rb_ruby_ripper_dedent_string(rb_parser_t *p, rb_parser_string_t *string, int width);
-int rb_ruby_ripper_initialized_p(rb_parser_t *p);
-void rb_ruby_ripper_parser_initialize(rb_parser_t *p);
-long rb_ruby_ripper_column(rb_parser_t *p);
-long rb_ruby_ripper_token_len(rb_parser_t *p);
-rb_parser_string_t *rb_ruby_ripper_lex_lastline(rb_parser_t *p);
-VALUE rb_ruby_ripper_lex_state_name(struct parser_params *p, int state);
-#ifdef UNIVERSAL_PARSER
-rb_parser_t *rb_ripper_parser_params_allocate(const rb_parser_config_t *config);
-#endif
-struct parser_params *rb_ruby_ripper_parser_allocate(void);
-#endif
-
-#ifdef UNIVERSAL_PARSER
-#undef rb_encoding
-#endif
-
-#endif /* INTERNAL_PARSE_H */

data/ext/kanayago/internal/rational.h

@@ -1,71 +0,0 @@
-#ifndef INTERNAL_RATIONAL_H                              /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_RATIONAL_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Rational.
- */
-#include "ruby/internal/config.h"      /* for HAVE_LIBGMP */
-#include "ruby/ruby.h"          /* for struct RBasic */
-#include "internal/numeric.h"   /* for INT_POSITIVE_P */
-#include "ruby_assert.h"        /* for assert */
-
-struct RRational {
-    struct RBasic basic;
-    VALUE num;
-    VALUE den;
-};
-
-#define RRATIONAL(obj) ((struct RRational *)(obj))
-
-/* rational.c */
-VALUE rb_rational_canonicalize(VALUE x);
-VALUE rb_rational_uminus(VALUE self);
-VALUE rb_rational_plus(VALUE self, VALUE other);
-VALUE rb_rational_minus(VALUE self, VALUE other);
-VALUE rb_rational_mul(VALUE self, VALUE other);
-VALUE rb_rational_div(VALUE self, VALUE other);
-VALUE rb_lcm(VALUE x, VALUE y);
-VALUE rb_rational_reciprocal(VALUE x);
-VALUE rb_cstr_to_rat(const char *, int);
-VALUE rb_rational_hash(VALUE self);
-VALUE rb_rational_abs(VALUE self);
-VALUE rb_rational_cmp(VALUE self, VALUE other);
-VALUE rb_rational_pow(VALUE self, VALUE other);
-VALUE rb_rational_floor(VALUE self, int ndigits);
-VALUE rb_numeric_quo(VALUE x, VALUE y);
-VALUE rb_flo_round_by_rational(int argc, VALUE *argv, VALUE num);
-VALUE rb_float_numerator(VALUE x);
-VALUE rb_float_denominator(VALUE x);
-
-static inline void RATIONAL_SET_NUM(VALUE r, VALUE n);
-static inline void RATIONAL_SET_DEN(VALUE r, VALUE d);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* rational.c (export) */
-VALUE rb_gcd(VALUE x, VALUE y);
-VALUE rb_gcd_normal(VALUE self, VALUE other);
-#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
-VALUE rb_gcd_gmp(VALUE x, VALUE y);
-#endif
-RUBY_SYMBOL_EXPORT_END
-
-static inline void
-RATIONAL_SET_NUM(VALUE r, VALUE n)
-{
-    assert(RB_INTEGER_TYPE_P(n));
-    RB_OBJ_WRITE(r, &RRATIONAL(r)->num, n);
-}
-
-static inline void
-RATIONAL_SET_DEN(VALUE r, VALUE d)
-{
-    assert(RB_INTEGER_TYPE_P(d));
-    assert(INT_POSITIVE_P(d));
-    RB_OBJ_WRITE(r, &RRATIONAL(r)->den, d);
-}
-
-#endif /* INTERNAL_RATIONAL_H */

data/ext/kanayago/internal/re.h

@@ -1,33 +0,0 @@
-#ifndef INTERNAL_RE_H                                    /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_RE_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Regexp.
- */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-/* re.c */
-VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
-VALUE rb_reg_check_preprocess(VALUE);
-long rb_reg_search0(VALUE, VALUE, long, int, int, VALUE *);
-VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
-bool rb_reg_start_with_p(VALUE re, VALUE str);
-VALUE rb_reg_hash(VALUE re);
-VALUE rb_reg_equal(VALUE re1, VALUE re2);
-VALUE rb_backref_set_string(VALUE string, long pos, long len);
-void rb_match_unbusy(VALUE);
-int rb_match_count(VALUE match);
-VALUE rb_reg_new_ary(VALUE ary, int options);
-VALUE rb_reg_last_defined(VALUE match);
-
-#define ARG_REG_OPTION_MASK \
-    (ONIG_OPTION_IGNORECASE|ONIG_OPTION_MULTILINE|ONIG_OPTION_EXTEND)
-#define ARG_ENCODING_FIXED    16
-#define ARG_ENCODING_NONE     32
-
-#endif /* INTERNAL_RE_H */

data/ext/kanayago/internal/ruby_parser.h

@@ -1,125 +0,0 @@
-#ifndef INTERNAL_RUBY_PARSE_H
-#define INTERNAL_RUBY_PARSE_H
-
-#include "internal.h"
-#include "internal/bignum.h"
-#include "internal/compilers.h"
-#include "internal/complex.h"
-#include "internal/parse.h"
-#include "internal/rational.h"
-#include "rubyparser.h"
-#include "vm.h"
-
-struct lex_pointer_string {
-    VALUE str;
-    long ptr;
-};
-
-// Add Ruby's Parser struct and enum for Kanayago
-enum lex_type {
-    lex_type_str,
-    lex_type_io,
-    lex_type_array,
-    lex_type_generic,
-};
-
-struct ruby_parser {
-    rb_parser_t *parser_params;
-    enum lex_type type;
-    union {
-        struct lex_pointer_string lex_str;
-        struct {
-            VALUE file;
-        } lex_io;
-        struct {
-            VALUE ary;
-        } lex_array;
-    } data;
-};
-// End for Kanayago
-
-RUBY_SYMBOL_EXPORT_BEGIN
-#ifdef UNIVERSAL_PARSER
-const rb_parser_config_t *rb_ruby_parser_config(void);
-rb_parser_t *rb_parser_params_new(void);
-#endif
-VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int);
-VALUE rb_parser_new(void);
-VALUE rb_parser_compile_string_path(VALUE vparser, VALUE fname, VALUE src, int line);
-VALUE rb_str_new_parser_string(rb_parser_string_t *str);
-VALUE rb_str_new_mutable_parser_string(rb_parser_string_t *str);
-rb_parser_string_t *rb_parser_lex_get_str(struct parser_params *p, struct lex_pointer_string *ptr_str);
-
-VALUE rb_node_str_string_val(const NODE *);
-VALUE rb_node_sym_string_val(const NODE *);
-VALUE rb_node_dstr_string_val(const NODE *);
-VALUE rb_node_regx_string_val(const NODE *);
-VALUE rb_node_dregx_string_val(const NODE *);
-VALUE rb_node_line_lineno_val(const NODE *);
-VALUE rb_node_file_path_val(const NODE *);
-VALUE rb_node_encoding_val(const NODE *);
-
-VALUE rb_node_integer_literal_val(const NODE *);
-VALUE rb_node_float_literal_val(const NODE *);
-VALUE rb_node_rational_literal_val(const NODE *);
-VALUE rb_node_imaginary_literal_val(const NODE *);
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_parser_end_seen_p(VALUE);
-VALUE rb_parser_encoding(VALUE);
-VALUE rb_parser_set_yydebug(VALUE, VALUE);
-VALUE rb_parser_build_script_lines_from(rb_parser_ary_t *script_lines);
-void rb_parser_set_options(VALUE, int, int, int, int);
-VALUE rb_parser_load_file(VALUE parser, VALUE name);
-void rb_parser_set_script_lines(VALUE vparser);
-void rb_parser_error_tolerant(VALUE vparser);
-void rb_parser_keep_tokens(VALUE vparser);
-
-VALUE rb_parser_compile_string(VALUE, const char*, VALUE, int);
-VALUE rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE input, int line);
-VALUE rb_parser_compile_generic(VALUE vparser, rb_parser_lex_gets_func *lex_gets, VALUE fname, VALUE input, int line);
-VALUE rb_parser_compile_array(VALUE vparser, VALUE fname, VALUE array, int start);
-
-enum lex_state_bits {
-    EXPR_BEG_bit,		/* ignore newline, +/- is a sign. */
-    EXPR_END_bit,		/* newline significant, +/- is an operator. */
-    EXPR_ENDARG_bit,		/* ditto, and unbound braces. */
-    EXPR_ENDFN_bit,		/* ditto, and unbound braces. */
-    EXPR_ARG_bit,		/* newline significant, +/- is an operator. */
-    EXPR_CMDARG_bit,		/* newline significant, +/- is an operator. */
-    EXPR_MID_bit,		/* newline significant, +/- is an operator. */
-    EXPR_FNAME_bit,		/* ignore newline, no reserved words. */
-    EXPR_DOT_bit,		/* right after `.', `&.' or `::', no reserved words. */
-    EXPR_CLASS_bit,		/* immediate after `class', no here document. */
-    EXPR_LABEL_bit,		/* flag bit, label is allowed. */
-    EXPR_LABELED_bit,		/* flag bit, just after a label. */
-    EXPR_FITEM_bit,		/* symbol literal as FNAME. */
-    EXPR_MAX_STATE
-};
-/* examine combinations */
-enum lex_state_e {
-#define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
-    DEF_EXPR(BEG),
-    DEF_EXPR(END),
-    DEF_EXPR(ENDARG),
-    DEF_EXPR(ENDFN),
-    DEF_EXPR(ARG),
-    DEF_EXPR(CMDARG),
-    DEF_EXPR(MID),
-    DEF_EXPR(FNAME),
-    DEF_EXPR(DOT),
-    DEF_EXPR(CLASS),
-    DEF_EXPR(LABEL),
-    DEF_EXPR(LABELED),
-    DEF_EXPR(FITEM),
-    EXPR_VALUE = EXPR_BEG,
-    EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_MID | EXPR_CLASS),
-    EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
-    EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN),
-    EXPR_NONE = 0
-};
-
-VALUE rb_ruby_ast_new(const NODE *const root);
-rb_ast_t *rb_ruby_ast_data_get(VALUE ast_value);
-
-#endif /* INTERNAL_RUBY_PARSE_H */