datadog-ruby_core_source 3.4.0 → 3.4.1

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/enumerator.h

@@ -0,0 +1,21 @@
+#ifndef INTERNAL_ENUMERATOR_H                            /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_ENUMERATOR_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 Enumerator.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+#include "ruby/intern.h"        /* for rb_enumerator_size_func */
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* enumerator.c (export) */
+VALUE rb_arith_seq_new(VALUE obj, VALUE meth, int argc, VALUE const *argv,
+                       rb_enumerator_size_func *size_fn,
+                       VALUE beg, VALUE end, VALUE step, int excl);
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* INTERNAL_ENUMERATOR_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/error.h

@@ -0,0 +1,244 @@
+#ifndef INTERNAL_ERROR_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_ERROR_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 Exception.
+ */
+#include "ruby/internal/config.h"
+#include <stdarg.h>             /* for va_list */
+#include "internal/string.h"    /* for rb_fstring_cstr */
+#include "ruby/internal/stdbool.h"     /* for bool */
+#include "ruby/encoding.h"      /* for rb_encoding */
+#include "ruby/intern.h"        /* for rb_exc_raise */
+#include "ruby/ruby.h"          /* for enum ruby_value_type */
+
+#ifdef Check_Type
+# undef Check_Type               /* in ruby/ruby.h */
+#endif
+
+#ifdef rb_raise_static
+# undef rb_raise_static
+# undef rb_sys_fail_path
+# undef rb_syserr_fail_path
+#endif
+
+#define rb_raise_static(e, m) \
+    rb_raise_cstr_i((e), rb_str_new_static((m), rb_strlen_lit(m)))
+#ifdef RUBY_FUNCTION_NAME_STRING
+# define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
+# define rb_syserr_new_path(err, path) rb_syserr_new_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
+#else
+# define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
+# define rb_syserr_new_path(err, path) rb_syserr_new_str((err), (path))
+#endif
+
+#define rb_sys_fail(mesg) \
+do { \
+    int errno_to_fail = errno; \
+    rb_syserr_fail(errno_to_fail, (mesg)); \
+} while (0)
+
+#define rb_sys_fail_str(mesg) \
+do { \
+    int errno_to_fail = errno; \
+    rb_syserr_fail_str(errno_to_fail, (mesg)); \
+} while (0)
+
+#define rb_sys_fail_path(path) \
+do { \
+    int errno_to_fail = errno; \
+    rb_syserr_fail_path(errno_to_fail, (path)); \
+} while (0)
+
+#define rb_sys_fail_sprintf(...) \
+do { \
+    int errno_to_fail = errno; \
+    rb_syserr_fail_str(errno_to_fail, rb_sprintf("" __VA_ARGS__)); \
+} while (0)
+
+/* error.c */
+extern long rb_backtrace_length_limit;
+extern VALUE rb_eEAGAIN;
+extern VALUE rb_eEWOULDBLOCK;
+extern VALUE rb_eEINPROGRESS;
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 0)
+void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args);
+NORETURN(void rb_async_bug_errno(const char *,int));
+const char *rb_builtin_type_name(int t);
+const char *rb_builtin_class_name(VALUE x);
+PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
+PRINTF_ARGS(void rb_warn_deprecated_to_remove(const char *removal, const char *fmt, const char *suggest, ...), 2, 4);
+PRINTF_ARGS(void rb_warn_reserved_name(const char *removal, const char *fmt, ...), 2, 3);
+#if RUBY_DEBUG
+# include "ruby/version.h"
+# define RUBY_VERSION_SINCE(major, minor) (RUBY_API_VERSION_CODE >= (major * 10000) + (minor) * 100)
+# define RUBY_VERSION_BEFORE(major, minor) (RUBY_API_VERSION_CODE < (major * 10000) + (minor) * 100)
+# if defined(RBIMPL_WARNING_PRAGMA0)
+#   define RBIMPL_TODO0(x) RBIMPL_WARNING_PRAGMA0(message(x))
+# elif RBIMPL_COMPILER_SINCE(MSVC, 12, 0, 0)
+#   define RBIMPL_TODO0(x) __pragma(message(x))
+# endif
+
+# if RBIMPL_HAS_ATTRIBUTE(diagnose_if) || defined(__OPTIMIZE__)
+
+#define RUBY_VERSION_isdigit(c) ('0'<=(c)&&(c)<='9')
+// upto 99
+#define RUBY_VERSION__number_len(v, ofs) \
+    (!RUBY_VERSION_isdigit((v)[ofs]) ? \
+     0 : !RUBY_VERSION_isdigit((v)[(ofs) + 1]) ? 1 : 2)
+#define RUBY_VERSION__to_number(v, ofs) \
+    (!RUBY_VERSION_isdigit((v)[ofs]) ? \
+     0 : !RUBY_VERSION_isdigit((v)[(ofs) + 1]) ? \
+     ((v)[ofs]-'0') : \
+     (((v)[ofs]-'0')*10+(v)[(ofs)+1]-'0'))
+
+#define RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v) \
+    (RUBY_VERSION__to_number(v, 0) * 10000 + \
+     ((v)[RUBY_VERSION__number_len(v, 0)] == '.' ? \
+      RUBY_VERSION__to_number(v, RUBY_VERSION__number_len(v, 0)+1) * 100 : 0))
+#define RUBY_VERSION_STRING_SINCE(v) (RUBY_API_VERSION_CODE >= RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v))
+#define RUBY_VERSION_STRING_BEFORE(v) (RUBY_API_VERSION_CODE < RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v))
+
+# if RBIMPL_HAS_ATTRIBUTE(diagnose_if)
+RBIMPL_ATTR_FORCEINLINE()
+static void
+rb_deprecated_method_to_be_removed(const char *removal)
+    RBIMPL_ATTR_DIAGNOSE_IF(!RUBY_VERSION_isdigit(removal[0]), "malformed version number", "error")
+    RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(removal), "deprecated method to be removed", "error")
+{
+}
+
+RBIMPL_ATTR_FORCEINLINE()
+static void
+rb_diagnose_reserved_name_at(const char *coming)
+    RBIMPL_ATTR_DIAGNOSE_IF(!RUBY_VERSION_isdigit(coming[0]), "malformed version number", "error")
+    RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(coming), "reserved name already in use", "error")
+{
+}
+# else
+RBIMPL_ATTR_ERROR(("deprecated"))
+void rb_deprecated_method_to_be_removed(const char *);
+#   define rb_deprecated_method_to_be_removed(removal) \
+    (sizeof(char[1-2*(!RUBY_VERSION_isdigit(removal[0]) || RUBY_VERSION_STRING_SINCE(removal))])!=1 ? \
+     rb_deprecated_method_to_be_removed(removal) : \
+     RBIMPL_ASSERT_NOTHING)
+
+RBIMPL_ATTR_ERROR(("deprecated"))
+void rb_diagnose_reserved_name_at(const char *);
+#   define rb_diagnose_reserved_name_at(coming) \
+    (sizeof(char[1-2*(!RUBY_VERSION_isdigit(coming[0]) || RUBY_VERSION_STRING_SINCE(coming))])!=1 ? \
+     rb_diagnose_reserved_name_at(coming) : \
+     RBIMPL_ASSERT_NOTHING)
+
+# endif
+# define rb_warn_deprecated_to_remove_at(removal, ...) \
+    (rb_deprecated_method_to_be_removed(#removal), \
+     rb_warn_deprecated_to_remove(#removal, __VA_ARGS__))
+
+# define rb_warn_reserved_name_at(coming, ...) \
+    (rb_diagnose_reserved_name_at(#coming), \
+     rb_warn_reserved_name(#coming, __VA_ARGS__))
+# endif
+#endif
+#ifndef rb_warn_deprecated_to_remove_at
+# define rb_warn_deprecated_to_remove_at(removal, ...) \
+        rb_warn_deprecated_to_remove(#removal, __VA_ARGS__)
+#endif
+#ifndef rb_warn_reserved_name_at
+# define rb_warn_reserved_name_at(removal, ...) \
+        rb_warn_reserved_name(#removal, __VA_ARGS__)
+#endif
+#ifndef RUBY_VERSION_SINCE
+# define RUBY_VERSION_SINCE(major, minor) 0
+#endif
+#ifndef RUBY_VERSION_BEFORE
+# define RUBY_VERSION_BEFORE(major, minor) 0
+#endif
+#ifndef RBIMPL_TODO0
+# define RBIMPL_TODO0(x)
+#endif
+#define RBIMPL_TODO(message) RBIMPL_TODO0("TODO: " message)
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
+VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*, va_list);
+PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
+PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
+PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
+PRINTF_ARGS(void rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
+PRINTF_ARGS(void rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
+rb_warning_category_t rb_warning_category_from_name(VALUE category);
+bool rb_warning_category_enabled_p(rb_warning_category_t category);
+VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
+VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv);
+VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name);
+PRINTF_ARGS(VALUE rb_warning_string(const char *fmt, ...), 1, 2);
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 2, 0)
+NORETURN(void rb_vraise(VALUE, const char *, va_list));
+NORETURN(static inline void rb_raise_cstr(VALUE etype, const char *mesg));
+NORETURN(static inline void rb_raise_cstr_i(VALUE etype, VALUE mesg));
+NORETURN(static inline void rb_name_err_raise_str(VALUE mesg, VALUE recv, VALUE name));
+NORETURN(static inline void rb_name_err_raise(const char *mesg, VALUE recv, VALUE name));
+NORETURN(static inline void rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name));
+static inline void Check_Type(VALUE v, enum ruby_value_type t);
+static inline bool rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type);
+#define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
+void rb_bug_without_die(const char *fmt, ...);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* error.c (export) */
+int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
+#ifdef RUBY_FUNCTION_NAME_STRING
+NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
+NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
+VALUE rb_syserr_new_path_in(const char *func_name, int n, VALUE path);
+#endif
+RUBY_SYMBOL_EXPORT_END
+
+/* vm.c */
+void rb_free_warning(void);
+
+static inline void
+rb_raise_cstr_i(VALUE etype, VALUE mesg)
+{
+    VALUE exc = rb_exc_new_str(etype, mesg);
+    rb_exc_raise(exc);
+}
+
+static inline void
+rb_raise_cstr(VALUE etype, const char *mesg)
+{
+    VALUE str = rb_str_new_cstr(mesg);
+    rb_raise_cstr_i(etype, str);
+}
+
+static inline void
+rb_name_err_raise_str(VALUE mesg, VALUE recv, VALUE name)
+{
+    VALUE exc = rb_name_err_new(mesg, recv, name);
+    rb_exc_raise(exc);
+}
+
+static inline void
+rb_name_err_raise(const char *mesg, VALUE recv, VALUE name)
+{
+    VALUE str = rb_fstring_cstr(mesg);
+    rb_name_err_raise_str(str, recv, name);
+}
+
+static inline void
+rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name)
+{
+    VALUE exc = rb_key_err_new(mesg, recv, name);
+    rb_exc_raise(exc);
+}
+
+static inline bool
+rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type)
+{
+    return RB_TYPE_P(obj, T_DATA) && RTYPEDDATA_P(obj) && (RTYPEDDATA_TYPE(obj) == data_type);
+}
+
+#endif /* INTERNAL_ERROR_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/eval.h

@@ -0,0 +1,33 @@
+#ifndef INTERNAL_EVAL_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_EVAL_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 evaluator.
+ * @note       There  also  is  eval_intern.h, which  is  evaluator's  internal
+ *             header (related to this file, but not the same role).
+ */
+#include "ruby/ruby.h"          /* for ID */
+
+#define id_signo ruby_static_id_signo
+#define id_status ruby_static_id_status
+
+/* eval.c */
+extern ID ruby_static_id_signo;
+extern ID ruby_static_id_status;
+VALUE rb_refinement_module_get_refined_class(VALUE module);
+void rb_class_modify_check(VALUE);
+NORETURN(VALUE rb_f_raise(int argc, VALUE *argv));
+VALUE rb_top_main_class(const char *method);
+
+/* eval_error.c */
+VALUE rb_get_backtrace(VALUE info);
+
+/* eval_jump.c */
+void rb_call_end_proc(VALUE data);
+void rb_mark_end_proc(void);
+
+#endif /* INTERNAL_EVAL_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/file.h

@@ -0,0 +1,38 @@
+#ifndef INTERNAL_FILE_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_FILE_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 File.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+#include "ruby/encoding.h"      /* for rb_encodinng */
+
+/* file.c */
+extern const char ruby_null_device[];
+VALUE rb_home_dir_of(VALUE user, VALUE result);
+VALUE rb_default_home_dir(VALUE result);
+VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
+VALUE rb_check_realpath(VALUE basedir, VALUE path, rb_encoding *origenc);
+void rb_file_const(const char*, VALUE);
+int rb_file_load_ok(const char *);
+VALUE rb_file_expand_path_fast(VALUE, VALUE);
+VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
+VALUE rb_get_path_check_to_string(VALUE);
+VALUE rb_get_path_check_convert(VALUE);
+int ruby_is_fd_loadable(int fd);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* file.c (export) */
+#ifdef HAVE_READLINK
+VALUE rb_readlink(VALUE path, rb_encoding *enc);
+#endif
+#ifdef __APPLE__
+VALUE rb_str_normalize_ospath(const char *ptr, long len);
+#endif
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* INTERNAL_FILE_H */

data/lib/datadog/ruby_core_source/ruby-3.5.0-preview1/internal/fixnum.h

@@ -0,0 +1,185 @@
+#ifndef INTERNAL_FIXNUM_H                                /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_FIXNUM_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 Fixnums.
+ */
+#include "ruby/internal/config.h"      /* for HAVE_LONG_LONG */
+#include <limits.h>             /* for CHAR_BIT */
+#include "internal/bits.h"      /* for MUL_OVERFLOW_FIXNUM_P */
+#include "internal/compilers.h" /* for __has_builtin */
+#include "ruby/internal/stdbool.h"     /* for bool */
+#include "ruby/intern.h"        /* for rb_big_mul */
+#include "ruby/ruby.h"          /* for RB_FIXABLE */
+
+#if HAVE_LONG_LONG && SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
+# define DLONG LONG_LONG
+# define DL2NUM(x) LL2NUM(x)
+#elif defined(HAVE_INT128_T) && !(defined(__OpenBSD__) && defined(__mips64__))
+# define DLONG int128_t
+# define DL2NUM(x) (RB_FIXABLE(x) ? LONG2FIX(x) : rb_int128t2big(x))
+VALUE rb_int128t2big(int128_t n); /* in bignum.c */
+#endif
+
+static inline long rb_overflowed_fix_to_int(long x);
+static inline VALUE rb_fix_plus_fix(VALUE x, VALUE y);
+static inline VALUE rb_fix_minus_fix(VALUE x, VALUE y);
+static inline VALUE rb_fix_mul_fix(VALUE x, VALUE y);
+static inline void rb_fix_divmod_fix(VALUE x, VALUE y, VALUE *divp, VALUE *modp);
+static inline VALUE rb_fix_div_fix(VALUE x, VALUE y);
+static inline VALUE rb_fix_mod_fix(VALUE x, VALUE y);
+static inline bool FIXNUM_POSITIVE_P(VALUE num);
+static inline bool FIXNUM_NEGATIVE_P(VALUE num);
+static inline bool FIXNUM_ZERO_P(VALUE num);
+
+static inline long
+rb_overflowed_fix_to_int(long x)
+{
+    return (long)((unsigned long)(x >> 1) ^ (1LU << (SIZEOF_LONG * CHAR_BIT - 1)));
+}
+
+static inline VALUE
+rb_fix_plus_fix(VALUE x, VALUE y)
+{
+#if !__has_builtin(__builtin_add_overflow)
+    long lz = FIX2LONG(x) + FIX2LONG(y);
+    return LONG2NUM(lz);
+#else
+    long lz;
+    /* NOTE
+     * (1) `LONG2FIX(FIX2LONG(x)+FIX2LONG(y))`
+     +     = `((lx*2+1)/2 + (ly*2+1)/2)*2+1`
+     +     = `lx*2 + ly*2 + 1`
+     +     = `(lx*2+1) + (ly*2+1) - 1`
+     +     = `x + y - 1`
+     * (2) Fixnum's LSB is always 1.
+     *     It means you can always run `x - 1` without overflow.
+     * (3) Of course `z = x + (y-1)` may overflow.
+     *     At that time true value is
+     *     * positive: 0b0 1xxx...1, and z = 0b1xxx...1
+     *     * negative: 0b1 0xxx...1, and z = 0b0xxx...1
+     *     To convert this true value to long,
+     *     (a) Use arithmetic shift
+     *         * positive: 0b11xxx...
+     *         * negative: 0b00xxx...
+     *     (b) invert MSB
+     *         * positive: 0b01xxx...
+     *         * negative: 0b10xxx...
+     */
+    if (__builtin_add_overflow((long)x, (long)y-1, &lz)) {
+        return rb_int2big(rb_overflowed_fix_to_int(lz));
+    }
+    else {
+        return (VALUE)lz;
+    }
+#endif
+}
+
+static inline VALUE
+rb_fix_minus_fix(VALUE x, VALUE y)
+{
+#if !__has_builtin(__builtin_sub_overflow)
+    long lz = FIX2LONG(x) - FIX2LONG(y);
+    return LONG2NUM(lz);
+#else
+    long lz;
+    if (__builtin_sub_overflow((long)x, (long)y-1, &lz)) {
+        return rb_int2big(rb_overflowed_fix_to_int(lz));
+    }
+    else {
+        return (VALUE)lz;
+    }
+#endif
+}
+
+/* arguments must be Fixnum */
+static inline VALUE
+rb_fix_mul_fix(VALUE x, VALUE y)
+{
+    long lx = FIX2LONG(x);
+    long ly = FIX2LONG(y);
+#ifdef DLONG
+    return DL2NUM((DLONG)lx * (DLONG)ly);
+#else
+    if (MUL_OVERFLOW_FIXNUM_P(lx, ly)) {
+        return rb_big_mul(rb_int2big(lx), rb_int2big(ly));
+    }
+    else {
+        return LONG2FIX(lx * ly);
+    }
+#endif
+}
+
+/*
+ * This behaves different from C99 for negative arguments.
+ * Note that div may overflow fixnum.
+ */
+static inline void
+rb_fix_divmod_fix(VALUE a, VALUE b, VALUE *divp, VALUE *modp)
+{
+    /* assume / and % comply C99.
+     * ldiv(3) won't be inlined by GCC and clang.
+     * I expect / and % are compiled as single idiv.
+     */
+    long x = FIX2LONG(a);
+    long y = FIX2LONG(b);
+    long div, mod;
+    if (x == FIXNUM_MIN && y == -1) {
+        if (divp) *divp = LONG2NUM(-FIXNUM_MIN);
+        if (modp) *modp = LONG2FIX(0);
+        return;
+    }
+    div = x / y;
+    mod = x % y;
+    if (y > 0 ? mod < 0 : mod > 0) {
+        mod += y;
+        div -= 1;
+    }
+    if (divp) *divp = LONG2FIX(div);
+    if (modp) *modp = LONG2FIX(mod);
+}
+
+/* div() for Ruby
+ * This behaves different from C99 for negative arguments.
+ */
+static inline VALUE
+rb_fix_div_fix(VALUE x, VALUE y)
+{
+    VALUE div;
+    rb_fix_divmod_fix(x, y, &div, NULL);
+    return div;
+}
+
+/* mod() for Ruby
+ * This behaves different from C99 for negative arguments.
+ */
+static inline VALUE
+rb_fix_mod_fix(VALUE x, VALUE y)
+{
+    VALUE mod;
+    rb_fix_divmod_fix(x, y, NULL, &mod);
+    return mod;
+}
+
+static inline bool
+FIXNUM_POSITIVE_P(VALUE num)
+{
+    return (SIGNED_VALUE)num > (SIGNED_VALUE)INT2FIX(0);
+}
+
+static inline bool
+FIXNUM_NEGATIVE_P(VALUE num)
+{
+    return (SIGNED_VALUE)num < 0;
+}
+
+static inline bool
+FIXNUM_ZERO_P(VALUE num)
+{
+    return num == INT2FIX(0);
+}
+#endif /* INTERNAL_FIXNUM_H */