debase-ruby_core_source 0.10.14 → 0.10.17

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/ccan/str/str.h

@@ -0,0 +1,16 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_STR_H
+#define CCAN_STR_H
+/**
+ * stringify - Turn expression into a string literal
+ * @expr: any C expression
+ *
+ * Example:
+ *	#define PRINT_COND_IF_FALSE(cond) \
+ *		((cond) || printf("%s is false!", stringify(cond)))
+ */
+#define stringify(expr)		stringify_1(expr)
+/* Double-indirection required to stringify expansions */
+#define stringify_1(expr)	#expr
+
+#endif /* CCAN_STR_H */

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/constant.h

@@ -0,0 +1,51 @@
+/**********************************************************************
+
+  constant.h -
+
+  $Author$
+  created at: Sun Nov 15 00:09:33 2009
+
+  Copyright (C) 2009 Yusuke Endoh
+
+**********************************************************************/
+#ifndef CONSTANT_H
+#define CONSTANT_H
+
+typedef enum {
+    CONST_DEPRECATED = 0x100,
+
+    CONST_VISIBILITY_MASK = 0xff,
+    CONST_PUBLIC    = 0x00,
+    CONST_PRIVATE,
+    CONST_VISIBILITY_MAX
+} rb_const_flag_t;
+
+#define RB_CONST_PRIVATE_P(ce) \
+    (((ce)->flag & CONST_VISIBILITY_MASK) == CONST_PRIVATE)
+#define RB_CONST_PUBLIC_P(ce) \
+    (((ce)->flag & CONST_VISIBILITY_MASK) == CONST_PUBLIC)
+
+#define RB_CONST_DEPRECATED_P(ce) \
+    ((ce)->flag & CONST_DEPRECATED)
+
+typedef struct rb_const_entry_struct {
+    rb_const_flag_t flag;
+    int line;
+    const VALUE value;            /* should be mark */
+    const VALUE file;             /* should be mark */
+} rb_const_entry_t;
+
+VALUE rb_mod_private_constant(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_mod_public_constant(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_mod_deprecate_constant(int argc, const VALUE *argv, VALUE obj);
+void rb_free_const_table(struct rb_id_table *tbl);
+VALUE rb_public_const_get(VALUE klass, ID id);
+VALUE rb_public_const_get_at(VALUE klass, ID id);
+VALUE rb_public_const_get_from(VALUE klass, ID id);
+int rb_public_const_defined(VALUE klass, ID id);
+int rb_public_const_defined_at(VALUE klass, ID id);
+int rb_public_const_defined_from(VALUE klass, ID id);
+rb_const_entry_t *rb_const_lookup(VALUE klass, ID id);
+int rb_autoloading_value(VALUE mod, ID id, VALUE *value, rb_const_flag_t *flag);
+
+#endif /* CONSTANT_H */

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/debug_counter.h

@@ -0,0 +1,109 @@
+/**********************************************************************
+
+  debug_counter.h -
+
+  created at: Tue Feb 21 16:51:18 2017
+
+  Copyright (C) 2017 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef USE_DEBUG_COUNTER
+#define USE_DEBUG_COUNTER 0
+#endif
+
+#ifdef RB_DEBUG_COUNTER
+
+/* method search */
+RB_DEBUG_COUNTER(mc_inline_hit)
+RB_DEBUG_COUNTER(mc_inline_miss)
+RB_DEBUG_COUNTER(mc_global_hit)
+RB_DEBUG_COUNTER(mc_global_miss)
+RB_DEBUG_COUNTER(mc_global_state_miss)
+RB_DEBUG_COUNTER(mc_class_serial_miss)
+RB_DEBUG_COUNTER(mc_cme_complement)
+RB_DEBUG_COUNTER(mc_cme_complement_hit)
+RB_DEBUG_COUNTER(mc_search_super)
+
+/* ivar access */
+RB_DEBUG_COUNTER(ivar_get_ic_hit)
+RB_DEBUG_COUNTER(ivar_get_ic_miss)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_serial)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_unset)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_noobject)
+RB_DEBUG_COUNTER(ivar_set_ic_hit)
+RB_DEBUG_COUNTER(ivar_set_ic_miss)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_serial)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_unset)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_oorange)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_noobject)
+RB_DEBUG_COUNTER(ivar_get_base)
+RB_DEBUG_COUNTER(ivar_set_base)
+
+/* lvar access */
+RB_DEBUG_COUNTER(lvar_get)
+RB_DEBUG_COUNTER(lvar_get_dynamic)
+RB_DEBUG_COUNTER(lvar_set)
+RB_DEBUG_COUNTER(lvar_set_dynamic)
+RB_DEBUG_COUNTER(lvar_set_slowpath)
+
+/* object counts */
+RB_DEBUG_COUNTER(obj_free)
+
+RB_DEBUG_COUNTER(obj_str_ptr)
+RB_DEBUG_COUNTER(obj_str_embed)
+RB_DEBUG_COUNTER(obj_str_shared)
+RB_DEBUG_COUNTER(obj_str_nofree)
+RB_DEBUG_COUNTER(obj_str_fstr)
+
+RB_DEBUG_COUNTER(obj_ary_ptr)
+RB_DEBUG_COUNTER(obj_ary_embed)
+
+RB_DEBUG_COUNTER(obj_obj_ptr)
+RB_DEBUG_COUNTER(obj_obj_embed)
+
+/* load */
+RB_DEBUG_COUNTER(load_files)
+RB_DEBUG_COUNTER(load_path_is_not_realpath)
+
+#endif
+
+#ifndef RUBY_DEBUG_COUNTER_H
+#define RUBY_DEBUG_COUNTER_H 1
+
+#if !defined(__GNUC__) && USE_DEBUG_COUNTER
+#error "USE_DEBUG_COUNTER is not supported by other than __GNUC__"
+#endif
+
+enum rb_debug_counter_type {
+#define RB_DEBUG_COUNTER(name) RB_DEBUG_COUNTER_##name,
+#include "debug_counter.h"
+    RB_DEBUG_COUNTER_MAX
+#undef RB_DEBUG_COUNTER
+};
+
+#if USE_DEBUG_COUNTER
+#include "ruby/ruby.h"
+
+extern size_t rb_debug_counter[];
+
+inline static int
+rb_debug_counter_add(enum rb_debug_counter_type type, int add, int cond)
+{
+    if (cond) {
+	rb_debug_counter[(int)type] += add;
+    }
+    return cond;
+}
+
+#define RB_DEBUG_COUNTER_INC(type)                rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, 1)
+#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (!rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, !(cond)))
+#define RB_DEBUG_COUNTER_INC_IF(type, cond)       rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, (cond))
+
+#else
+#define RB_DEBUG_COUNTER_INC(type)              ((void)0)
+#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (cond)
+#define RB_DEBUG_COUNTER_INC_IF(type, cond)     (cond)
+#endif
+
+#endif /* RUBY_DEBUG_COUNTER_H */

