Ruby  1.9.3p551(2014-11-13revision48407)
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 #define NORETURN_STYLE_NEW 1
30 #ifndef NORETURN
31 # define NORETURN(x) x
32 #endif
33 #ifndef DEPRECATED
34 # define DEPRECATED(x) x
35 #endif
36 #ifndef NOINLINE
37 # define NOINLINE(x) x
38 #endif
39 
40 #ifdef __GNUC__
41 #define PRINTF_ARGS(decl, string_index, first_to_check) \
42  decl __attribute__((format(printf, string_index, first_to_check)))
43 #else
44 #define PRINTF_ARGS(decl, string_index, first_to_check) decl
45 #endif
46 
47 #ifdef HAVE_STRING_H
48 # include <string.h>
49 #else
50 # include <strings.h>
51 #endif
52 
53 #ifdef HAVE_INTRINSICS_H
54 # include <intrinsics.h>
55 #endif
56 
57 #ifdef HAVE_STDINT_H
58 # include <stdint.h>
59 #endif
60 #ifdef HAVE_INTTYPES_H
61 # include <inttypes.h>
62 #endif
63 
64 #include <stdarg.h>
65 #include <stdio.h>
66 
67 #include "defines.h"
68 
69 #if defined __GNUC__ && __GNUC__ >= 4
70 #pragma GCC visibility push(default)
71 #endif
72 
73 #if defined(HAVE_ALLOCA_H)
74 #include <alloca.h>
75 #else
76 # ifdef _AIX
77 #pragma alloca
78 # endif
79 #endif
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) 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 SIZEOF_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 defined PRIdPTR && !defined PRI_VALUE_PREFIX
119 #define PRIdVALUE PRIdPTR
120 #define PRIiVALUE PRIiPTR
121 #define PRIoVALUE PRIoPTR
122 #define PRIuVALUE PRIuPTR
123 #define PRIxVALUE PRIxPTR
124 #define PRIXVALUE PRIXPTR
125 #else
126 #define PRIdVALUE PRI_VALUE_PREFIX"d"
127 #define PRIiVALUE PRI_VALUE_PREFIX"i"
128 #define PRIoVALUE PRI_VALUE_PREFIX"o"
129 #define PRIuVALUE PRI_VALUE_PREFIX"u"
130 #define PRIxVALUE PRI_VALUE_PREFIX"x"
131 #define PRIXVALUE PRI_VALUE_PREFIX"X"
132 #endif
133 #ifndef PRI_VALUE_PREFIX
134 # define PRI_VALUE_PREFIX ""
135 #endif
136 
137 #ifndef PRI_TIMET_PREFIX
138 # if SIZEOF_TIME_T == SIZEOF_INT
139 # define PRI_TIMET_PREFIX
140 # elif SIZEOF_TIME_T == SIZEOF_LONG
141 # define PRI_TIMET_PREFIX "l"
142 # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
143 # define PRI_TIMET_PREFIX PRI_LL_PREFIX
144 # endif
145 #endif
146 
147 #if defined PRI_PTRDIFF_PREFIX
148 #elif SIZEOF_PTRDIFF_T == SIZEOF_INT
149 # define PRI_PTRDIFF_PREFIX ""
150 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
151 # define PRI_PTRDIFF_PREFIX "l"
152 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
153 # define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX
154 #endif
155 #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
156 #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
157 #define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
158 #define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
159 #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
160 #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
161 
162 #if defined PRI_SIZE_PREFIX
163 #elif SIZEOF_SIZE_T == SIZEOF_INT
164 # define PRI_SIZE_PREFIX ""
165 #elif SIZEOF_SIZE_T == SIZEOF_LONG
166 # define PRI_SIZE_PREFIX "l"
167 #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG
168 # define PRI_SIZE_PREFIX PRI_LL_PREFIX
169 #endif
170 #define PRIdSIZE PRI_SIZE_PREFIX"d"
171 #define PRIiSIZE PRI_SIZE_PREFIX"i"
172 #define PRIoSIZE PRI_SIZE_PREFIX"o"
173 #define PRIuSIZE PRI_SIZE_PREFIX"u"
174 #define PRIxSIZE PRI_SIZE_PREFIX"x"
175 #define PRIXSIZE PRI_SIZE_PREFIX"X"
176 
177 #ifdef __STDC__
178 # include <limits.h>
179 #else
180 # ifndef LONG_MAX
181 # ifdef HAVE_LIMITS_H
182 # include <limits.h>
183 # else
184  /* assuming 32bit(2's compliment) long */
185 # define LONG_MAX 2147483647
186 # endif
187 # endif
188 # ifndef LONG_MIN
189 # define LONG_MIN (-LONG_MAX-1)
190 # endif
191 # ifndef CHAR_BIT
192 # define CHAR_BIT 8
193 # endif
194 #endif
195 
196 #ifdef HAVE_LONG_LONG
197 # ifndef LLONG_MAX
198 # ifdef LONG_LONG_MAX
199 # define LLONG_MAX LONG_LONG_MAX
200 # else
201 # ifdef _I64_MAX
202 # define LLONG_MAX _I64_MAX
203 # else
204  /* assuming 64bit(2's complement) long long */
205 # define LLONG_MAX 9223372036854775807LL
206 # endif
207 # endif
208 # endif
209 # ifndef LLONG_MIN
210 # ifdef LONG_LONG_MIN
211 # define LLONG_MIN LONG_LONG_MIN
212 # else
213 # ifdef _I64_MIN
214 # define LLONG_MIN _I64_MIN
215 # else
216 # define LLONG_MIN (-LLONG_MAX-1)
217 # endif
218 # endif
219 # endif
220 #endif
221 
222 #define FIXNUM_MAX (LONG_MAX>>1)
223 #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
224 
225 #define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG))
226 #define LONG2FIX(i) INT2FIX(i)
227 #define rb_fix_new(v) INT2FIX(v)
229 
230 #define rb_int_new(v) rb_int2inum(v)
232 
233 #define rb_uint_new(v) rb_uint2inum(v)
234 
235 #ifdef HAVE_LONG_LONG
236 VALUE rb_ll2inum(LONG_LONG);
237 #define LL2NUM(v) rb_ll2inum(v)
238 VALUE rb_ull2inum(unsigned LONG_LONG);
239 #define ULL2NUM(v) rb_ull2inum(v)
240 #endif
241 
242 #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
243 # define OFFT2NUM(v) LL2NUM(v)
244 #elif SIZEOF_OFF_T == SIZEOF_LONG
245 # define OFFT2NUM(v) LONG2NUM(v)
246 #else
247 # define OFFT2NUM(v) INT2NUM(v)
248 #endif
249 
250 #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
251 # define SIZET2NUM(v) ULL2NUM(v)
252 # define SSIZET2NUM(v) LL2NUM(v)
253 #elif SIZEOF_SIZE_T == SIZEOF_LONG
254 # define SIZET2NUM(v) ULONG2NUM(v)
255 # define SSIZET2NUM(v) LONG2NUM(v)
256 #else
257 # define SIZET2NUM(v) UINT2NUM(v)
258 # define SSIZET2NUM(v) INT2NUM(v)
259 #endif
260 
261 #ifndef SIZE_MAX
262 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
263 # define SIZE_MAX ULLONG_MAX
264 # define SIZE_MIN ULLONG_MIN
265 # elif SIZEOF_SIZE_T == SIZEOF_LONG
266 # define SIZE_MAX ULONG_MAX
267 # define SIZE_MIN ULONG_MIN
268 # elif SIZEOF_SIZE_T == SIZEOF_INT
269 # define SIZE_MAX UINT_MAX
270 # define SIZE_MIN UINT_MIN
271 # else
272 # define SIZE_MAX USHRT_MAX
273 # define SIZE_MIN USHRT_MIN
274 # endif
275 #endif
276 
277 #ifndef SSIZE_MAX
278 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
279 # define SSIZE_MAX LLONG_MAX
280 # define SSIZE_MIN LLONG_MIN
281 # elif SIZEOF_SIZE_T == SIZEOF_LONG
282 # define SSIZE_MAX LONG_MAX
283 # define SSIZE_MIN LONG_MIN
284 # elif SIZEOF_SIZE_T == SIZEOF_INT
285 # define SSIZE_MAX INT_MAX
286 # define SSIZE_MIN INT_MIN
287 # else
288 # define SSIZE_MAX SHRT_MAX
289 # define SSIZE_MIN SHRT_MIN
290 # endif
291 #endif
292 
293 #if SIZEOF_INT < SIZEOF_VALUE
294 NORETURN(void rb_out_of_int(SIGNED_VALUE num));
295 #endif
296 
297 #if SIZEOF_INT < SIZEOF_LONG
298 #define rb_long2int_internal(n, i) \
299  int (i) = (int)(n); \
300  if ((long)(i) != (n)) rb_out_of_int(n)
301 #ifdef __GNUC__
302 #define rb_long2int(n) __extension__ ({long i2l_n = (n); rb_long2int_internal(i2l_n, i2l_i); i2l_i;})
303 #else
304 static inline int
305 rb_long2int(long n) {rb_long2int_internal(n, i); return i;}
306 #endif
307 #else
308 #define rb_long2int(n) ((int)(n))
309 #endif
310 
311 #ifndef PIDT2NUM
312 #define PIDT2NUM(v) LONG2NUM(v)
313 #endif
314 #ifndef NUM2PIDT
315 #define NUM2PIDT(v) NUM2LONG(v)
316 #endif
317 #ifndef UIDT2NUM
318 #define UIDT2NUM(v) LONG2NUM(v)
319 #endif
320 #ifndef NUM2UIDT
321 #define NUM2UIDT(v) NUM2LONG(v)
322 #endif
323 #ifndef GIDT2NUM
324 #define GIDT2NUM(v) LONG2NUM(v)
325 #endif
326 #ifndef NUM2GIDT
327 #define NUM2GIDT(v) NUM2LONG(v)
328 #endif
329 #ifndef NUM2MODET
330 #define NUM2MODET(v) NUM2INT(v)
331 #endif
332 #ifndef MODET2NUM
333 #define MODET2NUM(v) INT2NUM(v)
334 #endif
335 
336 #define FIX2LONG(x) (long)RSHIFT((SIGNED_VALUE)(x),1)
337 #define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX)
338 #define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG)
339 #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
340 #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
341 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
342 
343 #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
344 
345 #define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG)
346 #define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
347 #define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT)
348 
349 /* Module#methods, #singleton_methods and so on return Symbols */
350 #define USE_SYMBOL_AS_METHOD_NAME 1
351 
352 /* special constants - i.e. non-zero and non-fixnum constants */
358 
363 };
364 
365 #define Qfalse ((VALUE)RUBY_Qfalse)
366 #define Qtrue ((VALUE)RUBY_Qtrue)
367 #define Qnil ((VALUE)RUBY_Qnil)
368 #define Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */
369 #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
370 #define FIXNUM_FLAG RUBY_FIXNUM_FLAG
371 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
372 
373 #define RTEST(v) (((VALUE)(v) & ~Qnil) != 0)
374 #define NIL_P(v) ((VALUE)(v) == Qnil)
375 
376 #define CLASS_OF(v) rb_class_of((VALUE)(v))
377 
379  RUBY_T_NONE = 0x00,
380 
382  RUBY_T_CLASS = 0x02,
384  RUBY_T_FLOAT = 0x04,
387  RUBY_T_ARRAY = 0x07,
388  RUBY_T_HASH = 0x08,
391  RUBY_T_FILE = 0x0b,
392  RUBY_T_DATA = 0x0c,
393  RUBY_T_MATCH = 0x0d,
396 
397  RUBY_T_NIL = 0x11,
398  RUBY_T_TRUE = 0x12,
399  RUBY_T_FALSE = 0x13,
402 
403  RUBY_T_UNDEF = 0x1b,
404  RUBY_T_NODE = 0x1c,
407 
408  RUBY_T_MASK = 0x1f
409 };
410 
411 #define T_NONE RUBY_T_NONE
412 #define T_NIL RUBY_T_NIL
413 #define T_OBJECT RUBY_T_OBJECT
414 #define T_CLASS RUBY_T_CLASS
415 #define T_ICLASS RUBY_T_ICLASS
416 #define T_MODULE RUBY_T_MODULE
417 #define T_FLOAT RUBY_T_FLOAT
418 #define T_STRING RUBY_T_STRING
419 #define T_REGEXP RUBY_T_REGEXP
420 #define T_ARRAY RUBY_T_ARRAY
421 #define T_HASH RUBY_T_HASH
422 #define T_STRUCT RUBY_T_STRUCT
423 #define T_BIGNUM RUBY_T_BIGNUM
424 #define T_FILE RUBY_T_FILE
425 #define T_FIXNUM RUBY_T_FIXNUM
426 #define T_TRUE RUBY_T_TRUE
427 #define T_FALSE RUBY_T_FALSE
428 #define T_DATA RUBY_T_DATA
429 #define T_MATCH RUBY_T_MATCH
430 #define T_SYMBOL RUBY_T_SYMBOL
431 #define T_RATIONAL RUBY_T_RATIONAL
432 #define T_COMPLEX RUBY_T_COMPLEX
433 #define T_UNDEF RUBY_T_UNDEF
434 #define T_NODE RUBY_T_NODE
435 #define T_ZOMBIE RUBY_T_ZOMBIE
436 #define T_MASK RUBY_T_MASK
437 
438 #define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK)
439 
440 static inline int rb_type(VALUE obj);
441 #define TYPE(x) rb_type((VALUE)(x))
442 
443 #ifdef __GNUC__
444 #define RB_GC_GUARD_PTR(ptr) \
445  __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
446 #else
447 #ifdef _MSC_VER
448 #pragma optimize("", off)
449 #endif
450 static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
451 #ifdef _MSC_VER
452 #pragma optimize("", on)
453 #endif
454 #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
455 #endif
456 #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
457 
458 void rb_check_type(VALUE,int);
459 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
460 
462 VALUE rb_string_value(volatile VALUE*);
463 char *rb_string_value_ptr(volatile VALUE*);
464 char *rb_string_value_cstr(volatile VALUE*);
465 
466 #define StringValue(v) rb_string_value(&(v))
467 #define StringValuePtr(v) rb_string_value_ptr(&(v))
468 #define StringValueCStr(v) rb_string_value_cstr(&(v))
469 
472 #define SafeStringValue(v) do {\
473  StringValue(v);\
474  rb_check_safe_obj(v);\
475 } while (0)
476 /* obsolete macro - use SafeStringValue(v) */
477 #define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
478 
480 #define ExportStringValue(v) do {\
481  SafeStringValue(v);\
482  (v) = rb_str_export(v);\
483 } while (0)
485 
487 #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
488 
490 #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
491 
492 void rb_secure(int);
493 int rb_safe_level(void);
494 void rb_set_safe_level(int);
495 void rb_set_safe_level_force(int);
496 void rb_secure_update(VALUE);
497 NORETURN(void rb_insecure_operation(void));
498 
499 VALUE rb_errinfo(void);
500 void rb_set_errinfo(VALUE);
501 
504 #define NUM2LONG_internal(x) ((long)(FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)))
505 #ifdef __GNUC__
506 #define NUM2LONG(x) \
507  __extension__ ({VALUE num2long_x = (x); NUM2LONG_internal(num2long_x);})
508 #else
509 static inline long
511 {
512  return NUM2LONG_internal(x);
513 }
514 #endif
515 #define NUM2ULONG(x) rb_num2ulong((VALUE)(x))
516 #if SIZEOF_INT < SIZEOF_LONG
517 long rb_num2int(VALUE);
518 long rb_fix2int(VALUE);
519 #define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
520 #define NUM2INT_internal(x) (FIXNUM_P(x) ? FIX2INT(x) : (int)rb_num2int(x))
521 #ifdef __GNUC__
522 #define NUM2INT(x) \
523  __extension__ ({VALUE num2int_x = (x); NUM2INT_internal(num2int_x);})
524 #else
525 static inline int
526 NUM2INT(VALUE x)
527 {
528  return NUM2INT_internal(x);
529 }
530 #endif
531 unsigned long rb_num2uint(VALUE);
532 #define NUM2UINT(x) ((unsigned int)rb_num2uint(x))
533 unsigned long rb_fix2uint(VALUE);
534 #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
535 #else
536 #define NUM2INT(x) ((int)NUM2LONG(x))
537 #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
538 #define FIX2INT(x) ((int)FIX2LONG(x))
539 #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
540 #endif
541 
542 #ifdef HAVE_LONG_LONG
543 LONG_LONG rb_num2ll(VALUE);
544 unsigned LONG_LONG rb_num2ull(VALUE);
545 # define NUM2LL_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2ll(x))
546 # ifdef __GNUC__
547 # define NUM2LL(x) \
548  __extension__ ({VALUE num2ll_x = (x); NUM2LL_internal(num2ll_x);})
549 # else
550 static inline LONG_LONG
551 NUM2LL(VALUE x)
552 {
553  return NUM2LL_internal(x);
554 }
555 # endif
556 # define NUM2ULL(x) rb_num2ull((VALUE)(x))
557 #endif
558 
559 #if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
560 # define NUM2OFFT(x) ((off_t)NUM2LL(x))
561 #else
562 # define NUM2OFFT(x) NUM2LONG(x)
563 #endif
564 
565 #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
566 # define NUM2SIZET(x) ((size_t)NUM2ULL(x))
567 # define NUM2SSIZET(x) ((size_t)NUM2LL(x))
568 #else
569 # define NUM2SIZET(x) NUM2ULONG(x)
570 # define NUM2SSIZET(x) NUM2LONG(x)
571 #endif
572 
573 double rb_num2dbl(VALUE);
574 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
575 
578 
579 VALUE rb_newobj(void);
580 #define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
581 #define OBJSETUP(obj,c,t) do {\
582  RBASIC(obj)->flags = (t);\
583  RBASIC(obj)->klass = (c);\
584  if (rb_safe_level() >= 3) FL_SET((obj), FL_TAINT | FL_UNTRUSTED);\
585 } while (0)
586 #define CLONESETUP(clone,obj) do {\
587  OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\
588  rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\
589  if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\
590 } while (0)
591 #define DUPSETUP(dup,obj) do {\
592  OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \
593  if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\
594 } while (0)
595 
596 struct RBasic {
599 };
600 
601 #define ROBJECT_EMBED_LEN_MAX 3
602 struct RObject {
603  struct RBasic basic;
604  union {
605  struct {
606  long numiv;
608  struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
609  } heap;
611  } as;
612 };
613 #define ROBJECT_EMBED FL_USER1
614 #define ROBJECT_NUMIV(o) \
615  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
616  ROBJECT_EMBED_LEN_MAX : \
617  ROBJECT(o)->as.heap.numiv)
618 #define ROBJECT_IVPTR(o) \
619  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
620  ROBJECT(o)->as.ary : \
621  ROBJECT(o)->as.heap.ivptr)
622 #define ROBJECT_IV_INDEX_TBL(o) \
623  ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
624  RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
625  ROBJECT(o)->as.heap.iv_index_tbl)
626 
629 
630 struct RClass {
631  struct RBasic basic;
633  struct st_table *m_tbl;
635 };
636 #define RCLASS_SUPER(c) rb_class_get_superclass(c)
637 #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
638 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
639 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
640 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
641 
642 struct RFloat {
643  struct RBasic basic;
644  double float_value;
645 };
646 #define RFLOAT_VALUE(v) (RFLOAT(v)->float_value)
647 #define DBL2NUM(dbl) rb_float_new(dbl)
648 
649 #define ELTS_SHARED FL_USER2
650 
651 #define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1))
652 struct RString {
653  struct RBasic basic;
654  union {
655  struct {
656  long len;
657  char *ptr;
658  union {
659  long capa;
661  } aux;
662  } heap;
664  } as;
665 };
666 #define RSTRING_NOEMBED FL_USER1
667 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6)
668 #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
669 #define RSTRING_EMBED_LEN(str) \
670  (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
671  (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
672 #define RSTRING_LEN(str) \
673  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
674  RSTRING_EMBED_LEN(str) : \
675  RSTRING(str)->as.heap.len)
676 #define RSTRING_PTR(str) \
677  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
678  RSTRING(str)->as.ary : \
679  RSTRING(str)->as.heap.ptr)
680 #define RSTRING_END(str) \
681  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
682  (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
683  (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
684 #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
685 #define RSTRING_GETMEM(str, ptrvar, lenvar) \
686  (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
687  ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
688  ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
689 
690 #define RARRAY_EMBED_LEN_MAX 3
691 struct RArray {
692  struct RBasic basic;
693  union {
694  struct {
695  long len;
696  union {
697  long capa;
699  } aux;
701  } heap;
703  } as;
704 };
705 #define RARRAY_EMBED_FLAG FL_USER1
706 /* FL_USER2 is for ELTS_SHARED */
707 #define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3)
708 #define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3)
709 #define RARRAY_LEN(a) \
710  ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
711  (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
712  (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
713  RARRAY(a)->as.heap.len)
714 #define RARRAY_PTR(a) \
715  ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
716  RARRAY(a)->as.ary : \
717  RARRAY(a)->as.heap.ptr)
718 #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
719 
720 struct RRegexp {
721  struct RBasic basic;
724  unsigned long usecnt;
725 };
726 #define RREGEXP_SRC(r) RREGEXP(r)->src
727 #define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
728 #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
729 #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
730 
731 struct RHash {
732  struct RBasic basic;
733  struct st_table *ntbl; /* possibly 0 */
734  int iter_lev;
736 };
737 /* RHASH_TBL allocates st_table if not available. */
738 #define RHASH_TBL(h) rb_hash_tbl(h)
739 #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
740 #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
741 #define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0)
742 #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
743 
744 struct RFile {
745  struct RBasic basic;
746  struct rb_io_t *fptr;
747 };
748 
749 struct RRational {
750  struct RBasic basic;
753 };
754 
755 struct RComplex {
756  struct RBasic basic;
759 };
760 
761 struct RData {
762  struct RBasic basic;
763  void (*dmark)(void*);
764  void (*dfree)(void*);
765  void *data;
766 };
767 
769 
771  const char *wrap_struct_name;
772  struct {
773  void (*dmark)(void*);
774  void (*dfree)(void*);
775  size_t (*dsize)(const void *);
776  void *reserved[2]; /* For future extension.
777  This array *must* be filled with ZERO. */
778  } function;
780  void *data; /* This area can be used for any purpose
781  by a programmer who define the type. */
782 };
783 
784 #define HAVE_TYPE_RB_DATA_TYPE_T 1
785 #define HAVE_RB_DATA_TYPE_T_FUNCTION 1
786 #define HAVE_RB_DATA_TYPE_T_PARENT 1
787 
788 struct RTypedData {
789  struct RBasic basic;
791  VALUE typed_flag; /* 1 or not */
792  void *data;
793 };
794 
795 #define DATA_PTR(dta) (RDATA(dta)->data)
796 
797 #define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1)
798 #define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
799 #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
800 
801 /*
802 #define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
803 */
804 typedef void (*RUBY_DATA_FUNC)(void*);
805 
808 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
810 void *rb_check_typeddata(VALUE, const rb_data_type_t *);
811 #define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
812 #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
813 #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0)
814 #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
815 #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE
816 
817 #define Data_Wrap_Struct(klass,mark,free,sval)\
818  rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
819 
820 #define Data_Make_Struct(klass,type,mark,free,sval) (\
821  (sval) = ALLOC(type),\
822  memset((sval), 0, sizeof(type)),\
823  Data_Wrap_Struct((klass),(mark),(free),(sval))\
824 )
825 
826 #define TypedData_Wrap_Struct(klass,data_type,sval)\
827  rb_data_typed_object_alloc((klass),(sval),(data_type))
828 
829 #define TypedData_Make_Struct(klass, type, data_type, sval) (\
830  (sval) = ALLOC(type),\
831  memset((sval), 0, sizeof(type)),\
832  TypedData_Wrap_Struct((klass),(data_type),(sval))\
833 )
834 
835 #define Data_Get_Struct(obj,type,sval) do {\
836  Check_Type((obj), T_DATA); \
837  (sval) = (type*)DATA_PTR(obj);\
838 } while (0)
839 
840 #define TypedData_Get_Struct(obj,type,data_type,sval) do {\
841  (sval) = (type*)rb_check_typeddata((obj), (data_type)); \
842 } while (0)
843 
844 #define RSTRUCT_EMBED_LEN_MAX 3
845 struct RStruct {
846  struct RBasic basic;
847  union {
848  struct {
849  long len;
851  } heap;
853  } as;
854 };
855 #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1)
856 #define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
857 #define RSTRUCT_LEN(st) \
858  ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
859  (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
860  (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
861  RSTRUCT(st)->as.heap.len)
862 #define RSTRUCT_PTR(st) \
863  ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
864  RSTRUCT(st)->as.ary : \
865  RSTRUCT(st)->as.heap.ptr)
866 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
867 
868 #define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT)))
869 struct RBignum {
870  struct RBasic basic;
871  union {
872  struct {
873  long len;
875  } heap;
877  } as;
878 };
879 #define RBIGNUM_SIGN_BIT FL_USER1
880 /* sign: positive:1, negative:0 */
881 #define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0)
882 #define RBIGNUM_SET_SIGN(b,sign) \
883  ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \
884  : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT))
885 #define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b)
886 #define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b))
887 
888 #define RBIGNUM_EMBED_FLAG FL_USER2
889 #define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
890 #define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3)
891 #define RBIGNUM_LEN(b) \
892  ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
893  (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \
894  (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \
895  RBIGNUM(b)->as.heap.len)
896 /* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */
897 #define RBIGNUM_DIGITS(b) \
898  ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
899  RBIGNUM(b)->as.ary : \
900  RBIGNUM(b)->as.heap.digits)
901 #define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b))
902 
903 #define R_CAST(st) (struct st*)
904 #define RBASIC(obj) (R_CAST(RBasic)(obj))
905 #define ROBJECT(obj) (R_CAST(RObject)(obj))
906 #define RCLASS(obj) (R_CAST(RClass)(obj))
907 #define RMODULE(obj) RCLASS(obj)
908 #define RFLOAT(obj) (R_CAST(RFloat)(obj))
909 #define RSTRING(obj) (R_CAST(RString)(obj))
910 #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
911 #define RARRAY(obj) (R_CAST(RArray)(obj))
912 #define RHASH(obj) (R_CAST(RHash)(obj))
913 #define RDATA(obj) (R_CAST(RData)(obj))
914 #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj))
915 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
916 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
917 #define RFILE(obj) (R_CAST(RFile)(obj))
918 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
919 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
920 
921 #define FL_SINGLETON FL_USER0
922 #define FL_MARK (((VALUE)1)<<5)
923 #define FL_RESERVED (((VALUE)1)<<6) /* will be used in the future GC */
924 #define FL_FINALIZE (((VALUE)1)<<7)
925 #define FL_TAINT (((VALUE)1)<<8)
926 #define FL_UNTRUSTED (((VALUE)1)<<9)
927 #define FL_EXIVAR (((VALUE)1)<<10)
928 #define FL_FREEZE (((VALUE)1)<<11)
929 
930 #define FL_USHIFT 12
931 
932 #define FL_USER0 (((VALUE)1)<<(FL_USHIFT+0))
933 #define FL_USER1 (((VALUE)1)<<(FL_USHIFT+1))
934 #define FL_USER2 (((VALUE)1)<<(FL_USHIFT+2))
935 #define FL_USER3 (((VALUE)1)<<(FL_USHIFT+3))
936 #define FL_USER4 (((VALUE)1)<<(FL_USHIFT+4))
937 #define FL_USER5 (((VALUE)1)<<(FL_USHIFT+5))
938 #define FL_USER6 (((VALUE)1)<<(FL_USHIFT+6))
939 #define FL_USER7 (((VALUE)1)<<(FL_USHIFT+7))
940 #define FL_USER8 (((VALUE)1)<<(FL_USHIFT+8))
941 #define FL_USER9 (((VALUE)1)<<(FL_USHIFT+9))
942 #define FL_USER10 (((VALUE)1)<<(FL_USHIFT+10))
943 #define FL_USER11 (((VALUE)1)<<(FL_USHIFT+11))
944 #define FL_USER12 (((VALUE)1)<<(FL_USHIFT+12))
945 #define FL_USER13 (((VALUE)1)<<(FL_USHIFT+13))
946 #define FL_USER14 (((VALUE)1)<<(FL_USHIFT+14))
947 #define FL_USER15 (((VALUE)1)<<(FL_USHIFT+15))
948 #define FL_USER16 (((VALUE)1)<<(FL_USHIFT+16))
949 #define FL_USER17 (((VALUE)1)<<(FL_USHIFT+17))
950 #define FL_USER18 (((VALUE)1)<<(FL_USHIFT+18))
951 #define FL_USER19 (((VALUE)1)<<(FL_USHIFT+19))
952 
953 #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
954 
955 #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
956 #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
957 #define FL_ANY(x,f) FL_TEST((x),(f))
958 #define FL_ALL(x,f) (FL_TEST((x),(f)) == (f))
959 #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
960 #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
961 #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
962 
963 #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT))
964 #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
965 #define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED))
966 #define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED)
967 #define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & (FL_TAINT | FL_UNTRUSTED);} while (0)
968 
969 #define OBJ_FROZEN(x) (!!FL_TEST((x), FL_FREEZE))
970 #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
971 
972 #if SIZEOF_INT < SIZEOF_LONG
973 # define INT2NUM(v) INT2FIX((int)(v))
974 # define UINT2NUM(v) LONG2FIX((unsigned int)(v))
975 #else
976 # define INT2NUM_internal(v) (FIXABLE(v) ? INT2FIX(v) : rb_int2big(v))
977 # ifdef __GNUC__
978 # define INT2NUM(v) __extension__ ({int int2num_v = (v); INT2NUM_internal(int2num_v);})
979 # else
980 static inline VALUE
981 INT2NUM(int v)
982 {
983  return INT2NUM_internal(v);
984 }
985 # endif
986 
987 # define UINT2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v))
988 # ifdef __GNUC__
989 # define UINT2NUM(v) __extension__ ({unsigned int uint2num_v = (v); UINT2NUM_internal(uint2num_v);})
990 # else
991 static inline VALUE
992 UINT2NUM(unsigned int v)
993 {
994  return UINT2NUM_internal(v);
995 }
996 # endif
997 #endif
998 
999 #define LONG2NUM_internal(v) (FIXABLE(v) ? LONG2FIX(v) : rb_int2big(v))
1000 #ifdef __GNUC__
1001 # define LONG2NUM(v) __extension__ ({long long2num_v = (v); LONG2NUM_internal(long2num_v);})
1002 #else
1003 static inline VALUE
1005 {
1006  return LONG2NUM_internal(v);
1007 }
1008 #endif
1009 
1010 #define ULONG2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v))
1011 #ifdef __GNUC__
1012 # define ULONG2NUM(v) __extension__ ({unsigned long ulong2num_v = (v); ULONG2NUM_internal(ulong2num_v);})
1013 #else
1014 static inline VALUE
1015 ULONG2NUM(unsigned long v)
1016 {
1017  return ULONG2NUM_internal(v);
1018 }
1019 #endif
1020 
1021 #define NUM2CHR_internal(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\
1022  RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff))
1023 #ifdef __GNUC__
1024 # define NUM2CHR(x) __extension__ ({VALUE num2chr_x = (x); NUM2CHR_internal(num2chr_x);})
1025 #else
1026 static inline char
1028 {
1029  return NUM2CHR_internal(x);
1030 }
1031 #endif
1032 #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
1033 
1034 #define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))
1035 #define ALLOC(type) ((type*)xmalloc(sizeof(type)))
1036 #define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))
1037 
1038 #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
1039 
1040 void *rb_alloc_tmp_buffer(volatile VALUE *store, long len);
1041 void rb_free_tmp_buffer(volatile VALUE *store);
1042 /* allocates _n_ bytes temporary buffer and stores VALUE including it
1043  * in _v_. _n_ may be evaluated twice. */
1044 #ifdef C_ALLOCA
1045 # define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
1046 #else
1047 # define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
1048 #endif
1049 #define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))
1050 #define ALLOCV_END(v) rb_free_tmp_buffer(&(v))
1051 
1052 #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
1053 #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
1054 #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
1055 #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
1056 
1057 void rb_obj_infect(VALUE,VALUE);
1058 
1059 typedef int ruby_glob_func(const char*,VALUE, void*);
1060 void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
1061 int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
1062 int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
1063 
1064 VALUE rb_define_class(const char*,VALUE);
1065 VALUE rb_define_module(const char*);
1066 VALUE rb_define_class_under(VALUE, const char*, VALUE);
1067 VALUE rb_define_module_under(VALUE, const char*);
1068 
1071 
1072 struct rb_global_variable;
1073 
1074 typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
1075 typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1076 typedef void rb_gvar_marker_t(VALUE *var);
1077 
1078 VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
1079 void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1080 void rb_gvar_undef_marker(VALUE *var);
1081 
1082 VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
1083 void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1084 void rb_gvar_val_marker(VALUE *var);
1085 
1086 VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
1087 void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1088 void rb_gvar_var_marker(VALUE *var);
1089 
1090 void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1091 
1092 void rb_define_variable(const char*,VALUE*);
1093 void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1094 void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1095 void rb_define_readonly_variable(const char*,VALUE*);
1096 void rb_define_const(VALUE,const char*,VALUE);
1097 void rb_define_global_const(const char*,VALUE);
1098 
1099 #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
1100 void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
1101 void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
1102 void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
1103 
1104 void rb_undef_method(VALUE,const char*);
1105 void rb_define_alias(VALUE,const char*,const char*);
1106 void rb_define_attr(VALUE,const char*,int,int);
1107 
1108 void rb_global_variable(VALUE*);
1112 
1113 ID rb_intern(const char*);
1114 ID rb_intern2(const char*, long);
1115 ID rb_intern_str(VALUE str);
1116 const char *rb_id2name(ID);
1117 ID rb_to_id(VALUE);
1118 VALUE rb_id2str(ID);
1119 
1120 #define CONST_ID_CACHE(result, str) \
1121  { \
1122  static ID rb_intern_id_cache; \
1123  if (!rb_intern_id_cache) \
1124  rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
1125  result rb_intern_id_cache; \
1126  }
1127 #define CONST_ID(var, str) \
1128  do CONST_ID_CACHE((var) =, (str)) while (0)
1129 #ifdef __GNUC__
1130 /* __builtin_constant_p and statement expression is available
1131  * since gcc-2.7.2.3 at least. */
1132 #define rb_intern(str) \
1133  (__builtin_constant_p(str) ? \
1134  __extension__ (CONST_ID_CACHE((ID), (str))) : \
1135  rb_intern(str))
1136 #define rb_intern_const(str) \
1137  (__builtin_constant_p(str) ? \
1138  __extension__ (rb_intern2((str), (long)strlen(str))) : \
1139  (rb_intern)(str))
1140 #else
1141 #define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
1142 #endif
1143 
1144 const char *rb_class2name(VALUE);
1145 const char *rb_obj_classname(VALUE);
1146 
1147 void rb_p(VALUE);
1148 
1149 VALUE rb_eval_string(const char*);
1150 VALUE rb_eval_string_protect(const char*, int*);
1151 VALUE rb_eval_string_wrap(const char*, int*);
1152 VALUE rb_funcall(VALUE, ID, int, ...);
1153 VALUE rb_funcall2(VALUE, ID, int, const VALUE*);
1154 VALUE rb_funcall3(VALUE, ID, int, const VALUE*);
1156 VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE);
1157 int rb_scan_args(int, const VALUE*, const char*, ...);
1158 VALUE rb_call_super(int, const VALUE*);
1159 
1160 VALUE rb_gv_set(const char*, VALUE);
1161 VALUE rb_gv_get(const char*);
1162 VALUE rb_iv_get(VALUE, const char*);
1163 VALUE rb_iv_set(VALUE, const char*, VALUE);
1164 
1166 
1167 VALUE *rb_ruby_verbose_ptr(void);
1168 VALUE *rb_ruby_debug_ptr(void);
1169 #define ruby_verbose (*rb_ruby_verbose_ptr())
1170 #define ruby_debug (*rb_ruby_debug_ptr())
1171 
1172 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
1173 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
1174 PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
1175 NORETURN(void rb_bug_errno(const char*, int));
1176 NORETURN(void rb_sys_fail(const char*));
1178 NORETURN(void rb_mod_sys_fail(VALUE, const char*));
1180 NORETURN(void rb_iter_break(void));
1181 NORETURN(void rb_exit(int));
1182 NORETURN(void rb_notimplement(void));
1183 VALUE rb_syserr_new(int, const char *);
1185 NORETURN(void rb_syserr_fail(int, const char*));
1186 NORETURN(void rb_syserr_fail_str(int, VALUE));
1187 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
1189 
1190 /* reports if `-W' specified */
1191 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
1192 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
1193 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
1194 /* reports always */
1195 PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
1196 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
1197 
1199 
1202 VALUE rb_yield_values(int n, ...);
1203 VALUE rb_yield_values2(int n, const VALUE *argv);
1205 int rb_block_given_p(void);
1206 void rb_need_block(void);
1212 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
1214 NORETURN(void rb_throw(const char*,VALUE));
1216 
1217 VALUE rb_require(const char*);
1218 
1219 #ifdef __ia64
1220 void ruby_init_stack(volatile VALUE*, void*);
1221 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
1222 #else
1223 void ruby_init_stack(volatile VALUE*);
1224 #endif
1225 #define RUBY_INIT_STACK \
1226  VALUE variable_in_this_stack_frame; \
1227  ruby_init_stack(&variable_in_this_stack_frame);
1228 void ruby_init(void);
1229 void *ruby_options(int, char**);
1230 int ruby_run_node(void *);
1231 int ruby_exec_node(void *);
1232 int ruby_executable_node(void *n, int *status);
1233 
1244 
1283 
1312 
1317 
1319 
1321 
1322 static inline VALUE
1324 {
1325  if (IMMEDIATE_P(obj)) {
1326  if (FIXNUM_P(obj)) return rb_cFixnum;
1327  if (obj == Qtrue) return rb_cTrueClass;
1328  if (SYMBOL_P(obj)) return rb_cSymbol;
1329  }
1330  else if (!RTEST(obj)) {
1331  if (obj == Qnil) return rb_cNilClass;
1332  if (obj == Qfalse) return rb_cFalseClass;
1333  }
1334  return RBASIC(obj)->klass;
1335 }
1336 
1337 static inline int
1339 {
1340  if (IMMEDIATE_P(obj)) {
1341  if (FIXNUM_P(obj)) return T_FIXNUM;
1342  if (obj == Qtrue) return T_TRUE;
1343  if (SYMBOL_P(obj)) return T_SYMBOL;
1344  if (obj == Qundef) return T_UNDEF;
1345  }
1346  else if (!RTEST(obj)) {
1347  if (obj == Qnil) return T_NIL;
1348  if (obj == Qfalse) return T_FALSE;
1349  }
1350  return BUILTIN_TYPE(obj);
1351 }
1352 
1353 #define RB_TYPE_P(obj, type) ( \
1354  ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
1355  ((type) == T_TRUE) ? ((obj) == Qtrue) : \
1356  ((type) == T_FALSE) ? ((obj) == Qfalse) : \
1357  ((type) == T_NIL) ? ((obj) == Qnil) : \
1358  ((type) == T_UNDEF) ? ((obj) == Qundef) : \
1359  ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
1360  (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
1361 
1362 #ifdef __GNUC__
1363 #define rb_type_p(obj, type) \
1364  __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
1365  rb_type(obj) == (type))
1366 #else
1367 #define rb_type_p(obj, type) (rb_type(obj) == (type))
1368 #endif
1369 
1370 #ifdef __GNUC__
1371 #define rb_special_const_p(obj) \
1372  __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);})
1373 #else
1374 static inline int
1376 {
1377  if (SPECIAL_CONST_P(obj)) return (int)Qtrue;
1378  return (int)Qfalse;
1379 }
1380 #endif
1381 
1382 #include "ruby/missing.h"
1383 #include "ruby/intern.h"
1384 
1385 #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
1386 /* hook for external modules */
1387 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
1388 #endif
1389 
1390 #if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__)
1391 #define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */
1392 #else
1393 #define RUBY_GLOBAL_SETUP
1394 #endif
1395 
1396 void ruby_sysinit(int *, char ***);
1397 
1398 #define RUBY_VM 1 /* YARV */
1399 #define HAVE_NATIVETHREAD
1400 int ruby_native_thread_p(void);
1401 
1402 #define RUBY_EVENT_NONE 0x0000
1403 #define RUBY_EVENT_LINE 0x0001
1404 #define RUBY_EVENT_CLASS 0x0002
1405 #define RUBY_EVENT_END 0x0004
1406 #define RUBY_EVENT_CALL 0x0008
1407 #define RUBY_EVENT_RETURN 0x0010
1408 #define RUBY_EVENT_C_CALL 0x0020
1409 #define RUBY_EVENT_C_RETURN 0x0040
1410 #define RUBY_EVENT_RAISE 0x0080
1411 #define RUBY_EVENT_ALL 0xffff
1412 #define RUBY_EVENT_VM 0x10000
1413 #define RUBY_EVENT_SWITCH 0x20000
1414 #define RUBY_EVENT_COVERAGE 0x40000
1415 
1416 typedef unsigned int rb_event_flag_t;
1417 typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass);
1418 
1419 typedef struct rb_event_hook_struct {
1420  rb_event_flag_t flag;
1422  VALUE data;
1424 } rb_event_hook_t;
1425 
1426 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
1427 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events,
1428  VALUE data);
1430 
1431 /* locale insensitive functions */
1432 
1433 #define rb_isascii(c) ((unsigned long)(c) < 128)
1434 int rb_isalnum(int c);
1435 int rb_isalpha(int c);
1436 int rb_isblank(int c);
1437 int rb_iscntrl(int c);
1438 int rb_isdigit(int c);
1439 int rb_isgraph(int c);
1440 int rb_islower(int c);
1441 int rb_isprint(int c);
1442 int rb_ispunct(int c);
1443 int rb_isspace(int c);
1444 int rb_isupper(int c);
1445 int rb_isxdigit(int c);
1446 int rb_tolower(int c);
1447 int rb_toupper(int c);
1448 
1449 #ifndef ISPRINT
1450 #define ISASCII(c) rb_isascii((unsigned char)(c))
1451 #undef ISPRINT
1452 #define ISPRINT(c) rb_isprint((unsigned char)(c))
1453 #define ISSPACE(c) rb_isspace((unsigned char)(c))
1454 #define ISUPPER(c) rb_isupper((unsigned char)(c))
1455 #define ISLOWER(c) rb_islower((unsigned char)(c))
1456 #define ISALNUM(c) rb_isalnum((unsigned char)(c))
1457 #define ISALPHA(c) rb_isalpha((unsigned char)(c))
1458 #define ISDIGIT(c) rb_isdigit((unsigned char)(c))
1459 #define ISXDIGIT(c) rb_isxdigit((unsigned char)(c))
1460 #endif
1461 #define TOUPPER(c) rb_toupper((unsigned char)(c))
1462 #define TOLOWER(c) rb_tolower((unsigned char)(c))
1463 
1464 int st_strcasecmp(const char *s1, const char *s2);
1465 int st_strncasecmp(const char *s1, const char *s2, size_t n);
1466 #define STRCASECMP(s1, s2) (st_strcasecmp((s1), (s2)))
1467 #define STRNCASECMP(s1, s2, n) (st_strncasecmp((s1), (s2), (n)))
1468 
1469 unsigned long ruby_strtoul(const char *str, char **endptr, int base);
1470 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
1471 
1472 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
1473 
1474 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
1475 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
1476 
1477 #if defined __GNUC__ && __GNUC__ >= 4
1478 #pragma GCC visibility pop
1479 #endif
1480 
1481 #ifndef RUBY_DONT_SUBST
1482 #include "ruby/subst.h"
1483 #endif
1484 
1485 #if defined(__cplusplus)
1486 #if 0
1487 { /* satisfy cc-mode */
1488 #endif
1489 } /* extern "C" { */
1490 #endif
1491 #endif /* RUBY_RUBY_H */
1492