Ruby  2.4.2p198(2017-09-14revision59899)
intern.h
Go to the documentation of this file.
1 /**********************************************************************
2 
3  intern.h -
4 
5  $Author: ktsj $
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 
35 #include "ruby/st.h"
36 
38 
39 /*
40  * Functions and variables that are used by more than one source file of
41  * the kernel.
42  */
43 
44 #define UNLIMITED_ARGUMENTS (-1)
45 
46 /* array.c */
47 void rb_mem_clear(register VALUE*, register long);
50 VALUE rb_ary_new(void);
51 VALUE rb_ary_new_capa(long capa);
52 VALUE rb_ary_new_from_args(long n, ...);
53 VALUE rb_ary_new_from_values(long n, const VALUE *elts);
54 VALUE rb_ary_tmp_new(long);
55 void rb_ary_free(VALUE);
56 void rb_ary_modify(VALUE);
59 VALUE rb_ary_aref(int, const VALUE*, VALUE);
60 VALUE rb_ary_subseq(VALUE, long, long);
61 void rb_ary_store(VALUE, long, VALUE);
66 VALUE rb_ary_cat(VALUE, const VALUE *, long);
71 VALUE rb_ary_entry(VALUE, long);
87 VALUE rb_ary_replace(VALUE copy, VALUE orig);
88 VALUE rb_get_values_at(VALUE, long, int, const VALUE*, VALUE(*)(VALUE,long));
89 VALUE rb_ary_resize(VALUE ary, long len);
90 #define rb_ary_new2 rb_ary_new_capa
91 #define rb_ary_new3 rb_ary_new_from_args
92 #define rb_ary_new4 rb_ary_new_from_values
93 /* bignum.c */
94 VALUE rb_big_new(size_t, int);
95 int rb_bigzero_p(VALUE x);
97 void rb_big_2comp(VALUE);
99 void rb_big_resize(VALUE big, size_t len);
100 VALUE rb_cstr_to_inum(const char*, int, int);
101 VALUE rb_str_to_inum(VALUE, int, int);
102 VALUE rb_cstr2inum(const char*, int);
103 VALUE rb_str2inum(VALUE, int);
104 VALUE rb_big2str(VALUE, int);
105 long rb_big2long(VALUE);
106 #define rb_big2int(x) rb_big2long(x)
107 unsigned long rb_big2ulong(VALUE);
108 #define rb_big2uint(x) rb_big2ulong(x)
109 #if HAVE_LONG_LONG
110 LONG_LONG rb_big2ll(VALUE);
111 unsigned LONG_LONG rb_big2ull(VALUE);
112 #endif /* HAVE_LONG_LONG */
113 void rb_big_pack(VALUE val, unsigned long *buf, long num_longs);
114 VALUE rb_big_unpack(unsigned long *buf, long num_longs);
115 int rb_uv_to_utf8(char[6],unsigned long);
116 VALUE rb_dbl2big(double);
117 double rb_big2dbl(VALUE);
134 
135 /* For rb_integer_pack and rb_integer_unpack: */
136 /* "MS" in MSWORD and MSBYTE means "most significant" */
137 /* "LS" in LSWORD and LSBYTE means "least significant" */
138 #define INTEGER_PACK_MSWORD_FIRST 0x01
139 #define INTEGER_PACK_LSWORD_FIRST 0x02
140 #define INTEGER_PACK_MSBYTE_FIRST 0x10
141 #define INTEGER_PACK_LSBYTE_FIRST 0x20
142 #define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40
143 #define INTEGER_PACK_2COMP 0x80
144 #define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400
145 /* For rb_integer_unpack: */
146 #define INTEGER_PACK_FORCE_BIGNUM 0x100
147 #define INTEGER_PACK_NEGATIVE 0x200
148 /* Combinations: */
149 #define INTEGER_PACK_LITTLE_ENDIAN \
150  (INTEGER_PACK_LSWORD_FIRST | \
151  INTEGER_PACK_LSBYTE_FIRST)
152 #define INTEGER_PACK_BIG_ENDIAN \
153  (INTEGER_PACK_MSWORD_FIRST | \
154  INTEGER_PACK_MSBYTE_FIRST)
155 int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags);
156 VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags);
157 size_t rb_absint_size(VALUE val, int *nlz_bits_ret);
158 size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret);
160 
161 /* rational.c */
163 #define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))
164 #define rb_rational_raw2(x,y) rb_rational_raw((x), (y))
166 #define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))
167 #define rb_rational_new2(x,y) rb_rational_new((x), (y))
169 #define rb_Rational1(x) rb_Rational((x), INT2FIX(1))
170 #define rb_Rational2(x,y) rb_Rational((x), (y))
175 /* complex.c */
177 #define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))
178 #define rb_complex_raw2(x,y) rb_complex_raw((x), (y))
180 #define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))
181 #define rb_complex_new2(x,y) rb_complex_new((x), (y))
184 #define rb_Complex1(x) rb_Complex((x), INT2FIX(0))
185 #define rb_Complex2(x,y) rb_Complex((x), (y))
188 /* class.c */
196 VALUE rb_module_new(void);
207 void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);
209 void rb_undef(VALUE, ID);
210 void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
211 void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
212 void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
214 /* compar.c */
215 int rb_cmpint(VALUE, VALUE, VALUE);
216 NORETURN(void rb_cmperr(VALUE, VALUE));
217 /* cont.c */
219 VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv);
220 VALUE rb_fiber_yield(int argc, const VALUE *argv);
221 VALUE rb_fiber_current(void);
223 /* enum.c */
224 VALUE rb_enum_values_pack(int, const VALUE*);
225 /* enumerator.c */
226 VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *);
229 #ifndef RUBY_EXPORT
230 #define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn) \
231  rb_enumeratorize_with_size(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn))
232 #endif
233 #define SIZED_ENUMERATOR(obj, argc, argv, size_fn) \
234  rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), \
235  (argc), (argv), (size_fn))
236 #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do { \
237  if (!rb_block_given_p()) \
238  return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \
239  } while (0)
240 #define RETURN_ENUMERATOR(obj, argc, argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0)
241 /* error.c */
242 VALUE rb_exc_new(VALUE, const char*, long);
243 VALUE rb_exc_new_cstr(VALUE, const char*);
245 #define rb_exc_new2 rb_exc_new_cstr
246 #define rb_exc_new3 rb_exc_new_str
247 PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
248 PRINTF_ARGS(NORETURN(void rb_loaderror_with_path(VALUE path, const char*, ...)), 2, 3);
249 PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);
250 PRINTF_ARGS(NORETURN(void rb_name_error_str(VALUE, const char*, ...)), 2, 3);
251 NORETURN(void rb_invalid_str(const char*, const char*));
252 NORETURN(DEPRECATED(PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4)));
253 NORETURN(DEPRECATED(PRINTF_ARGS(void rb_compile_error_with_enc(const char*, int, void *, const char*, ...), 4, 5)));
254 NORETURN(DEPRECATED(PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2)));
255 NORETURN(void rb_error_frozen(const char*));
258 void rb_check_frozen(VALUE);
260 #define rb_check_frozen_internal(obj) do { \
261  VALUE frozen_obj = (obj); \
262  if (OBJ_FROZEN(frozen_obj)) { \
263  rb_error_frozen_object(frozen_obj); \
264  } \
265  } while (0)
266 #define rb_check_trusted_internal(obj) ((void) 0)
267 #ifdef __GNUC__
268 #define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})
269 #define rb_check_trusted(obj) __extension__({rb_check_trusted_internal(obj);})
270 #else
271 static inline void
273 {
275 }
276 #define rb_check_frozen(obj) rb_check_frozen_inline(obj)
277 static inline void
279 {
281 }
282 #define rb_check_trusted(obj) rb_check_trusted_inline(obj)
283 #endif
284 void rb_check_copyable(VALUE obj, VALUE orig);
285 
286 #define RB_OBJ_INIT_COPY(obj, orig) \
287  ((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1))
288 #define OBJ_INIT_COPY(obj, orig) RB_OBJ_INIT_COPY(obj, orig)
289 
290 /* eval.c */
291 int rb_sourceline(void);
292 const char *rb_sourcefile(void);
293 VALUE rb_check_funcall(VALUE, ID, int, const VALUE*);
294 
295 NORETURN(void rb_error_arity(int, int, int));
296 static inline int
297 rb_check_arity(int argc, int min, int max)
298 {
299  if ((argc < min) || (max != UNLIMITED_ARGUMENTS && argc > max))
300  rb_error_arity(argc, min, max);
301  return argc;
302 }
303 #define rb_check_arity rb_check_arity /* for ifdef */
304 
305 #if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)
306 typedef struct {
307  int maxfd;
308  fd_set *fdset;
309 } rb_fdset_t;
310 
311 void rb_fd_init(rb_fdset_t *);
312 void rb_fd_term(rb_fdset_t *);
313 void rb_fd_zero(rb_fdset_t *);
314 void rb_fd_set(int, rb_fdset_t *);
315 void rb_fd_clr(int, rb_fdset_t *);
316 int rb_fd_isset(int, const rb_fdset_t *);
317 void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
318 void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
319 
320 struct timeval;
321 int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
322 
323 #define rb_fd_ptr(f) ((f)->fdset)
324 #define rb_fd_max(f) ((f)->maxfd)
325 
326 #elif defined(_WIN32)
327 
328 typedef struct {
329  int capa;
330  fd_set *fdset;
331 } rb_fdset_t;
332 
333 void rb_fd_init(rb_fdset_t *);
334 void rb_fd_term(rb_fdset_t *);
335 #define rb_fd_zero(f) ((f)->fdset->fd_count = 0)
336 void rb_fd_set(int, rb_fdset_t *);
337 #define rb_fd_clr(n, f) rb_w32_fdclr((n), (f)->fdset)
338 #define rb_fd_isset(n, f) rb_w32_fdisset((n), (f)->fdset)
339 #define rb_fd_copy(d, s, n) rb_w32_fd_copy((d), (s), (n))
340 void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int);
341 #define rb_fd_dup(d, s) rb_w32_fd_dup((d), (s))
342 void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
343 #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))
344 #define rb_fd_resize(n, f) ((void)(f))
345 
346 #define rb_fd_ptr(f) ((f)->fdset)
347 #define rb_fd_max(f) ((f)->fdset->fd_count)
348 
349 #else
350 
351 typedef fd_set rb_fdset_t;
352 #define rb_fd_zero(f) FD_ZERO(f)
353 #define rb_fd_set(n, f) FD_SET((n), (f))
354 #define rb_fd_clr(n, f) FD_CLR((n), (f))
355 #define rb_fd_isset(n, f) FD_ISSET((n), (f))
356 #define rb_fd_copy(d, s, n) (*(d) = *(s))
357 #define rb_fd_dup(d, s) (*(d) = *(s))
358 #define rb_fd_resize(n, f) ((void)(f))
359 #define rb_fd_ptr(f) (f)
360 #define rb_fd_init(f) FD_ZERO(f)
361 #define rb_fd_init_copy(d, s) (*(d) = *(s))
362 #define rb_fd_term(f) ((void)(f))
363 #define rb_fd_max(f) FD_SETSIZE
364 #define rb_fd_select(n, rfds, wfds, efds, timeout) select((n), (rfds), (wfds), (efds), (timeout))
365 
366 #endif
367 
370 NORETURN(VALUE rb_f_exit(int, const VALUE*));
371 NORETURN(VALUE rb_f_abort(int, const VALUE*));
372 void rb_remove_method(VALUE, const char*);
374 DEPRECATED(static inline void rb_disable_super(void));
375 DEPRECATED(static inline void rb_enable_super(void));
376 static inline void rb_disable_super(void)
377 {
378  /* obsolete - no use */
379 }
380 static inline void rb_enable_super(void)
381 {
382  rb_warning("rb_enable_super() is obsolete");
383 }
384 #define rb_disable_super(klass, name) rb_disable_super()
385 #define rb_enable_super(klass, name) rb_enable_super()
386 #define HAVE_RB_DEFINE_ALLOC_FUNC 1
391 NORETURN(DEPRECATED(void rb_clear_cache(void)));
392 void rb_clear_constant_cache(void);
394 void rb_alias(VALUE, ID, ID);
395 void rb_attr(VALUE,ID,int,int,int);
396 int rb_method_boundp(VALUE, ID, int);
399 int rb_obj_respond_to(VALUE, ID, int);
400 int rb_respond_to(VALUE, ID);
401 NORETURN(VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj));
402 #if !defined(RUBY_EXPORT) && defined(_WIN32)
403 RUBY_EXTERN VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE);
404 #define rb_f_notimplement (*rb_f_notimplement_)
405 #endif
406 NORETURN(void rb_interrupt(void));
407 VALUE rb_apply(VALUE, ID, VALUE);
408 void rb_backtrace(void);
409 ID rb_frame_this_func(void);
410 VALUE rb_obj_instance_eval(int, const VALUE*, VALUE);
411 VALUE rb_obj_instance_exec(int, const VALUE*, VALUE);
412 VALUE rb_mod_module_eval(int, const VALUE*, VALUE);
413 VALUE rb_mod_module_exec(int, const VALUE*, VALUE);
414 void rb_load(VALUE, int);
415 void rb_load_protect(VALUE, int, int*);
416 NORETURN(void rb_jump_tag(int));
417 int rb_provided(const char*);
418 int rb_feature_provided(const char *, const char **);
419 void rb_provide(const char*);
420 VALUE rb_f_require(VALUE, VALUE);
421 VALUE rb_require_safe(VALUE, int);
422 void rb_obj_call_init(VALUE, int, const VALUE*);
423 VALUE rb_class_new_instance(int, const VALUE*, VALUE);
424 VALUE rb_block_proc(void);
425 VALUE rb_block_lambda(void);
426 VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
427 VALUE rb_obj_is_proc(VALUE);
428 VALUE rb_proc_call(VALUE, VALUE);
429 VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE);
430 int rb_proc_arity(VALUE);
431 VALUE rb_proc_lambda_p(VALUE);
432 VALUE rb_binding_new(void);
433 VALUE rb_obj_method(VALUE, VALUE);
434 VALUE rb_obj_is_method(VALUE);
435 VALUE rb_method_call(int, const VALUE*, VALUE);
436 VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE);
437 int rb_mod_method_arity(VALUE, ID);
438 int rb_obj_method_arity(VALUE, ID);
439 VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
440 void rb_set_end_proc(void (*)(VALUE), VALUE);
441 void rb_exec_end_proc(void);
442 void rb_thread_schedule(void);
443 void rb_thread_wait_fd(int);
444 int rb_thread_fd_writable(int);
445 void rb_thread_fd_close(int);
446 int rb_thread_alone(void);
447 void rb_thread_sleep(int);
448 void rb_thread_sleep_forever(void);
449 void rb_thread_sleep_deadly(void);
450 VALUE rb_thread_stop(void);
451 VALUE rb_thread_wakeup(VALUE);
452 VALUE rb_thread_wakeup_alive(VALUE);
453 VALUE rb_thread_run(VALUE);
454 VALUE rb_thread_kill(VALUE);
455 VALUE rb_thread_create(VALUE (*)(ANYARGS), void*);
456 int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
457 void rb_thread_wait_for(struct timeval);
458 VALUE rb_thread_current(void);
459 VALUE rb_thread_main(void);
460 VALUE rb_thread_local_aref(VALUE, ID);
461 VALUE rb_thread_local_aset(VALUE, ID, VALUE);
462 void rb_thread_atfork(void);
464 VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
465 VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE);
466 VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
467 VALUE rb_exec_recursive_paired_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE);
468 /* dir.c */
469 VALUE rb_dir_getwd(void);
470 /* file.c */
471 VALUE rb_file_s_expand_path(int, const VALUE *);
472 VALUE rb_file_expand_path(VALUE, VALUE);
473 VALUE rb_file_s_absolute_path(int, const VALUE *);
474 VALUE rb_file_absolute_path(VALUE, VALUE);
475 VALUE rb_file_dirname(VALUE fname);
476 int rb_find_file_ext_safe(VALUE*, const char* const*, int);
477 VALUE rb_find_file_safe(VALUE, int);
478 int rb_find_file_ext(VALUE*, const char* const*);
479 VALUE rb_find_file(VALUE);
480 VALUE rb_file_directory_p(VALUE,VALUE);
481 VALUE rb_str_encode_ospath(VALUE);
482 int rb_is_absolute_path(const char *);
483 /* gc.c */
484 NORETURN(void rb_memerror(void));
485 PUREFUNC(int rb_during_gc(void));
486 void rb_gc_mark_locations(const VALUE*, const VALUE*);
487 void rb_mark_tbl(struct st_table*);
488 void rb_mark_set(struct st_table*);
489 void rb_mark_hash(struct st_table*);
490 void rb_gc_mark_maybe(VALUE);
491 void rb_gc_mark(VALUE);
492 void rb_gc_force_recycle(VALUE);
493 void rb_gc(void);
494 void rb_gc_copy_finalizer(VALUE,VALUE);
495 void rb_gc_finalize_deferred(void);
497 VALUE rb_gc_enable(void);
498 VALUE rb_gc_disable(void);
499 VALUE rb_gc_start(void);
500 VALUE rb_define_finalizer(VALUE, VALUE);
501 VALUE rb_undefine_finalizer(VALUE);
502 size_t rb_gc_count(void);
503 size_t rb_gc_stat(VALUE);
504 VALUE rb_gc_latest_gc_info(VALUE);
505 void rb_gc_adjust_memory_usage(ssize_t);
506 /* hash.c */
507 void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t);
508 VALUE rb_check_hash_type(VALUE);
509 void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE);
510 VALUE rb_hash(VALUE);
511 VALUE rb_hash_new(void);
512 VALUE rb_hash_dup(VALUE);
513 VALUE rb_hash_freeze(VALUE);
514 VALUE rb_hash_aref(VALUE, VALUE);
515 VALUE rb_hash_lookup(VALUE, VALUE);
516 VALUE rb_hash_lookup2(VALUE, VALUE, VALUE);
517 VALUE rb_hash_fetch(VALUE, VALUE);
518 VALUE rb_hash_aset(VALUE, VALUE, VALUE);
519 VALUE rb_hash_clear(VALUE);
520 VALUE rb_hash_delete_if(VALUE);
521 VALUE rb_hash_delete(VALUE,VALUE);
522 VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone);
523 typedef VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value);
524 VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func);
525 struct st_table *rb_hash_tbl(VALUE);
526 int rb_path_check(const char*);
527 int rb_env_path_tainted(void);
528 VALUE rb_env_clear(void);
529 VALUE rb_hash_size(VALUE);
530 DEPRECATED(int rb_hash_iter_lev(VALUE));
531 DEPRECATED(VALUE rb_hash_ifnone(VALUE));
532 /* io.c */
533 #define rb_defout rb_stdout
539 VALUE rb_io_write(VALUE, VALUE);
540 VALUE rb_io_gets(VALUE);
541 VALUE rb_io_getbyte(VALUE);
542 VALUE rb_io_ungetc(VALUE, VALUE);
543 VALUE rb_io_ungetbyte(VALUE, VALUE);
544 VALUE rb_io_close(VALUE);
545 VALUE rb_io_flush(VALUE);
546 VALUE rb_io_eof(VALUE);
547 VALUE rb_io_binmode(VALUE);
548 VALUE rb_io_ascii8bit_binmode(VALUE);
549 VALUE rb_io_addstr(VALUE, VALUE);
550 VALUE rb_io_printf(int, const VALUE*, VALUE);
551 VALUE rb_io_print(int, const VALUE*, VALUE);
552 VALUE rb_io_puts(int, const VALUE*, VALUE);
553 VALUE rb_io_fdopen(int, int, const char*);
554 VALUE rb_io_get_io(VALUE);
555 VALUE rb_file_open(const char*, const char*);
556 VALUE rb_file_open_str(VALUE, const char*);
557 VALUE rb_gets(void);
558 void rb_write_error(const char*);
559 void rb_write_error2(const char*, long);
560 void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds);
561 int rb_pipe(int *pipes);
562 int rb_reserved_fd_p(int fd);
563 int rb_cloexec_open(const char *pathname, int flags, mode_t mode);
564 int rb_cloexec_dup(int oldfd);
565 int rb_cloexec_dup2(int oldfd, int newfd);
566 int rb_cloexec_pipe(int fildes[2]);
567 int rb_cloexec_fcntl_dupfd(int fd, int minfd);
568 #define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)
569 void rb_update_max_fd(int fd);
570 void rb_fd_fix_cloexec(int fd);
571 /* marshal.c */
572 VALUE rb_marshal_dump(VALUE, VALUE);
573 VALUE rb_marshal_load(VALUE);
574 void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE));
575 /* numeric.c */
576 NORETURN(void rb_num_zerodiv(void));
577 #define RB_NUM_COERCE_FUNCS_NEED_OPID 1
578 VALUE rb_num_coerce_bin(VALUE, VALUE, ID);
579 VALUE rb_num_coerce_cmp(VALUE, VALUE, ID);
580 VALUE rb_num_coerce_relop(VALUE, VALUE, ID);
581 VALUE rb_num_coerce_bit(VALUE, VALUE, ID);
582 VALUE rb_num2fix(VALUE);
583 VALUE rb_fix2str(VALUE, int);
584 CONSTFUNC(VALUE rb_dbl_cmp(double, double));
585 /* object.c */
586 int rb_eql(VALUE, VALUE);
587 VALUE rb_any_to_s(VALUE);
588 VALUE rb_inspect(VALUE);
589 VALUE rb_obj_is_instance_of(VALUE, VALUE);
590 VALUE rb_obj_is_kind_of(VALUE, VALUE);
591 VALUE rb_obj_alloc(VALUE);
592 VALUE rb_obj_clone(VALUE);
593 VALUE rb_obj_dup(VALUE);
594 VALUE rb_obj_init_copy(VALUE,VALUE);
595 VALUE rb_obj_taint(VALUE);
596 PUREFUNC(VALUE rb_obj_tainted(VALUE));
597 VALUE rb_obj_untaint(VALUE);
598 VALUE rb_obj_untrust(VALUE);
599 PUREFUNC(VALUE rb_obj_untrusted(VALUE));
600 VALUE rb_obj_trust(VALUE);
601 VALUE rb_obj_freeze(VALUE);
602 PUREFUNC(VALUE rb_obj_frozen_p(VALUE));
603 VALUE rb_obj_id(VALUE);
604 VALUE rb_obj_class(VALUE);
605 PUREFUNC(VALUE rb_class_real(VALUE));
606 PUREFUNC(VALUE rb_class_inherited_p(VALUE, VALUE));
607 VALUE rb_class_superclass(VALUE);
608 VALUE rb_class_get_superclass(VALUE);
609 VALUE rb_convert_type(VALUE,int,const char*,const char*);
610 VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
611 VALUE rb_check_to_integer(VALUE, const char *);
612 VALUE rb_check_to_float(VALUE);
613 VALUE rb_to_int(VALUE);
614 VALUE rb_check_to_int(VALUE);
615 VALUE rb_Integer(VALUE);
616 VALUE rb_to_float(VALUE);
617 VALUE rb_Float(VALUE);
618 VALUE rb_String(VALUE);
619 VALUE rb_Array(VALUE);
620 VALUE rb_Hash(VALUE);
621 double rb_cstr_to_dbl(const char*, int);
622 double rb_str_to_dbl(VALUE, int);
623 /* parse.y */
632 int rb_symname_p(const char*);
633 int rb_sym_interned_p(VALUE);
634 VALUE rb_backref_get(void);
635 void rb_backref_set(VALUE);
636 VALUE rb_lastline_get(void);
637 void rb_lastline_set(VALUE);
638 /* process.c */
639 void rb_last_status_set(int status, rb_pid_t pid);
640 VALUE rb_last_status_get(void);
641 int rb_proc_exec(const char*);
642 NORETURN(VALUE rb_f_exec(int, const VALUE*));
643 rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags);
644 void rb_syswait(rb_pid_t pid);
645 rb_pid_t rb_spawn(int, const VALUE*);
646 rb_pid_t rb_spawn_err(int, const VALUE*, char*, size_t);
647 VALUE rb_proc_times(VALUE);
648 VALUE rb_detach_process(rb_pid_t pid);
649 /* range.c */
650 VALUE rb_range_new(VALUE, VALUE, int);
651 VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
652 int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp);
653 /* random.c */
654 unsigned int rb_genrand_int32(void);
655 double rb_genrand_real(void);
656 void rb_reset_random_seed(void);
657 VALUE rb_random_bytes(VALUE rnd, long n);
658 VALUE rb_random_int(VALUE rnd, VALUE max);
659 unsigned int rb_random_int32(VALUE rnd);
660 double rb_random_real(VALUE rnd);
661 unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit);
662 unsigned long rb_genrand_ulong_limited(unsigned long i);
663 /* re.c */
664 #define rb_memcmp memcmp
665 int rb_memcicmp(const void*,const void*,long);
666 void rb_match_busy(VALUE);
667 VALUE rb_reg_nth_defined(int, VALUE);
668 VALUE rb_reg_nth_match(int, VALUE);
669 int rb_reg_backref_number(VALUE match, VALUE backref);
670 VALUE rb_reg_last_match(VALUE);
671 VALUE rb_reg_match_pre(VALUE);
672 VALUE rb_reg_match_post(VALUE);
673 VALUE rb_reg_match_last(VALUE);
674 #define HAVE_RB_REG_NEW_STR 1
675 VALUE rb_reg_new_str(VALUE, int);
676 VALUE rb_reg_new(const char *, long, int);
677 VALUE rb_reg_alloc(void);
678 VALUE rb_reg_init_str(VALUE re, VALUE s, int options);
679 VALUE rb_reg_match(VALUE, VALUE);
680 VALUE rb_reg_match2(VALUE);
681 int rb_reg_options(VALUE);
682 /* ruby.c */
683 #define rb_argv rb_get_argv()
685 VALUE rb_get_argv(void);
686 void *rb_load_file(const char*);
687 void *rb_load_file_str(VALUE);
688 /* signal.c */
689 VALUE rb_f_kill(int, const VALUE*);
690 #ifdef POSIX_SIGNAL
691 #define posix_signal ruby_posix_signal
692 RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int);
693 #endif
694 void rb_trap_exit(void);
695 void rb_trap_exec(void);
696 const char *ruby_signal_name(int);
697 void ruby_default_signal(int);
698 /* sprintf.c */
699 VALUE rb_f_sprintf(int, const VALUE*);
700 PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
701 VALUE rb_vsprintf(const char*, va_list);
702 PRINTF_ARGS(VALUE rb_str_catf(VALUE, const char*, ...), 2, 3);
703 VALUE rb_str_vcatf(VALUE, const char*, va_list);
704 VALUE rb_str_format(int, const VALUE *, VALUE);
705 /* string.c */
706 VALUE rb_str_new(const char*, long);
707 VALUE rb_str_new_cstr(const char*);
708 VALUE rb_str_new_shared(VALUE);
709 VALUE rb_str_new_frozen(VALUE);
710 VALUE rb_str_new_with_class(VALUE, const char*, long);
711 VALUE rb_tainted_str_new_cstr(const char*);
712 VALUE rb_tainted_str_new(const char*, long);
713 VALUE rb_external_str_new(const char*, long);
714 VALUE rb_external_str_new_cstr(const char*);
715 VALUE rb_locale_str_new(const char*, long);
716 VALUE rb_locale_str_new_cstr(const char*);
717 VALUE rb_filesystem_str_new(const char*, long);
718 VALUE rb_filesystem_str_new_cstr(const char*);
719 VALUE rb_str_buf_new(long);
720 VALUE rb_str_buf_new_cstr(const char*);
721 VALUE rb_str_buf_new2(const char*);
722 VALUE rb_str_tmp_new(long);
723 VALUE rb_usascii_str_new(const char*, long);
724 VALUE rb_usascii_str_new_cstr(const char*);
725 VALUE rb_utf8_str_new(const char*, long);
726 VALUE rb_utf8_str_new_cstr(const char*);
727 VALUE rb_str_new_static(const char *, long);
728 VALUE rb_usascii_str_new_static(const char *, long);
729 VALUE rb_utf8_str_new_static(const char *, long);
730 void rb_str_free(VALUE);
731 void rb_str_shared_replace(VALUE, VALUE);
732 VALUE rb_str_buf_append(VALUE, VALUE);
733 VALUE rb_str_buf_cat(VALUE, const char*, long);
734 VALUE rb_str_buf_cat2(VALUE, const char*);
735 VALUE rb_str_buf_cat_ascii(VALUE, const char*);
736 VALUE rb_obj_as_string(VALUE);
737 VALUE rb_check_string_type(VALUE);
738 void rb_must_asciicompat(VALUE);
739 VALUE rb_str_dup(VALUE);
740 VALUE rb_str_resurrect(VALUE str);
741 VALUE rb_str_locktmp(VALUE);
742 VALUE rb_str_unlocktmp(VALUE);
743 VALUE rb_str_dup_frozen(VALUE);
744 #define rb_str_dup_frozen rb_str_new_frozen
745 VALUE rb_str_plus(VALUE, VALUE);
746 VALUE rb_str_times(VALUE, VALUE);
747 long rb_str_sublen(VALUE, long);
748 VALUE rb_str_substr(VALUE, long, long);
749 VALUE rb_str_subseq(VALUE, long, long);
750 char *rb_str_subpos(VALUE, long, long*);
751 void rb_str_modify(VALUE);
752 void rb_str_modify_expand(VALUE, long);
753 VALUE rb_str_freeze(VALUE);
754 void rb_str_set_len(VALUE, long);
755 VALUE rb_str_resize(VALUE, long);
756 VALUE rb_str_cat(VALUE, const char*, long);
757 VALUE rb_str_cat_cstr(VALUE, const char*);
758 VALUE rb_str_cat2(VALUE, const char*);
759 VALUE rb_str_append(VALUE, VALUE);
760 VALUE rb_str_concat(VALUE, VALUE);
761 st_index_t rb_memhash(const void *ptr, long len);
766 #define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
767 #define rb_hash_uint(h, i) st_hash_uint((h), (i))
768 #define rb_hash_end(h) st_hash_end(h)
769 st_index_t rb_str_hash(VALUE);
770 int rb_str_hash_cmp(VALUE,VALUE);
771 int rb_str_comparable(VALUE, VALUE);
772 int rb_str_cmp(VALUE, VALUE);
773 VALUE rb_str_equal(VALUE str1, VALUE str2);
774 VALUE rb_str_drop_bytes(VALUE, long);
775 void rb_str_update(VALUE, long, long, VALUE);
776 VALUE rb_str_replace(VALUE, VALUE);
777 VALUE rb_str_inspect(VALUE);
778 VALUE rb_str_dump(VALUE);
779 VALUE rb_str_split(VALUE, const char*);
780 NORETURN(DEPRECATED(void rb_str_associate(VALUE, VALUE)));
781 NORETURN(DEPRECATED(VALUE rb_str_associated(VALUE)));
782 void rb_str_setter(VALUE, ID, VALUE*);
783 VALUE rb_str_intern(VALUE);
784 VALUE rb_sym_to_s(VALUE);
785 long rb_str_strlen(VALUE);
786 VALUE rb_str_length(VALUE);
787 long rb_str_offset(VALUE, long);
788 PUREFUNC(size_t rb_str_capacity(VALUE));
789 VALUE rb_str_ellipsize(VALUE, long);
790 VALUE rb_str_scrub(VALUE, VALUE);
791 /* symbol.c */
792 VALUE rb_sym_all_symbols(void);
793 
794 #ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
795 #define rb_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
796  (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
797  rb_str_new_static((str), (len)) : \
798  rb_str_new((str), (len)) \
799 )
800 #define rb_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
801  (__builtin_constant_p(str)) ? \
802  rb_str_new_static((str), (long)strlen(str)) : \
803  rb_str_new_cstr(str) \
804 )
805 #define rb_usascii_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
806  (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
807  rb_usascii_str_new_static((str), (len)) : \
808  rb_usascii_str_new((str), (len)) \
809 )
810 #define rb_utf8_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
811  (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
812  rb_utf8_str_new_static((str), (len)) : \
813  rb_utf8_str_new((str), (len)) \
814 )
815 #define rb_tainted_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
816  (__builtin_constant_p(str)) ? \
817  rb_tainted_str_new((str), (long)strlen(str)) : \
818  rb_tainted_str_new_cstr(str) \
819 )
820 #define rb_usascii_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
821  (__builtin_constant_p(str)) ? \
822  rb_usascii_str_new_static((str), (long)strlen(str)) : \
823  rb_usascii_str_new_cstr(str) \
824 )
825 #define rb_utf8_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
826  (__builtin_constant_p(str)) ? \
827  rb_utf8_str_new_static((str), (long)strlen(str)) : \
828  rb_utf8_str_new_cstr(str) \
829 )
830 #define rb_external_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
831  (__builtin_constant_p(str)) ? \
832  rb_external_str_new((str), (long)strlen(str)) : \
833  rb_external_str_new_cstr(str) \
834 )
835 #define rb_locale_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
836  (__builtin_constant_p(str)) ? \
837  rb_locale_str_new((str), (long)strlen(str)) : \
838  rb_locale_str_new_cstr(str) \
839 )
840 #define rb_str_buf_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
841  (__builtin_constant_p(str)) ? \
842  rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), \
843  (str), (long)strlen(str)) : \
844  rb_str_buf_new_cstr(str) \
845 )
846 #define rb_str_cat_cstr(str, ptr) RB_GNUC_EXTENSION_BLOCK( \
847  (__builtin_constant_p(ptr)) ? \
848  rb_str_cat((str), (ptr), (long)strlen(ptr)) : \
849  rb_str_cat_cstr((str), (ptr)) \
850 )
851 #define rb_exc_new_cstr(klass, ptr) RB_GNUC_EXTENSION_BLOCK( \
852  (__builtin_constant_p(ptr)) ? \
853  rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \
854  rb_exc_new_cstr((klass), (ptr)) \
855 )
856 #endif
857 #define rb_str_new2 rb_str_new_cstr
858 #define rb_str_new3 rb_str_new_shared
859 #define rb_str_new4 rb_str_new_frozen
860 #define rb_str_new5 rb_str_new_with_class
861 #define rb_tainted_str_new2 rb_tainted_str_new_cstr
862 #define rb_str_buf_new2 rb_str_buf_new_cstr
863 #define rb_usascii_str_new2 rb_usascii_str_new_cstr
864 #define rb_str_buf_cat rb_str_cat
865 #define rb_str_buf_cat2 rb_str_cat_cstr
866 #define rb_str_cat2 rb_str_cat_cstr
867 #define rb_strlen_lit(str) (sizeof(str "") - 1)
868 #define rb_str_new_lit(str) rb_str_new_static((str), rb_strlen_lit(str))
869 #define rb_usascii_str_new_lit(str) rb_usascii_str_new_static((str), rb_strlen_lit(str))
870 #define rb_utf8_str_new_lit(str) rb_utf8_str_new_static((str), rb_strlen_lit(str))
871 #define rb_enc_str_new_lit(str, enc) rb_enc_str_new_static((str), rb_strlen_lit(str), (enc))
872 #define rb_str_new_literal(str) rb_str_new_lit(str)
873 #define rb_usascii_str_new_literal(str) rb_usascii_str_new_lit(str)
874 #define rb_utf8_str_new_literal(str) rb_utf8_str_new_lit(str)
875 #define rb_enc_str_new_literal(str, enc) rb_enc_str_new_lit(str, enc)
876 
877 /* struct.c */
878 VALUE rb_struct_new(VALUE, ...);
879 VALUE rb_struct_define(const char*, ...);
880 VALUE rb_struct_define_under(VALUE, const char*, ...);
881 VALUE rb_struct_alloc(VALUE, VALUE);
882 VALUE rb_struct_initialize(VALUE, VALUE);
883 VALUE rb_struct_aref(VALUE, VALUE);
884 VALUE rb_struct_aset(VALUE, VALUE, VALUE);
885 VALUE rb_struct_getmember(VALUE, ID);
886 VALUE rb_struct_s_members(VALUE);
887 VALUE rb_struct_members(VALUE);
888 VALUE rb_struct_size(VALUE s);
889 DEPRECATED(const VALUE *rb_struct_ptr(VALUE s));
890 VALUE rb_struct_alloc_noinit(VALUE);
891 VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t, ...);
892 VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, ...);
893 
894 /* thread.c */
895 typedef void rb_unblock_function_t(void *);
896 typedef VALUE rb_blocking_function_t(void *);
897 void rb_thread_check_ints(void);
898 int rb_thread_interrupted(VALUE thval);
899 
900 #define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
901 #define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1)
902 VALUE rb_mutex_new(void);
903 VALUE rb_mutex_locked_p(VALUE mutex);
904 VALUE rb_mutex_trylock(VALUE mutex);
905 VALUE rb_mutex_lock(VALUE mutex);
906 VALUE rb_mutex_unlock(VALUE mutex);
907 VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
908 VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg);
909 /* time.c */
910 void rb_timespec_now(struct timespec *);
911 VALUE rb_time_new(time_t, long);
912 VALUE rb_time_nano_new(time_t, long);
913 VALUE rb_time_timespec_new(const struct timespec *, int);
914 VALUE rb_time_num_new(VALUE, VALUE);
915 struct timeval rb_time_interval(VALUE num);
916 struct timeval rb_time_timeval(VALUE time);
917 struct timespec rb_time_timespec(VALUE time);
918 /* variable.c */
919 VALUE rb_mod_name(VALUE);
920 VALUE rb_class_path(VALUE);
921 VALUE rb_class_path_cached(VALUE);
922 void rb_set_class_path(VALUE, VALUE, const char*);
923 void rb_set_class_path_string(VALUE, VALUE, VALUE);
924 VALUE rb_path_to_class(VALUE);
925 VALUE rb_path2class(const char*);
926 void rb_name_class(VALUE, ID);
927 VALUE rb_class_name(VALUE);
928 DEPRECATED(void rb_autoload(VALUE, ID, const char*));
929 VALUE rb_autoload_load(VALUE, ID);
930 VALUE rb_autoload_p(VALUE, ID);
931 VALUE rb_f_trace_var(int, const VALUE*);
932 VALUE rb_f_untrace_var(int, const VALUE*);
933 VALUE rb_f_global_variables(void);
934 void rb_alias_variable(ID, ID);
936 void rb_copy_generic_ivar(VALUE,VALUE);
937 void rb_free_generic_ivar(VALUE);
938 VALUE rb_ivar_get(VALUE, ID);
939 VALUE rb_ivar_set(VALUE, ID, VALUE);
940 VALUE rb_ivar_defined(VALUE, ID);
941 void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t);
943 VALUE rb_attr_get(VALUE, ID);
944 VALUE rb_obj_instance_variables(VALUE);
945 VALUE rb_obj_remove_instance_variable(VALUE, VALUE);
946 void *rb_mod_const_at(VALUE, void*);
947 void *rb_mod_const_of(VALUE, void*);
948 VALUE rb_const_list(void*);
949 VALUE rb_mod_constants(int, const VALUE *, VALUE);
950 VALUE rb_mod_remove_const(VALUE, VALUE);
951 int rb_const_defined(VALUE, ID);
952 int rb_const_defined_at(VALUE, ID);
953 int rb_const_defined_from(VALUE, ID);
954 VALUE rb_const_get(VALUE, ID);
955 VALUE rb_const_get_at(VALUE, ID);
956 VALUE rb_const_get_from(VALUE, ID);
957 void rb_const_set(VALUE, ID, VALUE);
958 VALUE rb_const_remove(VALUE, ID);
959 NORETURN(VALUE rb_mod_const_missing(VALUE,VALUE));
960 VALUE rb_cvar_defined(VALUE, ID);
961 void rb_cvar_set(VALUE, ID, VALUE);
962 VALUE rb_cvar_get(VALUE, ID);
963 void rb_cv_set(VALUE, const char*, VALUE);
964 VALUE rb_cv_get(VALUE, const char*);
965 void rb_define_class_variable(VALUE, const char*, VALUE);
966 VALUE rb_mod_class_variables(int, const VALUE*, VALUE);
967 VALUE rb_mod_remove_cvar(VALUE, VALUE);
968 
969 ID rb_frame_callee(void);
970 VALUE rb_str_succ(VALUE);
971 VALUE rb_time_succ(VALUE);
972 int rb_frame_method_id_and_class(ID *idp, VALUE *klassp);
973 VALUE rb_make_backtrace(void);
974 VALUE rb_make_exception(int, const VALUE*);
975 
976 /* deprecated */
977 NORETURN(DEPRECATED(void rb_frame_pop(void)));
978 
979 
981 
982 #if defined(__cplusplus)
983 #if 0
984 { /* satisfy cc-mode */
985 #endif
986 } /* extern "C" { */
987 #endif
988 
989 #endif /* RUBY_INTERN_H */
VALUE rb_apply(VALUE, ID, VALUE)
Calls a method.
Definition: vm_eval.c:792
void rb_gc_call_finalizer_at_exit(void)
Definition: gc.c:2850
struct timeval rb_time_interval(VALUE num)
Definition: time.c:2286
int rb_provided(const char *)
Definition: load.c:522
VALUE rb_mutex_lock(VALUE mutex)
Definition: thread_sync.c:241
struct st_table * rb_hash_tbl(VALUE)
Definition: hash.c:483
void rb_str_associate(VALUE str, VALUE add)
Definition: pack.c:130
VALUE rb_cvar_get(VALUE, ID)
Definition: variable.c:2922
VALUE rb_mod_module_exec(int, const VALUE *, VALUE)
Definition: vm_eval.c:1827
void rb_thread_schedule(void)
Definition: thread.c:1264
void rb_thread_atfork_before_exec(void)
Definition: thread.c:4177
VALUE rb_io_addstr(VALUE, VALUE)
Definition: io.c:1530
VALUE rb_reg_match_last(VALUE)
Definition: re.c:1699
int rb_reg_backref_number(VALUE match, VALUE backref)
Definition: re.c:1146
VALUE rb_hash_delete_if(VALUE)
Definition: hash.c:1272
VALUE rb_hash_delete(VALUE, VALUE)
Definition: hash.c:1138
VALUE rb_define_module_id_under(VALUE, ID)
Definition: class.c:796
int rb_is_instance_id(ID id)
Definition: symbol.c:846
void rb_thread_atfork(void)
Definition: thread.c:4172
VALUE rb_file_dirname(VALUE fname)
Definition: file.c:4177
int rb_find_file_ext_safe(VALUE *, const char *const *, int)
Definition: file.c:5771
int rb_cloexec_fcntl_dupfd(int fd, int minfd)
Definition: io.c:360
VALUE rb_str_length(VALUE)
Definition: string.c:1749
VALUE rb_complex_set_imag(VALUE cmp, VALUE i)
Definition: complex.c:1457
VALUE rb_class_public_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1294
VALUE rb_mod_include_p(VALUE, VALUE)
Definition: class.c:1053
void rb_interrupt(void)
Definition: eval.c:638
VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE)
Definition: proc.c:899
VALUE rb_num_coerce_bin(VALUE, VALUE, ID)
Definition: numeric.c:509
VALUE rb_ary_new_from_args(long n,...)
Definition: array.c:499
void rb_compile_error(const char *file, int line, const char *fmt,...)
Definition: error.c:138
VALUE rb_detach_process(rb_pid_t pid)
Definition: process.c:1097
VALUE rb_big_clone(VALUE)
Definition: bignum.c:3004
VALUE rb_str_equal(VALUE str1, VALUE str2)
Definition: string.c:3105
VALUE rb_ary_new_capa(long capa)
Definition: array.c:487
void rb_cv_set(VALUE, const char *, VALUE)
Definition: variable.c:2968
void rb_check_inheritable(VALUE)
Ensures a class can be derived from super.
Definition: class.c:220
VALUE rb_mod_name(VALUE)
Definition: variable.c:228
VALUE rb_mod_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1839
void rb_update_max_fd(int fd)
Definition: io.c:189
VALUE rb_ary_delete(VALUE, VALUE)
Definition: array.c:2992
void rb_backref_set(VALUE)
Definition: vm.c:1213
Definition: st.h:79
VALUE rb_String(VALUE)
Definition: object.c:3097
VALUE rb_time_nano_new(time_t, long)
Definition: time.c:2157
VALUE rb_Rational(VALUE, VALUE)
Definition: rational.c:1904
VALUE rb_io_get_io(VALUE)
Definition: io.c:656
VALUE rb_file_expand_path(VALUE, VALUE)
Definition: file.c:3686
VALUE rb_hash_lookup2(VALUE, VALUE, VALUE)
Definition: hash.c:856
VALUE rb_hash_aref(VALUE, VALUE)
Definition: hash.c:845
void rb_gc_force_recycle(VALUE)
Definition: gc.c:6102
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:72
VALUE rb_big_pow(VALUE, VALUE)
Definition: bignum.c:6174
void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src)
Definition: win32.c:2816
static int max(int a, int b)
Definition: strftime.c:142
static unsigned int hash(str, len) register const char *str
void rb_undef_alloc_func(VALUE)
Definition: vm_method.c:681
void rb_define_singleton_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Defines a singleton method for obj.
Definition: class.c:1716
VALUE rb_complex_set_real(VALUE cmp, VALUE r)
Definition: complex.c:1450
VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE)
Definition: thread.c:4720
VALUE rb_f_sprintf(int, const VALUE *)
Definition: sprintf.c:455
VALUE rb_ary_reverse(VALUE)
Definition: array.c:2216
VALUE rb_ary_shared_with_p(VALUE, VALUE)
Definition: array.c:431
void rb_error_frozen_object(VALUE frozen_obj)
Definition: error.c:2453
int rb_obj_method_arity(VALUE, ID)
Definition: proc.c:2428
VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv)
Definition: cont.c:1507
void rb_thread_sleep_deadly(void)
Definition: thread.c:1163
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
Definition: io.c:255
void rb_define_class_variable(VALUE, const char *, VALUE)
Definition: variable.c:2982
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2664
VALUE rb_define_class_id_under(VALUE, ID, VALUE)
Defines a class under the namespace of outer.
Definition: class.c:716
void rb_unblock_function_t(void *)
Definition: intern.h:895
VALUE rb_f_exit(int argc, const VALUE *argv)
Definition: process.c:3834
#define rb_str_dup_frozen
Definition: intern.h:744
VALUE rb_hash_lookup(VALUE, VALUE)
Definition: hash.c:867
int rb_is_absolute_path(const char *)
Definition: file.c:5591
VALUE rb_class_protected_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1256
VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE)
Definition: intern.h:227
VALUE rb_complex_raw(VALUE, VALUE)
Definition: complex.c:1423
VALUE rb_reg_alloc(void)
Definition: re.c:2786
void rb_error_frozen(const char *what)
Definition: error.c:2447
VALUE rb_io_flush(VALUE)
Definition: io.c:1590
VALUE rb_mod_ancestors(VALUE)
Definition: class.c:1085
VALUE rb_ary_cmp(VALUE, VALUE)
Definition: array.c:4028
void rb_write_error2(const char *, long)
Definition: io.c:7373
int rb_symname_p(const char *)
Definition: symbol.c:190
int rb_is_const_id(ID id)
Definition: symbol.c:828
#define rb_check_frozen_internal(obj)
Definition: intern.h:260
VALUE rb_cstr2inum(const char *, int)
Definition: bignum.c:4488
int rb_hash_iter_lev(VALUE h)
Definition: hash.c:270
VALUE rb_str_unlocktmp(VALUE)
Definition: string.c:2528
void rb_define_private_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Definition: class.c:1527
VALUE rb_hash_clear(VALUE)
Definition: hash.c:1506
VALUE rb_Hash(VALUE)
Definition: object.c:3157
double rb_big2dbl(VALUE)
Definition: bignum.c:5249
VALUE rb_str_new_with_class(VALUE, const char *, long)
Definition: string.c:1230
void rb_autoload(VALUE mod, ID id, const char *file)
Definition: variable.c:1933
void rb_must_asciicompat(VALUE)
Definition: string.c:2032
VALUE rb_dbl_cmp(double a, double b)
Definition: numeric.c:1448
#define rb_check_arity
Definition: intern.h:303
void rb_trap_exec(void)
VALUE rb_struct_alloc_noinit(VALUE)
Definition: struct.c:328
VALUE rb_reg_match(VALUE, VALUE)
Definition: re.c:3074
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Definition: range.c:995
VALUE rb_struct_new(VALUE,...)
Definition: struct.c:605
VALUE rb_ary_sort(VALUE)
Definition: array.c:2535
void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds)
VALUE rb_reg_nth_defined(int, VALUE)
Definition: re.c:1592
void rb_cvar_set(VALUE, ID, VALUE)
Definition: variable.c:2889
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:54
VALUE rb_singleton_class_clone(VALUE)
Definition: class.c:365
VALUE rb_str_concat(VALUE, VALUE)
Definition: string.c:2890
int rb_thread_alone(void)
Definition: thread.c:3274
VALUE rb_obj_is_method(VALUE)
Definition: proc.c:1349
st_index_t rb_memhash(const void *ptr, long len)
Definition: random.c:1502
VALUE rb_io_ungetc(VALUE, VALUE)
Definition: io.c:3992
VALUE rb_str_plus(VALUE, VALUE)
Definition: string.c:1800
void rb_mark_hash(struct st_table *)
Definition: gc.c:4084
VALUE rb_usascii_str_new_static(const char *, long)
Definition: string.c:835
VALUE rb_thread_wakeup(VALUE)
Definition: thread.c:2381
VALUE rb_mod_init_copy(VALUE, VALUE)
Definition: class.c:314
VALUE rb_make_exception(int, const VALUE *)
Definition: eval.c:763
#define rb_hash_uint32(h, i)
Definition: intern.h:766
#define rb_check_trusted(obj)
Definition: intern.h:282
const char * rb_sourcefile(void)
Definition: vm.c:1247
int rb_path_check(const char *)
Definition: file.c:5670
#define rb_fd_zero(f)
Definition: intern.h:352
int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *)
Definition: thread.c:3795
double rb_genrand_real(void)
Definition: random.c:271
const VALUE * rb_struct_ptr(VALUE s)
Definition: struct.c:1136
VALUE rb_file_absolute_path(VALUE, VALUE)
Definition: file.c:3734
VALUE rb_str_times(VALUE, VALUE)
Definition: string.c:1842
VALUE rb_path_to_class(VALUE)
Definition: variable.c:389
void rb_str_set_len(VALUE, long)
Definition: string.c:2545
int rb_reg_options(VALUE)
Definition: re.c:3474
VALUE rb_backref_get(void)
Definition: vm.c:1207
VALUE rb_undefine_finalizer(VALUE)
Definition: gc.c:2595
VALUE rb_ary_dup(VALUE)
Definition: array.c:1927
VALUE rb_to_int(VALUE)
Definition: object.c:2687
VALUE rb_ivar_get(VALUE, ID)
Definition: variable.c:1260
void rb_str_update(VALUE, long, long, VALUE)
Definition: string.c:4396
VALUE rb_io_getbyte(VALUE)
Definition: io.c:3896
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Definition: object.c:2630
void rb_big_pack(VALUE val, unsigned long *buf, long num_longs)
Definition: bignum.c:3199
VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE)
Definition: thread.c:4697
size_t rb_gc_stat(VALUE)
Definition: gc.c:7217
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Definition: object.c:690
void rb_backtrace(void)
Definition: vm_backtrace.c:776
void rb_clear_constant_cache(void)
Definition: vm_method.c:90
int rb_const_defined(VALUE, ID)
Definition: variable.c:2580
VALUE rb_reg_match2(VALUE)
Definition: re.c:3133
VALUE rb_hash(VALUE)
Definition: hash.c:126
st_index_t rb_str_hash(VALUE)
Definition: string.c:2985
char * rb_str_subpos(VALUE, long, long *)
Definition: string.c:2348
void rb_syswait(rb_pid_t pid)
Definition: process.c:3885
VALUE rb_check_to_float(VALUE)
Definition: object.c:3016
int rb_pipe(int *pipes)
Definition: io.c:5822
int rb_feature_provided(const char *, const char **)
Definition: load.c:528
st_data_t st_index_t
Definition: st.h:50
VALUE rb_range_beg_len(VALUE, long *, long *, long, int)
Definition: range.c:1019
VALUE rb_big_xor(VALUE, VALUE)
Definition: bignum.c:6496
VALUE rb_ary_sort_bang(VALUE)
Definition: array.c:2451
double rb_str_to_dbl(VALUE, int)
Definition: object.c:2869
VALUE rb_hash_fetch(VALUE, VALUE)
Definition: hash.c:931
VALUE rb_reg_match_post(VALUE)
Definition: re.c:1681
VALUE rb_io_write(VALUE, VALUE)
Definition: io.c:1508
VALUE rb_tainted_str_new_cstr(const char *)
Definition: string.c:871
int rb_str_cmp(VALUE, VALUE)
Definition: string.c:3050
VALUE rb_file_open_str(VALUE, const char *)
Definition: io.c:5723
VALUE rb_ary_entry(VALUE, long)
Definition: array.c:1196
void rb_check_copyable(VALUE obj, VALUE orig)
Definition: error.c:2490
void rb_define_protected_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Definition: class.c:1521
VALUE rb_str_associated(VALUE str)
Definition: pack.c:136
VALUE rb_hash_dup(VALUE)
Definition: hash.c:457
int rb_env_path_tainted(void)
Definition: hash.c:3311
VALUE rb_fiber_yield(int argc, const VALUE *argv)
Definition: cont.c:1523
VALUE rb_utf8_str_new_cstr(const char *)
Definition: string.c:785
void rb_undef(VALUE, ID)
Definition: vm_method.c:1173
VALUE rb_path2class(const char *)
Definition: variable.c:431
VALUE rb_Float(VALUE)
Definition: object.c:2961
VALUE rb_proc_times(VALUE)
VALUE rb_find_file(VALUE)
Definition: file.c:5837
VALUE rb_struct_getmember(VALUE, ID)
Definition: struct.c:205
VALUE rb_str_tmp_new(long)
Definition: string.c:1275
VALUE rb_check_to_integer(VALUE, const char *)
Definition: object.c:2673
VALUE rb_obj_untrust(VALUE)
Definition: object.c:1059
int rb_const_defined_from(VALUE, ID)
Definition: variable.c:2574
void rb_loaderror(const char *fmt,...)
Definition: error.c:2229
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2802
void rb_ary_store(VALUE, long, VALUE)
Definition: array.c:799
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj)
Definition: vm_method.c:122
VALUE rb_big2str(VALUE, int)
Definition: bignum.c:5041
VALUE rb_fix2str(VALUE, int)
Definition: numeric.c:3404
long rb_big2long(VALUE)
Definition: bignum.c:5087
VALUE rb_ivar_defined(VALUE, ID)
Definition: variable.c:1421
VALUE rb_get_argv(void)
Definition: io.c:12088
VALUE rb_flt_rationalize_with_prec(VALUE, VALUE)
Definition: rational.c:2179
VALUE rb_struct_define_under(VALUE, const char *,...)
Definition: struct.c:425
VALUE rb_mod_remove_cvar(VALUE, VALUE)
Definition: variable.c:3109
VALUE rb_reg_last_match(VALUE)
Definition: re.c:1636
VALUE rb_external_str_new_cstr(const char *)
Definition: string.c:1026
void rb_ivar_foreach(VALUE, int(*)(ANYARGS), st_data_t)
Definition: variable.c:1591
VALUE rb_mutex_new(void)
Definition: thread_sync.c:118
VALUE rb_ary_delete_at(VALUE, long)
Definition: array.c:3045
void rb_name_error_str(VALUE str, const char *fmt,...)
Definition: error.c:1219
VALUE rb_str_to_inum(VALUE, int, int)
Definition: bignum.c:4205
struct timespec rb_time_timespec(VALUE time)
Definition: time.c:2309
VALUE rb_thread_local_aref(VALUE, ID)
Definition: thread.c:3049
#define rb_fd_set(n, f)
Definition: intern.h:353
VALUE rb_f_kill(int, const VALUE *)
Definition: signal.c:407
PRINTF_ARGS(NORETURN(void rb_loaderror(const char *,...)), 1, 2)
VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *)
Definition: enumerator.c:450
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
Definition: st.h:22
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:1204
VALUE rb_obj_untaint(VALUE)
Definition: object.c:1028
void rb_thread_fd_close(int)
Definition: thread.c:2226
VALUE rb_Complex(VALUE, VALUE)
Definition: complex.c:1441
#define rb_fd_isset(n, f)
Definition: intern.h:355
VALUE rb_utf8_str_new(const char *, long)
Definition: string.c:750
void rb_loaderror_with_path(VALUE path, const char *fmt,...)
Definition: error.c:2241
void * rb_load_file(const char *)
Definition: ruby.c:1992
void rb_exc_raise(VALUE mesg)
Definition: eval.c:620
VALUE rb_struct_members(VALUE)
Definition: struct.c:65
VALUE rb_gc_latest_gc_info(VALUE)
Definition: gc.c:6803
struct timeval rb_time_timeval(VALUE time)
Definition: time.c:2292
VALUE rb_exc_new_str(VALUE, VALUE)
Definition: error.c:809
VALUE rb_obj_dup(VALUE)
Definition: object.c:437
VALUE rb_singleton_class(VALUE)
Returns the singleton class of obj.
Definition: class.c:1689
void * rb_load_file_str(VALUE)
Definition: ruby.c:1999
void rb_reset_random_seed(void)
Definition: random.c:1560
VALUE rb_mutex_locked_p(VALUE mutex)
Definition: thread_sync.c:130
VALUE rb_struct_s_members(VALUE)
Definition: struct.c:51
VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE)
Definition: proc.c:2126
void rb_write_error(const char *)
Definition: io.c:7387
VALUE rb_binding_new(void)
Definition: proc.c:340
VALUE rb_file_open(const char *, const char *)
Definition: io.c:5730
VALUE rb_thread_kill(VALUE)
Definition: thread.c:2283
VALUE rb_str_encode_ospath(VALUE)
Definition: file.c:223
VALUE rb_big_cmp(VALUE, VALUE)
Definition: bignum.c:5346
int rb_thread_fd_writable(int)
Definition: thread.c:3788
VALUE rb_rational_raw(VALUE, VALUE)
Definition: rational.c:1892
VALUE rb_obj_method(VALUE, VALUE)
Definition: proc.c:1723
VALUE rb_lastline_get(void)
Definition: vm.c:1219
VALUE rb_enum_values_pack(int, const VALUE *)
Definition: enum.c:31
VALUE rb_hash_freeze(VALUE)
Definition: hash.c:76
RUBY_EXTERN VALUE rb_output_rs
Definition: intern.h:538
void rb_free_generic_ivar(VALUE)
Definition: variable.c:1183
void rb_str_setter(VALUE, ID, VALUE *)
Definition: string.c:9063
VALUE rb_cvar_defined(VALUE, ID)
Definition: variable.c:2949
void rb_thread_sleep(int)
Definition: thread.c:1241
fd_set rb_fdset_t
Definition: intern.h:351
#define rb_fd_term(f)
Definition: intern.h:362
VALUE rb_Array(VALUE)
Definition: object.c:3126
VALUE rb_str_succ(VALUE)
Definition: string.c:3889
VALUE rb_marshal_dump(VALUE, VALUE)
Definition: marshal.c:2249
VALUE rb_io_printf(int, const VALUE *, VALUE)
Definition: io.c:6979
VALUE rb_class_name(VALUE)
Definition: variable.c:443
void * rb_mod_const_at(VALUE, void *)
Definition: variable.c:2457
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:144
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:132
VALUE rb_str_new_shared(VALUE)
Definition: string.c:1114
VALUE rb_obj_taint(VALUE)
Definition: object.c:1008
int rb_proc_exec(const char *)
Definition: process.c:1322
VALUE rb_str_substr(VALUE, long, long)
Definition: string.c:2435
VALUE rb_big_and(VALUE, VALUE)
Definition: bignum.c:6283
VALUE rb_time_timespec_new(const struct timespec *, int)
Returns a time object with UTC/localtime/fixed offset.
Definition: time.c:2168
RUBY_EXTERN VALUE rb_output_fs
Definition: intern.h:535
#define val
VALUE rb_f_exec(int argc, const VALUE *argv)
Definition: process.c:2596
VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE, VALUE)
Definition: thread.c:4708
NORETURN(void rb_cmperr(VALUE, VALUE))
int rb_is_class_id(ID id)
Definition: symbol.c:834
VALUE rb_block_lambda(void)
Definition: proc.c:801
VALUE rb_dbl2big(double)
Definition: bignum.c:5193
static void rb_check_trusted_inline(VALUE obj)
Definition: intern.h:278
void rb_mem_clear(register VALUE *, register long)
Definition: array.c:135
void rb_str_free(VALUE)
Definition: string.c:1281
void rb_attr(VALUE, ID, int, int, int)
Definition: vm_method.c:1138
VALUE rb_mutex_sleep(VALUE self, VALUE timeout)
Definition: thread_sync.c:436
const char * ruby_signal_name(int)
Definition: signal.c:262
VALUE rb_time_succ(VALUE)
Definition: time.c:3670
VALUE rb_check_hash_type(VALUE)
Definition: hash.c:736
void rb_clear_cache(void)
Definition: vm_method.c:84
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
Definition: vm.c:2047
size_t rb_gc_count(void)
Definition: gc.c:6688
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1364
VALUE rb_ary_replace(VALUE copy, VALUE orig)
Definition: array.c:3437
void rb_gc_mark_locations(const VALUE *, const VALUE *)
Definition: gc.c:4008
#define rb_str_buf_new2
Definition: intern.h:862
VALUE rb_f_require(VALUE, VALUE)
Definition: load.c:821
VALUE rb_hash_size(VALUE)
Definition: hash.c:1678
VALUE rb_thread_current(void)
Definition: thread.c:2504
VALUE rb_locale_str_new(const char *, long)
Definition: string.c:1032
void rb_set_end_proc(void(*)(VALUE), VALUE)
Definition: eval_jump.c:60
void rb_w32_fd_copy(rb_fdset_t *dst, const fd_set *src, int max)
Definition: win32.c:2801
size_t rb_absint_size(VALUE val, int *nlz_bits_ret)
Definition: bignum.c:3231
VALUE rb_mutex_synchronize(VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
Definition: thread_sync.c:488
void rb_remove_method_id(VALUE, ID)
Definition: vm_method.c:994
VALUE rb_define_module_id(ID)
Definition: class.c:757
VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value)
Definition: intern.h:523
void rb_lastline_set(VALUE)
Definition: vm.c:1225
VALUE rb_ary_join(VALUE, VALUE)
Definition: array.c:2034
int argc
Definition: ruby.c:183
VALUE rb_ary_concat(VALUE, VALUE)
Definition: array.c:3686
VALUE rb_complex_polar(VALUE, VALUE)
Definition: complex.c:1435
VALUE rb_require_safe(VALUE, int)
Definition: load.c:1040
VALUE rb_external_str_new(const char *, long)
Definition: string.c:1020
VALUE rb_ary_rassoc(VALUE, VALUE)
Definition: array.c:3808
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1898
VALUE rb_Integer(VALUE)
Definition: object.c:2736
int rb_cloexec_dup2(int oldfd, int newfd)
Definition: io.c:288
VALUE rb_mutex_trylock(VALUE mutex)
Definition: thread_sync.c:157
int rb_uv_to_utf8(char[6], unsigned long)
Definition: pack.c:1903
size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
Definition: bignum.c:3366
void rb_frame_pop(void)
Definition: vm.c:553
RUBY_EXTERN VALUE rb_fs
Definition: intern.h:534
VALUE rb_exc_new_cstr(VALUE, const char *)
Definition: error.c:803
#define range(low, item, hi)
Definition: date_strftime.c:21
void rb_big_resize(VALUE big, size_t len)
Definition: bignum.c:2973
VALUE rb_hash_ifnone(VALUE h)
Definition: hash.c:87
static void rb_check_frozen_inline(VALUE obj)
Definition: intern.h:272
VALUE rb_big_mul(VALUE, VALUE)
Definition: bignum.c:5867
rb_alloc_func_t rb_get_alloc_func(VALUE)
Definition: vm_method.c:687
double rb_random_real(VALUE rnd)
Definition: random.c:956
VALUE rb_obj_alloc(VALUE)
Definition: object.c:1845
VALUE rb_gets(void)
Definition: io.c:8311
VALUE rb_class_get_superclass(VALUE)
Definition: object.c:1939
VALUE rb_str_split(VALUE, const char *)
Definition: string.c:7450
VALUE rb_class_superclass(VALUE)
Definition: object.c:1921
VALUE rb_obj_id(VALUE)
Definition: gc.c:3100
VALUE rb_struct_aset(VALUE, VALUE, VALUE)
Definition: struct.c:923
void st_foreach_safe(struct st_table *, int(*)(ANYARGS), st_data_t)
Definition: hash.c:327
VALUE rb_obj_init_copy(VALUE, VALUE)
Definition: object.c:470
void rb_num_zerodiv(void)
Definition: numeric.c:192
VALUE rb_big_norm(VALUE)
Definition: bignum.c:3136
VALUE rb_reg_init_str(VALUE re, VALUE s, int options)
Definition: re.c:2798
VALUE rb_sym_to_s(VALUE)
Definition: string.c:9693
VALUE rb_thread_wakeup_alive(VALUE)
Definition: thread.c:2390
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Definition: object.c:1891
VALUE rb_time_new(time_t, long)
Definition: time.c:2130
VALUE rb_flt_rationalize(VALUE)
Definition: rational.c:2195
void rb_trap_exit(void)
Definition: signal.c:999
VALUE rb_struct_size(VALUE s)
Definition: struct.c:1130
VALUE rb_ary_subseq(VALUE, long, long)
Definition: array.c:1212
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:811
VALUE rb_str_resurrect(VALUE str)
Definition: string.c:1442
VALUE rb_big_divmod(VALUE, VALUE)
Definition: bignum.c:6066
void rb_remove_method(VALUE, const char *)
Definition: vm_method.c:1000
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2562
VALUE rb_io_binmode(VALUE)
Definition: io.c:4836
long rb_str_offset(VALUE, long)
Definition: string.c:2266
VALUE rb_const_get(VALUE, ID)
Definition: variable.c:2335
VALUE rb_define_finalizer(VALUE, VALUE)
Definition: gc.c:2690
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2995
VALUE rb_num_coerce_bit(VALUE, VALUE, ID)
Definition: numeric.c:4317
VALUE rb_big_or(VALUE, VALUE)
Definition: bignum.c:6402
VALUE rb_ary_plus(VALUE, VALUE)
Definition: array.c:3621
VALUE rb_thread_local_aset(VALUE, ID, VALUE)
Definition: thread.c:3146
VALUE rb_str_subseq(VALUE, long, long)
Definition: string.c:2324
int rb_absint_singlebit_p(VALUE val)
Definition: bignum.c:3430
ID rb_frame_this_func(void)
Definition: eval.c:979
void rb_alias_variable(ID, ID)
Definition: variable.c:911
VALUE rb_locale_str_new_cstr(const char *)
Definition: string.c:1038
VALUE rb_str_new_static(const char *, long)
Definition: string.c:829
VALUE rb_str_replace(VALUE, VALUE)
Definition: string.c:5097
VALUE rb_str2inum(VALUE, int)
Definition: bignum.c:4494
VALUE rb_io_fdopen(int, int, const char *)
Definition: io.c:7453
VALUE rb_env_clear(void)
Definition: hash.c:3891
VALUE rb_io_print(int, const VALUE *, VALUE)
Definition: io.c:7040
VALUE rb_reg_new(const char *, long, int)
Definition: re.c:2844
int rb_during_gc(void)
Definition: gc.c:6664
unsigned long rb_genrand_ulong_limited(unsigned long i)
Definition: random.c:893
VALUE rb_obj_untrusted(VALUE obj)
Definition: object.c:1045
#define RUBY_EXTERN
Definition: missing.h:77
void rb_mark_tbl(struct st_table *)
Definition: gc.c:4229
VALUE rb_io_gets(VALUE)
Definition: io.c:3261
VALUE rb_obj_is_proc(VALUE)
Definition: proc.c:117
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1440
void rb_big_2comp(VALUE)
Definition: bignum.c:3033
VALUE rb_random_bytes(VALUE rnd, long n)
Definition: random.c:1107
VALUE rb_ary_resurrect(VALUE ary)
Definition: array.c:1937
VALUE rb_str_format(int, const VALUE *, VALUE)
Definition: sprintf.c:461
int rb_eql(VALUE, VALUE)
Definition: object.c:97
int rb_obj_respond_to(VALUE, ID, int)
Definition: vm_method.c:1985
#define rb_fd_copy(d, s, n)
Definition: intern.h:356
void rb_last_status_set(int status, rb_pid_t pid)
Definition: process.c:485
VALUE(*const rb_f_notimplement_)(int, const VALUE *, VALUE)
Definition: win32.c:7784
VALUE rb_class_path(VALUE)
Definition: variable.c:294
VALUE rb_mod_module_eval(int, const VALUE *, VALUE)
Definition: vm_eval.c:1799
VALUE rb_complex_new(VALUE, VALUE)
Definition: complex.c:1429
VALUE rb_ary_assoc(VALUE, VALUE)
Definition: array.c:3775
VALUE rb_str_vcatf(VALUE, const char *, va_list)
Definition: sprintf.c:1453
VALUE rb_ary_each(VALUE)
Definition: array.c:1818
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
rb_pid_t rb_spawn_err(int, const VALUE *, char *, size_t)
Definition: process.c:4000
st_table * rb_generic_ivar_table(VALUE obj)
Definition: variable.c:978
void rb_obj_call_init(VALUE, int, const VALUE *)
Definition: eval.c:1422
void * rb_mod_const_of(VALUE, void *)
Definition: variable.c:2470
void rb_str_modify_expand(VALUE, long)
Definition: string.c:1988
VALUE rb_ivar_set(VALUE, ID, VALUE)
Definition: variable.c:1364
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4309
DEPRECATED(VALUE rb_complex_set_real(VALUE, VALUE))
unsigned long ID
Definition: ruby.h:86
void rb_thread_wait_fd(int)
Definition: thread.c:3782
VALUE rb_class_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1241
VALUE rb_thread_main(void)
Definition: thread.c:2525
VALUE rb_big_unpack(unsigned long *buf, long num_longs)
Definition: bignum.c:3207
void rb_hash_foreach(VALUE, int(*)(ANYARGS), VALUE)
Definition: hash.c:402
void rb_clear_method_cache_by_class(VALUE)
Definition: vm_method.c:96
int rb_str_comparable(VALUE, VALUE)
Definition: string.c:3025
void rb_const_set(VALUE, ID, VALUE)
Definition: variable.c:2616
VALUE rb_const_list(void *)
Definition: variable.c:2492
#define mode_t
Definition: win32.h:119
static int options(unsigned char *cp)
Definition: nkf.c:6358
VALUE rb_ary_includes(VALUE, VALUE)
Definition: array.c:3958
VALUE rb_ary_unshift(VALUE, VALUE)
Definition: array.c:1178
VALUE rb_io_close(VALUE)
Definition: io.c:4469
unsigned long VALUE
Definition: ruby.h:85
VALUE rb_f_trace_var(int, const VALUE *)
Definition: variable.c:687
void rb_name_class(VALUE, ID)
Definition: variable.c:437
VALUE rb_fiber_new(VALUE(*)(ANYARGS), VALUE)
Definition: cont.c:1258
VALUE rb_big_plus(VALUE, VALUE)
Definition: bignum.c:5751
VALUE rb_mod_class_variables(int, const VALUE *, VALUE)
Definition: variable.c:3068
VALUE rb_big_idiv(VALUE, VALUE)
Definition: bignum.c:6028
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:48
VALUE rb_io_puts(int, const VALUE *, VALUE)
Definition: io.c:7212
VALUE rb_rational_den(VALUE rat)
Definition: rational.c:1919
void rb_alias(VALUE, ID, ID)
Definition: vm_method.c:1526
void rb_match_busy(VALUE)
Definition: re.c:1260
VALUE rb_gc_enable(void)
Definition: gc.c:7289
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
Definition: vm_eval.c:439
VALUE rb_random_int(VALUE rnd, VALUE max)
VALUE rb_num_coerce_relop(VALUE, VALUE, ID)
Definition: numeric.c:524
VALUE rb_file_directory_p(VALUE, VALUE)
Definition: file.c:1336
VALUE rb_cv_get(VALUE, const char *)
Definition: variable.c:2975
int rb_sym_interned_p(VALUE)
VALUE rb_str_ellipsize(VALUE, long)
Shortens str and adds three dots, an ellipsis, if it is longer than len characters.
Definition: string.c:9169
VALUE rb_str_new_cstr(const char *)
Definition: string.c:770
VALUE rb_str_dump(VALUE)
Definition: string.c:5771
VALUE rb_proc_call(VALUE, VALUE)
Definition: proc.c:879
VALUE rb_proc_lambda_p(VALUE)
Definition: proc.c:255
RUBY_EXTERN VALUE rb_rs
Definition: intern.h:536
int rb_is_global_id(ID id)
Definition: symbol.c:840
VALUE rb_blocking_function_t(void *)
Definition: intern.h:896
VALUE rb_io_ungetbyte(VALUE, VALUE)
Definition: io.c:3957
VALUE rb_obj_remove_instance_variable(VALUE, VALUE)
Definition: variable.c:1734
void rb_jump_tag(int tag)
Definition: eval.c:788
VALUE rb_str_dup(VALUE)
Definition: string.c:1436
VALUE rb_num2fix(VALUE)
Definition: numeric.c:3020
int rb_bigzero_p(VALUE x)
Definition: bignum.c:2903
int rb_is_junk_id(ID id)
Definition: symbol.c:864
int rb_reserved_fd_p(int fd)
unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit)
Definition: random.c:1016
VALUE rb_class_real(VALUE cl)
Definition: object.c:207
VALUE rb_file_s_absolute_path(int, const VALUE *)
Definition: file.c:3754
rb_pid_t rb_spawn(int, const VALUE *)
Definition: process.c:4006
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:1995
void rb_memerror(void)
Definition: gc.c:7622
unsigned int uint32_t
Definition: sha2.h:101
VALUE rb_method_call(int, const VALUE *, VALUE)
Definition: proc.c:2082
register unsigned int len
Definition: zonetab.h:51
VALUE rb_str_freeze(VALUE)
Definition: string.c:2467
VALUE rb_mod_constants(int, const VALUE *, VALUE)
Definition: variable.c:2524
#define rb_enable_super(klass, name)
Definition: intern.h:385
VALUE rb_big_new(size_t, int)
Definition: bignum.c:2998
RUBY_EXTERN VALUE rb_default_rs
Definition: intern.h:537
VALUE rb_check_to_int(VALUE)
Definition: object.c:2693
#define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn)
Definition: intern.h:230
int rb_cloexec_pipe(int fildes[2])
Definition: io.c:323
void rb_mark_set(struct st_table *)
Definition: gc.c:4061
void rb_thread_wait_for(struct timeval)
Definition: thread.c:1201
VALUE rb_obj_is_instance_of(VALUE, VALUE)
Definition: object.c:653
VALUE rb_obj_trust(VALUE)
Definition: object.c:1074
void rb_str_modify(VALUE)
Definition: string.c:1980
VALUE rb_obj_instance_eval(int, const VALUE *, VALUE)
Definition: vm_eval.c:1740
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2586
void rb_define_method_id(VALUE, ID, VALUE(*)(ANYARGS), int)
Definition: class.c:1509
VALUE rb_f_untrace_var(int, const VALUE *)
Definition: variable.c:746
#define rb_disable_super(klass, name)
Definition: intern.h:384
void rb_singleton_class_attached(VALUE, VALUE)
Attach a object to a singleton class.
Definition: class.c:421
#define UNLIMITED_ARGUMENTS
Definition: intern.h:44
int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
Definition: bignum.c:3531
int rb_sourceline(void)
Definition: vm.c:1261
VALUE rb_fiber_current(void)
Definition: cont.c:1358
VALUE rb_module_new(void)
Definition: class.c:749
VALUE rb_rational_num(VALUE rat)
Definition: rational.c:1913
#define rb_str_buf_cat
Definition: intern.h:864
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
Definition: object.c:2643
VALUE rb_ary_tmp_new(long)
Definition: array.c:532
VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
Definition: bignum.c:3617
VALUE rb_block_proc(void)
Definition: proc.c:787
VALUE rb_ary_resize(VALUE ary, long len)
expands or shrinks ary to len elements.
Definition: array.c:1650
VALUE rb_str_buf_cat_ascii(VALUE, const char *)
Definition: string.c:2778
VALUE rb_str_buf_new_cstr(const char *)
Definition: string.c:1263
#define ANYARGS
Definition: defines.h:173
void rb_fd_fix_cloexec(int fd)
Definition: io.c:231
VALUE rb_big_div(VALUE, VALUE)
Definition: bignum.c:6022
void rb_gc_mark_maybe(VALUE)
Definition: gc.c:4247
VALUE rb_struct_aref(VALUE, VALUE)
Definition: struct.c:896
VALUE rb_get_values_at(VALUE, long, int, const VALUE *, VALUE(*)(VALUE, long))
Definition: array.c:2775
VALUE rb_big_eql(VALUE, VALUE)
Definition: bignum.c:5471
void rb_error_arity(int argc, int min, int max)
VALUE rb_utf8_str_new_static(const char *, long)
Definition: string.c:841
#define rb_fd_select(n, rfds, wfds, efds, timeout)
Definition: intern.h:364
CONSTFUNC(void rb_error_untrusted(VALUE))
VALUE rb_str_catf(VALUE str, const char *format,...)
Definition: sprintf.c:1480
#define rb_str_cat2
Definition: intern.h:866
VALUE rb_class_path_cached(VALUE)
Definition: variable.c:318
VALUE rb_dir_getwd(void)
Definition: dir.c:1051
VALUE rb_check_string_type(VALUE)
Definition: string.c:2164
VALUE rb_io_ascii8bit_binmode(VALUE)
Definition: io.c:4882
#define rb_fd_clr(n, f)
Definition: intern.h:354
VALUE rb_any_to_s(VALUE)
Definition: object.c:500
VALUE rb_ary_push(VALUE, VALUE)
Definition: array.c:905
VALUE rb_obj_singleton_methods(int, const VALUE *, VALUE)
Definition: class.c:1418
void rb_str_shared_replace(VALUE, VALUE)
Definition: string.c:1314
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Definition: marshal.c:134
VALUE rb_proc_new(VALUE(*)(ANYARGS), VALUE)
Definition: proc.c:2661
void rb_thread_check_ints(void)
Definition: thread.c:1215
VALUE rb_thread_run(VALUE)
Definition: thread.c:2427
VALUE rb_str_locktmp(VALUE)
VALUE rb_mod_remove_const(VALUE, VALUE)
Definition: variable.c:2375
unsigned long rb_big2ulong(VALUE)
Definition: bignum.c:5072
void rb_ary_free(VALUE)
Definition: array.c:547
VALUE rb_mutex_unlock(VALUE mutex)
Definition: thread_sync.c:371
size_t rb_str_capacity(VALUE str)
Definition: string.c:674
int rb_method_basic_definition_p(VALUE, ID)
Definition: vm_method.c:1880
#define rb_check_trusted_internal(obj)
Definition: intern.h:266
VALUE rb_str_cat_cstr(VALUE, const char *)
Definition: string.c:2674
long rb_str_sublen(VALUE, long)
Definition: string.c:2313
VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func)
Definition: hash.c:2478
VALUE rb_f_global_variables(void)
Definition: variable.c:883
VALUE rb_obj_instance_exec(int, const VALUE *, VALUE)
Definition: vm_eval.c:1765
VALUE rb_find_file_safe(VALUE, int)
Definition: file.c:5843
VALUE rb_marshal_load(VALUE)
Definition: marshal.c:2255
void rb_gc(void)
Definition: gc.c:6656
VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc,...)
Definition: struct.c:384
VALUE rb_class_private_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1279
VALUE rb_str_inspect(VALUE)
Definition: string.c:5664
VALUE rb_eval_cmd(VALUE, VALUE, int)
Definition: vm_eval.c:1558
void rb_gc_mark(VALUE)
Definition: gc.c:4394
int rb_is_local_id(ID id)
Definition: symbol.c:858
VALUE rb_exec_recursive_paired_outer(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE, VALUE)
Definition: thread.c:4732
#define rb_str_buf_cat2
Definition: intern.h:865
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:1050
VALUE rb_hash_new(void)
Definition: hash.c:441
VALUE rb_gc_disable(void)
Definition: gc.c:7311
void rb_frozen_class_p(VALUE)
Definition: eval.c:396
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:2341
VALUE rb_reg_match_pre(VALUE)
Definition: re.c:1654
VALUE rb_obj_tainted(VALUE obj)
Definition: object.c:983
void rb_set_class_path(VALUE, VALUE, const char *)
Definition: variable.c:366
void rb_gc_adjust_memory_usage(ssize_t)
Definition: gc.c:8121
VALUE rb_ary_shift(VALUE)
Definition: array.c:1000
int rb_thread_interrupted(VALUE thval)
Definition: thread.c:1233
VALUE rb_file_s_expand_path(int, const VALUE *)
Definition: file.c:3727
void rb_gc_finalize_deferred(void)
Definition: gc.c:2818
long rb_str_strlen(VALUE)
Definition: string.c:1735
VALUE rb_protect(VALUE(*)(VALUE), VALUE, int *)
Definition: eval.c:891
void rb_load(VALUE, int)
Definition: load.c:662
ID rb_frame_callee(void)
Definition: eval.c:985
PUREFUNC(int rb_during_gc(void))
VALUE rb_sym_all_symbols(void)
Definition: symbol.c:814
VALUE rb_reg_new_str(VALUE, int)
Definition: re.c:2792
VALUE rb_assoc_new(VALUE, VALUE)
Definition: array.c:623
VALUE rb_thread_stop(void)
Definition: thread.c:2451
int rb_is_attrset_id(ID id)
Definition: symbol.c:852
void rb_gc_copy_finalizer(VALUE, VALUE)
Definition: gc.c:2698
VALUE rb_ary_to_s(VALUE)
Definition: array.c:2135
VALUE rb_mod_included_modules(VALUE)
Definition: class.c:1017
void rb_error_untrusted(VALUE obj)
Definition: error.c:2479
VALUE rb_ary_aref(int, const VALUE *, VALUE)
Definition: array.c:1266
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:1123
VALUE rb_big_modulo(VALUE, VALUE)
Definition: bignum.c:6034
VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t,...)
Definition: struct.c:397
VALUE rb_str_drop_bytes(VALUE, long)
Definition: string.c:4331
VALUE rb_define_class_id(ID, VALUE)
Defines a new class.
Definition: class.c:599
#define rb_fd_init(f)
Definition: intern.h:360
VALUE rb_inspect(VALUE)
Definition: object.c:519
VALUE rb_big_minus(VALUE, VALUE)
Definition: bignum.c:5780
int rb_cloexec_dup(int oldfd)
Definition: io.c:281
VALUE rb_gc_start(void)
Definition: gc.c:6649
VALUE rb_big_rshift(VALUE, VALUE)
Definition: bignum.c:6574
#define rb_fd_dup(d, s)
Definition: intern.h:357
void rb_ary_modify(VALUE)
Definition: array.c:316
#define rb_hash_end(h)
Definition: intern.h:768
void rb_warning(const char *fmt,...)
Definition: error.c:250
VALUE rb_ary_freeze(VALUE)
Definition: array.c:403
unsigned int rb_random_int32(VALUE rnd)
Definition: random.c:921
#define rb_check_frozen(obj)
Definition: intern.h:276
VALUE rb_ary_cat(VALUE, const VALUE *, long)
Definition: array.c:917
int rb_proc_arity(VALUE)
Definition: proc.c:1009
VALUE rb_str_intern(VALUE)
Definition: symbol.c:661
VALUE rb_obj_freeze(VALUE)
Definition: object.c:1111
void rb_copy_generic_ivar(VALUE, VALUE)
Definition: variable.c:1549
VALUE rb_struct_define(const char *,...)
Definition: struct.c:410
ID rb_id_attrset(ID)
Definition: symbol.c:100
int rb_cmpint(VALUE, VALUE, VALUE)
Definition: bignum.c:2909
VALUE rb_tainted_str_new(const char *, long)
Definition: string.c:853
VALUE rb_ary_pop(VALUE)
Definition: array.c:949
VALUE rb_str_buf_new(long)
Definition: string.c:1247
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:742
int rb_method_boundp(VALUE, ID, int)
Definition: vm_method.c:1069
VALUE rb_obj_instance_variables(VALUE)
Definition: variable.c:1681
VALUE rb_const_remove(VALUE, ID)
Definition: variable.c:2387
VALUE rb_const_get_from(VALUE, ID)
Definition: variable.c:2329
VALUE rb_ary_new(void)
Definition: array.c:493
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1434
VALUE rb_str_scrub(VALUE, VALUE)
Definition: string.c:9232
VALUE rb_last_status_get(void)
Definition: process.c:479
VALUE rb_ary_new_from_values(long n, const VALUE *elts)
Definition: array.c:518
void rb_timespec_now(struct timespec *)
Definition: time.c:1743
VALUE rb_cstr_to_inum(const char *, int, int)
Definition: bignum.c:3994
VALUE(* rb_alloc_func_t)(VALUE)
Definition: intern.h:387
void rb_exc_fatal(VALUE mesg)
Definition: eval.c:629
VALUE rb_fiber_alive_p(VALUE)
Definition: cont.c:1549
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
Definition: hash.c:1576
VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone)
Definition: hash.c:93
VALUE rb_struct_initialize(VALUE, VALUE)
Definition: struct.c:571
void ruby_default_signal(int)
Definition: signal.c:360
VALUE rb_thread_create(VALUE(*)(ANYARGS), void *)
Definition: thread.c:823
rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags)
Definition: process.c:902
VALUE rb_class_inherited_p(VALUE mod, VALUE arg)
Definition: object.c:1593
VALUE rb_class_new(VALUE)
Creates a new class.
Definition: class.c:242
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:280
VALUE rb_check_array_type(VALUE)
Definition: array.c:635
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2818
unsigned int rb_genrand_int32(void)
Definition: random.c:264
VALUE rb_io_eof(VALUE)
Definition: io.c:1827
void rb_load_protect(VALUE, int, int *)
Definition: load.c:668
void rb_provide(const char *)
Definition: load.c:572
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:79
VALUE rb_time_num_new(VALUE, VALUE)
Definition: time.c:2191
void rb_invalid_str(const char *str, const char *type)
Definition: error.c:1509
VALUE rb_obj_frozen_p(VALUE obj)
Definition: object.c:1134
double rb_cstr_to_dbl(const char *, int)
Definition: object.c:2785
int rb_find_file_ext(VALUE *, const char *const *)
Definition: file.c:5765
st_index_t rb_ivar_count(VALUE)
Definition: variable.c:1613
VALUE rb_struct_alloc(VALUE, VALUE)
Definition: struct.c:599
VALUE rb_ary_rotate(VALUE, long)
Definition: array.c:2280
#define rb_hash_uint(h, i)
Definition: intern.h:767
VALUE rb_autoload_load(VALUE, ID)
Definition: variable.c:2198
void rb_set_class_path_string(VALUE, VALUE, VALUE)
Definition: variable.c:343
void rb_cmperr(VALUE x, VALUE y)
Definition: compar.c:24
void rb_exec_end_proc(void)
Definition: eval_jump.c:114
VALUE rb_big_eq(VALUE, VALUE)
Definition: bignum.c:5451
st_index_t rb_hash_start(st_index_t)
Definition: random.c:1496
VALUE rb_obj_clone(VALUE)
Definition: object.c:388
VALUE rb_ary_to_ary(VALUE)
Definition: array.c:1555
VALUE rb_reg_nth_match(int, VALUE)
Definition: re.c:1610
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1273
VALUE rb_exc_new(VALUE, const char *, long)
Definition: error.c:797
VALUE rb_usascii_str_new_cstr(const char *)
Definition: string.c:777
char ** argv
Definition: ruby.c:184
VALUE rb_ary_clear(VALUE)
Definition: array.c:3487
VALUE rb_to_float(VALUE)
Definition: object.c:3006
VALUE rb_num_coerce_cmp(VALUE, VALUE, ID)
Definition: numeric.c:516
VALUE rb_f_abort(int argc, const VALUE *argv)
Definition: process.c:3862
VALUE rb_filesystem_str_new(const char *, long)
Definition: string.c:1044
RUBY_EXTERN VALUE rb_argv0
Definition: intern.h:684
void rb_thread_sleep_forever(void)
Definition: thread.c:1156
VALUE rb_autoload_p(VALUE, ID)
Definition: variable.c:2248
VALUE rb_str_new(const char *, long)
Definition: string.c:736
VALUE rb_obj_class(VALUE)
Definition: object.c:229
int rb_mod_method_arity(VALUE, ID)
Definition: proc.c:2420
VALUE rb_big_lshift(VALUE, VALUE)
Definition: bignum.c:6544