data/lib/debase/ruby_core_source/{ruby-1.9.3-p550 → ruby-2.5.4-p155}/dln.h

@@ -28,14 +28,17 @@
 # define _(args) ()
 #endif
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility push(default)
+RUBY_SYMBOL_EXPORT_BEGIN
+
+#ifndef DLN_FIND_EXTRA_ARG
+#define DLN_FIND_EXTRA_ARG
+#endif
+#ifndef DLN_FIND_EXTRA_ARG_DECL
+#define DLN_FIND_EXTRA_ARG_DECL
 #endif
 
-DEPRECATED(char *dln_find_exe(const char*,const char*));
-DEPRECATED(char *dln_find_file(const char*,const char*));
-char *dln_find_exe_r(const char*,const char*,char*,size_t);
-char *dln_find_file_r(const char*,const char*,char*,size_t);
+char *dln_find_exe_r(const char*,const char*,char*,size_t DLN_FIND_EXTRA_ARG_DECL);
+char *dln_find_file_r(const char*,const char*,char*,size_t DLN_FIND_EXTRA_ARG_DECL);
 
 #ifdef USE_DLN_A_OUT
 extern char *dln_argv0;
@@ -43,8 +46,6 @@ extern char *dln_argv0;
 
 void *dln_load(const char*);
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility pop
-#endif
+RUBY_SYMBOL_EXPORT_END
 
 #endif

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/encindex.h

