001
002
003
004
005
006
007
008
009
010
011
012
013
014 #ifndef RUBY_RUBY_H
015 #define RUBY_RUBY_H 1
016
017 #if defined(__cplusplus)
018 extern "C" {
019 #if 0
020 }
021 #endif
022 #endif
023
024 #include "ruby/config.h"
025 #ifdef RUBY_EXTCONF_H
026 #include RUBY_EXTCONF_H
027 #endif
028
029 #include "defines.h"
030
031 #define NORETURN_STYLE_NEW 1
032 #ifndef NORETURN
033 # define NORETURN(x) x
034 #endif
035 #ifndef DEPRECATED
036 # define DEPRECATED(x) x
037 #endif
038 #ifndef NOINLINE
039 # define NOINLINE(x) x
040 #endif
041 #ifndef UNREACHABLE
042 # define UNREACHABLE
043 #endif
044
045 #ifdef __GNUC__
046 #define PRINTF_ARGS(decl, string_index, first_to_check) \
047 decl __attribute__((format(printf, string_index, first_to_check)))
048 #else
049 #define PRINTF_ARGS(decl, string_index, first_to_check) decl
050 #endif
051
052 #ifdef HAVE_INTRINSICS_H
053 # include <intrinsics.h>
054 #endif
055
056 #include <stdarg.h>
057
058 RUBY_SYMBOL_EXPORT_BEGIN
059
060
061 #ifdef __GNUC__
062 # ifndef atarist
063 # ifndef alloca
064 # define alloca __builtin_alloca
065 # endif
066 # endif
067 #else
068 # ifdef HAVE_ALLOCA_H
069 # include <alloca.h>
070 # else
071 # ifdef _AIX
072 #pragma alloca
073 # else
074 # ifndef alloca
075 void *alloca();
076 # endif
077 # endif
078 # endif
079 #endif
080
081 #if defined HAVE_UINTPTR_T && 0
082 typedef uintptr_t VALUE;
083 typedef uintptr_t ID;
084 # define SIGNED_VALUE intptr_t
085 # define SIZEOF_VALUE SIZEOF_UINTPTR_T
086 # undef PRI_VALUE_PREFIX
087 #elif SIZEOF_LONG == SIZEOF_VOIDP
088 typedef unsigned long VALUE;
089 typedef unsigned long ID;
090 # define SIGNED_VALUE long
091 # define SIZEOF_VALUE SIZEOF_LONG
092 # define PRI_VALUE_PREFIX "l"
093 #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
094 typedef unsigned LONG_LONG VALUE;
095 typedef unsigned LONG_LONG ID;
096 # define SIGNED_VALUE LONG_LONG
097 # define LONG_LONG_VALUE 1
098 # define SIZEOF_VALUE SIZEOF_LONG_LONG
099 # 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 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 PRIoVALUE PRIoPTR
121 #define PRIuVALUE PRIuPTR
122 #define PRIxVALUE PRIxPTR
123 #define PRIXVALUE PRIXPTR
124 #define PRIsVALUE PRIiPTR
125 #else
126 #define PRIdVALUE PRI_VALUE_PREFIX"d"
127 #define PRIoVALUE PRI_VALUE_PREFIX"o"
128 #define PRIuVALUE PRI_VALUE_PREFIX"u"
129 #define PRIxVALUE PRI_VALUE_PREFIX"x"
130 #define PRIXVALUE PRI_VALUE_PREFIX"X"
131 #define PRIsVALUE PRI_VALUE_PREFIX"i"
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
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
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)
228 VALUE rb_int2inum(SIGNED_VALUE);
229
230 #define rb_int_new(v) rb_int2inum(v)
231 VALUE rb_uint2inum(VALUE);
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 static inline int
299 rb_long2int_inline(long n)
300 {
301 int i = (int)n;
302 if ((long)i != n)
303 rb_out_of_int(n);
304
305 return i;
306 }
307 #define rb_long2int(n) rb_long2int_inline(n)
308 #else
309 #define rb_long2int(n) ((int)(n))
310 #endif
311
312 #ifndef PIDT2NUM
313 #define PIDT2NUM(v) LONG2NUM(v)
314 #endif
315 #ifndef NUM2PIDT
316 #define NUM2PIDT(v) NUM2LONG(v)
317 #endif
318 #ifndef UIDT2NUM
319 #define UIDT2NUM(v) LONG2NUM(v)
320 #endif
321 #ifndef NUM2UIDT
322 #define NUM2UIDT(v) NUM2LONG(v)
323 #endif
324 #ifndef GIDT2NUM
325 #define GIDT2NUM(v) LONG2NUM(v)
326 #endif
327 #ifndef NUM2GIDT
328 #define NUM2GIDT(v) NUM2LONG(v)
329 #endif
330 #ifndef NUM2MODET
331 #define NUM2MODET(v) NUM2INT(v)
332 #endif
333 #ifndef MODET2NUM
334 #define MODET2NUM(v) INT2NUM(v)
335 #endif
336
337 #define FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1))
338 #define FIX2ULONG(x) ((unsigned long)FIX2LONG(x))
339 #define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG)
340 #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
341 #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
342 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
343
344 #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
345
346 #define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG)
347 #define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
348 #define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT)
349
350 #ifndef USE_FLONUM
351 #if SIZEOF_VALUE >= SIZEOF_DOUBLE
352 #define USE_FLONUM 1
353 #else
354 #define USE_FLONUM 0
355 #endif
356 #endif
357
358 #if USE_FLONUM
359 #define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG)
360 #else
361 #define FLONUM_P(x) 0
362 #endif
363
364
365 #define USE_SYMBOL_AS_METHOD_NAME 1
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389 enum ruby_special_consts {
390 #if USE_FLONUM
391 RUBY_Qfalse = 0x00,
392 RUBY_Qtrue = 0x14,
393 RUBY_Qnil = 0x08,
394 RUBY_Qundef = 0x34,
395
396 RUBY_IMMEDIATE_MASK = 0x07,
397 RUBY_FIXNUM_FLAG = 0x01,
398 RUBY_FLONUM_MASK = 0x03,
399 RUBY_FLONUM_FLAG = 0x02,
400 RUBY_SYMBOL_FLAG = 0x0c,
401 RUBY_SPECIAL_SHIFT = 8
402 #else
403 RUBY_Qfalse = 0,
404 RUBY_Qtrue = 2,
405 RUBY_Qnil = 4,
406 RUBY_Qundef = 6,
407
408 RUBY_IMMEDIATE_MASK = 0x03,
409 RUBY_FIXNUM_FLAG = 0x01,
410 RUBY_FLONUM_MASK = 0x00,
411 RUBY_FLONUM_FLAG = 0x02,
412 RUBY_SYMBOL_FLAG = 0x0e,
413 RUBY_SPECIAL_SHIFT = 8
414 #endif
415 };
416
417 #define Qfalse ((VALUE)RUBY_Qfalse)
418 #define Qtrue ((VALUE)RUBY_Qtrue)
419 #define Qnil ((VALUE)RUBY_Qnil)
420 #define Qundef ((VALUE)RUBY_Qundef)
421 #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
422 #define FIXNUM_FLAG RUBY_FIXNUM_FLAG
423 #if USE_FLONUM
424 #define FLONUM_MASK RUBY_FLONUM_MASK
425 #define FLONUM_FLAG RUBY_FLONUM_FLAG
426 #endif
427 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
428
429 #define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0)
430 #define NIL_P(v) !((VALUE)(v) != Qnil)
431
432 #define CLASS_OF(v) rb_class_of((VALUE)(v))
433
434 enum ruby_value_type {
435 RUBY_T_NONE = 0x00,
436
437 RUBY_T_OBJECT = 0x01,
438 RUBY_T_CLASS = 0x02,
439 RUBY_T_MODULE = 0x03,
440 RUBY_T_FLOAT = 0x04,
441 RUBY_T_STRING = 0x05,
442 RUBY_T_REGEXP = 0x06,
443 RUBY_T_ARRAY = 0x07,
444 RUBY_T_HASH = 0x08,
445 RUBY_T_STRUCT = 0x09,
446 RUBY_T_BIGNUM = 0x0a,
447 RUBY_T_FILE = 0x0b,
448 RUBY_T_DATA = 0x0c,
449 RUBY_T_MATCH = 0x0d,
450 RUBY_T_COMPLEX = 0x0e,
451 RUBY_T_RATIONAL = 0x0f,
452
453 RUBY_T_NIL = 0x11,
454 RUBY_T_TRUE = 0x12,
455 RUBY_T_FALSE = 0x13,
456 RUBY_T_SYMBOL = 0x14,
457 RUBY_T_FIXNUM = 0x15,
458
459 RUBY_T_UNDEF = 0x1b,
460 RUBY_T_NODE = 0x1c,
461 RUBY_T_ICLASS = 0x1d,
462 RUBY_T_ZOMBIE = 0x1e,
463
464 RUBY_T_MASK = 0x1f
465 };
466
467 #define T_NONE RUBY_T_NONE
468 #define T_NIL RUBY_T_NIL
469 #define T_OBJECT RUBY_T_OBJECT
470 #define T_CLASS RUBY_T_CLASS
471 #define T_ICLASS RUBY_T_ICLASS
472 #define T_MODULE RUBY_T_MODULE
473 #define T_FLOAT RUBY_T_FLOAT
474 #define T_STRING RUBY_T_STRING
475 #define T_REGEXP RUBY_T_REGEXP
476 #define T_ARRAY RUBY_T_ARRAY
477 #define T_HASH RUBY_T_HASH
478 #define T_STRUCT RUBY_T_STRUCT
479 #define T_BIGNUM RUBY_T_BIGNUM
480 #define T_FILE RUBY_T_FILE
481 #define T_FIXNUM RUBY_T_FIXNUM
482 #define T_TRUE RUBY_T_TRUE
483 #define T_FALSE RUBY_T_FALSE
484 #define T_DATA RUBY_T_DATA
485 #define T_MATCH RUBY_T_MATCH
486 #define T_SYMBOL RUBY_T_SYMBOL
487 #define T_RATIONAL RUBY_T_RATIONAL
488 #define T_COMPLEX RUBY_T_COMPLEX
489 #define T_UNDEF RUBY_T_UNDEF
490 #define T_NODE RUBY_T_NODE
491 #define T_ZOMBIE RUBY_T_ZOMBIE
492 #define T_MASK RUBY_T_MASK
493
494 #define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK)
495
496 static inline int rb_type(VALUE obj);
497 #define TYPE(x) rb_type((VALUE)(x))
498
499
500
501 #ifdef __GNUC__
502 #define RB_GC_GUARD_PTR(ptr) \
503 __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
504 #else
505 #ifdef _MSC_VER
506 #pragma optimize("", off)
507 #endif
508 static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
509 #ifdef _MSC_VER
510 #pragma optimize("", on)
511 #endif
512 #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
513 #endif
514 #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
515
516 #ifdef __GNUC__
517 #define RB_UNUSED_VAR(x) x __attribute__ ((unused))
518 #else
519 #define RB_UNUSED_VAR(x) x
520 #endif
521
522 void rb_check_type(VALUE,int);
523 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
524
525 VALUE rb_str_to_str(VALUE);
526 VALUE rb_string_value(volatile VALUE*);
527 char *rb_string_value_ptr(volatile VALUE*);
528 char *rb_string_value_cstr(volatile VALUE*);
529
530 #define StringValue(v) rb_string_value(&(v))
531 #define StringValuePtr(v) rb_string_value_ptr(&(v))
532 #define StringValueCStr(v) rb_string_value_cstr(&(v))
533
534 void rb_check_safe_obj(VALUE);
535 DEPRECATED(void rb_check_safe_str(VALUE));
536 #define SafeStringValue(v) do {\
537 StringValue(v);\
538 rb_check_safe_obj(v);\
539 } while (0)
540
541 #define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
542
543 VALUE rb_str_export(VALUE);
544 #define ExportStringValue(v) do {\
545 SafeStringValue(v);\
546 (v) = rb_str_export(v);\
547 } while (0)
548 VALUE rb_str_export_locale(VALUE);
549
550 VALUE rb_get_path(VALUE);
551 #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
552
553 VALUE rb_get_path_no_checksafe(VALUE);
554 #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
555
556 void rb_secure(int);
557 int rb_safe_level(void);
558 void rb_set_safe_level(int);
559 void rb_set_safe_level_force(int);
560 void rb_secure_update(VALUE);
561 NORETURN(void rb_insecure_operation(void));
562
563 VALUE rb_errinfo(void);
564 void rb_set_errinfo(VALUE);
565
566 SIGNED_VALUE rb_num2long(VALUE);
567 VALUE rb_num2ulong(VALUE);
568 static inline long
569 rb_num2long_inline(VALUE x)
570 {
571 if (FIXNUM_P(x))
572 return FIX2LONG(x);
573 else
574 return (long)rb_num2long(x);
575 }
576 #define NUM2LONG(x) rb_num2long_inline(x)
577 static inline unsigned long
578 rb_num2ulong_inline(VALUE x)
579 {
580 if (FIXNUM_P(x))
581 return (unsigned long)FIX2LONG(x);
582 else
583 return (unsigned long)rb_num2ulong(x);
584 }
585 #define NUM2ULONG(x) rb_num2ulong_inline(x)
586 #if SIZEOF_INT < SIZEOF_LONG
587 long rb_num2int(VALUE);
588 long rb_fix2int(VALUE);
589 #define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
590
591 static inline int
592 rb_num2int_inline(VALUE x)
593 {
594 if (FIXNUM_P(x))
595 return FIX2INT(x);
596 else
597 return (int)rb_num2int(x);
598 }
599 #define NUM2INT(x) rb_num2int_inline(x)
600
601 unsigned long rb_num2uint(VALUE);
602 #define NUM2UINT(x) ((unsigned int)rb_num2uint(x))
603 unsigned long rb_fix2uint(VALUE);
604 #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
605 #else
606 #define NUM2INT(x) ((int)NUM2LONG(x))
607 #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
608 #define FIX2INT(x) ((int)FIX2LONG(x))
609 #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
610 #endif
611
612 short rb_num2short(VALUE);
613 unsigned short rb_num2ushort(VALUE);
614 short rb_fix2short(VALUE);
615 unsigned short rb_fix2ushort(VALUE);
616 #define FIX2SHORT(x) (rb_fix2short((VALUE)(x)))
617 static inline short
618 rb_num2short_inline(VALUE x)
619 {
620 if (FIXNUM_P(x))
621 return FIX2SHORT(x);
622 else
623 return rb_num2short(x);
624 }
625
626 #define NUM2SHORT(x) rb_num2short_inline(x)
627 #define NUM2USHORT(x) rb_num2ushort(x)
628
629 #ifdef HAVE_LONG_LONG
630 LONG_LONG rb_num2ll(VALUE);
631 unsigned LONG_LONG rb_num2ull(VALUE);
632 static inline LONG_LONG
633 rb_num2ll_inline(VALUE x)
634 {
635 if (FIXNUM_P(x))
636 return FIX2LONG(x);
637 else
638 return rb_num2ll(x);
639 }
640 # define NUM2LL(x) rb_num2ll_inline(x)
641 # define NUM2ULL(x) rb_num2ull(x)
642 #endif
643
644 #if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
645 # define NUM2OFFT(x) ((off_t)NUM2LL(x))
646 #else
647 # define NUM2OFFT(x) NUM2LONG(x)
648 #endif
649
650 #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
651 # define NUM2SIZET(x) ((size_t)NUM2ULL(x))
652 # define NUM2SSIZET(x) ((ssize_t)NUM2LL(x))
653 #else
654 # define NUM2SIZET(x) NUM2ULONG(x)
655 # define NUM2SSIZET(x) NUM2LONG(x)
656 #endif
657
658 double rb_num2dbl(VALUE);
659 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
660
661 VALUE rb_uint2big(VALUE);
662 VALUE rb_int2big(SIGNED_VALUE);
663
664 VALUE rb_newobj(void);
665 VALUE rb_newobj_of(VALUE, VALUE);
666 #define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
667 #define NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags)
668 #define OBJSETUP(obj,c,t) do {\
669 RBASIC(obj)->flags = (t);\
670 RBASIC(obj)->klass = (c);\
671 if (rb_safe_level() >= 3) FL_SET((obj), FL_TAINT | FL_UNTRUSTED);\
672 } while (0)
673 #define CLONESETUP(clone,obj) do {\
674 OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\
675 rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\
676 if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\
677 } while (0)
678 #define DUPSETUP(dup,obj) do {\
679 OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \
680 if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\
681 } while (0)
682
683 struct RBasic {
684 VALUE flags;
685 VALUE klass;
686 }
687 #ifdef __GNUC__
688 __attribute__((aligned(sizeof(VALUE))))
689 #endif
690 ;
691
692 #define ROBJECT_EMBED_LEN_MAX 3
693 struct RObject {
694 struct RBasic basic;
695 union {
696 struct {
697 long numiv;
698 VALUE *ivptr;
699 struct st_table *iv_index_tbl;
700 } heap;
701 VALUE ary[ROBJECT_EMBED_LEN_MAX];
702 } as;
703 };
704 #define ROBJECT_EMBED FL_USER1
705 #define ROBJECT_NUMIV(o) \
706 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
707 ROBJECT_EMBED_LEN_MAX : \
708 ROBJECT(o)->as.heap.numiv)
709 #define ROBJECT_IVPTR(o) \
710 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
711 ROBJECT(o)->as.ary : \
712 ROBJECT(o)->as.heap.ivptr)
713 #define ROBJECT_IV_INDEX_TBL(o) \
714 ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
715 RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
716 ROBJECT(o)->as.heap.iv_index_tbl)
717
718
719 typedef struct rb_classext_struct rb_classext_t;
720
721 struct RClass {
722 struct RBasic basic;
723 rb_classext_t *ptr;
724 struct st_table *m_tbl;
725 struct st_table *iv_index_tbl;
726 };
727 #define RCLASS_SUPER(c) rb_class_get_superclass(c)
728 #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
729 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
730 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
731 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
732 #define RMODULE_IS_OVERLAID FL_USER2
733 #define RMODULE_IS_REFINEMENT FL_USER3
734 #define RMODULE_INCLUDED_INTO_REFINEMENT FL_USER4
735
736 struct RFloat {
737 struct RBasic basic;
738 double float_value;
739 };
740
741 VALUE rb_float_new_in_heap(double);
742
743 #if USE_FLONUM
744 #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
745 #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
746
747 static inline double
748 rb_float_value(VALUE v)
749 {
750 if (FLONUM_P(v)) {
751 if (v != (VALUE)0x8000000000000002) {
752 union {
753 double d;
754 VALUE v;
755 } t;
756
757 VALUE b63 = (v >> 63);
758
759
760
761 t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~0x03), 3);
762 return t.d;
763 }
764 else {
765 return 0.0;
766 }
767 }
768 else {
769 return ((struct RFloat *)v)->float_value;
770 }
771 }
772
773 static inline VALUE
774 rb_float_new(double d)
775 {
776 union {
777 double d;
778 VALUE v;
779 } t;
780 int bits;
781
782 t.d = d;
783 bits = (int)((VALUE)(t.v >> 60) & 0x7);
784
785
786
787
788
789 if (t.v != 0x3000000000000000 &&
790 !((bits-3) & ~0x01)) {
791 return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
792 }
793 else {
794 if (t.v == (VALUE)0) {
795
796 return 0x8000000000000002;
797 }
798 else {
799
800 return rb_float_new_in_heap(d);
801 }
802 }
803 }
804
805 #else
806
807 static inline double
808 rb_float_value(VALUE v)
809 {
810 return ((struct RFloat *)v)->float_value;
811 }
812
813 static inline VALUE
814 rb_float_new(double d)
815 {
816 return rb_float_new_in_heap(d);
817 }
818 #endif
819
820 #define RFLOAT_VALUE(v) rb_float_value(v)
821 #define DBL2NUM(dbl) rb_float_new(dbl)
822
823 #define ELTS_SHARED FL_USER2
824
825 #define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1))
826 struct RString {
827 struct RBasic basic;
828 union {
829 struct {
830 long len;
831 char *ptr;
832 union {
833 long capa;
834 VALUE shared;
835 } aux;
836 } heap;
837 char ary[RSTRING_EMBED_LEN_MAX + 1];
838 } as;
839 };
840 #define RSTRING_NOEMBED FL_USER1
841 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6)
842 #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
843 #define RSTRING_EMBED_LEN(str) \
844 (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
845 (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
846 #define RSTRING_LEN(str) \
847 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
848 RSTRING_EMBED_LEN(str) : \
849 RSTRING(str)->as.heap.len)
850 #define RSTRING_PTR(str) \
851 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
852 RSTRING(str)->as.ary : \
853 RSTRING(str)->as.heap.ptr)
854 #define RSTRING_END(str) \
855 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
856 (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
857 (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
858 #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
859 #define RSTRING_GETMEM(str, ptrvar, lenvar) \
860 (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
861 ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
862 ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
863
864 #define RARRAY_EMBED_LEN_MAX 3
865 struct RArray {
866 struct RBasic basic;
867 union {
868 struct {
869 long len;
870 union {
871 long capa;
872 VALUE shared;
873 } aux;
874 VALUE *ptr;
875 } heap;
876 VALUE ary[RARRAY_EMBED_LEN_MAX];
877 } as;
878 };
879 #define RARRAY_EMBED_FLAG FL_USER1
880
881 #define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3)
882 #define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3)
883 #define RARRAY_LEN(a) \
884 ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
885 (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
886 (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
887 RARRAY(a)->as.heap.len)
888 #define RARRAY_PTR(a) \
889 ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
890 RARRAY(a)->as.ary : \
891 RARRAY(a)->as.heap.ptr)
892 #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
893
894 struct RRegexp {
895 struct RBasic basic;
896 struct re_pattern_buffer *ptr;
897 VALUE src;
898 unsigned long usecnt;
899 };
900 #define RREGEXP_SRC(r) RREGEXP(r)->src
901 #define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
902 #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
903 #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
904
905 struct RHash {
906 struct RBasic basic;
907 struct st_table *ntbl;
908 int iter_lev;
909 VALUE ifnone;
910 };
911
912 #define RHASH_TBL(h) rb_hash_tbl(h)
913 #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
914 #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
915 #define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0)
916 #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
917
918 struct RFile {
919 struct RBasic basic;
920 struct rb_io_t *fptr;
921 };
922
923 struct RRational {
924 struct RBasic basic;
925 VALUE num;
926 VALUE den;
927 };
928
929 struct RComplex {
930 struct RBasic basic;
931 VALUE real;
932 VALUE imag;
933 };
934
935 struct RData {
936 struct RBasic basic;
937 void (*dmark)(void*);
938 void (*dfree)(void*);
939 void *data;
940 };
941
942 typedef struct rb_data_type_struct rb_data_type_t;
943
944 struct rb_data_type_struct {
945 const char *wrap_struct_name;
946 struct {
947 void (*dmark)(void*);
948 void (*dfree)(void*);
949 size_t (*dsize)(const void *);
950 void *reserved[2];
951
952 } function;
953 const rb_data_type_t *parent;
954 void *data;
955
956 };
957
958 #define HAVE_TYPE_RB_DATA_TYPE_T 1
959 #define HAVE_RB_DATA_TYPE_T_FUNCTION 1
960 #define HAVE_RB_DATA_TYPE_T_PARENT 1
961
962 struct RTypedData {
963 struct RBasic basic;
964 const rb_data_type_t *type;
965 VALUE typed_flag;
966 void *data;
967 };
968
969 #define DATA_PTR(dta) (RDATA(dta)->data)
970
971 #define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1)
972 #define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
973 #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
974
975
976
977
978 typedef void (*RUBY_DATA_FUNC)(void*);
979
980 VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
981 VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *);
982 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
983 int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *);
984 void *rb_check_typeddata(VALUE, const rb_data_type_t *);
985 #define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
986 #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
987 #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0)
988 #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
989 #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE
990
991 #define Data_Wrap_Struct(klass,mark,free,sval)\
992 rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
993
994 #define Data_Make_Struct(klass,type,mark,free,sval) (\
995 (sval) = ALLOC(type),\
996 memset((sval), 0, sizeof(type)),\
997 Data_Wrap_Struct((klass),(mark),(free),(sval))\
998 )
999
1000 #define TypedData_Wrap_Struct(klass,data_type,sval)\
1001 rb_data_typed_object_alloc((klass),(sval),(data_type))
1002
1003 #define TypedData_Make_Struct(klass, type, data_type, sval) (\
1004 (sval) = ALLOC(type),\
1005 memset((sval), 0, sizeof(type)),\
1006 TypedData_Wrap_Struct((klass),(data_type),(sval))\
1007 )
1008
1009 #define Data_Get_Struct(obj,type,sval) do {\
1010 Check_Type((obj), T_DATA); \
1011 (sval) = (type*)DATA_PTR(obj);\
1012 } while (0)
1013
1014 #define TypedData_Get_Struct(obj,type,data_type,sval) do {\
1015 (sval) = (type*)rb_check_typeddata((obj), (data_type)); \
1016 } while (0)
1017
1018 #define RSTRUCT_EMBED_LEN_MAX 3
1019 struct RStruct {
1020 struct RBasic basic;
1021 union {
1022 struct {
1023 long len;
1024 VALUE *ptr;
1025 } heap;
1026 VALUE ary[RSTRUCT_EMBED_LEN_MAX];
1027 } as;
1028 };
1029 #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1)
1030 #define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
1031 #define RSTRUCT_LEN(st) \
1032 ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
1033 (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
1034 (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
1035 RSTRUCT(st)->as.heap.len)
1036 #define RSTRUCT_PTR(st) \
1037 ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
1038 RSTRUCT(st)->as.ary : \
1039 RSTRUCT(st)->as.heap.ptr)
1040 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
1041
1042 #define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT)))
1043 struct RBignum {
1044 struct RBasic basic;
1045 union {
1046 struct {
1047 long len;
1048 BDIGIT *digits;
1049 } heap;
1050 BDIGIT ary[RBIGNUM_EMBED_LEN_MAX];
1051 } as;
1052 };
1053 #define RBIGNUM_SIGN_BIT FL_USER1
1054
1055 #define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0)
1056 #define RBIGNUM_SET_SIGN(b,sign) \
1057 ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \
1058 : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT))
1059 #define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b)
1060 #define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b))
1061
1062 #define RBIGNUM_EMBED_FLAG FL_USER2
1063 #define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
1064 #define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3)
1065 #define RBIGNUM_LEN(b) \
1066 ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
1067 (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \
1068 (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \
1069 RBIGNUM(b)->as.heap.len)
1070
1071 #define RBIGNUM_DIGITS(b) \
1072 ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
1073 RBIGNUM(b)->as.ary : \
1074 RBIGNUM(b)->as.heap.digits)
1075 #define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b))
1076
1077 #define R_CAST(st) (struct st*)
1078 #define RBASIC(obj) (R_CAST(RBasic)(obj))
1079 #define ROBJECT(obj) (R_CAST(RObject)(obj))
1080 #define RCLASS(obj) (R_CAST(RClass)(obj))
1081 #define RMODULE(obj) RCLASS(obj)
1082 #define RFLOAT(obj) (R_CAST(RFloat)(obj))
1083 #define RSTRING(obj) (R_CAST(RString)(obj))
1084 #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
1085 #define RARRAY(obj) (R_CAST(RArray)(obj))
1086 #define RHASH(obj) (R_CAST(RHash)(obj))
1087 #define RDATA(obj) (R_CAST(RData)(obj))
1088 #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj))
1089 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
1090 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
1091 #define RFILE(obj) (R_CAST(RFile)(obj))
1092 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
1093 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
1094
1095 #define FL_SINGLETON FL_USER0
1096 #define FL_RESERVED1 (((VALUE)1)<<5)
1097 #define FL_RESERVED2 (((VALUE)1)<<6)
1098 #define FL_FINALIZE (((VALUE)1)<<7)
1099 #define FL_TAINT (((VALUE)1)<<8)
1100 #define FL_UNTRUSTED (((VALUE)1)<<9)
1101 #define FL_EXIVAR (((VALUE)1)<<10)
1102 #define FL_FREEZE (((VALUE)1)<<11)
1103
1104 #define FL_USHIFT 12
1105
1106 #define FL_USER0 (((VALUE)1)<<(FL_USHIFT+0))
1107 #define FL_USER1 (((VALUE)1)<<(FL_USHIFT+1))
1108 #define FL_USER2 (((VALUE)1)<<(FL_USHIFT+2))
1109 #define FL_USER3 (((VALUE)1)<<(FL_USHIFT+3))
1110 #define FL_USER4 (((VALUE)1)<<(FL_USHIFT+4))
1111 #define FL_USER5 (((VALUE)1)<<(FL_USHIFT+5))
1112 #define FL_USER6 (((VALUE)1)<<(FL_USHIFT+6))
1113 #define FL_USER7 (((VALUE)1)<<(FL_USHIFT+7))
1114 #define FL_USER8 (((VALUE)1)<<(FL_USHIFT+8))
1115 #define FL_USER9 (((VALUE)1)<<(FL_USHIFT+9))
1116 #define FL_USER10 (((VALUE)1)<<(FL_USHIFT+10))
1117 #define FL_USER11 (((VALUE)1)<<(FL_USHIFT+11))
1118 #define FL_USER12 (((VALUE)1)<<(FL_USHIFT+12))
1119 #define FL_USER13 (((VALUE)1)<<(FL_USHIFT+13))
1120 #define FL_USER14 (((VALUE)1)<<(FL_USHIFT+14))
1121 #define FL_USER15 (((VALUE)1)<<(FL_USHIFT+15))
1122 #define FL_USER16 (((VALUE)1)<<(FL_USHIFT+16))
1123 #define FL_USER17 (((VALUE)1)<<(FL_USHIFT+17))
1124 #define FL_USER18 (((VALUE)1)<<(FL_USHIFT+18))
1125 #define FL_USER19 (((VALUE)1)<<(FL_USHIFT+19))
1126
1127 #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
1128
1129 #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
1130 #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
1131 #define FL_ANY(x,f) FL_TEST((x),(f))
1132 #define FL_ALL(x,f) (FL_TEST((x),(f)) == (f))
1133 #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
1134 #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
1135 #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
1136
1137 #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT))
1138 #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
1139 #define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED))
1140 #define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED)
1141 #define OBJ_INFECT(x,s) do { \
1142 if (FL_ABLE(x) && FL_ABLE(s)) \
1143 RBASIC(x)->flags |= RBASIC(s)->flags & \
1144 (FL_TAINT | FL_UNTRUSTED); \
1145 } while (0)
1146
1147 #define OBJ_FROZEN(x) (!!(FL_ABLE(x)?(RBASIC(x)->flags&(FL_FREEZE)):(FIXNUM_P(x)||FLONUM_P(x))))
1148 #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
1149
1150 #if SIZEOF_INT < SIZEOF_LONG
1151 # define INT2NUM(v) INT2FIX((int)(v))
1152 # define UINT2NUM(v) LONG2FIX((unsigned int)(v))
1153 #else
1154 static inline VALUE
1155 rb_int2num_inline(int v)
1156 {
1157 if (FIXABLE(v))
1158 return INT2FIX(v);
1159 else
1160 return rb_int2big(v);
1161 }
1162 #define INT2NUM(x) rb_int2num_inline(x)
1163
1164 static inline VALUE
1165 rb_uint2num_inline(unsigned int v)
1166 {
1167 if (POSFIXABLE(v))
1168 return LONG2FIX(v);
1169 else
1170 return rb_uint2big(v);
1171 }
1172 #define UINT2NUM(x) rb_uint2num_inline(x)
1173 #endif
1174
1175 static inline VALUE
1176 rb_long2num_inline(long v)
1177 {
1178 if (FIXABLE(v))
1179 return LONG2FIX(v);
1180 else
1181 return rb_int2big(v);
1182 }
1183 #define LONG2NUM(x) rb_long2num_inline(x)
1184
1185 static inline VALUE
1186 rb_ulong2num_inline(unsigned long v)
1187 {
1188 if (POSFIXABLE(v))
1189 return LONG2FIX(v);
1190 else
1191 return rb_uint2big(v);
1192 }
1193 #define ULONG2NUM(x) rb_ulong2num_inline(x)
1194
1195 static inline char
1196 rb_num2char_inline(VALUE x)
1197 {
1198 if ((TYPE(x) == T_STRING) && (RSTRING_LEN(x)>=1))
1199 return RSTRING_PTR(x)[0];
1200 else
1201 return (char)(NUM2INT(x) & 0xff);
1202 }
1203 #define NUM2CHR(x) rb_num2char_inline(x)
1204
1205 #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
1206
1207 #define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))
1208 #define ALLOC(type) ((type*)xmalloc(sizeof(type)))
1209 #define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))
1210
1211 #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
1212
1213 void *rb_alloc_tmp_buffer(volatile VALUE *store, long len);
1214 void rb_free_tmp_buffer(volatile VALUE *store);
1215
1216
1217 #ifdef C_ALLOCA
1218 # define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
1219 #else
1220 # define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
1221 #endif
1222 #define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))
1223 #define ALLOCV_END(v) rb_free_tmp_buffer(&(v))
1224
1225 #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
1226 #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
1227 #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
1228 #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
1229
1230 void rb_obj_infect(VALUE,VALUE);
1231
1232 typedef int ruby_glob_func(const char*,VALUE, void*);
1233 void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
1234 int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
1235 int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
1236
1237 VALUE rb_define_class(const char*,VALUE);
1238 VALUE rb_define_module(const char*);
1239 VALUE rb_define_class_under(VALUE, const char*, VALUE);
1240 VALUE rb_define_module_under(VALUE, const char*);
1241
1242 void rb_include_module(VALUE,VALUE);
1243 void rb_extend_object(VALUE,VALUE);
1244 void rb_prepend_module(VALUE,VALUE);
1245
1246 struct rb_global_variable;
1247
1248 typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
1249 typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1250 typedef void rb_gvar_marker_t(VALUE *var);
1251
1252 VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
1253 void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1254 void rb_gvar_undef_marker(VALUE *var);
1255
1256 VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
1257 void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1258 void rb_gvar_val_marker(VALUE *var);
1259
1260 VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
1261 void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1262 void rb_gvar_var_marker(VALUE *var);
1263
1264 void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
1265
1266 void rb_define_variable(const char*,VALUE*);
1267 void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1268 void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
1269 void rb_define_readonly_variable(const char*,VALUE*);
1270 void rb_define_const(VALUE,const char*,VALUE);
1271 void rb_define_global_const(const char*,VALUE);
1272
1273 #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
1274 void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
1275 void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
1276 void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
1277
1278 void rb_undef_method(VALUE,const char*);
1279 void rb_define_alias(VALUE,const char*,const char*);
1280 void rb_define_attr(VALUE,const char*,int,int);
1281
1282 void rb_global_variable(VALUE*);
1283 void rb_gc_register_mark_object(VALUE);
1284 void rb_gc_register_address(VALUE*);
1285 void rb_gc_unregister_address(VALUE*);
1286
1287 ID rb_intern(const char*);
1288 ID rb_intern2(const char*, long);
1289 ID rb_intern_str(VALUE str);
1290 const char *rb_id2name(ID);
1291 ID rb_check_id(volatile VALUE *);
1292 ID rb_to_id(VALUE);
1293 VALUE rb_id2str(ID);
1294
1295 #define CONST_ID_CACHE(result, str) \
1296 { \
1297 static ID rb_intern_id_cache; \
1298 if (!rb_intern_id_cache) \
1299 rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
1300 result rb_intern_id_cache; \
1301 }
1302 #define CONST_ID(var, str) \
1303 do CONST_ID_CACHE((var) =, (str)) while (0)
1304 #ifdef __GNUC__
1305
1306
1307 #define rb_intern(str) \
1308 (__builtin_constant_p(str) ? \
1309 __extension__ (CONST_ID_CACHE((ID), (str))) : \
1310 rb_intern(str))
1311 #define rb_intern_const(str) \
1312 (__builtin_constant_p(str) ? \
1313 __extension__ (rb_intern2((str), (long)strlen(str))) : \
1314 (rb_intern)(str))
1315 #else
1316 #define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
1317 #endif
1318
1319 const char *rb_class2name(VALUE);
1320 const char *rb_obj_classname(VALUE);
1321
1322 void rb_p(VALUE);
1323
1324 VALUE rb_eval_string(const char*);
1325 VALUE rb_eval_string_protect(const char*, int*);
1326 VALUE rb_eval_string_wrap(const char*, int*);
1327 VALUE rb_funcall(VALUE, ID, int, ...);
1328 VALUE rb_funcall2(VALUE, ID, int, const VALUE*);
1329 VALUE rb_funcall3(VALUE, ID, int, const VALUE*);
1330 VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*);
1331 int rb_scan_args(int, const VALUE*, const char*, ...);
1332 VALUE rb_call_super(int, const VALUE*);
1333
1334
1335 #define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1
1336
1337 VALUE rb_gv_set(const char*, VALUE);
1338 VALUE rb_gv_get(const char*);
1339 VALUE rb_iv_get(VALUE, const char*);
1340 VALUE rb_iv_set(VALUE, const char*, VALUE);
1341
1342 VALUE rb_equal(VALUE,VALUE);
1343
1344 VALUE *rb_ruby_verbose_ptr(void);
1345 VALUE *rb_ruby_debug_ptr(void);
1346 #define ruby_verbose (*rb_ruby_verbose_ptr())
1347 #define ruby_debug (*rb_ruby_debug_ptr())
1348
1349 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
1350 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
1351 PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
1352 NORETURN(void rb_bug_errno(const char*, int));
1353 NORETURN(void rb_sys_fail(const char*));
1354 NORETURN(void rb_sys_fail_str(VALUE));
1355 NORETURN(void rb_mod_sys_fail(VALUE, const char*));
1356 NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE));
1357 NORETURN(void rb_readwrite_sys_fail(int, const char*));
1358 NORETURN(void rb_iter_break(void));
1359 NORETURN(void rb_iter_break_value(VALUE));
1360 NORETURN(void rb_exit(int));
1361 NORETURN(void rb_notimplement(void));
1362 VALUE rb_syserr_new(int, const char *);
1363 VALUE rb_syserr_new_str(int n, VALUE arg);
1364 NORETURN(void rb_syserr_fail(int, const char*));
1365 NORETURN(void rb_syserr_fail_str(int, VALUE));
1366 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
1367 NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE));
1368
1369
1370 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
1371 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
1372 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
1373
1374 PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
1375 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
1376
1377
1378 #define RB_IO_WAIT_READABLE 0
1379 #define RB_IO_WAIT_WRITABLE 1
1380
1381 typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*);
1382
1383 VALUE rb_each(VALUE);
1384 VALUE rb_yield(VALUE);
1385 VALUE rb_yield_values(int n, ...);
1386 VALUE rb_yield_values2(int n, const VALUE *argv);
1387 VALUE rb_yield_splat(VALUE);
1388 int rb_block_given_p(void);
1389 void rb_need_block(void);
1390 VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
1391 VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE);
1392 VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
1393 VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
1394 VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
1395 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
1396 VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
1397 NORETURN(void rb_throw(const char*,VALUE));
1398 NORETURN(void rb_throw_obj(VALUE,VALUE));
1399
1400 VALUE rb_require(const char*);
1401
1402 RUBY_EXTERN VALUE rb_mKernel;
1403 RUBY_EXTERN VALUE rb_mComparable;
1404 RUBY_EXTERN VALUE rb_mEnumerable;
1405 RUBY_EXTERN VALUE rb_mErrno;
1406 RUBY_EXTERN VALUE rb_mFileTest;
1407 RUBY_EXTERN VALUE rb_mGC;
1408 RUBY_EXTERN VALUE rb_mMath;
1409 RUBY_EXTERN VALUE rb_mProcess;
1410 RUBY_EXTERN VALUE rb_mWaitReadable;
1411 RUBY_EXTERN VALUE rb_mWaitWritable;
1412
1413 RUBY_EXTERN VALUE rb_cBasicObject;
1414 RUBY_EXTERN VALUE rb_cObject;
1415 RUBY_EXTERN VALUE rb_cArray;
1416 RUBY_EXTERN VALUE rb_cBignum;
1417 RUBY_EXTERN VALUE rb_cBinding;
1418 RUBY_EXTERN VALUE rb_cClass;
1419 RUBY_EXTERN VALUE rb_cCont;
1420 RUBY_EXTERN VALUE rb_cDir;
1421 RUBY_EXTERN VALUE rb_cData;
1422 RUBY_EXTERN VALUE rb_cFalseClass;
1423 RUBY_EXTERN VALUE rb_cEncoding;
1424 RUBY_EXTERN VALUE rb_cEnumerator;
1425 RUBY_EXTERN VALUE rb_cFile;
1426 RUBY_EXTERN VALUE rb_cFixnum;
1427 RUBY_EXTERN VALUE rb_cFloat;
1428 RUBY_EXTERN VALUE rb_cHash;
1429 RUBY_EXTERN VALUE rb_cInteger;
1430 RUBY_EXTERN VALUE rb_cIO;
1431 RUBY_EXTERN VALUE rb_cMatch;
1432 RUBY_EXTERN VALUE rb_cMethod;
1433 RUBY_EXTERN VALUE rb_cModule;
1434 RUBY_EXTERN VALUE rb_cNameErrorMesg;
1435 RUBY_EXTERN VALUE rb_cNilClass;
1436 RUBY_EXTERN VALUE rb_cNumeric;
1437 RUBY_EXTERN VALUE rb_cProc;
1438 RUBY_EXTERN VALUE rb_cRandom;
1439 RUBY_EXTERN VALUE rb_cRange;
1440 RUBY_EXTERN VALUE rb_cRational;
1441 RUBY_EXTERN VALUE rb_cComplex;
1442 RUBY_EXTERN VALUE rb_cRegexp;
1443 RUBY_EXTERN VALUE rb_cStat;
1444 RUBY_EXTERN VALUE rb_cString;
1445 RUBY_EXTERN VALUE rb_cStruct;
1446 RUBY_EXTERN VALUE rb_cSymbol;
1447 RUBY_EXTERN VALUE rb_cThread;
1448 RUBY_EXTERN VALUE rb_cTime;
1449 RUBY_EXTERN VALUE rb_cTrueClass;
1450 RUBY_EXTERN VALUE rb_cUnboundMethod;
1451
1452 RUBY_EXTERN VALUE rb_eException;
1453 RUBY_EXTERN VALUE rb_eStandardError;
1454 RUBY_EXTERN VALUE rb_eSystemExit;
1455 RUBY_EXTERN VALUE rb_eInterrupt;
1456 RUBY_EXTERN VALUE rb_eSignal;
1457 RUBY_EXTERN VALUE rb_eFatal;
1458 RUBY_EXTERN VALUE rb_eArgError;
1459 RUBY_EXTERN VALUE rb_eEOFError;
1460 RUBY_EXTERN VALUE rb_eIndexError;
1461 RUBY_EXTERN VALUE rb_eStopIteration;
1462 RUBY_EXTERN VALUE rb_eKeyError;
1463 RUBY_EXTERN VALUE rb_eRangeError;
1464 RUBY_EXTERN VALUE rb_eIOError;
1465 RUBY_EXTERN VALUE rb_eRuntimeError;
1466 RUBY_EXTERN VALUE rb_eSecurityError;
1467 RUBY_EXTERN VALUE rb_eSystemCallError;
1468 RUBY_EXTERN VALUE rb_eThreadError;
1469 RUBY_EXTERN VALUE rb_eTypeError;
1470 RUBY_EXTERN VALUE rb_eZeroDivError;
1471 RUBY_EXTERN VALUE rb_eNotImpError;
1472 RUBY_EXTERN VALUE rb_eNoMemError;
1473 RUBY_EXTERN VALUE rb_eNoMethodError;
1474 RUBY_EXTERN VALUE rb_eFloatDomainError;
1475 RUBY_EXTERN VALUE rb_eLocalJumpError;
1476 RUBY_EXTERN VALUE rb_eSysStackError;
1477 RUBY_EXTERN VALUE rb_eRegexpError;
1478 RUBY_EXTERN VALUE rb_eEncodingError;
1479 RUBY_EXTERN VALUE rb_eEncCompatError;
1480
1481 RUBY_EXTERN VALUE rb_eScriptError;
1482 RUBY_EXTERN VALUE rb_eNameError;
1483 RUBY_EXTERN VALUE rb_eSyntaxError;
1484 RUBY_EXTERN VALUE rb_eLoadError;
1485
1486 RUBY_EXTERN VALUE rb_eMathDomainError;
1487
1488 RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr;
1489
1490 static inline VALUE
1491 rb_class_of(VALUE obj)
1492 {
1493 if (IMMEDIATE_P(obj)) {
1494 if (FIXNUM_P(obj)) return rb_cFixnum;
1495 if (FLONUM_P(obj)) return rb_cFloat;
1496 if (obj == Qtrue) return rb_cTrueClass;
1497 if (SYMBOL_P(obj)) return rb_cSymbol;
1498 }
1499 else if (!RTEST(obj)) {
1500 if (obj == Qnil) return rb_cNilClass;
1501 if (obj == Qfalse) return rb_cFalseClass;
1502 }
1503 return RBASIC(obj)->klass;
1504 }
1505
1506 static inline int
1507 rb_type(VALUE obj)
1508 {
1509 if (IMMEDIATE_P(obj)) {
1510 if (FIXNUM_P(obj)) return T_FIXNUM;
1511 if (FLONUM_P(obj)) return T_FLOAT;
1512 if (obj == Qtrue) return T_TRUE;
1513 if (SYMBOL_P(obj)) return T_SYMBOL;
1514 if (obj == Qundef) return T_UNDEF;
1515 }
1516 else if (!RTEST(obj)) {
1517 if (obj == Qnil) return T_NIL;
1518 if (obj == Qfalse) return T_FALSE;
1519 }
1520 return BUILTIN_TYPE(obj);
1521 }
1522
1523 #define RB_FLOAT_TYPE_P(obj) (FLONUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT))
1524
1525 #define RB_TYPE_P(obj, type) ( \
1526 ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
1527 ((type) == T_TRUE) ? ((obj) == Qtrue) : \
1528 ((type) == T_FALSE) ? ((obj) == Qfalse) : \
1529 ((type) == T_NIL) ? ((obj) == Qnil) : \
1530 ((type) == T_UNDEF) ? ((obj) == Qundef) : \
1531 ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
1532 ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \
1533 (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
1534
1535 #ifdef __GNUC__
1536 #define rb_type_p(obj, type) \
1537 __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
1538 rb_type(obj) == (type))
1539 #else
1540 #define rb_type_p(obj, type) (rb_type(obj) == (type))
1541 #endif
1542
1543 #ifdef __GNUC__
1544 #define rb_special_const_p(obj) \
1545 __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);})
1546 #else
1547 static inline int
1548 rb_special_const_p(VALUE obj)
1549 {
1550 if (SPECIAL_CONST_P(obj)) return (int)Qtrue;
1551 return (int)Qfalse;
1552 }
1553 #endif
1554
1555 #include "ruby/missing.h"
1556 #include "ruby/intern.h"
1557
1558 #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
1559
1560 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
1561 #endif
1562
1563 #define RUBY_VM 1
1564 #define HAVE_NATIVETHREAD
1565 int ruby_native_thread_p(void);
1566
1567
1568 #define RUBY_EVENT_NONE 0x0000
1569 #define RUBY_EVENT_LINE 0x0001
1570 #define RUBY_EVENT_CLASS 0x0002
1571 #define RUBY_EVENT_END 0x0004
1572 #define RUBY_EVENT_CALL 0x0008
1573 #define RUBY_EVENT_RETURN 0x0010
1574 #define RUBY_EVENT_C_CALL 0x0020
1575 #define RUBY_EVENT_C_RETURN 0x0040
1576 #define RUBY_EVENT_RAISE 0x0080
1577 #define RUBY_EVENT_ALL 0x00ff
1578
1579
1580 #define RUBY_EVENT_B_CALL 0x0100
1581 #define RUBY_EVENT_B_RETURN 0x0200
1582 #define RUBY_EVENT_THREAD_BEGIN 0x0400
1583 #define RUBY_EVENT_THREAD_END 0x0800
1584 #define RUBY_EVENT_TRACEPOINT_ALL 0xFFFF
1585
1586
1587 #define RUBY_EVENT_SPECIFIED_LINE 0x10000
1588 #define RUBY_EVENT_SWITCH 0x20000
1589 #define RUBY_EVENT_COVERAGE 0x40000
1590
1591 typedef unsigned long rb_event_flag_t;
1592 typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass);
1593
1594 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
1595 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data);
1596 int rb_remove_event_hook(rb_event_hook_func_t func);
1597
1598
1599
1600 #define rb_isascii(c) ((unsigned long)(c) < 128)
1601 int rb_isalnum(int c);
1602 int rb_isalpha(int c);
1603 int rb_isblank(int c);
1604 int rb_iscntrl(int c);
1605 int rb_isdigit(int c);
1606 int rb_isgraph(int c);
1607 int rb_islower(int c);
1608 int rb_isprint(int c);
1609 int rb_ispunct(int c);
1610 int rb_isspace(int c);
1611 int rb_isupper(int c);
1612 int rb_isxdigit(int c);
1613 int rb_tolower(int c);
1614 int rb_toupper(int c);
1615
1616 #ifndef ISPRINT
1617 #define ISASCII(c) rb_isascii((unsigned char)(c))
1618 #undef ISPRINT
1619 #define ISPRINT(c) rb_isprint((unsigned char)(c))
1620 #define ISSPACE(c) rb_isspace((unsigned char)(c))
1621 #define ISUPPER(c) rb_isupper((unsigned char)(c))
1622 #define ISLOWER(c) rb_islower((unsigned char)(c))
1623 #define ISALNUM(c) rb_isalnum((unsigned char)(c))
1624 #define ISALPHA(c) rb_isalpha((unsigned char)(c))
1625 #define ISDIGIT(c) rb_isdigit((unsigned char)(c))
1626 #define ISXDIGIT(c) rb_isxdigit((unsigned char)(c))
1627 #endif
1628 #define TOUPPER(c) rb_toupper((unsigned char)(c))
1629 #define TOLOWER(c) rb_tolower((unsigned char)(c))
1630
1631 int st_strcasecmp(const char *s1, const char *s2);
1632 int st_strncasecmp(const char *s1, const char *s2, size_t n);
1633 #define STRCASECMP(s1, s2) (st_strcasecmp((s1), (s2)))
1634 #define STRNCASECMP(s1, s2, n) (st_strncasecmp((s1), (s2), (n)))
1635
1636 unsigned long ruby_strtoul(const char *str, char **endptr, int base);
1637 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
1638
1639 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
1640
1641 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
1642 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
1643
1644 #ifndef RUBY_DONT_SUBST
1645 #include "ruby/subst.h"
1646 #endif
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 void ruby_sysinit(int *argc, char ***argv);
1665 void ruby_init(void);
1666 void* ruby_options(int argc, char** argv);
1667 int ruby_executable_node(void *n, int *status);
1668 int ruby_run_node(void *n);
1669
1670
1671 void ruby_show_version(void);
1672 void ruby_show_copyright(void);
1673
1674
1675
1676
1677 #define RUBY_INIT_STACK \
1678 VALUE variable_in_this_stack_frame; \
1679 ruby_init_stack(&variable_in_this_stack_frame);
1680
1681
1682 #ifdef __ia64
1683 void ruby_init_stack(volatile VALUE*, void*);
1684 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
1685 #else
1686 void ruby_init_stack(volatile VALUE*);
1687 #endif
1688 #define Init_stack(addr) ruby_init_stack(addr)
1689
1690 int ruby_setup(void);
1691 int ruby_cleanup(volatile int);
1692
1693 void ruby_finalize(void);
1694 NORETURN(void ruby_stop(int));
1695
1696 void ruby_set_stack_size(size_t);
1697 int ruby_stack_check(void);
1698 size_t ruby_stack_length(VALUE**);
1699
1700 int ruby_exec_node(void *n);
1701
1702 void ruby_script(const char* name);
1703 void ruby_set_script_name(VALUE name);
1704
1705 void ruby_prog_init(void);
1706 void ruby_set_argv(int, char**);
1707 void *ruby_process_options(int, char**);
1708 void ruby_init_loadpath(void);
1709 void ruby_incpush(const char*);
1710 void ruby_sig_finalize(void);
1711
1712
1713
1714 RUBY_SYMBOL_EXPORT_END
1715
1716 #if defined(__cplusplus)
1717 #if 0
1718 {
1719 #endif
1720 }
1721 #endif
1722 #endif