debase-ruby_core_source 0.10.18 → 3.2.0

data/lib/debase/ruby_core_source/ruby-3.2.0-preview1/hrtime.h

@@ -1,216 +0,0 @@
-#ifndef RB_HRTIME_H
-#define RB_HRTIME_H
-#include "ruby/ruby.h"
-#include <time.h>
-#if defined(HAVE_SYS_TIME_H)
-#  include <sys/time.h>
-#endif
-
-/*
- * Hi-res monotonic clock.  It is currently nsec resolution, which has over
- * 500 years of range (with an unsigned 64-bit integer).  Developers
- * targeting small systems may try 32-bit and low-resolution (milliseconds).
- *
- * TBD: Is nsec even necessary? usec resolution seems enough for userspace
- * and it'll be suitable for use with devices lasting over 500,000 years
- * (maybe some devices designed for long-term space travel)
- *
- * Current API:
- *
- *	* rb_hrtime_now      - current clock value (monotonic if available)
- *	* rb_hrtime_mul      - multiply with overflow check
- *	* rb_hrtime_add      - add with overflow check
- *	* rb_timeval2hrtime  - convert from timeval
- *	* rb_timespec2hrtime - convert from timespec
- *	* rb_msec2hrtime     - convert from millisecond
- *	* rb_sec2hrtime      - convert from time_t (seconds)
- *	* rb_hrtime2timeval  - convert to timeval
- *	* rb_hrtime2timespec - convert to timespec
- *
- * Note: no conversion to milliseconds is provided here because different
- * functions have different limits (e.g. epoll_wait vs w32_wait_events).
- * So we provide RB_HRTIME_PER_MSEC and similar macros for implementing
- * this for each use case.
- */
-#define RB_HRTIME_PER_USEC ((rb_hrtime_t)1000)
-#define RB_HRTIME_PER_MSEC (RB_HRTIME_PER_USEC * (rb_hrtime_t)1000)
-#define RB_HRTIME_PER_SEC  (RB_HRTIME_PER_MSEC * (rb_hrtime_t)1000)
-#define RB_HRTIME_MAX      UINT64_MAX
-
-/*
- * Lets try to support time travelers.  Lets assume anybody with a time machine
- * also has access to a modern gcc or clang with 128-bit int support
- */
-#ifdef MY_RUBY_BUILD_MAY_TIME_TRAVEL
-typedef int128_t rb_hrtime_t;
-#else
-typedef uint64_t rb_hrtime_t;
-#endif
-
-/* thread.c */
-/* returns the value of the monotonic clock (if available) */
-rb_hrtime_t rb_hrtime_now(void);
-
-/*
- * multiply @a and @b with overflow check and return the
- * (clamped to RB_HRTIME_MAX) result.
- */
-static inline rb_hrtime_t
-rb_hrtime_mul(rb_hrtime_t a, rb_hrtime_t b)
-{
-    rb_hrtime_t c;
-
-#ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW
-    if (__builtin_mul_overflow(a, b, &c))
-        return RB_HRTIME_MAX;
-#else
-    if (b != 0 && a > RB_HRTIME_MAX / b) /* overflow */
-        return RB_HRTIME_MAX;
-    c = a * b;
-#endif
-    return c;
-}
-
-/*
- * add @a and @b with overflow check and return the
- * (clamped to RB_HRTIME_MAX) result.
- */
-static inline rb_hrtime_t
-rb_hrtime_add(rb_hrtime_t a, rb_hrtime_t b)
-{
-    rb_hrtime_t c;
-
-#ifdef HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW
-    if (__builtin_add_overflow(a, b, &c))
-        return RB_HRTIME_MAX;
-#else
-    c = a + b;
-    if (c < a) /* overflow */
-        return RB_HRTIME_MAX;
-#endif
-    return c;
-}
-
-/*
- * convert a timeval struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
- */
-static inline rb_hrtime_t
-rb_timeval2hrtime(const struct timeval *tv)
-{
-    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)tv->tv_sec, RB_HRTIME_PER_SEC);
-    rb_hrtime_t u = rb_hrtime_mul((rb_hrtime_t)tv->tv_usec, RB_HRTIME_PER_USEC);
-
-    return rb_hrtime_add(s, u);
-}
-
-/*
- * convert a timespec struct to rb_hrtime_t, clamping at RB_HRTIME_MAX
- */
-static inline rb_hrtime_t
-rb_timespec2hrtime(const struct timespec *ts)
-{
-    rb_hrtime_t s = rb_hrtime_mul((rb_hrtime_t)ts->tv_sec, RB_HRTIME_PER_SEC);
-
-    return rb_hrtime_add(s, (rb_hrtime_t)ts->tv_nsec);
-}
-
-/*
- * convert a millisecond value to rb_hrtime_t, clamping at RB_HRTIME_MAX
- */
-static inline rb_hrtime_t
-rb_msec2hrtime(unsigned long msec)
-{
-    return rb_hrtime_mul((rb_hrtime_t)msec, RB_HRTIME_PER_MSEC);
-}
-
-/*
- * convert a time_t value to rb_hrtime_t, clamping at RB_HRTIME_MAX
- * Negative values will be clamped at 0.
- */
-static inline rb_hrtime_t
-rb_sec2hrtime(time_t sec)
-{
-    if (sec <= 0) return 0;
-
-    return rb_hrtime_mul((rb_hrtime_t)sec, RB_HRTIME_PER_SEC);
-}
-
-/*
- * convert a rb_hrtime_t value to a timespec, suitable for calling
- * functions like ppoll(2) or kevent(2)
- */
-static inline struct timespec *
-rb_hrtime2timespec(struct timespec *ts, const rb_hrtime_t *hrt)
-{
-    if (hrt) {
-        ts->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
-        ts->tv_nsec = (int32_t)(*hrt % RB_HRTIME_PER_SEC);
-        return ts;
-    }
-    return 0;
-}
-
-/*
- * convert a rb_hrtime_t value to a timeval, suitable for calling
- * functions like select(2)
- */
-static inline struct timeval *
-rb_hrtime2timeval(struct timeval *tv, const rb_hrtime_t *hrt)
-{
-    if (hrt) {
-        tv->tv_sec = (time_t)(*hrt / RB_HRTIME_PER_SEC);
-        tv->tv_usec = (int32_t)((*hrt % RB_HRTIME_PER_SEC)/RB_HRTIME_PER_USEC);
-
-        return tv;
-    }
-    return 0;
-}
-
-#include "internal/warnings.h"
-#include "internal/time.h"
-
-/*
- * Back when we used "struct timeval", not all platforms implemented
- * tv_sec as time_t.  Nowadays we use "struct timespec" and tv_sec
- * seems to be implemented more consistently across platforms.
- * At least other parts of our code hasn't had to deal with non-time_t
- * tv_sec in timespec...
- */
-#define TIMESPEC_SEC_MAX TIMET_MAX
-#define TIMESPEC_SEC_MIN TIMET_MIN
-
-COMPILER_WARNING_PUSH
-#if __has_warning("-Wimplicit-int-float-conversion")
-COMPILER_WARNING_IGNORED(-Wimplicit-int-float-conversion)
-#elif defined(_MSC_VER)
-/* C4305: 'initializing': truncation from '__int64' to 'const double' */
-COMPILER_WARNING_IGNORED(4305)
-#endif
-static const double TIMESPEC_SEC_MAX_as_double = TIMESPEC_SEC_MAX;
-COMPILER_WARNING_POP
-
-static inline rb_hrtime_t *
-double2hrtime(rb_hrtime_t *hrt, double d)
-{
-    /* assume timespec.tv_sec has same signedness as time_t */
-    const double TIMESPEC_SEC_MAX_PLUS_ONE = 2.0 * (TIMESPEC_SEC_MAX_as_double / 2.0 + 1.0);
-
-    if (TIMESPEC_SEC_MAX_PLUS_ONE <= d) {
-        return NULL;
-    }
-    else if (d <= 0) {
-        *hrt = 0;
-    }
-    else {
-        *hrt = (rb_hrtime_t)(d * (double)RB_HRTIME_PER_SEC);
-    }
-    return hrt;
-}
-
-static inline double
-hrtime2double(rb_hrtime_t hrt)
-{
-    return (double)hrt / (double)RB_HRTIME_PER_SEC;
-}
-
-#endif /* RB_HRTIME_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview1/insns.inc