@@ -0,0 +1,69 @@
+/**********************************************************************
+
+  encindex.h -
+
+  $Author$
+  created at: Tue Sep 15 13:21:14 JST 2015
+
+  Copyright (C) 2015 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_ENCINDEX_H
+#define RUBY_ENCINDEX_H 1
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+enum ruby_preserved_encindex {
+    RUBY_ENCINDEX_ASCII,
+    RUBY_ENCINDEX_UTF_8,
+    RUBY_ENCINDEX_US_ASCII,
+
+    /* preserved indexes */
+    RUBY_ENCINDEX_UTF_16BE,
+    RUBY_ENCINDEX_UTF_16LE,
+    RUBY_ENCINDEX_UTF_32BE,
+    RUBY_ENCINDEX_UTF_32LE,
+    RUBY_ENCINDEX_UTF_16,
+    RUBY_ENCINDEX_UTF_32,
+    RUBY_ENCINDEX_UTF8_MAC,
+
+    /* for old options of regexp */
+    RUBY_ENCINDEX_EUC_JP,
+    RUBY_ENCINDEX_Windows_31J,
+
+    RUBY_ENCINDEX_BUILTIN_MAX
+};
+
+#define ENCINDEX_ASCII       RUBY_ENCINDEX_ASCII
+#define ENCINDEX_UTF_8       RUBY_ENCINDEX_UTF_8
+#define ENCINDEX_US_ASCII    RUBY_ENCINDEX_US_ASCII
+#define ENCINDEX_UTF_16BE    RUBY_ENCINDEX_UTF_16BE
+#define ENCINDEX_UTF_16LE    RUBY_ENCINDEX_UTF_16LE
+#define ENCINDEX_UTF_32BE    RUBY_ENCINDEX_UTF_32BE
+#define ENCINDEX_UTF_32LE    RUBY_ENCINDEX_UTF_32LE
+#define ENCINDEX_UTF_16      RUBY_ENCINDEX_UTF_16
+#define ENCINDEX_UTF_32      RUBY_ENCINDEX_UTF_32
+#define ENCINDEX_UTF8_MAC    RUBY_ENCINDEX_UTF8_MAC
+#define ENCINDEX_EUC_JP      RUBY_ENCINDEX_EUC_JP
+#define ENCINDEX_Windows_31J RUBY_ENCINDEX_Windows_31J
+#define ENCINDEX_BUILTIN_MAX RUBY_ENCINDEX_BUILTIN_MAX
+
+#define rb_ascii8bit_encindex() RUBY_ENCINDEX_ASCII
+#define rb_utf8_encindex()      RUBY_ENCINDEX_UTF_8
+#define rb_usascii_encindex()   RUBY_ENCINDEX_US_ASCII
+
+int rb_enc_find_index2(const char *name, long len);
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_ENCINDEX_H */

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/eval_intern.h

