debase-ruby_core_source 3.3.0 → 3.3.5

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/shape.h

@@ -0,0 +1,233 @@
+#ifndef RUBY_SHAPE_H
+#define RUBY_SHAPE_H
+
+#include "internal/gc.h"
+
+#if (SIZEOF_UINT64_T <= SIZEOF_VALUE)
+
+#define SIZEOF_SHAPE_T 4
+#define SHAPE_IN_BASIC_FLAGS 1
+typedef uint32_t attr_index_t;
+typedef uint32_t shape_id_t;
+# define SHAPE_ID_NUM_BITS 32
+
+#else
+
+#define SIZEOF_SHAPE_T 2
+#define SHAPE_IN_BASIC_FLAGS 0
+typedef uint16_t attr_index_t;
+typedef uint16_t shape_id_t;
+# define SHAPE_ID_NUM_BITS 16
+
+#endif
+
+typedef uint32_t redblack_id_t;
+
+#define MAX_IVARS (attr_index_t)(-1)
+
+# define SHAPE_MASK (((uintptr_t)1 << SHAPE_ID_NUM_BITS) - 1)
+# define SHAPE_FLAG_MASK (((VALUE)-1) >> SHAPE_ID_NUM_BITS)
+
+# define SHAPE_FLAG_SHIFT ((SIZEOF_VALUE * 8) - SHAPE_ID_NUM_BITS)
+
+# define SHAPE_MAX_VARIATIONS 8
+
+# define INVALID_SHAPE_ID SHAPE_MASK
+# define ROOT_SHAPE_ID 0x0
+
+# define SPECIAL_CONST_SHAPE_ID (SIZE_POOL_COUNT * 2)
+# define OBJ_TOO_COMPLEX_SHAPE_ID (SPECIAL_CONST_SHAPE_ID + 1)
+
+typedef struct redblack_node redblack_node_t;
+
+struct rb_shape {
+    struct rb_id_table * edges; // id_table from ID (ivar) to next shape
+    ID edge_name; // ID (ivar) for transition from parent to rb_shape
+    attr_index_t next_iv_index;
+    uint32_t capacity; // Total capacity of the object with this shape
+    uint8_t type;
+    uint8_t size_pool_index;
+    shape_id_t parent_id;
+    redblack_node_t * ancestor_index;
+};
+
+typedef struct rb_shape rb_shape_t;
+
+struct redblack_node {
+    ID key;
+    rb_shape_t * value;
+    redblack_id_t l;
+    redblack_id_t r;
+};
+
+enum shape_type {
+    SHAPE_ROOT,
+    SHAPE_IVAR,
+    SHAPE_FROZEN,
+    SHAPE_T_OBJECT,
+    SHAPE_OBJ_TOO_COMPLEX,
+};
+
+typedef struct {
+    /* object shapes */
+    rb_shape_t *shape_list;
+    rb_shape_t *root_shape;
+    shape_id_t next_shape_id;
+
+    redblack_node_t *shape_cache;
+    unsigned int cache_size;
+} rb_shape_tree_t;
+RUBY_EXTERN rb_shape_tree_t *rb_shape_tree_ptr;
+
+static inline rb_shape_tree_t *
+rb_current_shape_tree(void)
+{
+    return rb_shape_tree_ptr;
+}
+#define GET_SHAPE_TREE() rb_current_shape_tree()
+
+static inline shape_id_t
+get_shape_id_from_flags(VALUE obj)
+{
+    RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
+    return (shape_id_t)(SHAPE_MASK & ((RBASIC(obj)->flags) >> SHAPE_FLAG_SHIFT));
+}
+
+static inline void
+set_shape_id_in_flags(VALUE obj, shape_id_t shape_id)
+{
+    // Ractors are occupying the upper 32 bits of flags, but only in debug mode
+    // Object shapes are occupying top bits
+    RBASIC(obj)->flags &= SHAPE_FLAG_MASK;
+    RBASIC(obj)->flags |= ((VALUE)(shape_id) << SHAPE_FLAG_SHIFT);
+}
+
+
+#if SHAPE_IN_BASIC_FLAGS
+static inline shape_id_t
+RBASIC_SHAPE_ID(VALUE obj)
+{
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+RBASIC_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    set_shape_id_in_flags(obj, shape_id);
+}
+#endif
+
+static inline shape_id_t
+ROBJECT_SHAPE_ID(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+ROBJECT_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    set_shape_id_in_flags(obj, shape_id);
+}
+
+static inline shape_id_t
+RCLASS_SHAPE_ID(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, T_CLASS) || RB_TYPE_P(obj, T_MODULE));
+    return get_shape_id_from_flags(obj);
+}
+
+static inline void
+RCLASS_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, T_CLASS) || RB_TYPE_P(obj, T_MODULE));
+    set_shape_id_in_flags(obj, shape_id);
+}
+
+rb_shape_t * rb_shape_get_root_shape(void);
+int32_t rb_shape_id_offset(void);
+
+rb_shape_t * rb_shape_get_parent(rb_shape_t * shape);
+
+rb_shape_t* rb_shape_get_shape_by_id(shape_id_t shape_id);
+shape_id_t rb_shape_get_shape_id(VALUE obj);
+rb_shape_t * rb_shape_get_next_iv_shape(rb_shape_t * shape, ID id);
+bool rb_shape_get_iv_index(rb_shape_t * shape, ID id, attr_index_t * value);
+bool rb_shape_get_iv_index_with_hint(shape_id_t shape_id, ID id, attr_index_t * value, shape_id_t *shape_id_hint);
+bool rb_shape_obj_too_complex(VALUE obj);
+
+void rb_shape_set_shape(VALUE obj, rb_shape_t* shape);
+rb_shape_t* rb_shape_get_shape(VALUE obj);
+int rb_shape_frozen_shape_p(rb_shape_t* shape);
+rb_shape_t* rb_shape_transition_shape_frozen(VALUE obj);
+bool rb_shape_transition_shape_remove_ivar(VALUE obj, ID id, rb_shape_t *shape, VALUE * removed);
+rb_shape_t* rb_shape_get_next(rb_shape_t* shape, VALUE obj, ID id);
+rb_shape_t* rb_shape_get_next_no_warnings(rb_shape_t* shape, VALUE obj, ID id);
+
+rb_shape_t * rb_shape_rebuild_shape(rb_shape_t * initial_shape, rb_shape_t * dest_shape);
+
+static inline uint32_t
+ROBJECT_IV_CAPACITY(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    // Asking for capacity doesn't make sense when the object is using
+    // a hash table for storing instance variables
+    RUBY_ASSERT(!rb_shape_obj_too_complex(obj));
+    return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->capacity;
+}
+
+static inline st_table *
+ROBJECT_IV_HASH(VALUE obj)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
+    return (st_table *)ROBJECT(obj)->as.heap.ivptr;
+}
+
+static inline void
+ROBJECT_SET_IV_HASH(VALUE obj, const st_table *tbl)
+{
+    RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
+    ROBJECT(obj)->as.heap.ivptr = (VALUE *)tbl;
+}
+
+size_t rb_id_table_size(const struct rb_id_table *tbl);
+
+static inline uint32_t
+ROBJECT_IV_COUNT(VALUE obj)
+{
+    if (rb_shape_obj_too_complex(obj)) {
+        return (uint32_t)rb_st_table_size(ROBJECT_IV_HASH(obj));
+    }
+    else {
+        RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
+        RUBY_ASSERT(!rb_shape_obj_too_complex(obj));
+        return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->next_iv_index;
+    }
+}
+
+static inline uint32_t
+RBASIC_IV_COUNT(VALUE obj)
+{
+    return rb_shape_get_shape_by_id(rb_shape_get_shape_id(obj))->next_iv_index;
+}
+
+rb_shape_t *rb_shape_traverse_from_new_root(rb_shape_t *initial_shape, rb_shape_t *orig_shape);
+
+bool rb_shape_set_shape_id(VALUE obj, shape_id_t shape_id);
+
+VALUE rb_obj_debug_shape(VALUE self, VALUE obj);
+
+// For ext/objspace
+RUBY_SYMBOL_EXPORT_BEGIN
+typedef void each_shape_callback(rb_shape_t * shape, void *data);
+void rb_shape_each_shape(each_shape_callback callback, void *data);
+size_t rb_shape_memsize(rb_shape_t *shape);
+size_t rb_shape_edges_count(rb_shape_t *shape);
+size_t rb_shape_depth(rb_shape_t *shape);
+shape_id_t rb_shape_id(rb_shape_t * shape);
+RUBY_SYMBOL_EXPORT_END
+
+#endif

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/siphash.h

