debase-ruby_core_source 4.0.1 → 4.1.0.preview1

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/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-4.1.0-preview1/symbol.h

@@ -0,0 +1,116 @@
+#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_internal_id(id) (id_type(id)==ID_INTERNAL)
+
+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);
+
+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_internal_sym(sym) (sym_type(sym)==ID_INTERNAL)
+
+#ifndef RIPPER
+RUBY_FUNC_EXPORTED
+#else
+RUBY_EXTERN
+#endif
+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, rb_len_t 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-4.1.0-preview1/thread_none.h

@@ -0,0 +1,25 @@
+#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
+
+// This model brings its own scheduler stubs (thread_none.c) instead of the
+// common one; thread.c keys off this.
+#define RB_THREAD_SCHED_NONE 1
+
+// The scheduler's types are shared with the threaded platforms: the code that
+// reads them (vm_sync.c, ractor.c, thread.c) is compiled for every thread
+// model, so it needs the real fields even here, where nothing ever runs
+// concurrently and they all stay zero.  thread_none.c only ever passes the
+// structs around, never looks inside them.
+#include "thread_sched.h"
+
+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-4.1.0-preview1/thread_pthread.h

@@ -0,0 +1,63 @@
+#ifndef RUBY_THREAD_PTHREAD_H
+#define RUBY_THREAD_PTHREAD_H
+/**********************************************************************
+
+  thread_pthread.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+  This platform runs the common scheduler; see thread_sched.h for its data
+  structures and thread_sched.c for the implementation.
+
+**********************************************************************/
+
+#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
+
+// TLS can not be accessed across .so on arm64 and perhaps ppc64le too.
+#if defined(__arm64__) || defined(__aarch64__) || defined(__powerpc64__)
+# define RB_THREAD_CURRENT_EC_NOINLINE
+#endif
+
+#include "thread_sched.h"
+
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  NOINLINE(void rb_current_ec_set(struct rb_execution_context_struct *));
+
+  # ifdef RB_THREAD_CURRENT_EC_NOINLINE
+    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-4.1.0-preview1/thread_sched.h

