debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/imemo.h

@@ -0,0 +1,243 @@
+#ifndef INTERNAL_IMEMO_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_IMEMO_H
+/**
+ * @file
+ * @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      IMEMO: Internal memo object.
+ */
+#include "ruby/internal/config.h"
+#include <stddef.h>             /* for size_t */
+#include "internal/array.h"     /* for rb_ary_tmp_new_fill */
+#include "internal/gc.h"        /* for RB_OBJ_WRITE */
+#include "ruby/internal/stdbool.h"     /* for bool */
+#include "ruby/ruby.h"          /* for rb_block_call_func_t */
+
+#ifndef IMEMO_DEBUG
+# define IMEMO_DEBUG 0
+#endif
+
+#define IMEMO_MASK   0x0f
+
+/* FL_USER0 to FL_USER3 is for type */
+#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
+#define IMEMO_FL_USER0 FL_USER4
+#define IMEMO_FL_USER1 FL_USER5
+#define IMEMO_FL_USER2 FL_USER6
+#define IMEMO_FL_USER3 FL_USER7
+#define IMEMO_FL_USER4 FL_USER8
+#define IMEMO_FL_USER5 FL_USER9
+
+enum imemo_type {
+    imemo_env            =  0,
+    imemo_cref           =  1, /*!< class reference */
+    imemo_svar           =  2, /*!< special variable */
+    imemo_throw_data     =  3,
+    imemo_ifunc          =  4, /*!< iterator function */
+    imemo_memo           =  5,
+    imemo_ment           =  6,
+    imemo_iseq           =  7,
+    imemo_tmpbuf         =  8,
+    imemo_ast            =  9,
+    imemo_parser_strterm = 10,
+    imemo_callinfo       = 11,
+    imemo_callcache      = 12,
+};
+
+/* CREF (Class REFerence) is defined in method.h */
+
+/*! SVAR (Special VARiable) */
+struct vm_svar {
+    VALUE flags;
+    const VALUE cref_or_me; /*!< class reference or rb_method_entry_t */
+    const VALUE lastline;
+    const VALUE backref;
+    const VALUE others;
+};
+
+/*! THROW_DATA */
+struct vm_throw_data {
+    VALUE flags;
+    VALUE reserved;
+    const VALUE throw_obj;
+    const struct rb_control_frame_struct *catch_frame;
+    int throw_state;
+};
+
+#define THROW_DATA_CONSUMED IMEMO_FL_USER0
+
+/* IFUNC (Internal FUNCtion) */
+
+struct vm_ifunc_argc {
+#if SIZEOF_INT * 2 > SIZEOF_VALUE
+    signed int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
+    signed int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
+#else
+    int min, max;
+#endif
+};
+
+/*! IFUNC (Internal FUNCtion) */
+struct vm_ifunc {
+    VALUE flags;
+    VALUE reserved;
+    rb_block_call_func_t func;
+    const void *data;
+    struct vm_ifunc_argc argc;
+};
+
+struct rb_imemo_tmpbuf_struct {
+    VALUE flags;
+    VALUE reserved;
+    VALUE *ptr; /* malloc'ed buffer */
+    struct rb_imemo_tmpbuf_struct *next; /* next imemo */
+    size_t cnt; /* buffer size in VALUE */
+};
+
+/*! MEMO
+ *
+ * @see imemo_type
+ * */
+struct MEMO {
+    VALUE flags;
+    VALUE reserved;
+    const VALUE v1;
+    const VALUE v2;
+    union {
+        long cnt;
+        long state;
+        const VALUE value;
+        void (*func)(void);
+    } u3;
+};
+
+/* ment is in method.h */
+
+#define THROW_DATA_P(err) imemo_throw_data_p((VALUE)err)
+#define MEMO_CAST(m) ((struct MEMO *)(m))
+#define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
+#define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
+#define NEW_MEMO_FOR(type, value) \
+  ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
+#define NEW_PARTIAL_MEMO_FOR(type, value, member) \
+  ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), \
+   rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
+   MEMO_FOR(type, value))
+
+typedef struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t;
+VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
+rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
+struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
+void rb_strterm_mark(VALUE obj);
+static inline enum imemo_type imemo_type(VALUE imemo);
+static inline int imemo_type_p(VALUE imemo, enum imemo_type imemo_type);
+static inline bool imemo_throw_data_p(VALUE imemo);
+static inline struct vm_ifunc *rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data);
+static inline VALUE rb_imemo_tmpbuf_auto_free_pointer(void);
+static inline void *RB_IMEMO_TMPBUF_PTR(VALUE v);
+static inline void *rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr);
+static inline VALUE rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str);
+static inline void MEMO_V1_SET(struct MEMO *m, VALUE v);
+static inline void MEMO_V2_SET(struct MEMO *m, VALUE v);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+#if IMEMO_DEBUG
+VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);
+#define rb_imemo_new(type, v1, v2, v3, v0) rb_imemo_new_debug(type, v1, v2, v3, v0, __FILE__, __LINE__)
+#else
+VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
+#endif
+const char *rb_imemo_name(enum imemo_type type);
+RUBY_SYMBOL_EXPORT_END
+
+static inline enum imemo_type
+imemo_type(VALUE imemo)
+{
+    return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
+}
+
+static inline int
+imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
+{
+    if (LIKELY(!RB_SPECIAL_CONST_P(imemo))) {
+        /* fixed at compile time if imemo_type is given. */
+        const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
+        const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
+        /* fixed at runtime. */
+        return expected_type == (RBASIC(imemo)->flags & mask);
+    }
+    else {
+        return 0;
+    }
+}
+
+#define IMEMO_TYPE_P(v, t) imemo_type_p((VALUE)v, t)
+
+static inline bool
+imemo_throw_data_p(VALUE imemo)
+{
+    return RB_TYPE_P(imemo, T_IMEMO);
+}
+
+static inline struct vm_ifunc *
+rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
+{
+    return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
+}
+
+static inline VALUE
+rb_imemo_tmpbuf_auto_free_pointer(void)
+{
+    return rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0);
+}
+
+static inline void *
+RB_IMEMO_TMPBUF_PTR(VALUE v)
+{
+    const struct rb_imemo_tmpbuf_struct *p = (const void *)v;
+    return p->ptr;
+}
+
+static inline void *
+rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
+{
+    return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
+}
+
+static inline VALUE
+rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
+{
+    const void *src;
+    VALUE imemo;
+    rb_imemo_tmpbuf_t *tmpbuf;
+    void *dst;
+    size_t len;
+
+    SafeStringValue(str);
+    /* create tmpbuf to keep the pointer before xmalloc */
+    imemo = rb_imemo_tmpbuf_auto_free_pointer();
+    tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
+    len = RSTRING_LEN(str);
+    src = RSTRING_PTR(str);
+    dst = ruby_xmalloc(len);
+    memcpy(dst, src, len);
+    tmpbuf->ptr = dst;
+    return imemo;
+}
+
+static inline void
+MEMO_V1_SET(struct MEMO *m, VALUE v)
+{
+    RB_OBJ_WRITE(m, &m->v1, v);
+}
+
+static inline void
+MEMO_V2_SET(struct MEMO *m, VALUE v)
+{
+    RB_OBJ_WRITE(m, &m->v2, v);
+}
+
+#endif /* INTERNAL_IMEMO_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/inits.h