@@ -0,0 +1,48 @@
+#ifndef SIPHASH_H
+#define SIPHASH_H 1
+#include <stdlib.h>
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+
+#ifndef HAVE_UINT64_T
+typedef struct {
+    uint32_t u32[2];
+} sip_uint64_t;
+#define uint64_t sip_uint64_t
+#else
+typedef uint64_t sip_uint64_t;
+#endif
+
+typedef struct {
+    int c;
+    int d;
+    uint64_t v[4];
+    uint8_t buf[sizeof(uint64_t)];
+    uint8_t buflen;
+    uint8_t msglen_byte;
+} sip_state;
+
+typedef struct sip_interface_st sip_interface;
+
+typedef struct {
+    sip_state state[1];
+    const sip_interface *methods;
+} sip_hash;
+
+sip_hash *sip_hash_new(const uint8_t key[16], int c, int d);
+sip_hash *sip_hash_init(sip_hash *h, const uint8_t key[16], int c, int d);
+int sip_hash_update(sip_hash *h, const uint8_t *data, size_t len);
+int sip_hash_final(sip_hash *h, uint8_t **digest, size_t *len);
+int sip_hash_final_integer(sip_hash *h, uint64_t *digest);
+int sip_hash_digest(sip_hash *h, const uint8_t *data, size_t data_len, uint8_t **digest, size_t *digest_len);
+int sip_hash_digest_integer(sip_hash *h, const uint8_t *data, size_t data_len, uint64_t *digest);
+void sip_hash_free(sip_hash *h);
+void sip_hash_dump(sip_hash *h);
+
+NO_SANITIZE("unsigned-integer-overflow", uint64_t sip_hash13(const uint8_t key[16], const uint8_t *data, size_t len));
+
+#endif

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/symbol.h