@@ -0,0 +1,271 @@
+#ifndef RUBY_THREAD_SCHED_H
+#define RUBY_THREAD_SCHED_H
+/**********************************************************************
+
+  thread_sched.h - data structures of the thread/ractor scheduler
+
+  The scheduler itself lives in thread_sched.c and is shared by every
+  platform.  This header holds the types it works on; it is included from
+  the platform header (thread_pthread.h / thread_win32.h), which adds the
+  platform specific members and the thread local storage plumbing.
+
+  == platform primitive layer ==
+
+  thread_sched.c is built on top of the following, which the platform
+  implementation (THREAD_IMPL_SRC) has to provide before including it:
+
+    * rb_native_mutex_*() / rb_native_cond_*()   (ruby/thread_native.h)
+    * native_thread_create0() / native_thread_destroy() and friends
+    * native_thread_interrupt()   -- poke a thread out of a blocking call
+    * timer_thread_polling()      -- the timer thread's blocking wait
+    * timer_thread_wakeup_force() -- wake that wait up
+    * TIMER_THREAD_CREATED_P()
+    * USE_MN_THREADS              -- 1 enables the M:N scheduler
+      (when 0 the platform supplies the stubs listed at the bottom of
+       thread_sched_mn.c)
+
+**********************************************************************/
+
+// How a thread_sched_wait_events() wait ended.  "unavailable" (could not be
+// registered) is not "the event fired": the caller must fall back, not proceed.
+enum thread_sched_wait_result {
+    thread_sched_wait_event,       // an event the caller asked for fired
+    thread_sched_wait_timeout,     // the timeout expired before any event
+    thread_sched_wait_unavailable, // not registered; the caller must fall back
+};
+
+// this data should be protected by timer_th.waiting_lock
+struct rb_thread_sched_waiting {
+    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
+        uint32_t event_serial;
+        int fd; // -1 for timeout only
+        int result;
+    } data;
+
+    // connected to a timer_th wheel slot (timed) or timer_th.waiting_untimed
+    struct ccan_list_node node;
+
+    /* which wheel slot `node` is on; meaningful only while flags has
+     * thread_sched_waiting_timeout */
+    uint8_t wheel_lvl;
+    uint8_t wheel_slot;
+
+    // connected to rb_fd_waiters.waiters of data.fd
+    struct ccan_list_node fd_node;
+};
+
+// One entry per fd with waiters; fds stay dense, so a table indexed by fd fits.
+// Entries live in fixed chunks: growing must not move a live list head.
+struct rb_fd_waiters {
+    struct ccan_list_head waiters; // rb_thread_sched_waiting.fd_node
+
+    // The io flags currently armed in epoll/kqueue for this fd: the union of
+    // what its waiters asked for.
+    uint32_t armed_flags;
+
+    // epoll only: the fd is in the interest set (kept across oneshot disarms).
+    bool registered;
+
+    // Bumped on full disarm.  Events carry the generation they were armed with,
+    // so one queued before the fd was disarmed (and reused) is recognised.
+    uint32_t generation;
+};
+
+// per-Thread 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;
+        // Indicates whether thread is on the readyq.
+        // There is no clear relationship between this and th->status.
+        bool is_ready;
+
+    } node;
+
+    struct rb_thread_sched_waiting waiting_reason;
+    uint32_t event_serial;
+
+    // wakes pending on this thread (timer thread or an fd shard claim);
+    // under timer_th.wake_pending_lock
+    uint32_t wake_pending_cnt;
+
+    // parked on its own condvar with a deadline; under the sched lock (see
+    // ubf_waiting).  Always false for an M:N thread: its deadline lives on the
+    // timer wheel, and its early wake comes from the timer thread instead.
+    bool waiting_timed;
+
+    bool malloc_stack;
+    void *context_stack;
+    size_t context_stack_size;
+    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
+
+#if defined(_WIN32)
+    // signalled by native_thread_interrupt() to break this thread out of a
+    // blocking w32_wait_events()
+    HANDLE interrupt_event;
+    // a high-resolution timer that ends a timed wait on readyq at its
+    // deadline rather than at the next timer tick (NULL if unavailable)
+    HANDLE wait_timer;
+#endif
+
+    struct rb_thread_struct *running_thread;
+
+    // The running thread on this shared nt, for the barrier/timeslice scans.
+    // While a scan holds running_th_lock the thread cannot finish parking.
+    rb_nativethread_lock_t running_th_lock;
+    struct rb_thread_struct *running_th;
+    struct ccan_list_node snts_node; // in vm->ractor.sched.ntlist.snts
+    // in vm->ractor.sched.ntlist.running_dnts while running_thread runs
+    struct ccan_list_node running_dnts_node;
+    // barrier_serial stamped by the barrier's counting walk; this nt's
+    // deregistration during that barrier decrements the snapshot count
+    uint32_t barrier_counted_serial;
+
+    // to control native thread; use sched->lock
+    rb_nativethread_cond_t readyq;
+
+#ifdef USE_SIGALTSTACK
+    void *altstack;
+#endif
+
+    struct coroutine_context *nt_context;
+    int dedicated;
+
+    // set when this thread came back from a blocking region with no room left
+    // in the shared pool; it ends when it next asks for work
+    bool retiring;
+
+    // A terminating coroutine records its context here before its final
+    // transfer; this nt's loop reclaims it. coroutine_transfer() cannot be
+    // used because a terminating coroutine never resumes to return a value.
+    struct coroutine_context *dead_co;
+};
+
+// <windows.h> defines these as macros, and the field names below (and in the
+// rest of the interpreter) would be rewritten by them.
+#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
+    // Most recently running thread or NULL. If this thread wakes up before the newly running
+    // thread completes the transfer of control, it can interrupt and resume running.
+    // The new thread clears this field when it takes control.
+    struct rb_thread_struct *runnable_hot_th;
+    int runnable_hot_th_waiting;
+    bool is_running;
+
+    bool enable_mn_threads;
+
+    struct ccan_list_head readyq;
+    int readyq_cnt;
+    // ractor scheduling
+    // When not linked in vm->ractor.sched.grq, this node is kept
+    // self-linked (ccan_list_node_init), so "linked?" can be read off the
+    // node itself: enqueuers assert it, and direct transfers cancel an
+    // outstanding entry (see ractor_sched_cancel_enq).
+    struct ccan_list_node grq_node;
+    struct ccan_list_node timeslice_node; // self-linked = not on timeslice.scheds
+};
+
+struct rb_thread_context;
+
+// A coroutine (M:N) thread's teardown runs coroutine_thread_terminated
+// instead of the dedicated-thread path in thread_start_func_2; see the
+// comments there and in thread_sched_mn.c. th->sched.context is cleared in
+// that epilogue, so this also reads as "did not tear down yet".
+// (Only meaningful when USE_MN_THREADS -- gate uses accordingly; the macro
+// itself is a plain pointer test and always compiles.)
+#define th_has_coroutine(th) ((th)->sched.context != NULL)
+
+struct rb_ractor_struct;
+
+// VM wide: what schedules Ractors onto native threads.  One per VM, in
+// rb_vm_struct.ractor.sched.
+struct rb_ractor_sched {
+    rb_nativethread_lock_t lock;
+    struct rb_ractor_struct *lock_owner;
+    bool locked;
+
+    rb_nativethread_cond_t cond; // GRQ
+    rb_atomic_t snt_cnt;  // count of shared NTs; lock-free (see native_thread_dedicated_inc)
+    unsigned int dnt_cnt; // count of dedicated NTs; logging only (USE_RUBY_DEBUG_LOG), not atomic
+
+    unsigned int max_cpu;
+    struct ccan_list_head grq; // // Global Ready Queue
+    rb_atomic_t winding_cnt; // native threads between a coroutine epilogue and its reclaim; ruby_vm_destruct waits for 0
+    unsigned int grq_cnt;
+
+    // What the barrier walk visits: threads running on dedicated
+    // nts, and the shared nts (whose running_th fields hold the rest).
+    struct {
+        rb_nativethread_lock_t lock;
+        struct ccan_list_head running_dnts;
+        struct ccan_list_head snts;
+    } ntlist;
+
+    // scheds whose readyq holds waiters: the timer ticks their
+    // running thread (timeslice_scan) and prunes drained entries.
+    struct {
+        rb_nativethread_lock_t lock;
+        struct ccan_list_head scheds;
+    } timeslice;
+
+    // true if timeslice timer is not enable
+    bool timeslice_wait_inf;
+
+    // barrier
+    rb_nativethread_cond_t barrier_complete_cond;
+    rb_nativethread_cond_t barrier_release_cond;
+    // bool; nonzero while a stop-the-world section is active.  Set
+    // before the barrier walks the running records; a record moved
+    // after the walk sees it (thread_sched_setup_running_threads).
+    rb_atomic_t barrier_is_waiting;
+    unsigned int barrier_joined_cnt; // threads joined so far; under sched.lock
+    unsigned int barrier_running_cnt; // runners counted by the barrier's walk; under sched.lock
+    unsigned int barrier_serial;
+    struct rb_ractor_struct *barrier_ractor;
+    unsigned int barrier_lock_rec;
+};
+
+void rb_ractor_sched_wait(struct rb_execution_context_struct *ec, struct rb_ractor_struct *cr, rb_unblock_function_t *ptr, void *arg);
+void rb_ractor_sched_wakeup(struct rb_ractor_struct *r, struct rb_thread_struct *th);
+void rb_ractor_sched_wait_terminate(struct rb_vm_struct *vm, rb_nativethread_cond_t *cond, unsigned long msec);
+void rb_thread_wake_fence(struct rb_thread_struct *th);
+
+#endif /* RUBY_THREAD_SCHED_H */

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/thread_win32.h

@@ -0,0 +1,48 @@
+#ifndef RUBY_THREAD_WIN32_H
+#define RUBY_THREAD_WIN32_H
+/**********************************************************************
+
+  thread_win32.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+  This platform runs the common scheduler; see thread_sched.h for its data
+  structures and thread_sched.c for the implementation.
+
+**********************************************************************/
+
+/* interface */
+
+# ifdef __CYGWIN__
+# undef _WIN32
+# endif
+
+WINBASEAPI BOOL WINAPI
+TryEnterCriticalSection(IN OUT LPCRITICAL_SECTION lpCriticalSection);
+
+#include "thread_sched.h"
+
+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-4.1.0-preview1/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