Ruby  2.1.10p492(2016-04-01revision54464)
ruby.h
Go to the documentation of this file.
1 /**********************************************************************
2 
3  ruby/ruby.h -
4 
5  $Author: usa $
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 #define NORETURN_STYLE_NEW 1
32 #ifndef NORETURN
33 # define NORETURN(x) x
34 #endif
35 #ifndef DEPRECATED
36 # define DEPRECATED(x) x
37 #endif
38 #ifndef NOINLINE
39 # define NOINLINE(x) x
40 #endif
41 #ifndef UNREACHABLE
42 # define UNREACHABLE /* unreachable */
43 #endif
44 
45 #ifdef __GNUC__
46 #define PRINTF_ARGS(decl, string_index, first_to_check) \
47  decl __attribute__((format(printf, string_index, first_to_check)))
48 #else
49 #define PRINTF_ARGS(decl, string_index, first_to_check) decl
50 #endif
51 
52 #ifdef HAVE_INTRINSICS_H
53 # include <intrinsics.h>
54 #endif
55 
56 #include <stdarg.h>
57 
59 
60 /* Make alloca work the best possible way. */
61 #ifdef __GNUC__
62 # ifndef atarist
63 # ifndef alloca
64 # define alloca __builtin_alloca
65 # endif
66 # endif /* atarist */
67 #else
68 # ifdef HAVE_ALLOCA_H
69 # include <alloca.h>
70 # else
71 # ifdef _AIX
72 #pragma alloca
73 # else
74 # ifndef alloca /* predefined by HP cc +Olibcalls */
75 void *alloca();
76 # endif
77 # endif /* AIX */
78 # endif /* HAVE_ALLOCA_H */
79 #endif /* __GNUC__ */
80 
81 #if defined HAVE_UINTPTR_T && 0
82 typedef uintptr_t VALUE;
83 typedef uintptr_t ID;
84 # define SIGNED_VALUE intptr_t
85 # define SIZEOF_VALUE SIZEOF_UINTPTR_T
86 # undef PRI_VALUE_PREFIX
87 #elif SIZEOF_LONG == SIZEOF_VOIDP
88 typedef unsigned long VALUE;
89 typedef unsigned long ID;
90 # define SIGNED_VALUE long
91 # define SIZEOF_VALUE SIZEOF_LONG
92 # define PRI_VALUE_PREFIX "l"
93 #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
94 typedef unsigned LONG_LONG VALUE;
95 typedef unsigned LONG_LONG ID;
96 # define SIGNED_VALUE LONG_LONG
97 # define LONG_LONG_VALUE 1
98 # define SIZEOF_VALUE SIZEOF_LONG_LONG
99 # define PRI_VALUE_PREFIX PRI_LL_PREFIX
100 #else
101 # error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
102 #endif
103 
104 typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1];
105 typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1];
106 #ifdef HAVE_LONG_LONG
107 typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1];
108 #endif
109 typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1];
110 
111 #ifndef PRI_INT_PREFIX
112 #define PRI_INT_PREFIX ""
113 #endif
114 #ifndef PRI_LONG_PREFIX
115 #define PRI_LONG_PREFIX "l"
116 #endif
117 
118 #if SIZEOF_LONG == 8
119 #define PRI_64_PREFIX PRI_LONG_PREFIX
120 #elif SIZEOF_LONG_LONG == 8
121 #define PRI_64_PREFIX PRI_LL_PREFIX
122 #endif
123 
124 #if defined PRIdPTR && !defined PRI_VALUE_PREFIX
125 #define PRIdVALUE PRIdPTR
126 #define PRIoVALUE PRIoPTR
127 #define PRIuVALUE PRIuPTR
128 #define PRIxVALUE PRIxPTR
129 #define PRIXVALUE PRIXPTR
130 #define PRIsVALUE PRIiPTR
131 #else
132 #define PRIdVALUE PRI_VALUE_PREFIX"d"
133 #define PRIoVALUE PRI_VALUE_PREFIX"o"
134 #define PRIuVALUE PRI_VALUE_PREFIX"u"
135 #define PRIxVALUE PRI_VALUE_PREFIX"x"
136 #define PRIXVALUE PRI_VALUE_PREFIX"X"
137 #define PRIsVALUE PRI_VALUE_PREFIX"i"
138 #endif
139 #ifndef PRI_VALUE_PREFIX
140 # define PRI_VALUE_PREFIX ""
141 #endif
142 
143 #ifndef PRI_TIMET_PREFIX
144 # if SIZEOF_TIME_T == SIZEOF_INT
145 # define PRI_TIMET_PREFIX
146 # elif SIZEOF_TIME_T == SIZEOF_LONG
147 # define PRI_TIMET_PREFIX "l"
148 # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
149 # define PRI_TIMET_PREFIX PRI_LL_PREFIX
150 # endif
151 #endif
152 
153 #if defined PRI_PTRDIFF_PREFIX
154 #elif SIZEOF_PTRDIFF_T == SIZEOF_INT
155 # define PRI_PTRDIFF_PREFIX ""
156 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
157 # define PRI_PTRDIFF_PREFIX "l"
158 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
159 # define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX
160 #endif
161 #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
162 #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
163 #define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
164 #define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
165 #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
166 #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
167 
168 #if defined PRI_SIZE_PREFIX
169 #elif SIZEOF_SIZE_T == SIZEOF_INT
170 # define PRI_SIZE_PREFIX ""
171 #elif SIZEOF_SIZE_T == SIZEOF_LONG
172 # define PRI_SIZE_PREFIX "l"
173 #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG
174 # define PRI_SIZE_PREFIX PRI_LL_PREFIX
175 #endif
176 #define PRIdSIZE PRI_SIZE_PREFIX"d"
177 #define PRIiSIZE PRI_SIZE_PREFIX"i"
178 #define PRIoSIZE PRI_SIZE_PREFIX"o"
179 #define PRIuSIZE PRI_SIZE_PREFIX"u"
180 #define PRIxSIZE PRI_SIZE_PREFIX"x"
181 #define PRIXSIZE PRI_SIZE_PREFIX"X"
182 
183 #ifdef __STDC__
184 # include <limits.h>
185 #else
186 # ifndef LONG_MAX
187 # ifdef HAVE_LIMITS_H
188 # include <limits.h>
189 # else
190  /* assuming 32bit(2's complement) long */
191 # define LONG_MAX 2147483647
192 # endif
193 # endif
194 # ifndef LONG_MIN
195 # define LONG_MIN (-LONG_MAX-1)
196 # endif
197 # ifndef CHAR_BIT
198 # define CHAR_BIT 8
199 # endif
200 #endif
201 
202 #ifdef HAVE_LONG_LONG
203 # ifndef LLONG_MAX
204 # ifdef LONG_LONG_MAX
205 # define LLONG_MAX LONG_LONG_MAX
206 # else
207 # ifdef _I64_MAX
208 # define LLONG_MAX _I64_MAX
209 # else
210  /* assuming 64bit(2's complement) long long */
211 # define LLONG_MAX 9223372036854775807LL
212 # endif
213 # endif
214 # endif
215 # ifndef LLONG_MIN
216 # ifdef LONG_LONG_MIN
217 # define LLONG_MIN LONG_LONG_MIN
218 # else
219 # ifdef _I64_MIN
220 # define LLONG_MIN _I64_MIN
221 # else
222 # define LLONG_MIN (-LLONG_MAX-1)
223 # endif
224 # endif
225 # endif
226 #endif
227 
228 #define FIXNUM_MAX (LONG_MAX>>1)
229 #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
230 
231 #define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG))
232 #define LONG2FIX(i) INT2FIX(i)
233 #define rb_fix_new(v) INT2FIX(v)
235 
236 #define rb_int_new(v) rb_int2inum(v)
238 
239 #define rb_uint_new(v) rb_uint2inum(v)
240 
241 #ifdef HAVE_LONG_LONG
242 VALUE rb_ll2inum(LONG_LONG);
243 #define LL2NUM(v) rb_ll2inum(v)
244 VALUE rb_ull2inum(unsigned LONG_LONG);
245 #define ULL2NUM(v) rb_ull2inum(v)
246 #endif
247 
248 #ifndef OFFT2NUM
249 #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
250 # define OFFT2NUM(v) LL2NUM(v)
251 #elif SIZEOF_OFF_T == SIZEOF_LONG
252 # define OFFT2NUM(v) LONG2NUM(v)
253 #else
254 # define OFFT2NUM(v) INT2NUM(v)
255 #endif
256 #endif
257 
258 #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
259 # define SIZET2NUM(v) ULL2NUM(v)
260 # define SSIZET2NUM(v) LL2NUM(v)
261 #elif SIZEOF_SIZE_T == SIZEOF_LONG
262 # define SIZET2NUM(v) ULONG2NUM(v)
263 # define SSIZET2NUM(v) LONG2NUM(v)
264 #else
265 # define SIZET2NUM(v) UINT2NUM(v)
266 # define SSIZET2NUM(v) INT2NUM(v)
267 #endif
268 
269 #ifndef SIZE_MAX
270 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
271 # define SIZE_MAX ULLONG_MAX
272 # define SIZE_MIN ULLONG_MIN
273 # elif SIZEOF_SIZE_T == SIZEOF_LONG
274 # define SIZE_MAX ULONG_MAX
275 # define SIZE_MIN ULONG_MIN
276 # elif SIZEOF_SIZE_T == SIZEOF_INT
277 # define SIZE_MAX UINT_MAX
278 # define SIZE_MIN UINT_MIN
279 # else
280 # define SIZE_MAX USHRT_MAX
281 # define SIZE_MIN USHRT_MIN
282 # endif
283 #endif
284 
285 #ifndef SSIZE_MAX
286 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
287 # define SSIZE_MAX LLONG_MAX
288 # define SSIZE_MIN LLONG_MIN
289 # elif SIZEOF_SIZE_T == SIZEOF_LONG
290 # define SSIZE_MAX LONG_MAX
291 # define SSIZE_MIN LONG_MIN
292 # elif SIZEOF_SIZE_T == SIZEOF_INT
293 # define SSIZE_MAX INT_MAX
294 # define SSIZE_MIN INT_MIN
295 # else
296 # define SSIZE_MAX SHRT_MAX
297 # define SSIZE_MIN SHRT_MIN
298 # endif
299 #endif
300 
301 #if SIZEOF_INT < SIZEOF_VALUE
302 NORETURN(void rb_out_of_int(SIGNED_VALUE num));
303 #endif
304 
305 #if SIZEOF_INT < SIZEOF_LONG
306 static inline int
307 rb_long2int_inline(long n)
308 {
309  int i = (int)n;
310  if ((long)i != n)
311  rb_out_of_int(n);
312 
313  return i;
314 }
315 #define rb_long2int(n) rb_long2int_inline(n)
316 #else
317 #define rb_long2int(n) ((int)(n))
318 #endif
319 
320 #ifndef PIDT2NUM
321 #define PIDT2NUM(v) LONG2NUM(v)
322 #endif
323 #ifndef NUM2PIDT
324 #define NUM2PIDT(v) NUM2LONG(v)
325 #endif
326 #ifndef UIDT2NUM
327 #define UIDT2NUM(v) LONG2NUM(v)
328 #endif
329 #ifndef NUM2UIDT
330 #define NUM2UIDT(v) NUM2LONG(v)
331 #endif
332 #ifndef GIDT2NUM
333 #define GIDT2NUM(v) LONG2NUM(v)
334 #endif
335 #ifndef NUM2GIDT
336 #define NUM2GIDT(v) NUM2LONG(v)
337 #endif
338 #ifndef NUM2MODET
339 #define NUM2MODET(v) NUM2INT(v)
340 #endif
341 #ifndef MODET2NUM
342 #define MODET2NUM(v) INT2NUM(v)
343 #endif
344 
345 #define FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1))
346 #define FIX2ULONG(x) ((unsigned long)FIX2LONG(x))
347 #define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG)
348 #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
349 #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
350 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
351 
352 #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
353 
354 #define SYMBOL_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG)
355 #define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
356 #define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT)
357 
358 #ifndef USE_FLONUM
359 #if SIZEOF_VALUE >= SIZEOF_DOUBLE
360 #define USE_FLONUM 1
361 #else
362 #define USE_FLONUM 0
363 #endif
364 #endif
365 
366 #if USE_FLONUM
367 #define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG)
368 #else
369 #define FLONUM_P(x) 0
370 #endif
371 
372 /* Module#methods, #singleton_methods and so on return Symbols */
373 #define USE_SYMBOL_AS_METHOD_NAME 1
374 
375 /*
376 !USE_FLONUM
377 -------------------------
378 ...xxxx xxx1 Fixnum
379 ...0000 1110 Symbol
380 ...0000 0000 Qfalse
381 ...0000 0010 Qtrue
382 ...0000 0100 Qnil
383 ...0000 0110 Qundef
384 
385 USE_FLONUM
386 -------------------------
387 ...xxxx xxx1 Fixnum
388 ...xxxx xx10 Flonum
389 ...0000 1100 Symbol
390 ...0000 0000 Qfalse 0x00 = 0
391 ...0000 1000 Qnil 0x08 = 8
392 ...0001 0100 Qtrue 0x14 = 20
393 ...0011 0100 Qundef 0x34 = 52
394  */
395 
396 /* special constants - i.e. non-zero and non-fixnum constants */
398 #if USE_FLONUM
399  RUBY_Qfalse = 0x00,
400  RUBY_Qtrue = 0x14,
401  RUBY_Qnil = 0x08,
402  RUBY_Qundef = 0x34,
403 
410 #else
411  RUBY_Qfalse = 0,
412  RUBY_Qtrue = 2,
413  RUBY_Qnil = 4,
414  RUBY_Qundef = 6,
415 
416  RUBY_IMMEDIATE_MASK = 0x03,
417  RUBY_FIXNUM_FLAG = 0x01,
418  RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */
419  RUBY_FLONUM_FLAG = 0x02,
420  RUBY_SYMBOL_FLAG = 0x0e,
422 #endif
423 };
424 
425 #define Qfalse ((VALUE)RUBY_Qfalse)
426 #define Qtrue ((VALUE)RUBY_Qtrue)
427 #define Qnil ((VALUE)RUBY_Qnil)
428 #define Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */
429 #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
430 #define FIXNUM_FLAG RUBY_FIXNUM_FLAG
431 #if USE_FLONUM
432 #define FLONUM_MASK RUBY_FLONUM_MASK
433 #define FLONUM_FLAG RUBY_FLONUM_FLAG
434 #endif
435 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
436 
437 #define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0)
438 #define NIL_P(v) !((VALUE)(v) != Qnil)
439 
440 #define CLASS_OF(v) rb_class_of((VALUE)(v))
441 
443  RUBY_T_NONE = 0x00,
444 
446  RUBY_T_CLASS = 0x02,
448  RUBY_T_FLOAT = 0x04,
451  RUBY_T_ARRAY = 0x07,
452  RUBY_T_HASH = 0x08,
455  RUBY_T_FILE = 0x0b,
456  RUBY_T_DATA = 0x0c,
457  RUBY_T_MATCH = 0x0d,
460 
461  RUBY_T_NIL = 0x11,
462  RUBY_T_TRUE = 0x12,
463  RUBY_T_FALSE = 0x13,
466 
467  RUBY_T_UNDEF = 0x1b,
468  RUBY_T_NODE = 0x1c,
471 
472  RUBY_T_MASK = 0x1f
473 };
474 
475 #define T_NONE RUBY_T_NONE
476 #define T_NIL RUBY_T_NIL
477 #define T_OBJECT RUBY_T_OBJECT
478 #define T_CLASS RUBY_T_CLASS
479 #define T_ICLASS RUBY_T_ICLASS
480 #define T_MODULE RUBY_T_MODULE
481 #define T_FLOAT RUBY_T_FLOAT
482 #define T_STRING RUBY_T_STRING
483 #define T_REGEXP RUBY_T_REGEXP
484 #define T_ARRAY RUBY_T_ARRAY
485 #define T_HASH RUBY_T_HASH
486 #define T_STRUCT RUBY_T_STRUCT
487 #define T_BIGNUM RUBY_T_BIGNUM
488 #define T_FILE RUBY_T_FILE
489 #define T_FIXNUM RUBY_T_FIXNUM
490 #define T_TRUE RUBY_T_TRUE
491 #define T_FALSE RUBY_T_FALSE
492 #define T_DATA RUBY_T_DATA
493 #define T_MATCH RUBY_T_MATCH
494 #define T_SYMBOL RUBY_T_SYMBOL
495 #define T_RATIONAL RUBY_T_RATIONAL
496 #define T_COMPLEX RUBY_T_COMPLEX
497 #define T_UNDEF RUBY_T_UNDEF
498 #define T_NODE RUBY_T_NODE
499 #define T_ZOMBIE RUBY_T_ZOMBIE
500 #define T_MASK RUBY_T_MASK
501 
502 #define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK)
503 
504 static inline int rb_type(VALUE obj);
505 #define TYPE(x) rb_type((VALUE)(x))
506 
507 /* RB_GC_GUARD_PTR() is an intermediate macro, and has no effect by
508  * itself. don't use it directly */
509 #ifdef __GNUC__
510 #define RB_GC_GUARD_PTR(ptr) \
511  __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
512 #else
513 #ifdef _MSC_VER
514 #pragma optimize("", off)
515 static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
516 #pragma optimize("", on)
517 #else
518 volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr);
519 #define HAVE_RB_GC_GUARDED_PTR 1
520 #endif
521 #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
522 #endif
523 #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
524 
525 #ifdef __GNUC__
526 #define RB_UNUSED_VAR(x) x __attribute__ ((unused))
527 #else
528 #define RB_UNUSED_VAR(x) x
529 #endif
530 
531 void rb_check_type(VALUE,int);
532 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
533 
535 VALUE rb_string_value(volatile VALUE*);
536 char *rb_string_value_ptr(volatile VALUE*);
537 char *rb_string_value_cstr(volatile VALUE*);
538 
539 #define StringValue(v) rb_string_value(&(v))
540 #define StringValuePtr(v) rb_string_value_ptr(&(v))
541 #define StringValueCStr(v) rb_string_value_cstr(&(v))
542 
545 #define SafeStringValue(v) do {\
546  StringValue(v);\
547  rb_check_safe_obj(v);\
548 } while (0)
549 /* obsolete macro - use SafeStringValue(v) */
550 #define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
551 
553 #define ExportStringValue(v) do {\
554  SafeStringValue(v);\
555  (v) = rb_str_export(v);\
556 } while (0)
558 
560 #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
561 
563 #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
564 
565 #define RUBY_SAFE_LEVEL_MAX 3
566 void rb_secure(int);
567 int rb_safe_level(void);
568 void rb_set_safe_level(int);
569 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
570 int ruby_safe_level_4_error(void) __attribute__((error("$SAFE=4 is obsolete")));
571 int ruby_safe_level_4_warning(void) __attribute__((warning("$SAFE=4 is obsolete")));
572 # ifdef RUBY_EXPORT
573 # define ruby_safe_level_4_warning() ruby_safe_level_4_error()
574 # endif
575 #define RUBY_SAFE_LEVEL_INVALID_P(level) \
576  __extension__(__builtin_constant_p(level) && \
577  ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)))
578 #define RUBY_SAFE_LEVEL_CHECK(level, type) \
579  (RUBY_SAFE_LEVEL_INVALID_P(level) ? ruby_safe_level_4_##type() : (level))
580 #define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning))
581 #define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error))
582 #endif
583 void rb_set_safe_level_force(int);
584 void rb_secure_update(VALUE);
585 NORETURN(void rb_insecure_operation(void));
586 
587 VALUE rb_errinfo(void);
588 void rb_set_errinfo(VALUE);
589 
592 static inline long
594 {
595  if (FIXNUM_P(x))
596  return FIX2LONG(x);
597  else
598  return (long)rb_num2long(x);
599 }
600 #define NUM2LONG(x) rb_num2long_inline(x)
601 static inline unsigned long
603 {
604  if (FIXNUM_P(x))
605  return (unsigned long)FIX2LONG(x);
606  else
607  return (unsigned long)rb_num2ulong(x);
608 }
609 #define NUM2ULONG(x) rb_num2ulong_inline(x)
610 #if SIZEOF_INT < SIZEOF_LONG
611 long rb_num2int(VALUE);
612 long rb_fix2int(VALUE);
613 #define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
614 
615 static inline int
616 rb_num2int_inline(VALUE x)
617 {
618  if (FIXNUM_P(x))
619  return FIX2INT(x);
620  else
621  return (int)rb_num2int(x);
622 }
623 #define NUM2INT(x) rb_num2int_inline(x)
624 
625 unsigned long rb_num2uint(VALUE);
626 #define NUM2UINT(x) ((unsigned int)rb_num2uint(x))
627 unsigned long rb_fix2uint(VALUE);
628 #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
629 #else /* SIZEOF_INT < SIZEOF_LONG */
630 #define NUM2INT(x) ((int)NUM2LONG(x))
631 #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
632 #define FIX2INT(x) ((int)FIX2LONG(x))
633 #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
634 #endif /* SIZEOF_INT < SIZEOF_LONG */
635 
636 short rb_num2short(VALUE);
637 unsigned short rb_num2ushort(VALUE);
638 short rb_fix2short(VALUE);
639 unsigned short rb_fix2ushort(VALUE);
640 #define FIX2SHORT(x) (rb_fix2short((VALUE)(x)))
641 static inline short
643 {
644  if (FIXNUM_P(x))
645  return FIX2SHORT(x);
646  else
647  return rb_num2short(x);
648 }
649 
650 #define NUM2SHORT(x) rb_num2short_inline(x)
651 #define NUM2USHORT(x) rb_num2ushort(x)
652 
653 #ifdef HAVE_LONG_LONG
654 LONG_LONG rb_num2ll(VALUE);
655 unsigned LONG_LONG rb_num2ull(VALUE);
656 static inline LONG_LONG
657 rb_num2ll_inline(VALUE x)
658 {
659  if (FIXNUM_P(x))
660  return FIX2LONG(x);
661  else
662  return rb_num2ll(x);
663 }
664 # define NUM2LL(x) rb_num2ll_inline(x)
665 # define NUM2ULL(x) rb_num2ull(x)
666 #endif
667 
668 #if !defined(NUM2OFFT)
669 # if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
670 # define NUM2OFFT(x) ((off_t)NUM2LL(x))
671 # else
672 # define NUM2OFFT(x) NUM2LONG(x)
673 # endif
674 #endif
675 
676 #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
677 # define NUM2SIZET(x) ((size_t)NUM2ULL(x))
678 # define NUM2SSIZET(x) ((ssize_t)NUM2LL(x))
679 #else
680 # define NUM2SIZET(x) NUM2ULONG(x)
681 # define NUM2SSIZET(x) NUM2LONG(x)
682 #endif
683 
684 double rb_num2dbl(VALUE);
685 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
686 
689 
690 VALUE rb_newobj(void);
693 #define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
694 #define NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags)
695 #define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */
696 #define CLONESETUP(clone,obj) do {\
697  OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\
698  rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\
699  if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\
700 } while (0)
701 #define DUPSETUP(dup,obj) do {\
702  OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT)); \
703  if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\
704 } while (0)
705 
706 #ifndef USE_RGENGC
707 #define USE_RGENGC 1
708 #endif
709 
710 #ifndef RGENGC_WB_PROTECTED_ARRAY
711 #define RGENGC_WB_PROTECTED_ARRAY 1
712 #endif
713 #ifndef RGENGC_WB_PROTECTED_HASH
714 #define RGENGC_WB_PROTECTED_HASH 1
715 #endif
716 #ifndef RGENGC_WB_PROTECTED_STRUCT
717 #define RGENGC_WB_PROTECTED_STRUCT 1
718 #endif
719 #ifndef RGENGC_WB_PROTECTED_STRING
720 #define RGENGC_WB_PROTECTED_STRING 1
721 #endif
722 #ifndef RGENGC_WB_PROTECTED_OBJECT
723 #define RGENGC_WB_PROTECTED_OBJECT 1
724 #endif
725 #ifndef RGENGC_WB_PROTECTED_REGEXP
726 #define RGENGC_WB_PROTECTED_REGEXP 1
727 #endif
728 #ifndef RGENGC_WB_PROTECTED_CLASS
729 #define RGENGC_WB_PROTECTED_CLASS 1
730 #endif
731 #ifndef RGENGC_WB_PROTECTED_FLOAT
732 #define RGENGC_WB_PROTECTED_FLOAT 1
733 #endif
734 #ifndef RGENGC_WB_PROTECTED_COMPLEX
735 #define RGENGC_WB_PROTECTED_COMPLEX 1
736 #endif
737 #ifndef RGENGC_WB_PROTECTED_RATIONAL
738 #define RGENGC_WB_PROTECTED_RATIONAL 1
739 #endif
740 #ifndef RGENGC_WB_PROTECTED_BIGNUM
741 #define RGENGC_WB_PROTECTED_BIGNUM 1
742 #endif
743 #ifndef RGENGC_WB_PROTECTED_NODE_CREF
744 #define RGENGC_WB_PROTECTED_NODE_CREF 1
745 #endif
746 
747 struct RBasic {
748  VALUE flags;
749  const VALUE klass;
750 }
751 #ifdef __GNUC__
752  __attribute__((aligned(sizeof(VALUE))))
753 #endif
754 ;
755 
757 VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change klass information */
758 
759 #define RBASIC_CLASS(obj) (RBASIC(obj)->klass)
760 
761 #define ROBJECT_EMBED_LEN_MAX 3
762 struct RObject {
763  struct RBasic basic;
764  union {
765  struct {
766  long numiv;
767  VALUE *ivptr;
768  struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
769  } heap;
771  } as;
772 };
773 #define ROBJECT_EMBED FL_USER1
774 #define ROBJECT_NUMIV(o) \
775  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
776  ROBJECT_EMBED_LEN_MAX : \
777  ROBJECT(o)->as.heap.numiv)
778 #define ROBJECT_IVPTR(o) \
779  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
780  ROBJECT(o)->as.ary : \
781  ROBJECT(o)->as.heap.ivptr)
782 #define ROBJECT_IV_INDEX_TBL(o) \
783  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
784  RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
785  ROBJECT(o)->as.heap.iv_index_tbl)
786 
789 
790 struct RClass {
791  struct RBasic basic;
792  VALUE super;
795 };
796 #define RCLASS_SUPER(c) rb_class_get_superclass(c)
797 #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
798 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
799 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
800 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
801 #define RMODULE_IS_OVERLAID FL_USER2
802 #define RMODULE_IS_REFINEMENT FL_USER3
803 #define RMODULE_INCLUDED_INTO_REFINEMENT FL_USER4
804 
805 struct RFloat {
806  struct RBasic basic;
807  double float_value;
808 };
809 
810 double rb_float_value(VALUE);
811 VALUE rb_float_new(double);
813 
814 #define RFLOAT_VALUE(v) rb_float_value(v)
815 #define DBL2NUM(dbl) rb_float_new(dbl)
816 
817 #define ELTS_SHARED FL_USER2
818 
819 #define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1))
820 struct RString {
821  struct RBasic basic;
822  union {
823  struct {
824  long len;
825  char *ptr;
826  union {
827  long capa;
828  VALUE shared;
829  } aux;
830  } heap;
831  char ary[RSTRING_EMBED_LEN_MAX + 1];
832  } as;
833 };
834 #define RSTRING_NOEMBED FL_USER1
835 #define RSTRING_FSTR FL_USER17
836 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6)
837 #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
838 #define RSTRING_EMBED_LEN(str) \
839  (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
840  (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
841 #define RSTRING_LEN(str) \
842  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
843  RSTRING_EMBED_LEN(str) : \
844  RSTRING(str)->as.heap.len)
845 #define RSTRING_PTR(str) \
846  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
847  RSTRING(str)->as.ary : \
848  RSTRING(str)->as.heap.ptr)
849 #define RSTRING_END(str) \
850  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
851  (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
852  (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
853 #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
854 #define RSTRING_GETMEM(str, ptrvar, lenvar) \
855  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
856  ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
857  ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
858 
859 #define RARRAY_EMBED_LEN_MAX 3
860 struct RArray {
861  struct RBasic basic;
862  union {
863  struct {
864  long len;
865  union {
866  long capa;
867  VALUE shared;
868  } aux;
869  const VALUE *ptr;
870  } heap;
872  } as;
873 };
874 #define RARRAY_EMBED_FLAG FL_USER1
875 /* FL_USER2 is for ELTS_SHARED */
876 #define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3)
877 #define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3)
878 #define RARRAY_LEN(a) \
879  ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
880  (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
881  (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
882  RARRAY(a)->as.heap.len)
883 
884 #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
885 
886 #define RARRAY_CONST_PTR(a) \
887  ((const VALUE *)((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
888  RARRAY(a)->as.ary : \
889  RARRAY(a)->as.heap.ptr))
890 
891 #define RARRAY_PTR_USE_START(a) ((VALUE *)RARRAY_CONST_PTR(a))
892 #define RARRAY_PTR_USE_END(a) /* */
893 
894 #define RARRAY_PTR_USE(ary, ptr_name, expr) do { \
895  const VALUE _ary = (ary); \
896  VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); \
897  expr; \
898  RARRAY_PTR_USE_END(_ary); \
899 } while (0)
900 
901 #define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i])
902 #define RARRAY_ASET(a, i, v) do { \
903  const VALUE _ary_ = (a); \
904  RB_OBJ_WRITE(_ary_, &RARRAY_CONST_PTR(_ary_)[i], (v)); \
905 } while (0)
906 
907 #define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RGENGC_WB_PROTECTED_ARRAY ? OBJ_WB_UNPROTECT((VALUE)a) : ((VALUE)a)))
908 
909 struct RRegexp {
910  struct RBasic basic;
911  struct re_pattern_buffer *ptr;
912  const VALUE src;
913  unsigned long usecnt;
914 };
915 #define RREGEXP_SRC(r) RREGEXP(r)->src
916 #define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
917 #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
918 #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
919 
920 struct RHash {
921  struct RBasic basic;
922  struct st_table *ntbl; /* possibly 0 */
923  int iter_lev;
924  const VALUE ifnone;
925 };
926 /* RHASH_TBL allocates st_table if not available. */
927 #define RHASH_TBL(h) rb_hash_tbl(h)
928 #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
929 #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
930 #define RHASH_SIZE(h) (RHASH(h)->ntbl ? (st_index_t)RHASH(h)->ntbl->num_entries : 0)
931 #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
932 #define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone)
933 
934 struct RFile {
935  struct RBasic basic;
936  struct rb_io_t *fptr;
937 };
938 
939 struct RRational {
940  struct RBasic basic;
941  const VALUE num;
942  const VALUE den;
943 };
944 
945 #define RRATIONAL_SET_NUM(rat, n) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->num,(n))
946 #define RRATIONAL_SET_DEN(rat, d) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->den,(d))
947 
948 struct RComplex {
949  struct RBasic basic;
950  const VALUE real;
951  const VALUE imag;
952 };
953 
954 #define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
955 #define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
956 
957 struct RData {
958  struct RBasic basic;
959  void (*dmark)(void*);
960  void (*dfree)(void*);
961  void *data;
962 };
963 
965 
966 struct rb_data_type_struct {
967  const char *wrap_struct_name;
968  struct {
969  void (*dmark)(void*);
970  void (*dfree)(void*);
971  size_t (*dsize)(const void *);
972  void *reserved[2]; /* For future extension.
973  This array *must* be filled with ZERO. */
974  } function;
975  const rb_data_type_t *parent;
976  void *data; /* This area can be used for any purpose
977  by a programmer who define the type. */
978  VALUE flags; /* FL_WB_PROTECTED */
979 };
980 
981 #define HAVE_TYPE_RB_DATA_TYPE_T 1
982 #define HAVE_RB_DATA_TYPE_T_FUNCTION 1
983 #define HAVE_RB_DATA_TYPE_T_PARENT 1
984 
985 struct RTypedData {
986  struct RBasic basic;
987  const rb_data_type_t *type;
988  VALUE typed_flag; /* 1 or not */
989  void *data;
990 };
991 
992 #define DATA_PTR(dta) (RDATA(dta)->data)
993 
994 #define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1)
995 #define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
996 #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
997 
998 /*
999 #define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
1000 */
1001 typedef void (*RUBY_DATA_FUNC)(void*);
1002 
1005 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
1007 void *rb_check_typeddata(VALUE, const rb_data_type_t *);
1008 #define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
1009 #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
1010 #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0)
1011 #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
1012 #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE
1013 
1014 /* bits for rb_data_type_struct::flags */
1015 #define RUBY_TYPED_FREE_IMMEDIATELY 1 /* TYPE field */
1016 #define RUBY_TYPED_WB_PROTECTED FL_WB_PROTECTED
1017 
1018 #define Data_Wrap_Struct(klass,mark,free,sval)\
1019  rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
1020 
1021 #define Data_Make_Struct(klass,type,mark,free,sval) (\
1022  (sval) = ALLOC(type),\
1023  memset((sval), 0, sizeof(type)),\
1024  Data_Wrap_Struct((klass),(mark),(free),(sval))\
1025 )
1026 
1027 #define TypedData_Wrap_Struct(klass,data_type,sval)\
1028  rb_data_typed_object_alloc((klass),(sval),(data_type))
1029 
1030 #define TypedData_Make_Struct(klass, type, data_type, sval) (\
1031  (sval) = ALLOC(type),\
1032  memset((sval), 0, sizeof(type)),\
1033  TypedData_Wrap_Struct((klass),(data_type),(sval))\
1034 )
1035 
1036 #define Data_Get_Struct(obj,type,sval) do {\
1037  Check_Type((obj), T_DATA); \
1038  (sval) = (type*)DATA_PTR(obj);\
1039 } while (0)
1040 
1041 #define TypedData_Get_Struct(obj,type,data_type,sval) do {\
1042  (sval) = (type*)rb_check_typeddata((obj), (data_type)); \
1043 } while (0)
1044 
1045 #define RSTRUCT_EMBED_LEN_MAX 3
1046 struct RStruct {
1047  struct RBasic basic;
1048  union {
1049  struct {
1050  long len;
1051  const VALUE *ptr;
1052  } heap;
1054  } as;
1055 };
1056 #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1)
1057 #define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
1058 #define RSTRUCT_LEN(st) \
1059  ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
1060  (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
1061  (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
1062  RSTRUCT(st)->as.heap.len)
1063 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
1064 #define RSTRUCT_CONST_PTR(st) \
1065  ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
1066  RSTRUCT(st)->as.ary : \
1067  RSTRUCT(st)->as.heap.ptr)
1068 #define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RGENGC_WB_PROTECTED_STRUCT ? OBJ_WB_UNPROTECT((VALUE)st) : (VALUE)st))
1069 
1070 #define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v))
1071 #define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx])
1072 
1073 #define RBIGNUM_EMBED_LEN_NUMBITS 3
1074 #ifndef RBIGNUM_EMBED_LEN_MAX
1075 # if (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT) < (1 << RBIGNUM_EMBED_LEN_NUMBITS)-1
1076 # define RBIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT)
1077 # else
1078 # define RBIGNUM_EMBED_LEN_MAX ((1 << RBIGNUM_EMBED_LEN_NUMBITS)-1)
1079 # endif
1080 #endif
1081 struct RBignum {
1082  struct RBasic basic;
1083  union {
1084  struct {
1085  long len;
1086  BDIGIT *digits;
1087  } heap;
1089  } as;
1090 };
1091 #define RBIGNUM_SIGN_BIT FL_USER1
1092 /* sign: positive:1, negative:0 */
1093 #define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0)
1094 #define RBIGNUM_SET_SIGN(b,sign) \
1095  ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \
1096  : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT))
1097 #define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b)
1098 #define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b))
1099 
1100 #define RBIGNUM_EMBED_FLAG FL_USER2
1101 #define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
1102 #define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+RBIGNUM_EMBED_LEN_NUMBITS)
1103 #define RBIGNUM_LEN(b) \
1104  ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
1105  (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \
1106  (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \
1107  RBIGNUM(b)->as.heap.len)
1108 /* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */
1109 #define RBIGNUM_DIGITS(b) \
1110  ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
1111  RBIGNUM(b)->as.ary : \
1112  RBIGNUM(b)->as.heap.digits)
1113 #define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b))
1114 
1115 #define R_CAST(st) (struct st*)
1116 #define RBASIC(obj) (R_CAST(RBasic)(obj))
1117 #define ROBJECT(obj) (R_CAST(RObject)(obj))
1118 #define RCLASS(obj) (R_CAST(RClass)(obj))
1119 #define RMODULE(obj) RCLASS(obj)
1120 #define RFLOAT(obj) (R_CAST(RFloat)(obj))
1121 #define RSTRING(obj) (R_CAST(RString)(obj))
1122 #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
1123 #define RARRAY(obj) (R_CAST(RArray)(obj))
1124 #define RHASH(obj) (R_CAST(RHash)(obj))
1125 #define RDATA(obj) (R_CAST(RData)(obj))
1126 #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj))
1127 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
1128 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
1129 #define RFILE(obj) (R_CAST(RFile)(obj))
1130 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
1131 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
1132 
1133 #define FL_SINGLETON FL_USER0
1134 #define FL_WB_PROTECTED (((VALUE)1)<<5)
1135 #define FL_PROMOTED (((VALUE)1)<<6)
1136 #define FL_FINALIZE (((VALUE)1)<<7)
1137 #define FL_TAINT (((VALUE)1)<<8)
1138 #define FL_UNTRUSTED FL_TAINT
1139 #define FL_EXIVAR (((VALUE)1)<<10)
1140 #define FL_FREEZE (((VALUE)1)<<11)
1141 
1142 #define FL_USHIFT 12
1143 
1144 #define FL_USER0 (((VALUE)1)<<(FL_USHIFT+0))
1145 #define FL_USER1 (((VALUE)1)<<(FL_USHIFT+1))
1146 #define FL_USER2 (((VALUE)1)<<(FL_USHIFT+2))
1147 #define FL_USER3 (((VALUE)1)<<(FL_USHIFT+3))
1148 #define FL_USER4 (((VALUE)1)<<(FL_USHIFT+4))
1149 #define FL_USER5 (((VALUE)1)<<(FL_USHIFT+5))
1150 #define FL_USER6 (((VALUE)1)<<(FL_USHIFT+6))
1151 #define FL_USER7 (((VALUE)1)<<(FL_USHIFT+7))
1152 #define FL_USER8 (((VALUE)1)<<(FL_USHIFT+8))
1153 #define FL_USER9 (((VALUE)1)<<(FL_USHIFT+9))
1154 #define FL_USER10 (((VALUE)1)<<(FL_USHIFT+10))
1155 #define FL_USER11 (((VALUE)1)<<(FL_USHIFT+11))
1156 #define FL_USER12 (((VALUE)1)<<(FL_USHIFT+12))
1157 #define FL_USER13 (((VALUE)1)<<(FL_USHIFT+13))
1158 #define FL_USER14 (((VALUE)1)<<(FL_USHIFT+14))
1159 #define FL_USER15 (((VALUE)1)<<(FL_USHIFT+15))
1160 #define FL_USER16 (((VALUE)1)<<(FL_USHIFT+16))
1161 #define FL_USER17 (((VALUE)1)<<(FL_USHIFT+17))
1162 #define FL_USER18 (((VALUE)1)<<(FL_USHIFT+18))
1163 #define FL_USER19 (((VALUE)1)<<(FL_USHIFT+19))
1164 
1165 #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
1166 
1167 #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
1168 #define FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f))
1169 #define FL_TEST(x,f) (FL_ABLE(x)?FL_TEST_RAW((x),(f)):0)
1170 #define FL_ANY_RAW(x,f) FL_TEST_RAW((x),(f))
1171 #define FL_ANY(x,f) FL_TEST((x),(f))
1172 #define FL_ALL_RAW(x,f) (FL_TEST_RAW((x),(f)) == (f))
1173 #define FL_ALL(x,f) (FL_TEST((x),(f)) == (f))
1174 #define FL_SET_RAW(x,f) (RBASIC(x)->flags |= (f))
1175 #define FL_SET(x,f) (FL_ABLE(x) ? FL_SET_RAW(x, f) : 0)
1176 #define FL_UNSET_RAW(x,f) (RBASIC(x)->flags &= ~(f))
1177 #define FL_UNSET(x,f) (FL_ABLE(x) ? FL_UNSET_RAW(x, f) : 0)
1178 #define FL_REVERSE_RAW(x,f) (RBASIC(x)->flags ^= (f))
1179 #define FL_REVERSE(x,f) (FL_ABLE(x) ? FL_REVERSE_RAW(x, f) : 0)
1180 
1181 #define OBJ_TAINTED_RAW(x) FL_TEST_RAW(x, FL_TAINT)
1182 #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT))
1183 #define OBJ_TAINT_RAW(x) FL_SET_RAW(x, FL_TAINT)
1184 #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
1185 #define OBJ_UNTRUSTED(x) OBJ_TAINTED(x)
1186 #define OBJ_UNTRUST(x) OBJ_TAINT(x)
1187 #define OBJ_INFECT_RAW(x,s) FL_SET_RAW(x, OBJ_TAINTED_RAW(s))
1188 #define OBJ_INFECT(x,s) do { \
1189  if (FL_ABLE(x) && FL_ABLE(s)) \
1190  FL_SET_RAW(x, OBJ_TAINTED_RAW(s)); \
1191 } while (0)
1192 
1193 #define OBJ_FROZEN(x) (!!(FL_ABLE(x)?(RBASIC(x)->flags&(FL_FREEZE)):(FIXNUM_P(x)||FLONUM_P(x)||SYMBOL_P(x))))
1194 #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
1195 
1196 #if USE_RGENGC
1197 #define OBJ_PROMOTED(x) (SPECIAL_CONST_P(x) ? 0 : FL_TEST_RAW((x), FL_PROMOTED))
1198 #define OBJ_WB_PROTECTED(x) (SPECIAL_CONST_P(x) ? 1 : FL_TEST_RAW((x), FL_WB_PROTECTED))
1199 #define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
1200 
1203 
1204 #else /* USE_RGENGC */
1205 #define OBJ_PROMOTED(x) 0
1206 #define OBJ_WB_PROTECTED(x) 0
1207 #define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
1208 #endif
1209 
1210 /* Write barrier (WB) interfaces:
1211  * - RB_OBJ_WRITE(a, slot, b): WB for new reference from `a' to `b'.
1212  * Write `b' into `*slot'. `slot' is a pointer in `a'.
1213  * - RB_OBJ_WRITTEN(a, oldv, b): WB for new reference from `a' to `b'.
1214  * This doesn't write any values, but only a WB declaration.
1215  * `oldv' is replaced value with `b' (not used in current Ruby).
1216  *
1217  * NOTE: The following core interfaces can be changed in the future.
1218  * Please catch up if you want to insert WB into C-extensions
1219  * correctly.
1220  */
1221 #define RB_OBJ_WRITE(a, slot, b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__)
1222 #define RB_OBJ_WRITTEN(a, oldv, b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__)
1223 
1224 #ifndef USE_RGENGC_LOGGING_WB_UNPROTECT
1225 #define USE_RGENGC_LOGGING_WB_UNPROTECT 0
1226 #endif
1227 
1228 #if USE_RGENGC_LOGGING_WB_UNPROTECT
1229 void rb_gc_unprotect_logging(void *objptr, const char *filename, int line);
1230 #define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging
1231 #endif
1232 
1233 static inline VALUE
1234 rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1235 {
1236 #ifdef RGENGC_LOGGING_WB_UNPROTECT
1237  RGENGC_LOGGING_WB_UNPROTECT((void *)x, filename, line);
1238 #endif
1239 
1240 #if USE_RGENGC
1241  /* `x' should be an RVALUE object */
1242  if (FL_TEST_RAW((x), FL_WB_PROTECTED)) {
1243  if (FL_TEST_RAW((x), FL_PROMOTED)) {
1245  }
1246  RBASIC(x)->flags &= ~FL_WB_PROTECTED;
1247  }
1248 #endif
1249  return x;
1250 }
1251 
1252 static inline VALUE
1253 rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1254 {
1255 #ifdef RGENGC_LOGGING_OBJ_WRITTEN
1256  RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line);
1257 #endif
1258 
1259 #if USE_RGENGC
1260  /* `a' should be an RVALUE object */
1261  if (FL_TEST_RAW((a), FL_PROMOTED) && !SPECIAL_CONST_P(b)) {
1262  rb_gc_writebarrier(a, b);
1263  }
1264 #endif
1265 
1266  return a;
1267 }
1268 
1269 static inline VALUE
1270 rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
1271 {
1272 #ifdef RGENGC_LOGGING_WRITE
1273  RGENGC_LOGGING_WRITE(a, slot, b, filename, line);
1274 #endif
1275 
1276  *slot = b;
1277 
1278 #if USE_RGENGC
1279  rb_obj_written(a, Qundef /* ignore `oldv' now */, b, filename, line);
1280 #endif
1281  return a;
1282 }
1283 
1284 #if SIZEOF_INT < SIZEOF_LONG
1285 # define INT2NUM(v) INT2FIX((int)(v))
1286 # define UINT2NUM(v) LONG2FIX((unsigned int)(v))
1287 #else
1288 static inline VALUE
1290 {
1291  if (FIXABLE(v))
1292  return INT2FIX(v);
1293  else
1294  return rb_int2big(v);
1295 }
1296 #define INT2NUM(x) rb_int2num_inline(x)
1297 
1298 static inline VALUE
1299 rb_uint2num_inline(unsigned int v)
1300 {
1301  if (POSFIXABLE(v))
1302  return LONG2FIX(v);
1303  else
1304  return rb_uint2big(v);
1305 }
1306 #define UINT2NUM(x) rb_uint2num_inline(x)
1307 #endif
1308 
1309 static inline VALUE
1311 {
1312  if (FIXABLE(v))
1313  return LONG2FIX(v);
1314  else
1315  return rb_int2big(v);
1316 }
1317 #define LONG2NUM(x) rb_long2num_inline(x)
1318 
1319 static inline VALUE
1320 rb_ulong2num_inline(unsigned long v)
1321 {
1322  if (POSFIXABLE(v))
1323  return LONG2FIX(v);
1324  else
1325  return rb_uint2big(v);
1326 }
1327 #define ULONG2NUM(x) rb_ulong2num_inline(x)
1328 
1329 static inline char
1331 {
1332  if ((TYPE(x) == T_STRING) && (RSTRING_LEN(x)>=1))
1333  return RSTRING_PTR(x)[0];
1334  else
1335  return (char)(NUM2INT(x) & 0xff);
1336 }
1337 #define NUM2CHR(x) rb_num2char_inline(x)
1338 
1339 #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
1340 
1341 #define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))
1342 #define ALLOC(type) ((type*)xmalloc(sizeof(type)))
1343 #define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))
1344 
1345 #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
1346 
1347 void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2));
1348 void rb_free_tmp_buffer(volatile VALUE *store);
1349 /* allocates _n_ bytes temporary buffer and stores VALUE including it
1350  * in _v_. _n_ may be evaluated twice. */
1351 #ifdef C_ALLOCA
1352 # define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
1353 #else
1354 # define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
1355 #endif
1356 #define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))
1357 #define ALLOCV_END(v) rb_free_tmp_buffer(&(v))
1358 
1359 #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
1360 #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
1361 #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
1362 #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
1363 
1364 void rb_obj_infect(VALUE,VALUE);
1365 
1366 typedef int ruby_glob_func(const char*,VALUE, void*);
1367 void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
1368 int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
1369 int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
1370 
1371 VALUE rb_define_class(const char*,VALUE);
1372 VALUE rb_define_module(const char*);
1373 VALUE rb_define_class_under(VALUE, const char*, VALUE);
1374 VALUE rb_define_module_under(VALUE, const char*);
1375 
1379 
1380 struct rb_global_variable;
1381 
1382 typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
1383 typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1384 typedef void rb_gvar_marker_t(VALUE *var);
1385 
1386 VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
1387 void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1389 
1390 VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
1391 void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1393 
1394 VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
1395 void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1397 
1398 void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1399 
1400 void rb_define_variable(const char*,VALUE*);
1401 void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1402 void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1403 void rb_define_readonly_variable(const char*,VALUE*);
1404 void rb_define_const(VALUE,const char*,VALUE);
1405 void rb_define_global_const(const char*,VALUE);
1406 
1407 #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
1408 void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
1409 void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
1410 void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
1411 
1412 void rb_undef_method(VALUE,const char*);
1413 void rb_define_alias(VALUE,const char*,const char*);
1414 void rb_define_attr(VALUE,const char*,int,int);
1415 
1416 void rb_global_variable(VALUE*);
1420 
1421 ID rb_intern(const char*);
1422 ID rb_intern2(const char*, long);
1424 const char *rb_id2name(ID);
1425 ID rb_check_id(volatile VALUE *);
1426 ID rb_to_id(VALUE);
1427 VALUE rb_id2str(ID);
1428 
1429 #define CONST_ID_CACHE(result, str) \
1430  { \
1431  static ID rb_intern_id_cache; \
1432  if (!rb_intern_id_cache) \
1433  rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
1434  result rb_intern_id_cache; \
1435  }
1436 #define CONST_ID(var, str) \
1437  do CONST_ID_CACHE((var) =, (str)) while (0)
1438 #ifdef __GNUC__
1439 /* __builtin_constant_p and statement expression is available
1440  * since gcc-2.7.2.3 at least. */
1441 #define rb_intern(str) \
1442  (__builtin_constant_p(str) ? \
1443  __extension__ (CONST_ID_CACHE((ID), (str))) : \
1444  rb_intern(str))
1445 #define rb_intern_const(str) \
1446  (__builtin_constant_p(str) ? \
1447  __extension__ (rb_intern2((str), (long)strlen(str))) : \
1448  (rb_intern)(str))
1449 #else
1450 #define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
1451 #endif
1452 
1453 const char *rb_class2name(VALUE);
1454 const char *rb_obj_classname(VALUE);
1455 
1456 void rb_p(VALUE);
1457 
1458 VALUE rb_eval_string(const char*);
1459 VALUE rb_eval_string_protect(const char*, int*);
1460 VALUE rb_eval_string_wrap(const char*, int*);
1461 VALUE rb_funcall(VALUE, ID, int, ...);
1462 VALUE rb_funcallv(VALUE, ID, int, const VALUE*);
1463 VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*);
1464 #define rb_funcall2 rb_funcallv
1465 #define rb_funcall3 rb_funcallv_public
1467 VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE);
1468 int rb_scan_args(int, const VALUE*, const char*, ...);
1469 VALUE rb_call_super(int, const VALUE*);
1470 
1471 /* rb_scan_args() format allows ':' for optional hash */
1472 #define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1
1473 
1474 VALUE rb_gv_set(const char*, VALUE);
1475 VALUE rb_gv_get(const char*);
1476 VALUE rb_iv_get(VALUE, const char*);
1477 VALUE rb_iv_set(VALUE, const char*, VALUE);
1478 
1480 
1481 VALUE *rb_ruby_verbose_ptr(void);
1482 VALUE *rb_ruby_debug_ptr(void);
1483 #define ruby_verbose (*rb_ruby_verbose_ptr())
1484 #define ruby_debug (*rb_ruby_debug_ptr())
1485 
1486 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
1487 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
1488 PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
1489 NORETURN(void rb_bug_errno(const char*, int));
1490 NORETURN(void rb_sys_fail(const char*));
1492 NORETURN(void rb_mod_sys_fail(VALUE, const char*));
1494 NORETURN(void rb_readwrite_sys_fail(int, const char*));
1495 NORETURN(void rb_iter_break(void));
1497 NORETURN(void rb_exit(int));
1498 NORETURN(void rb_notimplement(void));
1499 VALUE rb_syserr_new(int, const char *);
1501 NORETURN(void rb_syserr_fail(int, const char*));
1502 NORETURN(void rb_syserr_fail_str(int, VALUE));
1503 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
1505 
1506 /* reports if `-W' specified */
1507 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
1508 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
1509 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
1510 /* reports always */
1511 PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
1512 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
1513 
1514 /* for rb_readwrite_sys_fail first argument */
1515 #define RB_IO_WAIT_READABLE 0
1516 #define RB_IO_WAIT_WRITABLE 1
1517 
1518 #define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1
1519 #define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \
1520  VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg
1521 typedef VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg));
1522 
1523 #if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT
1525 #else
1526 typedef VALUE (*rb_block_call_func_t)(ANYARGS);
1527 #endif
1528 
1531 VALUE rb_yield_values(int n, ...);
1532 VALUE rb_yield_values2(int n, const VALUE *argv);
1534 VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */
1535 int rb_block_given_p(void);
1536 void rb_need_block(void);
1538 VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE);
1542 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
1544 NORETURN(void rb_throw(const char*,VALUE));
1546 
1547 VALUE rb_require(const char*);
1548 
1559 
1598 
1627 
1632 
1634 
1636 
1637 static inline VALUE
1639 {
1640  if (IMMEDIATE_P(obj)) {
1641  if (FIXNUM_P(obj)) return rb_cFixnum;
1642  if (FLONUM_P(obj)) return rb_cFloat;
1643  if (obj == Qtrue) return rb_cTrueClass;
1644  if (SYMBOL_P(obj)) return rb_cSymbol;
1645  }
1646  else if (!RTEST(obj)) {
1647  if (obj == Qnil) return rb_cNilClass;
1648  if (obj == Qfalse) return rb_cFalseClass;
1649  }
1650  return RBASIC(obj)->klass;
1651 }
1652 
1653 static inline int
1655 {
1656  if (IMMEDIATE_P(obj)) {
1657  if (FIXNUM_P(obj)) return T_FIXNUM;
1658  if (FLONUM_P(obj)) return T_FLOAT;
1659  if (obj == Qtrue) return T_TRUE;
1660  if (SYMBOL_P(obj)) return T_SYMBOL;
1661  if (obj == Qundef) return T_UNDEF;
1662  }
1663  else if (!RTEST(obj)) {
1664  if (obj == Qnil) return T_NIL;
1665  if (obj == Qfalse) return T_FALSE;
1666  }
1667  return BUILTIN_TYPE(obj);
1668 }
1669 
1670 #define RB_FLOAT_TYPE_P(obj) (FLONUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT))
1671 
1672 #define RB_TYPE_P(obj, type) ( \
1673  ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
1674  ((type) == T_TRUE) ? ((obj) == Qtrue) : \
1675  ((type) == T_FALSE) ? ((obj) == Qfalse) : \
1676  ((type) == T_NIL) ? ((obj) == Qnil) : \
1677  ((type) == T_UNDEF) ? ((obj) == Qundef) : \
1678  ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
1679  ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \
1680  (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
1681 
1682 #ifdef __GNUC__
1683 #define rb_type_p(obj, type) \
1684  __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
1685  rb_type(obj) == (type))
1686 #else
1687 #define rb_type_p(obj, type) (rb_type(obj) == (type))
1688 #endif
1689 
1690 #ifdef __GNUC__
1691 #define rb_special_const_p(obj) \
1692  __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);})
1693 #else
1694 static inline int
1696 {
1697  if (SPECIAL_CONST_P(obj)) return (int)Qtrue;
1698  return (int)Qfalse;
1699 }
1700 #endif
1701 
1702 #include "ruby/intern.h"
1703 
1704 #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
1705 /* hook for external modules */
1706 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
1707 #endif
1708 
1709 #define RUBY_VM 1 /* YARV */
1710 #define HAVE_NATIVETHREAD
1711 int ruby_native_thread_p(void);
1712 
1713 /* traditional set_trace_func events */
1714 #define RUBY_EVENT_NONE 0x0000
1715 #define RUBY_EVENT_LINE 0x0001
1716 #define RUBY_EVENT_CLASS 0x0002
1717 #define RUBY_EVENT_END 0x0004
1718 #define RUBY_EVENT_CALL 0x0008
1719 #define RUBY_EVENT_RETURN 0x0010
1720 #define RUBY_EVENT_C_CALL 0x0020
1721 #define RUBY_EVENT_C_RETURN 0x0040
1722 #define RUBY_EVENT_RAISE 0x0080
1723 #define RUBY_EVENT_ALL 0x00ff
1724 
1725 /* for TracePoint extended events */
1726 #define RUBY_EVENT_B_CALL 0x0100
1727 #define RUBY_EVENT_B_RETURN 0x0200
1728 #define RUBY_EVENT_THREAD_BEGIN 0x0400
1729 #define RUBY_EVENT_THREAD_END 0x0800
1730 #define RUBY_EVENT_TRACEPOINT_ALL 0xffff
1731 
1732 /* special events */
1733 #define RUBY_EVENT_SPECIFIED_LINE 0x010000
1734 #define RUBY_EVENT_COVERAGE 0x020000
1735 
1736 /* internal events */
1737 #define RUBY_INTERNAL_EVENT_SWITCH 0x040000
1738 #define RUBY_EVENT_SWITCH 0x040000 /* obsolete name. this macro is for compatibility */
1739  /* 0x080000 */
1740 #define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000
1741 #define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000
1742 #define RUBY_INTERNAL_EVENT_GC_START 0x400000
1743 #define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000
1744 #define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000
1745 #define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x1f00000
1746 #define RUBY_INTERNAL_EVENT_MASK 0xfffe0000
1747 
1748 typedef unsigned long rb_event_flag_t;
1749 typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass);
1750 
1751 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
1752 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data);
1754 
1755 /* locale insensitive functions */
1756 
1757 #define rb_isascii(c) ((unsigned long)(c) < 128)
1758 int rb_isalnum(int c);
1759 int rb_isalpha(int c);
1760 int rb_isblank(int c);
1761 int rb_iscntrl(int c);
1762 int rb_isdigit(int c);
1763 int rb_isgraph(int c);
1764 int rb_islower(int c);
1765 int rb_isprint(int c);
1766 int rb_ispunct(int c);
1767 int rb_isspace(int c);
1768 int rb_isupper(int c);
1769 int rb_isxdigit(int c);
1770 int rb_tolower(int c);
1771 int rb_toupper(int c);
1772 
1773 #ifndef ISPRINT
1774 #define ISASCII(c) rb_isascii((unsigned char)(c))
1775 #undef ISPRINT
1776 #define ISPRINT(c) rb_isprint((unsigned char)(c))
1777 #define ISGRAPH(c) rb_isgraph((unsigned char)(c))
1778 #define ISSPACE(c) rb_isspace((unsigned char)(c))
1779 #define ISUPPER(c) rb_isupper((unsigned char)(c))
1780 #define ISLOWER(c) rb_islower((unsigned char)(c))
1781 #define ISALNUM(c) rb_isalnum((unsigned char)(c))
1782 #define ISALPHA(c) rb_isalpha((unsigned char)(c))
1783 #define ISDIGIT(c) rb_isdigit((unsigned char)(c))
1784 #define ISXDIGIT(c) rb_isxdigit((unsigned char)(c))
1785 #endif
1786 #define TOUPPER(c) rb_toupper((unsigned char)(c))
1787 #define TOLOWER(c) rb_tolower((unsigned char)(c))
1788 
1789 int st_locale_insensitive_strcasecmp(const char *s1, const char *s2);
1790 int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n);
1791 #define STRCASECMP(s1, s2) (st_locale_insensitive_strcasecmp((s1), (s2)))
1792 #define STRNCASECMP(s1, s2, n) (st_locale_insensitive_strncasecmp((s1), (s2), (n)))
1793 
1794 unsigned long ruby_strtoul(const char *str, char **endptr, int base);
1795 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
1796 
1797 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
1798 
1799 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
1800 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
1801 
1802 #ifndef RUBY_DONT_SUBST
1803 #include "ruby/subst.h"
1804 #endif
1805 
1822 void ruby_sysinit(int *argc, char ***argv);
1823 void ruby_init(void);
1824 void* ruby_options(int argc, char** argv);
1825 int ruby_executable_node(void *n, int *status);
1826 int ruby_run_node(void *n);
1827 
1828 /* version.c */
1829 void ruby_show_version(void);
1830 void ruby_show_copyright(void);
1831 
1832 
1835 #define RUBY_INIT_STACK \
1836  VALUE variable_in_this_stack_frame; \
1837  ruby_init_stack(&variable_in_this_stack_frame);
1838 
1840 #ifdef __ia64
1841 void ruby_init_stack(volatile VALUE*, void*);
1842 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
1843 #else
1844 void ruby_init_stack(volatile VALUE*);
1845 #endif
1846 #define Init_stack(addr) ruby_init_stack(addr)
1847 
1848 int ruby_setup(void);
1849 int ruby_cleanup(volatile int);
1850 
1851 void ruby_finalize(void);
1852 NORETURN(void ruby_stop(int));
1853 
1854 void ruby_set_stack_size(size_t);
1855 int ruby_stack_check(void);
1856 size_t ruby_stack_length(VALUE**);
1857 
1858 int ruby_exec_node(void *n);
1859 
1860 void ruby_script(const char* name);
1861 void ruby_set_script_name(VALUE name);
1862 
1863 void ruby_prog_init(void);
1864 void ruby_set_argv(int, char**);
1865 void *ruby_process_options(int, char**);
1866 void ruby_init_loadpath(void);
1867 void ruby_incpush(const char*);
1868 void ruby_sig_finalize(void);
1869 
1873 
1874 #if defined(__cplusplus)
1875 #if 0
1876 { /* satisfy cc-mode */
1877 #endif
1878 } /* extern "C" { */
1879 #endif
1880 #endif /* RUBY_RUBY_H */
void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar)
VALUE data
Definition: tcltklib.c:3360
void(* rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass)
Definition: ripper.y:1749
VALUE rb_eScriptError
Definition: error.c:562
#define T_SYMBOL
Definition: ruby.h:494
VALUE rb_eStandardError
Definition: error.c:546
VALUE rb_eLocalJumpError
Definition: eval.c:27
union RString::@95 as
const VALUE num
Definition: ripper.y:941
#define DEPRECATED(x)
Definition: ruby.h:36
long len
Definition: ripper.y:1050
RUBY_SYMBOL_EXPORT_BEGIN void * alloca()
int ruby_cleanup(volatile int ex)
Destructs the VM.
Definition: eval.c:157
Definition: ripper.y:805
RUBY_EXTERN VALUE rb_cBasicObject
Definition: ripper.y:1560
VP_EXPORT int
Definition: bigdecimal.c:5172
const VALUE ary[RARRAY_EMBED_LEN_MAX]
Definition: ripper.y:871
void rb_bug(const char *fmt,...)
Definition: error.c:327
RUBY_EXTERN VALUE rb_cMatch
Definition: ripper.y:1578
VALUE rb_uint2big(VALUE n)
Definition: bignum.c:3142
RUBY_EXTERN VALUE rb_cNilClass
Definition: ripper.y:1582
RUBY_EXTERN VALUE rb_cModule
Definition: ripper.y:1580
void(* dfree)(void *)
Definition: ripper.y:960
RUBY_EXTERN VALUE rb_cStat
Definition: ripper.y:1590
BDIGIT * digits
Definition: ripper.y:1086
#define T_FIXNUM
Definition: ruby.h:489
const char * rb_obj_classname(VALUE)
Definition: variable.c:406
VALUE rb_id2str(ID id)
Definition: ripper.c:17201
VALUE rb_get_path(VALUE)
Definition: file.c:226
VALUE rb_iv_set(VALUE, const char *, VALUE)
Definition: variable.c:2612
void rb_syserr_fail(int e, const char *mesg)
Definition: error.c:1964
VALUE rb_cEncoding
Definition: encoding.c:37
VALUE rb_eSignal
Definition: error.c:544
void ruby_finalize(void)
Runs the VM finalization processes.
Definition: eval.c:140
#define NUM2INT(x)
Definition: ruby.h:630
void(* RUBY_DATA_FUNC)(void *)
Definition: ripper.y:1001
VALUE rb_gv_set(const char *, VALUE)
Definition: variable.c:810
const rb_data_type_t * type
Definition: ripper.y:987
void rb_throw(const char *tag, VALUE val)
Definition: vm_eval.c:1762
struct RString::@95::@96 heap
VALUE(* rb_block_call_func_t)(ANYARGS)
Definition: ripper.y:1526
VALUE rb_eKeyError
Definition: error.c:551
RUBY_EXTERN VALUE rb_stdout
Definition: ripper.y:1635
size_t ruby_stack_length(VALUE **)
Definition: gc.c:3253
VALUE rb_string_value(volatile VALUE *)
Definition: string.c:1588
struct st_table * iv_index_tbl
Definition: ripper.y:768
rb_funcall(memo->yielder, id_lshift, 1, rb_assoc_new(memo->prev_value, memo->prev_elts))
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:113
RUBY_EXTERN VALUE rb_mWaitReadable
Definition: ripper.y:1557
VALUE rb_eval_string_wrap(const char *, int *)
Evaluates the given string under a module binding in an isolated binding.
Definition: vm_eval.c:1444
void rb_secure(int)
Definition: safe.c:88
int rb_toupper(int c)
Definition: encoding.c:1958
void ruby_show_version(void)
Prints the version information of the CRuby interpreter to stdout.
Definition: version.c:78
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2239
void rb_p(VALUE)
Definition: io.c:7060
struct RStruct::@102::@103 heap
Definition: io.h:61
char * rb_string_value_ptr(volatile VALUE *)
Definition: string.c:1599
VALUE rb_syserr_new_str(int n, VALUE arg)
Definition: error.c:1958
RUBY_EXTERN VALUE rb_cTime
Definition: ripper.y:1595
VALUE rb_gv_get(const char *)
Definition: variable.c:819
struct st_table * ntbl
Definition: ripper.y:922
RUBY_EXTERN VALUE rb_eZeroDivError
Definition: ripper.y:1617
RUBY_EXTERN VALUE rb_cBinding
Definition: ripper.y:1564
VALUE rb_iv_get(VALUE, const char *)
Definition: variable.c:2604
int status
Definition: tcltklib.c:2197
RUBY_EXTERN VALUE rb_cSymbol
Definition: ripper.y:1593
Real * a
Definition: bigdecimal.c:1198
void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar)
rb_yield(i)
VALUE rb_eTypeError
Definition: error.c:548
void rb_define_hooked_variable(const char *, VALUE *, VALUE(*)(ANYARGS), void(*)(ANYARGS))
Definition: variable.c:585
VALUE rb_cNameErrorMesg
Definition: error.c:560
#define FIX2SHORT(x)
Definition: ruby.h:640
static VALUE rb_uint2num_inline(unsigned int v)
Definition: ruby.h:1299
rb_iter_break()
Definition: vm.c:1154
int ruby_exec_node(void *n)
Runs the given compiled source.
Definition: eval.c:315
unsigned long ruby_strtoul(const char *str, char **endptr, int base)
Definition: util.c:111
void ruby_show_copyright(void)
Prints the copyright notice of the CRuby interpreter to stdout and exits this process successfully...
Definition: version.c:88
VALUE rb_require(const char *)
Definition: load.c:1036
VALUE rb_yield_values2(int n, const VALUE *argv)
Definition: vm_eval.c:981
#define PRINTF_ARGS(decl, string_index, first_to_check)
static short rb_num2short_inline(VALUE x)
Definition: ruby.h:642
VALUE rb_eEncodingError
Definition: error.c:554
VALUE rb_str_export(VALUE)
Definition: string.c:743
long capa
Definition: ripper.y:827
RUBY_EXTERN VALUE rb_cTrueClass
Definition: ripper.y:1596
VALUE * rb_ruby_debug_ptr(void)
Definition: vm.c:2871
int rb_isblank(int c)
Definition: encoding.c:1940
int ruby_glob(const char *path, int flags, ruby_glob_func *func, VALUE arg)
Definition: dir.c:1578
struct RArray::@98::@99 heap
VALUE rb_cEnumerator
Definition: enumerator.c:105
VALUE var
Definition: tcltklib.c:5495
RUBY_EXTERN VALUE rb_cFloat
Definition: ripper.y:1574
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition: class.c:657
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1857
VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE *, VALUE)
Definition: vm_eval.c:841
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:179
int rb_isupper(int c)
Definition: encoding.c:1948
size_t(* dsize)(const void *)
Definition: ripper.y:971
void rb_check_safe_obj(VALUE)
Definition: safe.c:122
RUBY_EXTERN VALUE rb_eIOError
Definition: ripper.y:1611
int rb_isprint(int c)
Definition: encoding.c:1945
VALUE rb_eSecurityError
Definition: error.c:557
void rb_include_module(VALUE klass, VALUE module)
Definition: class.c:808
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Definition: object.c:62
void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar)
Definition: ripper.y:1383
int ruby_snprintf(char *str, size_t n, char const *fmt,...)
Definition: vsnprintf.c:1320
VALUE rb_catch_obj(VALUE, VALUE(*)(ANYARGS), VALUE)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
Definition: class.c:1675
double float_value
Definition: ripper.y:807
VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE *)
Definition: vm_eval.c:833
VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar)
int rb_isdigit(int c)
Definition: encoding.c:1942
void * reserved[2]
Definition: ripper.y:972
ruby_value_type
Definition: ripper.y:442
void(* dmark)(void *)
Definition: ripper.y:959
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17365
struct RBignum::@104::@105 heap
VALUE rb_eSyntaxError
Definition: error.c:563
#define FIXNUM_P(f)
Definition: ruby.h:347
VALUE rb_catch(const char *, VALUE(*)(ANYARGS), VALUE)
#define T_UNDEF
Definition: ruby.h:497
VALUE rb_iterate(VALUE(*)(VALUE), VALUE, VALUE(*)(ANYARGS), VALUE)
Definition: vm_eval.c:1059
void rb_undef_method(VALUE klass, const char *name)
Definition: class.c:1497
Definition: ripper.y:957
struct re_pattern_buffer * ptr
Definition: ripper.y:911
VALUE rb_equal(VALUE, VALUE)
Definition: object.c:89
int ruby_stack_check(void)
Definition: gc.c:3282
VALUE rb_str_to_str(VALUE)
Definition: string.c:964
VALUE rb_eRangeError
Definition: error.c:552
static VALUE rb_class_of(VALUE obj)
Definition: ruby.h:1638
RUBY_EXTERN VALUE rb_mWaitWritable
Definition: ripper.y:1558
i
Definition: enum.c:446
RUBY_EXTERN VALUE rb_cRegexp
Definition: ripper.y:1589
unsigned long rb_event_flag_t
Definition: ripper.y:1748
const char * fmt
Definition: tcltklib.c:846
void rb_gvar_undef_marker(VALUE *var)
void ruby_incpush(const char *)
Definition: ruby.c:337
void rb_gvar_marker_t(VALUE *var)
Definition: ripper.y:1384
VALUE rb_get_path_no_checksafe(VALUE)
Definition: file.c:220
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
Definition: ripper.y:1521
static VALUE rb_long2num_inline(long v)
Definition: ruby.h:1310
#define NORETURN(x)
Definition: ruby.h:33
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Definition: ruby.h:1519
void rb_gc_unprotect_logging(void *objptr, const char *filename, int line)
Definition: gc.c:4807
const VALUE den
Definition: ripper.y:942
void rb_prepend_module(VALUE klass, VALUE module)
Definition: class.c:921
int ruby_glob_func(const char *, VALUE, void *)
Definition: ripper.y:1366
VALUE rb_eNameError
Definition: error.c:553
void rb_define_readonly_variable(const char *, VALUE *)
Definition: variable.c:610
#define POSFIXABLE(f)
Definition: ruby.h:348
VALUE rb_newobj(void)
Definition: gc.c:1348
RUBY_EXTERN VALUE rb_mMath
Definition: ripper.y:1555
const VALUE src
Definition: ripper.y:912
RUBY_EXTERN VALUE rb_mFileTest
Definition: ripper.y:1553
struct RBasic basic
Definition: ripper.y:791
VALUE rb_rescue(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*r_proc)(ANYARGS), VALUE data2)
Definition: eval.c:799
VALUE rb_mComparable
Definition: compar.c:14
#define rb_intern_str(string)
Definition: generator.h:17
static int rb_type(VALUE obj)
static VALUE rb_ulong2num_inline(unsigned long v)
Definition: ruby.h:1320
int rb_block_given_p(void)
Definition: eval.c:712
int rb_isxdigit(int c)
Definition: encoding.c:1949
union RObject::@93 as
#define Qnil
Definition: enum.c:67
void ruby_init(void)
Definition: eval.c:73
#define val
Definition: tcltklib.c:1935
int rb_ispunct(int c)
Definition: encoding.c:1946
VALUE rb_yield_splat(VALUE)
Definition: vm_eval.c:987
VALUE rb_funcallv(VALUE, ID, int, const VALUE *)
Calls a method.
Definition: vm_eval.c:812
void rb_free_tmp_buffer(volatile VALUE *store)
Definition: string.c:933
VALUE rb_eRuntimeError
Definition: error.c:547
#define Qtrue
const rb_data_type_t * parent
Definition: ripper.y:975
int ruby_safe_level_4_warning(void)
Definition: safe.c:31
VALUE rb_eval_string_protect(const char *, int *)
Evaluates the given string in an isolated binding.
Definition: vm_eval.c:1427
VALUE rb_eSysStackError
Definition: eval.c:28
RUBY_EXTERN VALUE rb_mKernel
Definition: ripper.y:1549
VALUE rb_syserr_new(int n, const char *mesg)
Definition: error.c:1950
static VALUE char * str
Definition: tcltklib.c:3539
#define T_NIL
Definition: ruby.h:476
RUBY_EXTERN VALUE rb_cRational
Definition: ripper.y:1587
static VALUE rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
Definition: ruby.h:1270
int rb_isspace(int c)
Definition: encoding.c:1947
const VALUE imag
Definition: ripper.y:951
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Definition: error.c:510
RUBY_EXTERN VALUE rb_cHash
Definition: ripper.y:1575
union RArray::@98 as
VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE)
Definition: vm_eval.c:1000
RUBY_EXTERN VALUE rb_cMethod
Definition: ripper.y:1579
#define T_TRUE
Definition: ruby.h:490
void rb_gvar_val_marker(VALUE *var)
unsigned long ID
Definition: ripper.y:89
char ruby_check_sizeof_voidp[SIZEOF_VOIDP==sizeof(void *)?1:-1]
Definition: ripper.y:109
int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap)
Definition: vsnprintf.c:1302
Definition: ripper.y:747
short rb_num2short(VALUE)
Definition: numeric.c:2240
Definition: ripper.y:860
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2228
void * data
Definition: ripper.y:989
const VALUE real
Definition: ripper.y:950
long numiv
Definition: ripper.y:766
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:611
VALUE rb_eNoMethodError
Definition: error.c:556
static VALUE VALUE obj
Definition: tcltklib.c:3150
void rb_sys_fail_str(VALUE mesg)
Definition: error.c:1982
#define ANYARGS
VALUE rb_eNoMemError
Definition: error.c:559
double rb_num2dbl(VALUE)
Definition: object.c:2987
void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar)
struct RBasic basic
Definition: ripper.y:940
#define FLONUM_P(x)
Definition: ruby.h:367
VALUE typed_flag
Definition: ripper.y:988
#define T_FLOAT
Definition: ruby.h:481
#define TYPE(x)
Definition: ruby.h:505
void rb_check_type(VALUE x, int t)
Definition: error.c:477
void rb_gc_unregister_address(VALUE *)
Definition: gc.c:4942
static long rb_num2long_inline(VALUE x)
Definition: ruby.h:593
VALUE rb_call_super(int, const VALUE *)
Definition: vm_eval.c:275
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ripper.y:831
void rb_gvar_var_marker(VALUE *var)
void rb_exit(int status)
Definition: process.c:3656
void rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
Definition: error.c:2040
static VALUE rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
Definition: ruby.h:1234
VALUE rb_eEncCompatError
Definition: error.c:555
void ruby_stop(int ex)
Calls ruby_cleanup() and exits the process.
Definition: eval.c:264
#define RB_UNUSED_VAR(x)
Definition: ruby.h:528
VALUE rb_mErrno
Definition: error.c:567
VALUE rb_eLoadError
Definition: error.c:564
void rb_throw_obj(VALUE tag, VALUE value)
Definition: vm_eval.c:1740
VALUE rb_eIndexError
Definition: error.c:550
struct rb_io_t * fptr
Definition: ripper.y:936
int len
Definition: enumerator.c:1332
VALUE arg
Definition: enum.c:2427
void * ruby_process_options(int, char **)
Definition: ruby.c:1960
VALUE * ivptr
Definition: ripper.y:767
VALUE rb_eval_string(const char *)
Evaluates the given string in an isolated binding.
Definition: vm_eval.c:1411
void * data
Definition: ripper.y:961
int rb_isgraph(int c)
Definition: encoding.c:1943
void rb_need_block(void)
Definition: eval.c:733
void ruby_set_script_name(VALUE name)
Sets the current script name to this value.
Definition: ruby.c:1855
static unsigned long rb_num2ulong_inline(VALUE x)
Definition: ruby.h:602
VALUE rb_data_object_alloc(VALUE, void *, RUBY_DATA_FUNC, RUBY_DATA_FUNC)
Definition: gc.c:1369
VALUE rb_obj_hide(VALUE obj)
Definition: object.c:53
RUBY_EXTERN VALUE rb_cInteger
Definition: ripper.y:1576
VALUE * argv
Definition: tcltklib.c:1969
VALUE rb_newobj_of(VALUE, VALUE)
Definition: gc.c:1354
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
Definition: class.c:1688
#define RSTRING_LEN(str)
Definition: ruby.h:841
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for module.
Definition: class.c:1661
union RString::@95::@96::@97 aux
#define RUBY_EXTERN
Definition: missing.h:67
#define ruby_sysinit
Definition: stub.c:3
int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: st.c:1640
long rb_fix2int(VALUE val)
Definition: numeric.c:2203
VALUE rb_mEnumerable
Definition: enum.c:20
RUBY_EXTERN VALUE rb_cFixnum
Definition: ripper.y:1573
rb_block_call(enumerable, id_each, 0, 0, chunk_ii, arg)
VALUE v
Definition: enum.c:845
void rb_fatal(const char *fmt,...)
Definition: error.c:1911
void ruby_prog_init(void)
Defines built-in variables.
Definition: ruby.c:1913
VALUE rb_eSystemCallError
Definition: error.c:566
#define RSTRING_EMBED_LEN_MAX
Definition: ruby.h:819
const VALUE klass
Definition: ripper.y:749
void rb_gc_register_mark_object(VALUE)
Definition: gc.c:4923
long len
Definition: ripper.y:864
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:39
VP_EXPORT void
Definition: bigdecimal.c:5207
unsigned short rb_num2ushort(VALUE)
Definition: numeric.c:2258
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1719
VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar)
void(* dfree)(void *)
Definition: ripper.y:970
Definition: ripper.y:934
char * rb_string_value_cstr(volatile VALUE *)
Definition: string.c:1643
VALUE rb_eInterrupt
Definition: error.c:543
RUBY_EXTERN VALUE rb_cUnboundMethod
Definition: ripper.y:1597
static char rb_num2char_inline(VALUE x)
Definition: ruby.h:1330
SIGNED_VALUE rb_num2long(VALUE)
Definition: numeric.c:2038
VALUE rb_cDir
Definition: dir.c:350
unsigned int uintptr_t
Definition: win32.h:103
#define RBIGNUM_EMBED_LEN_MAX
Definition: ruby.h:1076
VALUE rb_eStopIteration
Definition: enumerator.c:111
int type
Definition: tcltklib.c:112
#define FL_TEST_RAW(x, f)
Definition: ruby.h:1168
const VALUE * ptr
Definition: ripper.y:869
#define BUILTIN_TYPE(x)
Definition: ruby.h:502
VALUE shared
Definition: ripper.y:828
int argc
Definition: tcltklib.c:1968
RUBY_EXTERN VALUE rb_mProcess
Definition: ripper.y:1556
int rb_remove_event_hook(rb_event_hook_func_t func)
Definition: vm_trace.c:204
union RArray::@98::@99::@100 aux
#define RBASIC(obj)
Definition: ruby.h:1116
void rb_set_safe_level_force(int)
Definition: safe.c:43
void rb_readwrite_sys_fail(int writable, const char *mesg)
Definition: io.c:11704
RUBY_EXTERN VALUE rb_cCont
Definition: ripper.y:1566
void rb_extend_object(VALUE obj, VALUE module)
Definition: eval.c:1318
#define FIX2INT(x)
Definition: ruby.h:632
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:38
void rb_mod_syserr_fail(VALUE mod, int e, const char *mesg)
Definition: error.c:2032
void rb_bug_errno(const char *mesg, int errno_arg)
Definition: error.c:350
VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar)
Definition: ripper.y:1382
VALUE rb_rescue2(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*r_proc)(ANYARGS), VALUE data2,...)
Definition: eval.c:741
char ruby_check_sizeof_int[SIZEOF_INT==sizeof(int)?1:-1]
Definition: ripper.y:104
RUBY_EXTERN VALUE rb_stdin
Definition: ripper.y:1635
void ruby_init_stack(volatile VALUE *)
RUBY_EXTERN VALUE rb_eMathDomainError
Definition: ripper.y:1633
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:839
VALUE flags
Definition: ripper.y:748
int rb_islower(int c)
Definition: encoding.c:1944
void rb_sys_fail(const char *mesg)
Definition: error.c:1976
BDIGIT ary[RBIGNUM_EMBED_LEN_MAX]
Definition: ripper.y:1088
RUBY_EXTERN VALUE rb_cString
Definition: ripper.y:1591
Real * b
Definition: bigdecimal.c:1198
VALUE ary[ROBJECT_EMBED_LEN_MAX]
Definition: ripper.y:770
void rb_glob(const char *path, void(*func)(const char *, VALUE, void *), VALUE arg)
Definition: dir.c:1615
#define FIXABLE(f)
Definition: ruby.h:350
#define ruby_run_node
Definition: goruby.c:3
return ptr
Definition: tcltklib.c:789
VpDivd * c
Definition: bigdecimal.c:1223
VALUE rb_each(VALUE)
Definition: vm_eval.c:1182
RUBY_EXTERN VALUE rb_cIO
Definition: ripper.y:1577
#define ruby_options
Definition: goruby.c:2
VALUE rb_define_module_under(VALUE outer, const char *name)
Definition: class.c:747
VALUE rb_str_export_locale(VALUE)
Definition: string.c:749
#define IMMEDIATE_P(x)
Definition: ruby.h:352
#define Qfalse
Definition: tcltklib.c:6845
ID rb_to_id(VALUE)
Definition: string.c:8734
#define RSTRUCT_EMBED_LEN_MAX
Definition: ruby.h:1045
long capa
Definition: ripper.y:866
void rb_iter_break_value(VALUE val)
Definition: vm.c:1160
RUBY_EXTERN VALUE rb_cFile
Definition: ripper.y:1572
unsigned long usecnt
Definition: ripper.y:913
#define RSTRING_PTR(str)
Definition: ruby.h:845
const char * rb_class2name(VALUE)
Definition: variable.c:397
RUBY_EXTERN VALUE rb_stderr
Definition: ripper.y:1635
void rb_gc_register_address(VALUE *)
Definition: gc.c:4930
VALUE rb_funcallv_public(VALUE, ID, int, const VALUE *)
Calls a method.
Definition: vm_eval.c:827
void * rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2))
Definition: string.c:925
void rb_mod_sys_fail_str(VALUE mod, VALUE mesg)
Definition: error.c:2024
void rb_insecure_operation(void)
Definition: safe.c:109
long len
Definition: ripper.y:1085
void ruby_set_stack_size(size_t)
static VALUE rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line))
Definition: ruby.h:1253
#define INT2FIX(i)
Definition: ruby.h:231
static VALUE rb_int2num_inline(int v)
Definition: ruby.h:1289
VALUE rb_cBignum
Definition: bignum.c:35
void rb_gc_writebarrier_unprotect_promoted(VALUE obj)
Definition: gc.c:4752
const VALUE ary[RSTRUCT_EMBED_LEN_MAX]
Definition: ripper.y:1053
long rb_num2int(VALUE val)
Definition: numeric.c:2197
VALUE rb_float_new_in_heap(double)
Definition: numeric.c:642
void rb_secure_update(VALUE)
Definition: safe.c:104
#define RUBY_ATTR_ALLOC_SIZE(params)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
Definition: error.c:520
ruby_special_consts
Definition: ripper.y:397
void ruby_script(const char *name)
Sets the current script name to this value.
Definition: ruby.c:1842
int iter_lev
Definition: ripper.y:923
#define rb_float_new(d)
void rb_define_attr(VALUE klass, const char *name, int read, int write)
Defines (a) public accessor method(s) for an attribute.
Definition: class.c:1701
VALUE name
Definition: enum.c:572
short rb_fix2short(VALUE)
Definition: numeric.c:2249
#define ROBJECT_EMBED_LEN_MAX
Definition: ruby.h:761
void rb_set_errinfo(VALUE err)
Definition: eval.c:1517
void rb_mod_sys_fail(VALUE mod, const char *mesg)
Definition: error.c:2016
void ruby_sig_finalize(void)
Definition: signal.c:1244
RUBY_EXTERN VALUE rb_cClass
Definition: ripper.y:1565
void rb_set_safe_level(int)
Definition: safe.c:49
void rb_syserr_fail_str(int e, VALUE mesg)
Definition: error.c:1970
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:192
#define FL_WB_PROTECTED
Definition: ruby.h:1134
RUBY_EXTERN VALUE rb_cObject
Definition: ripper.y:1561
void ruby_init_loadpath(void)
Definition: ruby.c:380
static int rb_special_const_p(VALUE obj)
Definition: ruby.h:1695
#define LONG2FIX(i)
Definition: ruby.h:232
const char * wrap_struct_name
Definition: ripper.y:967
void ruby_set_argv(int, char **)
Definition: ruby.c:1939
#define RTEST(v)
Definition: ruby.h:437
#define T_STRING
Definition: ruby.h:482
klass
Definition: tcltklib.c:3496
void rb_check_safe_str(VALUE x)
Definition: safe.c:130
union RStruct::@102 as
VALUE rb_uint2inum(VALUE n)
Definition: bignum.c:3185
void rb_define_variable(const char *, VALUE *)
Definition: variable.c:604
#define T_FALSE
Definition: ruby.h:491
VALUE rb_num2ulong(VALUE)
Definition: numeric.c:2118
void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar)
#define RARRAY_EMBED_LEN_MAX
Definition: ruby.h:859
int ruby_brace_glob(const char *str, int flags, ruby_glob_func *func, VALUE arg)
Definition: dir.c:1713
void rb_notimplement(void)
Definition: error.c:1903
void rb_define_virtual_variable(const char *, VALUE(*)(ANYARGS), void(*)(ANYARGS))
Definition: variable.c:616
VALUE rb_cArray
Definition: array.c:27
VALUE rb_int2big(SIGNED_VALUE n)
Definition: bignum.c:3164
char * endptr
Definition: tcltklib.c:3774
int rb_isalnum(int c)
Definition: encoding.c:1938
VALUE rb_eNotImpError
Definition: error.c:558
unsigned short rb_fix2ushort(VALUE)
Definition: numeric.c:2268
VALUE * rb_ruby_verbose_ptr(void)
Definition: vm.c:2865
const VALUE ifnone
Definition: ripper.y:924
#define rb_safe_level()
Definition: tcltklib.c:95
int rb_tolower(int c)
Definition: encoding.c:1952
data n
Definition: enum.c:860
int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent)
Definition: error.c:500
void(* dmark)(void *)
Definition: ripper.y:969
const VALUE * ptr
Definition: ripper.y:1051
int st_locale_insensitive_strcasecmp(const char *s1, const char *s2)
Definition: st.c:1616
RUBY_EXTERN VALUE rb_cProc
Definition: ripper.y:1584
const char * rb_id2name(ID id)
Definition: ripper.c:17271
#define rb_errinfo()
Definition: tcltklib.c:90
void rb_gc_writebarrier(VALUE a, VALUE b)
Definition: gc.c:4734
VALUE rb_eFatal
Definition: error.c:545
#define ruby_native_thread_p()
Definition: tcltklib.c:83
void rb_global_variable(VALUE *)
Definition: gc.c:4965
VALUE rb_int2inum(SIGNED_VALUE n)
Definition: bignum.c:3192
RUBY_EXTERN VALUE rb_cRandom
Definition: ripper.y:1585
char ruby_check_sizeof_long[SIZEOF_LONG==sizeof(long)?1:-1]
Definition: ripper.y:105
unsigned long VALUE
Definition: ripper.y:88
RUBY_EXTERN VALUE rb_eEOFError
Definition: ripper.y:1606
void rb_warning(const char *fmt,...)
Definition: error.c:236
int rb_iscntrl(int c)
Definition: encoding.c:1941
Definition: ripper.y:920
long len
Definition: ripper.y:824
union RBignum::@104 as
VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *)
Definition: gc.c:1376
VALUE super
Definition: ripper.y:792
#define SPECIAL_CONST_P(x)
Definition: ruby.h:1165
VALUE rb_define_module(const char *name)
Definition: class.c:727
RUBY_EXTERN VALUE rb_cFalseClass
Definition: ripper.y:1569
#define rb_intern(str)
volatile VALUE * rb_gc_guarded_ptr(volatile VALUE *ptr)
Definition: gc.c:93
return rb_yield_values(2, rb_enum_values_pack(argc, argv), INT2NUM(n))
#define SYMBOL_P(x)
Definition: ruby.h:354
rb_classext_t * ptr
Definition: ripper.y:793
ID rb_intern2(const char *name, long len)
Definition: ripper.c:17178
RUBY_EXTERN VALUE rb_cData
Definition: ripper.y:1568
void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
Definition: vm_trace.c:145
VALUE rb_eSystemExit
Definition: error.c:542
VALUE shared
Definition: ripper.y:867
#define rb_float_value(v)
VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar)
Definition: ripper.y:790
#define FIX2LONG(x)
Definition: ruby.h:345
#define Qundef
Definition: ruby.h:428
RUBY_EXTERN VALUE rb_eFloatDomainError
Definition: ripper.y:1621
RUBY_EXTERN VALUE rb_mGC
Definition: ripper.y:1554
RUBY_EXTERN VALUE rb_cRange
Definition: ripper.y:1586
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1479
struct RObject::@93::@94 heap
void rb_warn(const char *fmt,...)
Definition: error.c:223
VALUE rb_eThreadError
Definition: eval.c:730
VALUE rb_eArgError
Definition: error.c:549
RUBY_EXTERN VALUE rb_cNumeric
Definition: ripper.y:1583
RUBY_EXTERN VALUE rb_cThread
Definition: ripper.y:1594
int ruby_executable_node(void *n, int *status)
Checks the return value of ruby_options().
Definition: eval.c:282
#define FL_PROMOTED
Definition: ruby.h:1135
#define BDIGIT
Definition: bigdecimal.h:40
int ruby_setup(void)
Definition: eval.c:44
void rb_sys_warning(const char *fmt,...)
Definition: error.c:2048
char * ptr
Definition: ripper.y:825
VALUE rb_cComplex
Definition: complex.c:19
VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type)
Definition: object.c:71
int rb_isalpha(int c)
Definition: encoding.c:1939
RUBY_EXTERN VALUE rb_eRegexpError
Definition: ripper.y:1624
VALUE rb_eException
Definition: error.c:541
void rb_obj_infect(VALUE, VALUE)
Definition: object.c:1041
struct method_table_wrapper * m_tbl_wrapper
Definition: ripper.y:794
RUBY_EXTERN VALUE rb_cStruct
Definition: ripper.y:1592
#define SIGNED_VALUE
Definition: ruby.h:90