rubyosa19 0.5.4 → 0.6.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,912 @@
1
+ /**********************************************************************
2
+
3
+ osx_intern.h -
4
+
5
+ $Author: nobu $
6
+ created at: Thu Jun 10 14:22:17 JST 1993
7
+
8
+ Copyright (C) 1993-2007 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_INTERN_H
15
+ #define RUBY_INTERN_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/defines.h"
25
+ #ifdef RUBY_EXTCONF_H
26
+ #include RUBY_EXTCONF_H
27
+ #endif
28
+
29
+ #ifdef HAVE_STDARG_PROTOTYPES
30
+ # include <stdarg.h>
31
+ #else
32
+ # include <varargs.h>
33
+ #endif
34
+ #include "ruby/st.h"
35
+
36
+ #if defined __GNUC__ && __GNUC__ >= 4
37
+ #pragma GCC visibility push(default)
38
+ #endif
39
+
40
+ /*
41
+ * Functions and variables that are used by more than one source file of
42
+ * the kernel.
43
+ */
44
+
45
+ #define ID_ALLOCATOR 1
46
+
47
+ /* array.c */
48
+ void rb_mem_clear(register VALUE*, register long);
49
+ VALUE rb_assoc_new(VALUE, VALUE);
50
+ VALUE rb_check_array_type(VALUE);
51
+ VALUE rb_ary_new(void);
52
+ VALUE rb_ary_new2(long);
53
+ VALUE rb_ary_new3(long,...);
54
+ VALUE rb_ary_new4(long, const VALUE *);
55
+ VALUE rb_ary_tmp_new(long);
56
+ void rb_ary_free(VALUE);
57
+ void rb_ary_modify(VALUE);
58
+ VALUE rb_ary_freeze(VALUE);
59
+ VALUE rb_ary_aref(int, VALUE*, VALUE);
60
+ VALUE rb_ary_subseq(VALUE, long, long);
61
+ void rb_ary_store(VALUE, long, VALUE);
62
+ VALUE rb_ary_dup(VALUE);
63
+ VALUE rb_ary_resurrect(VALUE ary);
64
+ VALUE rb_ary_to_ary(VALUE);
65
+ VALUE rb_ary_to_s(VALUE);
66
+ VALUE rb_ary_push(VALUE, VALUE);
67
+ VALUE rb_ary_pop(VALUE);
68
+ VALUE rb_ary_shift(VALUE);
69
+ VALUE rb_ary_unshift(VALUE, VALUE);
70
+ VALUE rb_ary_entry(VALUE, long);
71
+ VALUE rb_ary_each(VALUE);
72
+ VALUE rb_ary_join(VALUE, VALUE);
73
+ VALUE rb_ary_reverse(VALUE);
74
+ VALUE rb_ary_sort(VALUE);
75
+ VALUE rb_ary_sort_bang(VALUE);
76
+ VALUE rb_ary_delete(VALUE, VALUE);
77
+ VALUE rb_ary_delete_at(VALUE, long);
78
+ VALUE rb_ary_clear(VALUE);
79
+ VALUE rb_ary_plus(VALUE, VALUE);
80
+ VALUE rb_ary_concat(VALUE, VALUE);
81
+ VALUE rb_ary_assoc(VALUE, VALUE);
82
+ VALUE rb_ary_rassoc(VALUE, VALUE);
83
+ VALUE rb_ary_includes(VALUE, VALUE);
84
+ VALUE rb_ary_cmp(VALUE, VALUE);
85
+ VALUE rb_ary_replace(VALUE copy, VALUE orig);
86
+ VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long));
87
+ VALUE rb_ary_resize(VALUE ary, long len);
88
+ /* bignum.c */
89
+ VALUE rb_big_new(long, int);
90
+ int rb_bigzero_p(VALUE x);
91
+ VALUE rb_big_clone(VALUE);
92
+ void rb_big_2comp(VALUE);
93
+ VALUE rb_big_norm(VALUE);
94
+ void rb_big_resize(VALUE big, long len);
95
+ VALUE rb_uint2big(VALUE);
96
+ VALUE rb_int2big(SIGNED_VALUE);
97
+ VALUE rb_uint2inum(VALUE);
98
+ VALUE rb_int2inum(SIGNED_VALUE);
99
+ VALUE rb_cstr_to_inum(const char*, int, int);
100
+ VALUE rb_str_to_inum(VALUE, int, int);
101
+ VALUE rb_cstr2inum(const char*, int);
102
+ VALUE rb_str2inum(VALUE, int);
103
+ VALUE rb_big2str(VALUE, int);
104
+ VALUE rb_big2str0(VALUE, int, int);
105
+ SIGNED_VALUE rb_big2long(VALUE);
106
+ #define rb_big2int(x) rb_big2long(x)
107
+ VALUE rb_big2ulong(VALUE);
108
+ #define rb_big2uint(x) rb_big2ulong(x)
109
+ VALUE rb_big2ulong_pack(VALUE x);
110
+ #if HAVE_LONG_LONG
111
+ VALUE rb_ll2inum(LONG_LONG);
112
+ VALUE rb_ull2inum(unsigned LONG_LONG);
113
+ LONG_LONG rb_big2ll(VALUE);
114
+ unsigned LONG_LONG rb_big2ull(VALUE);
115
+ #endif /* HAVE_LONG_LONG */
116
+ DEPRECATED(void rb_quad_pack(char*,VALUE));
117
+ DEPRECATED(VALUE rb_quad_unpack(const char*,int));
118
+ void rb_big_pack(VALUE val, unsigned long *buf, long num_longs);
119
+ VALUE rb_big_unpack(unsigned long *buf, long num_longs);
120
+ int rb_uv_to_utf8(char[6],unsigned long);
121
+ VALUE rb_dbl2big(double);
122
+ double rb_big2dbl(VALUE);
123
+ VALUE rb_big_cmp(VALUE, VALUE);
124
+ VALUE rb_big_eq(VALUE, VALUE);
125
+ VALUE rb_big_plus(VALUE, VALUE);
126
+ VALUE rb_big_minus(VALUE, VALUE);
127
+ VALUE rb_big_mul(VALUE, VALUE);
128
+ VALUE rb_big_div(VALUE, VALUE);
129
+ VALUE rb_big_idiv(VALUE, VALUE);
130
+ VALUE rb_big_modulo(VALUE, VALUE);
131
+ VALUE rb_big_divmod(VALUE, VALUE);
132
+ VALUE rb_big_pow(VALUE, VALUE);
133
+ VALUE rb_big_and(VALUE, VALUE);
134
+ VALUE rb_big_or(VALUE, VALUE);
135
+ VALUE rb_big_xor(VALUE, VALUE);
136
+ VALUE rb_big_lshift(VALUE, VALUE);
137
+ VALUE rb_big_rshift(VALUE, VALUE);
138
+ /* rational.c */
139
+ VALUE rb_rational_raw(VALUE, VALUE);
140
+ #define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))
141
+ #define rb_rational_raw2(x,y) rb_rational_raw((x), (y))
142
+ VALUE rb_rational_new(VALUE, VALUE);
143
+ #define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))
144
+ #define rb_rational_new2(x,y) rb_rational_new((x), (y))
145
+ VALUE rb_Rational(VALUE, VALUE);
146
+ #define rb_Rational1(x) rb_Rational((x), INT2FIX(1))
147
+ #define rb_Rational2(x,y) rb_Rational((x), (y))
148
+ /* complex.c */
149
+ VALUE rb_complex_raw(VALUE, VALUE);
150
+ #define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))
151
+ #define rb_complex_raw2(x,y) rb_complex_raw((x), (y))
152
+ VALUE rb_complex_new(VALUE, VALUE);
153
+ #define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))
154
+ #define rb_complex_new2(x,y) rb_complex_new((x), (y))
155
+ VALUE rb_complex_polar(VALUE, VALUE);
156
+ VALUE rb_Complex(VALUE, VALUE);
157
+ #define rb_Complex1(x) rb_Complex((x), INT2FIX(0))
158
+ #define rb_Complex2(x,y) rb_Complex((x), (y))
159
+ /* class.c */
160
+ VALUE rb_class_boot(VALUE);
161
+ VALUE rb_class_new(VALUE);
162
+ VALUE rb_mod_init_copy(VALUE, VALUE);
163
+ VALUE rb_class_init_copy(VALUE, VALUE);
164
+ VALUE rb_singleton_class_clone(VALUE);
165
+ void rb_singleton_class_attached(VALUE,VALUE);
166
+ VALUE rb_make_metaclass(VALUE, VALUE);
167
+ void rb_check_inheritable(VALUE);
168
+ VALUE rb_class_inherited(VALUE, VALUE);
169
+ VALUE rb_define_class_id(RB_ID, VALUE);
170
+ VALUE rb_define_class_id_under(VALUE, RB_ID, VALUE);
171
+ VALUE rb_module_new(void);
172
+ VALUE rb_define_module_id(RB_ID);
173
+ VALUE rb_define_module_id_under(VALUE, RB_ID);
174
+ VALUE rb_mod_included_modules(VALUE);
175
+ VALUE rb_mod_include_p(VALUE, VALUE);
176
+ VALUE rb_mod_ancestors(VALUE);
177
+ VALUE rb_class_instance_methods(int, VALUE*, VALUE);
178
+ VALUE rb_class_public_instance_methods(int, VALUE*, VALUE);
179
+ VALUE rb_class_protected_instance_methods(int, VALUE*, VALUE);
180
+ VALUE rb_class_private_instance_methods(int, VALUE*, VALUE);
181
+ VALUE rb_obj_singleton_methods(int, VALUE*, VALUE);
182
+ void rb_define_method_id(VALUE, RB_ID, VALUE (*)(ANYARGS), int);
183
+ void rb_frozen_class_p(VALUE);
184
+ void rb_undef(VALUE, RB_ID);
185
+ void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
186
+ void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
187
+ void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
188
+ VALUE rb_singleton_class(VALUE);
189
+ /* compar.c */
190
+ int rb_cmpint(VALUE, VALUE, VALUE);
191
+ NORETURN(void rb_cmperr(VALUE, VALUE));
192
+ /* cont.c */
193
+ VALUE rb_fiber_new(VALUE (*)(ANYARGS), VALUE);
194
+ VALUE rb_fiber_resume(VALUE fib, int argc, VALUE *args);
195
+ VALUE rb_fiber_yield(int argc, VALUE *args);
196
+ VALUE rb_fiber_current(void);
197
+ VALUE rb_fiber_alive_p(VALUE);
198
+ /* enum.c */
199
+ /* enumerator.c */
200
+ VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *);
201
+ #define RETURN_ENUMERATOR(obj, argc, argv) do { \
202
+ if (!rb_block_given_p()) \
203
+ return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()),\
204
+ (argc), (argv)); \
205
+ } while (0)
206
+ /* error.c */
207
+ VALUE rb_exc_new(VALUE, const char*, long);
208
+ VALUE rb_exc_new2(VALUE, const char*);
209
+ VALUE rb_exc_new3(VALUE, VALUE);
210
+ PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
211
+ PRINTF_ARGS(NORETURN(void rb_name_error(RB_ID, const char*, ...)), 2, 3);
212
+ NORETURN(void rb_invalid_str(const char*, const char*));
213
+ PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4);
214
+ PRINTF_ARGS(void rb_compile_error_with_enc(const char*, int, void *, const char*, ...), 4, 5);
215
+ PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2);
216
+ NORETURN(void rb_load_fail(const char*));
217
+ NORETURN(void rb_error_frozen(const char*));
218
+ void rb_check_frozen(VALUE);
219
+ #define rb_check_frozen_internal(obj) do { \
220
+ VALUE frozen_obj = (obj); \
221
+ if (OBJ_FROZEN(frozen_obj)) { \
222
+ rb_error_frozen(rb_obj_classname(frozen_obj)); \
223
+ } \
224
+ } while (0)
225
+ #ifdef __GNUC__
226
+ #define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})
227
+ #else
228
+ static inline void
229
+ rb_check_frozen_inline(VALUE obj)
230
+ {
231
+ rb_check_frozen_internal(obj);
232
+ }
233
+ #define rb_check_frozen(obj) rb_check_frozen_inline(obj)
234
+ #endif
235
+
236
+ /* eval.c */
237
+ int rb_sourceline(void);
238
+ const char *rb_sourcefile(void);
239
+ VALUE rb_check_funcall(VALUE, RB_ID, int, VALUE*);
240
+
241
+ #if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)
242
+ typedef struct {
243
+ int maxfd;
244
+ fd_set *fdset;
245
+ } rb_fdset_t;
246
+
247
+ void rb_fd_init(rb_fdset_t *);
248
+ void rb_fd_term(rb_fdset_t *);
249
+ void rb_fd_zero(rb_fdset_t *);
250
+ void rb_fd_set(int, rb_fdset_t *);
251
+ void rb_fd_clr(int, rb_fdset_t *);
252
+ int rb_fd_isset(int, const rb_fdset_t *);
253
+ void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
254
+ void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
255
+ int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
256
+
257
+ #define rb_fd_ptr(f) ((f)->fdset)
258
+ #define rb_fd_max(f) ((f)->maxfd)
259
+
260
+ #elif defined(_WIN32)
261
+
262
+ typedef struct {
263
+ int capa;
264
+ fd_set *fdset;
265
+ } rb_fdset_t;
266
+
267
+ void rb_fd_init(rb_fdset_t *);
268
+ void rb_fd_term(rb_fdset_t *);
269
+ #define rb_fd_zero(f) ((f)->fdset->fd_count = 0)
270
+ void rb_fd_set(int, rb_fdset_t *);
271
+ #define rb_fd_clr(n, f) rb_w32_fdclr((n), (f)->fdset)
272
+ #define rb_fd_isset(n, f) rb_w32_fdisset((n), (f)->fdset)
273
+ #define rb_fd_copy(d, s, n) rb_w32_fd_copy((d), (s), (n))
274
+ void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int);
275
+ #define rb_fd_dup(d, s) rb_w32_fd_dup((d), (s))
276
+ void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
277
+ #define rb_fd_select(n, rfds, wfds, efds, timeout) rb_w32_select((n), (rfds) ? ((rb_fdset_t*)(rfds))->fdset : NULL, (wfds) ? ((rb_fdset_t*)(wfds))->fdset : NULL, (efds) ? ((rb_fdset_t*)(efds))->fdset: NULL, (timeout))
278
+ #define rb_fd_resize(n, f) ((void)(f))
279
+
280
+ #define rb_fd_ptr(f) ((f)->fdset)
281
+ #define rb_fd_max(f) ((f)->fdset->fd_count)
282
+
283
+ #else
284
+
285
+ typedef fd_set rb_fdset_t;
286
+ #define rb_fd_zero(f) FD_ZERO(f)
287
+ #define rb_fd_set(n, f) FD_SET((n), (f))
288
+ #define rb_fd_clr(n, f) FD_CLR((n), (f))
289
+ #define rb_fd_isset(n, f) FD_ISSET((n), (f))
290
+ #define rb_fd_copy(d, s, n) (*(d) = *(s))
291
+ #define rb_fd_dup(d, s) (*(d) = *(s))
292
+ #define rb_fd_resize(n, f) ((void)(f))
293
+ #define rb_fd_ptr(f) (f)
294
+ #define rb_fd_init(f) FD_ZERO(f)
295
+ #define rb_fd_init_copy(d, s) (*(d) = *(s))
296
+ #define rb_fd_term(f) ((void)(f))
297
+ #define rb_fd_max(f) FD_SETSIZE
298
+ #define rb_fd_select(n, rfds, wfds, efds, timeout) select((n), (rfds), (wfds), (efds), (timeout))
299
+
300
+ #endif
301
+
302
+ NORETURN(void rb_exc_raise(VALUE));
303
+ NORETURN(void rb_exc_fatal(VALUE));
304
+ VALUE rb_f_exit(int,VALUE*);
305
+ VALUE rb_f_abort(int,VALUE*);
306
+ void rb_remove_method(VALUE, const char*);
307
+ void rb_remove_method_id(VALUE, RB_ID);
308
+ #define rb_disable_super(klass, name) ((void)0)
309
+ #define rb_enable_super(klass, name) ((void)0)
310
+ #define HAVE_RB_DEFINE_ALLOC_FUNC 1
311
+ typedef VALUE (*rb_alloc_func_t)(VALUE);
312
+ void rb_define_alloc_func(VALUE, rb_alloc_func_t);
313
+ void rb_undef_alloc_func(VALUE);
314
+ rb_alloc_func_t rb_get_alloc_func(VALUE);
315
+ void rb_clear_cache(void);
316
+ void rb_clear_cache_by_class(VALUE);
317
+ void rb_alias(VALUE, RB_ID, RB_ID);
318
+ void rb_attr(VALUE,RB_ID,int,int,int);
319
+ int rb_method_boundp(VALUE, RB_ID, int);
320
+ int rb_method_basic_definition_p(VALUE, RB_ID);
321
+ VALUE rb_eval_cmd(VALUE, VALUE, int);
322
+ int rb_obj_respond_to(VALUE, RB_ID, int);
323
+ int rb_respond_to(VALUE, RB_ID);
324
+ VALUE rb_f_notimplement(int argc, VALUE *argv, VALUE obj);
325
+ void rb_interrupt(void);
326
+ VALUE rb_apply(VALUE, RB_ID, VALUE);
327
+ void rb_backtrace(void);
328
+ RB_ID rb_frame_this_func(void);
329
+ VALUE rb_obj_instance_eval(int, VALUE*, VALUE);
330
+ VALUE rb_obj_instance_exec(int, VALUE*, VALUE);
331
+ VALUE rb_mod_module_eval(int, VALUE*, VALUE);
332
+ VALUE rb_mod_module_exec(int, VALUE*, VALUE);
333
+ void rb_load(VALUE, int);
334
+ void rb_load_protect(VALUE, int, int*);
335
+ NORETURN(void rb_jump_tag(int));
336
+ int rb_provided(const char*);
337
+ int rb_feature_provided(const char *, const char **);
338
+ void rb_provide(const char*);
339
+ VALUE rb_f_require(VALUE, VALUE);
340
+ VALUE rb_require_safe(VALUE, int);
341
+ void rb_obj_call_init(VALUE, int, VALUE*);
342
+ VALUE rb_class_new_instance(int, VALUE*, VALUE);
343
+ VALUE rb_block_proc(void);
344
+ VALUE rb_f_lambda(void);
345
+ VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
346
+ VALUE rb_obj_is_proc(VALUE);
347
+ VALUE rb_proc_call(VALUE, VALUE);
348
+ VALUE rb_proc_call_with_block(VALUE, int argc, VALUE *argv, VALUE);
349
+ int rb_proc_arity(VALUE);
350
+ VALUE rb_proc_lambda_p(VALUE);
351
+ VALUE rb_binding_new(void);
352
+ VALUE rb_obj_method(VALUE, VALUE);
353
+ VALUE rb_obj_is_method(VALUE);
354
+ VALUE rb_method_call(int, VALUE*, VALUE);
355
+ int rb_mod_method_arity(VALUE, RB_ID);
356
+ int rb_obj_method_arity(VALUE, RB_ID);
357
+ VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
358
+ void rb_set_end_proc(void (*)(VALUE), VALUE);
359
+ void rb_mark_end_proc(void);
360
+ void rb_exec_end_proc(void);
361
+ void ruby_finalize(void);
362
+ NORETURN(void ruby_stop(int));
363
+ int ruby_cleanup(volatile int);
364
+ DEPRECATED(void rb_gc_mark_threads(void));
365
+ void rb_thread_schedule(void);
366
+ void rb_thread_wait_fd(int);
367
+ int rb_thread_fd_writable(int);
368
+ void rb_thread_fd_close(int);
369
+ int rb_thread_alone(void);
370
+ void rb_thread_polling(void);
371
+ void rb_thread_sleep(int);
372
+ void rb_thread_sleep_forever(void);
373
+ VALUE rb_thread_stop(void);
374
+ VALUE rb_thread_wakeup(VALUE);
375
+ VALUE rb_thread_wakeup_alive(VALUE);
376
+ VALUE rb_thread_run(VALUE);
377
+ VALUE rb_thread_kill(VALUE);
378
+ VALUE rb_thread_create(VALUE (*)(ANYARGS), void*);
379
+ DEPRECATED(int rb_thread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *));
380
+ int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
381
+ void rb_thread_wait_for(struct timeval);
382
+ VALUE rb_thread_current(void);
383
+ VALUE rb_thread_main(void);
384
+ VALUE rb_thread_local_aref(VALUE, RB_ID);
385
+ VALUE rb_thread_local_aset(VALUE, RB_ID, VALUE);
386
+ void rb_thread_atfork(void);
387
+ void rb_thread_atfork_before_exec(void);
388
+ VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
389
+ VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE);
390
+ VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
391
+ /* dir.c */
392
+ VALUE rb_dir_getwd(void);
393
+ /* file.c */
394
+ VALUE rb_file_s_expand_path(int, VALUE *);
395
+ VALUE rb_file_expand_path(VALUE, VALUE);
396
+ VALUE rb_file_s_absolute_path(int, VALUE *);
397
+ VALUE rb_file_absolute_path(VALUE, VALUE);
398
+ VALUE rb_file_dirname(VALUE fname);
399
+ void rb_file_const(const char*, VALUE);
400
+ int rb_file_load_ok(const char *);
401
+ int rb_find_file_ext_safe(VALUE*, const char* const*, int);
402
+ VALUE rb_find_file_safe(VALUE, int);
403
+ int rb_find_file_ext(VALUE*, const char* const*);
404
+ VALUE rb_find_file(VALUE);
405
+ char *rb_path_next(const char *);
406
+ char *rb_path_skip_prefix(const char *);
407
+ char *rb_path_last_separator(const char *);
408
+ char *rb_path_end(const char *);
409
+ VALUE rb_file_directory_p(VALUE,VALUE);
410
+ VALUE rb_str_encode_ospath(VALUE);
411
+ int rb_is_absolute_path(const char *);
412
+ const char *ruby_find_basename(const char *name, long *baselen, long *alllen);
413
+ const char *ruby_find_extname(const char *name, long *len);
414
+ /* gc.c */
415
+ void ruby_set_stack_size(size_t);
416
+ NORETURN(void rb_memerror(void));
417
+ int ruby_stack_check(void);
418
+ size_t ruby_stack_length(VALUE**);
419
+ int rb_during_gc(void);
420
+ void rb_gc_mark_locations(VALUE*, VALUE*);
421
+ void rb_mark_tbl(struct st_table*);
422
+ void rb_mark_set(struct st_table*);
423
+ void rb_mark_hash(struct st_table*);
424
+ void rb_gc_mark_maybe(VALUE);
425
+ void rb_gc_mark(VALUE);
426
+ void rb_gc_force_recycle(VALUE);
427
+ void rb_gc(void);
428
+ void rb_gc_copy_finalizer(VALUE,VALUE);
429
+ void rb_gc_finalize_deferred(void);
430
+ void rb_gc_call_finalizer_at_exit(void);
431
+ VALUE rb_gc_enable(void);
432
+ VALUE rb_gc_disable(void);
433
+ VALUE rb_gc_start(void);
434
+ #define Init_stack(addr) ruby_init_stack(addr)
435
+ void rb_gc_set_params(void);
436
+ /* hash.c */
437
+ void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t);
438
+ VALUE rb_check_hash_type(VALUE);
439
+ void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE);
440
+ VALUE rb_hash(VALUE);
441
+ VALUE rb_hash_new(void);
442
+ VALUE rb_hash_dup(VALUE);
443
+ VALUE rb_hash_freeze(VALUE);
444
+ VALUE rb_hash_aref(VALUE, VALUE);
445
+ VALUE rb_hash_lookup(VALUE, VALUE);
446
+ VALUE rb_hash_lookup2(VALUE, VALUE, VALUE);
447
+ VALUE rb_hash_fetch(VALUE, VALUE);
448
+ VALUE rb_hash_aset(VALUE, VALUE, VALUE);
449
+ VALUE rb_hash_delete_if(VALUE);
450
+ VALUE rb_hash_delete(VALUE,VALUE);
451
+ typedef VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value);
452
+ VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func);
453
+ struct st_table *rb_hash_tbl(VALUE);
454
+ int rb_path_check(const char*);
455
+ int rb_env_path_tainted(void);
456
+ VALUE rb_env_clear(void);
457
+ /* io.c */
458
+ #define rb_defout rb_stdout
459
+ RUBY_EXTERN VALUE rb_fs;
460
+ RUBY_EXTERN VALUE rb_output_fs;
461
+ RUBY_EXTERN VALUE rb_rs;
462
+ RUBY_EXTERN VALUE rb_default_rs;
463
+ RUBY_EXTERN VALUE rb_output_rs;
464
+ VALUE rb_io_write(VALUE, VALUE);
465
+ VALUE rb_io_gets(VALUE);
466
+ VALUE rb_io_getbyte(VALUE);
467
+ VALUE rb_io_ungetc(VALUE, VALUE);
468
+ VALUE rb_io_ungetbyte(VALUE, VALUE);
469
+ VALUE rb_io_close(VALUE);
470
+ VALUE rb_io_flush(VALUE);
471
+ VALUE rb_io_eof(VALUE);
472
+ VALUE rb_io_binmode(VALUE);
473
+ VALUE rb_io_ascii8bit_binmode(VALUE);
474
+ VALUE rb_io_addstr(VALUE, VALUE);
475
+ VALUE rb_io_printf(int, VALUE*, VALUE);
476
+ VALUE rb_io_print(int, VALUE*, VALUE);
477
+ VALUE rb_io_puts(int, VALUE*, VALUE);
478
+ VALUE rb_io_fdopen(int, int, const char*);
479
+ VALUE rb_io_get_io(VALUE);
480
+ VALUE rb_file_open(const char*, const char*);
481
+ VALUE rb_file_open_str(VALUE, const char*);
482
+ VALUE rb_gets(void);
483
+ void rb_write_error(const char*);
484
+ void rb_write_error2(const char*, long);
485
+ void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds);
486
+ int rb_pipe(int *pipes);
487
+ int rb_reserved_fd_p(int fd);
488
+ #define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)
489
+ void rb_update_max_fd(int fd);
490
+ /* marshal.c */
491
+ VALUE rb_marshal_dump(VALUE, VALUE);
492
+ VALUE rb_marshal_load(VALUE);
493
+ void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE));
494
+ /* numeric.c */
495
+ void rb_num_zerodiv(void);
496
+ #define RB_NUM_COERCE_FUNCS_NEED_OPID 1
497
+ VALUE rb_num_coerce_bin(VALUE, VALUE, RB_ID);
498
+ VALUE rb_num_coerce_cmp(VALUE, VALUE, RB_ID);
499
+ VALUE rb_num_coerce_relop(VALUE, VALUE, RB_ID);
500
+ VALUE rb_float_new(double);
501
+ VALUE rb_num2fix(VALUE);
502
+ VALUE rb_fix2str(VALUE, int);
503
+ VALUE rb_dbl_cmp(double, double);
504
+ /* object.c */
505
+ int rb_eql(VALUE, VALUE);
506
+ VALUE rb_any_to_s(VALUE);
507
+ VALUE rb_inspect(VALUE);
508
+ VALUE rb_obj_is_instance_of(VALUE, VALUE);
509
+ VALUE rb_obj_is_kind_of(VALUE, VALUE);
510
+ VALUE rb_obj_alloc(VALUE);
511
+ VALUE rb_obj_clone(VALUE);
512
+ VALUE rb_obj_dup(VALUE);
513
+ VALUE rb_obj_init_copy(VALUE,VALUE);
514
+ VALUE rb_obj_taint(VALUE);
515
+ VALUE rb_obj_tainted(VALUE);
516
+ VALUE rb_obj_untaint(VALUE);
517
+ VALUE rb_obj_untrust(VALUE);
518
+ VALUE rb_obj_untrusted(VALUE);
519
+ VALUE rb_obj_trust(VALUE);
520
+ VALUE rb_obj_freeze(VALUE);
521
+ VALUE rb_obj_frozen_p(VALUE);
522
+ VALUE rb_obj_id(VALUE);
523
+ VALUE rb_obj_class(VALUE);
524
+ VALUE rb_class_real(VALUE);
525
+ VALUE rb_class_inherited_p(VALUE, VALUE);
526
+ VALUE rb_class_superclass(VALUE);
527
+ VALUE rb_class_get_superclass(VALUE);
528
+ VALUE rb_convert_type(VALUE,int,const char*,const char*);
529
+ VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
530
+ VALUE rb_check_to_integer(VALUE, const char *);
531
+ VALUE rb_check_to_float(VALUE);
532
+ VALUE rb_to_int(VALUE);
533
+ VALUE rb_Integer(VALUE);
534
+ VALUE rb_to_float(VALUE);
535
+ VALUE rb_Float(VALUE);
536
+ VALUE rb_String(VALUE);
537
+ VALUE rb_Array(VALUE);
538
+ double rb_cstr_to_dbl(const char*, int);
539
+ double rb_str_to_dbl(VALUE, int);
540
+ /* parse.y */
541
+ RUBY_EXTERN int ruby_sourceline;
542
+ RUBY_EXTERN char *ruby_sourcefile;
543
+ RB_ID rb_id_attrset(RB_ID);
544
+ void rb_gc_mark_parser(void);
545
+ int rb_is_const_id(RB_ID);
546
+ int rb_is_instance_id(RB_ID);
547
+ int rb_is_class_id(RB_ID);
548
+ int rb_is_local_id(RB_ID);
549
+ int rb_is_junk_id(RB_ID);
550
+ int rb_symname_p(const char*);
551
+ int rb_sym_interned_p(VALUE);
552
+ void rb_gc_mark_symbols(void);
553
+ VALUE rb_backref_get(void);
554
+ void rb_backref_set(VALUE);
555
+ VALUE rb_lastline_get(void);
556
+ void rb_lastline_set(VALUE);
557
+ VALUE rb_sym_all_symbols(void);
558
+ /* process.c */
559
+ void rb_last_status_set(int status, rb_pid_t pid);
560
+ VALUE rb_last_status_get(void);
561
+ struct rb_exec_arg {
562
+ int argc;
563
+ VALUE *argv;
564
+ const char *prog;
565
+ VALUE options;
566
+ VALUE redirect_fds;
567
+ };
568
+ int rb_proc_exec_n(int, VALUE*, const char*);
569
+ int rb_proc_exec(const char*);
570
+ VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e);
571
+ int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val);
572
+ void rb_exec_arg_fixup(struct rb_exec_arg *e);
573
+ int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s);
574
+ int rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char*, size_t);
575
+ int rb_exec(const struct rb_exec_arg*);
576
+ int rb_exec_err(const struct rb_exec_arg*, char*, size_t);
577
+ rb_pid_t rb_fork(int*, int (*)(void*), void*, VALUE);
578
+ rb_pid_t rb_fork_err(int*, int (*)(void*, char*, size_t), void*, VALUE, char*, size_t);
579
+ VALUE rb_f_exec(int,VALUE*);
580
+ rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags);
581
+ void rb_syswait(rb_pid_t pid);
582
+ rb_pid_t rb_spawn(int, VALUE*);
583
+ rb_pid_t rb_spawn_err(int, VALUE*, char*, size_t);
584
+ VALUE rb_proc_times(VALUE);
585
+ VALUE rb_detach_process(rb_pid_t pid);
586
+ /* range.c */
587
+ VALUE rb_range_new(VALUE, VALUE, int);
588
+ VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
589
+ int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp);
590
+ /* random.c */
591
+ unsigned int rb_genrand_int32(void);
592
+ double rb_genrand_real(void);
593
+ void rb_reset_random_seed(void);
594
+ VALUE rb_random_bytes(VALUE rnd, long n);
595
+ VALUE rb_random_int(VALUE rnd, VALUE max);
596
+ unsigned int rb_random_int32(VALUE rnd);
597
+ double rb_random_real(VALUE rnd);
598
+ unsigned long rb_genrand_ulong_limited(unsigned long i);
599
+ /* re.c */
600
+ #define rb_memcmp memcmp
601
+ int rb_memcicmp(const void*,const void*,long);
602
+ void rb_match_busy(VALUE);
603
+ VALUE rb_reg_nth_defined(int, VALUE);
604
+ VALUE rb_reg_nth_match(int, VALUE);
605
+ int rb_reg_backref_number(VALUE match, VALUE backref);
606
+ VALUE rb_reg_last_match(VALUE);
607
+ VALUE rb_reg_match_pre(VALUE);
608
+ VALUE rb_reg_match_post(VALUE);
609
+ VALUE rb_reg_match_last(VALUE);
610
+ #define HAVE_RB_REG_NEW_STR 1
611
+ VALUE rb_reg_new_str(VALUE, int);
612
+ VALUE rb_reg_new(const char *, long, int);
613
+ VALUE rb_reg_alloc(void);
614
+ VALUE rb_reg_init_str(VALUE re, VALUE s, int options);
615
+ VALUE rb_reg_match(VALUE, VALUE);
616
+ VALUE rb_reg_match2(VALUE);
617
+ int rb_reg_options(VALUE);
618
+ /* ruby.c */
619
+ #define rb_argv rb_get_argv()
620
+ RUBY_EXTERN VALUE rb_argv0;
621
+ VALUE rb_get_argv(void);
622
+ void *rb_load_file(const char*);
623
+ void ruby_script(const char*);
624
+ void ruby_prog_init(void);
625
+ void ruby_set_argv(int, char**);
626
+ void *ruby_process_options(int, char**);
627
+ void ruby_init_loadpath(void);
628
+ void ruby_incpush(const char*);
629
+ /* signal.c */
630
+ VALUE rb_f_kill(int, VALUE*);
631
+ void rb_gc_mark_trap_list(void);
632
+ #ifdef POSIX_SIGNAL
633
+ #define posix_signal ruby_posix_signal
634
+ RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int);
635
+ #endif
636
+ void ruby_sig_finalize(void);
637
+ void rb_trap_exit(void);
638
+ void rb_trap_exec(void);
639
+ const char *ruby_signal_name(int);
640
+ void ruby_default_signal(int);
641
+ /* sprintf.c */
642
+ VALUE rb_f_sprintf(int, const VALUE*);
643
+ PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
644
+ VALUE rb_vsprintf(const char*, va_list);
645
+ PRINTF_ARGS(VALUE rb_str_catf(VALUE, const char*, ...), 2, 3);
646
+ VALUE rb_str_vcatf(VALUE, const char*, va_list);
647
+ VALUE rb_str_format(int, const VALUE *, VALUE);
648
+ /* string.c */
649
+ VALUE rb_str_new(const char*, long);
650
+ VALUE rb_str_new_cstr(const char*);
651
+ VALUE rb_str_new2(const char*);
652
+ VALUE rb_str_new_shared(VALUE);
653
+ VALUE rb_str_new3(VALUE);
654
+ VALUE rb_str_new_frozen(VALUE);
655
+ VALUE rb_str_new4(VALUE);
656
+ VALUE rb_str_new_with_class(VALUE, const char*, long);
657
+ VALUE rb_str_new5(VALUE, const char*, long);
658
+ VALUE rb_tainted_str_new_cstr(const char*);
659
+ VALUE rb_tainted_str_new(const char*, long);
660
+ VALUE rb_tainted_str_new2(const char*);
661
+ VALUE rb_external_str_new(const char*, long);
662
+ VALUE rb_external_str_new_cstr(const char*);
663
+ VALUE rb_locale_str_new(const char*, long);
664
+ VALUE rb_locale_str_new_cstr(const char*);
665
+ VALUE rb_filesystem_str_new(const char*, long);
666
+ VALUE rb_filesystem_str_new_cstr(const char*);
667
+ VALUE rb_str_buf_new(long);
668
+ VALUE rb_str_buf_new_cstr(const char*);
669
+ VALUE rb_str_buf_new2(const char*);
670
+ VALUE rb_str_tmp_new(long);
671
+ VALUE rb_usascii_str_new(const char*, long);
672
+ VALUE rb_usascii_str_new_cstr(const char*);
673
+ VALUE rb_usascii_str_new2(const char*);
674
+ void rb_str_free(VALUE);
675
+ void rb_str_shared_replace(VALUE, VALUE);
676
+ VALUE rb_str_buf_append(VALUE, VALUE);
677
+ VALUE rb_str_buf_cat(VALUE, const char*, long);
678
+ VALUE rb_str_buf_cat2(VALUE, const char*);
679
+ VALUE rb_str_buf_cat_ascii(VALUE, const char*);
680
+ VALUE rb_obj_as_string(VALUE);
681
+ VALUE rb_check_string_type(VALUE);
682
+ VALUE rb_str_dup(VALUE);
683
+ VALUE rb_str_resurrect(VALUE str);
684
+ VALUE rb_str_locktmp(VALUE);
685
+ VALUE rb_str_unlocktmp(VALUE);
686
+ VALUE rb_str_dup_frozen(VALUE);
687
+ #define rb_str_dup_frozen rb_str_new_frozen
688
+ VALUE rb_str_plus(VALUE, VALUE);
689
+ VALUE rb_str_times(VALUE, VALUE);
690
+ long rb_str_sublen(VALUE, long);
691
+ VALUE rb_str_substr(VALUE, long, long);
692
+ VALUE rb_str_subseq(VALUE, long, long);
693
+ void rb_str_modify(VALUE);
694
+ void rb_str_modify_expand(VALUE, long);
695
+ VALUE rb_str_freeze(VALUE);
696
+ void rb_str_set_len(VALUE, long);
697
+ VALUE rb_str_resize(VALUE, long);
698
+ VALUE rb_str_cat(VALUE, const char*, long);
699
+ VALUE rb_str_cat2(VALUE, const char*);
700
+ VALUE rb_str_append(VALUE, VALUE);
701
+ VALUE rb_str_concat(VALUE, VALUE);
702
+ st_index_t rb_memhash(const void *ptr, long len);
703
+ st_index_t rb_hash_start(st_index_t);
704
+ st_index_t rb_hash_uint32(st_index_t, uint32_t);
705
+ st_index_t rb_hash_uint(st_index_t, st_index_t);
706
+ st_index_t rb_hash_end(st_index_t);
707
+ #define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
708
+ #define rb_hash_uint(h, i) st_hash_uint((h), (i))
709
+ #define rb_hash_end(h) st_hash_end(h)
710
+ st_index_t rb_str_hash(VALUE);
711
+ int rb_str_hash_cmp(VALUE,VALUE);
712
+ int rb_str_comparable(VALUE, VALUE);
713
+ int rb_str_cmp(VALUE, VALUE);
714
+ VALUE rb_str_equal(VALUE str1, VALUE str2);
715
+ VALUE rb_str_drop_bytes(VALUE, long);
716
+ void rb_str_update(VALUE, long, long, VALUE);
717
+ VALUE rb_str_replace(VALUE, VALUE);
718
+ VALUE rb_str_inspect(VALUE);
719
+ VALUE rb_str_dump(VALUE);
720
+ VALUE rb_str_split(VALUE, const char*);
721
+ void rb_str_associate(VALUE, VALUE);
722
+ VALUE rb_str_associated(VALUE);
723
+ void rb_str_setter(VALUE, RB_ID, VALUE*);
724
+ VALUE rb_str_intern(VALUE);
725
+ VALUE rb_sym_to_s(VALUE);
726
+ long rb_str_strlen(VALUE);
727
+ VALUE rb_str_length(VALUE);
728
+ long rb_str_offset(VALUE, long);
729
+ size_t rb_str_capacity(VALUE);
730
+ VALUE rb_str_ellipsize(VALUE, long);
731
+ #if defined(__GNUC__) && !defined(__PCC__)
732
+ #define rb_str_new_cstr(str) __extension__ ( \
733
+ { \
734
+ (__builtin_constant_p(str)) ? \
735
+ rb_str_new((str), (long)strlen(str)) : \
736
+ rb_str_new_cstr(str); \
737
+ })
738
+ #define rb_tainted_str_new_cstr(str) __extension__ ( \
739
+ { \
740
+ (__builtin_constant_p(str)) ? \
741
+ rb_tainted_str_new((str), (long)strlen(str)) : \
742
+ rb_tainted_str_new_cstr(str); \
743
+ })
744
+ #define rb_usascii_str_new_cstr(str) __extension__ ( \
745
+ { \
746
+ (__builtin_constant_p(str)) ? \
747
+ rb_usascii_str_new((str), (long)strlen(str)) : \
748
+ rb_usascii_str_new_cstr(str); \
749
+ })
750
+ #define rb_external_str_new_cstr(str) __extension__ ( \
751
+ { \
752
+ (__builtin_constant_p(str)) ? \
753
+ rb_external_str_new((str), (long)strlen(str)) : \
754
+ rb_external_str_new_cstr(str); \
755
+ })
756
+ #define rb_locale_str_new_cstr(str) __extension__ ( \
757
+ { \
758
+ (__builtin_constant_p(str)) ? \
759
+ rb_locale_str_new((str), (long)strlen(str)) : \
760
+ rb_locale_str_new_cstr(str); \
761
+ })
762
+ #define rb_str_buf_new_cstr(str) __extension__ ( \
763
+ { \
764
+ (__builtin_constant_p(str)) ? \
765
+ rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), \
766
+ (str), (long)strlen(str)) : \
767
+ rb_str_buf_new_cstr(str); \
768
+ })
769
+ #define rb_str_buf_cat2(str, ptr) __extension__ ( \
770
+ { \
771
+ (__builtin_constant_p(ptr)) ? \
772
+ rb_str_buf_cat((str), (ptr), (long)strlen(ptr)) : \
773
+ rb_str_buf_cat2((str), (ptr)); \
774
+ })
775
+ #define rb_str_cat2(str, ptr) __extension__ ( \
776
+ { \
777
+ (__builtin_constant_p(ptr)) ? \
778
+ rb_str_cat((str), (ptr), (long)strlen(ptr)) : \
779
+ rb_str_cat2((str), (ptr)); \
780
+ })
781
+ #define rb_exc_new2(klass, ptr) __extension__ ( \
782
+ { \
783
+ (__builtin_constant_p(ptr)) ? \
784
+ rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \
785
+ rb_exc_new2((klass), (ptr)); \
786
+ })
787
+ #endif
788
+ #define rb_str_new2 rb_str_new_cstr
789
+ #define rb_str_new3 rb_str_new_shared
790
+ #define rb_str_new4 rb_str_new_frozen
791
+ #define rb_str_new5 rb_str_new_with_class
792
+ #define rb_tainted_str_new2 rb_tainted_str_new_cstr
793
+ #define rb_str_buf_new2 rb_str_buf_new_cstr
794
+ #define rb_usascii_str_new2 rb_usascii_str_new_cstr
795
+ /* struct.c */
796
+ VALUE rb_struct_new(VALUE, ...);
797
+ VALUE rb_struct_define(const char*, ...);
798
+ VALUE rb_struct_alloc(VALUE, VALUE);
799
+ VALUE rb_struct_initialize(VALUE, VALUE);
800
+ VALUE rb_struct_aref(VALUE, VALUE);
801
+ VALUE rb_struct_aset(VALUE, VALUE, VALUE);
802
+ VALUE rb_struct_getmember(VALUE, RB_ID);
803
+ DEPRECATED(VALUE rb_struct_iv_get(VALUE, const char*));
804
+ VALUE rb_struct_s_members(VALUE);
805
+ VALUE rb_struct_members(VALUE);
806
+ VALUE rb_struct_alloc_noinit(VALUE);
807
+ VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t, ...);
808
+ /* thread.c */
809
+ typedef void rb_unblock_function_t(void *);
810
+ typedef VALUE rb_blocking_function_t(void *);
811
+ void rb_thread_check_ints(void);
812
+ int rb_thread_interrupted(VALUE thval);
813
+ VALUE rb_thread_blocking_region(rb_blocking_function_t *func, void *data1,
814
+ rb_unblock_function_t *ubf, void *data2);
815
+ #define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
816
+ #define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1)
817
+ VALUE rb_mutex_new(void);
818
+ VALUE rb_mutex_locked_p(VALUE mutex);
819
+ VALUE rb_mutex_trylock(VALUE mutex);
820
+ VALUE rb_mutex_lock(VALUE mutex);
821
+ VALUE rb_mutex_unlock(VALUE mutex);
822
+ VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
823
+ VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg);
824
+ VALUE rb_barrier_new(void);
825
+ VALUE rb_barrier_wait(VALUE self);
826
+ VALUE rb_barrier_release(VALUE self);
827
+ VALUE rb_barrier_destroy(VALUE self);
828
+ /* time.c */
829
+ VALUE rb_time_new(time_t, long);
830
+ VALUE rb_time_nano_new(time_t, long);
831
+ VALUE rb_time_num_new(VALUE, VALUE);
832
+ struct timeval rb_time_interval(VALUE num);
833
+ struct timeval rb_time_timeval(VALUE time);
834
+ struct timespec rb_time_timespec(VALUE time);
835
+ /* variable.c */
836
+ VALUE rb_mod_name(VALUE);
837
+ VALUE rb_class_path(VALUE);
838
+ void rb_set_class_path(VALUE, VALUE, const char*);
839
+ void rb_set_class_path_string(VALUE, VALUE, VALUE);
840
+ VALUE rb_path_to_class(VALUE);
841
+ VALUE rb_path2class(const char*);
842
+ void rb_name_class(VALUE, RB_ID);
843
+ VALUE rb_class_name(VALUE);
844
+ void rb_autoload(VALUE, RB_ID, const char*);
845
+ VALUE rb_autoload_load(VALUE, RB_ID);
846
+ VALUE rb_autoload_p(VALUE, RB_ID);
847
+ void rb_gc_mark_global_tbl(void);
848
+ VALUE rb_f_trace_var(int, VALUE*);
849
+ VALUE rb_f_untrace_var(int, VALUE*);
850
+ VALUE rb_f_global_variables(void);
851
+ void rb_alias_variable(RB_ID, RB_ID);
852
+ struct st_table* rb_generic_ivar_table(VALUE);
853
+ void rb_copy_generic_ivar(VALUE,VALUE);
854
+ void rb_mark_generic_ivar(VALUE);
855
+ void rb_mark_generic_ivar_tbl(void);
856
+ void rb_free_generic_ivar(VALUE);
857
+ VALUE rb_ivar_get(VALUE, RB_ID);
858
+ VALUE rb_ivar_set(VALUE, RB_ID, VALUE);
859
+ VALUE rb_ivar_defined(VALUE, RB_ID);
860
+ void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t);
861
+ st_index_t rb_ivar_count(VALUE);
862
+ VALUE rb_iv_set(VALUE, const char*, VALUE);
863
+ VALUE rb_iv_get(VALUE, const char*);
864
+ VALUE rb_attr_get(VALUE, RB_ID);
865
+ VALUE rb_obj_instance_variables(VALUE);
866
+ VALUE rb_obj_remove_instance_variable(VALUE, VALUE);
867
+ void *rb_mod_const_at(VALUE, void*);
868
+ void *rb_mod_const_of(VALUE, void*);
869
+ VALUE rb_const_list(void*);
870
+ VALUE rb_mod_constants(int, VALUE *, VALUE);
871
+ VALUE rb_mod_remove_const(VALUE, VALUE);
872
+ int rb_const_defined(VALUE, RB_ID);
873
+ int rb_const_defined_at(VALUE, RB_ID);
874
+ int rb_const_defined_from(VALUE, RB_ID);
875
+ VALUE rb_const_get(VALUE, RB_ID);
876
+ VALUE rb_const_get_at(VALUE, RB_ID);
877
+ VALUE rb_const_get_from(VALUE, RB_ID);
878
+ void rb_const_set(VALUE, RB_ID, VALUE);
879
+ VALUE rb_const_remove(VALUE, RB_ID);
880
+ VALUE rb_mod_const_missing(VALUE,VALUE);
881
+ VALUE rb_cvar_defined(VALUE, RB_ID);
882
+ void rb_cvar_set(VALUE, RB_ID, VALUE);
883
+ VALUE rb_cvar_get(VALUE, RB_ID);
884
+ void rb_cv_set(VALUE, const char*, VALUE);
885
+ VALUE rb_cv_get(VALUE, const char*);
886
+ void rb_define_class_variable(VALUE, const char*, VALUE);
887
+ VALUE rb_mod_class_variables(VALUE);
888
+ VALUE rb_mod_remove_cvar(VALUE, VALUE);
889
+ /* version.c */
890
+ void ruby_show_version(void);
891
+ void ruby_show_copyright(void);
892
+
893
+ RB_ID rb_frame_callee(void);
894
+ VALUE rb_str_succ(VALUE);
895
+ VALUE rb_time_succ(VALUE);
896
+ void rb_frame_pop(void);
897
+ int rb_frame_method_id_and_class(RB_ID *idp, VALUE *klassp);
898
+ VALUE rb_make_backtrace(void);
899
+ VALUE rb_make_exception(int, VALUE*);
900
+
901
+ #if defined __GNUC__ && __GNUC__ >= 4
902
+ #pragma GCC visibility pop
903
+ #endif
904
+
905
+ #if defined(__cplusplus)
906
+ #if 0
907
+ { /* satisfy cc-mode */
908
+ #endif
909
+ } /* extern "C" { */
910
+ #endif
911
+
912
+ #endif /* RUBY_INTERN_H */