debase-ruby_core_source 0.10.14 → 0.10.17

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

@@ -1,10 +1,11 @@
-#ifndef ONIGURUMA_REGPARSE_H
-#define ONIGURUMA_REGPARSE_H
+#ifndef ONIGMO_REGPARSE_H
+#define ONIGMO_REGPARSE_H
 /**********************************************************************
-  regparse.h -  Oniguruma (regular expression library)
+  regparse.h -  Onigmo (Oniguruma-mod) (regular expression library)
 **********************************************************************/
 /*-
  * Copyright (c) 2002-2007  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
+ * Copyright (c) 2011-2016  K.Takata  <kentkt AT csc DOT jp>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,9 +32,7 @@
 
 #include "regint.h"
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility push(default)
-#endif
+RUBY_SYMBOL_EXPORT_BEGIN
 
 /* node type */
 #define NT_STR         0
@@ -68,7 +67,11 @@
                        BIT_NT_CANY | BIT_NT_BREF)) != 0)
 
 #define NTYPE(node)             ((node)->u.base.type)
-#define SET_NTYPE(node, ntype)   (node)->u.base.type = (ntype)
+#define SET_NTYPE(node, ntype) \
+    do { \
+	int value = ntype; \
+	memcpy(&((node)->u.base.type), &value, sizeof(int)); \
+    } while (0)
 
 #define NSTR(node)         (&((node)->u.str))
 #define NCCLASS(node)      (&((node)->u.cclass))
@@ -91,6 +94,8 @@
 #define ENCLOSE_MEMORY           (1<<0)
 #define ENCLOSE_OPTION           (1<<1)
 #define ENCLOSE_STOP_BACKTRACK   (1<<2)
+#define ENCLOSE_CONDITION        (1<<3)
+#define ENCLOSE_ABSENT           (1<<4)
 
 #define NODE_STR_MARGIN         16
 #define NODE_STR_BUF_SIZE       24  /* sizeof(CClassNode) - sizeof(int)*4 */
@@ -100,7 +105,7 @@
 #define NSTR_AMBIG              (1<<1)
 #define NSTR_DONT_GET_OPT_INFO  (1<<2)
 
-#define NSTRING_LEN(node) (OnigDistance)((node)->u.str.end - (node)->u.str.s)
+#define NSTRING_LEN(node) (OnigDistance )((node)->u.str.end - (node)->u.str.s)
 #define NSTRING_SET_RAW(node)          (node)->u.str.flag |= NSTR_RAW
 #define NSTRING_CLEAR_RAW(node)        (node)->u.str.flag &= ~NSTR_RAW
 #define NSTRING_SET_AMBIG(node)        (node)->u.str.flag |= NSTR_AMBIG
@@ -150,6 +155,7 @@
 #define IS_ENCLOSE_STOP_BT_SIMPLE_REPEAT(en) \
     (((en)->state & NST_STOP_BT_SIMPLE_REPEAT) != 0)
 #define IS_ENCLOSE_NAMED_GROUP(en)     (((en)->state & NST_NAMED_GROUP)   != 0)
+#define IS_ENCLOSE_NAME_REF(en)        (((en)->state & NST_NAME_REF)      != 0)
 
 #define SET_CALL_RECURSION(node)       (node)->u.call.state |= NST_RECURSION
 #define IS_CALL_RECURSION(cn)          (((cn)->state & NST_RECURSION)  != 0)
