1 /**********************************************************************
2
3 ruby/ruby.h -
4
5 $Author: naruse $
6 created at: Thu Jun 10 14:26:32 JST 1993
7
8 Copyright (C) 1993-2008 Yukihiro Matsumoto
9 Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
10 Copyright (C) 2000 Information-technology Promotion Agency, Japan
11
12 **********************************************************************/
13
14 #ifndef RUBY_RUBY_H
15 #define RUBY_RUBY_H 1
16
17 #if defined(__cplusplus)
18 extern "C" {
19 #if 0
20 } /* satisfy cc-mode */
21 #endif
22 #endif
23
24 #include "ruby/config.h"
25 #ifdef RUBY_EXTCONF_H
26 #include RUBY_EXTCONF_H
27 #endif
28
29 #include "defines.h"
30
31 /* For MinGW, we need __declspec(dllimport) for RUBY_EXTERN on MJIT.
32 mswin's RUBY_EXTERN already has that. See also: win32/Makefile.sub */
33 #if defined(MJIT_HEADER) && defined(_WIN32) && defined(__GNUC__)
34 # undef RUBY_EXTERN
35 # define RUBY_EXTERN extern __declspec(dllimport)
36 #endif
37
38 #if defined(__cplusplus)
39 /* __builtin_choose_expr and __builtin_types_compatible aren't available
40 * on C++. See https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */
41 # undef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P
42 # undef HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P
43 #elif GCC_VERSION_BEFORE(4,8,6) /* Bug #14221 */
44 # undef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P
45 #endif
46
47 #ifndef ASSUME
48 # ifdef UNREACHABLE
49 # define ASSUME(x) (RB_LIKELY(!!(x)) ? (void)0 : UNREACHABLE)
50 # else
51 # define ASSUME(x) ((void)(x))
52 # endif
53 #endif
54 #ifndef UNREACHABLE_RETURN
55 # ifdef UNREACHABLE
56 # define UNREACHABLE_RETURN(val) UNREACHABLE
57 # else
58 # define UNREACHABLE_RETURN(val) return (val)
59 # endif
60 #endif
61 #ifndef UNREACHABLE
62 # define UNREACHABLE ((void)0) /* unreachable */
63 #endif
64
65 #define RUBY_MACRO_SELECT(base, n) TOKEN_PASTE(base, n)
66
67 #ifdef HAVE_INTRINSICS_H
68 # include <intrinsics.h>
69 #endif
70
71 #include <stdarg.h>
72
73 RUBY_SYMBOL_EXPORT_BEGIN
74
75 /* Make alloca work the best possible way. */
76 #ifdef __GNUC__
77 # ifndef alloca
78 # define alloca __builtin_alloca
79 # endif
80 #else
81 # ifdef HAVE_ALLOCA_H
82 # include <alloca.h>
83 # else
84 # ifdef _AIX
85 #pragma alloca
86 # else
87 # ifndef alloca /* predefined by HP cc +Olibcalls */
88 void *alloca();
89 # endif
90 # endif /* AIX */
91 # endif /* HAVE_ALLOCA_H */
92 #endif /* __GNUC__ */
93
94 #if defined HAVE_UINTPTR_T && 0
95 typedef uintptr_t VALUE;
96 typedef uintptr_t ID;
97 # define SIGNED_VALUE intptr_t
98 # define SIZEOF_VALUE SIZEOF_UINTPTR_T
99 # undef PRI_VALUE_PREFIX
100 #elif SIZEOF_LONG == SIZEOF_VOIDP
101 typedef unsigned long VALUE;
102 typedef unsigned long ID;
103 # define SIGNED_VALUE long
104 # define SIZEOF_VALUE SIZEOF_LONG
105 # define PRI_VALUE_PREFIX "l"
106 #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
107 typedef unsigned LONG_LONG VALUE;
108 typedef unsigned LONG_LONG ID;
109 # define SIGNED_VALUE LONG_LONG
110 # define LONG_LONG_VALUE 1
111 # define SIZEOF_VALUE SIZEOF_LONG_LONG
112 # define PRI_VALUE_PREFIX PRI_LL_PREFIX
113 #else
114 # error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
115 #endif
116
117 typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1];
118 typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1];
119 #ifdef HAVE_LONG_LONG
120 typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1];
121 #endif
122 typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1];
123
124 #ifndef PRI_INT_PREFIX
125 #define PRI_INT_PREFIX ""
126 #endif
127 #ifndef PRI_LONG_PREFIX
128 #define PRI_LONG_PREFIX "l"
129 #endif
130 #ifndef PRI_SHORT_PREFIX
131 #define PRI_SHORT_PREFIX "h"
132 #endif
133
134 #ifndef PRI_64_PREFIX
135 #if SIZEOF_LONG == 8
136 #define PRI_64_PREFIX PRI_LONG_PREFIX
137 #elif SIZEOF_LONG_LONG == 8
138 #define PRI_64_PREFIX PRI_LL_PREFIX
139 #endif
140 #endif
141
142 #ifndef PRIdPTR
143 #define PRIdPTR PRI_PTR_PREFIX"d"
144 #define PRIiPTR PRI_PTR_PREFIX"i"
145 #define PRIoPTR PRI_PTR_PREFIX"o"
146 #define PRIuPTR PRI_PTR_PREFIX"u"
147 #define PRIxPTR PRI_PTR_PREFIX"x"
148 #define PRIXPTR PRI_PTR_PREFIX"X"
149 #endif
150
151 #define RUBY_PRI_VALUE_MARK "\v"
152 #if defined PRIdPTR && !defined PRI_VALUE_PREFIX
153 #define PRIdVALUE PRIdPTR
154 #define PRIoVALUE PRIoPTR
155 #define PRIuVALUE PRIuPTR
156 #define PRIxVALUE PRIxPTR
157 #define PRIXVALUE PRIXPTR
158 #define PRIsVALUE PRIiPTR"" RUBY_PRI_VALUE_MARK
159 #else
160 #define PRIdVALUE PRI_VALUE_PREFIX"d"
161 #define PRIoVALUE PRI_VALUE_PREFIX"o"
162 #define PRIuVALUE PRI_VALUE_PREFIX"u"
163 #define PRIxVALUE PRI_VALUE_PREFIX"x"
164 #define PRIXVALUE PRI_VALUE_PREFIX"X"
165 #define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK
166 #endif
167 #ifndef PRI_VALUE_PREFIX
168 # define PRI_VALUE_PREFIX ""
169 #endif
170
171 #ifndef PRI_TIMET_PREFIX
172 # if SIZEOF_TIME_T == SIZEOF_INT
173 # define PRI_TIMET_PREFIX
174 # elif SIZEOF_TIME_T == SIZEOF_LONG
175 # define PRI_TIMET_PREFIX "l"
176 # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
177 # define PRI_TIMET_PREFIX PRI_LL_PREFIX
178 # endif
179 #endif
180
181 #if defined PRI_PTRDIFF_PREFIX
182 #elif SIZEOF_PTRDIFF_T == SIZEOF_INT
183 # define PRI_PTRDIFF_PREFIX ""
184 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
185 # define PRI_PTRDIFF_PREFIX "l"
186 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
187 # define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX
188 #endif
189 #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
190 #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
191 #define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
192 #define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
193 #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
194 #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
195
196 #if defined PRI_SIZE_PREFIX
197 #elif SIZEOF_SIZE_T == SIZEOF_INT
198 # define PRI_SIZE_PREFIX ""
199 #elif SIZEOF_SIZE_T == SIZEOF_LONG
200 # define PRI_SIZE_PREFIX "l"
201 #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG
202 # define PRI_SIZE_PREFIX PRI_LL_PREFIX
203 #endif
204 #define PRIdSIZE PRI_SIZE_PREFIX"d"
205 #define PRIiSIZE PRI_SIZE_PREFIX"i"
206 #define PRIoSIZE PRI_SIZE_PREFIX"o"
207 #define PRIuSIZE PRI_SIZE_PREFIX"u"
208 #define PRIxSIZE PRI_SIZE_PREFIX"x"
209 #define PRIXSIZE PRI_SIZE_PREFIX"X"
210
211 #ifdef __STDC__
212 # include <limits.h>
213 #else
214 # ifndef LONG_MAX
215 # ifdef HAVE_LIMITS_H
216 # include <limits.h>
217 # else
218 /* assuming 32bit(2's complement) long */
219 # define LONG_MAX 2147483647
220 # endif
221 # endif
222 # ifndef LONG_MIN
223 # define LONG_MIN (-LONG_MAX-1)
224 # endif
225 # ifndef CHAR_BIT
226 # define CHAR_BIT 8
227 # endif
228 #endif
229
230 #ifdef HAVE_LONG_LONG
231 # ifndef LLONG_MAX
232 # ifdef LONG_LONG_MAX
233 # define LLONG_MAX LONG_LONG_MAX
234 # else
235 # ifdef _I64_MAX
236 # define LLONG_MAX _I64_MAX
237 # else
238 /* assuming 64bit(2's complement) long long */
239 # define LLONG_MAX 9223372036854775807LL
240 # endif
241 # endif
242 # endif
243 # ifndef LLONG_MIN
244 # ifdef LONG_LONG_MIN
245 # define LLONG_MIN LONG_LONG_MIN
246 # else
247 # ifdef _I64_MIN
248 # define LLONG_MIN _I64_MIN
249 # else
250 # define LLONG_MIN (-LLONG_MAX-1)
251 # endif
252 # endif
253 # endif
254 #endif
255
256 #define RUBY_FIXNUM_MAX (LONG_MAX>>1)
257 #define RUBY_FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
258 #define FIXNUM_MAX RUBY_FIXNUM_MAX
259 #define FIXNUM_MIN RUBY_FIXNUM_MIN
260
261 #define RB_INT2FIX(i) (((VALUE)(i))<<1 | RUBY_FIXNUM_FLAG)
262 #define INT2FIX(i) RB_INT2FIX(i)
263 #define RB_LONG2FIX(i) RB_INT2FIX(i)
264 #define LONG2FIX(i) RB_INT2FIX(i)
265 #define rb_fix_new(v) RB_INT2FIX(v)
266 VALUE rb_int2inum(intptr_t);
267
268 #define rb_int_new(v) rb_int2inum(v)
269 VALUE rb_uint2inum(uintptr_t);
270
271 #define rb_uint_new(v) rb_uint2inum(v)
272
273 #ifdef HAVE_LONG_LONG
274 VALUE rb_ll2inum(LONG_LONG);
275 #define LL2NUM(v) rb_ll2inum(v)
276 VALUE rb_ull2inum(unsigned LONG_LONG);
277 #define ULL2NUM(v) rb_ull2inum(v)
278 #endif
279
280 #ifndef OFFT2NUM
281 #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
282 # define OFFT2NUM(v) LL2NUM(v)
283 #elif SIZEOF_OFF_T == SIZEOF_LONG
284 # define OFFT2NUM(v) LONG2NUM(v)
285 #else
286 # define OFFT2NUM(v) INT2NUM(v)
287 #endif
288 #endif
289
290 #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
291 # define SIZET2NUM(v) ULL2NUM(v)
292 # define SSIZET2NUM(v) LL2NUM(v)
293 #elif SIZEOF_SIZE_T == SIZEOF_LONG
294 # define SIZET2NUM(v) ULONG2NUM(v)
295 # define SSIZET2NUM(v) LONG2NUM(v)
296 #else
297 # define SIZET2NUM(v) UINT2NUM(v)
298 # define SSIZET2NUM(v) INT2NUM(v)
299 #endif
300
301 #ifndef SIZE_MAX
302 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
303 # define SIZE_MAX ULLONG_MAX
304 # define SIZE_MIN ULLONG_MIN
305 # elif SIZEOF_SIZE_T == SIZEOF_LONG
306 # define SIZE_MAX ULONG_MAX
307 # define SIZE_MIN ULONG_MIN
308 # elif SIZEOF_SIZE_T == SIZEOF_INT
309 # define SIZE_MAX UINT_MAX
310 # define SIZE_MIN UINT_MIN
311 # else
312 # define SIZE_MAX USHRT_MAX
313 # define SIZE_MIN USHRT_MIN
314 # endif
315 #endif
316
317 #ifndef SSIZE_MAX
318 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
319 # define SSIZE_MAX LLONG_MAX
320 # define SSIZE_MIN LLONG_MIN
321 # elif SIZEOF_SIZE_T == SIZEOF_LONG
322 # define SSIZE_MAX LONG_MAX
323 # define SSIZE_MIN LONG_MIN
324 # elif SIZEOF_SIZE_T == SIZEOF_INT
325 # define SSIZE_MAX INT_MAX
326 # define SSIZE_MIN INT_MIN
327 # else
328 # define SSIZE_MAX SHRT_MAX
329 # define SSIZE_MIN SHRT_MIN
330 # endif
331 #endif
332
333 #if SIZEOF_INT < SIZEOF_VALUE
334 NORETURN(void rb_out_of_int(SIGNED_VALUE num));
335 #endif
336
337 #if SIZEOF_INT < SIZEOF_LONG
338 static inline int
rb_long2int_inline(long n)339 rb_long2int_inline(long n)
340 {
341 int i = (int)n;
342 if ((long)i != n)
343 rb_out_of_int(n);
344
345 return i;
346 }
347 #define rb_long2int(n) rb_long2int_inline(n)
348 #else
349 #define rb_long2int(n) ((int)(n))
350 #endif
351
352 #ifndef PIDT2NUM
353 #define PIDT2NUM(v) LONG2NUM(v)
354 #endif
355 #ifndef NUM2PIDT
356 #define NUM2PIDT(v) NUM2LONG(v)
357 #endif
358 #ifndef UIDT2NUM
359 #define UIDT2NUM(v) LONG2NUM(v)
360 #endif
361 #ifndef NUM2UIDT
362 #define NUM2UIDT(v) NUM2LONG(v)
363 #endif
364 #ifndef GIDT2NUM
365 #define GIDT2NUM(v) LONG2NUM(v)
366 #endif
367 #ifndef NUM2GIDT
368 #define NUM2GIDT(v) NUM2LONG(v)
369 #endif
370 #ifndef NUM2MODET
371 #define NUM2MODET(v) NUM2INT(v)
372 #endif
373 #ifndef MODET2NUM
374 #define MODET2NUM(v) INT2NUM(v)
375 #endif
376
377 #define RB_FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1))
378 static inline long
rb_fix2long(VALUE x)379 rb_fix2long(VALUE x)
380 {
381 return RB_FIX2LONG(x);
382 }
383 #define RB_FIX2ULONG(x) ((unsigned long)RB_FIX2LONG(x))
384 static inline unsigned long
rb_fix2ulong(VALUE x)385 rb_fix2ulong(VALUE x)
386 {
387 return RB_FIX2ULONG(x);
388 }
389 #define RB_FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&RUBY_FIXNUM_FLAG)
390 #define RB_POSFIXABLE(f) ((f) < RUBY_FIXNUM_MAX+1)
391 #define RB_NEGFIXABLE(f) ((f) >= RUBY_FIXNUM_MIN)
392 #define RB_FIXABLE(f) (RB_POSFIXABLE(f) && RB_NEGFIXABLE(f))
393 #define FIX2LONG(x) RB_FIX2LONG(x)
394 #define FIX2ULONG(x) RB_FIX2ULONG(x)
395 #define FIXNUM_P(f) RB_FIXNUM_P(f)
396 #define POSFIXABLE(f) RB_POSFIXABLE(f)
397 #define NEGFIXABLE(f) RB_NEGFIXABLE(f)
398 #define FIXABLE(f) RB_FIXABLE(f)
399
400 #define RB_IMMEDIATE_P(x) ((VALUE)(x) & RUBY_IMMEDIATE_MASK)
401 #define IMMEDIATE_P(x) RB_IMMEDIATE_P(x)
402
403 ID rb_sym2id(VALUE);
404 VALUE rb_id2sym(ID);
405 #define RB_STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT)) == RUBY_SYMBOL_FLAG)
406 #define RB_DYNAMIC_SYM_P(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) == (RUBY_T_SYMBOL))
407 #define RB_SYMBOL_P(x) (RB_STATIC_SYM_P(x)||RB_DYNAMIC_SYM_P(x))
408 #define RB_ID2SYM(x) (rb_id2sym(x))
409 #define RB_SYM2ID(x) (rb_sym2id(x))
410 #define STATIC_SYM_P(x) RB_STATIC_SYM_P(x)
411 #define DYNAMIC_SYM_P(x) RB_DYNAMIC_SYM_P(x)
412 #define SYMBOL_P(x) RB_SYMBOL_P(x)
413 #define ID2SYM(x) RB_ID2SYM(x)
414 #define SYM2ID(x) RB_SYM2ID(x)
415
416 #ifndef USE_FLONUM
417 #if SIZEOF_VALUE >= SIZEOF_DOUBLE
418 #define USE_FLONUM 1
419 #else
420 #define USE_FLONUM 0
421 #endif
422 #endif
423
424 #if USE_FLONUM
425 #define RB_FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG)
426 #else
427 #define RB_FLONUM_P(x) 0
428 #endif
429 #define FLONUM_P(x) RB_FLONUM_P(x)
430
431 /* Module#methods, #singleton_methods and so on return Symbols */
432 #define USE_SYMBOL_AS_METHOD_NAME 1
433
434 /* special constants - i.e. non-zero and non-fixnum constants */
435 enum ruby_special_consts {
436 #if USE_FLONUM
437 RUBY_Qfalse = 0x00, /* ...0000 0000 */
438 RUBY_Qtrue = 0x14, /* ...0001 0100 */
439 RUBY_Qnil = 0x08, /* ...0000 1000 */
440 RUBY_Qundef = 0x34, /* ...0011 0100 */
441
442 RUBY_IMMEDIATE_MASK = 0x07,
443 RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */
444 RUBY_FLONUM_MASK = 0x03,
445 RUBY_FLONUM_FLAG = 0x02, /* ...xxxx xx10 */
446 RUBY_SYMBOL_FLAG = 0x0c, /* ...0000 1100 */
447 #else
448 RUBY_Qfalse = 0, /* ...0000 0000 */
449 RUBY_Qtrue = 2, /* ...0000 0010 */
450 RUBY_Qnil = 4, /* ...0000 0100 */
451 RUBY_Qundef = 6, /* ...0000 0110 */
452
453 RUBY_IMMEDIATE_MASK = 0x03,
454 RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */
455 RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */
456 RUBY_FLONUM_FLAG = 0x02,
457 RUBY_SYMBOL_FLAG = 0x0e, /* ...0000 1110 */
458 #endif
459 RUBY_SPECIAL_SHIFT = 8
460 };
461
462 #define RUBY_Qfalse ((VALUE)RUBY_Qfalse)
463 #define RUBY_Qtrue ((VALUE)RUBY_Qtrue)
464 #define RUBY_Qnil ((VALUE)RUBY_Qnil)
465 #define RUBY_Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */
466 #define Qfalse RUBY_Qfalse
467 #define Qtrue RUBY_Qtrue
468 #define Qnil RUBY_Qnil
469 #define Qundef RUBY_Qundef
470 #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
471 #define FIXNUM_FLAG RUBY_FIXNUM_FLAG
472 #if USE_FLONUM
473 #define FLONUM_MASK RUBY_FLONUM_MASK
474 #define FLONUM_FLAG RUBY_FLONUM_FLAG
475 #endif
476 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
477
478 #define RB_TEST(v) !(((VALUE)(v) & (VALUE)~RUBY_Qnil) == 0)
479 #define RB_NIL_P(v) !((VALUE)(v) != RUBY_Qnil)
480 #define RTEST(v) RB_TEST(v)
481 #define NIL_P(v) RB_NIL_P(v)
482
483 #define CLASS_OF(v) rb_class_of((VALUE)(v))
484
485 enum ruby_value_type {
486 RUBY_T_NONE = 0x00,
487
488 RUBY_T_OBJECT = 0x01,
489 RUBY_T_CLASS = 0x02,
490 RUBY_T_MODULE = 0x03,
491 RUBY_T_FLOAT = 0x04,
492 RUBY_T_STRING = 0x05,
493 RUBY_T_REGEXP = 0x06,
494 RUBY_T_ARRAY = 0x07,
495 RUBY_T_HASH = 0x08,
496 RUBY_T_STRUCT = 0x09,
497 RUBY_T_BIGNUM = 0x0a,
498 RUBY_T_FILE = 0x0b,
499 RUBY_T_DATA = 0x0c,
500 RUBY_T_MATCH = 0x0d,
501 RUBY_T_COMPLEX = 0x0e,
502 RUBY_T_RATIONAL = 0x0f,
503
504 RUBY_T_NIL = 0x11,
505 RUBY_T_TRUE = 0x12,
506 RUBY_T_FALSE = 0x13,
507 RUBY_T_SYMBOL = 0x14,
508 RUBY_T_FIXNUM = 0x15,
509 RUBY_T_UNDEF = 0x16,
510
511 RUBY_T_IMEMO = 0x1a, /*!< @see imemo_type */
512 RUBY_T_NODE = 0x1b,
513 RUBY_T_ICLASS = 0x1c,
514 RUBY_T_ZOMBIE = 0x1d,
515
516 RUBY_T_MASK = 0x1f
517 };
518
519 #define T_NONE RUBY_T_NONE
520 #define T_NIL RUBY_T_NIL
521 #define T_OBJECT RUBY_T_OBJECT
522 #define T_CLASS RUBY_T_CLASS
523 #define T_ICLASS RUBY_T_ICLASS
524 #define T_MODULE RUBY_T_MODULE
525 #define T_FLOAT RUBY_T_FLOAT
526 #define T_STRING RUBY_T_STRING
527 #define T_REGEXP RUBY_T_REGEXP
528 #define T_ARRAY RUBY_T_ARRAY
529 #define T_HASH RUBY_T_HASH
530 #define T_STRUCT RUBY_T_STRUCT
531 #define T_BIGNUM RUBY_T_BIGNUM
532 #define T_FILE RUBY_T_FILE
533 #define T_FIXNUM RUBY_T_FIXNUM
534 #define T_TRUE RUBY_T_TRUE
535 #define T_FALSE RUBY_T_FALSE
536 #define T_DATA RUBY_T_DATA
537 #define T_MATCH RUBY_T_MATCH
538 #define T_SYMBOL RUBY_T_SYMBOL
539 #define T_RATIONAL RUBY_T_RATIONAL
540 #define T_COMPLEX RUBY_T_COMPLEX
541 #define T_IMEMO RUBY_T_IMEMO
542 #define T_UNDEF RUBY_T_UNDEF
543 #define T_NODE RUBY_T_NODE
544 #define T_ZOMBIE RUBY_T_ZOMBIE
545 #define T_MASK RUBY_T_MASK
546
547 #define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK)
548 #define BUILTIN_TYPE(x) RB_BUILTIN_TYPE(x)
549
550 static inline int rb_type(VALUE obj);
551 #define TYPE(x) rb_type((VALUE)(x))
552
553 #define RB_FLOAT_TYPE_P(obj) (\
554 RB_FLONUM_P(obj) || \
555 (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == RUBY_T_FLOAT))
556
557 #define RB_TYPE_P(obj, type) ( \
558 ((type) == RUBY_T_FIXNUM) ? RB_FIXNUM_P(obj) : \
559 ((type) == RUBY_T_TRUE) ? ((obj) == RUBY_Qtrue) : \
560 ((type) == RUBY_T_FALSE) ? ((obj) == RUBY_Qfalse) : \
561 ((type) == RUBY_T_NIL) ? ((obj) == RUBY_Qnil) : \
562 ((type) == RUBY_T_UNDEF) ? ((obj) == RUBY_Qundef) : \
563 ((type) == RUBY_T_SYMBOL) ? RB_SYMBOL_P(obj) : \
564 ((type) == RUBY_T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \
565 (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == (type)))
566
567 #ifdef __GNUC__
568 #define RB_GC_GUARD(v) \
569 (*__extension__ ({ \
570 volatile VALUE *rb_gc_guarded_ptr = &(v); \
571 __asm__("" : : "m"(rb_gc_guarded_ptr)); \
572 rb_gc_guarded_ptr; \
573 }))
574 #elif defined _MSC_VER
575 #pragma optimize("", off)
rb_gc_guarded_ptr(volatile VALUE * ptr)576 static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
577 #pragma optimize("", on)
578 #define RB_GC_GUARD(v) (*rb_gc_guarded_ptr(&(v)))
579 #else
580 volatile VALUE *rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val);
581 #define HAVE_RB_GC_GUARDED_PTR_VAL 1
582 #define RB_GC_GUARD(v) (*rb_gc_guarded_ptr_val(&(v),(v)))
583 #endif
584
585 #ifdef __GNUC__
586 #define RB_UNUSED_VAR(x) x __attribute__ ((unused))
587 #else
588 #define RB_UNUSED_VAR(x) x
589 #endif
590
591 void rb_check_type(VALUE,int);
592 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
593
594 VALUE rb_str_to_str(VALUE);
595 VALUE rb_string_value(volatile VALUE*);
596 char *rb_string_value_ptr(volatile VALUE*);
597 char *rb_string_value_cstr(volatile VALUE*);
598
599 #define StringValue(v) rb_string_value(&(v))
600 #define StringValuePtr(v) rb_string_value_ptr(&(v))
601 #define StringValueCStr(v) rb_string_value_cstr(&(v))
602
603 void rb_check_safe_obj(VALUE);
604 #define SafeStringValue(v) do {\
605 StringValue(v);\
606 rb_check_safe_obj(v);\
607 } while (0)
608 #if GCC_VERSION_SINCE(4,4,0)
609 void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use SafeStringValue() instead")));
610 # define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
611 #else
612 # define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">]
613 # define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">]
614 #endif
615
616 VALUE rb_str_export(VALUE);
617 #define ExportStringValue(v) do {\
618 SafeStringValue(v);\
619 (v) = rb_str_export(v);\
620 } while (0)
621 VALUE rb_str_export_locale(VALUE);
622
623 VALUE rb_get_path(VALUE);
624 #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
625
626 VALUE rb_get_path_no_checksafe(VALUE);
627 #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
628
629 #define RUBY_SAFE_LEVEL_MAX 1
630 void rb_secure(int);
631 int rb_safe_level(void);
632 void rb_set_safe_level(int);
633 #if GCC_VERSION_SINCE(4,4,0)
634 int ruby_safe_level_2_error(void) __attribute__((error("$SAFE=2 to 4 are obsolete")));
635 int ruby_safe_level_2_warning(void) __attribute__((const,warning("$SAFE=2 to 4 are obsolete")));
636 # ifdef RUBY_EXPORT
637 # define ruby_safe_level_2_warning() ruby_safe_level_2_error()
638 # endif
639 # if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
640 # define RUBY_SAFE_LEVEL_INVALID_P(level) \
641 __extension__(\
642 __builtin_choose_expr(\
643 __builtin_constant_p(level), \
644 ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)), 0))
645 # define RUBY_SAFE_LEVEL_CHECK(level, type) \
646 __extension__(__builtin_choose_expr(RUBY_SAFE_LEVEL_INVALID_P(level), ruby_safe_level_2_##type(), (level)))
647 # else
648 /* in gcc 4.8 or earlier, __builtin_choose_expr() does not consider
649 * __builtin_constant_p(variable) a constant expression.
650 */
651 # define RUBY_SAFE_LEVEL_INVALID_P(level) \
652 __extension__(__builtin_constant_p(level) && \
653 ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)))
654 # define RUBY_SAFE_LEVEL_CHECK(level, type) \
655 (RUBY_SAFE_LEVEL_INVALID_P(level) ? ruby_safe_level_2_##type() : (level))
656 # endif
657 # define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning))
658 # define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error))
659 #endif
660 void rb_set_safe_level_force(int);
661 void rb_secure_update(VALUE);
662 NORETURN(void rb_insecure_operation(void));
663
664 VALUE rb_errinfo(void);
665 void rb_set_errinfo(VALUE);
666
667 long rb_num2long(VALUE);
668 unsigned long rb_num2ulong(VALUE);
669 static inline long
rb_num2long_inline(VALUE x)670 rb_num2long_inline(VALUE x)
671 {
672 if (RB_FIXNUM_P(x))
673 return RB_FIX2LONG(x);
674 else
675 return rb_num2long(x);
676 }
677 #define RB_NUM2LONG(x) rb_num2long_inline(x)
678 #define NUM2LONG(x) RB_NUM2LONG(x)
679 static inline unsigned long
rb_num2ulong_inline(VALUE x)680 rb_num2ulong_inline(VALUE x)
681 {
682 if (RB_FIXNUM_P(x))
683 return RB_FIX2ULONG(x);
684 else
685 return rb_num2ulong(x);
686 }
687 #define RB_NUM2ULONG(x) rb_num2ulong_inline(x)
688 #define NUM2ULONG(x) RB_NUM2ULONG(x)
689 #if SIZEOF_INT < SIZEOF_LONG
690 long rb_num2int(VALUE);
691 long rb_fix2int(VALUE);
692 #define RB_FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
693
694 static inline int
rb_num2int_inline(VALUE x)695 rb_num2int_inline(VALUE x)
696 {
697 if (RB_FIXNUM_P(x))
698 return (int)rb_fix2int(x);
699 else
700 return (int)rb_num2int(x);
701 }
702 #define RB_NUM2INT(x) rb_num2int_inline(x)
703
704 unsigned long rb_num2uint(VALUE);
705 #define RB_NUM2UINT(x) ((unsigned int)rb_num2uint(x))
706 unsigned long rb_fix2uint(VALUE);
707 #define RB_FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
708 #else /* SIZEOF_INT < SIZEOF_LONG */
709 #define RB_NUM2INT(x) ((int)RB_NUM2LONG(x))
710 #define RB_NUM2UINT(x) ((unsigned int)RB_NUM2ULONG(x))
711 #define RB_FIX2INT(x) ((int)RB_FIX2LONG(x))
712 #define RB_FIX2UINT(x) ((unsigned int)RB_FIX2ULONG(x))
713 #endif /* SIZEOF_INT < SIZEOF_LONG */
714 #define NUM2INT(x) RB_NUM2INT(x)
715 #define NUM2UINT(x) RB_NUM2UINT(x)
716 #define FIX2INT(x) RB_FIX2INT(x)
717 #define FIX2UINT(x) RB_FIX2UINT(x)
718
719 short rb_num2short(VALUE);
720 unsigned short rb_num2ushort(VALUE);
721 short rb_fix2short(VALUE);
722 unsigned short rb_fix2ushort(VALUE);
723 #define RB_FIX2SHORT(x) (rb_fix2short((VALUE)(x)))
724 #define FIX2SHORT(x) RB_FIX2SHORT(x)
725 static inline short
rb_num2short_inline(VALUE x)726 rb_num2short_inline(VALUE x)
727 {
728 if (RB_FIXNUM_P(x))
729 return rb_fix2short(x);
730 else
731 return rb_num2short(x);
732 }
733
734 #define RB_NUM2SHORT(x) rb_num2short_inline(x)
735 #define RB_NUM2USHORT(x) rb_num2ushort(x)
736 #define NUM2SHORT(x) RB_NUM2SHORT(x)
737 #define NUM2USHORT(x) RB_NUM2USHORT(x)
738
739 #ifdef HAVE_LONG_LONG
740 LONG_LONG rb_num2ll(VALUE);
741 unsigned LONG_LONG rb_num2ull(VALUE);
742 static inline LONG_LONG
rb_num2ll_inline(VALUE x)743 rb_num2ll_inline(VALUE x)
744 {
745 if (RB_FIXNUM_P(x))
746 return RB_FIX2LONG(x);
747 else
748 return rb_num2ll(x);
749 }
750 # define RB_NUM2LL(x) rb_num2ll_inline(x)
751 # define RB_NUM2ULL(x) rb_num2ull(x)
752 # define NUM2LL(x) RB_NUM2LL(x)
753 # define NUM2ULL(x) RB_NUM2ULL(x)
754 #endif
755
756 #if !defined(NUM2OFFT)
757 # if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
758 # define NUM2OFFT(x) ((off_t)NUM2LL(x))
759 # else
760 # define NUM2OFFT(x) NUM2LONG(x)
761 # endif
762 #endif
763
764 #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
765 # define NUM2SIZET(x) ((size_t)NUM2ULL(x))
766 # define NUM2SSIZET(x) ((ssize_t)NUM2LL(x))
767 #else
768 # define NUM2SIZET(x) NUM2ULONG(x)
769 # define NUM2SSIZET(x) NUM2LONG(x)
770 #endif
771
772 double rb_num2dbl(VALUE);
773 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
774
775 VALUE rb_uint2big(uintptr_t);
776 VALUE rb_int2big(intptr_t);
777
778 VALUE rb_newobj(void);
779 VALUE rb_newobj_of(VALUE, VALUE);
780 VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type);
781 #define RB_NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
782 #define RB_NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags)
783 #define NEWOBJ(obj,type) RB_NEWOBJ(obj,type)
784 #define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags) /* core has special NEWOBJ_OF() in internal.h */
785 #define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */
786 #define CLONESETUP(clone,obj) rb_clone_setup(clone,obj)
787 #define DUPSETUP(dup,obj) rb_dup_setup(dup,obj)
788
789 #ifndef USE_RGENGC
790 #define USE_RGENGC 1
791 #ifndef USE_RINCGC
792 #define USE_RINCGC 1
793 #endif
794 #endif
795
796 #if USE_RGENGC == 0
797 #define USE_RINCGC 0
798 #endif
799
800 #ifndef RGENGC_WB_PROTECTED_ARRAY
801 #define RGENGC_WB_PROTECTED_ARRAY 1
802 #endif
803 #ifndef RGENGC_WB_PROTECTED_HASH
804 #define RGENGC_WB_PROTECTED_HASH 1
805 #endif
806 #ifndef RGENGC_WB_PROTECTED_STRUCT
807 #define RGENGC_WB_PROTECTED_STRUCT 1
808 #endif
809 #ifndef RGENGC_WB_PROTECTED_STRING
810 #define RGENGC_WB_PROTECTED_STRING 1
811 #endif
812 #ifndef RGENGC_WB_PROTECTED_OBJECT
813 #define RGENGC_WB_PROTECTED_OBJECT 1
814 #endif
815 #ifndef RGENGC_WB_PROTECTED_REGEXP
816 #define RGENGC_WB_PROTECTED_REGEXP 1
817 #endif
818 #ifndef RGENGC_WB_PROTECTED_CLASS
819 #define RGENGC_WB_PROTECTED_CLASS 1
820 #endif
821 #ifndef RGENGC_WB_PROTECTED_FLOAT
822 #define RGENGC_WB_PROTECTED_FLOAT 1
823 #endif
824 #ifndef RGENGC_WB_PROTECTED_COMPLEX
825 #define RGENGC_WB_PROTECTED_COMPLEX 1
826 #endif
827 #ifndef RGENGC_WB_PROTECTED_RATIONAL
828 #define RGENGC_WB_PROTECTED_RATIONAL 1
829 #endif
830 #ifndef RGENGC_WB_PROTECTED_BIGNUM
831 #define RGENGC_WB_PROTECTED_BIGNUM 1
832 #endif
833 #ifndef RGENGC_WB_PROTECTED_NODE_CREF
834 #define RGENGC_WB_PROTECTED_NODE_CREF 1
835 #endif
836
837 #ifdef __GNUC__
838 __extension__
839 #endif
840 enum ruby_fl_type {
841 RUBY_FL_WB_PROTECTED = (1<<5),
842 RUBY_FL_PROMOTED0 = (1<<5),
843 RUBY_FL_PROMOTED1 = (1<<6),
844 RUBY_FL_PROMOTED = RUBY_FL_PROMOTED0|RUBY_FL_PROMOTED1,
845 RUBY_FL_FINALIZE = (1<<7),
846 RUBY_FL_TAINT = (1<<8),
847 RUBY_FL_UNTRUSTED = RUBY_FL_TAINT,
848 RUBY_FL_EXIVAR = (1<<10),
849 RUBY_FL_FREEZE = (1<<11),
850
851 RUBY_FL_USHIFT = 12,
852
853 #define RUBY_FL_USER_N(n) RUBY_FL_USER##n = (1<<(RUBY_FL_USHIFT+n))
854 RUBY_FL_USER_N(0),
855 RUBY_FL_USER_N(1),
856 RUBY_FL_USER_N(2),
857 RUBY_FL_USER_N(3),
858 RUBY_FL_USER_N(4),
859 RUBY_FL_USER_N(5),
860 RUBY_FL_USER_N(6),
861 RUBY_FL_USER_N(7),
862 RUBY_FL_USER_N(8),
863 RUBY_FL_USER_N(9),
864 RUBY_FL_USER_N(10),
865 RUBY_FL_USER_N(11),
866 RUBY_FL_USER_N(12),
867 RUBY_FL_USER_N(13),
868 RUBY_FL_USER_N(14),
869 RUBY_FL_USER_N(15),
870 RUBY_FL_USER_N(16),
871 RUBY_FL_USER_N(17),
872 RUBY_FL_USER_N(18),
873 #if defined ENUM_OVER_INT || SIZEOF_INT*CHAR_BIT>12+19+1
874 RUBY_FL_USER_N(19),
875 #else
876 #define RUBY_FL_USER19 (((VALUE)1)<<(RUBY_FL_USHIFT+19))
877 #endif
878
879 RUBY_ELTS_SHARED = RUBY_FL_USER2,
880 RUBY_FL_DUPPED = (RUBY_T_MASK|RUBY_FL_EXIVAR|RUBY_FL_TAINT),
881 RUBY_FL_SINGLETON = RUBY_FL_USER0
882 };
883
RUBY_ALIGNAS(SIZEOF_VALUE)884 struct RUBY_ALIGNAS(SIZEOF_VALUE) RBasic {
885 VALUE flags;
886 const VALUE klass;
887 };
888
889 VALUE rb_obj_hide(VALUE obj);
890 VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change klass information */
891
892 #if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
893 # define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \
894 __extension__( \
895 __builtin_choose_expr( \
896 RGENGC_WB_PROTECTED_##type, \
897 OBJ_WB_UNPROTECT((VALUE)(obj)), ((VALUE)(obj))))
898 #else
899 # define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \
900 (RGENGC_WB_PROTECTED_##type ? \
901 OBJ_WB_UNPROTECT((VALUE)(obj)) : ((VALUE)(obj)))
902 #endif
903
904 #define RBASIC_CLASS(obj) (RBASIC(obj)->klass)
905
906 #define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX
907 #define ROBJECT_EMBED ROBJECT_EMBED
908 enum ruby_robject_flags {
909 ROBJECT_EMBED_LEN_MAX = 3,
910 ROBJECT_EMBED = RUBY_FL_USER1,
911
912 ROBJECT_ENUM_END
913 };
914
915 struct RObject {
916 struct RBasic basic;
917 union {
918 struct {
919 uint32_t numiv;
920 VALUE *ivptr;
921 void *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
922 } heap;
923 VALUE ary[ROBJECT_EMBED_LEN_MAX];
924 } as;
925 };
926 #define ROBJECT_NUMIV(o) \
927 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
928 ROBJECT_EMBED_LEN_MAX : \
929 ROBJECT(o)->as.heap.numiv)
930 #define ROBJECT_IVPTR(o) \
931 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
932 ROBJECT(o)->as.ary : \
933 ROBJECT(o)->as.heap.ivptr)
934 #define ROBJECT_IV_INDEX_TBL(o) \
935 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
936 RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
937 ROBJECT(o)->as.heap.iv_index_tbl)
938
939 #define RCLASS_SUPER(c) rb_class_get_superclass(c)
940 #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
941 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
942 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
943 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
944 #define RMODULE_IS_OVERLAID RMODULE_IS_OVERLAID
945 #define RMODULE_IS_REFINEMENT RMODULE_IS_REFINEMENT
946 #define RMODULE_INCLUDED_INTO_REFINEMENT RMODULE_INCLUDED_INTO_REFINEMENT
947 enum ruby_rmodule_flags {
948 RMODULE_IS_OVERLAID = RUBY_FL_USER2,
949 RMODULE_IS_REFINEMENT = RUBY_FL_USER3,
950 RMODULE_INCLUDED_INTO_REFINEMENT = RUBY_FL_USER4,
951
952 RMODULE_ENUM_END
953 };
954
955 PUREFUNC(double rb_float_value(VALUE));
956 VALUE rb_float_new(double);
957 VALUE rb_float_new_in_heap(double);
958
959 #define RFLOAT_VALUE(v) rb_float_value(v)
960 #define DBL2NUM(dbl) rb_float_new(dbl)
961
962 #define RUBY_ELTS_SHARED RUBY_ELTS_SHARED
963 #define ELTS_SHARED RUBY_ELTS_SHARED
964
965 #define RSTRING_NOEMBED RSTRING_NOEMBED
966 #define RSTRING_EMBED_LEN_MASK RSTRING_EMBED_LEN_MASK
967 #define RSTRING_EMBED_LEN_SHIFT RSTRING_EMBED_LEN_SHIFT
968 #define RSTRING_EMBED_LEN_MAX RSTRING_EMBED_LEN_MAX
969 #define RSTRING_FSTR RSTRING_FSTR
970 enum ruby_rstring_flags {
971 RSTRING_NOEMBED = RUBY_FL_USER1,
972 RSTRING_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4|
973 RUBY_FL_USER5|RUBY_FL_USER6),
974 RSTRING_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+2),
975 RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*3)/sizeof(char)-1),
976 RSTRING_FSTR = RUBY_FL_USER17,
977
978 RSTRING_ENUM_END
979 };
980
981 struct RString {
982 struct RBasic basic;
983 union {
984 struct {
985 long len;
986 char *ptr;
987 union {
988 long capa;
989 VALUE shared;
990 } aux;
991 } heap;
992 char ary[RSTRING_EMBED_LEN_MAX + 1];
993 } as;
994 };
995 #define RSTRING_EMBED_LEN(str) \
996 (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
997 (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
998 #define RSTRING_LEN(str) \
999 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
1000 RSTRING_EMBED_LEN(str) : \
1001 RSTRING(str)->as.heap.len)
1002 #define RSTRING_PTR(str) \
1003 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
1004 RSTRING(str)->as.ary : \
1005 RSTRING(str)->as.heap.ptr)
1006 #define RSTRING_END(str) \
1007 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
1008 (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
1009 (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
1010 #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
1011 #define RSTRING_GETMEM(str, ptrvar, lenvar) \
1012 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
1013 ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
1014 ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
1015
1016 #ifndef USE_TRANSIENT_HEAP
1017 #define USE_TRANSIENT_HEAP 1
1018 #endif
1019
1020 enum ruby_rarray_flags {
1021 RARRAY_EMBED_LEN_MAX = 3,
1022 RARRAY_EMBED_FLAG = RUBY_FL_USER1,
1023 /* RUBY_FL_USER2 is for ELTS_SHARED */
1024 RARRAY_EMBED_LEN_MASK = (RUBY_FL_USER4|RUBY_FL_USER3),
1025 RARRAY_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+3),
1026
1027 #if USE_TRANSIENT_HEAP
1028 RARRAY_TRANSIENT_FLAG = RUBY_FL_USER13,
1029 #define RARRAY_TRANSIENT_FLAG RARRAY_TRANSIENT_FLAG
1030 #else
1031 #define RARRAY_TRANSIENT_FLAG 0
1032 #endif
1033
1034 RARRAY_ENUM_END
1035 };
1036 #define RARRAY_EMBED_FLAG (VALUE)RARRAY_EMBED_FLAG
1037 #define RARRAY_EMBED_LEN_MASK (VALUE)RARRAY_EMBED_LEN_MASK
1038 #define RARRAY_EMBED_LEN_MAX RARRAY_EMBED_LEN_MAX
1039 #define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT
1040
1041 struct RArray {
1042 struct RBasic basic;
1043 union {
1044 struct {
1045 long len;
1046 union {
1047 long capa;
1048 VALUE shared;
1049 } aux;
1050 const VALUE *ptr;
1051 } heap;
1052 const VALUE ary[RARRAY_EMBED_LEN_MAX];
1053 } as;
1054 };
1055 #define RARRAY_EMBED_LEN(a) \
1056 (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
1057 (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT))
1058 #define RARRAY_LEN(a) rb_array_len(a)
1059 #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
1060 #define RARRAY_CONST_PTR(a) rb_array_const_ptr(a)
1061 #define RARRAY_CONST_PTR_TRANSIENT(a) rb_array_const_ptr_transient(a)
1062
1063 #if USE_TRANSIENT_HEAP
1064 #define RARRAY_TRANSIENT_P(ary) FL_TEST_RAW((ary), RARRAY_TRANSIENT_FLAG)
1065 #else
1066 #define RARRAY_TRANSIENT_P(ary) 0
1067 #endif
1068
1069 #define RARRAY_PTR_USE_START_TRANSIENT(a) rb_array_ptr_use_start(a, 1)
1070 #define RARRAY_PTR_USE_END_TRANSIENT(a) rb_array_ptr_use_end(a, 1)
1071
1072 #define RARRAY_PTR_USE_TRANSIENT(ary, ptr_name, expr) do { \
1073 const VALUE _ary = (ary); \
1074 VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); \
1075 expr; \
1076 RARRAY_PTR_USE_END_TRANSIENT(_ary); \
1077 } while (0)
1078
1079 #define RARRAY_PTR_USE_START(a) rb_array_ptr_use_start(a, 0)
1080 #define RARRAY_PTR_USE_END(a) rb_array_ptr_use_end(a, 0)
1081
1082 #define RARRAY_PTR_USE(ary, ptr_name, expr) do { \
1083 const VALUE _ary = (ary); \
1084 VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); \
1085 expr; \
1086 RARRAY_PTR_USE_END(_ary); \
1087 } while (0)
1088
1089 #define RARRAY_AREF(a, i) (RARRAY_CONST_PTR_TRANSIENT(a)[i])
1090 #define RARRAY_ASET(a, i, v) do { \
1091 const VALUE _ary = (a); \
1092 const VALUE _v = (v); \
1093 VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); \
1094 RB_OBJ_WRITE(_ary, &ptr[i], _v); \
1095 RARRAY_PTR_USE_END_TRANSIENT(_ary); \
1096 } while (0)
1097
1098 #define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(ARRAY, a)))
1099
1100 struct RRegexp {
1101 struct RBasic basic;
1102 struct re_pattern_buffer *ptr;
1103 const VALUE src;
1104 unsigned long usecnt;
1105 };
1106 #define RREGEXP_PTR(r) (RREGEXP(r)->ptr)
1107 #define RREGEXP_SRC(r) (RREGEXP(r)->src)
1108 #define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
1109 #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
1110 #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
1111
1112 /* RHash is defined at internal.h */
1113 size_t rb_hash_size_num(VALUE hash);
1114
1115 #define RHASH_TBL(h) rb_hash_tbl(h, __FILE__, __LINE__)
1116 #define RHASH_ITER_LEV(h) rb_hash_iter_lev(h)
1117 #define RHASH_IFNONE(h) rb_hash_ifnone(h)
1118 #define RHASH_SIZE(h) rb_hash_size_num(h)
1119 #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
1120 #define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone)
1121
1122 struct RFile {
1123 struct RBasic basic;
1124 struct rb_io_t *fptr;
1125 };
1126
1127 struct RData {
1128 struct RBasic basic;
1129 void (*dmark)(void*);
1130 void (*dfree)(void*);
1131 void *data;
1132 };
1133
1134 typedef struct rb_data_type_struct rb_data_type_t;
1135
1136 struct rb_data_type_struct {
1137 const char *wrap_struct_name;
1138 struct {
1139 void (*dmark)(void*);
1140 void (*dfree)(void*);
1141 size_t (*dsize)(const void *);
1142 void *reserved[2]; /* For future extension.
1143 This array *must* be filled with ZERO. */
1144 } function;
1145 const rb_data_type_t *parent;
1146 void *data; /* This area can be used for any purpose
1147 by a programmer who define the type. */
1148 VALUE flags; /* RUBY_FL_WB_PROTECTED */
1149 };
1150
1151 #define HAVE_TYPE_RB_DATA_TYPE_T 1
1152 #define HAVE_RB_DATA_TYPE_T_FUNCTION 1
1153 #define HAVE_RB_DATA_TYPE_T_PARENT 1
1154
1155 struct RTypedData {
1156 struct RBasic basic;
1157 const rb_data_type_t *type;
1158 VALUE typed_flag; /* 1 or not */
1159 void *data;
1160 };
1161
1162 #define DATA_PTR(dta) (RDATA(dta)->data)
1163
1164 #define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1)
1165 #define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
1166 #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
1167
1168 /*
1169 #define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
1170 */
1171 typedef void (*RUBY_DATA_FUNC)(void*);
1172
1173 #ifndef RUBY_UNTYPED_DATA_WARNING
1174 # if defined RUBY_EXPORT
1175 # define RUBY_UNTYPED_DATA_WARNING 1
1176 # else
1177 # define RUBY_UNTYPED_DATA_WARNING 0
1178 # endif
1179 #endif
1180 VALUE rb_data_object_wrap(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
1181 VALUE rb_data_object_zalloc(VALUE,size_t,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
1182 VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *);
1183 VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type);
1184 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
1185 int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *);
1186 void *rb_check_typeddata(VALUE, const rb_data_type_t *);
1187 #define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
1188 #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
1189 #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0)
1190 #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
1191 #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE
1192
1193 /* bits for rb_data_type_struct::flags */
1194 #define RUBY_TYPED_FREE_IMMEDIATELY 1 /* TYPE field */
1195 #define RUBY_TYPED_WB_PROTECTED RUBY_FL_WB_PROTECTED /* THIS FLAG DEPENDS ON Ruby version */
1196 #define RUBY_TYPED_PROMOTED1 RUBY_FL_PROMOTED1 /* THIS FLAG DEPENDS ON Ruby version */
1197
1198 #define Data_Wrap_Struct(klass,mark,free,sval)\
1199 rb_data_object_wrap((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
1200
1201 #define Data_Make_Struct0(result, klass, type, size, mark, free, sval) \
1202 VALUE result = rb_data_object_zalloc((klass), (size), \
1203 (RUBY_DATA_FUNC)(mark), \
1204 (RUBY_DATA_FUNC)(free)); \
1205 (void)((sval) = (type *)DATA_PTR(result));
1206
1207 #ifdef __GNUC__
1208 #define Data_Make_Struct(klass,type,mark,free,sval) RB_GNUC_EXTENSION_BLOCK(\
1209 Data_Make_Struct0(data_struct_obj, klass, type, sizeof(type), mark, free, sval); \
1210 data_struct_obj \
1211 )
1212 #else
1213 #define Data_Make_Struct(klass,type,mark,free,sval) (\
1214 rb_data_object_make((klass),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free),(void **)&(sval),sizeof(type)) \
1215 )
1216 #endif
1217
1218 #define TypedData_Wrap_Struct(klass,data_type,sval)\
1219 rb_data_typed_object_wrap((klass),(sval),(data_type))
1220
1221 #define TypedData_Make_Struct0(result, klass, type, size, data_type, sval) \
1222 VALUE result = rb_data_typed_object_zalloc(klass, size, data_type); \
1223 (void)((sval) = (type *)DATA_PTR(result));
1224
1225 #ifdef __GNUC__
1226 #define TypedData_Make_Struct(klass, type, data_type, sval) RB_GNUC_EXTENSION_BLOCK(\
1227 TypedData_Make_Struct0(data_struct_obj, klass, type, sizeof(type), data_type, sval); \
1228 data_struct_obj \
1229 )
1230 #else
1231 #define TypedData_Make_Struct(klass, type, data_type, sval) (\
1232 rb_data_typed_object_make((klass),(data_type),(void **)&(sval),sizeof(type)) \
1233 )
1234 #endif
1235
1236 #define Data_Get_Struct(obj,type,sval) \
1237 ((sval) = (type*)rb_data_object_get(obj))
1238
1239 #define TypedData_Get_Struct(obj,type,data_type,sval) \
1240 ((sval) = (type*)rb_check_typeddata((obj), (data_type)))
1241
1242 #define RSTRUCT_LEN(st) NUM2LONG(rb_struct_size(st))
1243 #define RSTRUCT_PTR(st) rb_struct_ptr(st)
1244 #define RSTRUCT_SET(st, idx, v) rb_struct_aset(st, INT2NUM(idx), (v))
1245 #define RSTRUCT_GET(st, idx) rb_struct_aref(st, INT2NUM(idx))
1246
1247 int rb_big_sign(VALUE);
1248 #define RBIGNUM_SIGN(b) (rb_big_sign(b))
1249 #define RBIGNUM_POSITIVE_P(b) (RBIGNUM_SIGN(b)!=0)
1250 #define RBIGNUM_NEGATIVE_P(b) (RBIGNUM_SIGN(b)==0)
1251
1252 #define R_CAST(st) (struct st*)
1253 #define RBASIC(obj) (R_CAST(RBasic)(obj))
1254 #define ROBJECT(obj) (R_CAST(RObject)(obj))
1255 #define RCLASS(obj) (R_CAST(RClass)(obj))
1256 #define RMODULE(obj) RCLASS(obj)
1257 #define RSTRING(obj) (R_CAST(RString)(obj))
1258 #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
1259 #define RARRAY(obj) (R_CAST(RArray)(obj))
1260 #define RDATA(obj) (R_CAST(RData)(obj))
1261 #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj))
1262 #define RFILE(obj) (R_CAST(RFile)(obj))
1263
1264 #define FL_SINGLETON ((VALUE)RUBY_FL_SINGLETON)
1265 #define FL_WB_PROTECTED ((VALUE)RUBY_FL_WB_PROTECTED)
1266 #define FL_PROMOTED0 ((VALUE)RUBY_FL_PROMOTED0)
1267 #define FL_PROMOTED1 ((VALUE)RUBY_FL_PROMOTED1)
1268 #define FL_FINALIZE ((VALUE)RUBY_FL_FINALIZE)
1269 #define FL_TAINT ((VALUE)RUBY_FL_TAINT)
1270 #define FL_UNTRUSTED ((VALUE)RUBY_FL_UNTRUSTED)
1271 #define FL_EXIVAR ((VALUE)RUBY_FL_EXIVAR)
1272 #define FL_FREEZE ((VALUE)RUBY_FL_FREEZE)
1273
1274 #define FL_USHIFT ((VALUE)RUBY_FL_USHIFT)
1275
1276 #define FL_USER0 ((VALUE)RUBY_FL_USER0)
1277 #define FL_USER1 ((VALUE)RUBY_FL_USER1)
1278 #define FL_USER2 ((VALUE)RUBY_FL_USER2)
1279 #define FL_USER3 ((VALUE)RUBY_FL_USER3)
1280 #define FL_USER4 ((VALUE)RUBY_FL_USER4)
1281 #define FL_USER5 ((VALUE)RUBY_FL_USER5)
1282 #define FL_USER6 ((VALUE)RUBY_FL_USER6)
1283 #define FL_USER7 ((VALUE)RUBY_FL_USER7)
1284 #define FL_USER8 ((VALUE)RUBY_FL_USER8)
1285 #define FL_USER9 ((VALUE)RUBY_FL_USER9)
1286 #define FL_USER10 ((VALUE)RUBY_FL_USER10)
1287 #define FL_USER11 ((VALUE)RUBY_FL_USER11)
1288 #define FL_USER12 ((VALUE)RUBY_FL_USER12)
1289 #define FL_USER13 ((VALUE)RUBY_FL_USER13)
1290 #define FL_USER14 ((VALUE)RUBY_FL_USER14)
1291 #define FL_USER15 ((VALUE)RUBY_FL_USER15)
1292 #define FL_USER16 ((VALUE)RUBY_FL_USER16)
1293 #define FL_USER17 ((VALUE)RUBY_FL_USER17)
1294 #define FL_USER18 ((VALUE)RUBY_FL_USER18)
1295 #define FL_USER19 ((VALUE)RUBY_FL_USER19)
1296
1297 #define RB_SPECIAL_CONST_P(x) (RB_IMMEDIATE_P(x) || !RB_TEST(x))
1298 #define SPECIAL_CONST_P(x) RB_SPECIAL_CONST_P(x)
1299
1300 #define RB_FL_ABLE(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) != RUBY_T_NODE)
1301 #define RB_FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f))
1302 #define RB_FL_TEST(x,f) (RB_FL_ABLE(x)?RB_FL_TEST_RAW((x),(f)):0)
1303 #define RB_FL_ANY_RAW(x,f) RB_FL_TEST_RAW((x),(f))
1304 #define RB_FL_ANY(x,f) RB_FL_TEST((x),(f))
1305 #define RB_FL_ALL_RAW(x,f) (RB_FL_TEST_RAW((x),(f)) == (f))
1306 #define RB_FL_ALL(x,f) (RB_FL_TEST((x),(f)) == (f))
1307 #define RB_FL_SET_RAW(x,f) (void)(RBASIC(x)->flags |= (f))
1308 #define RB_FL_SET(x,f) (RB_FL_ABLE(x) ? RB_FL_SET_RAW(x, f) : (void)0)
1309 #define RB_FL_UNSET_RAW(x,f) (void)(RBASIC(x)->flags &= ~(VALUE)(f))
1310 #define RB_FL_UNSET(x,f) (RB_FL_ABLE(x) ? RB_FL_UNSET_RAW(x, f) : (void)0)
1311 #define RB_FL_REVERSE_RAW(x,f) (void)(RBASIC(x)->flags ^= (f))
1312 #define RB_FL_REVERSE(x,f) (RB_FL_ABLE(x) ? RB_FL_REVERSE_RAW(x, f) : (void)0)
1313
1314 #define RB_OBJ_TAINTABLE(x) (RB_FL_ABLE(x) && RB_BUILTIN_TYPE(x) != RUBY_T_BIGNUM && RB_BUILTIN_TYPE(x) != RUBY_T_FLOAT)
1315 #define RB_OBJ_TAINTED_RAW(x) RB_FL_TEST_RAW(x, RUBY_FL_TAINT)
1316 #define RB_OBJ_TAINTED(x) (!!RB_FL_TEST((x), RUBY_FL_TAINT))
1317 #define RB_OBJ_TAINT_RAW(x) RB_FL_SET_RAW(x, RUBY_FL_TAINT)
1318 #define RB_OBJ_TAINT(x) (RB_OBJ_TAINTABLE(x) ? RB_OBJ_TAINT_RAW(x) : (void)0)
1319 #define RB_OBJ_UNTRUSTED(x) RB_OBJ_TAINTED(x)
1320 #define RB_OBJ_UNTRUST(x) RB_OBJ_TAINT(x)
1321 #define RB_OBJ_INFECT_RAW(x,s) RB_FL_SET_RAW(x, RB_OBJ_TAINTED_RAW(s))
1322 #define RB_OBJ_INFECT(x,s) ( \
1323 (RB_OBJ_TAINTABLE(x) && RB_FL_ABLE(s)) ? \
1324 RB_OBJ_INFECT_RAW(x, s) : (void)0)
1325
1326 #define RB_OBJ_FROZEN_RAW(x) (RBASIC(x)->flags&RUBY_FL_FREEZE)
1327 #define RB_OBJ_FROZEN(x) (!RB_FL_ABLE(x) || RB_OBJ_FROZEN_RAW(x))
1328 #define RB_OBJ_FREEZE_RAW(x) (void)(RBASIC(x)->flags |= RUBY_FL_FREEZE)
1329 #define RB_OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x)
1330
1331 /*!
1332 * \defgroup deprecated_macros deprecated macro APIs
1333 * \{
1334 * \par These macros are deprecated. Prefer their `RB_`-prefixed versions.
1335 */
1336 #define FL_ABLE(x) RB_FL_ABLE(x)
1337 #define FL_TEST_RAW(x,f) RB_FL_TEST_RAW(x,f)
1338 #define FL_TEST(x,f) RB_FL_TEST(x,f)
1339 #define FL_ANY_RAW(x,f) RB_FL_ANY_RAW(x,f)
1340 #define FL_ANY(x,f) RB_FL_ANY(x,f)
1341 #define FL_ALL_RAW(x,f) RB_FL_ALL_RAW(x,f)
1342 #define FL_ALL(x,f) RB_FL_ALL(x,f)
1343 #define FL_SET_RAW(x,f) RB_FL_SET_RAW(x,f)
1344 #define FL_SET(x,f) RB_FL_SET(x,f)
1345 #define FL_UNSET_RAW(x,f) RB_FL_UNSET_RAW(x,f)
1346 #define FL_UNSET(x,f) RB_FL_UNSET(x,f)
1347 #define FL_REVERSE_RAW(x,f) RB_FL_REVERSE_RAW(x,f)
1348 #define FL_REVERSE(x,f) RB_FL_REVERSE(x,f)
1349
1350 #define OBJ_TAINTABLE(x) RB_OBJ_TAINTABLE(x)
1351 #define OBJ_TAINTED_RAW(x) RB_OBJ_TAINTED_RAW(x)
1352 #define OBJ_TAINTED(x) RB_OBJ_TAINTED(x)
1353 #define OBJ_TAINT_RAW(x) RB_OBJ_TAINT_RAW(x)
1354 #define OBJ_TAINT(x) RB_OBJ_TAINT(x)
1355 #define OBJ_UNTRUSTED(x) RB_OBJ_UNTRUSTED(x)
1356 #define OBJ_UNTRUST(x) RB_OBJ_UNTRUST(x)
1357 #define OBJ_INFECT_RAW(x,s) RB_OBJ_INFECT_RAW(x,s)
1358 #define OBJ_INFECT(x,s) RB_OBJ_INFECT(x,s)
1359 #define OBJ_FROZEN_RAW(x) RB_OBJ_FROZEN_RAW(x)
1360 #define OBJ_FROZEN(x) RB_OBJ_FROZEN(x)
1361 #define OBJ_FREEZE_RAW(x) RB_OBJ_FREEZE_RAW(x)
1362 #define OBJ_FREEZE(x) RB_OBJ_FREEZE(x)
1363
1364 /* \} */
1365
1366 void rb_freeze_singleton_class(VALUE klass);
1367
1368 static inline void
rb_obj_freeze_inline(VALUE x)1369 rb_obj_freeze_inline(VALUE x)
1370 {
1371 if (RB_FL_ABLE(x)) {
1372 RB_OBJ_FREEZE_RAW(x);
1373 if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & RUBY_FL_SINGLETON)) {
1374 rb_freeze_singleton_class(x);
1375 }
1376 }
1377 }
1378
1379 #if GCC_VERSION_SINCE(4,4,0)
1380 # define RUBY_UNTYPED_DATA_FUNC(func) func __attribute__((warning("untyped Data is unsafe; use TypedData instead")))
1381 #else
1382 # define RUBY_UNTYPED_DATA_FUNC(func) DEPRECATED(func)
1383 #endif
1384
1385 #if defined(__GNUC__) && !defined(__NO_INLINE__)
1386 #if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
1387 RUBY_UNTYPED_DATA_FUNC(static inline VALUE rb_data_object_wrap_warning(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC));
1388 #endif
1389 RUBY_UNTYPED_DATA_FUNC(static inline void *rb_data_object_get_warning(VALUE));
1390
1391 static inline VALUE
rb_data_object_wrap_warning(VALUE klass,void * ptr,RUBY_DATA_FUNC mark,RUBY_DATA_FUNC free)1392 rb_data_object_wrap_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free)
1393 {
1394 return rb_data_object_wrap(klass, ptr, mark, free);
1395 }
1396
1397 #if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
1398 #define rb_data_object_wrap_warning(klass, ptr, mark, free) \
1399 __extension__( \
1400 __builtin_choose_expr( \
1401 __builtin_constant_p(klass) && !(klass), \
1402 rb_data_object_wrap(klass, ptr, mark, free), \
1403 rb_data_object_wrap_warning(klass, ptr, mark, free)))
1404 #endif
1405 #endif
1406
1407 static inline void *
rb_data_object_get(VALUE obj)1408 rb_data_object_get(VALUE obj)
1409 {
1410 Check_Type(obj, RUBY_T_DATA);
1411 return ((struct RData *)obj)->data;
1412 }
1413
1414 #if defined(__GNUC__) && !defined(__NO_INLINE__)
1415 static inline void *
rb_data_object_get_warning(VALUE obj)1416 rb_data_object_get_warning(VALUE obj)
1417 {
1418 return rb_data_object_get(obj);
1419 }
1420 #endif
1421
1422 static inline VALUE
rb_data_object_make(VALUE klass,RUBY_DATA_FUNC mark_func,RUBY_DATA_FUNC free_func,void ** datap,size_t size)1423 rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **datap, size_t size)
1424 {
1425 Data_Make_Struct0(result, klass, void, size, mark_func, free_func, *datap);
1426 return result;
1427 }
1428
1429 static inline VALUE
rb_data_typed_object_make(VALUE klass,const rb_data_type_t * type,void ** datap,size_t size)1430 rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size)
1431 {
1432 TypedData_Make_Struct0(result, klass, void, size, type, *datap);
1433 return result;
1434 }
1435
1436 #ifndef rb_data_object_alloc
1437 DEPRECATED_BY(rb_data_object_wrap, static inline VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC));
1438 static inline VALUE
rb_data_object_alloc(VALUE klass,void * data,RUBY_DATA_FUNC dmark,RUBY_DATA_FUNC dfree)1439 rb_data_object_alloc(VALUE klass, void *data, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
1440 {
1441 return rb_data_object_wrap(klass, data, dmark, dfree);
1442 }
1443 #endif
1444
1445 #ifndef rb_data_typed_object_alloc
1446 DEPRECATED_BY(rb_data_typed_object_wrap, static inline VALUE rb_data_typed_object_alloc(VALUE,void*,const rb_data_type_t*));
1447 static inline VALUE
rb_data_typed_object_alloc(VALUE klass,void * datap,const rb_data_type_t * type)1448 rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *type)
1449 {
1450 return rb_data_typed_object_wrap(klass, datap, type);
1451 }
1452 #endif
1453
1454 #if defined(__GNUC__) && !defined(__NO_INLINE__)
1455 #define rb_data_object_wrap_0 rb_data_object_wrap
1456 #define rb_data_object_wrap_1 rb_data_object_wrap_warning
1457 #define rb_data_object_wrap RUBY_MACRO_SELECT(rb_data_object_wrap_, RUBY_UNTYPED_DATA_WARNING)
1458 #define rb_data_object_get_0 rb_data_object_get
1459 #define rb_data_object_get_1 rb_data_object_get_warning
1460 #define rb_data_object_get RUBY_MACRO_SELECT(rb_data_object_get_, RUBY_UNTYPED_DATA_WARNING)
1461 #define rb_data_object_make_0 rb_data_object_make
1462 #define rb_data_object_make_1 rb_data_object_make_warning
1463 #define rb_data_object_make RUBY_MACRO_SELECT(rb_data_object_make_, RUBY_UNTYPED_DATA_WARNING)
1464 #endif
1465
1466 #if USE_RGENGC
1467 #define RB_OBJ_PROMOTED_RAW(x) RB_FL_ALL_RAW(x, RUBY_FL_PROMOTED)
1468 #define RB_OBJ_PROMOTED(x) (RB_SPECIAL_CONST_P(x) ? 0 : RB_OBJ_PROMOTED_RAW(x))
1469 #define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
1470
1471 void rb_gc_writebarrier(VALUE a, VALUE b);
1472 void rb_gc_writebarrier_unprotect(VALUE obj);
1473
1474 #else /* USE_RGENGC */
1475 #define RB_OBJ_PROMOTED(x) 0
1476 #define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
1477 #endif
1478 #define OBJ_PROMOTED_RAW(x) RB_OBJ_PROMOTED_RAW(x)
1479 #define OBJ_PROMOTED(x) RB_OBJ_PROMOTED(x)
1480 #define OBJ_WB_UNPROTECT(x) RB_OBJ_WB_UNPROTECT(x)
1481
1482 /* Write barrier (WB) interfaces:
1483 * - RB_OBJ_WRITE(a, slot, b): WB for new reference from `a' to `b'.
1484 * Write `b' into `*slot'. `slot' is a pointer in `a'.
1485 * - RB_OBJ_WRITTEN(a, oldv, b): WB for new reference from `a' to `b'.
1486 * This doesn't write any values, but only a WB declaration.
1487 * `oldv' is replaced value with `b' (not used in current Ruby).
1488 *
1489 * NOTE: The following core interfaces can be changed in the future.
1490 * Please catch up if you want to insert WB into C-extensions
1491 * correctly.
1492 */
1493 #define RB_OBJ_WRITE(a, slot, b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__)
1494 #define RB_OBJ_WRITTEN(a, oldv, b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__)
1495
1496 #ifndef USE_RGENGC_LOGGING_WB_UNPROTECT
1497 #define USE_RGENGC_LOGGING_WB_UNPROTECT 0
1498 #endif
1499
1500 #if USE_RGENGC_LOGGING_WB_UNPROTECT
1501 void rb_gc_unprotect_logging(void *objptr, const char *filename, int line);
1502 #define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging
1503 #endif
1504
1505 static inline VALUE
rb_obj_wb_unprotect(VALUE x,RB_UNUSED_VAR (const char * filename),RB_UNUSED_VAR (int line))1506 rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1507 {
1508 #ifdef RGENGC_LOGGING_WB_UNPROTECT
1509 RGENGC_LOGGING_WB_UNPROTECT((void *)x, filename, line);
1510 #endif
1511 #if USE_RGENGC
1512 rb_gc_writebarrier_unprotect(x);
1513 #endif
1514 return x;
1515 }
1516
1517 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))1518 rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1519 {
1520 #ifdef RGENGC_LOGGING_OBJ_WRITTEN
1521 RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line);
1522 #endif
1523
1524 #if USE_RGENGC
1525 if (!RB_SPECIAL_CONST_P(b)) {
1526 rb_gc_writebarrier(a, b);
1527 }
1528 #endif
1529
1530 return a;
1531 }
1532
1533 static inline VALUE
rb_obj_write(VALUE a,VALUE * slot,VALUE b,RB_UNUSED_VAR (const char * filename),RB_UNUSED_VAR (int line))1534 rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1535 {
1536 #ifdef RGENGC_LOGGING_WRITE
1537 RGENGC_LOGGING_WRITE(a, slot, b, filename, line);
1538 #endif
1539
1540 *slot = b;
1541
1542 #if USE_RGENGC
1543 rb_obj_written(a, RUBY_Qundef /* ignore `oldv' now */, b, filename, line);
1544 #endif
1545 return a;
1546 }
1547
1548 #define RUBY_INTEGER_UNIFICATION 1
1549 #define RB_INTEGER_TYPE_P(obj) rb_integer_type_p(obj)
1550 #if defined __GNUC__ && !GCC_VERSION_SINCE(4, 3, 0)
1551 /* clang 3.x (4.2 compatible) can't eliminate CSE of RB_BUILTIN_TYPE
1552 * in inline function and caller function */
1553 #define rb_integer_type_p(obj) \
1554 __extension__ ({ \
1555 const VALUE integer_type_obj = (obj); \
1556 (RB_FIXNUM_P(integer_type_obj) || \
1557 (!RB_SPECIAL_CONST_P(integer_type_obj) && \
1558 RB_BUILTIN_TYPE(integer_type_obj) == RUBY_T_BIGNUM)); \
1559 })
1560 #else
1561 static inline int
rb_integer_type_p(VALUE obj)1562 rb_integer_type_p(VALUE obj)
1563 {
1564 return (RB_FIXNUM_P(obj) ||
1565 (!RB_SPECIAL_CONST_P(obj) &&
1566 RB_BUILTIN_TYPE(obj) == RUBY_T_BIGNUM));
1567 }
1568 #endif
1569
1570 #if SIZEOF_INT < SIZEOF_LONG
1571 # define RB_INT2NUM(v) RB_INT2FIX((int)(v))
1572 # define RB_UINT2NUM(v) RB_LONG2FIX((unsigned int)(v))
1573 #else
1574 static inline VALUE
rb_int2num_inline(int v)1575 rb_int2num_inline(int v)
1576 {
1577 if (RB_FIXABLE(v))
1578 return RB_INT2FIX(v);
1579 else
1580 return rb_int2big(v);
1581 }
1582 #define RB_INT2NUM(x) rb_int2num_inline(x)
1583
1584 static inline VALUE
rb_uint2num_inline(unsigned int v)1585 rb_uint2num_inline(unsigned int v)
1586 {
1587 if (RB_POSFIXABLE(v))
1588 return RB_LONG2FIX(v);
1589 else
1590 return rb_uint2big(v);
1591 }
1592 #define RB_UINT2NUM(x) rb_uint2num_inline(x)
1593 #endif
1594 #define INT2NUM(x) RB_INT2NUM(x)
1595 #define UINT2NUM(x) RB_UINT2NUM(x)
1596
1597 static inline VALUE
rb_long2num_inline(long v)1598 rb_long2num_inline(long v)
1599 {
1600 if (RB_FIXABLE(v))
1601 return RB_LONG2FIX(v);
1602 else
1603 return rb_int2big(v);
1604 }
1605 #define RB_LONG2NUM(x) rb_long2num_inline(x)
1606
1607 static inline VALUE
rb_ulong2num_inline(unsigned long v)1608 rb_ulong2num_inline(unsigned long v)
1609 {
1610 if (RB_POSFIXABLE(v))
1611 return RB_LONG2FIX(v);
1612 else
1613 return rb_uint2big(v);
1614 }
1615 #define RB_ULONG2NUM(x) rb_ulong2num_inline(x)
1616
1617 static inline char
rb_num2char_inline(VALUE x)1618 rb_num2char_inline(VALUE x)
1619 {
1620 if (RB_TYPE_P(x, RUBY_T_STRING) && (RSTRING_LEN(x)>=1))
1621 return RSTRING_PTR(x)[0];
1622 else
1623 return (char)(NUM2INT(x) & 0xff);
1624 }
1625 #define RB_NUM2CHR(x) rb_num2char_inline(x)
1626
1627 #define RB_CHR2FIX(x) RB_INT2FIX((long)((x)&0xff))
1628
1629 #define LONG2NUM(x) RB_LONG2NUM(x)
1630 #define ULONG2NUM(x) RB_ULONG2NUM(x)
1631 #define USHORT2NUM(x) RB_INT2FIX(x)
1632 #define NUM2CHR(x) RB_NUM2CHR(x)
1633 #define CHR2FIX(x) RB_CHR2FIX(x)
1634
1635 #if SIZEOF_LONG < SIZEOF_VALUE
1636 #define RB_ST2FIX(h) RB_LONG2FIX((long)((h) > 0 ? (h) & (unsigned long)-1 >> 2 : (h) | ~((unsigned long)-1 >> 2)))
1637 #else
1638 #define RB_ST2FIX(h) RB_LONG2FIX((long)(h))
1639 #endif
1640 #define ST2FIX(h) RB_ST2FIX(h)
1641
1642 #define RB_ALLOC_N(type,n) ((type*)ruby_xmalloc2((size_t)(n),sizeof(type)))
1643 #define RB_ALLOC(type) ((type*)ruby_xmalloc(sizeof(type)))
1644 #define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((size_t)(n),sizeof(type)))
1645 #define RB_ZALLOC(type) (RB_ZALLOC_N(type,1))
1646 #define RB_REALLOC_N(var,type,n) ((var)=(type*)ruby_xrealloc2((char*)(var),(size_t)(n),sizeof(type)))
1647
1648 #define ALLOC_N(type,n) RB_ALLOC_N(type,n)
1649 #define ALLOC(type) RB_ALLOC(type)
1650 #define ZALLOC_N(type,n) RB_ZALLOC_N(type,n)
1651 #define ZALLOC(type) RB_ZALLOC(type)
1652 #define REALLOC_N(var,type,n) RB_REALLOC_N(var,type,n)
1653
1654 #if GCC_VERSION_BEFORE(4,9,5)
1655 /* GCC 4.9.2 reportedly has this feature and is broken.
1656 * The function is not officially documented below.
1657 * Seems we should not use it.
1658 * https://gcc.gnu.org/onlinedocs/gcc-4.9.4/gcc/Other-Builtins.html#Other-Builtins */
1659 # undef HAVE_BUILTIN___BUILTIN_ALLOCA_WITH_ALIGN
1660 #endif
1661
1662 #if defined(HAVE_BUILTIN___BUILTIN_ALLOCA_WITH_ALIGN) && defined(RUBY_ALIGNOF)
1663 /* I don't know why but __builtin_alloca_with_align's second argument
1664 takes bits rather than bytes. */
1665 #define ALLOCA_N(type, n) \
1666 (type*)__builtin_alloca_with_align((sizeof(type)*(n)), \
1667 RUBY_ALIGNOF(type) * CHAR_BIT)
1668 #else
1669 #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
1670 #endif
1671
1672 void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2));
1673 void *rb_alloc_tmp_buffer_with_count(volatile VALUE *store, size_t len,size_t count) RUBY_ATTR_ALLOC_SIZE((2,3));
1674 void rb_free_tmp_buffer(volatile VALUE *store);
1675 NORETURN(void ruby_malloc_size_overflow(size_t, size_t));
1676 #if HAVE_LONG_LONG && SIZEOF_SIZE_T * 2 <= SIZEOF_LONG_LONG
1677 # define DSIZE_T unsigned LONG_LONG
1678 #elif defined(HAVE_INT128_T)
1679 # define DSIZE_T uint128_t
1680 #endif
1681 static inline int
rb_mul_size_overflow(size_t a,size_t b,size_t max,size_t * c)1682 rb_mul_size_overflow(size_t a, size_t b, size_t max, size_t *c)
1683 {
1684 #ifdef DSIZE_T
1685 # ifdef __GNUC__
1686 __extension__
1687 # endif
1688 DSIZE_T c2 = (DSIZE_T)a * (DSIZE_T)b;
1689 if (c2 > max) return 1;
1690 *c = (size_t)c2;
1691 #else
1692 if (b != 0 && a > max / b) return 1;
1693 *c = a * b;
1694 #endif
1695 return 0;
1696 }
1697 static inline void *
rb_alloc_tmp_buffer2(volatile VALUE * store,long count,size_t elsize)1698 rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize)
1699 {
1700 size_t cnt = (size_t)count;
1701 if (elsize == sizeof(VALUE)) {
1702 if (RB_UNLIKELY(cnt > LONG_MAX / sizeof(VALUE))) {
1703 ruby_malloc_size_overflow(cnt, elsize);
1704 }
1705 }
1706 else {
1707 size_t size, max = LONG_MAX - sizeof(VALUE) + 1;
1708 if (RB_UNLIKELY(rb_mul_size_overflow(cnt, elsize, max, &size))) {
1709 ruby_malloc_size_overflow(cnt, elsize);
1710 }
1711 cnt = (size + sizeof(VALUE) - 1) / sizeof(VALUE);
1712 }
1713 return rb_alloc_tmp_buffer_with_count(store, cnt * sizeof(VALUE), cnt);
1714 }
1715 /* allocates _n_ bytes temporary buffer and stores VALUE including it
1716 * in _v_. _n_ may be evaluated twice. */
1717 #ifdef C_ALLOCA
1718 # define RB_ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
1719 # define RB_ALLOCV_N(type, v, n) \
1720 rb_alloc_tmp_buffer2(&(v), (n), sizeof(type))
1721 #else
1722 # define RUBY_ALLOCV_LIMIT 1024
1723 # define RB_ALLOCV(v, n) ((n) < RUBY_ALLOCV_LIMIT ? \
1724 ((v) = 0, alloca(n)) : \
1725 rb_alloc_tmp_buffer(&(v), (n)))
1726 # define RB_ALLOCV_N(type, v, n) \
1727 ((type*)(((size_t)(n) < RUBY_ALLOCV_LIMIT / sizeof(type)) ? \
1728 ((v) = 0, alloca((size_t)(n) * sizeof(type))) : \
1729 rb_alloc_tmp_buffer2(&(v), (long)(n), sizeof(type))))
1730 #endif
1731 #define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v))
1732
1733 #define ALLOCV(v, n) RB_ALLOCV(v, n)
1734 #define ALLOCV_N(type, v, n) RB_ALLOCV_N(type, v, n)
1735 #define ALLOCV_END(v) RB_ALLOCV_END(v)
1736
1737 #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(size_t)(n))
1738 #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(size_t)(n))
1739 #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(size_t)(n))
1740 #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(size_t)(n))
1741
1742 void rb_obj_infect(VALUE victim, VALUE carrier);
1743
1744 typedef int ruby_glob_func(const char*,VALUE, void*);
1745 void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
1746 int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
1747 int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
1748
1749 VALUE rb_define_class(const char*,VALUE);
1750 VALUE rb_define_module(const char*);
1751 VALUE rb_define_class_under(VALUE, const char*, VALUE);
1752 VALUE rb_define_module_under(VALUE, const char*);
1753
1754 void rb_include_module(VALUE,VALUE);
1755 void rb_extend_object(VALUE,VALUE);
1756 void rb_prepend_module(VALUE,VALUE);
1757
1758 struct rb_global_variable;
1759
1760 typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
1761 typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1762 typedef void rb_gvar_marker_t(VALUE *var);
1763
1764 VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
1765 void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1766 void rb_gvar_undef_marker(VALUE *var);
1767
1768 VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
1769 void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1770 void rb_gvar_val_marker(VALUE *var);
1771
1772 VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
1773 void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1774 void rb_gvar_var_marker(VALUE *var);
1775
1776 NORETURN(void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar));
1777
1778 void rb_define_variable(const char*,VALUE*);
1779 void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1780 void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1781 void rb_define_readonly_variable(const char*,const VALUE*);
1782 void rb_define_const(VALUE,const char*,VALUE);
1783 void rb_define_global_const(const char*,VALUE);
1784
1785 #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
1786 void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
1787 void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
1788 void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
1789
1790 void rb_undef_method(VALUE,const char*);
1791 void rb_define_alias(VALUE,const char*,const char*);
1792 void rb_define_attr(VALUE,const char*,int,int);
1793
1794 void rb_global_variable(VALUE*);
1795 void rb_gc_register_mark_object(VALUE);
1796 void rb_gc_register_address(VALUE*);
1797 void rb_gc_unregister_address(VALUE*);
1798
1799 ID rb_intern(const char*);
1800 ID rb_intern2(const char*, long);
1801 ID rb_intern_str(VALUE str);
1802 const char *rb_id2name(ID);
1803 ID rb_check_id(volatile VALUE *);
1804 ID rb_to_id(VALUE);
1805 VALUE rb_id2str(ID);
1806 VALUE rb_sym2str(VALUE);
1807 VALUE rb_to_symbol(VALUE name);
1808 VALUE rb_check_symbol(volatile VALUE *namep);
1809
1810 #define RUBY_CONST_ID_CACHE_NB(result, str) \
1811 static ID rb_intern_id_cache; \
1812 if (!rb_intern_id_cache) \
1813 rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
1814 result rb_intern_id_cache;
1815 #define RUBY_CONST_ID_CACHE(result, str) \
1816 { \
1817 RUBY_CONST_ID_CACHE_NB(result, str) \
1818 }
1819 #define RUBY_CONST_ID(var, str) \
1820 do RUBY_CONST_ID_CACHE((var) =, (str)) while (0)
1821 #define CONST_ID_CACHE(result, str) RUBY_CONST_ID_CACHE(result, str)
1822 #define CONST_ID(var, str) RUBY_CONST_ID(var, str)
1823 #if defined(HAVE_BUILTIN___BUILTIN_CONSTANT_P) && defined(HAVE_STMT_AND_DECL_IN_EXPR)
1824 /* __builtin_constant_p and statement expression is available
1825 * since gcc-2.7.2.3 at least. */
1826 #define rb_intern(str) \
1827 (__builtin_constant_p(str) ? \
1828 __extension__ ({RUBY_CONST_ID_CACHE_NB((ID), (str))}) : \
1829 rb_intern(str))
1830 #define rb_intern_const(str) \
1831 (__builtin_constant_p(str) ? \
1832 __extension__ (rb_intern2((str), (long)strlen(str))) : \
1833 (rb_intern)(str))
1834
1835 # define rb_varargs_argc_check_runtime(argc, vargc) \
1836 (((argc) <= (vargc)) ? (argc) : \
1837 (rb_fatal("argc(%d) exceeds actual arguments(%d)", \
1838 argc, vargc), 0))
1839 # define rb_varargs_argc_valid_p(argc, vargc) \
1840 ((argc) == 0 ? (vargc) <= 1 : /* [ruby-core:85266] [Bug #14425] */ \
1841 (argc) == (vargc))
1842 # if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P)
1843 # if HAVE_ATTRIBUTE_ERRORFUNC
1844 ERRORFUNC((" argument length doesn't match"), int rb_varargs_bad_length(int,int));
1845 # else
1846 # define rb_varargs_bad_length(argc, vargc) \
1847 ((argc)/rb_varargs_argc_valid_p(argc, vargc))
1848 # endif
1849 # define rb_varargs_argc_check(argc, vargc) \
1850 __builtin_choose_expr(__builtin_constant_p(argc), \
1851 (rb_varargs_argc_valid_p(argc, vargc) ? (argc) : \
1852 rb_varargs_bad_length(argc, vargc)), \
1853 rb_varargs_argc_check_runtime(argc, vargc))
1854 # else
1855 # define rb_varargs_argc_check(argc, vargc) \
1856 rb_varargs_argc_check_runtime(argc, vargc)
1857 # endif
1858
1859 #else
1860 #define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
1861 #endif
1862
1863 const char *rb_class2name(VALUE);
1864 const char *rb_obj_classname(VALUE);
1865
1866 void rb_p(VALUE);
1867
1868 VALUE rb_eval_string(const char*);
1869 VALUE rb_eval_string_protect(const char*, int*);
1870 VALUE rb_eval_string_wrap(const char*, int*);
1871 VALUE rb_funcall(VALUE, ID, int, ...);
1872 VALUE rb_funcallv(VALUE, ID, int, const VALUE*);
1873 VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*);
1874 #define rb_funcall2 rb_funcallv
1875 #define rb_funcall3 rb_funcallv_public
1876 VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*);
1877 VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE);
1878 int rb_scan_args(int, const VALUE*, const char*, ...);
1879 VALUE rb_call_super(int, const VALUE*);
1880 VALUE rb_current_receiver(void);
1881 int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *);
1882 VALUE rb_extract_keywords(VALUE *orighash);
1883
1884 /* rb_scan_args() format allows ':' for optional hash */
1885 #define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1
1886
1887 VALUE rb_gv_set(const char*, VALUE);
1888 VALUE rb_gv_get(const char*);
1889 VALUE rb_iv_get(VALUE, const char*);
1890 VALUE rb_iv_set(VALUE, const char*, VALUE);
1891
1892 VALUE rb_equal(VALUE,VALUE);
1893
1894 VALUE *rb_ruby_verbose_ptr(void);
1895 VALUE *rb_ruby_debug_ptr(void);
1896 #define ruby_verbose (*rb_ruby_verbose_ptr())
1897 #define ruby_debug (*rb_ruby_debug_ptr())
1898
1899 /* for rb_readwrite_sys_fail first argument */
1900 enum rb_io_wait_readwrite {RB_IO_WAIT_READABLE, RB_IO_WAIT_WRITABLE};
1901 #define RB_IO_WAIT_READABLE RB_IO_WAIT_READABLE
1902 #define RB_IO_WAIT_WRITABLE RB_IO_WAIT_WRITABLE
1903
1904 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
1905 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
1906 COLDFUNC PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
1907 NORETURN(void rb_bug_errno(const char*, int));
1908 NORETURN(void rb_sys_fail(const char*));
1909 NORETURN(void rb_sys_fail_str(VALUE));
1910 NORETURN(void rb_mod_sys_fail(VALUE, const char*));
1911 NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE));
1912 NORETURN(void rb_readwrite_sys_fail(enum rb_io_wait_readwrite, const char*));
1913 NORETURN(void rb_iter_break(void));
1914 NORETURN(void rb_iter_break_value(VALUE));
1915 NORETURN(void rb_exit(int));
1916 NORETURN(void rb_notimplement(void));
1917 VALUE rb_syserr_new(int, const char *);
1918 VALUE rb_syserr_new_str(int n, VALUE arg);
1919 NORETURN(void rb_syserr_fail(int, const char*));
1920 NORETURN(void rb_syserr_fail_str(int, VALUE));
1921 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
1922 NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE));
1923 NORETURN(void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite, int, const char*));
1924
1925 /* reports if `-W' specified */
1926 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
1927 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
1928 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
1929 /* reports always */
1930 COLDFUNC PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
1931 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
1932
1933 #define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1
1934 #define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \
1935 VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg
1936 typedef VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg));
1937
1938 #if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT
1939 typedef rb_block_call_func *rb_block_call_func_t;
1940 #else
1941 typedef VALUE (*rb_block_call_func_t)(ANYARGS);
1942 #endif
1943
1944 VALUE rb_each(VALUE);
1945 VALUE rb_yield(VALUE);
1946 VALUE rb_yield_values(int n, ...);
1947 VALUE rb_yield_values2(int n, const VALUE *argv);
1948 VALUE rb_yield_splat(VALUE);
1949 VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */
1950 int rb_block_given_p(void);
1951 void rb_need_block(void);
1952 VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
1953 VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE);
1954 VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
1955 VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
1956 VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
1957 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
1958 VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
1959 NORETURN(void rb_throw(const char*,VALUE));
1960 NORETURN(void rb_throw_obj(VALUE,VALUE));
1961
1962 VALUE rb_require(const char*);
1963
1964 RUBY_EXTERN VALUE rb_mKernel;
1965 RUBY_EXTERN VALUE rb_mComparable;
1966 RUBY_EXTERN VALUE rb_mEnumerable;
1967 RUBY_EXTERN VALUE rb_mErrno;
1968 RUBY_EXTERN VALUE rb_mFileTest;
1969 RUBY_EXTERN VALUE rb_mGC;
1970 RUBY_EXTERN VALUE rb_mMath;
1971 RUBY_EXTERN VALUE rb_mProcess;
1972 RUBY_EXTERN VALUE rb_mWaitReadable;
1973 RUBY_EXTERN VALUE rb_mWaitWritable;
1974
1975 RUBY_EXTERN VALUE rb_cBasicObject;
1976 RUBY_EXTERN VALUE rb_cObject;
1977 RUBY_EXTERN VALUE rb_cArray;
1978 #ifndef RUBY_INTEGER_UNIFICATION
1979 RUBY_EXTERN VALUE rb_cBignum;
1980 #endif
1981 RUBY_EXTERN VALUE rb_cBinding;
1982 RUBY_EXTERN VALUE rb_cClass;
1983 RUBY_EXTERN VALUE rb_cCont;
1984 RUBY_EXTERN VALUE rb_cData;
1985 RUBY_EXTERN VALUE rb_cDir;
1986 RUBY_EXTERN VALUE rb_cEncoding;
1987 RUBY_EXTERN VALUE rb_cEnumerator;
1988 RUBY_EXTERN VALUE rb_cFalseClass;
1989 RUBY_EXTERN VALUE rb_cFile;
1990 #ifndef RUBY_INTEGER_UNIFICATION
1991 RUBY_EXTERN VALUE rb_cFixnum;
1992 #endif
1993 RUBY_EXTERN VALUE rb_cComplex;
1994 RUBY_EXTERN VALUE rb_cFloat;
1995 RUBY_EXTERN VALUE rb_cHash;
1996 RUBY_EXTERN VALUE rb_cIO;
1997 RUBY_EXTERN VALUE rb_cInteger;
1998 RUBY_EXTERN VALUE rb_cMatch;
1999 RUBY_EXTERN VALUE rb_cMethod;
2000 RUBY_EXTERN VALUE rb_cModule;
2001 RUBY_EXTERN VALUE rb_cNameErrorMesg;
2002 RUBY_EXTERN VALUE rb_cNilClass;
2003 RUBY_EXTERN VALUE rb_cNumeric;
2004 RUBY_EXTERN VALUE rb_cProc;
2005 RUBY_EXTERN VALUE rb_cRandom;
2006 RUBY_EXTERN VALUE rb_cRange;
2007 RUBY_EXTERN VALUE rb_cRational;
2008 RUBY_EXTERN VALUE rb_cRegexp;
2009 RUBY_EXTERN VALUE rb_cStat;
2010 RUBY_EXTERN VALUE rb_cString;
2011 RUBY_EXTERN VALUE rb_cStruct;
2012 RUBY_EXTERN VALUE rb_cSymbol;
2013 RUBY_EXTERN VALUE rb_cThread;
2014 RUBY_EXTERN VALUE rb_cTime;
2015 RUBY_EXTERN VALUE rb_cTrueClass;
2016 RUBY_EXTERN VALUE rb_cUnboundMethod;
2017
2018 RUBY_EXTERN VALUE rb_eException;
2019 RUBY_EXTERN VALUE rb_eStandardError;
2020 RUBY_EXTERN VALUE rb_eSystemExit;
2021 RUBY_EXTERN VALUE rb_eInterrupt;
2022 RUBY_EXTERN VALUE rb_eSignal;
2023 RUBY_EXTERN VALUE rb_eFatal;
2024 RUBY_EXTERN VALUE rb_eArgError;
2025 RUBY_EXTERN VALUE rb_eEOFError;
2026 RUBY_EXTERN VALUE rb_eIndexError;
2027 RUBY_EXTERN VALUE rb_eStopIteration;
2028 RUBY_EXTERN VALUE rb_eKeyError;
2029 RUBY_EXTERN VALUE rb_eRangeError;
2030 RUBY_EXTERN VALUE rb_eIOError;
2031 RUBY_EXTERN VALUE rb_eRuntimeError;
2032 RUBY_EXTERN VALUE rb_eFrozenError;
2033 RUBY_EXTERN VALUE rb_eSecurityError;
2034 RUBY_EXTERN VALUE rb_eSystemCallError;
2035 RUBY_EXTERN VALUE rb_eThreadError;
2036 RUBY_EXTERN VALUE rb_eTypeError;
2037 RUBY_EXTERN VALUE rb_eZeroDivError;
2038 RUBY_EXTERN VALUE rb_eNotImpError;
2039 RUBY_EXTERN VALUE rb_eNoMemError;
2040 RUBY_EXTERN VALUE rb_eNoMethodError;
2041 RUBY_EXTERN VALUE rb_eFloatDomainError;
2042 RUBY_EXTERN VALUE rb_eLocalJumpError;
2043 RUBY_EXTERN VALUE rb_eSysStackError;
2044 RUBY_EXTERN VALUE rb_eRegexpError;
2045 RUBY_EXTERN VALUE rb_eEncodingError;
2046 RUBY_EXTERN VALUE rb_eEncCompatError;
2047
2048 RUBY_EXTERN VALUE rb_eScriptError;
2049 RUBY_EXTERN VALUE rb_eNameError;
2050 RUBY_EXTERN VALUE rb_eSyntaxError;
2051 RUBY_EXTERN VALUE rb_eLoadError;
2052
2053 RUBY_EXTERN VALUE rb_eMathDomainError;
2054
2055 RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr;
2056
2057 static inline VALUE
rb_class_of(VALUE obj)2058 rb_class_of(VALUE obj)
2059 {
2060 if (RB_IMMEDIATE_P(obj)) {
2061 if (RB_FIXNUM_P(obj)) return rb_cInteger;
2062 if (RB_FLONUM_P(obj)) return rb_cFloat;
2063 if (obj == RUBY_Qtrue) return rb_cTrueClass;
2064 if (RB_STATIC_SYM_P(obj)) return rb_cSymbol;
2065 }
2066 else if (!RB_TEST(obj)) {
2067 if (obj == RUBY_Qnil) return rb_cNilClass;
2068 if (obj == RUBY_Qfalse) return rb_cFalseClass;
2069 }
2070 return RBASIC(obj)->klass;
2071 }
2072
2073 static inline int
rb_type(VALUE obj)2074 rb_type(VALUE obj)
2075 {
2076 if (RB_IMMEDIATE_P(obj)) {
2077 if (RB_FIXNUM_P(obj)) return RUBY_T_FIXNUM;
2078 if (RB_FLONUM_P(obj)) return RUBY_T_FLOAT;
2079 if (obj == RUBY_Qtrue) return RUBY_T_TRUE;
2080 if (RB_STATIC_SYM_P(obj)) return RUBY_T_SYMBOL;
2081 if (obj == RUBY_Qundef) return RUBY_T_UNDEF;
2082 }
2083 else if (!RB_TEST(obj)) {
2084 if (obj == RUBY_Qnil) return RUBY_T_NIL;
2085 if (obj == RUBY_Qfalse) return RUBY_T_FALSE;
2086 }
2087 return RB_BUILTIN_TYPE(obj);
2088 }
2089
2090 #ifdef __GNUC__
2091 #define rb_type_p(obj, type) \
2092 __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
2093 rb_type(obj) == (type))
2094 #else
2095 #define rb_type_p(obj, type) (rb_type(obj) == (type))
2096 #endif
2097
2098 #ifdef __GNUC__
2099 #define rb_special_const_p(obj) \
2100 __extension__ ({ \
2101 VALUE special_const_obj = (obj); \
2102 (int)(RB_SPECIAL_CONST_P(special_const_obj) ? RUBY_Qtrue : RUBY_Qfalse); \
2103 })
2104 #else
2105 static inline int
rb_special_const_p(VALUE obj)2106 rb_special_const_p(VALUE obj)
2107 {
2108 if (RB_SPECIAL_CONST_P(obj)) return (int)RUBY_Qtrue;
2109 return (int)RUBY_Qfalse;
2110 }
2111 #endif
2112
2113 #include "ruby/intern.h"
2114
2115 static inline void
rb_clone_setup(VALUE clone,VALUE obj)2116 rb_clone_setup(VALUE clone, VALUE obj)
2117 {
2118 rb_obj_setup(clone, rb_singleton_class_clone(obj),
2119 RBASIC(obj)->flags & ~(FL_PROMOTED0|FL_PROMOTED1|FL_FINALIZE));
2120 rb_singleton_class_attached(RBASIC_CLASS(clone), clone);
2121 if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(clone, obj);
2122 }
2123
2124 static inline void
rb_dup_setup(VALUE dup,VALUE obj)2125 rb_dup_setup(VALUE dup, VALUE obj)
2126 {
2127 rb_obj_setup(dup, rb_obj_class(obj), RB_FL_TEST_RAW(obj, RUBY_FL_DUPPED));
2128 if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(dup, obj);
2129 }
2130
2131 static inline long
rb_array_len(VALUE a)2132 rb_array_len(VALUE a)
2133 {
2134 return (RBASIC(a)->flags & RARRAY_EMBED_FLAG) ?
2135 RARRAY_EMBED_LEN(a) : RARRAY(a)->as.heap.len;
2136 }
2137
2138 #if defined(__fcc__) || defined(__fcc_version) || \
2139 defined(__FCC__) || defined(__FCC_VERSION)
2140 /* workaround for old version of Fujitsu C Compiler (fcc) */
2141 # define FIX_CONST_VALUE_PTR(x) ((const VALUE *)(x))
2142 #else
2143 # define FIX_CONST_VALUE_PTR(x) (x)
2144 #endif
2145
2146 /* internal function. do not use this function */
2147 static inline const VALUE *
rb_array_const_ptr_transient(VALUE a)2148 rb_array_const_ptr_transient(VALUE a)
2149 {
2150 return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ?
2151 RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr);
2152 }
2153
2154 /* internal function. do not use this function */
2155 static inline const VALUE *
rb_array_const_ptr(VALUE a)2156 rb_array_const_ptr(VALUE a)
2157 {
2158 #if USE_TRANSIENT_HEAP
2159 void rb_ary_detransient(VALUE a);
2160
2161 if (RARRAY_TRANSIENT_P(a)) {
2162 rb_ary_detransient(a);
2163 }
2164 #endif
2165 return rb_array_const_ptr_transient(a);
2166 }
2167
2168 /* internal function. do not use this function */
2169 static inline VALUE *
rb_array_ptr_use_start(VALUE a,int allow_transient)2170 rb_array_ptr_use_start(VALUE a, int allow_transient)
2171 {
2172 VALUE *rb_ary_ptr_use_start(VALUE ary);
2173
2174 #if USE_TRANSIENT_HEAP
2175 if (!allow_transient) {
2176 if (RARRAY_TRANSIENT_P(a)) {
2177 void rb_ary_detransient(VALUE a);
2178 rb_ary_detransient(a);
2179 }
2180 }
2181 #endif
2182
2183 return rb_ary_ptr_use_start(a);
2184 }
2185
2186 /* internal function. do not use this function */
2187 static inline void
rb_array_ptr_use_end(VALUE a,int allow_transient)2188 rb_array_ptr_use_end(VALUE a, int allow_transient)
2189 {
2190 void rb_ary_ptr_use_end(VALUE a);
2191 rb_ary_ptr_use_end(a);
2192 }
2193
2194 #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
2195 /* hook for external modules */
2196 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
2197 #endif
2198
2199 #define RUBY_VM 1 /* YARV */
2200 #define HAVE_NATIVETHREAD
2201 int ruby_native_thread_p(void);
2202
2203 /* traditional set_trace_func events */
2204 #define RUBY_EVENT_NONE 0x0000
2205 #define RUBY_EVENT_LINE 0x0001
2206 #define RUBY_EVENT_CLASS 0x0002
2207 #define RUBY_EVENT_END 0x0004
2208 #define RUBY_EVENT_CALL 0x0008
2209 #define RUBY_EVENT_RETURN 0x0010
2210 #define RUBY_EVENT_C_CALL 0x0020
2211 #define RUBY_EVENT_C_RETURN 0x0040
2212 #define RUBY_EVENT_RAISE 0x0080
2213 #define RUBY_EVENT_ALL 0x00ff
2214
2215 /* for TracePoint extended events */
2216 #define RUBY_EVENT_B_CALL 0x0100
2217 #define RUBY_EVENT_B_RETURN 0x0200
2218 #define RUBY_EVENT_THREAD_BEGIN 0x0400
2219 #define RUBY_EVENT_THREAD_END 0x0800
2220 #define RUBY_EVENT_FIBER_SWITCH 0x1000
2221 #define RUBY_EVENT_SCRIPT_COMPILED 0x2000
2222 #define RUBY_EVENT_TRACEPOINT_ALL 0xffff
2223
2224 /* special events */
2225 #define RUBY_EVENT_RESERVED_FOR_INTERNAL_USE 0x030000
2226
2227 /* internal events */
2228 #define RUBY_INTERNAL_EVENT_SWITCH 0x040000
2229 #define RUBY_EVENT_SWITCH 0x040000 /* obsolete name. this macro is for compatibility */
2230 /* 0x080000 */
2231 #define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000
2232 #define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000
2233 #define RUBY_INTERNAL_EVENT_GC_START 0x400000
2234 #define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000
2235 #define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000
2236 #define RUBY_INTERNAL_EVENT_GC_ENTER 0x2000000
2237 #define RUBY_INTERNAL_EVENT_GC_EXIT 0x4000000
2238 #define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x7f00000
2239 #define RUBY_INTERNAL_EVENT_MASK 0xffff0000
2240
2241 typedef uint32_t rb_event_flag_t;
2242 typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass);
2243
2244 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
2245 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data);
2246 int rb_remove_event_hook(rb_event_hook_func_t func);
2247
2248 /* locale insensitive functions */
2249
rb_isascii(int c)2250 static inline int rb_isascii(int c){ return '\0' <= c && c <= '\x7f'; }
rb_isupper(int c)2251 static inline int rb_isupper(int c){ return 'A' <= c && c <= 'Z'; }
rb_islower(int c)2252 static inline int rb_islower(int c){ return 'a' <= c && c <= 'z'; }
rb_isalpha(int c)2253 static inline int rb_isalpha(int c){ return rb_isupper(c) || rb_islower(c); }
rb_isdigit(int c)2254 static inline int rb_isdigit(int c){ return '0' <= c && c <= '9'; }
rb_isalnum(int c)2255 static inline int rb_isalnum(int c){ return rb_isalpha(c) || rb_isdigit(c); }
rb_isxdigit(int c)2256 static inline int rb_isxdigit(int c){ return rb_isdigit(c) || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'); }
rb_isblank(int c)2257 static inline int rb_isblank(int c){ return c == ' ' || c == '\t'; }
rb_isspace(int c)2258 static inline int rb_isspace(int c){ return c == ' ' || ('\t' <= c && c <= '\r'); }
rb_iscntrl(int c)2259 static inline int rb_iscntrl(int c){ return ('\0' <= c && c < ' ') || c == '\x7f'; }
rb_isprint(int c)2260 static inline int rb_isprint(int c){ return ' ' <= c && c <= '\x7e'; }
rb_ispunct(int c)2261 static inline int rb_ispunct(int c){ return !rb_isalnum(c); }
rb_isgraph(int c)2262 static inline int rb_isgraph(int c){ return '!' <= c && c <= '\x7e'; }
rb_tolower(int c)2263 static inline int rb_tolower(int c) { return rb_isupper(c) ? (c|0x20) : c; }
rb_toupper(int c)2264 static inline int rb_toupper(int c) { return rb_islower(c) ? (c&0x5f) : c; }
2265
2266 #ifndef ISPRINT
2267 #define ISASCII(c) rb_isascii(c)
2268 #define ISPRINT(c) rb_isprint(c)
2269 #define ISGRAPH(c) rb_isgraph(c)
2270 #define ISSPACE(c) rb_isspace(c)
2271 #define ISUPPER(c) rb_isupper(c)
2272 #define ISLOWER(c) rb_islower(c)
2273 #define ISALNUM(c) rb_isalnum(c)
2274 #define ISALPHA(c) rb_isalpha(c)
2275 #define ISDIGIT(c) rb_isdigit(c)
2276 #define ISXDIGIT(c) rb_isxdigit(c)
2277 #endif
2278 #define TOUPPER(c) rb_toupper(c)
2279 #define TOLOWER(c) rb_tolower(c)
2280
2281 int st_locale_insensitive_strcasecmp(const char *s1, const char *s2);
2282 int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n);
2283 #define STRCASECMP(s1, s2) (st_locale_insensitive_strcasecmp((s1), (s2)))
2284 #define STRNCASECMP(s1, s2, n) (st_locale_insensitive_strncasecmp((s1), (s2), (n)))
2285
2286 unsigned long ruby_strtoul(const char *str, char **endptr, int base);
2287 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
2288
2289 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
2290
2291 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
2292 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
2293
2294 #if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) && defined(HAVE_VA_ARGS_MACRO) && defined(__OPTIMIZE__)
2295 # define rb_scan_args(argc,argvp,fmt,...) \
2296 __builtin_choose_expr(__builtin_constant_p(fmt), \
2297 rb_scan_args0(argc,argvp,fmt,\
2298 (sizeof((VALUE*[]){__VA_ARGS__})/sizeof(VALUE*)), \
2299 ((VALUE*[]){__VA_ARGS__})), \
2300 rb_scan_args(argc,argvp,fmt,__VA_ARGS__))
2301 # if HAVE_ATTRIBUTE_ERRORFUNC
2302 ERRORFUNC(("bad scan arg format"), int rb_scan_args_bad_format(const char*));
2303 ERRORFUNC(("variable argument length doesn't match"), int rb_scan_args_length_mismatch(const char*,int));
2304 # else
2305 # define rb_scan_args_bad_format(fmt) 0
2306 # define rb_scan_args_length_mismatch(fmt, varc) 0
2307 # endif
2308
2309 # define rb_scan_args_isdigit(c) ((unsigned char)((c)-'0')<10)
2310
2311 #if !defined(__has_attribute)
2312 #define __has_attribute(x) 0
2313 #endif
2314 # if __has_attribute(diagnose_if)
2315 # define rb_scan_args_count_end(fmt, ofs, varc, vari) \
2316 (fmt[ofs] ? rb_scan_args_bad_format(fmt) : (vari))
2317 # else
2318 # define rb_scan_args_count_end(fmt, ofs, varc, vari) \
2319 ((vari)/(!fmt[ofs] || rb_scan_args_bad_format(fmt)))
2320 # endif
2321
2322 # define rb_scan_args_count_block(fmt, ofs, varc, vari) \
2323 (fmt[ofs]!='&' ? \
2324 rb_scan_args_count_end(fmt, ofs, varc, vari) : \
2325 rb_scan_args_count_end(fmt, ofs+1, varc, vari+1))
2326
2327 # define rb_scan_args_count_hash(fmt, ofs, varc, vari) \
2328 (fmt[ofs]!=':' ? \
2329 rb_scan_args_count_block(fmt, ofs, varc, vari) : \
2330 rb_scan_args_count_block(fmt, ofs+1, varc, vari+1))
2331
2332 # define rb_scan_args_count_trail(fmt, ofs, varc, vari) \
2333 (!rb_scan_args_isdigit(fmt[ofs]) ? \
2334 rb_scan_args_count_hash(fmt, ofs, varc, vari) : \
2335 rb_scan_args_count_hash(fmt, ofs+1, varc, vari+(fmt[ofs]-'0')))
2336
2337 # define rb_scan_args_count_var(fmt, ofs, varc, vari) \
2338 (fmt[ofs]!='*' ? \
2339 rb_scan_args_count_trail(fmt, ofs, varc, vari) : \
2340 rb_scan_args_count_trail(fmt, ofs+1, varc, vari+1))
2341
2342 # define rb_scan_args_count_opt(fmt, ofs, varc, vari) \
2343 (!rb_scan_args_isdigit(fmt[1]) ? \
2344 rb_scan_args_count_var(fmt, ofs, varc, vari) : \
2345 rb_scan_args_count_var(fmt, ofs+1, varc, vari+fmt[ofs]-'0'))
2346
2347 # define rb_scan_args_count(fmt, varc) \
2348 (!rb_scan_args_isdigit(fmt[0]) ? \
2349 rb_scan_args_count_var(fmt, 0, varc, 0) : \
2350 rb_scan_args_count_opt(fmt, 1, varc, fmt[0]-'0'))
2351
2352 # define rb_scan_args_verify_count(fmt, varc) \
2353 ((varc)/(rb_scan_args_count(fmt, varc) == (varc) || \
2354 rb_scan_args_length_mismatch(fmt, varc)))
2355
2356 # if defined(__has_attribute) && __has_attribute(diagnose_if)
2357 # define rb_scan_args_verify(fmt, varc) (void)0
2358 # elif defined(__GNUC__)
2359 # define rb_scan_args_verify(fmt, varc) \
2360 (void)__extension__ ({ \
2361 int verify; \
2362 _Pragma("GCC diagnostic push"); \
2363 _Pragma("GCC diagnostic ignored \"-Warray-bounds\""); \
2364 verify = rb_scan_args_verify_count(fmt, varc); \
2365 _Pragma("GCC diagnostic pop"); \
2366 verify; \
2367 })
2368 # else
2369 # define rb_scan_args_verify(fmt, varc) \
2370 (void)rb_scan_args_verify_count(fmt, varc)
2371 # endif
2372
2373 ALWAYS_INLINE(static int rb_scan_args_lead_p(const char *fmt));
2374 static inline int
rb_scan_args_lead_p(const char * fmt)2375 rb_scan_args_lead_p(const char *fmt)
2376 {
2377 return rb_scan_args_isdigit(fmt[0]);
2378 }
2379
2380 ALWAYS_INLINE(static int rb_scan_args_n_lead(const char *fmt));
2381 static inline int
rb_scan_args_n_lead(const char * fmt)2382 rb_scan_args_n_lead(const char *fmt)
2383 {
2384 return (rb_scan_args_lead_p(fmt) ? fmt[0]-'0' : 0);
2385 }
2386
2387 ALWAYS_INLINE(static int rb_scan_args_opt_p(const char *fmt));
2388 static inline int
rb_scan_args_opt_p(const char * fmt)2389 rb_scan_args_opt_p(const char *fmt)
2390 {
2391 return (rb_scan_args_lead_p(fmt) && rb_scan_args_isdigit(fmt[1]));
2392 }
2393
2394 ALWAYS_INLINE(static int rb_scan_args_n_opt(const char *fmt));
2395 static inline int
rb_scan_args_n_opt(const char * fmt)2396 rb_scan_args_n_opt(const char *fmt)
2397 {
2398 return (rb_scan_args_opt_p(fmt) ? fmt[1]-'0' : 0);
2399 }
2400
2401 ALWAYS_INLINE(static int rb_scan_args_var_idx(const char *fmt));
2402 static inline int
rb_scan_args_var_idx(const char * fmt)2403 rb_scan_args_var_idx(const char *fmt)
2404 {
2405 return (!rb_scan_args_lead_p(fmt) ? 0 : !rb_scan_args_isdigit(fmt[1]) ? 1 : 2);
2406 }
2407
2408 ALWAYS_INLINE(static int rb_scan_args_f_var(const char *fmt));
2409 static inline int
rb_scan_args_f_var(const char * fmt)2410 rb_scan_args_f_var(const char *fmt)
2411 {
2412 return (fmt[rb_scan_args_var_idx(fmt)]=='*');
2413 }
2414
2415 ALWAYS_INLINE(static int rb_scan_args_trail_idx(const char *fmt));
2416 static inline int
rb_scan_args_trail_idx(const char * fmt)2417 rb_scan_args_trail_idx(const char *fmt)
2418 {
2419 const int idx = rb_scan_args_var_idx(fmt);
2420 return idx+(fmt[idx]=='*');
2421 }
2422
2423 ALWAYS_INLINE(static int rb_scan_args_n_trail(const char *fmt));
2424 static inline int
rb_scan_args_n_trail(const char * fmt)2425 rb_scan_args_n_trail(const char *fmt)
2426 {
2427 const int idx = rb_scan_args_trail_idx(fmt);
2428 return (rb_scan_args_isdigit(fmt[idx]) ? fmt[idx]-'0' : 0);
2429 }
2430
2431 ALWAYS_INLINE(static int rb_scan_args_hash_idx(const char *fmt));
2432 static inline int
rb_scan_args_hash_idx(const char * fmt)2433 rb_scan_args_hash_idx(const char *fmt)
2434 {
2435 const int idx = rb_scan_args_trail_idx(fmt);
2436 return idx+rb_scan_args_isdigit(fmt[idx]);
2437 }
2438
2439 ALWAYS_INLINE(static int rb_scan_args_f_hash(const char *fmt));
2440 static inline int
rb_scan_args_f_hash(const char * fmt)2441 rb_scan_args_f_hash(const char *fmt)
2442 {
2443 return (fmt[rb_scan_args_hash_idx(fmt)]==':');
2444 }
2445
2446 ALWAYS_INLINE(static int rb_scan_args_block_idx(const char *fmt));
2447 static inline int
rb_scan_args_block_idx(const char * fmt)2448 rb_scan_args_block_idx(const char *fmt)
2449 {
2450 const int idx = rb_scan_args_hash_idx(fmt);
2451 return idx+(fmt[idx]==':');
2452 }
2453
2454 ALWAYS_INLINE(static int rb_scan_args_f_block(const char *fmt));
2455 static inline int
rb_scan_args_f_block(const char * fmt)2456 rb_scan_args_f_block(const char *fmt)
2457 {
2458 return (fmt[rb_scan_args_block_idx(fmt)]=='&');
2459 }
2460
2461 # if 0
2462 ALWAYS_INLINE(static int rb_scan_args_end_idx(const char *fmt));
2463 static inline int
2464 rb_scan_args_end_idx(const char *fmt)
2465 {
2466 const int idx = rb_scan_args_block_idx(fmt);
2467 return idx+(fmt[idx]=='&');
2468 }
2469 # endif
2470
2471 /* NOTE: Use `char *fmt` instead of `const char *fmt` because of clang's bug*/
2472 /* https://bugs.llvm.org/show_bug.cgi?id=38095 */
2473 # define rb_scan_args0(argc, argv, fmt, varc, vars) \
2474 rb_scan_args_set(argc, argv, \
2475 rb_scan_args_n_lead(fmt), \
2476 rb_scan_args_n_opt(fmt), \
2477 rb_scan_args_n_trail(fmt), \
2478 rb_scan_args_f_var(fmt), \
2479 rb_scan_args_f_hash(fmt), \
2480 rb_scan_args_f_block(fmt), \
2481 (rb_scan_args_verify(fmt, varc), vars), (char *)fmt, varc)
2482 ALWAYS_INLINE(static int
2483 rb_scan_args_set(int argc, const VALUE *argv,
2484 int n_lead, int n_opt, int n_trail,
2485 int f_var, int f_hash, int f_block,
2486 VALUE *vars[], char *fmt, int varc));
2487
2488 inline int
rb_scan_args_set(int argc,const VALUE * argv,int n_lead,int n_opt,int n_trail,int f_var,int f_hash,int f_block,VALUE * vars[],RB_UNUSED_VAR (char * fmt),RB_UNUSED_VAR (int varc))2489 rb_scan_args_set(int argc, const VALUE *argv,
2490 int n_lead, int n_opt, int n_trail,
2491 int f_var, int f_hash, int f_block,
2492 VALUE *vars[], RB_UNUSED_VAR(char *fmt), RB_UNUSED_VAR(int varc))
2493 # if defined(__has_attribute) && __has_attribute(diagnose_if)
2494 __attribute__((diagnose_if(rb_scan_args_count(fmt,varc)==0,"bad scan arg format","error")))
2495 __attribute__((diagnose_if(rb_scan_args_count(fmt,varc)!=varc,"variable argument length doesn't match","error")))
2496 # endif
2497 {
2498 int i, argi = 0, vari = 0, last_idx = -1;
2499 VALUE *var, hash = Qnil, last_hash = 0;
2500 const int n_mand = n_lead + n_trail;
2501
2502 /* capture an option hash - phase 1: pop */
2503 if (f_hash && n_mand < argc) {
2504 VALUE last = argv[argc - 1];
2505
2506 if (RB_NIL_P(last)) {
2507 /* nil is taken as an empty option hash only if it is not
2508 ambiguous; i.e. '*' is not specified and arguments are
2509 given more than sufficient */
2510 if (!f_var && n_mand + n_opt < argc)
2511 argc--;
2512 }
2513 else {
2514 hash = rb_check_hash_type(last);
2515 if (!RB_NIL_P(hash)) {
2516 VALUE opts = rb_extract_keywords(&hash);
2517 if (!(last_hash = hash)) argc--;
2518 else last_idx = argc - 1;
2519 hash = opts ? opts : Qnil;
2520 }
2521 }
2522 }
2523
2524 rb_check_arity(argc, n_mand, f_var ? UNLIMITED_ARGUMENTS : n_mand + n_opt);
2525
2526 /* capture leading mandatory arguments */
2527 for (i = n_lead; i-- > 0; ) {
2528 var = vars[vari++];
2529 if (var) *var = (argi == last_idx) ? last_hash : argv[argi];
2530 argi++;
2531 }
2532 /* capture optional arguments */
2533 for (i = n_opt; i-- > 0; ) {
2534 var = vars[vari++];
2535 if (argi < argc - n_trail) {
2536 if (var) *var = (argi == last_idx) ? last_hash : argv[argi];
2537 argi++;
2538 }
2539 else {
2540 if (var) *var = Qnil;
2541 }
2542 }
2543 /* capture variable length arguments */
2544 if (f_var) {
2545 int n_var = argc - argi - n_trail;
2546
2547 var = vars[vari++];
2548 if (0 < n_var) {
2549 if (var) {
2550 int f_last = (last_idx + 1 == argc - n_trail);
2551 *var = rb_ary_new4(n_var-f_last, &argv[argi]);
2552 if (f_last) rb_ary_push(*var, last_hash);
2553 }
2554 argi += n_var;
2555 }
2556 else {
2557 if (var) *var = rb_ary_new();
2558 }
2559 }
2560 /* capture trailing mandatory arguments */
2561 for (i = n_trail; i-- > 0; ) {
2562 var = vars[vari++];
2563 if (var) *var = (argi == last_idx) ? last_hash : argv[argi];
2564 argi++;
2565 }
2566 /* capture an option hash - phase 2: assignment */
2567 if (f_hash) {
2568 var = vars[vari++];
2569 if (var) *var = hash;
2570 }
2571 /* capture iterator block */
2572 if (f_block) {
2573 var = vars[vari++];
2574 if (rb_block_given_p()) {
2575 *var = rb_block_proc();
2576 }
2577 else {
2578 *var = Qnil;
2579 }
2580 }
2581
2582 return argc;
2583 }
2584 #endif
2585
2586 #if defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO) && defined(__OPTIMIZE__)
2587 # define rb_yield_values(argc, ...) \
2588 __extension__({ \
2589 const int rb_yield_values_argc = (argc); \
2590 const VALUE rb_yield_values_args[] = {__VA_ARGS__}; \
2591 const int rb_yield_values_nargs = \
2592 (int)(sizeof(rb_yield_values_args) / sizeof(VALUE)); \
2593 rb_yield_values2( \
2594 rb_varargs_argc_check(rb_yield_values_argc, rb_yield_values_nargs), \
2595 rb_yield_values_nargs ? rb_yield_values_args : NULL); \
2596 })
2597
2598 # define rb_funcall(recv, mid, argc, ...) \
2599 __extension__({ \
2600 const int rb_funcall_argc = (argc); \
2601 const VALUE rb_funcall_args[] = {__VA_ARGS__}; \
2602 const int rb_funcall_nargs = \
2603 (int)(sizeof(rb_funcall_args) / sizeof(VALUE)); \
2604 rb_funcallv(recv, mid, \
2605 rb_varargs_argc_check(rb_funcall_argc, rb_funcall_nargs), \
2606 rb_funcall_nargs ? rb_funcall_args : NULL); \
2607 })
2608 #endif
2609
2610 #ifndef RUBY_DONT_SUBST
2611 #include "ruby/subst.h"
2612 #endif
2613
2614 /**
2615 * @defgroup embed CRuby Embedding APIs
2616 * CRuby interpreter APIs. These are APIs to embed MRI interpreter into your
2617 * program.
2618 * These functions are not a part of Ruby extension library API.
2619 * Extension libraries of Ruby should not depend on these functions.
2620 * @{
2621 */
2622
2623 /** @defgroup ruby1 ruby(1) implementation
2624 * A part of the implementation of ruby(1) command.
2625 * Other programs that embed Ruby interpreter do not always need to use these
2626 * functions.
2627 * @{
2628 */
2629
2630 void ruby_sysinit(int *argc, char ***argv);
2631 void ruby_init(void);
2632 void* ruby_options(int argc, char** argv);
2633 int ruby_executable_node(void *n, int *status);
2634 int ruby_run_node(void *n);
2635
2636 /* version.c */
2637 void ruby_show_version(void);
2638 void ruby_show_copyright(void);
2639
2640
2641 /*! A convenience macro to call ruby_init_stack(). Must be placed just after
2642 * variable declarations */
2643 #define RUBY_INIT_STACK \
2644 VALUE variable_in_this_stack_frame; \
2645 ruby_init_stack(&variable_in_this_stack_frame);
2646 /*! @} */
2647
2648 #ifdef __ia64
2649 void ruby_init_stack(volatile VALUE*, void*);
2650 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
2651 #else
2652 void ruby_init_stack(volatile VALUE*);
2653 #endif
2654 #define Init_stack(addr) ruby_init_stack(addr)
2655
2656 int ruby_setup(void);
2657 int ruby_cleanup(volatile int);
2658
2659 void ruby_finalize(void);
2660 NORETURN(void ruby_stop(int));
2661
2662 void ruby_set_stack_size(size_t);
2663 int ruby_stack_check(void);
2664 size_t ruby_stack_length(VALUE**);
2665
2666 int ruby_exec_node(void *n);
2667
2668 void ruby_script(const char* name);
2669 void ruby_set_script_name(VALUE name);
2670
2671 void ruby_prog_init(void);
2672 void ruby_set_argv(int, char**);
2673 void *ruby_process_options(int, char**);
2674 void ruby_init_loadpath(void);
2675 void ruby_incpush(const char*);
2676 void ruby_sig_finalize(void);
2677
2678 /*! @} */
2679
2680 #if !defined RUBY_EXPORT && !defined RUBY_NO_OLD_COMPATIBILITY
2681 # include "ruby/backward.h"
2682 #endif
2683
2684 RUBY_SYMBOL_EXPORT_END
2685
2686 #if defined(__cplusplus)
2687 #if 0
2688 { /* satisfy cc-mode */
2689 #endif
2690 } /* extern "C" { */
2691 #endif
2692 #endif /* RUBY_RUBY_H */
2693