@@ -0,0 +1,334 @@
+#ifndef RUBY_EVAL_INTERN_H
+#define RUBY_EVAL_INTERN_H
+
+#include "ruby/ruby.h"
+#include "vm_core.h"
+
+static inline void
+vm_passed_block_handler_set(rb_execution_context_t *ec, VALUE block_handler)
+{
+    vm_block_handler_verify(block_handler);
+    ec->passed_block_handler = block_handler;
+}
+
+static inline void
+pass_passed_block_handler(rb_execution_context_t *ec)
+{
+    VALUE block_handler = rb_vm_frame_block_handler(ec->cfp);
+    vm_block_handler_verify(block_handler);
+    vm_passed_block_handler_set(ec, block_handler);
+    VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_PASSED);
+}
+
+#define PASS_PASSED_BLOCK_HANDLER_EC(ec) pass_passed_block_handler(ec)
+#define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_EC())
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+#include <stdio.h>
+#include <setjmp.h>
+
+#ifdef __APPLE__
+# ifdef HAVE_CRT_EXTERNS_H
+#  include <crt_externs.h>
+# else
+#  include "missing/crt_externs.h"
+# endif
+#endif
+
+#ifndef HAVE_STRING_H
+char *strrchr(const char *, const char);
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_NET_SOCKET_H
+#include <net/socket.h>
+#endif
+
+#define ruby_setjmp(env) RUBY_SETJMP(env)
+#define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
+#ifdef __CYGWIN__
+# ifndef _setjmp
+int _setjmp(jmp_buf);
+# endif
+# ifndef _longjmp
+NORETURN(void _longjmp(jmp_buf, int));
+# endif
+#endif
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+/*
+  Solaris sys/select.h switches select to select_large_fdset to support larger
+  file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
+  But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
+  So following definition is required to use select_large_fdset.
+*/
+#ifdef HAVE_SELECT_LARGE_FDSET
+#define select(n, r, w, e, t) select_large_fdset((n), (r), (w), (e), (t))
+extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#include <sys/stat.h>
+
+#ifdef _MSC_VER
+#define SAVE_ROOT_JMPBUF_BEFORE_STMT \
+    __try {
+#define SAVE_ROOT_JMPBUF_AFTER_STMT \
+    } \
+    __except (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW ? \
+	      (rb_ec_raised_set(GET_EC(), RAISED_STACKOVERFLOW), \
+	       raise(SIGSEGV), \
+	       EXCEPTION_EXECUTE_HANDLER) : \
+	      EXCEPTION_CONTINUE_SEARCH) { \
+	/* never reaches here */ \
+    }
+#elif defined(__MINGW32__)
+LONG WINAPI rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *);
+#define SAVE_ROOT_JMPBUF_BEFORE_STMT \
+    do { \
+	PVOID _handler = AddVectoredExceptionHandler(1, rb_w32_stack_overflow_handler);
+
+#define SAVE_ROOT_JMPBUF_AFTER_STMT \
+	RemoveVectoredExceptionHandler(_handler); \
+    } while (0);
+#else
+#define SAVE_ROOT_JMPBUF_BEFORE_STMT
+#define SAVE_ROOT_JMPBUF_AFTER_STMT
+#endif
+
+#define SAVE_ROOT_JMPBUF(th, stmt) do \
+  if (ruby_setjmp((th)->root_jmpbuf) == 0) { \
+      SAVE_ROOT_JMPBUF_BEFORE_STMT \
+      stmt; \
+      SAVE_ROOT_JMPBUF_AFTER_STMT \
+  } \
+  else { \
+      rb_fiber_start(); \
+  } while (0)
+
+#define EC_PUSH_TAG(ec) do { \
+  rb_execution_context_t * const _ec = (ec); \
+  struct rb_vm_tag _tag; \
+  _tag.state = TAG_NONE; \
+  _tag.tag = Qundef; \
+  _tag.prev = _ec->tag;
+
+#define EC_POP_TAG() \
+  _ec->tag = _tag.prev; \
+} while (0)
+
+#define EC_TMPPOP_TAG() \
+  _ec->tag = _tag.prev
+
+#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
+
+#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8) || __clang__
+/* This macro prevents GCC 4.6--4.8 from emitting maybe-uninitialized warnings.
+ * This macro also prevents Clang from dumping core in EC_EXEC_TAG().
+ * (I confirmed Clang 4.0.1 and 5.0.0.)
+ */
+# define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
+# define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
+# define VAR_NOCLOBBERED(var) volatile var
+#else
+# define VAR_FROM_MEMORY(var) (var)
+# define VAR_INITIALIZED(var) ((void)&(var))
+# define VAR_NOCLOBBERED(var) var
+#endif
+
+#if defined(USE_UNALIGNED_MEMBER_ACCESS) && USE_UNALIGNED_MEMBER_ACCESS && \
+    defined(__clang__)
+# define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
+    _Pragma("GCC diagnostic push"); \
+    _Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\""); \
+    typeof(expr) unaligned_member_access_result = (expr); \
+    _Pragma("GCC diagnostic pop"); \
+    unaligned_member_access_result; \
+})
+#else
+# define UNALIGNED_MEMBER_ACCESS(expr) expr
+#endif
+#define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
+
+#undef RB_OBJ_WRITE
+#define RB_OBJ_WRITE(a, slot, b) UNALIGNED_MEMBER_ACCESS(rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__))
+
+/* clear ec->tag->state, and return the value */
+static inline int
+rb_ec_tag_state(const rb_execution_context_t *ec)
+{
+    enum ruby_tag_type state = ec->tag->state;
+    ec->tag->state = TAG_NONE;
+    return state;
+}
+
+NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st));
+static inline void
+rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
+{
+    ec->tag->state = st;
+    ruby_longjmp(ec->tag->buf, 1);
+}
+
+/*
+  setjmp() in assignment expression rhs is undefined behavior
+  [ISO/IEC 9899:1999] 7.13.1.1
+*/
+#define EC_EXEC_TAG() \
+    (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
+
+#define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
+
+#define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
+
+/* CREF operators */
+
+#define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
+#define CREF_FL_OMOD_SHARED    IMEMO_FL_USER2
+
+static inline VALUE
+CREF_CLASS(const rb_cref_t *cref)
+{
+    return cref->klass;
+}
+
+static inline rb_cref_t *
+CREF_NEXT(const rb_cref_t *cref)
+{
+    return cref->next;
+}
+
+static inline const rb_scope_visibility_t *
+CREF_SCOPE_VISI(const rb_cref_t *cref)
+{
+    return &cref->scope_visi;
+}
+
+static inline VALUE
+CREF_REFINEMENTS(const rb_cref_t *cref)
+{
+    return cref->refinements;
+}
+
+static inline void
+CREF_REFINEMENTS_SET(rb_cref_t *cref, VALUE refs)
+{
+    RB_OBJ_WRITE(cref, &cref->refinements, refs);
+}
+
+static inline int
+CREF_PUSHED_BY_EVAL(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_PUSHED_BY_EVAL;
+}
+
+static inline void
+CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_PUSHED_BY_EVAL;
+}
+
+static inline int
+CREF_OMOD_SHARED(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_OMOD_SHARED;
+}
+
+static inline void
+CREF_OMOD_SHARED_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_OMOD_SHARED;
+}
+
+static inline void
+CREF_OMOD_SHARED_UNSET(rb_cref_t *cref)
+{
+    cref->flags &= ~CREF_FL_OMOD_SHARED;
+}
+
+void rb_thread_cleanup(void);
+void rb_thread_wait_other_threads(void);
+
+enum {
+    RAISED_EXCEPTION = 1,
+    RAISED_STACKOVERFLOW = 2,
+    RAISED_NOMEMORY = 4
+};
+#define rb_ec_raised_set(ec, f)   ((ec)->raised_flag |= (f))
+#define rb_ec_raised_reset(ec, f) ((ec)->raised_flag &= ~(f))
+#define rb_ec_raised_p(ec, f)    (((ec)->raised_flag & (f)) != 0)
+#define rb_ec_raised_clear(ec)    ((ec)->raised_flag = 0)
+int rb_ec_set_raised(rb_execution_context_t *ec);
+int rb_ec_reset_raised(rb_execution_context_t *ec);
+int rb_ec_stack_check(rb_execution_context_t *ec);
+
+VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
+VALUE rb_make_exception(int argc, const VALUE *argv);
+
+NORETURN(void rb_method_name_error(VALUE, VALUE));
+
+NORETURN(void rb_fiber_start(void));
+
+NORETURN(void rb_print_undef(VALUE, ID, rb_method_visibility_t));
+NORETURN(void rb_print_undef_str(VALUE, VALUE));
+NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
+NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
+#if 0
+NORETURN(void rb_vm_jump_tag_but_local_jump(int));
+#endif
+
+VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
+rb_cref_t *rb_vm_cref(void);
+rb_cref_t *rb_vm_cref_replace_with_duplicated_cref(void);
+VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename);
+void rb_vm_set_progname(VALUE filename);
+void rb_thread_terminate_all(void);
+VALUE rb_vm_cbase(void);
+
+/* vm_backtrace.c */
+VALUE rb_ec_backtrace_object(const rb_execution_context_t *ec);
+VALUE rb_ec_backtrace_str_ary(const rb_execution_context_t *ec, long lev, long n);
+
+#ifndef CharNext		/* defined as CharNext[AW] on Windows. */
+# ifdef HAVE_MBLEN
+#  define CharNext(p) ((p) + mblen((p), RUBY_MBCHAR_MAXSIZE))
+# else
+#  define CharNext(p) ((p) + 1)
+# endif
+#endif
+
+#if defined DOSISH || defined __CYGWIN__
+static inline void
+translit_char(char *p, int from, int to)
+{
+    while (*p) {
+	if ((unsigned char)*p == from)
+	    *p = to;
+	p = CharNext(p);
+    }
+}
+#endif
+
+#endif /* RUBY_EVAL_INTERN_H */