@@ -192,8 +198,8 @@ typedef struct {
   int type;
   int regnum;
   OnigOptionType option;
-  struct _Node*  target;
   AbsAddrType    call_addr;
+  struct _Node*  target;
   /* for multiple call reference */
   OnigDistance min_len; /* min length (byte) */
   OnigDistance max_len; /* max length (byte) */
@@ -240,6 +246,7 @@ typedef struct {
   int type;
   struct _Node* target;
   int char_len;
+  int ascii_range;
 } AnchorNode;
 
 typedef struct {
@@ -252,6 +259,7 @@ typedef struct {
   NodeBase base;
   int ctype;
   int not;
+  int ascii_range;
 } CtypeNode;
 
 typedef struct _Node {
@@ -293,10 +301,10 @@ typedef struct {
   UChar*           error;
   UChar*           error_end;
   regex_t*         reg;       /* for reg->names only */
-  int              num_call;
 #ifdef USE_SUBEXP_CALL
   UnsetAddrList*   unset_addr_list;
 #endif
+  int              num_call;
   int              num_mem;
 #ifdef USE_NAMED_GROUP
   int              num_named;
@@ -310,9 +318,12 @@ typedef struct {
   int curr_max_regnum;
   int has_recursion;
 #endif
+  unsigned int parse_depth;
   int warnings_flag;
+#ifdef RUBY
   const char* sourcefile;
   int sourceline;
+#endif
 } ScanEnv;
 
 
@@ -325,38 +336,35 @@ typedef struct {
   int new_val;
 } GroupNumRemap;
 
-extern int    onig_renumber_name_table P_((regex_t* reg, GroupNumRemap* map));
+extern int    onig_renumber_name_table(regex_t* reg, GroupNumRemap* map);
 #endif
 
-extern int    onig_strncmp P_((const UChar* s1, const UChar* s2, int n));
-extern void   onig_strcpy P_((UChar* dest, const UChar* src, const UChar* end));
-extern void   onig_scan_env_set_error_string P_((ScanEnv* env, int ecode, UChar* arg, UChar* arg_end));
-extern int    onig_scan_unsigned_number P_((UChar** src, const UChar* end, OnigEncoding enc));
-extern void   onig_reduce_nested_quantifier P_((Node* pnode, Node* cnode));
-extern void   onig_node_conv_to_str_node P_((Node* node, int raw));
-extern int    onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end));
-extern int    onig_node_str_set P_((Node* node, const UChar* s, const UChar* end));
-extern void   onig_node_free P_((Node* node));
-extern Node*  onig_node_new_enclose P_((int type));
-extern Node*  onig_node_new_anchor P_((int type));
-extern Node*  onig_node_new_str P_((const UChar* s, const UChar* end));
-extern Node*  onig_node_new_list P_((Node* left, Node* right));
-extern Node*  onig_node_list_add P_((Node* list, Node* x));
-extern Node*  onig_node_new_alt P_((Node* left, Node* right));
-extern void   onig_node_str_clear P_((Node* node));
-extern int    onig_free_node_list P_((void));
-extern int    onig_names_free P_((regex_t* reg));
-extern int    onig_parse_make_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env));
-extern int    onig_free_shared_cclass_table P_((void));
+extern int    onig_strncmp(const UChar* s1, const UChar* s2, int n);
+extern void   onig_strcpy(UChar* dest, const UChar* src, const UChar* end);
+extern void   onig_scan_env_set_error_string(ScanEnv* env, int ecode, UChar* arg, UChar* arg_end);
+extern int    onig_scan_unsigned_number(UChar** src, const UChar* end, OnigEncoding enc);
+extern void   onig_reduce_nested_quantifier(Node* pnode, Node* cnode);
+extern void   onig_node_conv_to_str_node(Node* node, int raw);
+extern int    onig_node_str_cat(Node* node, const UChar* s, const UChar* end);
+extern int    onig_node_str_set(Node* node, const UChar* s, const UChar* end);
+extern void   onig_node_free(Node* node);
+extern Node*  onig_node_new_enclose(int type);
+extern Node*  onig_node_new_anchor(int type);
+extern Node*  onig_node_new_str(const UChar* s, const UChar* end);
+extern Node*  onig_node_new_list(Node* left, Node* right);
+extern Node*  onig_node_list_add(Node* list, Node* x);
+extern Node*  onig_node_new_alt(Node* left, Node* right);
+extern void   onig_node_str_clear(Node* node);
+extern int    onig_names_free(regex_t* reg);
+extern int    onig_parse_make_tree(Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env);
+extern int    onig_free_shared_cclass_table(void);
 
 #ifdef ONIG_DEBUG
-#ifdef USE_NAMED_GROUP
+# ifdef USE_NAMED_GROUP
 extern int onig_print_names(FILE*, regex_t*);
-#endif
+# endif
 #endif
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility pop
-#endif
+RUBY_SYMBOL_EXPORT_END
 
-#endif /* ONIGURUMA_REGPARSE_H */
+#endif /* ONIGMO_REGPARSE_H */

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

@@ -0,0 +1 @@
+#define RUBY_REVISION 67245

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

