include/ruby/intern.h

   1 /**********************************************************************
   2
   3   intern.h -
   4
   5   $Author$
   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 #ifdef HAVE_STDARG_PROTOTYPES
  25 # include <stdarg.h>
  26 #else
  27 # include <varargs.h>
  28 #endif
  29 #include "ruby/st.h"
  30
  31 /*
  32  * Functions and variables that are used by more than one source file of
  33  * the kernel.
  34  */
  35
  36 #define ID_ALLOCATOR 1
  37
  38 /* array.c */
  39 void rb_mem_clear(register VALUE*, register long);
  40 VALUE rb_assoc_new(VALUE, VALUE);
  41 VALUE rb_check_array_type(VALUE);
  42 VALUE rb_ary_new(void);
  43 VALUE rb_ary_new2(long);
  44 VALUE rb_ary_new3(long,...);
  45 VALUE rb_ary_new4(long, const VALUE *);
  46 VALUE rb_ary_tmp_new(long);
  47 void rb_ary_free(VALUE);
  48 VALUE rb_ary_freeze(VALUE);
  49 VALUE rb_ary_aref(int, VALUE*, VALUE);
  50 VALUE rb_ary_subseq(VALUE, long, long);
  51 void rb_ary_store(VALUE, long, VALUE);
  52 VALUE rb_ary_dup(VALUE);
  53 VALUE rb_ary_to_ary(VALUE);
  54 VALUE rb_ary_to_s(VALUE);
  55 VALUE rb_ary_push(VALUE, VALUE);
  56 VALUE rb_ary_pop(VALUE);
  57 VALUE rb_ary_shift(VALUE);
  58 VALUE rb_ary_unshift(VALUE, VALUE);
  59 VALUE rb_ary_entry(VALUE, long);
  60 VALUE rb_ary_each(VALUE);
  61 VALUE rb_ary_join(VALUE, VALUE);
  62 VALUE rb_ary_print_on(VALUE, VALUE);
  63 VALUE rb_ary_reverse(VALUE);
  64 VALUE rb_ary_sort(VALUE);
  65 VALUE rb_ary_sort_bang(VALUE);
  66 VALUE rb_ary_delete(VALUE, VALUE);
  67 VALUE rb_ary_delete_at(VALUE, long);
  68 VALUE rb_ary_clear(VALUE);
  69 VALUE rb_ary_plus(VALUE, VALUE);
  70 VALUE rb_ary_concat(VALUE, VALUE);
  71 VALUE rb_ary_assoc(VALUE, VALUE);
  72 VALUE rb_ary_rassoc(VALUE, VALUE);
  73 VALUE rb_ary_includes(VALUE, VALUE);
  74 VALUE rb_ary_cmp(VALUE, VALUE);
  75 VALUE rb_ary_replace(VALUE copy, VALUE orig);
  76 VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long));
  77 /* bignum.c */
  78 VALUE rb_big_clone(VALUE);
  79 void rb_big_2comp(VALUE);
  80 VALUE rb_big_norm(VALUE);
  81 void rb_big_resize(VALUE big, long len);
  82 VALUE rb_uint2big(VALUE);
  83 VALUE rb_int2big(SIGNED_VALUE);
  84 VALUE rb_uint2inum(VALUE);
  85 VALUE rb_int2inum(SIGNED_VALUE);
  86 VALUE rb_cstr_to_inum(const char*, int, int);
  87 VALUE rb_str_to_inum(VALUE, int, int);
  88 VALUE rb_cstr2inum(const char*, int);
  89 VALUE rb_str2inum(VALUE, int);
  90 VALUE rb_big2str(VALUE, int);
  91 VALUE rb_big2str0(VALUE, int, int);
  92 SIGNED_VALUE rb_big2long(VALUE);
  93 #define rb_big2int(x) rb_big2long(x)
  94 VALUE rb_big2ulong(VALUE);
  95 #define rb_big2uint(x) rb_big2ulong(x)
  96 #if HAVE_LONG_LONG
  97 VALUE rb_ll2inum(LONG_LONG);
  98 VALUE rb_ull2inum(unsigned LONG_LONG);
  99 LONG_LONG rb_big2ll(VALUE);
 100 unsigned LONG_LONG rb_big2ull(VALUE);
 101 #endif  /* HAVE_LONG_LONG */
 102 void rb_quad_pack(char*,VALUE);
 103 VALUE rb_quad_unpack(const char*,int);
 104 int rb_uv_to_utf8(char[6],unsigned long);
 105 VALUE rb_dbl2big(double);
 106 double rb_big2dbl(VALUE);
 107 VALUE rb_big_cmp(VALUE, VALUE);
 108 VALUE rb_big_eq(VALUE, VALUE);
 109 VALUE rb_big_plus(VALUE, VALUE);
 110 VALUE rb_big_minus(VALUE, VALUE);
 111 VALUE rb_big_mul(VALUE, VALUE);
 112 VALUE rb_big_div(VALUE, VALUE);
 113 VALUE rb_big_modulo(VALUE, VALUE);
 114 VALUE rb_big_divmod(VALUE, VALUE);
 115 VALUE rb_big_pow(VALUE, VALUE);
 116 VALUE rb_big_and(VALUE, VALUE);
 117 VALUE rb_big_or(VALUE, VALUE);
 118 VALUE rb_big_xor(VALUE, VALUE);
 119 VALUE rb_big_lshift(VALUE, VALUE);
 120 VALUE rb_big_rshift(VALUE, VALUE);
 121 /* rational.c */
 122 VALUE rb_rational_raw(VALUE, VALUE);
 123 #define rb_rational_raw1(x) rb_rational_raw(x, INT2FIX(1))
 124 #define rb_rational_raw2(x,y) rb_rational_raw(x, y)
 125 VALUE rb_rational_new(VALUE, VALUE);
 126 #define rb_rational_new1(x) rb_rational_new(x, INT2FIX(1))
 127 #define rb_rational_new2(x,y) rb_rational_new(x, y)
 128 VALUE rb_Rational(VALUE, VALUE);
 129 #define rb_Rational1(x) rb_Rational(x, INT2FIX(1))
 130 #define rb_Rational2(x,y) rb_Rational(x, y)
 131 /* complex.c */
 132 VALUE rb_complex_raw(VALUE, VALUE);
 133 #define rb_complex_raw1(x) rb_complex_raw(x, INT2FIX(0))
 134 #define rb_complex_raw2(x,y) rb_complex_raw(x, y)
 135 VALUE rb_complex_new(VALUE, VALUE);
 136 #define rb_complex_new1(x) rb_complex_new(x, INT2FIX(0))
 137 #define rb_complex_new2(x,y) rb_complex_new(x, y)
 138 VALUE rb_Complex(VALUE, VALUE);
 139 #define rb_Complex1(x) rb_Complex(x, INT2FIX(0))
 140 #define rb_Complex2(x,y) rb_Complex(x, y)
 141 /* class.c */
 142 VALUE rb_class_boot(VALUE);
 143 VALUE rb_class_new(VALUE);
 144 VALUE rb_mod_init_copy(VALUE, VALUE);
 145 VALUE rb_class_init_copy(VALUE, VALUE);
 146 VALUE rb_singleton_class_clone(VALUE);
 147 void rb_singleton_class_attached(VALUE,VALUE);
 148 VALUE rb_make_metaclass(VALUE, VALUE);
 149 void rb_check_inheritable(VALUE);
 150 VALUE rb_class_inherited(VALUE, VALUE);
 151 VALUE rb_define_class_id(ID, VALUE);
 152 VALUE rb_module_new(void);
 153 VALUE rb_define_module_id(ID);
 154 VALUE rb_mod_included_modules(VALUE);
 155 VALUE rb_mod_include_p(VALUE, VALUE);
 156 VALUE rb_mod_ancestors(VALUE);
 157 VALUE rb_class_instance_methods(int, VALUE*, VALUE);
 158 VALUE rb_class_public_instance_methods(int, VALUE*, VALUE);
 159 VALUE rb_class_protected_instance_methods(int, VALUE*, VALUE);
 160 VALUE rb_class_private_instance_methods(int, VALUE*, VALUE);
 161 VALUE rb_obj_singleton_methods(int, VALUE*, VALUE);
 162 void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);
 163 void rb_frozen_class_p(VALUE);
 164 void rb_undef(VALUE, ID);
 165 void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
 166 void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
 167 void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
 168 VALUE rb_singleton_class(VALUE);
 169 /* compar.c */
 170 int rb_cmpint(VALUE, VALUE, VALUE);
 171 NORETURN(void rb_cmperr(VALUE, VALUE));
 172 /* cont.c */
 173 VALUE rb_fiber_new(VALUE (*)(ANYARGS), VALUE);
 174 VALUE rb_fiber_resume(VALUE fib, int argc, VALUE *args);
 175 VALUE rb_fiber_yield(int argc, VALUE *args);
 176 VALUE rb_fiber_current(void);
 177 VALUE rb_fiber_alive_p(VALUE);
 178 /* enum.c */
 179 /* enumerator.c */
 180 VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *);
 181 #define RETURN_ENUMERATOR(obj, argc, argv) do {                         \
 182         if (!rb_block_given_p())                                        \
 183             return rb_enumeratorize(obj, ID2SYM(rb_frame_this_func()),  \
 184                                     argc, argv);                        \
 185     } while (0)
 186 /* error.c */
 187 VALUE rb_exc_new(VALUE, const char*, long);
 188 VALUE rb_exc_new2(VALUE, const char*);
 189 VALUE rb_exc_new3(VALUE, VALUE);
 190 PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
 191 PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);
 192 NORETURN(void rb_invalid_str(const char*, const char*));
 193 PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4);
 194 PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2);
 195 NORETURN(void rb_load_fail(const char*));
 196 NORETURN(void rb_error_frozen(const char*));
 197 void rb_check_frozen(VALUE);
 198 /* eval.c */
 199 int rb_sourceline(void);
 200 const char *rb_sourcefile(void);
 201
 202 #if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)
 203 typedef struct {
 204     int maxfd;
 205     fd_set *fdset;
 206 } rb_fdset_t;
 207
 208 void rb_fd_init(volatile rb_fdset_t *);
 209 void rb_fd_term(rb_fdset_t *);
 210 void rb_fd_zero(rb_fdset_t *);
 211 void rb_fd_set(int, rb_fdset_t *);
 212 void rb_fd_clr(int, rb_fdset_t *);
 213 int rb_fd_isset(int, const rb_fdset_t *);
 214 void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
 215 int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
 216
 217 #define rb_fd_ptr(f)    ((f)->fdset)
 218 #define rb_fd_max(f)    ((f)->maxfd)
 219
 220 #else
 221
 222 typedef fd_set rb_fdset_t;
 223 #define rb_fd_zero(f)   FD_ZERO(f)
 224 #define rb_fd_set(n, f) FD_SET(n, f)
 225 #define rb_fd_clr(n, f) FD_CLR(n, f)
 226 #define rb_fd_isset(n, f) FD_ISSET(n, f)
 227 #define rb_fd_copy(d, s, n) (*(d) = *(s))
 228 #define rb_fd_ptr(f)    (f)
 229 #define rb_fd_init(f)   FD_ZERO(f)
 230 #define rb_fd_term(f)   (void)(f)
 231 #define rb_fd_max(f)    FD_SETSIZE
 232 #define rb_fd_select(n, rfds, wfds, efds, timeout)      select(n, rfds, wfds, efds, timeout)
 233
 234 #endif
 235
 236 NORETURN(void rb_exc_raise(VALUE));
 237 NORETURN(void rb_exc_fatal(VALUE));
 238 VALUE rb_f_exit(int,VALUE*);
 239 VALUE rb_f_abort(int,VALUE*);
 240 void rb_remove_method(VALUE, const char*);
 241 #define rb_disable_super(klass, name) ((void)0)
 242 #define rb_enable_super(klass, name) ((void)0)
 243 #define HAVE_RB_DEFINE_ALLOC_FUNC 1
 244 typedef VALUE (*rb_alloc_func_t)(VALUE);
 245 void rb_define_alloc_func(VALUE, rb_alloc_func_t);
 246 void rb_undef_alloc_func(VALUE);
 247 rb_alloc_func_t rb_get_alloc_func(VALUE);
 248 void rb_clear_cache(void);
 249 void rb_clear_cache_by_class(VALUE);
 250 void rb_alias(VALUE, ID, ID);
 251 void rb_attr(VALUE,ID,int,int,int);
 252 int rb_method_boundp(VALUE, ID, int);
 253 int rb_method_basic_definition_p(VALUE, ID);
 254 VALUE rb_eval_cmd(VALUE, VALUE, int);
 255 int rb_obj_respond_to(VALUE, ID, int);
 256 int rb_respond_to(VALUE, ID);
 257 void rb_interrupt(void);
 258 VALUE rb_apply(VALUE, ID, VALUE);
 259 void rb_backtrace(void);
 260 ID rb_frame_this_func(void);
 261 VALUE rb_obj_instance_eval(int, VALUE*, VALUE);
 262 VALUE rb_obj_instance_exec(int, VALUE*, VALUE);
 263 VALUE rb_mod_module_eval(int, VALUE*, VALUE);
 264 VALUE rb_mod_module_exec(int, VALUE*, VALUE);
 265 void rb_load(VALUE, int);
 266 void rb_load_protect(VALUE, int, int*);
 267 NORETURN(void rb_jump_tag(int));
 268 int rb_provided(const char*);
 269 void rb_provide(const char*);
 270 VALUE rb_f_require(VALUE, VALUE);
 271 VALUE rb_require_safe(VALUE, int);
 272 void rb_obj_call_init(VALUE, int, VALUE*);
 273 VALUE rb_class_new_instance(int, VALUE*, VALUE);
 274 VALUE rb_block_proc(void);
 275 VALUE rb_f_lambda(void);
 276 VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
 277 VALUE rb_proc_call(VALUE, VALUE);
 278 VALUE rb_proc_call_with_block(VALUE, int argc, VALUE *argv, VALUE);
 279 int rb_proc_arity(VALUE);
 280 VALUE rb_binding_new(void);
 281 VALUE rb_obj_method(VALUE, VALUE);
 282 VALUE rb_method_call(int, VALUE*, VALUE);
 283 int rb_mod_method_arity(VALUE, ID);
 284 int rb_obj_method_arity(VALUE, ID);
 285 VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
 286 void rb_set_end_proc(void (*)(VALUE), VALUE);
 287 void rb_mark_end_proc(void);
 288 void rb_exec_end_proc(void);
 289 void Init_jump(void);
 290 void ruby_finalize(void);
 291 NORETURN(void ruby_stop(int));
 292 int ruby_cleanup(int);
 293 void rb_gc_mark_threads(void);
 294 void rb_thread_schedule(void);
 295 void rb_thread_wait_fd(int);
 296 int rb_thread_fd_writable(int);
 297 void rb_thread_fd_close(int);
 298 int rb_thread_alone(void);
 299 void rb_thread_polling(void);
 300 void rb_thread_sleep(int);
 301 void rb_thread_sleep_forever(void);
 302 VALUE rb_thread_stop(void);
 303 VALUE rb_thread_wakeup(VALUE);
 304 VALUE rb_thread_run(VALUE);
 305 VALUE rb_thread_kill(VALUE);
 306 VALUE rb_thread_create(VALUE (*)(ANYARGS), void*);
 307 void rb_thread_signal_raise(void *, int);
 308 void rb_thread_signal_exit(void *);
 309 int rb_thread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
 310 void rb_thread_wait_for(struct timeval);
 311 VALUE rb_thread_current(void);
 312 VALUE rb_thread_main(void);
 313 VALUE rb_thread_local_aref(VALUE, ID);
 314 VALUE rb_thread_local_aset(VALUE, ID, VALUE);
 315 void rb_thread_atfork(void);
 316 void rb_thread_atfork_before_exec(void);
 317 VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
 318 /* file.c */
 319 VALUE rb_file_s_expand_path(int, VALUE *);
 320 VALUE rb_file_expand_path(VALUE, VALUE);
 321 void rb_file_const(const char*, VALUE);
 322 int rb_find_file_ext(VALUE*, const char* const*);
 323 VALUE rb_find_file(VALUE);
 324 char *rb_path_next(const char *);
 325 char *rb_path_skip_prefix(const char *);
 326 char *rb_path_last_separator(const char *);
 327 char *rb_path_end(const char *);
 328 VALUE rb_file_directory_p(VALUE,VALUE);
 329 /* gc.c */
 330 void ruby_set_stack_size(size_t);
 331 NORETURN(void rb_memerror(void));
 332 int ruby_stack_check(void);
 333 size_t ruby_stack_length(VALUE**);
 334 int rb_during_gc(void);
 335 void rb_gc_mark_locations(VALUE*, VALUE*);
 336 void rb_mark_tbl(struct st_table*);
 337 void rb_mark_set(struct st_table*);
 338 void rb_mark_hash(struct st_table*);
 339 void rb_gc_mark_maybe(VALUE);
 340 void rb_gc_mark(VALUE);
 341 void rb_gc_force_recycle(VALUE);
 342 void rb_gc(void);
 343 void rb_gc_copy_finalizer(VALUE,VALUE);
 344 void rb_gc_finalize_deferred(void);
 345 void rb_gc_call_finalizer_at_exit(void);
 346 VALUE rb_gc_enable(void);
 347 VALUE rb_gc_disable(void);
 348 VALUE rb_gc_start(void);
 349 /* hash.c */
 350 void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t);
 351 void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE);
 352 VALUE rb_hash(VALUE);
 353 VALUE rb_hash_new(void);
 354 VALUE rb_hash_dup(VALUE);
 355 VALUE rb_hash_freeze(VALUE);
 356 VALUE rb_hash_aref(VALUE, VALUE);
 357 VALUE rb_hash_lookup(VALUE, VALUE);
 358 VALUE rb_hash_aset(VALUE, VALUE, VALUE);
 359 VALUE rb_hash_delete_if(VALUE);
 360 VALUE rb_hash_delete(VALUE,VALUE);
 361 struct st_table *rb_hash_tbl(VALUE);
 362 int rb_path_check(const char*);
 363 int rb_env_path_tainted(void);
 364 VALUE rb_env_clear(void);
 365 /* io.c */
 366 #define rb_defout rb_stdout
 367 RUBY_EXTERN VALUE rb_fs;
 368 RUBY_EXTERN VALUE rb_output_fs;
 369 RUBY_EXTERN VALUE rb_rs;
 370 RUBY_EXTERN VALUE rb_default_rs;
 371 RUBY_EXTERN VALUE rb_output_rs;
 372 VALUE rb_io_write(VALUE, VALUE);
 373 VALUE rb_io_gets(VALUE);
 374 VALUE rb_io_getbyte(VALUE);
 375 VALUE rb_io_ungetc(VALUE, VALUE);
 376 VALUE rb_io_close(VALUE);
 377 VALUE rb_io_flush(VALUE);
 378 VALUE rb_io_eof(VALUE);
 379 VALUE rb_io_binmode(VALUE);
 380 VALUE rb_io_addstr(VALUE, VALUE);
 381 VALUE rb_io_printf(int, VALUE*, VALUE);
 382 VALUE rb_io_print(int, VALUE*, VALUE);
 383 VALUE rb_io_puts(int, VALUE*, VALUE);
 384 VALUE rb_io_fdopen(int, int, const char*);
 385 VALUE rb_file_open(const char*, const char*);
 386 VALUE rb_gets(void);
 387 void rb_write_error(const char*);
 388 void rb_write_error2(const char*, long);
 389 int rb_io_mode_modenum(const char *mode);
 390 void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds);
 391 int rb_pipe(int *pipes);
 392 /* marshal.c */
 393 VALUE rb_marshal_dump(VALUE, VALUE);
 394 VALUE rb_marshal_load(VALUE);
 395 void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE));
 396 /* numeric.c */
 397 void rb_num_zerodiv(void);
 398 VALUE rb_num_coerce_bin(VALUE, VALUE, ID);
 399 VALUE rb_num_coerce_cmp(VALUE, VALUE, ID);
 400 VALUE rb_num_coerce_relop(VALUE, VALUE, ID);
 401 VALUE rb_float_new(double);
 402 VALUE rb_num2fix(VALUE);
 403 VALUE rb_fix2str(VALUE, int);
 404 VALUE rb_dbl_cmp(double, double);
 405 /* object.c */
 406 int rb_eql(VALUE, VALUE);
 407 VALUE rb_any_to_s(VALUE);
 408 VALUE rb_inspect(VALUE);
 409 VALUE rb_obj_is_instance_of(VALUE, VALUE);
 410 VALUE rb_obj_is_kind_of(VALUE, VALUE);
 411 VALUE rb_obj_alloc(VALUE);
 412 VALUE rb_obj_clone(VALUE);
 413 VALUE rb_obj_dup(VALUE);
 414 VALUE rb_obj_init_copy(VALUE,VALUE);
 415 VALUE rb_obj_taint(VALUE);
 416 VALUE rb_obj_tainted(VALUE);
 417 VALUE rb_obj_untaint(VALUE);
 418 VALUE rb_obj_freeze(VALUE);
 419 VALUE rb_obj_frozen_p(VALUE);
 420 VALUE rb_obj_id(VALUE);
 421 VALUE rb_obj_class(VALUE);
 422 VALUE rb_class_real(VALUE);
 423 VALUE rb_class_inherited_p(VALUE, VALUE);
 424 VALUE rb_convert_type(VALUE,int,const char*,const char*);
 425 VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
 426 VALUE rb_check_to_integer(VALUE, const char *);
 427 VALUE rb_to_int(VALUE);
 428 VALUE rb_Integer(VALUE);
 429 VALUE rb_Float(VALUE);
 430 VALUE rb_String(VALUE);
 431 VALUE rb_Array(VALUE);
 432 double rb_cstr_to_dbl(const char*, int);
 433 double rb_str_to_dbl(VALUE, int);
 434 /* parse.y */
 435 RUBY_EXTERN int   ruby_sourceline;
 436 RUBY_EXTERN char *ruby_sourcefile;
 437 ID rb_id_attrset(ID);
 438 void rb_gc_mark_parser(void);
 439 int rb_is_const_id(ID);
 440 int rb_is_instance_id(ID);
 441 int rb_is_class_id(ID);
 442 int rb_is_local_id(ID);
 443 int rb_is_junk_id(ID);
 444 int rb_symname_p(const char*);
 445 int rb_sym_interned_p(VALUE);
 446 void rb_gc_mark_symbols(void);
 447 VALUE rb_backref_get(void);
 448 void rb_backref_set(VALUE);
 449 VALUE rb_lastline_get(void);
 450 void rb_lastline_set(VALUE);
 451 VALUE rb_sym_all_symbols(void);
 452 /* process.c */
 453 void rb_last_status_set(int status, rb_pid_t pid);
 454 VALUE rb_last_status_get(void);
 455 struct rb_exec_arg {
 456     int argc;
 457     VALUE *argv;
 458     const char *prog;
 459     VALUE options;
 460     VALUE redirect_fds;
 461 };
 462 int rb_proc_exec_n(int, VALUE*, const char*);
 463 int rb_proc_exec(const char*);
 464 VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e);
 465 int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val);
 466 void rb_exec_arg_fixup(struct rb_exec_arg *e);
 467 int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s);
 468 int rb_exec(const struct rb_exec_arg*);
 469 rb_pid_t rb_fork(int*, int (*)(void*), void*, VALUE);
 470 VALUE rb_f_exec(int,VALUE*);
 471 rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags);
 472 void rb_syswait(rb_pid_t pid);
 473 rb_pid_t rb_spawn(int, VALUE*);
 474 VALUE rb_proc_times(VALUE);
 475 VALUE rb_detach_process(rb_pid_t pid);
 476 /* range.c */
 477 VALUE rb_range_new(VALUE, VALUE, int);
 478 VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
 479 /* random.c */
 480 unsigned long rb_genrand_int32(void);
 481 double rb_genrand_real(void);
 482 void rb_reset_random_seed(void);
 483 /* re.c */
 484 #define rb_memcmp memcmp
 485 int rb_memcicmp(const void*,const void*,long);
 486 void rb_match_busy(VALUE);
 487 VALUE rb_reg_nth_defined(int, VALUE);
 488 VALUE rb_reg_nth_match(int, VALUE);
 489 VALUE rb_reg_last_match(VALUE);
 490 VALUE rb_reg_match_pre(VALUE);
 491 VALUE rb_reg_match_post(VALUE);
 492 VALUE rb_reg_match_last(VALUE);
 493 #define HAVE_RB_REG_NEW_STR 1
 494 VALUE rb_reg_new_str(VALUE, int);
 495 VALUE rb_reg_new(const char *, long, int);
 496 VALUE rb_reg_match(VALUE, VALUE);
 497 VALUE rb_reg_match2(VALUE);
 498 int rb_reg_options(VALUE);
 499 void rb_set_kcode(const char*);
 500 const char* rb_get_kcode(void);
 501 /* ruby.c */
 502 #define rb_argv rb_get_argv()
 503 RUBY_EXTERN VALUE rb_argv0;
 504 VALUE rb_get_argv(void);
 505 void *rb_load_file(const char*);
 506 void ruby_script(const char*);
 507 void ruby_prog_init(void);
 508 void ruby_set_argv(int, char**);
 509 void *ruby_process_options(int, char**);
 510 void ruby_init_loadpath(void);
 511 void ruby_incpush(const char*);
 512 /* signal.c */
 513 VALUE rb_f_kill(int, VALUE*);
 514 void rb_gc_mark_trap_list(void);
 515 #ifdef POSIX_SIGNAL
 516 #define posix_signal ruby_posix_signal
 517 RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int);
 518 #endif
 519 void ruby_sig_finalize(void);
 520 void rb_trap_exit(void);
 521 void rb_trap_exec(void);
 522 const char *ruby_signal_name(int);
 523 void ruby_default_signal(int);
 524 /* sprintf.c */
 525 VALUE rb_f_sprintf(int, const VALUE*);
 526 PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
 527 VALUE rb_vsprintf(const char*, va_list);
 528 PRINTF_ARGS(VALUE rb_str_catf(VALUE, const char*, ...), 2, 3);
 529 VALUE rb_str_vcatf(VALUE, const char*, va_list);
 530 VALUE rb_str_format(int, const VALUE *, VALUE);
 531 /* string.c */
 532 VALUE rb_str_new(const char*, long);
 533 VALUE rb_str_new_cstr(const char*);
 534 VALUE rb_str_new2(const char*);
 535 VALUE rb_str_new_shared(VALUE);
 536 VALUE rb_str_new3(VALUE);
 537 VALUE rb_str_new_frozen(VALUE);
 538 VALUE rb_str_new4(VALUE);
 539 VALUE rb_str_new_with_class(VALUE, const char*, long);
 540 VALUE rb_str_new5(VALUE, const char*, long);
 541 VALUE rb_tainted_str_new_cstr(const char*);
 542 VALUE rb_tainted_str_new(const char*, long);
 543 VALUE rb_tainted_str_new2(const char*);
 544 VALUE rb_str_buf_new(long);
 545 VALUE rb_str_buf_new_cstr(const char*);
 546 VALUE rb_str_buf_new2(const char*);
 547 VALUE rb_str_tmp_new(long);
 548 VALUE rb_usascii_str_new(const char*, long);
 549 VALUE rb_usascii_str_new_cstr(const char*);
 550 VALUE rb_usascii_str_new2(const char*);
 551 void rb_str_free(VALUE);
 552 void rb_str_shared_replace(VALUE, VALUE);
 553 VALUE rb_str_buf_append(VALUE, VALUE);
 554 VALUE rb_str_buf_cat(VALUE, const char*, long);
 555 VALUE rb_str_buf_cat2(VALUE, const char*);
 556 VALUE rb_str_buf_cat_ascii(VALUE, const char*);
 557 VALUE rb_obj_as_string(VALUE);
 558 VALUE rb_check_string_type(VALUE);
 559 VALUE rb_str_dup(VALUE);
 560 VALUE rb_str_locktmp(VALUE);
 561 VALUE rb_str_unlocktmp(VALUE);
 562 VALUE rb_str_dup_frozen(VALUE);
 563 #define rb_str_dup_frozen rb_str_new_frozen
 564 VALUE rb_str_plus(VALUE, VALUE);
 565 VALUE rb_str_times(VALUE, VALUE);
 566 long rb_str_sublen(VALUE, long);
 567 VALUE rb_str_substr(VALUE, long, long);
 568 VALUE rb_str_subseq(VALUE, long, long);
 569 void rb_str_modify(VALUE);
 570 VALUE rb_str_freeze(VALUE);
 571 void rb_str_set_len(VALUE, long);
 572 VALUE rb_str_resize(VALUE, long);
 573 VALUE rb_str_cat(VALUE, const char*, long);
 574 VALUE rb_str_cat2(VALUE, const char*);
 575 VALUE rb_str_append(VALUE, VALUE);
 576 VALUE rb_str_concat(VALUE, VALUE);
 577 int rb_memhash(const void *ptr, long len);
 578 int rb_str_hash(VALUE);
 579 int rb_str_hash_cmp(VALUE,VALUE);
 580 int rb_str_comparable(VALUE, VALUE);
 581 int rb_str_cmp(VALUE, VALUE);
 582 VALUE rb_str_equal(VALUE str1, VALUE str2);
 583 VALUE rb_str_drop_bytes(VALUE, long);
 584 void rb_str_update(VALUE, long, long, VALUE);
 585 VALUE rb_str_inspect(VALUE);
 586 VALUE rb_str_dump(VALUE);
 587 VALUE rb_str_split(VALUE, const char*);
 588 void rb_str_associate(VALUE, VALUE);
 589 VALUE rb_str_associated(VALUE);
 590 void rb_str_setter(VALUE, ID, VALUE*);
 591 VALUE rb_str_intern(VALUE);
 592 VALUE rb_sym_to_s(VALUE);
 593 VALUE rb_str_length(VALUE);
 594 size_t rb_str_capacity(VALUE);
 595 #if defined __GNUC__
 596 #define rb_str_new_cstr(str) __extension__ (    \
 597 {                                               \
 598     (__builtin_constant_p(str)) ?               \
 599         rb_str_new(str, strlen(str)) :          \
 600         rb_str_new_cstr(str);                   \
 601 })
 602 #define rb_tainted_str_new_cstr(str) __extension__ ( \
 603 {                                              \
 604     (__builtin_constant_p(str)) ?              \
 605         rb_tainted_str_new(str, strlen(str)) : \
 606         rb_tainted_str_new_cstr(str);          \
 607 })
 608 #define rb_usascii_str_new_cstr(str) __extension__ ( \
 609 {                                              \
 610     (__builtin_constant_p(str)) ?              \
 611         rb_usascii_str_new(str, strlen(str)) : \
 612         rb_usascii_str_new_cstr(str);          \
 613 })
 614 #define rb_str_buf_new_cstr(str) __extension__ ( \
 615 {                                               \
 616     (__builtin_constant_p(str)) ?               \
 617         rb_str_buf_cat(rb_str_buf_new(strlen(str)), \
 618                        str, strlen(str)) :      \
 619         rb_str_buf_new_cstr(str);               \
 620 })
 621 #define rb_str_buf_cat2(str, ptr) __extension__ ( \
 622 {                                               \
 623     (__builtin_constant_p(ptr)) ?               \
 624         rb_str_buf_cat(str, ptr, strlen(ptr)) : \
 625         rb_str_buf_cat2(str, ptr);              \
 626 })
 627 #define rb_str_cat2(str, ptr) __extension__ (   \
 628 {                                               \
 629     (__builtin_constant_p(ptr)) ?               \
 630         rb_str_cat(str, ptr, strlen(ptr)) :     \
 631         rb_str_cat2(str, ptr);                  \
 632 })
 633 #endif
 634 #define rb_str_new2 rb_str_new_cstr
 635 #define rb_str_new3 rb_str_new_shared
 636 #define rb_str_new4 rb_str_new_frozen
 637 #define rb_str_new5 rb_str_new_with_class
 638 #define rb_tainted_str_new2 rb_tainted_str_new_cstr
 639 #define rb_str_buf_new2 rb_str_buf_new_cstr
 640 #define rb_usascii_str_new2 rb_usascii_str_new_cstr
 641 /* struct.c */
 642 VALUE rb_struct_new(VALUE, ...);
 643 VALUE rb_struct_define(const char*, ...);
 644 VALUE rb_struct_alloc(VALUE, VALUE);
 645 VALUE rb_struct_initialize(VALUE, VALUE);
 646 VALUE rb_struct_aref(VALUE, VALUE);
 647 VALUE rb_struct_aset(VALUE, VALUE, VALUE);
 648 VALUE rb_struct_getmember(VALUE, ID);
 649 VALUE rb_struct_iv_get(VALUE, const char*);
 650 VALUE rb_struct_s_members(VALUE);
 651 VALUE rb_struct_members(VALUE);
 652 VALUE rb_struct_alloc_noinit(VALUE);
 653 VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t, ...);
 654 /* thread.c */
 655 typedef void rb_unblock_function_t(void *);
 656 typedef VALUE rb_blocking_function_t(void *);
 657 void rb_thread_check_ints(void);
 658 VALUE rb_thread_blocking_region(rb_blocking_function_t *func, void *data1,
 659                                 rb_unblock_function_t *ubf, void *data2);
 660 #define RB_UBF_DFL ((rb_unblock_function_t *)-1)
 661 VALUE rb_mutex_new(void);
 662 VALUE rb_mutex_locked_p(VALUE mutex);
 663 VALUE rb_mutex_try_lock(VALUE mutex);
 664 VALUE rb_mutex_lock(VALUE mutex);
 665 VALUE rb_mutex_unlock(VALUE mutex);
 666 VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
 667 VALUE rb_mutex_synchronize(VALUE self);
 668 VALUE rb_barrier_new(void);
 669 VALUE rb_barrier_wait(VALUE self);
 670 VALUE rb_barrier_release(VALUE self);
 671 /* time.c */
 672 VALUE rb_time_new(time_t, long);
 673 VALUE rb_time_nano_new(time_t, long);
 674 /* variable.c */
 675 VALUE rb_mod_name(VALUE);
 676 VALUE rb_class_path(VALUE);
 677 void rb_set_class_path(VALUE, VALUE, const char*);
 678 VALUE rb_path2class(const char*);
 679 void rb_name_class(VALUE, ID);
 680 VALUE rb_class_name(VALUE);
 681 void rb_autoload(VALUE, ID, const char*);
 682 VALUE rb_autoload_load(VALUE, ID);
 683 VALUE rb_autoload_p(VALUE, ID);
 684 void rb_gc_mark_global_tbl(void);
 685 VALUE rb_f_trace_var(int, VALUE*);
 686 VALUE rb_f_untrace_var(int, VALUE*);
 687 VALUE rb_f_global_variables(void);
 688 void rb_alias_variable(ID, ID);
 689 struct st_table* rb_generic_ivar_table(VALUE);
 690 void rb_copy_generic_ivar(VALUE,VALUE);
 691 void rb_mark_generic_ivar(VALUE);
 692 void rb_mark_generic_ivar_tbl(void);
 693 void rb_free_generic_ivar(VALUE);
 694 VALUE rb_ivar_get(VALUE, ID);
 695 VALUE rb_ivar_set(VALUE, ID, VALUE);
 696 VALUE rb_ivar_defined(VALUE, ID);
 697 void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t);
 698 VALUE rb_iv_set(VALUE, const char*, VALUE);
 699 VALUE rb_iv_get(VALUE, const char*);
 700 VALUE rb_attr_get(VALUE, ID);
 701 VALUE rb_obj_instance_variables(VALUE);
 702 VALUE rb_obj_remove_instance_variable(VALUE, VALUE);
 703 void *rb_mod_const_at(VALUE, void*);
 704 void *rb_mod_const_of(VALUE, void*);
 705 VALUE rb_const_list(void*);
 706 VALUE rb_mod_constants(int, VALUE *, VALUE);
 707 VALUE rb_mod_remove_const(VALUE, VALUE);
 708 int rb_const_defined(VALUE, ID);
 709 int rb_const_defined_at(VALUE, ID);
 710 int rb_const_defined_from(VALUE, ID);
 711 VALUE rb_const_get(VALUE, ID);
 712 VALUE rb_const_get_at(VALUE, ID);
 713 VALUE rb_const_get_from(VALUE, ID);
 714 void rb_const_set(VALUE, ID, VALUE);
 715 VALUE rb_mod_const_missing(VALUE,VALUE);
 716 VALUE rb_cvar_defined(VALUE, ID);
 717 void rb_cvar_set(VALUE, ID, VALUE);
 718 VALUE rb_cvar_get(VALUE, ID);
 719 void rb_cv_set(VALUE, const char*, VALUE);
 720 VALUE rb_cv_get(VALUE, const char*);
 721 void rb_define_class_variable(VALUE, const char*, VALUE);
 722 VALUE rb_mod_class_variables(VALUE);
 723 VALUE rb_mod_remove_cvar(VALUE, VALUE);
 724 /* version.c */
 725 void ruby_show_version(void);
 726 void ruby_show_copyright(void);
 727
 728 ID rb_frame_callee(void);
 729 VALUE rb_str_succ(VALUE);
 730 VALUE rb_time_succ(VALUE);
 731 #define Init_stack(addr) ruby_init_stack(addr)
 732 void rb_frame_pop(void);
 733 int rb_frame_method_id_and_class(ID *idp, VALUE *klassp);
 734
 735 #if defined(__cplusplus)
 736 #if 0
 737 { /* satisfy cc-mode */
 738 #endif
 739 }  /* extern "C" { */
 740 #endif
 741
 742 #endif /* RUBY_INTERN_H */