@@ -0,0 +1,118 @@
+#ifndef RUBY_SYMBOL_H
+#define RUBY_SYMBOL_H 1
+/**********************************************************************
+
+  symbol.h -
+
+  $Author$
+  created at: Tue Jul  8 15:49:54 JST 2014
+
+  Copyright (C) 2014 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#include "id.h"
+#include "ruby/encoding.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) ((struct 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 const uint32_t RB_ID_SERIAL_MAX = /* 256M on LP32 */
+    UINT32_MAX >>
+    ((sizeof(ID)-sizeof(rb_id_serial_t))*CHAR_BIT < RUBY_ID_SCOPE_SHIFT ?
+     RUBY_ID_SCOPE_SHIFT : 0);
+
+typedef struct {
+    rb_id_serial_t last_id;
+    st_table *str_sym;
+    VALUE ids;
+    VALUE dsymbol_fstr_hash;
+} rb_symbols_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 uint_least32_t 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;
+}
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset);
+size_t rb_sym_immortal_count(void);
+
+RUBY_SYMBOL_EXPORT_END
+#endif

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/thread_none.h

@@ -0,0 +1,21 @@
+#ifndef RUBY_THREAD_NONE_H
+#define RUBY_THREAD_NONE_H
+
+#define RB_NATIVETHREAD_LOCK_INIT (void)(0)
+#define RB_NATIVETHREAD_COND_INIT (void)(0)
+
+// no-thread impl doesn't use TLS but define this to avoid using tls key
+// based implementation in vm.c
+#define RB_THREAD_LOCAL_SPECIFIER
+
+struct rb_native_thread {
+    void *thread_id; // NULL
+};
+
+struct rb_thread_sched_item {};
+struct rb_thread_sched {};
+
+RUBY_EXTERN struct rb_execution_context_struct *ruby_current_ec;
+NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void)); // for assertions
+
+#endif /* RUBY_THREAD_NONE_H */

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/thread_pthread.h