@@ -0,0 +1,54 @@
+#ifndef RUBY_ASSERT_H
+#define RUBY_ASSERT_H
+
+#include "ruby/ruby.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+NORETURN(void rb_assert_failure(const char *, int, const char *, const char *));
+#ifdef RUBY_FUNCTION_NAME_STRING
+# define RUBY_ASSERT_FAIL(expr) \
+    rb_assert_failure(__FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING, expr)
+#else
+# define RUBY_ASSERT_FAIL(expr) \
+    rb_assert_failure(__FILE__, __LINE__, NULL, expr)
+#endif
+#define RUBY_ASSERT_MESG(expr, mesg) \
+    ((expr) ? (void)0 : RUBY_ASSERT_FAIL(mesg))
+#ifdef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P
+# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \
+    __builtin_choose_expr( \
+	__builtin_constant_p(cond), \
+	__builtin_choose_expr(cond, RUBY_ASSERT_MESG(expr, mesg), (void)0), \
+	RUBY_ASSERT_MESG(!(cond) || (expr), mesg))
+#else
+# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \
+    RUBY_ASSERT_MESG(!(cond) || (expr), mesg)
+#endif
+#define RUBY_ASSERT(expr) RUBY_ASSERT_MESG_WHEN(!RUBY_NDEBUG+0, expr, #expr)
+#define RUBY_ASSERT_WHEN(cond, expr) RUBY_ASSERT_MESG_WHEN(cond, expr, #expr)
+
+#undef assert
+#define assert RUBY_ASSERT
+
+#ifndef RUBY_NDEBUG
+# ifdef NDEBUG
+#   define RUBY_NDEBUG 1
+# else
+#   define RUBY_NDEBUG 0
+# endif
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif

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

@@ -7,24 +7,17 @@ typedef unsigned int rb_atomic_t;
 # define ATOMIC_SET(var, val)  (void)__atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
 # define ATOMIC_INC(var) __atomic_fetch_add(&(var), 1, __ATOMIC_SEQ_CST)
 # define ATOMIC_DEC(var) __atomic_fetch_sub(&(var), 1, __ATOMIC_SEQ_CST)
-# define ATOMIC_OR(var, val) __atomic_or_fetch(&(var), (val), __ATOMIC_SEQ_CST)
+# define ATOMIC_OR(var, val) __atomic_fetch_or(&(var), (val), __ATOMIC_SEQ_CST)
 # define ATOMIC_EXCHANGE(var, val) __atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
 # define ATOMIC_CAS(var, oldval, newval) \