@@ -0,0 +1,51 @@
+#ifndef INTERNAL_INITS_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_INITS_H
+/**
+ * @file
+ * @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 aggregating init functions.
+ */
+
+/* class.c */
+void Init_class_hierarchy(void);
+
+/* dmyext.c */
+void Init_enc(void);
+void Init_ext(void);
+
+/* file.c */
+void Init_File(void);
+
+/* gc.c */
+void Init_heap(void);
+
+/* localeinit.c */
+int Init_enc_set_filesystem_encoding(void);
+
+/* newline.c */
+void Init_newline(void);
+
+/* vm.c */
+void Init_BareVM(void);
+void Init_vm_objects(void);
+
+/* vm_backtrace.c */
+void Init_vm_backtrace(void);
+
+/* vm_eval.c */
+void Init_vm_eval(void);
+
+/* vm_insnhelper.c */
+void Init_vm_stack_canary(void);
+
+/* vm_method.c */
+void Init_eval_method(void);
+
+/* inits.c */
+void rb_call_inits(void);
+
+#endif /* INTERNAL_INITS_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/io.h

@@ -0,0 +1,35 @@
+#ifndef INTERNAL_IO_H                                    /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_IO_H
+/**
+ * @file
+ * @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 IO.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+#include "ruby/io.h"            /* for rb_io_t */
+
+/* io.c */
+void ruby_set_inplace_mode(const char *);
+void rb_stdio_set_default_encoding(void);
+VALUE rb_io_flush_raw(VALUE, int);
+size_t rb_io_memsize(const rb_io_t *);
+int rb_stderr_tty_p(void);
+void rb_io_fptr_finalize_internal(void *ptr);
+#ifdef rb_io_fptr_finalize
+# undef rb_io_fptr_finalize
+#endif
+#define rb_io_fptr_finalize rb_io_fptr_finalize_internal
+VALUE rb_io_popen(VALUE pname, VALUE pmode, VALUE env, VALUE opt);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* io.c (export) */
+void rb_maygvl_fd_fix_cloexec(int fd);
+int rb_gc_for_fd(int err);
+void rb_write_error_str(VALUE mesg);
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* INTERNAL_IO_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/load.h