@@ -0,0 +1,166 @@
+#ifndef RUBY_THREAD_PTHREAD_H
+#define RUBY_THREAD_PTHREAD_H
+/**********************************************************************
+
+  thread_pthread.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifdef HAVE_PTHREAD_NP_H
+#include <pthread_np.h>
+#endif
+
+#define RB_NATIVETHREAD_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
+#define RB_NATIVETHREAD_COND_INIT PTHREAD_COND_INITIALIZER
+
+// per-Thead scheduler helper data
+struct rb_thread_sched_item {
+    struct {
+        struct ccan_list_node ubf;
+
+        // connected to ractor->threads.sched.reqdyq
+        // locked by ractor->threads.sched.lock
+        struct ccan_list_node readyq;
+
+        // connected to vm->ractor.sched.timeslice_threads
+        // locked by vm->ractor.sched.lock
+        struct ccan_list_node timeslice_threads;
+
+        // connected to vm->ractor.sched.running_threads
+        // locked by vm->ractor.sched.lock
+        struct ccan_list_node running_threads;
+
+        // connected to vm->ractor.sched.zombie_threads
+        struct ccan_list_node zombie_threads;
+    } node;
+
+    // this data should be protected by timer_th.waiting_lock
+    struct {
+        enum thread_sched_waiting_flag {
+            thread_sched_waiting_none     = 0x00,
+            thread_sched_waiting_timeout  = 0x01,
+            thread_sched_waiting_io_read  = 0x02,
+            thread_sched_waiting_io_write = 0x08,
+            thread_sched_waiting_io_force = 0x40, // ignore readable
+        } flags;
+
+        struct {
+            // should be compat with hrtime.h
+#ifdef MY_RUBY_BUILD_MAY_TIME_TRAVEL
+            int128_t timeout;
+#else
+            uint64_t timeout;
+#endif
+            int fd; // -1 for timeout only
+            int result;
+        } data;
+
+        // connected to timer_th.waiting
+        struct ccan_list_node node;
+    } waiting_reason;
+
+    bool finished;
+    bool malloc_stack;
+    void *context_stack;
+    struct coroutine_context *context;
+};
+
+struct rb_native_thread {
+    rb_atomic_t serial;
+    struct rb_vm_struct *vm;
+
+    rb_nativethread_id_t thread_id;
+
+#ifdef RB_THREAD_T_HAS_NATIVE_ID
+    int tid;
+#endif
+
+    struct rb_thread_struct *running_thread;
+
+    // to control native thread
+#if defined(__GLIBC__) || defined(__FreeBSD__)
+    union
+#else
+    /*
+     * assume the platform condvars are badly implemented and have a
+     * "memory" of which mutex they're associated with
+     */
+    struct
+#endif
+      {
+        rb_nativethread_cond_t intr; /* th->interrupt_lock */
+        rb_nativethread_cond_t readyq; /* use sched->lock */
+    } cond;
+
+#ifdef USE_SIGALTSTACK
+    void *altstack;
+#endif
+
+    struct coroutine_context *nt_context;
+    int dedicated;
+
+    size_t machine_stack_maxsize;
+};
+
+#undef except
+#undef try
+#undef leave
+#undef finally
+
+// per-Ractor
+struct rb_thread_sched {
+    rb_nativethread_lock_t lock_;
+#if VM_CHECK_MODE
+    struct rb_thread_struct *lock_owner;
+#endif
+    struct rb_thread_struct *running; // running thread or NULL
+    bool is_running;
+    bool is_running_timeslice;
+    bool enable_mn_threads;
+
+    struct ccan_list_head readyq;
+    int readyq_cnt;
+    // ractor scheduling
+    struct ccan_list_node grq_node;
+};
+
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  NOINLINE(void rb_current_ec_set(struct rb_execution_context_struct *));
+  NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
+
+  # ifdef __APPLE__
+    // on Darwin, TLS can not be accessed across .so
+    NOINLINE(struct rb_execution_context_struct *rb_current_ec(void));
+  # else
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER struct rb_execution_context_struct *ruby_current_ec;
+
+    // for RUBY_DEBUG_LOG()
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER rb_atomic_t ruby_nt_serial;
+    #define RUBY_NT_SERIAL 1
+  # endif
+#else
+typedef pthread_key_t native_tls_key_t;
+
+static inline void *
+native_tls_get(native_tls_key_t key)
+{
+    // return value should be checked by caller
+    return pthread_getspecific(key);
+}
+
+static inline void
+native_tls_set(native_tls_key_t key, void *ptr)
+{
+    if (UNLIKELY(pthread_setspecific(key, ptr) != 0)) {
+        rb_bug("pthread_setspecific error");
+    }
+}
+
+RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
+#endif
+
+#endif /* RUBY_THREAD_PTHREAD_H */

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/thread_win32.h

