avalara_sdk 24.12.0 → 24.12.2

data/vendor/bundle/ruby/2.7.0/gems/debase-ruby_core_source-3.3.6/lib/debase/ruby_core_source/ruby-3.4.0-preview1/internal/error.h

@@ -1,216 +0,0 @@
-#ifndef INTERNAL_ERROR_H                                 /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_ERROR_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for Exception.
- */
-#include "ruby/internal/config.h"
-#include <stdarg.h>             /* for va_list */
-#include "internal/string.h"    /* for rb_fstring_cstr */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/encoding.h"      /* for rb_encoding */
-#include "ruby/intern.h"        /* for rb_exc_raise */
-#include "ruby/ruby.h"          /* for enum ruby_value_type */
-
-#ifdef Check_Type
-# undef Check_Type               /* in ruby/ruby.h */
-#endif
-
-#ifdef rb_raise_static
-# undef rb_raise_static
-# undef rb_sys_fail_path
-# undef rb_syserr_fail_path
-#endif
-
-#define rb_raise_static(e, m) \
-    rb_raise_cstr_i((e), rb_str_new_static((m), rb_strlen_lit(m)))
-#ifdef RUBY_FUNCTION_NAME_STRING
-# define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
-# define rb_syserr_new_path(err, path) rb_syserr_new_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
-#else
-# define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
-# define rb_syserr_new_path(err, path) rb_syserr_new_str((err), (path))
-#endif
-
-#define rb_sys_fail(mesg) \
-do { \
-    int errno_to_fail = errno; \
-    rb_syserr_fail(errno_to_fail, (mesg)); \
-} while (0)
-
-#define rb_sys_fail_str(mesg) \
-do { \
-    int errno_to_fail = errno; \
-    rb_syserr_fail_str(errno_to_fail, (mesg)); \
-} while (0)
-
-#define rb_sys_fail_path(path) \
-do { \
-    int errno_to_fail = errno; \
-    rb_syserr_fail_path(errno_to_fail, (path)); \
-} while (0)
-
-#define rb_sys_fail_sprintf(...) \
-do { \
-    int errno_to_fail = errno; \
-    rb_syserr_fail_str(errno_to_fail, rb_sprintf("" __VA_ARGS__)); \
-} while (0)
-
-/* error.c */
-extern long rb_backtrace_length_limit;
-extern VALUE rb_eEAGAIN;
-extern VALUE rb_eEWOULDBLOCK;
-extern VALUE rb_eEINPROGRESS;
-RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 0)
-void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args);
-NORETURN(void rb_async_bug_errno(const char *,int));
-const char *rb_builtin_type_name(int t);
-const char *rb_builtin_class_name(VALUE x);
-PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
-PRINTF_ARGS(void rb_warn_deprecated_to_remove(const char *removal, const char *fmt, const char *suggest, ...), 2, 4);
-#if RUBY_DEBUG
-# include "ruby/version.h"
-# define RUBY_VERSION_SINCE(major, minor) (RUBY_API_VERSION_CODE >= (major * 10000) + (minor) * 100)
-# define RUBY_VERSION_BEFORE(major, minor) (RUBY_API_VERSION_CODE < (major * 10000) + (minor) * 100)
-# if defined(RBIMPL_WARNING_PRAGMA0)
-#   define RBIMPL_TODO0(x) RBIMPL_WARNING_PRAGMA0(message(x))
-# elif RBIMPL_COMPILER_SINCE(MSVC, 12, 0, 0)
-#   define RBIMPL_TODO0(x) __pragma(message(x))
-# endif
-
-# if RBIMPL_HAS_ATTRIBUTE(diagnose_if) || defined(__OPTIMIZE__)
-
-#define RUBY_VERSION_isdigit(c) ('0'<=(c)&&(c)<='9')
-// upto 99
-#define RUBY_VERSION__number_len(v, ofs) \
-    (!RUBY_VERSION_isdigit((v)[ofs]) ? \
-     0 : !RUBY_VERSION_isdigit((v)[(ofs) + 1]) ? 1 : 2)
-#define RUBY_VERSION__to_number(v, ofs) \
-    (!RUBY_VERSION_isdigit((v)[ofs]) ? \
-     0 : !RUBY_VERSION_isdigit((v)[(ofs) + 1]) ? \
-     ((v)[ofs]-'0') : \
-     (((v)[ofs]-'0')*10+(v)[(ofs)+1]-'0'))
-
-#define RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v) \
-    (RUBY_VERSION__to_number(v, 0) * 10000 + \
-     ((v)[RUBY_VERSION__number_len(v, 0)] == '.' ? \
-      RUBY_VERSION__to_number(v, RUBY_VERSION__number_len(v, 0)+1) * 100 : 0))
-#define RUBY_VERSION_STRING_SINCE(v) (RUBY_API_VERSION_CODE >= RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v))
-#define RUBY_VERSION_STRING_BEFORE(v) (RUBY_API_VERSION_CODE < RUBY_VERSION_CODE_FROM_MAJOR_MINOR_STRING(v))
-
-# if RBIMPL_HAS_ATTRIBUTE(diagnose_if)
-RBIMPL_ATTR_FORCEINLINE()
-static void
-rb_deprecated_method_to_be_removed(const char *removal)
-    RBIMPL_ATTR_DIAGNOSE_IF(!RUBY_VERSION_isdigit(removal[0]), "malformed version number", "error")
-    RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(removal), "deprecated method to be removed", "error")
-{
-}
-# else
-RBIMPL_ATTR_ERROR(("deprecated"))
-void rb_deprecated_method_to_be_removed(const char *);
-#   define rb_deprecated_method_to_be_removed(removal) \
-    (sizeof(char[1-2*(!RUBY_VERSION_isdigit(removal[0]) || RUBY_VERSION_STRING_SINCE(removal))])!=1 ? \
-     rb_deprecated_method_to_be_removed(removal) : \
-     RBIMPL_ASSERT_NOTHING)
-# endif
-# define rb_warn_deprecated_to_remove_at(removal, ...) \
-    (rb_deprecated_method_to_be_removed(#removal), \
-     rb_warn_deprecated_to_remove(#removal, __VA_ARGS__))
-# endif
-#endif
-#ifndef rb_warn_deprecated_to_remove_at
-# define rb_warn_deprecated_to_remove_at(removal, ...) \
-        rb_warn_deprecated_to_remove(#removal, __VA_ARGS__)
-#endif
-#ifndef RUBY_VERSION_SINCE
-# define RUBY_VERSION_SINCE(major, minor) 0
-#endif
-#ifndef RUBY_VERSION_BEFORE
-# define RUBY_VERSION_BEFORE(major, minor) 0
-#endif
-#ifndef RBIMPL_TODO0
-# define RBIMPL_TODO0(x)
-#endif
-#define RBIMPL_TODO(message) RBIMPL_TODO0("TODO: " message)
-RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
-VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*, va_list);
-PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
-PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
-PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
-rb_warning_category_t rb_warning_category_from_name(VALUE category);
-bool rb_warning_category_enabled_p(rb_warning_category_t category);
-VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
-VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv);
-VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name);
-PRINTF_ARGS(VALUE rb_warning_string(const char *fmt, ...), 1, 2);
-RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 2, 0)
-NORETURN(void rb_vraise(VALUE, const char *, va_list));
-NORETURN(static inline void rb_raise_cstr(VALUE etype, const char *mesg));
-NORETURN(static inline void rb_raise_cstr_i(VALUE etype, VALUE mesg));
-NORETURN(static inline void rb_name_err_raise_str(VALUE mesg, VALUE recv, VALUE name));
-NORETURN(static inline void rb_name_err_raise(const char *mesg, VALUE recv, VALUE name));
-NORETURN(static inline void rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name));
-static inline void Check_Type(VALUE v, enum ruby_value_type t);
-static inline bool rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type);
-#define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* error.c (export) */
-int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
-#ifdef RUBY_FUNCTION_NAME_STRING
-NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
-NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
-VALUE rb_syserr_new_path_in(const char *func_name, int n, VALUE path);
-#endif
-RUBY_SYMBOL_EXPORT_END
-
-/* vm.c */
-void rb_free_warning(void);
-
-static inline void
-rb_raise_cstr_i(VALUE etype, VALUE mesg)
-{
-    VALUE exc = rb_exc_new_str(etype, mesg);
-    rb_exc_raise(exc);
-}
-
-static inline void
-rb_raise_cstr(VALUE etype, const char *mesg)
-{
-    VALUE str = rb_str_new_cstr(mesg);
-    rb_raise_cstr_i(etype, str);
-}
-
-static inline void
-rb_name_err_raise_str(VALUE mesg, VALUE recv, VALUE name)
-{
-    VALUE exc = rb_name_err_new(mesg, recv, name);
-    rb_exc_raise(exc);
-}
-
-static inline void
-rb_name_err_raise(const char *mesg, VALUE recv, VALUE name)
-{
-    VALUE str = rb_fstring_cstr(mesg);
-    rb_name_err_raise_str(str, recv, name);
-}
-
-static inline void
-rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name)
-{
-    VALUE exc = rb_key_err_new(mesg, recv, name);
-    rb_exc_raise(exc);
-}
-
-static inline bool
-rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type)
-{
-    return RB_TYPE_P(obj, T_DATA) && RTYPEDDATA_P(obj) && (RTYPEDDATA_TYPE(obj) == data_type);
-}
-
-#endif /* INTERNAL_ERROR_H */

