diff options
Diffstat (limited to 'include/ruby/ruby.h')
| -rw-r--r-- | include/ruby/ruby.h | 2549 |
1 files changed, 383 insertions, 2166 deletions
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index bc9c08067b..ca794bcaeb 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -1,2229 +1,446 @@ -/********************************************************************** - - ruby/ruby.h - - - $Author$ - created at: Thu Jun 10 14:26:32 JST 1993 - - Copyright (C) 1993-2008 Yukihiro Matsumoto - Copyright (C) 2000 Network Applied Communication Laboratory, Inc. - Copyright (C) 2000 Information-technology Promotion Agency, Japan - -**********************************************************************/ - -#ifndef RUBY_RUBY_H +#ifndef RUBY_RUBY_H /*-*-C++-*-vi:se ft=cpp:*/ #define RUBY_RUBY_H 1 +/** + * @file + * @author $Author$ + * @date Thu Jun 10 14:26:32 JST 1993 + * @copyright Copyright (C) 1993-2008 Yukihiro Matsumoto + * @copyright Copyright (C) 2000 Network Applied Communication Laboratory, Inc. + * @copyright Copyright (C) 2000 Information-technology Promotion Agency, Japan + * @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. + */ +#include "ruby/internal/config.h" -#if defined(__cplusplus) -extern "C" { -#if 0 -} /* satisfy cc-mode */ -#endif -#endif - -#include "ruby/config.h" -#ifdef RUBY_EXTCONF_H -#include RUBY_EXTCONF_H -#endif - -#if defined(__cplusplus) -/* __builtin_choose_expr and __builtin_types_compatible aren't available - * on C++. See https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */ -# undef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P -# undef HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P -#endif - -#include "defines.h" - -#define NORETURN_STYLE_NEW 1 -#ifndef NORETURN -# define NORETURN(x) x -#endif -#ifndef DEPRECATED -# define DEPRECATED(x) x -#endif -#ifndef DEPRECATED_BY -# define DEPRECATED_BY(n,x) DEPRECATED(x) -#endif -#ifndef DEPRECATED_TYPE -# define DEPRECATED_TYPE(mesg, decl) decl -#endif -#ifndef NOINLINE -# define NOINLINE(x) x -#endif -#ifndef ASSUME -# ifdef UNREACHABLE -# define ASSUME(x) (LIKELY(!!(x)) ? (void)0 : UNREACHABLE) -# else -# define ASSUME(x) ((void)(x)) -# endif -#endif -#ifndef UNREACHABLE -# define UNREACHABLE ((void)0) /* unreachable */ -#endif - -#ifdef __GNUC__ -#define PRINTF_ARGS(decl, string_index, first_to_check) \ - decl __attribute__((format(printf, string_index, first_to_check))) -#else -#define PRINTF_ARGS(decl, string_index, first_to_check) decl -#endif - -#define RUBY_MACRO_SELECT(base, n) TOKEN_PASTE(base, n) - +/* @shyouhei doesn't understand why we need <intrinsics.h> at this very + * beginning of the entire <ruby.h> circus. */ #ifdef HAVE_INTRINSICS_H # include <intrinsics.h> #endif #include <stdarg.h> -RUBY_SYMBOL_EXPORT_BEGIN - -/* Make alloca work the best possible way. */ -#ifdef __GNUC__ -# ifndef atarist -# ifndef alloca -# define alloca __builtin_alloca -# endif -# endif /* atarist */ -#else -# ifdef HAVE_ALLOCA_H -# include <alloca.h> -# else -# ifdef _AIX -#pragma alloca -# else -# ifndef alloca /* predefined by HP cc +Olibcalls */ -void *alloca(); -# endif -# endif /* AIX */ -# endif /* HAVE_ALLOCA_H */ -#endif /* __GNUC__ */ - -#if defined HAVE_UINTPTR_T && 0 -typedef uintptr_t VALUE; -typedef uintptr_t ID; -# define SIGNED_VALUE intptr_t -# define SIZEOF_VALUE SIZEOF_UINTPTR_T -# undef PRI_VALUE_PREFIX -#elif SIZEOF_LONG == SIZEOF_VOIDP -typedef unsigned long VALUE; -typedef unsigned long ID; -# define SIGNED_VALUE long -# define SIZEOF_VALUE SIZEOF_LONG -# define PRI_VALUE_PREFIX "l" -#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP -typedef unsigned LONG_LONG VALUE; -typedef unsigned LONG_LONG ID; -# define SIGNED_VALUE LONG_LONG -# define LONG_LONG_VALUE 1 -# define SIZEOF_VALUE SIZEOF_LONG_LONG -# define PRI_VALUE_PREFIX PRI_LL_PREFIX -#else -# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<---- -#endif - -typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1]; -typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1]; -#ifdef HAVE_LONG_LONG -typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1]; -#endif -typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; - -#ifndef PRI_INT_PREFIX -#define PRI_INT_PREFIX "" -#endif -#ifndef PRI_LONG_PREFIX -#define PRI_LONG_PREFIX "l" -#endif - -#if SIZEOF_LONG == 8 -#define PRI_64_PREFIX PRI_LONG_PREFIX -#elif SIZEOF_LONG_LONG == 8 -#define PRI_64_PREFIX PRI_LL_PREFIX -#endif - -#define RUBY_PRI_VALUE_MARK "\v" -#if defined PRIdPTR && !defined PRI_VALUE_PREFIX -#define PRIdVALUE PRIdPTR -#define PRIoVALUE PRIoPTR -#define PRIuVALUE PRIuPTR -#define PRIxVALUE PRIxPTR -#define PRIXVALUE PRIXPTR -#define PRIsVALUE PRIiPTR"" RUBY_PRI_VALUE_MARK -#else -#define PRIdVALUE PRI_VALUE_PREFIX"d" -#define PRIoVALUE PRI_VALUE_PREFIX"o" -#define PRIuVALUE PRI_VALUE_PREFIX"u" -#define PRIxVALUE PRI_VALUE_PREFIX"x" -#define PRIXVALUE PRI_VALUE_PREFIX"X" -#define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK -#endif -#ifndef PRI_VALUE_PREFIX -# define PRI_VALUE_PREFIX "" -#endif - -#ifndef PRI_TIMET_PREFIX -# if SIZEOF_TIME_T == SIZEOF_INT -# define PRI_TIMET_PREFIX -# elif SIZEOF_TIME_T == SIZEOF_LONG -# define PRI_TIMET_PREFIX "l" -# elif SIZEOF_TIME_T == SIZEOF_LONG_LONG -# define PRI_TIMET_PREFIX PRI_LL_PREFIX -# endif -#endif - -#if defined PRI_PTRDIFF_PREFIX -#elif SIZEOF_PTRDIFF_T == SIZEOF_INT -# define PRI_PTRDIFF_PREFIX "" -#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG -# define PRI_PTRDIFF_PREFIX "l" -#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG -# define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX -#endif -#define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d" -#define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i" -#define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o" -#define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u" -#define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x" -#define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X" - -#if defined PRI_SIZE_PREFIX -#elif SIZEOF_SIZE_T == SIZEOF_INT -# define PRI_SIZE_PREFIX "" -#elif SIZEOF_SIZE_T == SIZEOF_LONG -# define PRI_SIZE_PREFIX "l" -#elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG -# define PRI_SIZE_PREFIX PRI_LL_PREFIX -#endif -#define PRIdSIZE PRI_SIZE_PREFIX"d" -#define PRIiSIZE PRI_SIZE_PREFIX"i" -#define PRIoSIZE PRI_SIZE_PREFIX"o" -#define PRIuSIZE PRI_SIZE_PREFIX"u" -#define PRIxSIZE PRI_SIZE_PREFIX"x" -#define PRIXSIZE PRI_SIZE_PREFIX"X" - -#ifdef __STDC__ -# include <limits.h> -#else -# ifndef LONG_MAX -# ifdef HAVE_LIMITS_H -# include <limits.h> -# else - /* assuming 32bit(2's complement) long */ -# define LONG_MAX 2147483647 -# endif -# endif -# ifndef LONG_MIN -# define LONG_MIN (-LONG_MAX-1) -# endif -# ifndef CHAR_BIT -# define CHAR_BIT 8 -# endif -#endif - -#ifdef HAVE_LONG_LONG -# ifndef LLONG_MAX -# ifdef LONG_LONG_MAX -# define LLONG_MAX LONG_LONG_MAX -# else -# ifdef _I64_MAX -# define LLONG_MAX _I64_MAX -# else - /* assuming 64bit(2's complement) long long */ -# define LLONG_MAX 9223372036854775807LL -# endif -# endif -# endif -# ifndef LLONG_MIN -# ifdef LONG_LONG_MIN -# define LLONG_MIN LONG_LONG_MIN -# else -# ifdef _I64_MIN -# define LLONG_MIN _I64_MIN -# else -# define LLONG_MIN (-LLONG_MAX-1) -# endif -# endif -# endif -#endif - -#define RUBY_FIXNUM_MAX (LONG_MAX>>1) -#define RUBY_FIXNUM_MIN RSHIFT((long)LONG_MIN,1) -#define FIXNUM_MAX RUBY_FIXNUM_MAX -#define FIXNUM_MIN RUBY_FIXNUM_MIN - -#define INT2FIX(i) (((VALUE)(i))<<1 | RUBY_FIXNUM_FLAG) -#define LONG2FIX(i) INT2FIX(i) -#define rb_fix_new(v) INT2FIX(v) -VALUE rb_int2inum(SIGNED_VALUE); - -#define rb_int_new(v) rb_int2inum(v) -VALUE rb_uint2inum(VALUE); - -#define rb_uint_new(v) rb_uint2inum(v) - -#ifdef HAVE_LONG_LONG -VALUE rb_ll2inum(LONG_LONG); -#define LL2NUM(v) rb_ll2inum(v) -VALUE rb_ull2inum(unsigned LONG_LONG); -#define ULL2NUM(v) rb_ull2inum(v) -#endif - -#ifndef OFFT2NUM -#if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) -# define OFFT2NUM(v) LL2NUM(v) -#elif SIZEOF_OFF_T == SIZEOF_LONG -# define OFFT2NUM(v) LONG2NUM(v) -#else -# define OFFT2NUM(v) INT2NUM(v) -#endif -#endif - -#if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) -# define SIZET2NUM(v) ULL2NUM(v) -# define SSIZET2NUM(v) LL2NUM(v) -#elif SIZEOF_SIZE_T == SIZEOF_LONG -# define SIZET2NUM(v) ULONG2NUM(v) -# define SSIZET2NUM(v) LONG2NUM(v) -#else -# define SIZET2NUM(v) UINT2NUM(v) -# define SSIZET2NUM(v) INT2NUM(v) -#endif - -#ifndef SIZE_MAX -# if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) -# define SIZE_MAX ULLONG_MAX -# define SIZE_MIN ULLONG_MIN -# elif SIZEOF_SIZE_T == SIZEOF_LONG -# define SIZE_MAX ULONG_MAX -# define SIZE_MIN ULONG_MIN -# elif SIZEOF_SIZE_T == SIZEOF_INT -# define SIZE_MAX UINT_MAX -# define SIZE_MIN UINT_MIN -# else -# define SIZE_MAX USHRT_MAX -# define SIZE_MIN USHRT_MIN -# endif -#endif - -#ifndef SSIZE_MAX -# if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) -# define SSIZE_MAX LLONG_MAX -# define SSIZE_MIN LLONG_MIN -# elif SIZEOF_SIZE_T == SIZEOF_LONG -# define SSIZE_MAX LONG_MAX -# define SSIZE_MIN LONG_MIN -# elif SIZEOF_SIZE_T == SIZEOF_INT -# define SSIZE_MAX INT_MAX -# define SSIZE_MIN INT_MIN -# else -# define SSIZE_MAX SHRT_MAX -# define SSIZE_MIN SHRT_MIN -# endif -#endif - -#if SIZEOF_INT < SIZEOF_VALUE -NORETURN(void rb_out_of_int(SIGNED_VALUE num)); -#endif - -#if SIZEOF_INT < SIZEOF_LONG -static inline int -rb_long2int_inline(long n) -{ - int i = (int)n; - if ((long)i != n) - rb_out_of_int(n); - - return i; -} -#define rb_long2int(n) rb_long2int_inline(n) -#else -#define rb_long2int(n) ((int)(n)) -#endif - -#ifndef PIDT2NUM -#define PIDT2NUM(v) LONG2NUM(v) -#endif -#ifndef NUM2PIDT -#define NUM2PIDT(v) NUM2LONG(v) -#endif -#ifndef UIDT2NUM -#define UIDT2NUM(v) LONG2NUM(v) -#endif -#ifndef NUM2UIDT -#define NUM2UIDT(v) NUM2LONG(v) -#endif -#ifndef GIDT2NUM -#define GIDT2NUM(v) LONG2NUM(v) -#endif -#ifndef NUM2GIDT -#define NUM2GIDT(v) NUM2LONG(v) -#endif -#ifndef NUM2MODET -#define NUM2MODET(v) NUM2INT(v) -#endif -#ifndef MODET2NUM -#define MODET2NUM(v) INT2NUM(v) -#endif - -#define RB_FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1)) -static inline long -rb_fix2long(VALUE x) -{ - return RB_FIX2LONG(x); -} -#define RB_FIX2ULONG(x) ((unsigned long)RB_FIX2LONG(x)) -static inline unsigned long -rb_fix2ulong(VALUE x) -{ - return RB_FIX2ULONG(x); -} -#define RB_FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&RUBY_FIXNUM_FLAG) -#define RB_POSFIXABLE(f) ((f) < RUBY_FIXNUM_MAX+1) -#define RB_NEGFIXABLE(f) ((f) >= RUBY_FIXNUM_MIN) -#define RB_FIXABLE(f) (RB_POSFIXABLE(f) && RB_NEGFIXABLE(f)) -#define FIX2LONG(x) RB_FIX2LONG(x) -#define FIX2ULONG(x) RB_FIX2ULONG(x) -#define FIXNUM_P(f) RB_FIXNUM_P(f) -#define POSFIXABLE(f) RB_POSFIXABLE(f) -#define NEGFIXABLE(f) RB_NEGFIXABLE(f) -#define FIXABLE(f) RB_FIXABLE(f) - -#define RB_IMMEDIATE_P(x) ((VALUE)(x) & RUBY_IMMEDIATE_MASK) -#define IMMEDIATE_P(x) RB_IMMEDIATE_P(x) - -ID rb_sym2id(VALUE); -VALUE rb_id2sym(ID); -#define RB_STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT)) == RUBY_SYMBOL_FLAG) -#define RB_DYNAMIC_SYM_P(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) == (RUBY_T_SYMBOL)) -#define RB_SYMBOL_P(x) (RB_STATIC_SYM_P(x)||RB_DYNAMIC_SYM_P(x)) -#define RB_ID2SYM(x) (rb_id2sym(x)) -#define RB_SYM2ID(x) (rb_sym2id(x)) -#define STATIC_SYM_P(x) RB_STATIC_SYM_P(x) -#define DYNAMIC_SYM_P(x) RB_DYNAMIC_SYM_P(x) -#define SYMBOL_P(x) RB_SYMBOL_P(x) -#define ID2SYM(x) RB_ID2SYM(x) -#define SYM2ID(x) RB_SYM2ID(x) - -#ifndef USE_FLONUM -#if SIZEOF_VALUE >= SIZEOF_DOUBLE -#define USE_FLONUM 1 -#else -#define USE_FLONUM 0 -#endif -#endif - -#if USE_FLONUM -#define RB_FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG) -#else -#define RB_FLONUM_P(x) 0 -#endif -#define FLONUM_P(x) RB_FLONUM_P(x) +#include "defines.h" +#include "ruby/internal/abi.h" +#include "ruby/internal/anyargs.h" +#include "ruby/internal/arithmetic.h" +#include "ruby/internal/core.h" +#include "ruby/internal/ctype.h" +#include "ruby/internal/dllexport.h" +#include "ruby/internal/error.h" +#include "ruby/internal/eval.h" +#include "ruby/internal/event.h" +#include "ruby/internal/fl_type.h" +#include "ruby/internal/gc.h" +#include "ruby/internal/glob.h" +#include "ruby/internal/globals.h" +#include "ruby/internal/has/warning.h" +#include "ruby/internal/interpreter.h" +#include "ruby/internal/iterator.h" +#include "ruby/internal/memory.h" +#include "ruby/internal/method.h" +#include "ruby/internal/module.h" +#include "ruby/internal/newobj.h" +#include "ruby/internal/scan_args.h" +#include "ruby/internal/special_consts.h" +#include "ruby/internal/symbol.h" +#include "ruby/internal/value.h" +#include "ruby/internal/value_type.h" +#include "ruby/internal/variable.h" +#include "ruby/assert.h" +#include "ruby/backward/2/assume.h" +#include "ruby/backward/2/inttypes.h" +#include "ruby/backward/2/limits.h" + +RBIMPL_SYMBOL_EXPORT_BEGIN() /* Module#methods, #singleton_methods and so on return Symbols */ +/** + * @private + * + * @deprecated This macro once was a thing in the old days, but makes no sense + * any longer today. Exists here for backwards compatibility + * only. You can safely forget about it. + */ #define USE_SYMBOL_AS_METHOD_NAME 1 -/* special constants - i.e. non-zero and non-fixnum constants */ -enum ruby_special_consts { -#if USE_FLONUM - RUBY_Qfalse = 0x00, /* ...0000 0000 */ - RUBY_Qtrue = 0x14, /* ...0001 0100 */ - RUBY_Qnil = 0x08, /* ...0000 1000 */ - RUBY_Qundef = 0x34, /* ...0011 0100 */ - - RUBY_IMMEDIATE_MASK = 0x07, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x03, - RUBY_FLONUM_FLAG = 0x02, /* ...xxxx xx10 */ - RUBY_SYMBOL_FLAG = 0x0c, /* ...0000 1100 */ -#else - RUBY_Qfalse = 0, /* ...0000 0000 */ - RUBY_Qtrue = 2, /* ...0000 0010 */ - RUBY_Qnil = 4, /* ...0000 0100 */ - RUBY_Qundef = 6, /* ...0000 0110 */ - - RUBY_IMMEDIATE_MASK = 0x03, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */ - RUBY_FLONUM_FLAG = 0x02, - RUBY_SYMBOL_FLAG = 0x0e, /* ...0000 1110 */ -#endif - RUBY_SPECIAL_SHIFT = 8 -}; - -#define Qfalse ((VALUE)RUBY_Qfalse) -#define Qtrue ((VALUE)RUBY_Qtrue) -#define Qnil ((VALUE)RUBY_Qnil) -#define Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */ -#define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK -#define FIXNUM_FLAG RUBY_FIXNUM_FLAG -#if USE_FLONUM -#define FLONUM_MASK RUBY_FLONUM_MASK -#define FLONUM_FLAG RUBY_FLONUM_FLAG -#endif -#define SYMBOL_FLAG RUBY_SYMBOL_FLAG - -#define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0) -#define NIL_P(v) !((VALUE)(v) != Qnil) - -#define CLASS_OF(v) rb_class_of((VALUE)(v)) - -enum ruby_value_type { - RUBY_T_NONE = 0x00, - - RUBY_T_OBJECT = 0x01, - RUBY_T_CLASS = 0x02, - RUBY_T_MODULE = 0x03, - RUBY_T_FLOAT = 0x04, - RUBY_T_STRING = 0x05, - RUBY_T_REGEXP = 0x06, - RUBY_T_ARRAY = 0x07, - RUBY_T_HASH = 0x08, - RUBY_T_STRUCT = 0x09, - RUBY_T_BIGNUM = 0x0a, - RUBY_T_FILE = 0x0b, - RUBY_T_DATA = 0x0c, - RUBY_T_MATCH = 0x0d, - RUBY_T_COMPLEX = 0x0e, - RUBY_T_RATIONAL = 0x0f, - - RUBY_T_NIL = 0x11, - RUBY_T_TRUE = 0x12, - RUBY_T_FALSE = 0x13, - RUBY_T_SYMBOL = 0x14, - RUBY_T_FIXNUM = 0x15, - RUBY_T_UNDEF = 0x16, - - RUBY_T_IMEMO = 0x1a, - RUBY_T_NODE = 0x1b, - RUBY_T_ICLASS = 0x1c, - RUBY_T_ZOMBIE = 0x1d, - - RUBY_T_MASK = 0x1f -}; - -#define T_NONE RUBY_T_NONE -#define T_NIL RUBY_T_NIL -#define T_OBJECT RUBY_T_OBJECT -#define T_CLASS RUBY_T_CLASS -#define T_ICLASS RUBY_T_ICLASS -#define T_MODULE RUBY_T_MODULE -#define T_FLOAT RUBY_T_FLOAT -#define T_STRING RUBY_T_STRING -#define T_REGEXP RUBY_T_REGEXP -#define T_ARRAY RUBY_T_ARRAY -#define T_HASH RUBY_T_HASH -#define T_STRUCT RUBY_T_STRUCT -#define T_BIGNUM RUBY_T_BIGNUM -#define T_FILE RUBY_T_FILE -#define T_FIXNUM RUBY_T_FIXNUM -#define T_TRUE RUBY_T_TRUE -#define T_FALSE RUBY_T_FALSE -#define T_DATA RUBY_T_DATA -#define T_MATCH RUBY_T_MATCH -#define T_SYMBOL RUBY_T_SYMBOL -#define T_RATIONAL RUBY_T_RATIONAL -#define T_COMPLEX RUBY_T_COMPLEX -#define T_IMEMO RUBY_T_IMEMO -#define T_UNDEF RUBY_T_UNDEF -#define T_NODE RUBY_T_NODE -#define T_ZOMBIE RUBY_T_ZOMBIE -#define T_MASK RUBY_T_MASK - -#define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK) -#define BUILTIN_TYPE(x) RB_BUILTIN_TYPE(x) - -static inline int rb_type(VALUE obj); -#define TYPE(x) rb_type((VALUE)(x)) - -#define RB_FLOAT_TYPE_P(obj) (\ - RB_FLONUM_P(obj) || \ - (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == RUBY_T_FLOAT)) - -#define RB_TYPE_P(obj, type) ( \ - ((type) == RUBY_T_FIXNUM) ? RB_FIXNUM_P(obj) : \ - ((type) == RUBY_T_TRUE) ? ((obj) == RUBY_Qtrue) : \ - ((type) == RUBY_T_FALSE) ? ((obj) == RUBY_Qfalse) : \ - ((type) == RUBY_T_NIL) ? ((obj) == RUBY_Qnil) : \ - ((type) == RUBY_T_UNDEF) ? ((obj) == RUBY_Qundef) : \ - ((type) == RUBY_T_SYMBOL) ? RB_SYMBOL_P(obj) : \ - ((type) == RUBY_T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \ - (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == (type))) - -/* RB_GC_GUARD_PTR() is an intermediate macro, and has no effect by - * itself. don't use it directly */ -#ifdef __GNUC__ -#define RB_GC_GUARD_PTR(ptr) \ - __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;}) -#else -#ifdef _MSC_VER -#pragma optimize("", off) -static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;} -#pragma optimize("", on) -#else -volatile VALUE *rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val); -#define HAVE_RB_GC_GUARDED_PTR_VAL 1 -#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr_val(&(v),(v))) -#endif -#define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr) -#endif - -#ifndef RB_GC_GUARD -#define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) -#endif - -#ifdef __GNUC__ -#define RB_UNUSED_VAR(x) x __attribute__ ((unused)) -#else -#define RB_UNUSED_VAR(x) x -#endif - -void rb_check_type(VALUE,int); -#define Check_Type(v,t) rb_check_type((VALUE)(v),(t)) - -VALUE rb_str_to_str(VALUE); -VALUE rb_string_value(volatile VALUE*); -char *rb_string_value_ptr(volatile VALUE*); -char *rb_string_value_cstr(volatile VALUE*); - -#define StringValue(v) rb_string_value(&(v)) -#define StringValuePtr(v) rb_string_value_ptr(&(v)) -#define StringValueCStr(v) rb_string_value_cstr(&(v)) - -void rb_check_safe_obj(VALUE); -#define SafeStringValue(v) do {\ - StringValue(v);\ - rb_check_safe_obj(v);\ -} while (0) -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use SafeStringValue() instead"))); -# define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) -#else -# define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">] -# define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">] -#endif - -VALUE rb_str_export(VALUE); -#define ExportStringValue(v) do {\ - SafeStringValue(v);\ - (v) = rb_str_export(v);\ -} while (0) -VALUE rb_str_export_locale(VALUE); +/** + * Converts an object to a path. It first tries `#to_path` method if any, then + * falls back to `#to_str` method. + * + * @param[in] obj Arbitrary ruby object. + * @exception rb_eArgError `obj` contains a NUL byte. + * @exception rb_eTypeError `obj` is not path-ish. + * @exception rb_eEncCompatError No encoding conversion from `obj` to path. + * @return Converted path object. + */ +VALUE rb_get_path(VALUE obj); -VALUE rb_get_path(VALUE); +/** + * Ensures that the parameter object is a path. + * + * @param[in,out] v Arbitrary ruby object. + * @exception rb_eArgError `v` contains a NUL byte. + * @exception rb_eTypeError `v` is not path-ish. + * @exception rb_eEncCompatError `v` is not path-compatible. + * @post `v` is a path. + */ #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v)) +/** + * @deprecated This function is an alias of rb_get_path() now. The part that + * did "no_checksafe" was deleted. It remains here because of no + * harm. + */ VALUE rb_get_path_no_checksafe(VALUE); -#define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v)) -#define RUBY_SAFE_LEVEL_MAX 1 -void rb_secure(int); -int rb_safe_level(void); -void rb_set_safe_level(int); -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -int ruby_safe_level_2_error(void) __attribute__((error("$SAFE=2 to 4 are obsolete"))); -int ruby_safe_level_2_warning(void) __attribute__((warning("$SAFE=2 to 4 are obsolete"))); -# ifdef RUBY_EXPORT -# define ruby_safe_level_2_warning() ruby_safe_level_2_error() -# endif -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(\ - __builtin_choose_expr(\ - __builtin_constant_p(level), \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)), 0)) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - __extension__(__builtin_choose_expr(RUBY_SAFE_LEVEL_INVALID_P(level), ruby_safe_level_2_##type(), (level))) -#else -/* in gcc 4.8 or earlier, __builtin_choose_expr() does not consider - * __builtin_constant_p(variable) a constant expression. +/** + * This macro actually does the same thing as #FilePathValue now. The "String" + * part indicates that this is for when a string is treated like a pathname, + * rather than the actual pathname on the file systems. For examples: + * `Dir.fnmatch?`, `File.join`, `File.basename`, etc. */ -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(__builtin_constant_p(level) && \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level))) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - (RUBY_SAFE_LEVEL_INVALID_P(level) ? ruby_safe_level_2_##type() : (level)) -#endif -#define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning)) -#define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error)) -#endif -void rb_set_safe_level_force(int); -void rb_secure_update(VALUE); -NORETURN(void rb_insecure_operation(void)); - -VALUE rb_errinfo(void); -void rb_set_errinfo(VALUE); - -long rb_num2long(VALUE); -unsigned long rb_num2ulong(VALUE); -static inline long -rb_num2long_inline(VALUE x) -{ - if (RB_FIXNUM_P(x)) - return RB_FIX2LONG(x); - else - return rb_num2long(x); -} -#define RB_NUM2LONG(x) rb_num2long_inline(x) -#define NUM2LONG(x) RB_NUM2LONG(x) -static inline unsigned long -rb_num2ulong_inline(VALUE x) -{ - if (RB_FIXNUM_P(x)) - return RB_FIX2ULONG(x); - else - return rb_num2ulong(x); -} -#define RB_NUM2ULONG(x) rb_num2ulong_inline(x) -#define NUM2ULONG(x) RB_NUM2ULONG(x) -#if SIZEOF_INT < SIZEOF_LONG -long rb_num2int(VALUE); -long rb_fix2int(VALUE); -#define RB_FIX2INT(x) ((int)rb_fix2int((VALUE)(x))) - -static inline int -rb_num2int_inline(VALUE x) -{ - if (RB_FIXNUM_P(x)) - return (int)rb_fix2int(x); - else - return (int)rb_num2int(x); -} -#define RB_NUM2INT(x) rb_num2int_inline(x) - -unsigned long rb_num2uint(VALUE); -#define RB_NUM2UINT(x) ((unsigned int)rb_num2uint(x)) -unsigned long rb_fix2uint(VALUE); -#define RB_FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) -#else /* SIZEOF_INT < SIZEOF_LONG */ -#define RB_NUM2INT(x) ((int)RB_NUM2LONG(x)) -#define RB_NUM2UINT(x) ((unsigned int)RB_NUM2ULONG(x)) -#define RB_FIX2INT(x) ((int)RB_FIX2LONG(x)) -#define RB_FIX2UINT(x) ((unsigned int)RB_FIX2ULONG(x)) -#endif /* SIZEOF_INT < SIZEOF_LONG */ -#define NUM2INT(x) RB_NUM2INT(x) -#define NUM2UINT(x) RB_NUM2UINT(x) -#define FIX2INT(x) RB_FIX2INT(x) -#define FIX2UINT(x) RB_FIX2UINT(x) - -short rb_num2short(VALUE); -unsigned short rb_num2ushort(VALUE); -short rb_fix2short(VALUE); -unsigned short rb_fix2ushort(VALUE); -#define RB_FIX2SHORT(x) (rb_fix2short((VALUE)(x))) -#define FIX2SHORT(x) RB_FIX2SHORT(x) -static inline short -rb_num2short_inline(VALUE x) -{ - if (RB_FIXNUM_P(x)) - return rb_fix2short(x); - else - return rb_num2short(x); -} - -#define RB_NUM2SHORT(x) rb_num2short_inline(x) -#define RB_NUM2USHORT(x) rb_num2ushort(x) -#define NUM2SHORT(x) RB_NUM2SHORT(x) -#define NUM2USHORT(x) RB_NUM2USHORT(x) - -#ifdef HAVE_LONG_LONG -LONG_LONG rb_num2ll(VALUE); -unsigned LONG_LONG rb_num2ull(VALUE); -static inline LONG_LONG -rb_num2ll_inline(VALUE x) -{ - if (RB_FIXNUM_P(x)) - return RB_FIX2LONG(x); - else - return rb_num2ll(x); -} -# define RB_NUM2LL(x) rb_num2ll_inline(x) -# define RB_NUM2ULL(x) rb_num2ull(x) -# define NUM2LL(x) RB_NUM2LL(x) -# define NUM2ULL(x) RB_NUM2ULL(x) -#endif - -#if !defined(NUM2OFFT) -# if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG -# define NUM2OFFT(x) ((off_t)NUM2LL(x)) -# else -# define NUM2OFFT(x) NUM2LONG(x) -# endif -#endif - -#if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG -# define NUM2SIZET(x) ((size_t)NUM2ULL(x)) -# define NUM2SSIZET(x) ((ssize_t)NUM2LL(x)) -#else -# define NUM2SIZET(x) NUM2ULONG(x) -# define NUM2SSIZET(x) NUM2LONG(x) -#endif - -double rb_num2dbl(VALUE); -#define NUM2DBL(x) rb_num2dbl((VALUE)(x)) - -VALUE rb_uint2big(VALUE); -VALUE rb_int2big(SIGNED_VALUE); - -VALUE rb_newobj(void); -VALUE rb_newobj_of(VALUE, VALUE); -VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type); -#define RB_NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj() -#define RB_NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags) -#define NEWOBJ(obj,type) RB_NEWOBJ(obj,type) -#define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags) /* core has special NEWOBJ_OF() in internal.h */ -#define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */ -#define CLONESETUP(clone,obj) rb_clone_setup(clone,obj) -#define DUPSETUP(dup,obj) rb_dup_setup(dup,obj) - -#ifndef USE_RGENGC -#define USE_RGENGC 1 -#ifndef USE_RINCGC -#define USE_RINCGC 1 -#endif -#endif - -#if USE_RGENGC == 0 -#define USE_RINCGC 0 -#endif - -#ifndef RGENGC_WB_PROTECTED_ARRAY -#define RGENGC_WB_PROTECTED_ARRAY 1 -#endif -#ifndef RGENGC_WB_PROTECTED_HASH -#define RGENGC_WB_PROTECTED_HASH 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRUCT -#define RGENGC_WB_PROTECTED_STRUCT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRING -#define RGENGC_WB_PROTECTED_STRING 1 -#endif -#ifndef RGENGC_WB_PROTECTED_OBJECT -#define RGENGC_WB_PROTECTED_OBJECT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_REGEXP -#define RGENGC_WB_PROTECTED_REGEXP 1 -#endif -#ifndef RGENGC_WB_PROTECTED_CLASS -#define RGENGC_WB_PROTECTED_CLASS 1 -#endif -#ifndef RGENGC_WB_PROTECTED_FLOAT -#define RGENGC_WB_PROTECTED_FLOAT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_COMPLEX -#define RGENGC_WB_PROTECTED_COMPLEX 1 -#endif -#ifndef RGENGC_WB_PROTECTED_RATIONAL -#define RGENGC_WB_PROTECTED_RATIONAL 1 -#endif -#ifndef RGENGC_WB_PROTECTED_BIGNUM -#define RGENGC_WB_PROTECTED_BIGNUM 1 -#endif -#ifndef RGENGC_WB_PROTECTED_NODE_CREF -#define RGENGC_WB_PROTECTED_NODE_CREF 1 -#endif - -enum ruby_fl_type { - RUBY_FL_WB_PROTECTED = (1<<5), - RUBY_FL_PROMOTED0 = (1<<5), - RUBY_FL_PROMOTED1 = (1<<6), - RUBY_FL_PROMOTED = RUBY_FL_PROMOTED0|RUBY_FL_PROMOTED1, - RUBY_FL_FINALIZE = (1<<7), - RUBY_FL_TAINT = (1<<8), - RUBY_FL_UNTRUSTED = RUBY_FL_TAINT, - RUBY_FL_EXIVAR = (1<<10), - RUBY_FL_FREEZE = (1<<11), - - RUBY_FL_USHIFT = 12, - -#define RUBY_FL_USER_N(n) RUBY_FL_USER##n = (1<<(RUBY_FL_USHIFT+n)) - RUBY_FL_USER_N(0), - RUBY_FL_USER_N(1), - RUBY_FL_USER_N(2), - RUBY_FL_USER_N(3), - RUBY_FL_USER_N(4), - RUBY_FL_USER_N(5), - RUBY_FL_USER_N(6), - RUBY_FL_USER_N(7), - RUBY_FL_USER_N(8), - RUBY_FL_USER_N(9), - RUBY_FL_USER_N(10), - RUBY_FL_USER_N(11), - RUBY_FL_USER_N(12), - RUBY_FL_USER_N(13), - RUBY_FL_USER_N(14), - RUBY_FL_USER_N(15), - RUBY_FL_USER_N(16), - RUBY_FL_USER_N(17), - RUBY_FL_USER_N(18), -#if defined ENUM_OVER_INT || SIZEOF_INT*CHAR_BIT>12+19+1 - RUBY_FL_USER_N(19), -#else -#define RUBY_FL_USER19 (((VALUE)1)<<(RUBY_FL_USHIFT+19)) -#endif - - RUBY_ELTS_SHARED = RUBY_FL_USER2, - RUBY_FL_DUPPED = (RUBY_T_MASK|RUBY_FL_EXIVAR|RUBY_FL_TAINT), - RUBY_FL_SINGLETON = RUBY_FL_USER0 -}; - -struct RBasic { - VALUE flags; - const VALUE klass; -} -#ifdef __GNUC__ - __attribute__((aligned(sizeof(VALUE)))) -#endif -; - -VALUE rb_obj_hide(VALUE obj); -VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change klass information */ - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -# define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \ - __extension__( \ - __builtin_choose_expr( \ - RGENGC_WB_PROTECTED_##type, \ - OBJ_WB_UNPROTECT((VALUE)(obj)), ((VALUE)(obj)))) -#else -# define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \ - (RGENGC_WB_PROTECTED_##type ? \ - OBJ_WB_UNPROTECT((VALUE)(obj)) : ((VALUE)(obj))) -#endif - -#define RBASIC_CLASS(obj) (RBASIC(obj)->klass) - -#define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX -#define ROBJECT_EMBED ROBJECT_EMBED -enum { - ROBJECT_EMBED_LEN_MAX = 3, - ROBJECT_EMBED = RUBY_FL_USER1, - - ROBJECT_ENUM_END -}; - -struct RObject { - struct RBasic basic; - union { - struct { - long numiv; /* only uses 32-bits */ - VALUE *ivptr; - void *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ - } heap; - VALUE ary[ROBJECT_EMBED_LEN_MAX]; - } as; -}; -#define ROBJECT_NUMIV(o) \ - ((RBASIC(o)->flags & ROBJECT_EMBED) ? \ - ROBJECT_EMBED_LEN_MAX : \ - ROBJECT(o)->as.heap.numiv) -#define ROBJECT_IVPTR(o) \ - ((RBASIC(o)->flags & ROBJECT_EMBED) ? \ - ROBJECT(o)->as.ary : \ - ROBJECT(o)->as.heap.ivptr) -#define ROBJECT_IV_INDEX_TBL(o) \ - ((RBASIC(o)->flags & ROBJECT_EMBED) ? \ - RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \ - ROBJECT(o)->as.heap.iv_index_tbl) - -#define RClass RClassDeprecated -#ifndef __cplusplus -DEPRECATED_TYPE(("RClass is internal use only"), -struct RClass { - struct RBasic basic; -}); -#endif -#define RCLASS_SUPER(c) rb_class_get_superclass(c) -#define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m) -#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m) -#define RMODULE_M_TBL(m) RCLASS_M_TBL(m) -#define RMODULE_SUPER(m) RCLASS_SUPER(m) -#define RMODULE_IS_OVERLAID RMODULE_IS_OVERLAID -#define RMODULE_IS_REFINEMENT RMODULE_IS_REFINEMENT -#define RMODULE_INCLUDED_INTO_REFINEMENT RMODULE_INCLUDED_INTO_REFINEMENT -enum { - RMODULE_IS_OVERLAID = RUBY_FL_USER2, - RMODULE_IS_REFINEMENT = RUBY_FL_USER3, - RMODULE_INCLUDED_INTO_REFINEMENT = RUBY_FL_USER4, - - RMODULE_ENUM_END -}; - -double rb_float_value(VALUE); -VALUE rb_float_new(double); -VALUE rb_float_new_in_heap(double); - -#define RFLOAT_VALUE(v) rb_float_value(v) -#define DBL2NUM(dbl) rb_float_new(dbl) - -#define RUBY_ELTS_SHARED RUBY_ELTS_SHARED -#define ELTS_SHARED RUBY_ELTS_SHARED - -#define RSTRING_NOEMBED RSTRING_NOEMBED -#define RSTRING_EMBED_LEN_MASK RSTRING_EMBED_LEN_MASK -#define RSTRING_EMBED_LEN_SHIFT RSTRING_EMBED_LEN_SHIFT -#define RSTRING_EMBED_LEN_MAX RSTRING_EMBED_LEN_MAX -#define RSTRING_FSTR RSTRING_FSTR -enum { - RSTRING_NOEMBED = RUBY_FL_USER1, - RSTRING_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4| - RUBY_FL_USER5|RUBY_FL_USER6), - RSTRING_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+2), - RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*3)/sizeof(char)-1), - RSTRING_FSTR = RUBY_FL_USER17, - - RSTRING_ENUM_END -}; -struct RString { - struct RBasic basic; - union { - struct { - long len; - char *ptr; - union { - long capa; - VALUE shared; - } aux; - } heap; - char ary[RSTRING_EMBED_LEN_MAX + 1]; - } as; -}; -#define RSTRING_EMBED_LEN(str) \ - (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ - (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) -#define RSTRING_LEN(str) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - RSTRING_EMBED_LEN(str) : \ - RSTRING(str)->as.heap.len) -#define RSTRING_PTR(str) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - RSTRING(str)->as.ary : \ - RSTRING(str)->as.heap.ptr) -#define RSTRING_END(str) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \ - (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len)) -#define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str)) -#define RSTRING_GETMEM(str, ptrvar, lenvar) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \ - ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len)) - -#define RARRAY_EMBED_FLAG RARRAY_EMBED_FLAG -#define RARRAY_EMBED_LEN_MASK RARRAY_EMBED_LEN_MASK -#define RARRAY_EMBED_LEN_MAX RARRAY_EMBED_LEN_MAX -#define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT -enum { - RARRAY_EMBED_LEN_MAX = 3, - RARRAY_EMBED_FLAG = RUBY_FL_USER1, - /* RUBY_FL_USER2 is for ELTS_SHARED */ - RARRAY_EMBED_LEN_MASK = (RUBY_FL_USER4|RUBY_FL_USER3), - RARRAY_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+3), - - RARRAY_ENUM_END -}; -struct RArray { - struct RBasic basic; - union { - struct { - long len; - union { - long capa; - VALUE shared; - } aux; - const VALUE *ptr; - } heap; - const VALUE ary[RARRAY_EMBED_LEN_MAX]; - } as; -}; -#define RARRAY_EMBED_LEN(a) \ - (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \ - (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) -#define RARRAY_LEN(a) rb_array_len(a) -#define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) -#define RARRAY_CONST_PTR(a) rb_array_const_ptr(a) - -#define RARRAY_PTR_USE_START(a) ((VALUE *)RARRAY_CONST_PTR(a)) -#define RARRAY_PTR_USE_END(a) /* */ - -#define RARRAY_PTR_USE(ary, ptr_name, expr) do { \ - const VALUE _ary = (ary); \ - VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - expr; \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i]) -#define RARRAY_ASET(a, i, v) do { \ - const VALUE _ary = (a); \ - VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - RB_OBJ_WRITE(_ary, &ptr[i], (v)); \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(ARRAY, a))) - -struct RRegexp { - struct RBasic basic; - struct re_pattern_buffer *ptr; - const VALUE src; - unsigned long usecnt; -}; -#define RREGEXP_PTR(r) (RREGEXP(r)->ptr) -#define RREGEXP_SRC(r) (RREGEXP(r)->src) -#define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src) -#define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src) -#define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src) - -/* RHASH_TBL allocates st_table if not available. */ -#define RHASH_TBL(h) rb_hash_tbl(h) -#define RHASH_ITER_LEV(h) rb_hash_iter_lev(h) -#define RHASH_IFNONE(h) rb_hash_ifnone(h) -#define RHASH_SIZE(h) NUM2SIZET(rb_hash_size(h)) -#define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0) -#define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone) - -struct RFile { - struct RBasic basic; - struct rb_io_t *fptr; -}; - -#define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r)) -#define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i)) - -struct RData { - struct RBasic basic; - void (*dmark)(void*); - void (*dfree)(void*); - void *data; -}; - -typedef struct rb_data_type_struct rb_data_type_t; - -struct rb_data_type_struct { - const char *wrap_struct_name; - struct { - void (*dmark)(void*); - void (*dfree)(void*); - size_t (*dsize)(const void *); - void *reserved[2]; /* For future extension. - This array *must* be filled with ZERO. */ - } function; - const rb_data_type_t *parent; - void *data; /* This area can be used for any purpose - by a programmer who define the type. */ - VALUE flags; /* RUBY_FL_WB_PROTECTED */ -}; - -#define HAVE_TYPE_RB_DATA_TYPE_T 1 -#define HAVE_RB_DATA_TYPE_T_FUNCTION 1 -#define HAVE_RB_DATA_TYPE_T_PARENT 1 - -struct RTypedData { - struct RBasic basic; - const rb_data_type_t *type; - VALUE typed_flag; /* 1 or not */ - void *data; -}; - -#define DATA_PTR(dta) (RDATA(dta)->data) - -#define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1) -#define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type) -#define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data) - -/* -#define RUBY_DATA_FUNC(func) ((void (*)(void*))(func)) -*/ -typedef void (*RUBY_DATA_FUNC)(void*); - -#ifndef RUBY_UNTYPED_DATA_WARNING -# if defined RUBY_EXPORT -# define RUBY_UNTYPED_DATA_WARNING 1 +#define FilePathStringValue(v) ((v) = rb_get_path(v)) + +/** @cond INTERNAL_MACRO */ +#if defined(HAVE_BUILTIN___BUILTIN_CONSTANT_P) && defined(HAVE_STMT_AND_DECL_IN_EXPR) +# define rb_varargs_argc_check_runtime(argc, vargc) \ + (((argc) <= (vargc)) ? (argc) : \ + (rb_fatal("argc(%d) exceeds actual arguments(%d)", \ + argc, vargc), 0)) +# define rb_varargs_argc_valid_p(argc, vargc) \ + ((argc) == 0 ? (vargc) <= 1 : /* [ruby-core:85266] [Bug #14425] */ \ + (argc) == (vargc)) +# if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) +# ifdef HAVE_ATTRIBUTE_ERRORFUNC +ERRORFUNC((" argument length doesn't match"), int rb_varargs_bad_length(int,int)); +# else +# define rb_varargs_bad_length(argc, vargc) \ + ((argc)/rb_varargs_argc_valid_p(argc, vargc)) +# endif +# define rb_varargs_argc_check(argc, vargc) \ + __builtin_choose_expr(__builtin_constant_p(argc), \ + (rb_varargs_argc_valid_p(argc, vargc) ? (argc) : \ + rb_varargs_bad_length(argc, vargc)), \ + rb_varargs_argc_check_runtime(argc, vargc)) # else -# define RUBY_UNTYPED_DATA_WARNING 0 +# define rb_varargs_argc_check(argc, vargc) \ + rb_varargs_argc_check_runtime(argc, vargc) # endif #endif -VALUE rb_data_object_wrap(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC); -VALUE rb_data_object_zalloc(VALUE,size_t,RUBY_DATA_FUNC,RUBY_DATA_FUNC); -VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *); -VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type); -int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent); -int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *); -void *rb_check_typeddata(VALUE, const rb_data_type_t *); -#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t)) -#define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1) -#define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0) -#define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE -#define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE - -/* bits for rb_data_type_struct::flags */ -#define RUBY_TYPED_FREE_IMMEDIATELY 1 /* TYPE field */ -#define RUBY_TYPED_WB_PROTECTED RUBY_FL_WB_PROTECTED /* THIS FLAG DEPENDS ON Ruby version */ -#define RUBY_TYPED_PROMOTED1 RUBY_FL_PROMOTED1 /* THIS FLAG DEPENDS ON Ruby version */ - -#define Data_Wrap_Struct(klass,mark,free,sval)\ - rb_data_object_wrap((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free)) - -#define Data_Make_Struct0(result, klass, type, size, mark, free, sval) \ - VALUE result = rb_data_object_zalloc((klass), (size), \ - (RUBY_DATA_FUNC)(mark), \ - (RUBY_DATA_FUNC)(free)); \ - (void)((sval) = (type *)DATA_PTR(result)); - -#ifdef __GNUC__ -#define Data_Make_Struct(klass,type,mark,free,sval) ({\ - Data_Make_Struct0(data_struct_obj, klass, type, sizeof(type), mark, free, sval); \ - data_struct_obj; \ -}) -#else -#define Data_Make_Struct(klass,type,mark,free,sval) (\ - rb_data_object_make((klass),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free),(void **)&(sval),sizeof(type)) \ -) -#endif - -#define TypedData_Wrap_Struct(klass,data_type,sval)\ - rb_data_typed_object_wrap((klass),(sval),(data_type)) - -#define TypedData_Make_Struct0(result, klass, type, size, data_type, sval) \ - VALUE result = rb_data_typed_object_zalloc(klass, size, data_type); \ - (void)((sval) = (type *)DATA_PTR(result)); - -#ifdef __GNUC__ -#define TypedData_Make_Struct(klass, type, data_type, sval) ({\ - TypedData_Make_Struct0(data_struct_obj, klass, type, sizeof(type), data_type, sval); \ - data_struct_obj; \ -}) -#else -#define TypedData_Make_Struct(klass, type, data_type, sval) (\ - rb_data_typed_object_make((klass),(data_type),(void **)&(sval),sizeof(type)) \ -) -#endif - -#define Data_Get_Struct(obj,type,sval) \ - ((sval) = (type*)rb_data_object_get(obj)) - -#define TypedData_Get_Struct(obj,type,data_type,sval) \ - ((sval) = (type*)rb_check_typeddata((obj), (data_type))) - -#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX -#define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK -#define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT -enum { - RSTRUCT_EMBED_LEN_MAX = 3, - RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1), - RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1), - - RSTRUCT_ENUM_END -}; - -struct RStruct { - struct RBasic basic; - union { - struct { - long len; - const VALUE *ptr; - } heap; - const VALUE ary[RSTRUCT_EMBED_LEN_MAX]; - } as; -}; - -#define RSTRUCT_EMBED_LEN(st) \ - (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \ - (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) -#define RSTRUCT_LEN(st) rb_struct_len(st) -#define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st)) -#define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st) -#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st))) - -#define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v)) -#define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx]) - -#define RBIGNUM_SIGN(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_POSITIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_NEGATIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) < 0) - -#define R_CAST(st) (struct st*) -#define RBASIC(obj) (R_CAST(RBasic)(obj)) -#define ROBJECT(obj) (R_CAST(RObject)(obj)) -#define RCLASS(obj) (R_CAST(RClass)(obj)) -#define RMODULE(obj) RCLASS(obj) -#define RSTRING(obj) (R_CAST(RString)(obj)) -#define RREGEXP(obj) (R_CAST(RRegexp)(obj)) -#define RARRAY(obj) (R_CAST(RArray)(obj)) -#define RDATA(obj) (R_CAST(RData)(obj)) -#define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj)) -#define RSTRUCT(obj) (R_CAST(RStruct)(obj)) -#define RFILE(obj) (R_CAST(RFile)(obj)) - -#define FL_SINGLETON RUBY_FL_SINGLETON -#define FL_WB_PROTECTED RUBY_FL_WB_PROTECTED -#define FL_PROMOTED0 RUBY_FL_PROMOTED0 -#define FL_PROMOTED1 RUBY_FL_PROMOTED1 -#define FL_FINALIZE RUBY_FL_FINALIZE -#define FL_TAINT RUBY_FL_TAINT -#define FL_UNTRUSTED RUBY_FL_UNTRUSTED -#define FL_EXIVAR RUBY_FL_EXIVAR -#define FL_FREEZE RUBY_FL_FREEZE - -#define FL_USHIFT RUBY_FL_USHIFT - -#define FL_USER0 RUBY_FL_USER0 -#define FL_USER1 RUBY_FL_USER1 -#define FL_USER2 RUBY_FL_USER2 -#define FL_USER3 RUBY_FL_USER3 -#define FL_USER4 RUBY_FL_USER4 -#define FL_USER5 RUBY_FL_USER5 -#define FL_USER6 RUBY_FL_USER6 -#define FL_USER7 RUBY_FL_USER7 -#define FL_USER8 RUBY_FL_USER8 -#define FL_USER9 RUBY_FL_USER9 -#define FL_USER10 RUBY_FL_USER10 -#define FL_USER11 RUBY_FL_USER11 -#define FL_USER12 RUBY_FL_USER12 -#define FL_USER13 RUBY_FL_USER13 -#define FL_USER14 RUBY_FL_USER14 -#define FL_USER15 RUBY_FL_USER15 -#define FL_USER16 RUBY_FL_USER16 -#define FL_USER17 RUBY_FL_USER17 -#define FL_USER18 RUBY_FL_USER18 -#define FL_USER19 RUBY_FL_USER19 - -#define RB_SPECIAL_CONST_P(x) (RB_IMMEDIATE_P(x) || !RTEST(x)) -#define SPECIAL_CONST_P(x) RB_SPECIAL_CONST_P(x) - -#define RB_FL_ABLE(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) != RUBY_T_NODE) -#define RB_FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f)) -#define RB_FL_TEST(x,f) (RB_FL_ABLE(x)?RB_FL_TEST_RAW((x),(f)):0) -#define RB_FL_ANY_RAW(x,f) RB_FL_TEST_RAW((x),(f)) -#define RB_FL_ANY(x,f) RB_FL_TEST((x),(f)) -#define RB_FL_ALL_RAW(x,f) (RB_FL_TEST_RAW((x),(f)) == (f)) -#define RB_FL_ALL(x,f) (RB_FL_TEST((x),(f)) == (f)) -#define RB_FL_SET_RAW(x,f) (void)(RBASIC(x)->flags |= (f)) -#define RB_FL_SET(x,f) (RB_FL_ABLE(x) ? RB_FL_SET_RAW(x, f) : (void)0) -#define RB_FL_UNSET_RAW(x,f) (void)(RBASIC(x)->flags &= ~(f)) -#define RB_FL_UNSET(x,f) (RB_FL_ABLE(x) ? RB_FL_UNSET_RAW(x, f) : (void)0) -#define RB_FL_REVERSE_RAW(x,f) (void)(RBASIC(x)->flags ^= (f)) -#define RB_FL_REVERSE(x,f) (RB_FL_ABLE(x) ? RB_FL_REVERSE_RAW(x, f) : (void)0) - -#define RB_OBJ_TAINTABLE(x) (RB_FL_ABLE(x) && RB_BUILTIN_TYPE(x) != RUBY_T_BIGNUM && RB_BUILTIN_TYPE(x) != RUBY_T_FLOAT) -#define RB_OBJ_TAINTED_RAW(x) RB_FL_TEST_RAW(x, RUBY_FL_TAINT) -#define RB_OBJ_TAINTED(x) (!!RB_FL_TEST((x), RUBY_FL_TAINT)) -#define RB_OBJ_TAINT_RAW(x) RB_FL_SET_RAW(x, RUBY_FL_TAINT) -#define RB_OBJ_TAINT(x) (RB_OBJ_TAINTABLE(x) ? RB_OBJ_TAINT_RAW(x) : (void)0) -#define RB_OBJ_UNTRUSTED(x) RB_OBJ_TAINTED(x) -#define RB_OBJ_UNTRUST(x) RB_OBJ_TAINT(x) -#define RB_OBJ_INFECT_RAW(x,s) RB_FL_SET_RAW(x, RB_OBJ_TAINTED_RAW(s)) -#define RB_OBJ_INFECT(x,s) ( \ - (RB_OBJ_TAINTABLE(x) && RB_FL_ABLE(s)) ? \ - RB_OBJ_INFECT_RAW(x, s) : (void)0) - -#define RB_OBJ_FROZEN_RAW(x) (RBASIC(x)->flags&RUBY_FL_FREEZE) -#define RB_OBJ_FROZEN(x) (!RB_FL_ABLE(x) || RB_OBJ_FROZEN_RAW(x)) -#define RB_OBJ_FREEZE_RAW(x) (void)(RBASIC(x)->flags |= RUBY_FL_FREEZE) -#define RB_OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x) - -#define FL_ABLE(x) RB_FL_ABLE(x) -#define FL_TEST_RAW(x,f) RB_FL_TEST_RAW(x,f) -#define FL_TEST(x,f) RB_FL_TEST(x,f) -#define FL_ANY_RAW(x,f) RB_FL_ANY_RAW(x,f) -#define FL_ANY(x,f) RB_FL_ANY(x,f) -#define FL_ALL_RAW(x,f) RB_FL_ALL_RAW(x,f) -#define FL_ALL(x,f) RB_FL_ALL(x,f) -#define FL_SET_RAW(x,f) RB_FL_SET_RAW(x,f) -#define FL_SET(x,f) RB_FL_SET(x,f) -#define FL_UNSET_RAW(x,f) RB_FL_UNSET_RAW(x,f) -#define FL_UNSET(x,f) RB_FL_UNSET(x,f) -#define FL_REVERSE_RAW(x,f) RB_FL_REVERSE_RAW(x,f) -#define FL_REVERSE(x,f) RB_FL_REVERSE(x,f) - -#define OBJ_TAINTABLE(x) RB_OBJ_TAINTABLE(x) -#define OBJ_TAINTED_RAW(x) RB_OBJ_TAINTED_RAW(x) -#define OBJ_TAINTED(x) RB_OBJ_TAINTED(x) -#define OBJ_TAINT_RAW(x) RB_OBJ_TAINT_RAW(x) -#define OBJ_TAINT(x) RB_OBJ_TAINT(x) -#define OBJ_UNTRUSTED(x) RB_OBJ_UNTRUSTED(x) -#define OBJ_UNTRUST(x) RB_OBJ_UNTRUST(x) -#define OBJ_INFECT_RAW(x,s) RB_OBJ_INFECT_RAW(x,s) -#define OBJ_INFECT(x,s) RB_OBJ_INFECT(x,s) -#define OBJ_FROZEN_RAW(x) RB_OBJ_FROZEN_RAW(x) -#define OBJ_FROZEN(x) RB_OBJ_FROZEN(x) -#define OBJ_FREEZE_RAW(x) RB_OBJ_FREEZE_RAW(x) -#define OBJ_FREEZE(x) RB_OBJ_FREEZE(x) - -void rb_freeze_singleton_class(VALUE klass); - -static inline void -rb_obj_freeze_inline(VALUE x) -{ - if (RB_FL_ABLE(x)) { - RB_OBJ_FREEZE_RAW(x); - if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & RUBY_FL_SINGLETON)) { - rb_freeze_singleton_class(x); - } - } -} - -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -# define RUBY_UNTYPED_DATA_FUNC(func) func __attribute__((warning("untyped Data is unsafe; use TypedData instead"))) -#else -# define RUBY_UNTYPED_DATA_FUNC(func) DEPRECATED(func) -#endif - -#if defined(__GNUC__) && !defined(__NO_INLINE__) -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -RUBY_UNTYPED_DATA_FUNC(static inline VALUE rb_data_object_wrap_warning(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); -#endif -RUBY_UNTYPED_DATA_FUNC(static inline void *rb_data_object_get_warning(VALUE)); - -static inline VALUE -rb_data_object_wrap_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free) -{ - return rb_data_object_wrap(klass, ptr, mark, free); -} - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -#define rb_data_object_wrap_warning(klass, ptr, mark, free) \ - __extension__( \ - __builtin_choose_expr( \ - __builtin_constant_p(klass) && !(klass), \ - rb_data_object_wrap(klass, ptr, mark, free), \ - rb_data_object_wrap_warning(klass, ptr, mark, free))) -#endif -#endif +/** @endcond */ -static inline void * -rb_data_object_get(VALUE obj) -{ - Check_Type(obj, RUBY_T_DATA); - return ((struct RData *)obj)->data; -} - -#if defined(__GNUC__) && !defined(__NO_INLINE__) -static inline void * -rb_data_object_get_warning(VALUE obj) -{ - return rb_data_object_get(obj); -} -#endif - -static inline VALUE -rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **datap, size_t size) -{ - Data_Make_Struct0(result, klass, void, size, mark_func, free_func, *datap); - return result; -} - -static inline VALUE -rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size) -{ - TypedData_Make_Struct0(result, klass, void, size, type, *datap); - return result; -} - -#ifndef rb_data_object_alloc -DEPRECATED_BY(rb_data_object_wrap, static inline VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); -static inline VALUE -rb_data_object_alloc(VALUE klass, void *data, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree) -{ - return rb_data_object_wrap(klass, data, dmark, dfree); -} -#endif - -#ifndef rb_data_typed_object_alloc -DEPRECATED_BY(rb_data_typed_object_wrap, static inline VALUE rb_data_typed_object_alloc(VALUE,void*,const rb_data_type_t*)); -static inline VALUE -rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *type) -{ - return rb_data_typed_object_wrap(klass, datap, type); -} -#endif - -#if defined(__GNUC__) && !defined(__NO_INLINE__) -#define rb_data_object_wrap_0 rb_data_object_wrap -#define rb_data_object_wrap_1 rb_data_object_wrap_warning -#define rb_data_object_wrap RUBY_MACRO_SELECT(rb_data_object_wrap_, RUBY_UNTYPED_DATA_WARNING) -#define rb_data_object_get_0 rb_data_object_get -#define rb_data_object_get_1 rb_data_object_get_warning -#define rb_data_object_get RUBY_MACRO_SELECT(rb_data_object_get_, RUBY_UNTYPED_DATA_WARNING) -#define rb_data_object_make_0 rb_data_object_make -#define rb_data_object_make_1 rb_data_object_make_warning -#define rb_data_object_make RUBY_MACRO_SELECT(rb_data_object_make_, RUBY_UNTYPED_DATA_WARNING) -#endif - -#if USE_RGENGC -#define RB_OBJ_PROMOTED_RAW(x) RB_FL_ALL_RAW(x, RUBY_FL_PROMOTED) -#define RB_OBJ_PROMOTED(x) (RB_SPECIAL_CONST_P(x) ? 0 : RB_OBJ_PROMOTED_RAW(x)) -#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) - -void rb_gc_writebarrier(VALUE a, VALUE b); -void rb_gc_writebarrier_unprotect(VALUE obj); - -#else /* USE_RGENGC */ -#define RB_OBJ_PROMOTED(x) 0 -#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) -#endif -#define OBJ_PROMOTED_RAW(x) RB_OBJ_PROMOTED_RAW(x) -#define OBJ_PROMOTED(x) RB_OBJ_PROMOTED(x) -#define OBJ_WB_UNPROTECT(x) RB_OBJ_WB_UNPROTECT(x) - -/* Write barrier (WB) interfaces: - * - RB_OBJ_WRITE(a, slot, b): WB for new reference from `a' to `b'. - * Write `b' into `*slot'. `slot' is a pointer in `a'. - * - RB_OBJ_WRITTEN(a, oldv, b): WB for new reference from `a' to `b'. - * This doesn't write any values, but only a WB declaration. - * `oldv' is replaced value with `b' (not used in current Ruby). +/** + * Queries the name of the passed class. * - * NOTE: The following core interfaces can be changed in the future. - * Please catch up if you want to insert WB into C-extensions - * correctly. + * @param[in] klass An instance of a class. + * @return The name of `klass`. + * @note Return value is managed by our GC. Don't free. */ -#define RB_OBJ_WRITE(a, slot, b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__) -#define RB_OBJ_WRITTEN(a, oldv, b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__) - -#ifndef USE_RGENGC_LOGGING_WB_UNPROTECT -#define USE_RGENGC_LOGGING_WB_UNPROTECT 0 -#endif +const char *rb_class2name(VALUE klass); -#if USE_RGENGC_LOGGING_WB_UNPROTECT -void rb_gc_unprotect_logging(void *objptr, const char *filename, int line); -#define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging -#endif - -static inline VALUE -rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WB_UNPROTECT - RGENGC_LOGGING_WB_UNPROTECT((void *)x, filename, line); -#endif -#if USE_RGENGC - rb_gc_writebarrier_unprotect(x); -#endif - return x; -} - -static inline VALUE -rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_OBJ_WRITTEN - RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line); -#endif +/** + * Queries the name of the class of the passed object. + * + * @param[in] obj Arbitrary ruby object. + * @return The name of the class of `obj`. + * @note Return value is managed by our GC. Don't free. + */ +const char *rb_obj_classname(VALUE obj); -#if USE_RGENGC - if (!RB_SPECIAL_CONST_P(b)) { - rb_gc_writebarrier(a, b); - } -#endif +/** + * Inspects an object. It first calls the argument's `#inspect` method, then + * feeds its result string into ::rb_stdout. + * + * This is identical to Ruby level `Kernel#p`, except it takes only one object. + * + * @internal + * + * Above description is in fact inaccurate. This API interfaces with Ractors. + */ +void rb_p(VALUE obj); - return a; -} +/** + * This function is an optimised version of calling `#==`. It checks equality + * between two objects by first doing a fast identity check using using C's + * `==` (same as `BasicObject#equal?`). If that check fails, it calls `#==` + * dynamically. This optimisation actually affects semantics, because when + * `#==` returns false for the same object obj, `rb_equal(obj, obj)` would + * still return true. This happens for `Float::NAN`, where `Float::NAN == + * Float::NAN` is `false`, but `rb_equal(Float::NAN, Float::NAN)` is `true`. + * + * @param[in] lhs Comparison LHS. + * @param[in] rhs Comparison RHS. + * @retval RUBY_Qtrue They are the same. + * @retval RUBY_Qfalse They are different. + */ +VALUE rb_equal(VALUE lhs, VALUE rhs); -static inline VALUE -rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WRITE - RGENGC_LOGGING_WRITE(a, slot, b, filename, line); -#endif +/** + * Identical to rb_require_string(), except it takes C's string instead of + * Ruby's. + * + * @param[in] feature Name of a feature, e.g. `"json"`. + * @exception rb_eLoadError No such feature. + * @exception rb_eRuntimeError `$"` is frozen; unable to push. + * @retval RUBY_Qtrue The feature is loaded for the first time. + * @retval RUBY_Qfalse The feature has already been loaded. + * @post `$"` is updated. + */ +VALUE rb_require(const char *feature); - *slot = b; +#include "ruby/intern.h" -#if USE_RGENGC - rb_obj_written(a, Qundef /* ignore `oldv' now */, b, filename, line); -#endif - return a; -} +/** + * @private + * + * @deprecated This macro once was a thing in the old days, but makes no sense + * any longer today. Exists here for backwards compatibility + * only. You can safely forget about it. + */ +#define RUBY_VM 1 /* YARV */ -#if SIZEOF_INT < SIZEOF_LONG -# define RB_INT2NUM(v) INT2FIX((int)(v)) -# define RB_UINT2NUM(v) LONG2FIX((unsigned int)(v)) -#else -static inline VALUE -rb_int2num_inline(int v) -{ - if (RB_FIXABLE(v)) - return INT2FIX(v); - else - return rb_int2big(v); -} -#define RB_INT2NUM(x) rb_int2num_inline(x) +/** + * @private + * + * @deprecated This macro once was a thing in the old days, but makes no sense + * any longer today. Exists here for backwards compatibility + * only. You can safely forget about it. + */ +#define HAVE_NATIVETHREAD -static inline VALUE -rb_uint2num_inline(unsigned int v) -{ - if (RB_POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); -} -#define RB_UINT2NUM(x) rb_uint2num_inline(x) -#endif -#define INT2NUM(x) RB_INT2NUM(x) -#define UINT2NUM(x) RB_UINT2NUM(x) +/** + * Queries if the thread which calls this function is a ruby's thread. + * "Ruby's" in this context is a thread created using one of our APIs like + * rb_thread_create(). There are distinctions between ruby's and other + * threads. For instance calling ruby methods are allowed only from inside of + * a ruby's thread. + * + * @retval 1 The current thread is a Ruby's thread. + * @retval 0 The current thread is a random thread from outside of Ruby. + */ +int ruby_native_thread_p(void); -static inline VALUE -rb_long2num_inline(long v) -{ - if (RB_FIXABLE(v)) - return LONG2FIX(v); - else - return rb_int2big(v); -} -#define RB_LONG2NUM(x) rb_long2num_inline(x) +/** + * @private + * + * This macro is for internal use. Must be a mistake to place here. + */ +#define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} -static inline VALUE -rb_ulong2num_inline(unsigned long v) -{ - if (RB_POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); -} -#define RB_ULONG2NUM(x) rb_ulong2num_inline(x) +RBIMPL_ATTR_NONNULL((3)) +RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 4) +/** + * Our own locale-insensitive version of `snprintf(3)`. It can also be seen as + * a routine identical to rb_sprintf(), except it writes back to the passed + * buffer instead of allocating a new Ruby object. + * + * @param[out] str Return buffer + * @param[in] n Number of bytes of `str`. + * @param[in] fmt A `printf`-like format specifier. + * @param[in] ... Variadic number of contents to format. + * @return Number of bytes that would have been written to `str`, if `n` + * was large enough. Comparing this to `n` can give you insights + * that the buffer is too small or too big. Especially passing 0 + * to `n` gives you the exact number of bytes necessary to hold + * the result string without writing anything to anywhere. + * @post `str` holds up to `n-1` bytes of formatted contents (and the + * terminating NUL character.) + */ +int ruby_snprintf(char *str, size_t n, char const *fmt, ...); -static inline char -rb_num2char_inline(VALUE x) -{ - if (RB_TYPE_P(x, RUBY_T_STRING) && (RSTRING_LEN(x)>=1)) - return RSTRING_PTR(x)[0]; - else - return (char)(NUM2INT(x) & 0xff); -} -#define RB_NUM2CHR(x) rb_num2char_inline(x) +RBIMPL_ATTR_NONNULL((3)) +RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 3, 0) +/** + * Identical to ruby_snprintf(), except it takes a `va_list`. It can also be + * seen as a routine identical to rb_vsprintf(), except it writes back to the + * passed buffer instead of allocating a new Ruby object. + * + * @param[out] str Return buffer + * @param[in] n Number of bytes of `str`. + * @param[in] fmt A `printf`-like format specifier. + * @param[in] ap Contents to format. + * @return Number of bytes that would have been written to `str`, if `n` + * was large enough. Comparing this to `n` can give you insights + * that the buffer is too small or too big. Especially passing 0 + * to `n` gives you the exact number of bytes necessary to hold + * the result string without writing anything to anywhere. + * @post `str` holds up to `n-1` bytes of formatted contents (and the + * terminating NUL character.) + */ +int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); -#define RB_CHR2FIX(x) INT2FIX((long)((x)&0xff)) +#include <errno.h> -#define LONG2NUM(x) RB_LONG2NUM(x) -#define ULONG2NUM(x) RB_ULONG2NUM(x) -#define NUM2CHR(x) RB_NUM2CHR(x) -#define CHR2FIX(x) RB_CHR2FIX(x) +/** + * @name Errno handling routines for userland threads + * @note POSIX chapter 2 section 3 states that for each thread of a process, + * the value of `errno` shall not be affected by function calls or + * assignments to `errno` by other threads. + * + * Soooo this `#define errno` below seems like a noob mistake at first sight. + * If you look at its actual implementation, the functions are just adding one + * level of indirection. It doesn't make any sense sorry? But yes! @ko1 told + * @shyouhei that this is inevitable. + * + * The ultimate reason is because Ruby now has N:M threads implemented. + * Threads of that sort change their context in user land. A function can be + * "transferred" between threads in middle of their executions. Let us for + * instance consider: + * + * ```cxx + * void foo() + * { + * auto i = errno; + * close(0); + * errno = i; + * } + * ``` + * + * This function (if ran under our Ractor) could change its running thread at + * the `close` function. But the two `errno` invocations are different! Look + * how the source code above is compiled by clang 17 with `-O3` flag @ Linux: + * + * ``` + * foo(int): # @foo(int) + * push rbp + * push r14 + * push rbx + * mov ebx, edi + * call __errno_location@PLT + * mov r14, rax + * mov ebp, dword ptr [rax] + * mov edi, ebx + * call close@PLT + * mov dword ptr [r14], ebp + * pop rbx + * pop r14 + * pop rbp + * ret + * ``` + * + * Notice how `__errno_location@PLT` is `call`-ed only once. The compiler + * assumes that the location of `errno` does not change during a function call. + * Sadly this is no longer true for us. The `close@PLT` now changes threads, + * which should also change where `errno` is stored. + * + * With the `#define errno` below the compilation result changes to this: + * + * ``` + * foo(int): # @foo(int) + * push rbp + * push rbx + * push rax + * mov ebx, edi + * call rb_errno_ptr()@PLT + * mov ebp, dword ptr [rax] + * mov edi, ebx + * call close@PLT + * call rb_errno_ptr()@PLT + * mov dword ptr [rax], ebp + * add rsp, 8 + * pop rbx + * pop rbp + * ret + * ``` + * + * Which fixes the problem. + */ -#define RB_ALLOC_N(type,n) ((type*)ruby_xmalloc2((n),sizeof(type))) -#define RB_ALLOC(type) ((type*)ruby_xmalloc(sizeof(type))) -#define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((n),sizeof(type))) -#define RB_ZALLOC(type) (RB_ZALLOC_N(type,1)) -#define RB_REALLOC_N(var,type,n) ((var)=(type*)ruby_xrealloc2((char*)(var),(n),sizeof(type))) +/** + * Identical to system `errno`. + * + * @return The last set `errno` number. + */ +int rb_errno(void); -#define ALLOC_N(type,n) RB_ALLOC_N(type,n) -#define ALLOC(type) RB_ALLOC(type) -#define ZALLOC_N(type,n) RB_ZALLOC_N(type,n) -#define ZALLOC(type) RB_ZALLOC(type) -#define REALLOC_N(var,type,n) RB_REALLOC_N(var,type,n) +/** + * Set the errno. + * + * @param err New `errno`. + * @post `errno` is now set to `err`. + */ +void rb_errno_set(int err); -#define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n))) +/** + * The location of `errno` + * + * @return The (thread-specific) location of `errno`. + */ +int *rb_errno_ptr(void); -void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2)); -void rb_free_tmp_buffer(volatile VALUE *store); -NORETURN(void ruby_malloc_size_overflow(size_t, size_t)); -static inline size_t -ruby_xmalloc2_size(const size_t count, const size_t elsize) +/** + * Not sure if it is necessary for extension libraries but this is where the + * "bare" errno is located. + * + * @return The location of `errno`. + */ +static inline int * +rb_orig_errno_ptr(void) { - if (count > SIZE_MAX / elsize) { - ruby_malloc_size_overflow(count, elsize); - } - return count * elsize; + return &errno; } -/* allocates _n_ bytes temporary buffer and stores VALUE including it - * in _v_. _n_ may be evaluated twice. */ -#ifdef C_ALLOCA -# define RB_ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n)) -# define RB_ALLOCV_N(type, v, n) \ - ((type*)RB_ALLOCV((v), ruby_xmalloc2_size((n), sizeof(type)))) -#else -# define RUBY_ALLOCV_LIMIT 1024 -# define RB_ALLOCV(v, n) ((n) < RUBY_ALLOCV_LIMIT ? \ - (RB_GC_GUARD(v) = 0, alloca(n)) : \ - rb_alloc_tmp_buffer(&(v), (n))) -# define RB_ALLOCV_N(type, v, n) \ - ((type*)(ruby_xmalloc2_size((n), sizeof(type)) < RUBY_ALLOCV_LIMIT ? \ - (RB_GC_GUARD(v) = 0, alloca((n) * sizeof(type))) : \ - rb_alloc_tmp_buffer(&(v), (n) * sizeof(type)))) -#endif -#define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v)) -#define ALLOCV(v, n) RB_ALLOCV(v, n) -#define ALLOCV_N(type, v, n) RB_ALLOCV_N(type, v, n) -#define ALLOCV_END(v) RB_ALLOCV_END(v) +#define rb_orig_errno errno /**< System-provided original `errno`. */ +#undef errno +#define errno (*rb_errno_ptr()) /**< Ractor-aware version of `errno`. */ -#define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n)) -#define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n)) -#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n)) -#define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n)) +/** @} */ -void rb_obj_infect(VALUE,VALUE); - -typedef int ruby_glob_func(const char*,VALUE, void*); -void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE); -int ruby_glob(const char*,int,ruby_glob_func*,VALUE); -int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE); - -VALUE rb_define_class(const char*,VALUE); -VALUE rb_define_module(const char*); -VALUE rb_define_class_under(VALUE, const char*, VALUE); -VALUE rb_define_module_under(VALUE, const char*); - -void rb_include_module(VALUE,VALUE); -void rb_extend_object(VALUE,VALUE); -void rb_prepend_module(VALUE,VALUE); - -struct rb_global_variable; - -typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar); -typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar); -typedef void rb_gvar_marker_t(VALUE *var); - -VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_undef_marker(VALUE *var); - -VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_val_marker(VALUE *var); - -VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); -void rb_gvar_var_marker(VALUE *var); - -void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); - -void rb_define_variable(const char*,VALUE*); -void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); -void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); -void rb_define_readonly_variable(const char*,const VALUE*); -void rb_define_const(VALUE,const char*,VALUE); -void rb_define_global_const(const char*,VALUE); - -#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func)) -void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int); -void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int); -void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int); - -void rb_undef_method(VALUE,const char*); -void rb_define_alias(VALUE,const char*,const char*); -void rb_define_attr(VALUE,const char*,int,int); - -void rb_global_variable(VALUE*); -void rb_gc_register_mark_object(VALUE); -void rb_gc_register_address(VALUE*); -void rb_gc_unregister_address(VALUE*); - -ID rb_intern(const char*); -ID rb_intern2(const char*, long); -ID rb_intern_str(VALUE str); -const char *rb_id2name(ID); -ID rb_check_id(volatile VALUE *); -ID rb_to_id(VALUE); -VALUE rb_id2str(ID); -VALUE rb_sym2str(VALUE); -VALUE rb_to_symbol(VALUE name); -VALUE rb_check_symbol(volatile VALUE *namep); - -#define RUBY_CONST_ID_CACHE(result, str) \ - { \ - static ID rb_intern_id_cache; \ - if (!rb_intern_id_cache) \ - rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \ - result rb_intern_id_cache; \ - } -#define RUBY_CONST_ID(var, str) \ - do RUBY_CONST_ID_CACHE((var) =, (str)) while (0) -#define CONST_ID_CACHE(result, str) RUBY_CONST_ID_CACHE(result, str) -#define CONST_ID(var, str) RUBY_CONST_ID(var, str) -#ifdef __GNUC__ -/* __builtin_constant_p and statement expression is available - * since gcc-2.7.2.3 at least. */ -#define rb_intern(str) \ - (__builtin_constant_p(str) ? \ - __extension__ (CONST_ID_CACHE((ID), (str))) : \ - rb_intern(str)) -#define rb_intern_const(str) \ - (__builtin_constant_p(str) ? \ - __extension__ (rb_intern2((str), (long)strlen(str))) : \ - (rb_intern)(str)) -#else -#define rb_intern_const(str) rb_intern2((str), (long)strlen(str)) -#endif -const char *rb_class2name(VALUE); -const char *rb_obj_classname(VALUE); - -void rb_p(VALUE); - -VALUE rb_eval_string(const char*); -VALUE rb_eval_string_protect(const char*, int*); -VALUE rb_eval_string_wrap(const char*, int*); -VALUE rb_funcall(VALUE, ID, int, ...); -VALUE rb_funcallv(VALUE, ID, int, const VALUE*); -VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*); -#define rb_funcall2 rb_funcallv -#define rb_funcall3 rb_funcallv_public -VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*); -VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE); -int rb_scan_args(int, const VALUE*, const char*, ...); -VALUE rb_call_super(int, const VALUE*); -VALUE rb_current_receiver(void); -int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *); -VALUE rb_extract_keywords(VALUE *orighash); - -/* rb_scan_args() format allows ':' for optional hash */ -#define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1 - -VALUE rb_gv_set(const char*, VALUE); -VALUE rb_gv_get(const char*); -VALUE rb_iv_get(VALUE, const char*); -VALUE rb_iv_set(VALUE, const char*, VALUE); - -VALUE rb_equal(VALUE,VALUE); - -VALUE *rb_ruby_verbose_ptr(void); -VALUE *rb_ruby_debug_ptr(void); -#define ruby_verbose (*rb_ruby_verbose_ptr()) -#define ruby_debug (*rb_ruby_debug_ptr()) - -/* for rb_readwrite_sys_fail first argument */ -enum rb_io_wait_readwrite {RB_IO_WAIT_READABLE, RB_IO_WAIT_WRITABLE}; -#define RB_IO_WAIT_READABLE RB_IO_WAIT_READABLE -#define RB_IO_WAIT_WRITABLE RB_IO_WAIT_WRITABLE - -PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3); -PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); -PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2); -NORETURN(void rb_bug_errno(const char*, int)); -NORETURN(void rb_sys_fail(const char*)); -NORETURN(void rb_sys_fail_str(VALUE)); -NORETURN(void rb_mod_sys_fail(VALUE, const char*)); -NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE)); -NORETURN(void rb_readwrite_sys_fail(enum rb_io_wait_readwrite, const char*)); -NORETURN(void rb_iter_break(void)); -NORETURN(void rb_iter_break_value(VALUE)); -NORETURN(void rb_exit(int)); -NORETURN(void rb_notimplement(void)); -VALUE rb_syserr_new(int, const char *); -VALUE rb_syserr_new_str(int n, VALUE arg); -NORETURN(void rb_syserr_fail(int, const char*)); -NORETURN(void rb_syserr_fail_str(int, VALUE)); -NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*)); -NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE)); -NORETURN(void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite, int, const char*)); - -/* reports if `-W' specified */ -PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); -PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4); -PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2); -/* reports always */ -PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2); -PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4); - -#define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1 -#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \ - VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg -typedef VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)); - -#if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT -typedef rb_block_call_func *rb_block_call_func_t; -#else -typedef VALUE (*rb_block_call_func_t)(ANYARGS); -#endif - -VALUE rb_each(VALUE); -VALUE rb_yield(VALUE); -VALUE rb_yield_values(int n, ...); -VALUE rb_yield_values2(int n, const VALUE *argv); -VALUE rb_yield_splat(VALUE); -VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */ -int rb_block_given_p(void); -void rb_need_block(void); -VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE); -VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE); -VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); -VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...); -VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); -VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE); -VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE); -NORETURN(void rb_throw(const char*,VALUE)); -NORETURN(void rb_throw_obj(VALUE,VALUE)); - -VALUE rb_require(const char*); - -RUBY_EXTERN VALUE rb_mKernel; -RUBY_EXTERN VALUE rb_mComparable; -RUBY_EXTERN VALUE rb_mEnumerable; -RUBY_EXTERN VALUE rb_mErrno; -RUBY_EXTERN VALUE rb_mFileTest; -RUBY_EXTERN VALUE rb_mGC; -RUBY_EXTERN VALUE rb_mMath; -RUBY_EXTERN VALUE rb_mProcess; -RUBY_EXTERN VALUE rb_mWaitReadable; -RUBY_EXTERN VALUE rb_mWaitWritable; - -RUBY_EXTERN VALUE rb_cBasicObject; -RUBY_EXTERN VALUE rb_cObject; -RUBY_EXTERN VALUE rb_cArray; -RUBY_EXTERN VALUE rb_cBignum; -RUBY_EXTERN VALUE rb_cBinding; -RUBY_EXTERN VALUE rb_cClass; -RUBY_EXTERN VALUE rb_cCont; -RUBY_EXTERN VALUE rb_cDir; -RUBY_EXTERN VALUE rb_cData; -RUBY_EXTERN VALUE rb_cFalseClass; -RUBY_EXTERN VALUE rb_cEncoding; -RUBY_EXTERN VALUE rb_cEnumerator; -RUBY_EXTERN VALUE rb_cFile; -RUBY_EXTERN VALUE rb_cFixnum; -RUBY_EXTERN VALUE rb_cFloat; -RUBY_EXTERN VALUE rb_cHash; -RUBY_EXTERN VALUE rb_cInteger; -RUBY_EXTERN VALUE rb_cIO; -RUBY_EXTERN VALUE rb_cMatch; -RUBY_EXTERN VALUE rb_cMethod; -RUBY_EXTERN VALUE rb_cModule; -RUBY_EXTERN VALUE rb_cNameErrorMesg; -RUBY_EXTERN VALUE rb_cNilClass; -RUBY_EXTERN VALUE rb_cNumeric; -RUBY_EXTERN VALUE rb_cProc; -RUBY_EXTERN VALUE rb_cRandom; -RUBY_EXTERN VALUE rb_cRange; -RUBY_EXTERN VALUE rb_cRational; -RUBY_EXTERN VALUE rb_cComplex; -RUBY_EXTERN VALUE rb_cRegexp; -RUBY_EXTERN VALUE rb_cStat; -RUBY_EXTERN VALUE rb_cString; -RUBY_EXTERN VALUE rb_cStruct; -RUBY_EXTERN VALUE rb_cSymbol; -RUBY_EXTERN VALUE rb_cThread; -RUBY_EXTERN VALUE rb_cTime; -RUBY_EXTERN VALUE rb_cTrueClass; -RUBY_EXTERN VALUE rb_cUnboundMethod; - -RUBY_EXTERN VALUE rb_eException; -RUBY_EXTERN VALUE rb_eStandardError; -RUBY_EXTERN VALUE rb_eSystemExit; -RUBY_EXTERN VALUE rb_eInterrupt; -RUBY_EXTERN VALUE rb_eSignal; -RUBY_EXTERN VALUE rb_eFatal; -RUBY_EXTERN VALUE rb_eArgError; -RUBY_EXTERN VALUE rb_eEOFError; -RUBY_EXTERN VALUE rb_eIndexError; -RUBY_EXTERN VALUE rb_eStopIteration; -RUBY_EXTERN VALUE rb_eKeyError; -RUBY_EXTERN VALUE rb_eRangeError; -RUBY_EXTERN VALUE rb_eIOError; -RUBY_EXTERN VALUE rb_eRuntimeError; -RUBY_EXTERN VALUE rb_eSecurityError; -RUBY_EXTERN VALUE rb_eSystemCallError; -RUBY_EXTERN VALUE rb_eThreadError; -RUBY_EXTERN VALUE rb_eTypeError; -RUBY_EXTERN VALUE rb_eZeroDivError; -RUBY_EXTERN VALUE rb_eNotImpError; -RUBY_EXTERN VALUE rb_eNoMemError; -RUBY_EXTERN VALUE rb_eNoMethodError; -RUBY_EXTERN VALUE rb_eFloatDomainError; -RUBY_EXTERN VALUE rb_eLocalJumpError; -RUBY_EXTERN VALUE rb_eSysStackError; -RUBY_EXTERN VALUE rb_eRegexpError; -RUBY_EXTERN VALUE rb_eEncodingError; -RUBY_EXTERN VALUE rb_eEncCompatError; - -RUBY_EXTERN VALUE rb_eScriptError; -RUBY_EXTERN VALUE rb_eNameError; -RUBY_EXTERN VALUE rb_eSyntaxError; -RUBY_EXTERN VALUE rb_eLoadError; - -RUBY_EXTERN VALUE rb_eMathDomainError; - -RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr; - -static inline VALUE -rb_class_of(VALUE obj) -{ - if (RB_IMMEDIATE_P(obj)) { - if (RB_FIXNUM_P(obj)) return rb_cFixnum; - if (RB_FLONUM_P(obj)) return rb_cFloat; - if (obj == RUBY_Qtrue) return rb_cTrueClass; - if (RB_STATIC_SYM_P(obj)) return rb_cSymbol; - } - else if (!RTEST(obj)) { - if (obj == RUBY_Qnil) return rb_cNilClass; - if (obj == RUBY_Qfalse) return rb_cFalseClass; - } - return RBASIC(obj)->klass; -} - -static inline int -rb_type(VALUE obj) -{ - if (RB_IMMEDIATE_P(obj)) { - if (RB_FIXNUM_P(obj)) return RUBY_T_FIXNUM; - if (RB_FLONUM_P(obj)) return RUBY_T_FLOAT; - if (obj == RUBY_Qtrue) return RUBY_T_TRUE; - if (RB_STATIC_SYM_P(obj)) return RUBY_T_SYMBOL; - if (obj == RUBY_Qundef) return RUBY_T_UNDEF; - } - else if (!RTEST(obj)) { - if (obj == RUBY_Qnil) return RUBY_T_NIL; - if (obj == RUBY_Qfalse) return RUBY_T_FALSE; - } - return RB_BUILTIN_TYPE(obj); -} - -#ifdef __GNUC__ -#define rb_type_p(obj, type) \ - __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \ - rb_type(obj) == (type)) -#else -#define rb_type_p(obj, type) (rb_type(obj) == (type)) -#endif - -#ifdef __GNUC__ -#define rb_special_const_p(obj) \ - __extension__ ({ \ - VALUE special_const_obj = (obj); \ - (int)(RB_SPECIAL_CONST_P(special_const_obj) ? RUBY_Qtrue : RUBY_Qfalse); \ +/** @cond INTERNAL_MACRO */ +#if RBIMPL_HAS_WARNING("-Wgnu-zero-variadic-macro-arguments") +# /* Skip it; clang -pedantic doesn't like the following */ +#elif defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO) && defined(__OPTIMIZE__) +# define rb_yield_values(argc, ...) \ +__extension__({ \ + const int rb_yield_values_argc = (argc); \ + const VALUE rb_yield_values_args[] = {__VA_ARGS__}; \ + const int rb_yield_values_nargs = \ + (int)(sizeof(rb_yield_values_args) / sizeof(VALUE)); \ + rb_yield_values2( \ + rb_varargs_argc_check(rb_yield_values_argc, rb_yield_values_nargs), \ + rb_yield_values_nargs ? rb_yield_values_args : NULL); \ }) -#else -static inline int -rb_special_const_p(VALUE obj) -{ - if (RB_SPECIAL_CONST_P(obj)) return (int)RUBY_Qtrue; - return (int)RUBY_Qfalse; -} -#endif - -#include "ruby/intern.h" - -static inline void -rb_clone_setup(VALUE clone, VALUE obj) -{ - rb_obj_setup(clone, rb_singleton_class_clone(obj), RBASIC(obj)->flags); - rb_singleton_class_attached(RBASIC_CLASS(clone), clone); - if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(clone, obj); -} - -static inline void -rb_dup_setup(VALUE dup, VALUE obj) -{ - rb_obj_setup(dup, rb_obj_class(obj), RB_FL_TEST_RAW(obj, RUBY_FL_DUPPED)); - if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(dup, obj); -} - -static inline long -rb_array_len(VALUE a) -{ - return (RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? - RARRAY_EMBED_LEN(a) : RARRAY(a)->as.heap.len; -} - -#if defined(__fcc__) || defined(__fcc_version) || \ - defined(__FCC__) || defined(__FCC_VERSION) -/* workaround for old version of Fujitsu C Compiler (fcc) */ -# define FIX_CONST_VALUE_PTR(x) ((const VALUE *)(x)) -#else -# define FIX_CONST_VALUE_PTR(x) (x) -#endif - -static inline const VALUE * -rb_array_const_ptr(VALUE a) -{ - return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? - RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr); -} - -static inline long -rb_struct_len(VALUE st) -{ - return (RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? - RSTRUCT_EMBED_LEN(st) : RSTRUCT(st)->as.heap.len; -} - -static inline const VALUE * -rb_struct_const_ptr(VALUE st) -{ - return FIX_CONST_VALUE_PTR((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? - RSTRUCT(st)->as.ary : RSTRUCT(st)->as.heap.ptr); -} - -#if defined(EXTLIB) && defined(USE_DLN_A_OUT) -/* hook for external modules */ -static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; -#endif - -#define RUBY_VM 1 /* YARV */ -#define HAVE_NATIVETHREAD -int ruby_native_thread_p(void); - -/* traditional set_trace_func events */ -#define RUBY_EVENT_NONE 0x0000 -#define RUBY_EVENT_LINE 0x0001 -#define RUBY_EVENT_CLASS 0x0002 -#define RUBY_EVENT_END 0x0004 -#define RUBY_EVENT_CALL 0x0008 -#define RUBY_EVENT_RETURN 0x0010 -#define RUBY_EVENT_C_CALL 0x0020 -#define RUBY_EVENT_C_RETURN 0x0040 -#define RUBY_EVENT_RAISE 0x0080 -#define RUBY_EVENT_ALL 0x00ff - -/* for TracePoint extended events */ -#define RUBY_EVENT_B_CALL 0x0100 -#define RUBY_EVENT_B_RETURN 0x0200 -#define RUBY_EVENT_THREAD_BEGIN 0x0400 -#define RUBY_EVENT_THREAD_END 0x0800 -#define RUBY_EVENT_FIBER_SWITCH 0x1000 -#define RUBY_EVENT_TRACEPOINT_ALL 0xffff - -/* special events */ -#define RUBY_EVENT_SPECIFIED_LINE 0x010000 -#define RUBY_EVENT_COVERAGE 0x020000 - -/* internal events */ -#define RUBY_INTERNAL_EVENT_SWITCH 0x040000 -#define RUBY_EVENT_SWITCH 0x040000 /* obsolete name. this macro is for compatibility */ - /* 0x080000 */ -#define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000 -#define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000 -#define RUBY_INTERNAL_EVENT_GC_START 0x400000 -#define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000 -#define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000 -#define RUBY_INTERNAL_EVENT_GC_ENTER 0x2000000 -#define RUBY_INTERNAL_EVENT_GC_EXIT 0x4000000 -#define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x7f00000 -#define RUBY_INTERNAL_EVENT_MASK 0xfffe0000 -typedef uint32_t rb_event_flag_t; -typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass); - -#define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 -void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data); -int rb_remove_event_hook(rb_event_hook_func_t func); - -/* locale insensitive functions */ - -#define rb_isascii(c) ((unsigned long)(c) < 128) -int rb_isalnum(int c); -int rb_isalpha(int c); -int rb_isblank(int c); -int rb_iscntrl(int c); -int rb_isdigit(int c); -int rb_isgraph(int c); -int rb_islower(int c); -int rb_isprint(int c); -int rb_ispunct(int c); -int rb_isspace(int c); -int rb_isupper(int c); -int rb_isxdigit(int c); -int rb_tolower(int c); -int rb_toupper(int c); - -#ifndef ISPRINT -#define ISASCII(c) rb_isascii((unsigned char)(c)) -#undef ISPRINT -#define ISPRINT(c) rb_isprint((unsigned char)(c)) -#define ISGRAPH(c) rb_isgraph((unsigned char)(c)) -#define ISSPACE(c) rb_isspace((unsigned char)(c)) -#define ISUPPER(c) rb_isupper((unsigned char)(c)) -#define ISLOWER(c) rb_islower((unsigned char)(c)) -#define ISALNUM(c) rb_isalnum((unsigned char)(c)) -#define ISALPHA(c) rb_isalpha((unsigned char)(c)) -#define ISDIGIT(c) rb_isdigit((unsigned char)(c)) -#define ISXDIGIT(c) rb_isxdigit((unsigned char)(c)) +# define rb_funcall(recv, mid, argc, ...) \ +__extension__({ \ + const int rb_funcall_argc = (argc); \ + const VALUE rb_funcall_args[] = {__VA_ARGS__}; \ + const int rb_funcall_nargs = \ + (int)(sizeof(rb_funcall_args) / sizeof(VALUE)); \ + rb_funcallv(recv, mid, \ + rb_varargs_argc_check(rb_funcall_argc, rb_funcall_nargs), \ + rb_funcall_nargs ? rb_funcall_args : NULL); \ + }) #endif -#define TOUPPER(c) rb_toupper((unsigned char)(c)) -#define TOLOWER(c) rb_tolower((unsigned char)(c)) - -int st_locale_insensitive_strcasecmp(const char *s1, const char *s2); -int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n); -#define STRCASECMP(s1, s2) (st_locale_insensitive_strcasecmp((s1), (s2))) -#define STRNCASECMP(s1, s2, n) (st_locale_insensitive_strncasecmp((s1), (s2), (n))) - -unsigned long ruby_strtoul(const char *str, char **endptr, int base); -#define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base))) - -#define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} - -PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); -int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); +/** @endcond */ #ifndef RUBY_DONT_SUBST #include "ruby/subst.h" #endif -/** - * @defgroup embed CRuby Embedding APIs - * CRuby interpreter APIs. These are APIs to embed MRI interpreter into your - * program. - * These functions are not a part of Ruby extension library API. - * Extension libraries of Ruby should not depend on these functions. - * @{ - */ - -/** @defgroup ruby1 ruby(1) implementation - * A part of the implementation of ruby(1) command. - * Other programs that embed Ruby interpreter do not always need to use these - * functions. - * @{ - */ - -void ruby_sysinit(int *argc, char ***argv); -void ruby_init(void); -void* ruby_options(int argc, char** argv); -int ruby_executable_node(void *n, int *status); -int ruby_run_node(void *n); - -/* version.c */ -void ruby_show_version(void); -void ruby_show_copyright(void); - - -/*! A convenience macro to call ruby_init_stack(). Must be placed just after - * variable declarations */ -#define RUBY_INIT_STACK \ - VALUE variable_in_this_stack_frame; \ - ruby_init_stack(&variable_in_this_stack_frame); -/*! @} */ - -#ifdef __ia64 -void ruby_init_stack(volatile VALUE*, void*); -#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp()) -#else -void ruby_init_stack(volatile VALUE*); +#if !defined RUBY_EXPORT && !defined RUBY_NO_OLD_COMPATIBILITY +# include "ruby/backward.h" #endif -#define Init_stack(addr) ruby_init_stack(addr) - -int ruby_setup(void); -int ruby_cleanup(volatile int); - -void ruby_finalize(void); -NORETURN(void ruby_stop(int)); - -void ruby_set_stack_size(size_t); -int ruby_stack_check(void); -size_t ruby_stack_length(VALUE**); -int ruby_exec_node(void *n); - -void ruby_script(const char* name); -void ruby_set_script_name(VALUE name); - -void ruby_prog_init(void); -void ruby_set_argv(int, char**); -void *ruby_process_options(int, char**); -void ruby_init_loadpath(void); -void ruby_incpush(const char*); -void ruby_sig_finalize(void); +#ifndef RUBY__ASAN_DEFAULT_OPTIONS +# define RUBY__ASAN_DEFAULT_OPTIONS +#endif -/*! @} */ +#define RUBY_GLOBAL_SETUP \ + RUBY__ASAN_DEFAULT_OPTIONS \ + /* RUBY_GLOBAL_SETUP end */ -#if !defined RUBY_EXPORT && !defined RUBY_NO_OLD_COMPATIBILITY -# include "ruby/backward.h" +#if defined(__wasm__) && !defined(__EMSCRIPTEN__) +int rb_wasm_rt_start(int (*)(int, char **), int, char **); +# define ruby_start_main rb_wasm_rt_start +#else +# define ruby_start_main(main, argc, argv) main(argc, argv) #endif -RUBY_SYMBOL_EXPORT_END +RBIMPL_SYMBOL_EXPORT_END() -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C" { */ -#endif #endif /* RUBY_RUBY_H */ |