@@ -1,249 +0,0 @@
-/* -*- C -*- */
-
-/* This is  an auto-generated file  and is a  part of the  programming language
- * Ruby.   The person  who  created  a program  to  generate  this file  (``I''
- * hereafter) would like  to refrain from defining licensing  of this generated
- * source code.
- *
- * This file consists of many small  parts of codes copyrighted by each author,
- * not  only  the  ``I''  person.   Those  original  authors  agree  with  some
- * open-source license.  I  believe that the license we agree  is the condition
- * mentioned in  the file COPYING.  It  states "4.  You may  modify and include
- * the part of the software into any  other software ...".  But the problem is,
- * the license never makes it clear if  such modified parts still remain in the
- * same  license, or  not.   The fact  that  we agree  with  the source  code's
- * licensing terms does not automatically  define that of generated ones.  This
- * is the reason why this file is  under an unclear situation.  All what I know
- * is that above provision guarantees this file to exist.
- *
- * Please let me hesitate to declare  something about this nuanced contract.  I
- * am not in the position to take  over other authors' license to merge into my
- * one.  Changing them to (say) GPLv3 is not doable by myself.  Perhaps someday
- * it might turn  out to be okay to  say this file is under a  license.  I wish
- * the situation would become more clear in the future. */
-
-/*******************************************************************/
-/*******************************************************************/
-/*******************************************************************/
-/**
-  This file contains YARV instruction list.
-
-  ----
-  This file is auto generated by insns2vm.rb
-  DO NOT TOUCH!
-
-  If you want to fix something, you must edit "tool/ruby_vm/views/insns.inc.erb"
-  or tool/insns2vm.rb
- */
-
-/* BIN : Basic Instruction Name */
-#define BIN(n) YARVINSN_##n
-
-enum ruby_vminsn_type {
-    BIN(nop),
-    BIN(getlocal),
-    BIN(setlocal),
-    BIN(getblockparam),
-    BIN(setblockparam),
-    BIN(getblockparamproxy),
-    BIN(getspecial),
-    BIN(setspecial),
-    BIN(getinstancevariable),
-    BIN(setinstancevariable),
-    BIN(getclassvariable),
-    BIN(setclassvariable),
-    BIN(getconstant),
-    BIN(setconstant),
-    BIN(getglobal),
-    BIN(setglobal),
-    BIN(putnil),
-    BIN(putself),
-    BIN(putobject),
-    BIN(putspecialobject),
-    BIN(putstring),
-    BIN(concatstrings),
-    BIN(anytostring),
-    BIN(toregexp),
-    BIN(intern),
-    BIN(newarray),
-    BIN(newarraykwsplat),
-    BIN(duparray),
-    BIN(duphash),
-    BIN(expandarray),
-    BIN(concatarray),
-    BIN(splatarray),
-    BIN(newhash),
-    BIN(newrange),
-    BIN(pop),
-    BIN(dup),
-    BIN(dupn),
-    BIN(swap),
-    BIN(topn),
-    BIN(setn),
-    BIN(adjuststack),
-    BIN(defined),
-    BIN(checkmatch),
-    BIN(checkkeyword),
-    BIN(checktype),
-    BIN(defineclass),
-    BIN(definemethod),
-    BIN(definesmethod),
-    BIN(send),
-    BIN(opt_send_without_block),
-    BIN(objtostring),
-    BIN(opt_str_freeze),
-    BIN(opt_nil_p),
-    BIN(opt_str_uminus),
-    BIN(opt_newarray_max),
-    BIN(opt_newarray_min),
-    BIN(invokesuper),
-    BIN(invokeblock),
-    BIN(leave),
-    BIN(throw),
-    BIN(jump),
-    BIN(branchif),
-    BIN(branchunless),
-    BIN(branchnil),
-    BIN(opt_getinlinecache),
-    BIN(opt_setinlinecache),
-    BIN(once),
-    BIN(opt_case_dispatch),
-    BIN(opt_plus),
-    BIN(opt_minus),
-    BIN(opt_mult),
-    BIN(opt_div),
-    BIN(opt_mod),
-    BIN(opt_eq),
-    BIN(opt_neq),
-    BIN(opt_lt),
-    BIN(opt_le),
-    BIN(opt_gt),
-    BIN(opt_ge),
-    BIN(opt_ltlt),
-    BIN(opt_and),
-    BIN(opt_or),
-    BIN(opt_aref),
-    BIN(opt_aset),
-    BIN(opt_aset_with),
-    BIN(opt_aref_with),
-    BIN(opt_length),
-    BIN(opt_size),
-    BIN(opt_empty_p),
-    BIN(opt_succ),
-    BIN(opt_not),
-    BIN(opt_regexpmatch2),
-    BIN(invokebuiltin),
-    BIN(opt_invokebuiltin_delegate),
-    BIN(opt_invokebuiltin_delegate_leave),
-    BIN(getlocal_WC_0),
-    BIN(getlocal_WC_1),
-    BIN(setlocal_WC_0),
-    BIN(setlocal_WC_1),
-    BIN(putobject_INT2FIX_0_),
-    BIN(putobject_INT2FIX_1_),
-    BIN(trace_nop),
-    BIN(trace_getlocal),
-    BIN(trace_setlocal),
-    BIN(trace_getblockparam),
-    BIN(trace_setblockparam),
-    BIN(trace_getblockparamproxy),
-    BIN(trace_getspecial),
-    BIN(trace_setspecial),
-    BIN(trace_getinstancevariable),
-    BIN(trace_setinstancevariable),
-    BIN(trace_getclassvariable),
-    BIN(trace_setclassvariable),
-    BIN(trace_getconstant),
-    BIN(trace_setconstant),
-    BIN(trace_getglobal),
-    BIN(trace_setglobal),
-    BIN(trace_putnil),
-    BIN(trace_putself),
-    BIN(trace_putobject),
-    BIN(trace_putspecialobject),
-    BIN(trace_putstring),
-    BIN(trace_concatstrings),
-    BIN(trace_anytostring),
-    BIN(trace_toregexp),
-    BIN(trace_intern),
-    BIN(trace_newarray),
-    BIN(trace_newarraykwsplat),
-    BIN(trace_duparray),
-    BIN(trace_duphash),
-    BIN(trace_expandarray),
-    BIN(trace_concatarray),
-    BIN(trace_splatarray),
-    BIN(trace_newhash),
-    BIN(trace_newrange),
-    BIN(trace_pop),
-    BIN(trace_dup),
-    BIN(trace_dupn),
-    BIN(trace_swap),
-    BIN(trace_topn),
-    BIN(trace_setn),
-    BIN(trace_adjuststack),
-    BIN(trace_defined),
-    BIN(trace_checkmatch),
-    BIN(trace_checkkeyword),
-    BIN(trace_checktype),
-    BIN(trace_defineclass),
-    BIN(trace_definemethod),
-    BIN(trace_definesmethod),
-    BIN(trace_send),
-    BIN(trace_opt_send_without_block),
-    BIN(trace_objtostring),
-    BIN(trace_opt_str_freeze),
-    BIN(trace_opt_nil_p),
-    BIN(trace_opt_str_uminus),
-    BIN(trace_opt_newarray_max),
-    BIN(trace_opt_newarray_min),
-    BIN(trace_invokesuper),
-    BIN(trace_invokeblock),
-    BIN(trace_leave),
-    BIN(trace_throw),
-    BIN(trace_jump),
-    BIN(trace_branchif),
-    BIN(trace_branchunless),
-    BIN(trace_branchnil),
-    BIN(trace_opt_getinlinecache),
-    BIN(trace_opt_setinlinecache),
-    BIN(trace_once),
-    BIN(trace_opt_case_dispatch),
-    BIN(trace_opt_plus),
-    BIN(trace_opt_minus),
-    BIN(trace_opt_mult),
-    BIN(trace_opt_div),
-    BIN(trace_opt_mod),
-    BIN(trace_opt_eq),
-    BIN(trace_opt_neq),
-    BIN(trace_opt_lt),
-    BIN(trace_opt_le),
-    BIN(trace_opt_gt),
-    BIN(trace_opt_ge),
-    BIN(trace_opt_ltlt),
-    BIN(trace_opt_and),
-    BIN(trace_opt_or),
-    BIN(trace_opt_aref),
-    BIN(trace_opt_aset),
-    BIN(trace_opt_aset_with),
-    BIN(trace_opt_aref_with),
-    BIN(trace_opt_length),
-    BIN(trace_opt_size),
-    BIN(trace_opt_empty_p),
-    BIN(trace_opt_succ),
-    BIN(trace_opt_not),
-    BIN(trace_opt_regexpmatch2),
-    BIN(trace_invokebuiltin),
-    BIN(trace_opt_invokebuiltin_delegate),
-    BIN(trace_opt_invokebuiltin_delegate_leave),
-    BIN(trace_getlocal_WC_0),
-    BIN(trace_getlocal_WC_1),
-    BIN(trace_setlocal_WC_0),
-    BIN(trace_setlocal_WC_1),
-    BIN(trace_putobject_INT2FIX_0_),
-    BIN(trace_putobject_INT2FIX_1_),
-    VM_INSTRUCTION_SIZE
-};
-
-#define ASSERT_VM_INSTRUCTION_SIZE(array) \
-    STATIC_ASSERT(numberof_##array, numberof(array) == VM_INSTRUCTION_SIZE)