datadog-ruby_core_source 3.5.5 → 3.5.6

data/lib/datadog/ruby_core_source/ruby-4.1.0-preview1/hrtime.h

@@ -0,0 +1,237 @@
+#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
+
+#include "internal/compilers.h"
+
+/*
+ * 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
+#define RB_HRTIME_MIN      ((rb_hrtime_t)0)
+
+/*
+ * 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 ckd_mul
+    if (ckd_mul(&c, a, b))
+        return RB_HRTIME_MAX;
+
+#elif __has_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 ckd_add
+    if (ckd_add(&c, a, b))
+        return RB_HRTIME_MAX;
+
+#elif __has_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;
+}
+
+static inline rb_hrtime_t
+rb_hrtime_sub(rb_hrtime_t a, rb_hrtime_t b)
+{
+    if (a < b) {
+        return RB_HRTIME_MIN;
+    }
+    return a - b;
+}
+
+/*
+ * 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) {
+        *hrt = RB_HRTIME_MAX;
+        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/datadog/ruby_core_source/ruby-4.1.0-preview1/id.h

@@ -0,0 +1,365 @@
+/* DO NOT EDIT THIS FILE DIRECTLY: source is at template/id.h.tmpl */
+/**********************************************************************
+
+  id.h -
+
+  $Author$
+  created at: Sun Oct 19 21:12:51 2008
+
+  Copyright (C) 2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_ID_H
+#define RUBY_ID_H
+
+enum ruby_id_types {
+    RUBY_ID_LOCAL       = 0x00,
+    RUBY_ID_STATIC_SYM  = 0x01,
+    RUBY_ID_INSTANCE    = (0x01<<1),
+    RUBY_ID_GLOBAL      = (0x03<<1),
+    RUBY_ID_ATTRSET     = (0x04<<1),
+    RUBY_ID_CONST       = (0x05<<1),
+    RUBY_ID_CLASS       = (0x06<<1),
+    RUBY_ID_INTERNAL    = (0x07<<1),
+    RUBY_ID_SCOPE_SHIFT = 4,
+    RUBY_ID_SCOPE_MASK  = (~(~0U<<(RUBY_ID_SCOPE_SHIFT-1))<<1)
+};
+
+#define ID_STATIC_SYM  RUBY_ID_STATIC_SYM
+#define ID_SCOPE_SHIFT RUBY_ID_SCOPE_SHIFT
+#define ID_SCOPE_MASK  RUBY_ID_SCOPE_MASK
+#define ID_LOCAL       RUBY_ID_LOCAL
+#define ID_INSTANCE    RUBY_ID_INSTANCE
+#define ID_GLOBAL      RUBY_ID_GLOBAL
+#define ID_ATTRSET     RUBY_ID_ATTRSET
+#define ID_CONST       RUBY_ID_CONST
+#define ID_CLASS       RUBY_ID_CLASS
+#define ID_INTERNAL    RUBY_ID_INTERNAL
+
+#define symIFUNC ID2SYM(idIFUNC)
+#define symCFUNC ID2SYM(idCFUNC)
+
+#define RUBY_TOKEN_DOT2 128
+#define RUBY_TOKEN_DOT3 129
+#define RUBY_TOKEN_BDOT2 130
+#define RUBY_TOKEN_BDOT3 131
+#define RUBY_TOKEN_UPLUS 132
+#define RUBY_TOKEN_UMINUS 133
+#define RUBY_TOKEN_POW 134
+#define RUBY_TOKEN_CMP 135
+#define RUBY_TOKEN_LSHFT 136
+#define RUBY_TOKEN_RSHFT 137
+#define RUBY_TOKEN_LEQ 138
+#define RUBY_TOKEN_GEQ 139
+#define RUBY_TOKEN_EQ 140
+#define RUBY_TOKEN_EQQ 141
+#define RUBY_TOKEN_NEQ 142
+#define RUBY_TOKEN_MATCH 143
+#define RUBY_TOKEN_NMATCH 144
+#define RUBY_TOKEN_AREF 145
+#define RUBY_TOKEN_ASET 146
+#define RUBY_TOKEN_COLON2 147
+#define RUBY_TOKEN_ANDOP 148
+#define RUBY_TOKEN_OROP 149
+#define RUBY_TOKEN_ANDDOT 150
+#define RUBY_TOKEN(t) RUBY_TOKEN_##t
+
+#define RUBY_TOKEN2ID_TYPE(tok, type) ((tok<<RUBY_ID_SCOPE_SHIFT)|type|RUBY_ID_STATIC_SYM)
+#define TOKEN2LOCALID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_LOCAL)
+#define TOKEN2INSTANCEID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_INSTANCE)
+#define TOKEN2GLOBALID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_GLOBAL)
+#define TOKEN2CONSTID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_CONST)
+#define TOKEN2CLASSID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_CLASS)
+#define TOKEN2ATTRSETID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_ATTRSET)
+
+enum ruby_method_ids {
+    idDot2 = RUBY_TOKEN(DOT2),
+    idDot3 = RUBY_TOKEN(DOT3),
+    idUPlus = RUBY_TOKEN(UPLUS),
+    idUMinus = RUBY_TOKEN(UMINUS),
+    idPow = RUBY_TOKEN(POW),
+    idCmp = RUBY_TOKEN(CMP),
+    idPLUS = '+',
+    idMINUS = '-',
+    idMULT = '*',
+    idDIV = '/',
+    idMOD = '%',
+    idLTLT = RUBY_TOKEN(LSHFT),
+    idGTGT = RUBY_TOKEN(RSHFT),
+    idLT = '<',
+    idLE = RUBY_TOKEN(LEQ),
+    idGT = '>',
+    idGE = RUBY_TOKEN(GEQ),
+    idEq = RUBY_TOKEN(EQ),
+    idEqq = RUBY_TOKEN(EQQ),
+    idNeq = RUBY_TOKEN(NEQ),
+    idNot = '!',
+    idAnd = '&',
+    idOr = '|',
+    idBackquote = '`',
+    idEqTilde = RUBY_TOKEN(MATCH),
+    idNeqTilde = RUBY_TOKEN(NMATCH),
+    idAREF = RUBY_TOKEN(AREF),
+    idASET = RUBY_TOKEN(ASET),
+    idCOLON2 = RUBY_TOKEN(COLON2),
+    idANDOP = RUBY_TOKEN(ANDOP),
+    idOROP = RUBY_TOKEN(OROP),
+    idANDDOT = RUBY_TOKEN(ANDDOT),
+    tPRESERVED_ID_BEGIN = 150,
+    idNilP,
+    idIncludeP,
+    idItImplicit,
+    idNULL,
+    idEmptyP,
+    idEqlP,
+    idRespond_to,
+    idRespond_to_missing,
+    idIFUNC,
+    idCFUNC,
+    id_core_set_method_alias,
+    id_core_set_variable_alias,
+    id_core_undef_method,
+    id_core_define_method,
+    id_core_define_singleton_method,
+    id_core_iseq_path,
+    id_core_set_postexe,
+    id_core_hash_merge_ptr,
+    id_core_hash_merge_bang_ptr,
+    id_core_hash_merge_kwd,
+    id_core_hash_merge_bang_kwd,
+    id_core_hash_coerce,
+    id_core_raise,
+    id_core_sprintf,
+    id_debug_created_info,
+    tPRESERVED_ID_END,
+
+    /* LOCAL tokens {{{ */
+    tTOKEN_LOCAL_BEGIN = tPRESERVED_ID_END-1,
+    tMax,
+    tMin,
+    tHash,
+    tFreeze,
+    tInspect,
+    tIntern,
+    tObject_id,
+    t__id__,
+    tConst_added,
+    tConst_missing,
+    tMethodMissing,
+    tMethod_added,
+    tSingleton_method_added,
+    tMethod_removed,
+    tSingleton_method_removed,
+    tMethod_undefined,
+    tSingleton_method_undefined,
+    tLength,
+    tSize,
+    tGets,
+    tSucc,
+    tEach,
+    tProc,
+    tLambda,
+    tSend,
+    t__send__,
+    t__recursive_key__,
+    tClone,
+    tInitialize,
+    tInitialize_copy,
+    tInitialize_clone,
+    tInitialize_dup,
+    tTo_int,
+    tTo_ary,
+    tTo_str,
+    tTo_sym,
+    tTo_hash,
+    tTo_proc,
+    tTo_io,
+    tTo_a,
+    tTo_s,
+    tTo_i,
+    tTo_f,
+    tTo_r,
+    tBt,
+    tBt_locations,
+    tCall,
+    tYield,
+    tMesg,
+    tException,
+    tLocals,
+    tNOT,
+    tAND,
+    tOR,
+    tDiv,
+    tDivmod,
+    tFdiv,
+    tQuo,
+    tName,
+    tNil,
+    tPath,
+    tPack,
+    tBuffer,
+    tAborted,
+    tExited,
+    tUScore,
+    tNUMPARAM_1,
+    tNUMPARAM_2,
+    tNUMPARAM_3,
+    tNUMPARAM_4,
+    tNUMPARAM_5,
+    tNUMPARAM_6,
+    tNUMPARAM_7,
+    tNUMPARAM_8,
+    tNUMPARAM_9,
+    tIt,
+    tDefault,
+    tTOKEN_LOCAL_END,
+    /* LOCAL tokens }}} */
+
+    /* INSTANCE tokens {{{ */
+    tTOKEN_INSTANCE_BEGIN = tTOKEN_LOCAL_END-1,
+    tTOKEN_INSTANCE_END,
+    /* INSTANCE tokens }}} */
+
+    /* GLOBAL tokens {{{ */
+    tTOKEN_GLOBAL_BEGIN = tTOKEN_INSTANCE_END-1,
+    tLASTLINE,
+    tBACKREF,
+    tERROR_INFO,
+    tTOKEN_GLOBAL_END,
+    /* GLOBAL tokens }}} */
+
+    /* CONST tokens {{{ */
+    tTOKEN_CONST_BEGIN = tTOKEN_GLOBAL_END-1,
+    tRuby,
+    tTOKEN_CONST_END,
+    /* CONST tokens }}} */
+
+    /* CLASS tokens {{{ */
+    tTOKEN_CLASS_BEGIN = tTOKEN_CONST_END-1,
+    tTOKEN_CLASS_END,
+    /* CLASS tokens }}} */
+
+    /* ATTRSET tokens {{{ */
+    tTOKEN_ATTRSET_BEGIN = tTOKEN_CLASS_END-1,
+    tTOKEN_ATTRSET_END,
+    /* ATTRSET tokens }}} */
+
+    tNEXT_ID = tTOKEN_ATTRSET_END,
+
+    /* LOCAL IDs {{{ */
+#define DEFINE_LOCALID_FROM_TOKEN(n) id##n = TOKEN2LOCALID(t##n)
+    DEFINE_LOCALID_FROM_TOKEN(Max),
+    DEFINE_LOCALID_FROM_TOKEN(Min),
+    DEFINE_LOCALID_FROM_TOKEN(Hash),
+    DEFINE_LOCALID_FROM_TOKEN(Freeze),
+    DEFINE_LOCALID_FROM_TOKEN(Inspect),
+    DEFINE_LOCALID_FROM_TOKEN(Intern),
+    DEFINE_LOCALID_FROM_TOKEN(Object_id),
+    DEFINE_LOCALID_FROM_TOKEN(__id__),
+    DEFINE_LOCALID_FROM_TOKEN(Const_added),
+    DEFINE_LOCALID_FROM_TOKEN(Const_missing),
+    DEFINE_LOCALID_FROM_TOKEN(MethodMissing),
+    DEFINE_LOCALID_FROM_TOKEN(Method_added),
+    DEFINE_LOCALID_FROM_TOKEN(Singleton_method_added),
+    DEFINE_LOCALID_FROM_TOKEN(Method_removed),
+    DEFINE_LOCALID_FROM_TOKEN(Singleton_method_removed),
+    DEFINE_LOCALID_FROM_TOKEN(Method_undefined),
+    DEFINE_LOCALID_FROM_TOKEN(Singleton_method_undefined),
+    DEFINE_LOCALID_FROM_TOKEN(Length),
+    DEFINE_LOCALID_FROM_TOKEN(Size),
+    DEFINE_LOCALID_FROM_TOKEN(Gets),
+    DEFINE_LOCALID_FROM_TOKEN(Succ),
+    DEFINE_LOCALID_FROM_TOKEN(Each),
+    DEFINE_LOCALID_FROM_TOKEN(Proc),
+    DEFINE_LOCALID_FROM_TOKEN(Lambda),
+    DEFINE_LOCALID_FROM_TOKEN(Send),
+    DEFINE_LOCALID_FROM_TOKEN(__send__),
+    DEFINE_LOCALID_FROM_TOKEN(__recursive_key__),
+    DEFINE_LOCALID_FROM_TOKEN(Clone),
+    DEFINE_LOCALID_FROM_TOKEN(Initialize),
+    DEFINE_LOCALID_FROM_TOKEN(Initialize_copy),
+    DEFINE_LOCALID_FROM_TOKEN(Initialize_clone),
+    DEFINE_LOCALID_FROM_TOKEN(Initialize_dup),
+    DEFINE_LOCALID_FROM_TOKEN(To_int),
+    DEFINE_LOCALID_FROM_TOKEN(To_ary),
+    DEFINE_LOCALID_FROM_TOKEN(To_str),
+    DEFINE_LOCALID_FROM_TOKEN(To_sym),
+    DEFINE_LOCALID_FROM_TOKEN(To_hash),
+    DEFINE_LOCALID_FROM_TOKEN(To_proc),
+    DEFINE_LOCALID_FROM_TOKEN(To_io),
+    DEFINE_LOCALID_FROM_TOKEN(To_a),
+    DEFINE_LOCALID_FROM_TOKEN(To_s),
+    DEFINE_LOCALID_FROM_TOKEN(To_i),
+    DEFINE_LOCALID_FROM_TOKEN(To_f),
+    DEFINE_LOCALID_FROM_TOKEN(To_r),
+    DEFINE_LOCALID_FROM_TOKEN(Bt),
+    DEFINE_LOCALID_FROM_TOKEN(Bt_locations),
+    DEFINE_LOCALID_FROM_TOKEN(Call),
+    DEFINE_LOCALID_FROM_TOKEN(Yield),
+    DEFINE_LOCALID_FROM_TOKEN(Mesg),
+    DEFINE_LOCALID_FROM_TOKEN(Exception),
+    DEFINE_LOCALID_FROM_TOKEN(Locals),
+    DEFINE_LOCALID_FROM_TOKEN(NOT),
+    DEFINE_LOCALID_FROM_TOKEN(AND),
+    DEFINE_LOCALID_FROM_TOKEN(OR),
+    DEFINE_LOCALID_FROM_TOKEN(Div),
+    DEFINE_LOCALID_FROM_TOKEN(Divmod),
+    DEFINE_LOCALID_FROM_TOKEN(Fdiv),
+    DEFINE_LOCALID_FROM_TOKEN(Quo),
+    DEFINE_LOCALID_FROM_TOKEN(Name),
+    DEFINE_LOCALID_FROM_TOKEN(Nil),
+    DEFINE_LOCALID_FROM_TOKEN(Path),
+    DEFINE_LOCALID_FROM_TOKEN(Pack),
+    DEFINE_LOCALID_FROM_TOKEN(Buffer),
+    DEFINE_LOCALID_FROM_TOKEN(Aborted),
+    DEFINE_LOCALID_FROM_TOKEN(Exited),
+    DEFINE_LOCALID_FROM_TOKEN(UScore),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_1),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_2),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_3),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_4),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_5),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_6),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_7),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_8),
+    DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_9),
+    DEFINE_LOCALID_FROM_TOKEN(It),
+    DEFINE_LOCALID_FROM_TOKEN(Default),
+#undef DEFINE_LOCALID_FROM_TOKEN
+    /* LOCAL IDs }}} */
+
+    /* INSTANCE IDs {{{ */
+#define DEFINE_INSTANCEID_FROM_TOKEN(n) id##n = TOKEN2INSTANCEID(t##n)
+#undef DEFINE_INSTANCEID_FROM_TOKEN
+    /* INSTANCE IDs }}} */
+
+    /* GLOBAL IDs {{{ */
+#define DEFINE_GLOBALID_FROM_TOKEN(n) id##n = TOKEN2GLOBALID(t##n)
+    DEFINE_GLOBALID_FROM_TOKEN(LASTLINE),
+    DEFINE_GLOBALID_FROM_TOKEN(BACKREF),
+    DEFINE_GLOBALID_FROM_TOKEN(ERROR_INFO),
+#undef DEFINE_GLOBALID_FROM_TOKEN
+    /* GLOBAL IDs }}} */
+
+    /* CONST IDs {{{ */
+#define DEFINE_CONSTID_FROM_TOKEN(n) id##n = TOKEN2CONSTID(t##n)
+    DEFINE_CONSTID_FROM_TOKEN(Ruby),
+#undef DEFINE_CONSTID_FROM_TOKEN
+    /* CONST IDs }}} */
+
+    /* CLASS IDs {{{ */
+#define DEFINE_CLASSID_FROM_TOKEN(n) id##n = TOKEN2CLASSID(t##n)
+#undef DEFINE_CLASSID_FROM_TOKEN
+    /* CLASS IDs }}} */
+
+    /* ATTRSET IDs {{{ */
+#define DEFINE_ATTRSETID_FROM_TOKEN(n) id##n = TOKEN2ATTRSETID(t##n)
+#undef DEFINE_ATTRSETID_FROM_TOKEN
+    /* ATTRSET IDs }}} */
+
+    tLAST_OP_ID = tPRESERVED_ID_END-1,
+    idLAST_OP_ID = tLAST_OP_ID >> ID_SCOPE_SHIFT
+};
+
+#endif /* RUBY_ID_H */