data/lib/debase/ruby_core_source/{ruby-1.9.3-p550 → ruby-2.5.4-p155}/gc.h

@@ -2,10 +2,10 @@
 #ifndef RUBY_GC_H
 #define RUBY_GC_H 1
 
-#if defined(__x86_64__) && defined(__GNUC__)
-#define SET_MACHINE_STACK_END(p) __asm__ volatile ("movq\t%%rsp, %0" : "=r" (*(p)))
+#if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movq\t%%rsp, %0" : "=r" (*(p)))
 #elif defined(__i386) && defined(__GNUC__)
-#define SET_MACHINE_STACK_END(p) __asm__ volatile ("movl\t%%esp, %0" : "=r" (*(p)))
+#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movl\t%%esp, %0" : "=r" (*(p)))
 #else
 NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
 #define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
@@ -57,7 +57,10 @@ rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
 #define RUBY_GC_INFO if(0)printf
 #endif
 
-#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
+#define RUBY_MARK_UNLESS_NULL(ptr) do { \
+    VALUE markobj = (ptr); \
+    if (RTEST(markobj)) {rb_gc_mark(markobj);} \
+} while (0)
 #define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
 
 #if STACK_GROW_DIRECTION > 0
@@ -83,17 +86,31 @@ int ruby_get_stack_grow_direction(volatile VALUE *addr);
 #endif
 #define IS_STACK_DIR_UPPER() STACK_DIR_UPPER(1,0)
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility push(default)
-#endif
+const char *rb_obj_info(VALUE obj);
+const char *rb_raw_obj_info(char *buff, const int buff_size, VALUE obj);
+void rb_obj_info_dump(VALUE obj);
+
+struct rb_thread_struct;
 
+RUBY_SYMBOL_EXPORT_BEGIN
+
+/* exports for objspace module */
 size_t rb_objspace_data_type_memsize(VALUE obj);
+void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
+void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *data);
+int rb_objspace_markable_object_p(VALUE obj);
+int rb_objspace_internal_object_p(VALUE obj);
+int rb_objspace_marked_object_p(VALUE obj);
+int rb_objspace_garbage_object_p(VALUE obj);
+
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
     void *data);
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility pop
-#endif
+void rb_objspace_each_objects_without_setup(
+    int (*callback)(void *, void *, size_t, void *),
+    void *data);
+
+RUBY_SYMBOL_EXPORT_END
 
 #endif /* RUBY_GC_H */