data/vendor/bundle/ruby/2.7.0/gems/debase-ruby_core_source-3.3.6/lib/debase/ruby_core_source/ruby-3.4.0-preview1/internal/gc.h

@@ -1,334 +0,0 @@
-#ifndef INTERNAL_GC_H                                    /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_GC_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for GC.
- */
-#include "ruby/internal/config.h"
-
-#include <stddef.h>             /* for size_t */
-
-#include "internal/compilers.h" /* for __has_attribute */
-#include "ruby/ruby.h"          /* for rb_event_flag_t */
-#include "vm_core.h"            /* for GET_EC() */
-
-#ifndef USE_SHARED_GC
-# define USE_SHARED_GC 0
-#endif
-
-#if defined(__x86_64__) && !defined(_ILP32) && defined(__GNUC__)
-#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movq\t%%rsp, %0" : "=r" (*(p)))
-#elif defined(__i386) && defined(__GNUC__)
-#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movl\t%%esp, %0" : "=r" (*(p)))
-#elif (defined(__powerpc__) || defined(__powerpc64__)) && defined(__GNUC__) && !defined(_AIX) && !defined(__APPLE__) // Not Apple is NEEDED to unbreak ppc64 build on Darwin. Don't ask.
-#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("mr\t%0, %%r1" : "=r" (*(p)))
-#elif (defined(__powerpc__) || defined(__powerpc64__)) && defined(__GNUC__) && defined(_AIX)
-#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("mr %0,1" : "=r" (*(p)))
-#elif defined(__POWERPC__) && defined(__APPLE__) // Darwin ppc and ppc64
-#define SET_MACHINE_STACK_END(p) __asm__ volatile("mr %0, r1" : "=r" (*(p)))
-#elif defined(__aarch64__) && defined(__GNUC__)
-#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("mov\t%0, sp" : "=r" (*(p)))
-#else
-NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
-#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
-#define USE_CONSERVATIVE_STACK_END
-#endif
-
-/* for GC debug */
-
-#ifndef RUBY_MARK_FREE_DEBUG
-#define RUBY_MARK_FREE_DEBUG 0
-#endif
-
-#if RUBY_MARK_FREE_DEBUG
-extern int ruby_gc_debug_indent;
-
-static inline void
-rb_gc_debug_indent(void)
-{
-    ruby_debug_printf("%*s", ruby_gc_debug_indent, "");
-}
-
-static inline void
-rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
-{
-    if (st == 0) {
-        ruby_gc_debug_indent--;
-    }
-    rb_gc_debug_indent();
-    ruby_debug_printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
-
-    if (st) {
-        ruby_gc_debug_indent++;
-    }
-
-    fflush(stdout);
-}
-
-#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", (msg), 1, ptr)
-#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", (msg), 0, ptr)
-#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", (msg), 1, ptr)
-#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", (msg), 0, ptr)
-#define RUBY_GC_INFO         rb_gc_debug_indent(), ruby_debug_printf
-
-#else
-#define RUBY_MARK_ENTER(msg)
-#define RUBY_MARK_LEAVE(msg)
-#define RUBY_FREE_ENTER(msg)
-#define RUBY_FREE_LEAVE(msg)
-#define RUBY_GC_INFO if(0)printf
-#endif
-
-#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
-
-#if STACK_GROW_DIRECTION > 0
-# define STACK_UPPER(x, a, b) (a)
-#elif STACK_GROW_DIRECTION < 0
-# define STACK_UPPER(x, a, b) (b)
-#else
-RUBY_EXTERN int ruby_stack_grow_direction;
-int ruby_get_stack_grow_direction(volatile VALUE *addr);
-# define stack_growup_p(x) (			\
-        (ruby_stack_grow_direction ?		\
-         ruby_stack_grow_direction :		\
-         ruby_get_stack_grow_direction(x)) > 0)
-# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? (a) : (b))
-#endif
-
-/*
-  STACK_GROW_DIR_DETECTION is used with STACK_DIR_UPPER.
-
-  On most normal systems, stacks grow from high address to lower address. In
-  this case, STACK_DIR_UPPER(a, b) will return (b), but on exotic systems where
-  the stack grows UP (from low address to high address), it will return (a).
-*/
-
-#if STACK_GROW_DIRECTION
-#define STACK_GROW_DIR_DETECTION
-#define STACK_DIR_UPPER(a,b) STACK_UPPER(0, (a), (b))
-#else
-#define STACK_GROW_DIR_DETECTION VALUE stack_grow_dir_detection
-#define STACK_DIR_UPPER(a,b) STACK_UPPER(&stack_grow_dir_detection, (a), (b))
-#endif
-#define IS_STACK_DIR_UPPER() STACK_DIR_UPPER(1,0)
-
-const char *rb_obj_info(VALUE obj);
-const char *rb_raw_obj_info(char *const buff, const size_t buff_size, VALUE obj);
-
-struct rb_execution_context_struct; /* in vm_core.h */
-struct rb_objspace; /* in vm_core.h */
-
-#define NEWOBJ_OF(var, T, c, f, s, ec) \
-    T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
-            rb_wb_protected_newobj_of((ec ? ec : GET_EC()), (c), (f) & ~FL_WB_PROTECTED, s) : \
-            rb_wb_unprotected_newobj_of((c), (f), s))
-
-#define RB_OBJ_GC_FLAGS_MAX 6   /* used in ext/objspace */
-
-#ifndef USE_UNALIGNED_MEMBER_ACCESS
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#elif ! USE_UNALIGNED_MEMBER_ACCESS
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#elif ! (__has_warning("-Waddress-of-packed-member") || GCC_VERSION_SINCE(9, 0, 0))
-# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
-#else
-# include "internal/warnings.h"
-# define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
-    __typeof__(expr) unaligned_member_access_result = (expr); \
-    COMPILER_WARNING_POP; \
-    unaligned_member_access_result; \
-})
-
-# define UNALIGNED_MEMBER_PTR(ptr, mem) __extension__({ \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
-    const volatile void *unaligned_member_ptr_result = &(ptr)->mem; \
-    COMPILER_WARNING_POP; \
-    (__typeof__((ptr)->mem) *)unaligned_member_ptr_result; \
-})
-#endif
-
-#ifndef UNALIGNED_MEMBER_PTR
-# define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
-#endif
-
-#define RB_OBJ_WRITE_UNALIGNED(old, slot, young) do { \
-    VALUE *_slot = UNALIGNED_MEMBER_ACCESS(slot); \
-    RB_OBJ_WRITE(old, _slot, young); \
-} while (0)
-
-// We use SIZE_POOL_COUNT number of shape IDs for transitions out of different size pools
-// The next available shape ID will be the SPECIAL_CONST_SHAPE_ID
-#ifndef SIZE_POOL_COUNT
-# define SIZE_POOL_COUNT 5
-#endif
-
-/* Used in places that could malloc during, which can cause the GC to run. We
- * need to temporarily disable the GC to allow the malloc to happen.
- * Allocating memory during GC is a bad idea, so use this only when absolutely
- * necessary. */
-#define DURING_GC_COULD_MALLOC_REGION_START() \
-    assert(rb_during_gc()); \
-    VALUE _already_disabled = rb_gc_disable_no_rest()
-
-#define DURING_GC_COULD_MALLOC_REGION_END() \
-    if (_already_disabled == Qfalse) rb_gc_enable()
-
-typedef struct ractor_newobj_size_pool_cache {
-    struct RVALUE *freelist;
-    struct heap_page *using_page;
-} rb_ractor_newobj_size_pool_cache_t;
-
-typedef struct ractor_newobj_cache {
-    size_t incremental_mark_step_allocated_slots;
-    rb_ractor_newobj_size_pool_cache_t size_pool_caches[SIZE_POOL_COUNT];
-} rb_ractor_newobj_cache_t;
-
-/* gc.c */
-extern int ruby_disable_gc;
-RUBY_ATTR_MALLOC void *ruby_mimmalloc(size_t size);
-RUBY_ATTR_MALLOC void *ruby_mimcalloc(size_t num, size_t size);
-void ruby_mimfree(void *ptr);
-void rb_gc_prepare_heap(void);
-void rb_objspace_set_event_hook(const rb_event_flag_t event);
-VALUE rb_objspace_gc_enable(struct rb_objspace *);
-VALUE rb_objspace_gc_disable(struct rb_objspace *);
-void ruby_gc_set_params(void);
-void rb_gc_copy_attributes(VALUE dest, VALUE obj);
-size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
-size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE); /* used in iseq.h */
-size_t rb_malloc_grow_capa(size_t current_capacity, size_t type_size);
-RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add(size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add(size_t, size_t, size_t);
-void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t);
-RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t);
-static inline void *ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
-static inline void *ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
-static inline void ruby_sized_xfree_inlined(void *ptr, size_t size);
-void rb_gc_ractor_newobj_cache_clear(rb_ractor_newobj_cache_t *newobj_cache);
-bool rb_gc_size_allocatable_p(size_t size);
-size_t *rb_gc_size_pool_sizes(void);
-size_t rb_gc_size_pool_id_for_size(size_t size);
-int rb_objspace_garbage_object_p(VALUE obj);
-bool rb_gc_is_ptr_to_obj(const void *ptr);
-
-void rb_gc_mark_and_move(VALUE *ptr);
-
-void rb_gc_mark_weak(VALUE *ptr);
-void rb_gc_remove_weak(VALUE parent_obj, VALUE *ptr);
-
-void rb_gc_ref_update_table_values_only(st_table *tbl);
-
-void rb_gc_initial_stress_set(VALUE flag);
-
-#define rb_gc_mark_and_move_ptr(ptr) do { \
-    VALUE _obj = (VALUE)*(ptr); \
-    rb_gc_mark_and_move(&_obj); \
-    if (_obj != (VALUE)*(ptr)) *(ptr) = (void *)_obj; \
-} while (0)
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* exports for objspace module */
-void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
-void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *data);
-int rb_objspace_markable_object_p(VALUE obj);
-int rb_objspace_internal_object_p(VALUE obj);
-
-void rb_objspace_each_objects(
-    int (*callback)(void *start, void *end, size_t stride, void *data),
-    void *data);
-
-size_t rb_gc_obj_slot_size(VALUE obj);
-
-VALUE rb_gc_disable_no_rest(void);
-
-
-/* gc.c (export) */
-const char *rb_objspace_data_type_name(VALUE obj);
-VALUE rb_wb_protected_newobj_of(struct rb_execution_context_struct *, VALUE, VALUE, size_t);
-VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE, size_t);
-size_t rb_obj_memsize_of(VALUE);
-void rb_gc_verify_internal_consistency(void);
-size_t rb_obj_gc_flags(VALUE, ID[], size_t);
-void rb_gc_mark_values(long n, const VALUE *values);
-void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
-void rb_gc_update_values(long n, VALUE *values);
-void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
-void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
-void ruby_sized_xfree(void *x, size_t size);
-RUBY_SYMBOL_EXPORT_END
-
-int rb_ec_stack_check(struct rb_execution_context_struct *ec);
-void rb_gc_writebarrier_remember(VALUE obj);
-const char *rb_obj_info(VALUE obj);
-
-#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
-
-static inline void *
-ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
-{
-    return ruby_xrealloc(ptr, new_size);
-}
-
-static inline void *
-ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
-{
-    return ruby_xrealloc2(ptr, new_count, elemsiz);
-}
-
-static inline void
-ruby_sized_xfree_inlined(void *ptr, size_t size)
-{
-    ruby_xfree(ptr);
-}
-
-# define SIZED_REALLOC_N(x, y, z, w) REALLOC_N(x, y, z)
-
-static inline void *
-ruby_sized_realloc_n(void *ptr, size_t new_count, size_t element_size, size_t old_count)
-{
-    return ruby_xrealloc2(ptr, new_count, element_size);
-}
-
-#else
-
-static inline void *
-ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
-{
-    return ruby_sized_xrealloc(ptr, new_size, old_size);
-}
-
-static inline void *
-ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
-{
-    return ruby_sized_xrealloc2(ptr, new_count, elemsiz, old_count);
-}
-
-static inline void
-ruby_sized_xfree_inlined(void *ptr, size_t size)
-{
-    ruby_sized_xfree(ptr, size);
-}
-
-# define SIZED_REALLOC_N(v, T, m, n) \
-    ((v) = (T *)ruby_sized_xrealloc2((void *)(v), (m), sizeof(T), (n)))
-
-static inline void *
-ruby_sized_realloc_n(void *ptr, size_t new_count, size_t element_size, size_t old_count)
-{
-    return ruby_sized_xrealloc2(ptr, new_count, element_size, old_count);
-}
-
-#endif /* HAVE_MALLOC_USABLE_SIZE */
-
-#define ruby_sized_xrealloc ruby_sized_xrealloc_inlined
-#define ruby_sized_xrealloc2 ruby_sized_xrealloc2_inlined
-#define ruby_sized_xfree ruby_sized_xfree_inlined
-#endif /* INTERNAL_GC_H */