diff options
Diffstat (limited to 'include/ruby/ruby.h')
| -rw-r--r-- | include/ruby/ruby.h | 1751 |
1 files changed, 402 insertions, 1349 deletions
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 97ad41c70b..ca794bcaeb 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -1,1393 +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 - -#if defined(__cplusplus) -extern "C" { -#if 0 -} /* satisfy cc-mode */ -#endif -#endif - -#ifndef RUBY_LIB -#include "ruby/config.h" -#ifdef RUBY_EXTCONF_H -#include RUBY_EXTCONF_H -#endif -#endif - -#define NORETURN_STYLE_NEW 1 -#ifndef NORETURN -# define NORETURN(x) x -#endif -#ifndef DEPRECATED -# define DEPRECATED(x) x -#endif -#ifndef NOINLINE -# define NOINLINE(x) x -#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 - -#ifdef HAVE_STDLIB_H -# include <stdlib.h> -#endif - -#ifdef HAVE_STRING_H -# include <string.h> -#else -# include <strings.h> -#endif - +/** + * @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" + +/* @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 -#ifdef HAVE_STDINT_H -# include <stdint.h> -#endif -#ifdef HAVE_INTTYPES_H -# include <inttypes.h> -#endif - -#include <stddef.h> -#include <stdio.h> +#include <stdarg.h> #include "defines.h" - -#if defined(HAVE_ALLOCA_H) -#include <alloca.h> -#else -# ifdef _AIX -#pragma alloca -# endif -#endif - -#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 "ll" -#else -# error ---->> ruby requires sizeof(void*) == sizeof(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 SIZEOF_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]; - -#if defined PRIdPTR && !defined PRI_VALUE_PREFIX -#define PRIdVALUE PRIdPTR -#define PRIiVALUE PRIiPTR -#define PRIoVALUE PRIoPTR -#define PRIuVALUE PRIuPTR -#define PRIxVALUE PRIxPTR -#define PRIXVALUE PRIXPTR -#else -#define PRIdVALUE PRI_VALUE_PREFIX"d" -#define PRIiVALUE PRI_VALUE_PREFIX"i" -#define PRIoVALUE PRI_VALUE_PREFIX"o" -#define PRIuVALUE PRI_VALUE_PREFIX"u" -#define PRIxVALUE PRI_VALUE_PREFIX"x" -#define PRIXVALUE PRI_VALUE_PREFIX"X" -#endif -#ifndef PRI_VALUE_PREFIX -# define PRI_VALUE_PREFIX "" -#endif - -#if defined PRIdPTR -# define PRI_PTRDIFF_PREFIX "t" -#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 "ll" -#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 PRIdPTR -# define PRI_SIZE_PREFIX "z" -#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 "ll" -#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 compliment) 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 FIXNUM_MAX (LONG_MAX>>1) -#define FIXNUM_MIN RSHIFT((long)LONG_MIN,1) - -#define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | 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 - -#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 - -#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 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 - -#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 - -#define FIX2LONG(x) RSHIFT((SIGNED_VALUE)x,1) -#define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX) -#define FIXNUM_P(f) (((SIGNED_VALUE)(f))&FIXNUM_FLAG) -#define POSFIXABLE(f) ((f) < FIXNUM_MAX+1) -#define NEGFIXABLE(f) ((f) >= FIXNUM_MIN) -#define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f)) - -#define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK) - -#define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG) -#define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG) -#define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT) +#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 { - RUBY_Qfalse = 0, - RUBY_Qtrue = 2, - RUBY_Qnil = 4, - RUBY_Qundef = 6, - - RUBY_IMMEDIATE_MASK = 0x03, - RUBY_FIXNUM_FLAG = 0x01, - RUBY_SYMBOL_FLAG = 0x0e, - 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 -#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 = 0x1b, - RUBY_T_NODE = 0x1c, - RUBY_T_ICLASS = 0x1d, - RUBY_T_ZOMBIE = 0x1e, - - 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_UNDEF RUBY_T_UNDEF -#define T_NODE RUBY_T_NODE -#define T_ZOMBIE RUBY_T_ZOMBIE -#define T_MASK RUBY_T_MASK - -#define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK) - -static inline int rb_type(VALUE obj); -#define TYPE(x) rb_type((VALUE)(x)) - -#ifdef __GNUC__ -#define RB_GC_GUARD_PTR(ptr) \ - __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;}) -#else -#define RB_GC_GUARD_PTR(ptr) (volatile VALUE *)(ptr) -#endif -#define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) - -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); -DEPRECATED(void rb_check_safe_str(VALUE)); -#define SafeStringValue(v) do {\ - StringValue(v);\ - rb_check_safe_obj(v);\ -} while (0) -/* obsolete macro - use SafeStringValue(v) */ -#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) - -VALUE rb_str_export(VALUE); -#define ExportStringValue(v) do {\ - SafeStringValue(v);\ - (v) = rb_str_export(v);\ -} while (0) -VALUE rb_str_export_locale(VALUE); - -VALUE rb_get_path(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); + +/** + * 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)) - -void rb_secure(int); -int rb_safe_level(void); -void rb_set_safe_level(int); -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); - -SIGNED_VALUE rb_num2long(VALUE); -VALUE rb_num2ulong(VALUE); -#define NUM2LONG_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)) -#ifdef __GNUC__ -#define NUM2LONG(x) \ - __extension__ ({VALUE num2long_x = (x); NUM2LONG_internal(num2long_x);}) -#else -static inline long -NUM2LONG(VALUE x) -{ - return NUM2LONG_internal(x); -} -#endif -#define NUM2ULONG(x) rb_num2ulong((VALUE)x) -#if SIZEOF_INT < SIZEOF_LONG -long rb_num2int(VALUE); -long rb_fix2int(VALUE); -#define FIX2INT(x) ((int)rb_fix2int((VALUE)x)) -#define NUM2INT_internal(x) (FIXNUM_P(x) ? FIX2INT(x) : (int)rb_num2int(x)) -#ifdef __GNUC__ -#define NUM2INT(x) \ - __extension__ ({VALUE num2int_x = (x); NUM2INT_internal(num2int_x);}) -#else -static inline int -NUM2INT(VALUE x) -{ - return NUM2INT_internal(x); -} -#endif -unsigned long rb_num2uint(VALUE); -#define NUM2UINT(x) ((unsigned int)rb_num2uint(x)) -unsigned long rb_fix2uint(VALUE); -#define FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) -#else -#define NUM2INT(x) ((int)NUM2LONG(x)) -#define NUM2UINT(x) ((unsigned int)NUM2ULONG(x)) -#define FIX2INT(x) ((int)FIX2LONG(x)) -#define FIX2UINT(x) ((unsigned int)FIX2ULONG(x)) -#endif -#ifdef HAVE_LONG_LONG -LONG_LONG rb_num2ll(VALUE); -unsigned LONG_LONG rb_num2ull(VALUE); -# define NUM2LL_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2ll(x)) -# ifdef __GNUC__ -# define NUM2LL(x) \ - __extension__ ({VALUE num2ll_x = (x); NUM2LL_internal(num2ll_x);}) +/** + * 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 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 -static inline LONG_LONG -NUM2LL(VALUE x) -{ - return NUM2LL_internal(x); -} +# define rb_varargs_argc_check(argc, vargc) \ + rb_varargs_argc_check_runtime(argc, vargc) # endif -# define NUM2ULL(x) rb_num2ull((VALUE)x) -#endif - -#if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG -# define NUM2OFFT(x) ((off_t)NUM2LL(x)) -#else -# define NUM2OFFT(x) NUM2LONG(x) -#endif - -#if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG -# define NUM2SIZET(x) ((size_t)NUM2ULL(x)) -# define NUM2SSIZET(x) ((size_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); -#define NEWOBJ(obj,type) type *obj = (type*)rb_newobj() -#define OBJSETUP(obj,c,t) do {\ - RBASIC(obj)->flags = (t);\ - RBASIC(obj)->klass = (c);\ - if (rb_safe_level() >= 3) FL_SET(obj, FL_TAINT | FL_UNTRUSTED);\ -} while (0) -#define CLONESETUP(clone,obj) do {\ - OBJSETUP(clone,rb_singleton_class_clone((VALUE)obj),RBASIC(obj)->flags);\ - rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);\ - if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)clone,(VALUE)obj);\ -} while (0) -#define DUPSETUP(dup,obj) do {\ - OBJSETUP(dup,rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \ - if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)dup,(VALUE)obj);\ -} while (0) - -struct RBasic { - VALUE flags; - VALUE klass; -}; - -#define ROBJECT_EMBED_LEN_MAX 3 -struct RObject { - struct RBasic basic; - union { - struct { - long numiv; - VALUE *ivptr; - struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ - } heap; - VALUE ary[ROBJECT_EMBED_LEN_MAX]; - } as; -}; -#define ROBJECT_EMBED FL_USER1 -#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) - -/** @internal */ -typedef struct { - VALUE super; - struct st_table *iv_tbl; -} rb_classext_t; - -struct RClass { - struct RBasic basic; - rb_classext_t *ptr; - struct st_table *m_tbl; - struct st_table *iv_index_tbl; -}; -#define RCLASS_IV_TBL(c) (RCLASS(c)->ptr->iv_tbl) -#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl) -#define RCLASS_SUPER(c) (RCLASS(c)->ptr->super) -#define RCLASS_IV_INDEX_TBL(c) (RCLASS(c)->iv_index_tbl) -#define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m) -#define RMODULE_M_TBL(m) RCLASS_M_TBL(m) -#define RMODULE_SUPER(m) RCLASS_SUPER(m) - -struct RFloat { - struct RBasic basic; - double float_value; -}; -#define RFLOAT_VALUE(v) (RFLOAT(v)->float_value) -#define DBL2NUM(dbl) rb_float_new(dbl) - -#define ELTS_SHARED FL_USER2 - -#define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1)) -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_NOEMBED FL_USER1 -#define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6) -#define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2) -#define RSTRING_LEN(str) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ - (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) : \ - 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 + \ - ((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ - (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))) : \ - (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len)) - -#define RARRAY_EMBED_LEN_MAX 3 -struct RArray { - struct RBasic basic; - union { - struct { - long len; - union { - long capa; - VALUE shared; - } aux; - VALUE *ptr; - } heap; - VALUE ary[RARRAY_EMBED_LEN_MAX]; - } as; -}; -#define RARRAY_EMBED_FLAG FL_USER1 -/* FL_USER2 is for ELTS_SHARED */ -#define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3) -#define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3) -#define RARRAY_LEN(a) \ - ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ - (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \ - (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \ - RARRAY(a)->as.heap.len) -#define RARRAY_PTR(a) \ - ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ - RARRAY(a)->as.ary : \ - RARRAY(a)->as.heap.ptr) - -#if SIZEOF_INT < SIZEOF_VALUE -NORETURN(void rb_out_of_int(SIGNED_VALUE num)); -#endif - -#if SIZEOF_INT < SIZEOF_LONG -#define rb_long2int_internal(n, i) \ - int i = (int)(n); \ - if ((long)i != (n)) rb_out_of_int(n) -#ifdef __GNUC__ -#define rb_long2int(n) __extension__ ({long i2l_n = (n); rb_long2int_internal(i2l_n, i2l_i); i2l_i;}) -#else -static inline int -rb_long2int(long n) {rb_long2int_internal(n, i); return i;} #endif -#else -#define rb_long2int(n) ((int)(n)) -#endif -#define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) - -struct RRegexp { - struct RBasic basic; - struct re_pattern_buffer *ptr; - VALUE src; - unsigned long usecnt; -}; -#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) - -struct RHash { - struct RBasic basic; - struct st_table *ntbl; /* possibly 0 */ - int iter_lev; - VALUE ifnone; -}; -/* RHASH_TBL allocates st_table if not available. */ -#define RHASH_TBL(h) rb_hash_tbl(h) -#define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev) -#define RHASH_IFNONE(h) (RHASH(h)->ifnone) -#define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0) -#define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0) - -struct RFile { - struct RBasic basic; - struct rb_io_t *fptr; -}; - -struct RRational { - struct RBasic basic; - VALUE num; - VALUE den; -}; - -struct RComplex { - struct RBasic basic; - VALUE real; - VALUE imag; -}; - -struct RData { - struct RBasic basic; - void (*dmark)(void*); - void (*dfree)(void*); - void *data; -}; - -typedef struct rb_data_type_struct { - const char *wrap_struct_name; - void (*dmark)(void*); - void (*dfree)(void*); - size_t (*dsize)(const void *); - void *reserved[3]; /* For future extension. - This array *must* be filled with ZERO. */ - void *data; /* This area can be used for any purpose - by a programmer who define the type. */ -} rb_data_type_t; - -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*); - -VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC); -VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *); -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_TYPED_DEFAULT_FREE ((void (*)(void *))-1) - -#define Data_Wrap_Struct(klass,mark,free,sval)\ - rb_data_object_alloc(klass,sval,(RUBY_DATA_FUNC)mark,(RUBY_DATA_FUNC)free) - -#define Data_Make_Struct(klass,type,mark,free,sval) (\ - sval = ALLOC(type),\ - memset(sval, 0, sizeof(type)),\ - Data_Wrap_Struct(klass,mark,free,sval)\ -) - -#define TypedData_Wrap_Struct(klass,data_type,sval)\ - rb_data_typed_object_alloc(klass,sval,data_type) - -#define TypedData_Make_Struct(klass, type, data_type, sval) (\ - sval = ALLOC(type),\ - memset(sval, 0, sizeof(type)),\ - TypedData_Wrap_Struct(klass,data_type,sval)\ -) - -#define Data_Get_Struct(obj,type,sval) do {\ - Check_Type(obj, T_DATA); \ - sval = (type*)DATA_PTR(obj);\ -} while (0) - -#define TypedData_Get_Struct(obj,type,data_type,sval) do {\ - sval = (type*)rb_check_typeddata(obj, data_type); \ -} while (0) +/** @endcond */ + +/** + * Queries the name of the passed class. + * + * @param[in] klass An instance of a class. + * @return The name of `klass`. + * @note Return value is managed by our GC. Don't free. + */ +const char *rb_class2name(VALUE klass); + +/** + * 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); + +/** + * 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); + +/** + * 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); + +/** + * 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); -#define RSTRUCT_EMBED_LEN_MAX 3 -struct RStruct { - struct RBasic basic; - union { - struct { - long len; - VALUE *ptr; - } heap; - VALUE ary[RSTRUCT_EMBED_LEN_MAX]; - } as; -}; -#define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1) -#define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1) -#define RSTRUCT_LEN(st) \ - ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ - (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \ - (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \ - RSTRUCT(st)->as.heap.len) -#define RSTRUCT_PTR(st) \ - ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ - RSTRUCT(st)->as.ary : \ - RSTRUCT(st)->as.heap.ptr) - -#define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT))) -struct RBignum { - struct RBasic basic; - union { - struct { - long len; - BDIGIT *digits; - } heap; - BDIGIT ary[RBIGNUM_EMBED_LEN_MAX]; - } as; -}; -#define RBIGNUM_SIGN_BIT FL_USER1 -/* sign: positive:1, negative:0 */ -#define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0) -#define RBIGNUM_SET_SIGN(b,sign) \ - ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \ - : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT)) -#define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b) -#define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b)) - -#define RBIGNUM_EMBED_FLAG FL_USER2 -#define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3) -#define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3) -#define RBIGNUM_LEN(b) \ - ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ - (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \ - (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \ - RBIGNUM(b)->as.heap.len) -/* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */ -#define RBIGNUM_DIGITS(b) \ - ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ - RBIGNUM(b)->as.ary : \ - RBIGNUM(b)->as.heap.digits) - -#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 RFLOAT(obj) (R_CAST(RFloat)(obj)) -#define RSTRING(obj) (R_CAST(RString)(obj)) -#define RREGEXP(obj) (R_CAST(RRegexp)(obj)) -#define RARRAY(obj) (R_CAST(RArray)(obj)) -#define RHASH(obj) (R_CAST(RHash)(obj)) -#define RDATA(obj) (R_CAST(RData)(obj)) -#define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj)) -#define RSTRUCT(obj) (R_CAST(RStruct)(obj)) -#define RBIGNUM(obj) (R_CAST(RBignum)(obj)) -#define RFILE(obj) (R_CAST(RFile)(obj)) -#define RRATIONAL(obj) (R_CAST(RRational)(obj)) -#define RCOMPLEX(obj) (R_CAST(RComplex)(obj)) - -#define FL_SINGLETON FL_USER0 -#define FL_MARK (((VALUE)1)<<5) -#define FL_RESERVED (((VALUE)1)<<6) /* will be used in the future GC */ -#define FL_FINALIZE (((VALUE)1)<<7) -#define FL_TAINT (((VALUE)1)<<8) -#define FL_UNTRUSTED (((VALUE)1)<<9) -#define FL_EXIVAR (((VALUE)1)<<10) -#define FL_FREEZE (((VALUE)1)<<11) - -#define FL_USHIFT 12 - -#define FL_USER0 (((VALUE)1)<<(FL_USHIFT+0)) -#define FL_USER1 (((VALUE)1)<<(FL_USHIFT+1)) -#define FL_USER2 (((VALUE)1)<<(FL_USHIFT+2)) -#define FL_USER3 (((VALUE)1)<<(FL_USHIFT+3)) -#define FL_USER4 (((VALUE)1)<<(FL_USHIFT+4)) -#define FL_USER5 (((VALUE)1)<<(FL_USHIFT+5)) -#define FL_USER6 (((VALUE)1)<<(FL_USHIFT+6)) -#define FL_USER7 (((VALUE)1)<<(FL_USHIFT+7)) -#define FL_USER8 (((VALUE)1)<<(FL_USHIFT+8)) -#define FL_USER9 (((VALUE)1)<<(FL_USHIFT+9)) -#define FL_USER10 (((VALUE)1)<<(FL_USHIFT+10)) -#define FL_USER11 (((VALUE)1)<<(FL_USHIFT+11)) -#define FL_USER12 (((VALUE)1)<<(FL_USHIFT+12)) -#define FL_USER13 (((VALUE)1)<<(FL_USHIFT+13)) -#define FL_USER14 (((VALUE)1)<<(FL_USHIFT+14)) -#define FL_USER15 (((VALUE)1)<<(FL_USHIFT+15)) -#define FL_USER16 (((VALUE)1)<<(FL_USHIFT+16)) -#define FL_USER17 (((VALUE)1)<<(FL_USHIFT+17)) -#define FL_USER18 (((VALUE)1)<<(FL_USHIFT+18)) -#define FL_USER19 (((VALUE)1)<<(FL_USHIFT+19)) - -#define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x)) - -#define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE) -#define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0) -#define FL_ANY(x,f) FL_TEST(x,f) -#define FL_ALL(x,f) (FL_TEST(x,f) == (f)) -#define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0) -#define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0) -#define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0) - -#define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT)) -#define OBJ_TAINT(x) FL_SET((x), FL_TAINT) -#define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED)) -#define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED) -#define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & (FL_TAINT | FL_UNTRUSTED);} while (0) - -#define OBJ_FROZEN(x) (!!FL_TEST((x), FL_FREEZE)) -#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE) - -#if SIZEOF_INT < SIZEOF_VALUE -# define INT2NUM(v) INT2FIX((int)(v)) -# define UINT2NUM(v) LONG2FIX((unsigned int)(v)) -#else -# define INT2NUM_internal(v) (FIXABLE(v) ? INT2FIX(v) : rb_int2big(v)) -# ifdef __GNUC__ -# define INT2NUM(v) __extension__ ({int int2num_v = (v); INT2NUM_internal(int2num_v);}) -# else -static inline VALUE -INT2NUM(int v) -{ - return INT2NUM_internal(v); -} -# endif +#include "ruby/intern.h" -# define UINT2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) -# ifdef __GNUC__ -# define UINT2NUM(v) __extension__ ({unsigned int uint2num_v = (v); UINT2NUM_internal(uint2num_v);}) -# else -static inline VALUE -UINT2NUM(unsigned int v) -{ - return UINT2NUM_internal(v); -} -# endif -#endif +/** + * @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 */ -#define LONG2NUM_internal(v) (FIXABLE(v) ? LONG2FIX(v) : rb_int2big(v)) -#ifdef __GNUC__ -# define LONG2NUM(v) __extension__ ({long long2num_v = (v); LONG2NUM_internal(long2num_v);}) -#else -static inline VALUE -LONG2NUM(long v) -{ - return LONG2NUM_internal(v); -} -#endif +/** + * @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 -#define ULONG2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) -#ifdef __GNUC__ -# define ULONG2NUM(v) __extension__ ({unsigned long ulong2num_v = (v); ULONG2NUM_internal(ulong2num_v);}) -#else -static inline VALUE -ULONG2NUM(unsigned long v) -{ - return ULONG2NUM_internal(v); -} -#endif +/** + * 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); -#define NUM2CHR_internal(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\ - RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff)) -#ifdef __GNUC__ -# define NUM2CHR(x) __extension__ ({VALUE num2chr_x = (x); NUM2CHR_internal(num2chr_x);}) -#else -static inline char -NUM2CHR(VALUE x) +/** + * @private + * + * This macro is for internal use. Must be a mistake to place here. + */ +#define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} + +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, ...); + +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); + +#include <errno.h> + +/** + * @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. + */ + +/** + * Identical to system `errno`. + * + * @return The last set `errno` number. + */ +int rb_errno(void); + +/** + * Set the errno. + * + * @param err New `errno`. + * @post `errno` is now set to `err`. + */ +void rb_errno_set(int err); + +/** + * The location of `errno` + * + * @return The (thread-specific) location of `errno`. + */ +int *rb_errno_ptr(void); + +/** + * 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) { - return NUM2CHR_internal(x); + return &errno; } -#endif -#define CHR2FIX(x) INT2FIX((long)((x)&0xff)) - -#define ALLOC_N(type,n) (type*)xmalloc2((n),sizeof(type)) -#define ALLOC(type) (type*)xmalloc(sizeof(type)) -#define REALLOC_N(var,type,n) (var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)) - -#define ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n)) - -#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); - -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*,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); +#define rb_orig_errno errno /**< System-provided original `errno`. */ +#undef errno +#define errno (*rb_errno_ptr()) /**< Ractor-aware version of `errno`. */ -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_to_id(VALUE); -VALUE rb_id2str(ID); +/** @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); \ + }) -#define CONST_ID_CACHE(result, str) \ - { \ - static ID rb_intern_id_cache; \ - if (!rb_intern_id_cache) \ - rb_intern_id_cache = rb_intern2(str, strlen(str)); \ - result rb_intern_id_cache; \ - } -#define CONST_ID(var, str) \ - do CONST_ID_CACHE(var =, str) while (0) -#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(/**/, str)) : \ - rb_intern(str)) -#define rb_intern_const(str) \ - (__builtin_constant_p(str) ? \ - __extension__ (rb_intern2(str, strlen(str))) : \ - (rb_intern)(str)) -#else -#define rb_intern_const(str) rb_intern2(str, strlen(str)) +# 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 +/** @endcond */ -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_funcall2(VALUE, ID, int, const VALUE*); -VALUE rb_funcall3(VALUE, ID, int, const VALUE*); -int rb_scan_args(int, const VALUE*, const char*, ...); -VALUE rb_call_super(int, const VALUE*); - -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()) - -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_sys_fail(const char*)); -NORETURN(void rb_mod_sys_fail(VALUE, const char*)); -NORETURN(void rb_iter_break(void)); -NORETURN(void rb_exit(int)); -NORETURN(void rb_notimplement(void)); - -/* 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); - -typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*); - -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); -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,VALUE*,VALUE(*)(ANYARGS),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*); - -#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*); +#ifndef RUBY_DONT_SUBST +#include "ruby/subst.h" #endif -#define RUBY_INIT_STACK \ - VALUE variable_in_this_stack_frame; \ - ruby_init_stack(&variable_in_this_stack_frame); -void ruby_init(void); -void *ruby_options(int, char**); -int ruby_run_node(void *); -int ruby_exec_node(void *); - -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_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_stdin, rb_stdout, rb_stderr; - -static inline VALUE -rb_class_of(VALUE obj) -{ - if (IMMEDIATE_P(obj)) { - if (FIXNUM_P(obj)) return rb_cFixnum; - if (obj == Qtrue) return rb_cTrueClass; - if (SYMBOL_P(obj)) return rb_cSymbol; - } - else if (!RTEST(obj)) { - if (obj == Qnil) return rb_cNilClass; - if (obj == Qfalse) return rb_cFalseClass; - } - return RBASIC(obj)->klass; -} - -static inline int -rb_type(VALUE obj) -{ - if (IMMEDIATE_P(obj)) { - if (FIXNUM_P(obj)) return T_FIXNUM; - if (obj == Qtrue) return T_TRUE; - if (SYMBOL_P(obj)) return T_SYMBOL; - if (obj == Qundef) return T_UNDEF; - } - else if (!RTEST(obj)) { - if (obj == Qnil) return T_NIL; - if (obj == Qfalse) return T_FALSE; - } - return BUILTIN_TYPE(obj); -} - -#define RB_TYPE_P(obj, type) ( \ - ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ - ((type) == T_TRUE) ? ((obj) == Qtrue) : \ - ((type) == T_FALSE) ? ((obj) == Qfalse) : \ - ((type) == T_NIL) ? ((obj) == Qnil) : \ - ((type) == T_UNDEF) ? ((obj) == Qundef) : \ - ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ - (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) - -#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)) +#if !defined RUBY_EXPORT && !defined RUBY_NO_OLD_COMPATIBILITY +# include "ruby/backward.h" #endif -#ifdef __GNUC__ -#define rb_special_const_p(obj) \ - __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);}) -#else -static inline int -rb_special_const_p(VALUE obj) -{ - if (SPECIAL_CONST_P(obj)) return (int)Qtrue; - return (int)Qfalse; -} +#ifndef RUBY__ASAN_DEFAULT_OPTIONS +# define RUBY__ASAN_DEFAULT_OPTIONS #endif -#include "ruby/missing.h" -#include "ruby/intern.h" - -#if defined(EXTLIB) && defined(USE_DLN_A_OUT) -/* hook for external modules */ -static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; -#endif +#define RUBY_GLOBAL_SETUP \ + RUBY__ASAN_DEFAULT_OPTIONS \ + /* RUBY_GLOBAL_SETUP end */ -#if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__) -#define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */ +#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_GLOBAL_SETUP +# define ruby_start_main(main, argc, argv) main(argc, argv) #endif -void ruby_sysinit(int *, char ***); +RBIMPL_SYMBOL_EXPORT_END() -#define RUBY_VM 1 /* YARV */ -#define HAVE_NATIVETHREAD -int ruby_native_thread_p(void); - -#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 0xffff -#define RUBY_EVENT_VM 0x10000 -#define RUBY_EVENT_SWITCH 0x20000 -#define RUBY_EVENT_COVERAGE 0x40000 - -typedef unsigned int rb_event_flag_t; -typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass); - -typedef struct rb_event_hook_struct { - rb_event_flag_t flag; - rb_event_hook_func_t func; - VALUE data; - struct rb_event_hook_struct *next; -} rb_event_hook_t; - -#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 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)) -#endif -#define TOUPPER(c) rb_toupper((unsigned char)(c)) -#define TOLOWER(c) rb_tolower((unsigned char)(c)) - -int st_strcasecmp(const char *s1, const char *s2); -int st_strncasecmp(const char *s1, const char *s2, size_t n); -#define STRCASECMP(s1, s2) (st_strcasecmp(s1, s2)) -#define STRNCASECMP(s1, s2, n) (st_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)) - -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C" { */ -#endif #endif /* RUBY_RUBY_H */ |