-({ __typeof__(oldval) oldvaldup = (oldval); /* oldval should not be modified */ \
+({ __typeof__(var) oldvaldup = (oldval); /* oldval should not be modified */ \
    __atomic_compare_exchange_n(&(var), &oldvaldup, (newval), 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); \
    oldvaldup; })
 
 # define ATOMIC_SIZE_ADD(var, val) __atomic_fetch_add(&(var), (val), __ATOMIC_SEQ_CST)
 # define ATOMIC_SIZE_SUB(var, val) __atomic_fetch_sub(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_SIZE_INC(var) __atomic_fetch_add(&(var), 1, __ATOMIC_SEQ_CST)
-# define ATOMIC_SIZE_DEC(var) __atomic_fetch_sub(&(var), 1, __ATOMIC_SEQ_CST)
-# define ATOMIC_SIZE_EXCHANGE(var, val) __atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_SIZE_CAS(var, oldval, newval) \
-({ size_t oldvaldup = (oldval); \
-   __atomic_compare_exchange_n(&(var), &oldvaldup, (newval), 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); \
-   oldvaldup; })
 
-# define ATOMIC_PTR_EXCHANGE(var, val) __atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
+# define RUBY_ATOMIC_GENERIC_MACRO 1
 
 #elif defined HAVE_GCC_SYNC_BUILTINS
 /* @shyouhei hack to support atomic operations in case of gcc. Gcc
@@ -35,18 +28,14 @@ typedef unsigned int rb_atomic_t; /* Anything OK */
 # define ATOMIC_SET(var, val)  (void)__sync_lock_test_and_set(&(var), (val))
 # define ATOMIC_INC(var) __sync_fetch_and_add(&(var), 1)
 # define ATOMIC_DEC(var) __sync_fetch_and_sub(&(var), 1)
-# define ATOMIC_OR(var, val) __sync_or_and_fetch(&(var), (val))
+# define ATOMIC_OR(var, val) __sync_fetch_and_or(&(var), (val))
 # define ATOMIC_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
 # define ATOMIC_CAS(var, oldval, newval) __sync_val_compare_and_swap(&(var), (oldval), (newval))
 
 # define ATOMIC_SIZE_ADD(var, val) __sync_fetch_and_add(&(var), (val))
 # define ATOMIC_SIZE_SUB(var, val) __sync_fetch_and_sub(&(var), (val))
-# define ATOMIC_SIZE_INC(var) __sync_fetch_and_add(&(var), 1)
-# define ATOMIC_SIZE_DEC(var) __sync_fetch_and_sub(&(var), 1)
-# define ATOMIC_SIZE_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
-# define ATOMIC_PTR_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
 
-# define ATOMIC_PTR_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
+# define RUBY_ATOMIC_GENERIC_MACRO 1
 
 #elif defined _WIN32
 #if defined _MSC_VER && _MSC_VER > 1200
@@ -77,7 +66,6 @@ rb_w32_atomic_or(volatile rb_atomic_t *var, rb_atomic_t val)
 #endif
 # define ATOMIC_EXCHANGE(var, val) InterlockedExchange(&(var), (val))
 # define ATOMIC_CAS(var, oldval, newval) InterlockedCompareExchange(&(var), (newval), (oldval))
-
 # if defined _MSC_VER && _MSC_VER <= 1200
 static inline rb_atomic_t
 rb_w32_atomic_cas(volatile rb_atomic_t *var, rb_atomic_t oldval, rb_atomic_t newval)
@@ -88,15 +76,15 @@ rb_w32_atomic_cas(volatile rb_atomic_t *var, rb_atomic_t oldval, rb_atomic_t new
 #   define ATOMIC_CAS(var, oldval, newval) rb_w32_atomic_cas(&(var), (oldval), (newval))
 # endif
 # ifdef _M_AMD64
-#  define ATOMIC_SIZE_ADD(var, val) InterlockedExchangeAdd64(&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd64(&(var), -(val))
+#  define ATOMIC_SIZE_ADD(var, val) InterlockedExchangeAdd64((LONG_LONG *)&(var), (val))
+#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd64((LONG_LONG *)&(var), -(LONG)(val))
 #  define ATOMIC_SIZE_INC(var) InterlockedIncrement64(&(var))
 #  define ATOMIC_SIZE_DEC(var) InterlockedDecrement64(&(var))
 #  define ATOMIC_SIZE_EXCHANGE(var, val) InterlockedExchange64(&(var), (val))
-#  define ATOMIC_SIZE_CAS(var, oldval, val) InterlockedCompareExchange64(&(var), (oldval), (val))
+#  define ATOMIC_SIZE_CAS(var, oldval, newval) InterlockedCompareExchange64(&(var), (newval), (oldval))
 # else
 #  define ATOMIC_SIZE_ADD(var, val) InterlockedExchangeAdd((LONG *)&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd((LONG *)&(var), -(val))
+#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd((LONG *)&(var), -(LONG)(val))
 #  define ATOMIC_SIZE_INC(var) InterlockedIncrement((LONG *)&(var))
 #  define ATOMIC_SIZE_DEC(var) InterlockedDecrement((LONG *)&(var))
 #  define ATOMIC_SIZE_EXCHANGE(var, val) InterlockedExchange((LONG *)&(var), (val))
@@ -130,7 +118,7 @@ typedef unsigned int rb_atomic_t;
 
 #else
 typedef int rb_atomic_t;
-#define NEED_RUBY_ATOMIC_EXCHANGE
+#define NEED_RUBY_ATOMIC_OPS
 extern rb_atomic_t ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val);
 extern rb_atomic_t ruby_atomic_compare_and_swap(rb_atomic_t *ptr,
 						rb_atomic_t cmp,
@@ -145,11 +133,9 @@ extern rb_atomic_t ruby_atomic_compare_and_swap(rb_atomic_t *ptr,
 
 # define ATOMIC_SIZE_ADD(var, val) (void)((var) += (val))
 # define ATOMIC_SIZE_SUB(var, val) (void)((var) -= (val))
-# define ATOMIC_SIZE_INC(var) ((var)++)
-# define ATOMIC_SIZE_DEC(var) ((var)--)
-# define ATOMIC_SIZE_EXCHANGE(var, val) atomic_size_exchange(&(var), (val))
+# define ATOMIC_SIZE_EXCHANGE(var, val) ruby_atomic_size_exchange(&(var), (val))
 static inline size_t
-atomic_size_exchange(size_t *ptr, size_t val)
+ruby_atomic_size_exchange(size_t *ptr, size_t val)
 {
     size_t old = *ptr;
     *ptr = val;
@@ -157,18 +143,90 @@ atomic_size_exchange(size_t *ptr, size_t val)
 }
 #endif
 
+#ifndef ATOMIC_SIZE_INC
+# define ATOMIC_SIZE_INC(var) ATOMIC_INC(var)
+#endif
+#ifndef ATOMIC_SIZE_DEC
+# define ATOMIC_SIZE_DEC(var) ATOMIC_DEC(var)
+#endif
+#ifndef ATOMIC_SIZE_EXCHANGE
+# define ATOMIC_SIZE_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
+#endif
 #ifndef ATOMIC_SIZE_CAS
 # define ATOMIC_SIZE_CAS(var, oldval, val) ATOMIC_CAS(var, oldval, val)
 #endif
 
+#if RUBY_ATOMIC_GENERIC_MACRO
+# ifndef ATOMIC_PTR_EXCHANGE
+#   define ATOMIC_PTR_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
+# endif
+# ifndef ATOMIC_PTR_CAS
+#   define ATOMIC_PTR_CAS(var, oldval, newval) ATOMIC_CAS(var, oldval, newval)
+# endif
+
+# ifndef ATOMIC_VALUE_EXCHANGE
+#   define ATOMIC_VALUE_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
+# endif
+# ifndef ATOMIC_VALUE_CAS
+#   define ATOMIC_VALUE_CAS(var, oldval, val) ATOMIC_CAS(var, oldval, val)
+# endif
+#endif
+
 #ifndef ATOMIC_PTR_EXCHANGE
 # if SIZEOF_VOIDP == SIZEOF_SIZE_T
 #   define ATOMIC_PTR_EXCHANGE(var, val) (void *)ATOMIC_SIZE_EXCHANGE(*(size_t *)&(var), (size_t)(val))
+# else
+#   define ATOMIC_PTR_EXCHANGE(var, val) ruby_atomic_ptr_exchange((const void **)&(var), (val))
+static inline void *
+ruby_atomic_ptr_exchange(const void **ptr, const void *val)
+{
+    const void *const old = *ptr;
+    *ptr = val;
+    return (void *)old;
+}
 # endif
 #endif
 #ifndef ATOMIC_PTR_CAS
 # if SIZEOF_VOIDP == SIZEOF_SIZE_T
 #   define ATOMIC_PTR_CAS(var, oldval, val) (void *)ATOMIC_SIZE_CAS(*(size_t *)&(var), (size_t)(oldval), (size_t)(val))
+# else
+#   define ATOMIC_PTR_CAS(var, oldval, val) ruby_atomic_ptr_cas(&(var), (oldval), (val))
+static inline void *
+ruby_atomic_ptr_cas(const void **ptr, const void *oldval, const void *val)
+{
+    const void *const old = *ptr;
+    if (old == oldval) *ptr = val;
+    return (void *)old;
+}
+# endif
+#endif
+
+#ifndef ATOMIC_VALUE_EXCHANGE
+# if SIZEOF_VALUE == SIZEOF_SIZE_T
+#   define ATOMIC_VALUE_EXCHANGE(var, val) ATOMIC_SIZE_EXCHANGE(*(size_t *)&(var), (size_t)(val))
+# else
+#   define ATOMIC_VALUE_EXCHANGE(var, val) ruby_atomic_value_exchange(&(var), (val))
+static inline VALUE
+ruby_atomic_value_exchange(VALUE *ptr, VALUE val)
+{
+    const VALUE old = *ptr;
+    *ptr = val;
+    return old;
+}
+# endif
+#endif
+#ifndef ATOMIC_VALUE_CAS
+# if SIZEOF_VALUE == SIZEOF_SIZE_T
+#   define ATOMIC_VALUE_CAS(var, oldval, val) ATOMIC_SIZE_CAS(*(size_t *)&(var), (size_t)(oldval), (size_t)(val))
+# else
+#   define ATOMIC_VALUE_CAS(var, oldval, val) ruby_atomic_value_cas(&(var), (oldval), (val))
+static inline VALUE
+ruby_atomic_value_cas(VALUE *ptr, VALUE oldval, VALUE val)
+{
+    const VALUE old = *ptr;
+    if (old == oldval) *ptr = val;
+    return old;
+}
 # endif
 #endif
 

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

@@ -43,6 +43,6 @@ int sip_hash_digest_integer(sip_hash *h, const uint8_t *data, size_t data_len, u
 void sip_hash_free(sip_hash *h);
 void sip_hash_dump(sip_hash *h);
 
-uint64_t sip_hash24(const uint8_t key[16], const uint8_t *data, size_t len);
+uint64_t sip_hash13(const uint8_t key[16], const uint8_t *data, size_t len);
 
 #endif

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

@@ -0,0 +1,108 @@
+/**********************************************************************
+
+  symbol.h -
+
+  $Author$
+  created at: Tue Jul  8 15:49:54 JST 2014
+
+  Copyright (C) 2014 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_SYMBOL_H
+#define RUBY_SYMBOL_H 1
+
+#include "id.h"
+
+#define DYNAMIC_ID_P(id) (!(id&ID_STATIC_SYM)&&id>tLAST_OP_ID)
+#define STATIC_ID2SYM(id)  (((VALUE)(id)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
+
+#ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
+#define rb_id2sym(id) \
+    RB_GNUC_EXTENSION_BLOCK(__builtin_constant_p(id) && !DYNAMIC_ID_P(id) ? \
+			    STATIC_ID2SYM(id) : rb_id2sym(id))
+#endif
+
+struct RSymbol {
+    struct RBasic basic;
+    st_index_t hashval;
+    VALUE fstr;
+    ID id;
+};
+
+#define RSYMBOL(obj) (R_CAST(RSymbol)(obj))
+
+#define is_notop_id(id) ((id)>tLAST_OP_ID)
+#define is_local_id(id) (id_type(id)==ID_LOCAL)
+#define is_global_id(id) (id_type(id)==ID_GLOBAL)
+#define is_instance_id(id) (id_type(id)==ID_INSTANCE)
+#define is_attrset_id(id) ((id)==idASET||id_type(id)==ID_ATTRSET)
+#define is_const_id(id) (id_type(id)==ID_CONST)
+#define is_class_id(id) (id_type(id)==ID_CLASS)
+#define is_junk_id(id) (id_type(id)==ID_JUNK)
+
+static inline int
+id_type(ID id)
+{
+    if (is_notop_id(id)) {
+	return (int)(id&ID_SCOPE_MASK);
+    }
+    else {
+	return -1;
+    }
+}
+
+typedef uint32_t rb_id_serial_t;
+
+static inline rb_id_serial_t
+rb_id_to_serial(ID id)
+{
+    if (is_notop_id(id)) {
+	return (rb_id_serial_t)(id >> ID_SCOPE_SHIFT);
+    }
+    else {
+	return (rb_id_serial_t)id;
+    }
+}
+
+static inline int
+sym_type(VALUE sym)
+{
+    ID id;
+    if (STATIC_SYM_P(sym)) {
+	id = RSHIFT(sym, RUBY_SPECIAL_SHIFT);
+	if (id<=tLAST_OP_ID) {
+	    return -1;
+	}
+    }
+    else {
+	id = RSYMBOL(sym)->id;
+    }
+    return (int)(id&ID_SCOPE_MASK);
+}
+
+#define is_local_sym(sym) (sym_type(sym)==ID_LOCAL)
+#define is_global_sym(sym) (sym_type(sym)==ID_GLOBAL)
+#define is_instance_sym(sym) (sym_type(sym)==ID_INSTANCE)
+#define is_attrset_sym(sym) (sym_type(sym)==ID_ATTRSET)
+#define is_const_sym(sym) (sym_type(sym)==ID_CONST)
+#define is_class_sym(sym) (sym_type(sym)==ID_CLASS)
+#define is_junk_sym(sym) (sym_type(sym)==ID_JUNK)
+
+RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
+
+static inline int
+is_global_name_punct(const int c)
+{
+    if (c <= 0x20 || 0x7e < c) return 0;
+    return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
+}
+
+ID rb_intern_cstr_without_pindown(const char *, long, rb_encoding *);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+size_t rb_sym_immortal_count(void);
+
+RUBY_SYMBOL_EXPORT_END
+#endif

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

@@ -11,39 +11,42 @@
 #ifndef RUBY_THREAD_PTHREAD_H
 #define RUBY_THREAD_PTHREAD_H
 
-#include <pthread.h>
 #ifdef HAVE_PTHREAD_NP_H
 #include <pthread_np.h>
 #endif
-typedef pthread_t rb_thread_id_t;
-typedef pthread_mutex_t rb_thread_lock_t;
+
+#define RB_NATIVETHREAD_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
+#define RB_NATIVETHREAD_COND_INIT { PTHREAD_COND_INITIALIZER, }
 
 typedef struct rb_thread_cond_struct {
     pthread_cond_t cond;
 #ifdef HAVE_CLOCKID_T
     clockid_t clockid;
 #endif
-} rb_thread_cond_t;
+} rb_nativethread_cond_t;
 
 typedef struct native_thread_data_struct {
-    void *signal_thread_list;
-    rb_thread_cond_t sleep_cond;
+    struct list_node ubf_list;
+    rb_nativethread_cond_t sleep_cond;
 } native_thread_data_t;
 
-#include <semaphore.h>
+#undef except
+#undef try
+#undef leave
+#undef finally
 
 typedef struct rb_global_vm_lock_struct {
     /* fast path */
     unsigned long acquired;
-    pthread_mutex_t lock;
+    rb_nativethread_lock_t lock;
 
     /* slow path */
     volatile unsigned long waiting;
-    rb_thread_cond_t cond;
+    rb_nativethread_cond_t cond;
 
     /* yield */
-    rb_thread_cond_t switch_cond;
-    rb_thread_cond_t switch_wait_cond;
+    rb_nativethread_cond_t switch_cond;
+    rb_nativethread_cond_t switch_wait_cond;
     int need_yield;
     int wait_yield;
 } rb_global_vm_lock_t;

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

@@ -2,7 +2,7 @@
 
   thread_win32.h -
 
-  $Author: kosaki $
+  $Author: ko1 $
 
   Copyright (C) 2004-2007 Koichi Sasada
 
@@ -12,8 +12,6 @@
 #ifndef RUBY_THREAD_WIN32_H
 #define RUBY_THREAD_WIN32_H
 
-#include <windows.h>
-
 # ifdef __CYGWIN__
 # undef _WIN32
 # endif
@@ -21,12 +19,10 @@
 WINBASEAPI BOOL WINAPI
 TryEnterCriticalSection(IN OUT LPCRITICAL_SECTION lpCriticalSection);
 
-typedef HANDLE rb_thread_id_t;
-typedef CRITICAL_SECTION rb_thread_lock_t;
 typedef struct rb_thread_cond_struct {
     struct cond_event_entry *next;
     struct cond_event_entry *prev;
-} rb_thread_cond_t;
+} rb_nativethread_cond_t;
 
 typedef struct native_thread_data_struct {
     HANDLE interrupt_event;

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

@@ -0,0 +1,42 @@
+#ifndef RUBY_TIMEV_H
+#define RUBY_TIMEV_H
+
+PACKED_STRUCT_UNALIGNED(struct vtm {
+    VALUE year; /* 2000 for example.  Integer. */
+    VALUE subsecx; /* 0 <= subsecx < TIME_SCALE.  possibly Rational. */
+    VALUE utc_offset; /* -3600 as -01:00 for example.  possibly Rational. */
+    const char *zone; /* "JST", "EST", "EDT", etc. */
+    uint16_t yday:9; /* 1..366 */
+    uint8_t mon:4; /* 1..12 */
+    uint8_t mday:5; /* 1..31 */
+    uint8_t hour:5; /* 0..23 */
+    uint8_t min:6; /* 0..59 */
+    uint8_t sec:6; /* 0..60 */
+    uint8_t wday:3; /* 0:Sunday, 1:Monday, ..., 6:Saturday 7:init */
+    uint8_t isdst:2; /* 0:StandardTime 1:DayLightSavingTime 3:init */
+});
+
+#define TIME_SCALE 1000000000
+
+#ifndef TYPEOF_TIMEVAL_TV_SEC
+# define TYPEOF_TIMEVAL_TV_SEC time_t
+#endif
+#ifndef TYPEOF_TIMEVAL_TV_USEC
+# if INT_MAX >= 1000000
+# define TYPEOF_TIMEVAL_TV_USEC int
+# else
+# define TYPEOF_TIMEVAL_TV_USEC long
+# endif
+#endif
+
+#if SIZEOF_TIME_T == SIZEOF_LONG
+typedef unsigned long unsigned_time_t;
+#elif SIZEOF_TIME_T == SIZEOF_INT
+typedef unsigned int unsigned_time_t;
+#elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
+typedef unsigned LONG_LONG unsigned_time_t;
+#else
+# error cannot find integer type which size is same as time_t.
+#endif
+
+#endif