@@ -0,0 +1,19 @@
+#ifndef INTERNAL_LOAD_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_LOAD_H
+/**
+ * @file
+ * @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 require.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+
+/* load.c */
+VALUE rb_get_expanded_load_path(void);
+int rb_require_internal(VALUE fname);
+NORETURN(void rb_load_fail(VALUE, const char*));
+
+#endif /* INTERNAL_LOAD_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/loadpath.h

@@ -0,0 +1,17 @@
+#ifndef INTERNAL_LOADPATH_H                              /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_LOADPATH_H
+/**
+ * @file
+ * @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 $LOAD_PATH.
+ */
+
+/* loadpath.c */
+extern const char ruby_exec_prefix[];
+extern const char ruby_initial_load_paths[];
+
+#endif /* INTERNAL_LOADPATH_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/math.h

@@ -0,0 +1,24 @@
+#ifndef INTERNAL_MATH_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_MATH_H
+/**
+ * @file
+ * @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 Math.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+
+/* math.c */
+VALUE rb_math_atan2(VALUE, VALUE);
+VALUE rb_math_cos(VALUE);
+VALUE rb_math_cosh(VALUE);
+VALUE rb_math_exp(VALUE);
+VALUE rb_math_hypot(VALUE, VALUE);
+VALUE rb_math_log(int argc, const VALUE *argv);
+VALUE rb_math_sin(VALUE);
+VALUE rb_math_sinh(VALUE);
+
+#endif /* INTERNAL_MATH_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/missing.h

@@ -0,0 +1,19 @@
+#ifndef INTERNAL_MISSING_H                               /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_MISSING_H
+/**
+ * @file
+ * @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 corresponding missing.
+ */
+#include "ruby/internal/config.h"      /* for HAVE_SETPROCTITLE */
+
+/* missing/setproctitle.c */
+#ifndef HAVE_SETPROCTITLE
+extern void ruby_init_setproctitle(int argc, char *argv[]);
+#endif
+
+#endif /* INTERNAL_MISSING_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/numeric.h

@@ -0,0 +1,255 @@
+#ifndef INTERNAL_NUMERIC_H                               /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_NUMERIC_H
+/**
+ * @file
+ * @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,
+};
+
+struct RFloat {
+    struct RBasic basic;
+    double 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_lshift(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_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) */
+VALUE rb_int_positive_pow(long x, unsigned long y);
+RUBY_SYMBOL_EXPORT_END
+
+MJIT_SYMBOL_EXPORT_BEGIN
+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);
+MJIT_SYMBOL_EXPORT_END
+
+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 (r == Qundef) {
+        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)
+{
+    return RFLOAT(v)->float_value;
+}
+
+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 */