data/lib/datadog/ruby_core_source/ruby-4.1.0-preview1/id_table.h

@@ -0,0 +1,74 @@
+#ifndef RUBY_ID_TABLE_H
+#define RUBY_ID_TABLE_H 1
+#include "ruby/internal/config.h"
+#include <stddef.h>
+#include "ruby/ruby.h"
+
+struct rb_id_table {
+    int capa;
+    int num;
+    int used;
+    /* The table body is a single buffer laid out as:
+     *
+     * [VALUE values[capa] | id_key_t keys[capa] | collision bitmap]
+     *
+     * where the collision bitmap uses one mark bit per slot. */
+    void *buf;
+};
+
+/* compatible with ST_* */
+enum rb_id_table_iterator_result {
+    ID_TABLE_CONTINUE = ST_CONTINUE,
+    ID_TABLE_STOP     = ST_STOP,
+    ID_TABLE_DELETE   = ST_DELETE,
+    ID_TABLE_REPLACE  = ST_REPLACE,
+    ID_TABLE_ITERATOR_RESULT_END
+};
+
+struct rb_id_table *rb_id_table_create(size_t size);
+struct rb_id_table *rb_id_table_init(struct rb_id_table *tbl, size_t capa);
+
+void rb_id_table_free(struct rb_id_table *tbl);
+void rb_id_table_free_items(struct rb_id_table *tbl);
+void rb_id_table_clear(struct rb_id_table *tbl);
+
+size_t rb_id_table_memsize(const struct rb_id_table *tbl);
+
+int rb_id_table_insert(struct rb_id_table *tbl, ID id, VALUE val);
+int rb_id_table_lookup(struct rb_id_table *tbl, ID id, VALUE *valp);
+int rb_id_table_delete(struct rb_id_table *tbl, ID id);
+
+typedef enum rb_id_table_iterator_result rb_id_table_update_value_callback_func_t(VALUE *val, void *data, int existing);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_func_t(ID id, VALUE val, void *data);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_values_func_t(VALUE val, void *data);
+void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data);
+void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);
+void rb_id_table_foreach_values_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, rb_id_table_update_value_callback_func_t *replace, void *data);
+
+VALUE rb_managed_id_table_create(const rb_data_type_t *type, size_t capa);
+VALUE rb_managed_id_table_new(size_t capa);
+VALUE rb_managed_id_table_dup(VALUE table);
+int rb_managed_id_table_insert(VALUE table, ID id, VALUE val);
+int rb_managed_id_table_lookup(VALUE table, ID id, VALUE *valp);
+size_t rb_managed_id_table_size(VALUE table);
+void rb_managed_id_table_foreach(VALUE table, rb_id_table_foreach_func_t *func, void *data);
+void rb_managed_id_table_foreach_values(VALUE table, rb_id_table_foreach_values_func_t *func, void *data);
+int rb_managed_id_table_delete(VALUE table, ID id);
+
+extern const rb_data_type_t rb_managed_id_table_type;
+
+VALUE rb_marked_id_table_new(size_t capa);
+int rb_marked_id_table_insert(VALUE table, ID id, VALUE val);
+VALUE rb_marked_id_table_dup(VALUE table);
+
+// alisases
+#define rb_marked_id_table_size             rb_managed_id_table_size
+#define rb_marked_id_table_lookup           rb_managed_id_table_lookup
+#define rb_marked_id_table_foreach          rb_managed_id_table_foreach
+#define rb_marked_id_table_foreach_values   rb_managed_id_table_foreach_values
+
+RUBY_SYMBOL_EXPORT_BEGIN
+size_t rb_id_table_size(const struct rb_id_table *tbl);
+RUBY_SYMBOL_EXPORT_END
+
+#endif	/* RUBY_ID_TABLE_H */