@@ -0,0 +1,58 @@
+#ifndef RUBY_THREAD_WIN32_H
+#define RUBY_THREAD_WIN32_H
+/**********************************************************************
+
+  thread_win32.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+/* interface */
+
+# ifdef __CYGWIN__
+# undef _WIN32
+# endif
+
+#define USE_VM_CLOCK 1
+
+WINBASEAPI BOOL WINAPI
+TryEnterCriticalSection(IN OUT LPCRITICAL_SECTION lpCriticalSection);
+
+struct rb_native_thread {
+    HANDLE thread_id;
+    HANDLE interrupt_event;
+};
+
+struct rb_thread_sched_item {
+    void *vm_stack;
+};
+
+struct rb_thread_sched {
+    HANDLE lock;
+};
+
+typedef DWORD native_tls_key_t; // TLS index
+
+static inline void *
+native_tls_get(native_tls_key_t key)
+{
+    // return value should be checked by caller.
+    return TlsGetValue(key);
+}
+
+static inline void
+native_tls_set(native_tls_key_t key, void *ptr)
+{
+    if (UNLIKELY(TlsSetValue(key, ptr) == 0)) {
+        rb_bug("TlsSetValue() error");
+    }
+}
+
+RUBY_SYMBOL_EXPORT_BEGIN
+RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* RUBY_THREAD_WIN32_H */

data/lib/debase/ruby_core_source/ruby-3.3.5-p100/timev.h

@@ -0,0 +1,58 @@
+#ifndef RUBY_TIMEV_H
+#define RUBY_TIMEV_H
+#include "ruby/ruby.h"
+
+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. */
+    VALUE zone; /* "JST", "EST", "EDT", etc. as String */
+    unsigned int yday:9; /* 1..366 */
+    unsigned int mon:4; /* 1..12 */
+    unsigned int mday:5; /* 1..31 */
+    unsigned int hour:5; /* 0..23 */
+    unsigned int min:6; /* 0..59 */
+    unsigned int sec:6; /* 0..60 */
+    unsigned int wday:3; /* 0:Sunday, 1:Monday, ..., 6:Saturday 7:init */
+    unsigned int isdst:2; /* 0:StandardTime 1:DayLightSavingTime 3:init */
+
+    /* Flags for struct time_object */
+    unsigned int tzmode:3; /* 0:localtime 1:utc 2:fixoff 3:uninitialized */
+    unsigned int tm_got:1;
+};
+
+#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
+
+/* strftime.c */
+#ifdef RUBY_ENCODING_H
+VALUE rb_strftime_timespec(const char *format, size_t format_len, rb_encoding *enc,
+                           VALUE time, const struct vtm *vtm, struct timespec *ts, int gmt);
+VALUE rb_strftime(const char *format, size_t format_len, rb_encoding *enc,
+                  VALUE time, const struct vtm *vtm, VALUE timev, int gmt);
+#endif
+
+/* time.c */
+VALUE rb_time_zone_abbreviation(VALUE zone, VALUE time);
+
+#endif