mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* bignum.c: changed foo _((boo))' to
foo(boo)`. [ruby-dev:27056]
* defines.h, dir.c, dln.h, enumerator.c, env.h, error.c, eval.c, file.c, gc.c, hash.c, inits.c, intern.h, io.c, lex.c, marshal.c, missing.h, node.h, numeric.c, pack.c, process.c, re.h, ruby.c, ruby.h, rubyio.h, rubysig.h, signal.c, sprintf.c, st.h, string.c, struct.c, time.c, util.c, util.h, variable.c: ditto. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9155 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
parent
6b1239a820
commit
08c1738c51
36 changed files with 826 additions and 816 deletions
10
ChangeLog
10
ChangeLog
|
@ -1,3 +1,13 @@
|
|||
Wed Sep 14 15:06:22 2005 Hirokazu Yamamoto <ocean@m2.ccsnet.ne.jp>
|
||||
|
||||
* bignum.c: changed `foo _((boo))' to `foo(boo)`. [ruby-dev:27056]
|
||||
|
||||
* defines.h, dir.c, dln.h, enumerator.c, env.h, error.c, eval.c, file.c,
|
||||
gc.c, hash.c, inits.c, intern.h, io.c, lex.c, marshal.c, missing.h,
|
||||
node.h, numeric.c, pack.c, process.c, re.h, ruby.c, ruby.h, rubyio.h,
|
||||
rubysig.h, signal.c, sprintf.c, st.h, string.c, struct.c, time.c,
|
||||
util.c, util.h, variable.c: ditto.
|
||||
|
||||
Tue Sep 13 22:09:40 2005 NAKAMURA, Hiroshi <nakahiro@sarion.co.jp>
|
||||
|
||||
* lib/logger.rb (Logger): added formatter accessor to logger for
|
||||
|
|
2
bignum.c
2
bignum.c
|
@ -1739,7 +1739,7 @@ rb_big_xor(VALUE xx, VALUE yy)
|
|||
return bignorm(z);
|
||||
}
|
||||
|
||||
static VALUE rb_big_rshift _((VALUE,VALUE));
|
||||
static VALUE rb_big_rshift(VALUE,VALUE);
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
|
|
|
@ -46,10 +46,10 @@
|
|||
#define xrealloc ruby_xrealloc
|
||||
#define xfree ruby_xfree
|
||||
|
||||
void *xmalloc _((long));
|
||||
void *xcalloc _((long,long));
|
||||
void *xrealloc _((void*,long));
|
||||
void xfree _((void*));
|
||||
void *xmalloc(long);
|
||||
void *xcalloc(long,long);
|
||||
void *xrealloc(void*,long);
|
||||
void xfree(void*);
|
||||
|
||||
#if SIZEOF_LONG_LONG > 0
|
||||
# define LONG_LONG long long
|
||||
|
|
8
dir.c
8
dir.c
|
@ -56,7 +56,7 @@ char *getenv();
|
|||
#endif
|
||||
|
||||
#ifndef HAVE_STRING_H
|
||||
char *strchr _((char*,char));
|
||||
char *strchr(char*,char);
|
||||
#endif
|
||||
|
||||
#include <ctype.h>
|
||||
|
@ -351,7 +351,7 @@ free_dir(struct dir_data *dir)
|
|||
free(dir);
|
||||
}
|
||||
|
||||
static VALUE dir_close _((VALUE));
|
||||
static VALUE dir_close(VALUE);
|
||||
|
||||
static VALUE
|
||||
dir_s_alloc(VALUE klass)
|
||||
|
@ -1104,7 +1104,7 @@ enum answer { YES, NO, UNKNOWN };
|
|||
#endif
|
||||
|
||||
struct glob_args {
|
||||
void (*func) _((const char *, VALUE));
|
||||
void (*func)(const char *, VALUE);
|
||||
const char *c;
|
||||
VALUE v;
|
||||
};
|
||||
|
@ -1329,7 +1329,7 @@ rb_glob2(const char *path, int flags, void (*func) (const char *, VALUE), VALUE
|
|||
}
|
||||
|
||||
struct rb_glob_args {
|
||||
void (*func) _((const char*, VALUE));
|
||||
void (*func)(const char*, VALUE);
|
||||
VALUE arg;
|
||||
};
|
||||
|
||||
|
|
6
dln.h
6
dln.h
|
@ -29,12 +29,12 @@
|
|||
# define _(args) ()
|
||||
#endif
|
||||
|
||||
char *dln_find_exe _((const char*,const char*));
|
||||
char *dln_find_file _((const char*,const char*));
|
||||
char *dln_find_exe(const char*,const char*);
|
||||
char *dln_find_file(const char*,const char*);
|
||||
|
||||
#ifdef USE_DLN_A_OUT
|
||||
extern char *dln_argv0;
|
||||
#endif
|
||||
|
||||
void *dln_load _((const char*));
|
||||
void *dln_load(const char*);
|
||||
#endif
|
||||
|
|
|
@ -272,7 +272,7 @@ enumerator_init(VALUE enum_obj, VALUE obj, VALUE meth, int argc, VALUE *argv)
|
|||
ptr->iter = enumerator_iter_i;
|
||||
}
|
||||
else {
|
||||
ptr->iter = (VALUE (*) _((VALUE, struct enumerator *)))rb_yield;
|
||||
ptr->iter = (VALUE (*)(VALUE, struct enumerator *))rb_yield;
|
||||
}
|
||||
if (argc) ptr->args = rb_ary_new4(argc, argv);
|
||||
|
||||
|
|
2
env.h
2
env.h
|
@ -27,7 +27,7 @@ RUBY_EXTERN struct FRAME {
|
|||
unsigned long uniq;
|
||||
} *ruby_frame;
|
||||
|
||||
void rb_gc_mark_frame _((struct FRAME *));
|
||||
void rb_gc_mark_frame(struct FRAME *);
|
||||
|
||||
#define FRAME_DMETH 1
|
||||
#define FRAME_FUNC 2
|
||||
|
|
2
error.c
2
error.c
|
@ -53,7 +53,7 @@ err_snprintf(char *buf, long len, const char *fmt, va_list args)
|
|||
}
|
||||
}
|
||||
|
||||
static void err_append _((const char*));
|
||||
static void err_append(const char*);
|
||||
static void
|
||||
err_print(const char *fmt, va_list args)
|
||||
{
|
||||
|
|
118
eval.c
118
eval.c
|
@ -66,7 +66,7 @@ void *alloca ();
|
|||
#include <stdarg.h>
|
||||
|
||||
#ifndef HAVE_STRING_H
|
||||
char *strrchr _((const char*,const char));
|
||||
char *strrchr(const char*,const char);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_UNISTD_H
|
||||
|
@ -191,18 +191,18 @@ typedef jmp_buf rb_jmpbuf_t;
|
|||
|
||||
VALUE rb_cProc;
|
||||
static VALUE rb_cBinding;
|
||||
static VALUE proc_invoke _((VALUE,VALUE,VALUE,VALUE));
|
||||
static VALUE proc_lambda _((void));
|
||||
static VALUE rb_f_binding _((VALUE));
|
||||
static void rb_f_END _((void));
|
||||
static VALUE rb_f_block_given_p _((void));
|
||||
static VALUE block_pass _((VALUE,NODE*));
|
||||
static VALUE proc_invoke(VALUE,VALUE,VALUE,VALUE);
|
||||
static VALUE proc_lambda(void);
|
||||
static VALUE rb_f_binding(VALUE);
|
||||
static void rb_f_END(void);
|
||||
static VALUE rb_f_block_given_p(void);
|
||||
static VALUE block_pass(VALUE,NODE*);
|
||||
static VALUE rb_cMethod;
|
||||
static VALUE rb_cUnboundMethod;
|
||||
static VALUE umethod_bind _((VALUE, VALUE));
|
||||
static VALUE rb_mod_define_method _((int, VALUE*, VALUE));
|
||||
NORETURN(static void rb_raise_jump _((VALUE)));
|
||||
static VALUE rb_make_exception _((int argc, VALUE *argv));
|
||||
static VALUE umethod_bind(VALUE, VALUE);
|
||||
static VALUE rb_mod_define_method(int, VALUE*, VALUE);
|
||||
NORETURN(static void rb_raise_jump(VALUE));
|
||||
static VALUE rb_make_exception(int argc, VALUE *argv);
|
||||
|
||||
static int scope_vmode;
|
||||
#define SCOPE_PUBLIC 0
|
||||
|
@ -223,8 +223,8 @@ int ruby_safe_level = 0;
|
|||
4 - no global (non-tainted) variable modification/no direct output
|
||||
*/
|
||||
|
||||
static VALUE safe_getter _((void));
|
||||
static void safe_setter _((VALUE val));
|
||||
static VALUE safe_getter(void);
|
||||
static void safe_setter(VALUE val);
|
||||
|
||||
void
|
||||
rb_secure(int level)
|
||||
|
@ -271,7 +271,7 @@ rb_check_safe_str(VALUE x)
|
|||
}
|
||||
}
|
||||
|
||||
NORETURN(static void print_undef _((VALUE, ID)));
|
||||
NORETURN(static void print_undef(VALUE, ID));
|
||||
static void
|
||||
print_undef(VALUE klass, ID id)
|
||||
{
|
||||
|
@ -987,7 +987,7 @@ static NODE *top_cref;
|
|||
typedef struct thread * rb_thread_t;
|
||||
static rb_thread_t curr_thread = 0;
|
||||
static rb_thread_t main_thread;
|
||||
static void scope_dup _((struct SCOPE *));
|
||||
static void scope_dup(struct SCOPE *);
|
||||
|
||||
#define POP_SCOPE() \
|
||||
if (ruby_scope->flags & SCOPE_DONT_RECYCLE) {\
|
||||
|
@ -1016,8 +1016,8 @@ struct ruby_env {
|
|||
NODE *cref;
|
||||
};
|
||||
|
||||
static void push_thread_anchor _((struct ruby_env *));
|
||||
static void pop_thread_anchor _((struct ruby_env *));
|
||||
static void push_thread_anchor(struct ruby_env *);
|
||||
static void pop_thread_anchor(struct ruby_env *);
|
||||
|
||||
#define PUSH_THREAD_TAG() PUSH_TAG(PROT_THREAD); \
|
||||
do { \
|
||||
|
@ -1028,11 +1028,11 @@ static void pop_thread_anchor _((struct ruby_env *));
|
|||
} while (0); \
|
||||
POP_TAG()
|
||||
|
||||
static VALUE rb_eval _((VALUE,NODE*));
|
||||
static VALUE eval _((VALUE,VALUE,VALUE,char*,int));
|
||||
static NODE *compile _((VALUE, char*, int));
|
||||
static VALUE rb_eval(VALUE,NODE*);
|
||||
static VALUE eval(VALUE,VALUE,VALUE,char*,int);
|
||||
static NODE *compile(VALUE, char*, int);
|
||||
|
||||
static VALUE rb_yield_0 _((VALUE, VALUE, VALUE, int, int));
|
||||
static VALUE rb_yield_0(VALUE, VALUE, VALUE, int, int);
|
||||
|
||||
#define YIELD_LAMBDA_CALL 1
|
||||
#define YIELD_PROC_CALL 2
|
||||
|
@ -1040,12 +1040,12 @@ static VALUE rb_yield_0 _((VALUE, VALUE, VALUE, int, int));
|
|||
#define YIELD_FUNC_AVALUE 1
|
||||
#define YIELD_FUNC_SVALUE 2
|
||||
|
||||
static VALUE rb_call _((VALUE,VALUE,ID,int,const VALUE*,int));
|
||||
static VALUE module_setup _((VALUE,NODE*));
|
||||
static VALUE rb_call(VALUE,VALUE,ID,int,const VALUE*,int);
|
||||
static VALUE module_setup(VALUE,NODE*);
|
||||
|
||||
static VALUE massign _((VALUE,NODE*,VALUE,int));
|
||||
static void assign _((VALUE,NODE*,VALUE,int));
|
||||
static int formal_assign _((VALUE, NODE*, int, const VALUE*, VALUE*));
|
||||
static VALUE massign(VALUE,NODE*,VALUE,int);
|
||||
static void assign(VALUE,NODE*,VALUE,int);
|
||||
static int formal_assign(VALUE, NODE*, int, const VALUE*, VALUE*);
|
||||
|
||||
typedef struct event_hook {
|
||||
rb_event_hook_func_t func;
|
||||
|
@ -1067,7 +1067,7 @@ static rb_event_hook_t *event_hooks;
|
|||
|
||||
static VALUE trace_func = 0;
|
||||
static int tracing = 0;
|
||||
static void call_trace_func _((rb_event_t,NODE*,VALUE,ID,VALUE));
|
||||
static void call_trace_func(rb_event_t,NODE*,VALUE,ID,VALUE);
|
||||
|
||||
#if 0
|
||||
#define SET_CURRENT_SOURCE() (ruby_sourcefile = ruby_current_node->nd_file, \
|
||||
|
@ -1247,10 +1247,10 @@ extern char **environ;
|
|||
#endif
|
||||
char **rb_origenviron;
|
||||
|
||||
void rb_call_inits _((void));
|
||||
void Init_stack _((VALUE*));
|
||||
void Init_heap _((void));
|
||||
void Init_ext _((void));
|
||||
void rb_call_inits(void);
|
||||
void Init_stack(VALUE*);
|
||||
void Init_heap(void);
|
||||
void Init_ext(void);
|
||||
|
||||
#ifdef HAVE_NATIVETHREAD
|
||||
static rb_nativethread_t ruby_thid;
|
||||
|
@ -1270,7 +1270,7 @@ ruby_native_thread_kill(sig)
|
|||
# endif
|
||||
#endif
|
||||
|
||||
NORETURN(static void rb_thread_start_1 _((void)));
|
||||
NORETURN(static void rb_thread_start_1(void));
|
||||
|
||||
void
|
||||
ruby_init(void)
|
||||
|
@ -1344,8 +1344,8 @@ eval_node(VALUE self, NODE *node)
|
|||
|
||||
int ruby_in_eval;
|
||||
|
||||
static void rb_thread_cleanup _((void));
|
||||
static void rb_thread_wait_other_threads _((void));
|
||||
static void rb_thread_cleanup(void);
|
||||
static void rb_thread_wait_other_threads(void);
|
||||
|
||||
static int thread_set_raised(void);
|
||||
static int thread_reset_raised(void);
|
||||
|
@ -1440,7 +1440,7 @@ ruby_options(int argc, char **argv)
|
|||
POP_THREAD_TAG();
|
||||
}
|
||||
|
||||
void rb_exec_end_proc _((void));
|
||||
void rb_exec_end_proc(void);
|
||||
|
||||
static void
|
||||
ruby_finalize_0(void)
|
||||
|
@ -1679,7 +1679,7 @@ localjump_reason(VALUE exc)
|
|||
return rb_iv_get(exc, "@reason");
|
||||
}
|
||||
|
||||
NORETURN(static void jump_tag_but_local_jump _((int,VALUE)));
|
||||
NORETURN(static void jump_tag_but_local_jump(int,VALUE));
|
||||
static void
|
||||
jump_tag_but_local_jump(int state, VALUE val)
|
||||
{
|
||||
|
@ -2163,7 +2163,7 @@ copy_node_scope(NODE *node, NODE *rval)
|
|||
|
||||
#define MATCH_DATA *rb_svar(node->nd_cnt)
|
||||
|
||||
static const char* is_defined _((VALUE, NODE*, char*, int));
|
||||
static const char* is_defined(VALUE, NODE*, char*, int);
|
||||
|
||||
static char*
|
||||
arg_defined(VALUE self, NODE *node, char *buf, char *type)
|
||||
|
@ -2366,7 +2366,7 @@ is_defined(VALUE self, NODE *node /* OK */, char *buf, int noeval)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int handle_rescue _((VALUE,NODE*));
|
||||
static int handle_rescue(VALUE,NODE*);
|
||||
|
||||
static void blk_free(struct BLOCK *data);
|
||||
|
||||
|
@ -2686,9 +2686,9 @@ class_prefix(VALUE self, NODE *cpath)
|
|||
}\
|
||||
} while (0)
|
||||
|
||||
NORETURN(static void return_jump _((VALUE)));
|
||||
NORETURN(static void break_jump _((VALUE)));
|
||||
NORETURN(static void unknown_node _((NODE * volatile)));
|
||||
NORETURN(static void return_jump(VALUE));
|
||||
NORETURN(static void break_jump(VALUE));
|
||||
NORETURN(static void unknown_node(NODE * volatile));
|
||||
|
||||
static void
|
||||
unknown_node(NODE *volatile node)
|
||||
|
@ -4202,7 +4202,7 @@ rb_mod_protected_method_defined(VALUE mod, VALUE mid)
|
|||
return Qfalse;
|
||||
}
|
||||
|
||||
NORETURN(static VALUE terminate_process _((int, VALUE)));
|
||||
NORETURN(static VALUE terminate_process(int, VALUE));
|
||||
static VALUE
|
||||
terminate_process(int status, VALUE mesg)
|
||||
{
|
||||
|
@ -4331,8 +4331,8 @@ rb_iter_break(void)
|
|||
break_jump(Qnil);
|
||||
}
|
||||
|
||||
NORETURN(static void rb_longjmp _((int, VALUE)));
|
||||
static VALUE make_backtrace _((void));
|
||||
NORETURN(static void rb_longjmp(int, VALUE));
|
||||
static VALUE make_backtrace(void);
|
||||
|
||||
static void
|
||||
rb_longjmp(int tag, VALUE mesg)
|
||||
|
@ -4631,8 +4631,8 @@ break_jump(VALUE retval)
|
|||
localjump_error("unexpected break", retval, TAG_BREAK);
|
||||
}
|
||||
|
||||
static VALUE bmcall _((VALUE, VALUE));
|
||||
static int method_arity _((VALUE));
|
||||
static VALUE bmcall(VALUE, VALUE);
|
||||
static int method_arity(VALUE);
|
||||
|
||||
void
|
||||
rb_need_block(void)
|
||||
|
@ -6453,7 +6453,7 @@ rb_mod_module_eval(int argc, VALUE *argv, VALUE mod)
|
|||
|
||||
VALUE rb_load_path;
|
||||
|
||||
NORETURN(static void load_failed _((VALUE)));
|
||||
NORETURN(static void load_failed(VALUE));
|
||||
|
||||
void
|
||||
rb_load(VALUE fname, int wrap)
|
||||
|
@ -6649,7 +6649,7 @@ static const char *const loadable_ext[] = {
|
|||
0
|
||||
};
|
||||
|
||||
static int search_required _((VALUE, VALUE *));
|
||||
static int search_required(VALUE, VALUE *);
|
||||
|
||||
int
|
||||
rb_provided(const char *feature)
|
||||
|
@ -7368,8 +7368,8 @@ rb_f_local_variables(void)
|
|||
return ary;
|
||||
}
|
||||
|
||||
static VALUE rb_f_catch _((VALUE,VALUE));
|
||||
NORETURN(static VALUE rb_f_throw _((int,VALUE*)));
|
||||
static VALUE rb_f_catch(VALUE,VALUE);
|
||||
NORETURN(static VALUE rb_f_throw(int,VALUE*));
|
||||
|
||||
struct end_proc_data {
|
||||
void (*func)();
|
||||
|
@ -9750,7 +9750,7 @@ thread_reset_raised(void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static void rb_thread_ready _((rb_thread_t));
|
||||
static void rb_thread_ready(rb_thread_t);
|
||||
|
||||
static VALUE
|
||||
run_trap_eval(VALUE arg)
|
||||
|
@ -9964,7 +9964,7 @@ rb_thread_check(VALUE data)
|
|||
return (rb_thread_t)RDATA(data)->data;
|
||||
}
|
||||
|
||||
static VALUE rb_thread_raise _((int, VALUE*, rb_thread_t));
|
||||
static VALUE rb_thread_raise(int, VALUE*, rb_thread_t);
|
||||
|
||||
static VALUE th_raise_exception;
|
||||
static NODE *th_raise_node;
|
||||
|
@ -10096,8 +10096,8 @@ rb_thread_switch(int n)
|
|||
(rb_thread_save_context(th),\
|
||||
rb_thread_switch((FLUSH_REGISTER_WINDOWS, ruby_setjmp((th)->context))))
|
||||
|
||||
NORETURN(static void rb_thread_restore_context _((rb_thread_t,int)));
|
||||
NOINLINE(static void stack_extend _((rb_thread_t, int)));
|
||||
NORETURN(static void rb_thread_restore_context(rb_thread_t,int));
|
||||
NOINLINE(static void stack_extend(rb_thread_t, int));
|
||||
|
||||
static void
|
||||
stack_extend(rb_thread_t th, int exit)
|
||||
|
@ -10237,7 +10237,7 @@ rb_thread_fd_close(int fd)
|
|||
END_FOREACH(th);
|
||||
}
|
||||
|
||||
NORETURN(static void rb_thread_main_jump _((VALUE, int)));
|
||||
NORETURN(static void rb_thread_main_jump(VALUE, int));
|
||||
static void
|
||||
rb_thread_main_jump(VALUE err, int tag)
|
||||
{
|
||||
|
@ -10247,7 +10247,7 @@ rb_thread_main_jump(VALUE err, int tag)
|
|||
rb_thread_restore_context(main_thread, tag);
|
||||
}
|
||||
|
||||
NORETURN(static void rb_thread_deadlock _((void)));
|
||||
NORETURN(static void rb_thread_deadlock(void));
|
||||
static void
|
||||
rb_thread_deadlock(void)
|
||||
{
|
||||
|
@ -10677,7 +10677,7 @@ rb_thread_wait_for(struct timeval time)
|
|||
rb_thread_schedule();
|
||||
}
|
||||
|
||||
void rb_thread_sleep_forever _((void));
|
||||
void rb_thread_sleep_forever(void);
|
||||
|
||||
int
|
||||
rb_thread_alone(void)
|
||||
|
@ -11526,8 +11526,8 @@ rb_thread_stop_timer()
|
|||
int rb_thread_tick = THREAD_TICK;
|
||||
#endif
|
||||
|
||||
NORETURN(static void rb_thread_terminated _((rb_thread_t, int, enum thread_status)));
|
||||
static VALUE rb_thread_yield _((VALUE, rb_thread_t));
|
||||
NORETURN(static void rb_thread_terminated(rb_thread_t, int, enum thread_status));
|
||||
static VALUE rb_thread_yield(VALUE, rb_thread_t);
|
||||
|
||||
static void
|
||||
push_thread_anchor(struct ruby_env *ip)
|
||||
|
|
12
file.c
12
file.c
|
@ -29,7 +29,7 @@
|
|||
#ifdef HAVE_SYS_FILE_H
|
||||
# include <sys/file.h>
|
||||
#else
|
||||
int flock _((int, int));
|
||||
int flock(int, int);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SYS_PARAM_H
|
||||
|
@ -41,7 +41,7 @@ int flock _((int, int));
|
|||
|
||||
#include <time.h>
|
||||
|
||||
VALUE rb_time_new _((time_t, time_t));
|
||||
VALUE rb_time_new(time_t, time_t);
|
||||
|
||||
#ifdef HAVE_UTIME_H
|
||||
#include <utime.h>
|
||||
|
@ -54,7 +54,7 @@ VALUE rb_time_new _((time_t, time_t));
|
|||
#endif
|
||||
|
||||
#ifndef HAVE_STRING_H
|
||||
char *strrchr _((const char*,const char));
|
||||
char *strrchr(const char*,const char);
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
|
@ -1889,7 +1889,7 @@ rb_file_s_utime(int argc, VALUE *argv)
|
|||
|
||||
#endif
|
||||
|
||||
NORETURN(static void sys_fail2 _((VALUE,VALUE)));
|
||||
NORETURN(static void sys_fail2(VALUE,VALUE));
|
||||
static void
|
||||
sys_fail2(VALUE s1, VALUE s2)
|
||||
{
|
||||
|
@ -2262,7 +2262,7 @@ rb_path_end(const char *path)
|
|||
#define TOLOWER(c) (ISUPPER(c) ? tolower(c) : (c))
|
||||
#endif
|
||||
|
||||
static int is_absolute_path _((const char*));
|
||||
static int is_absolute_path(const char*);
|
||||
|
||||
static VALUE
|
||||
file_expand_path(VALUE fname, VALUE dname, VALUE result)
|
||||
|
@ -2690,7 +2690,7 @@ rb_file_s_split(VALUE klass, VALUE path)
|
|||
|
||||
static VALUE separator;
|
||||
|
||||
static VALUE rb_file_join _((VALUE ary, VALUE sep));
|
||||
static VALUE rb_file_join(VALUE ary, VALUE sep);
|
||||
|
||||
static VALUE
|
||||
file_inspect_join(VALUE ary, VALUE *arg, int recur)
|
||||
|
|
10
gc.c
10
gc.c
|
@ -52,7 +52,7 @@ extern unsigned long __libc_ia64_register_backing_store_base;
|
|||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int rb_io_fptr_finalize _((struct OpenFile*));
|
||||
int rb_io_fptr_finalize(struct OpenFile*);
|
||||
|
||||
#if !defined(setjmp) && defined(HAVE__SETJMP)
|
||||
#define setjmp(env) _setjmp(env)
|
||||
|
@ -417,7 +417,7 @@ static unsigned int STACK_LEVEL_MAX = 655300;
|
|||
# define STACK_LEVEL_MAX 655300
|
||||
#endif
|
||||
|
||||
NOINLINE(static void set_stack_end _((VALUE **stack_end_p)));
|
||||
NOINLINE(static void set_stack_end(VALUE **stack_end_p));
|
||||
|
||||
static void
|
||||
set_stack_end(VALUE **stack_end_p)
|
||||
|
@ -534,8 +534,8 @@ sweep_source_filename(char *key, char *value)
|
|||
}
|
||||
}
|
||||
|
||||
static void gc_mark _((VALUE ptr, int lev));
|
||||
static void gc_mark_children _((VALUE ptr, int lev));
|
||||
static void gc_mark(VALUE ptr, int lev);
|
||||
static void gc_mark_children(VALUE ptr, int lev);
|
||||
|
||||
static void
|
||||
gc_mark_all(void)
|
||||
|
@ -952,7 +952,7 @@ gc_mark_children(VALUE ptr, int lev)
|
|||
}
|
||||
}
|
||||
|
||||
static void obj_free _((VALUE));
|
||||
static void obj_free(VALUE);
|
||||
|
||||
static void
|
||||
finalize_list(RVALUE *p)
|
||||
|
|
2
hash.c
2
hash.c
|
@ -196,7 +196,7 @@ rb_hash_foreach(VALUE hash, int (*func) (/* ??? */), VALUE farg)
|
|||
rb_ensure(hash_foreach_call, (VALUE)&arg, hash_foreach_ensure, hash);
|
||||
}
|
||||
|
||||
static VALUE hash_alloc _((VALUE));
|
||||
static VALUE hash_alloc(VALUE);
|
||||
|
||||
static VALUE
|
||||
hash_alloc(VALUE klass)
|
||||
|
|
68
inits.c
68
inits.c
|
@ -12,40 +12,40 @@
|
|||
|
||||
#include "ruby.h"
|
||||
|
||||
void Init_Array _((void));
|
||||
void Init_Bignum _((void));
|
||||
void Init_Binding _((void));
|
||||
void Init_Comparable _((void));
|
||||
void Init_Dir _((void));
|
||||
void Init_Enumerable _((void));
|
||||
void Init_Enumerator _((void));
|
||||
void Init_Exception _((void));
|
||||
void Init_syserr _((void));
|
||||
void Init_eval _((void));
|
||||
void Init_load _((void));
|
||||
void Init_Proc _((void));
|
||||
void Init_Thread _((void));
|
||||
void Init_File _((void));
|
||||
void Init_GC _((void));
|
||||
void Init_Hash _((void));
|
||||
void Init_IO _((void));
|
||||
void Init_Math _((void));
|
||||
void Init_marshal _((void));
|
||||
void Init_Numeric _((void));
|
||||
void Init_Object _((void));
|
||||
void Init_pack _((void));
|
||||
void Init_Precision _((void));
|
||||
void Init_sym _((void));
|
||||
void Init_process _((void));
|
||||
void Init_Random _((void));
|
||||
void Init_Range _((void));
|
||||
void Init_Regexp _((void));
|
||||
void Init_signal _((void));
|
||||
void Init_String _((void));
|
||||
void Init_Struct _((void));
|
||||
void Init_Time _((void));
|
||||
void Init_var_tables _((void));
|
||||
void Init_version _((void));
|
||||
void Init_Array(void);
|
||||
void Init_Bignum(void);
|
||||
void Init_Binding(void);
|
||||
void Init_Comparable(void);
|
||||
void Init_Dir(void);
|
||||
void Init_Enumerable(void);
|
||||
void Init_Enumerator(void);
|
||||
void Init_Exception(void);
|
||||
void Init_syserr(void);
|
||||
void Init_eval(void);
|
||||
void Init_load(void);
|
||||
void Init_Proc(void);
|
||||
void Init_Thread(void);
|
||||
void Init_File(void);
|
||||
void Init_GC(void);
|
||||
void Init_Hash(void);
|
||||
void Init_IO(void);
|
||||
void Init_Math(void);
|
||||
void Init_marshal(void);
|
||||
void Init_Numeric(void);
|
||||
void Init_Object(void);
|
||||
void Init_pack(void);
|
||||
void Init_Precision(void);
|
||||
void Init_sym(void);
|
||||
void Init_process(void);
|
||||
void Init_Random(void);
|
||||
void Init_Range(void);
|
||||
void Init_Regexp(void);
|
||||
void Init_signal(void);
|
||||
void Init_String(void);
|
||||
void Init_Struct(void);
|
||||
void Init_Time(void);
|
||||
void Init_var_tables(void);
|
||||
void Init_version(void);
|
||||
|
||||
void
|
||||
rb_call_inits(void)
|
||||
|
|
916
intern.h
916
intern.h
|
@ -29,120 +29,120 @@
|
|||
#define ID_ALLOCATOR 1
|
||||
|
||||
/* array.c */
|
||||
void rb_mem_clear _((register VALUE*, register long));
|
||||
VALUE rb_assoc_new _((VALUE, VALUE));
|
||||
VALUE rb_check_array_type _((VALUE));
|
||||
VALUE rb_ary_new _((void));
|
||||
VALUE rb_ary_new2 _((long));
|
||||
VALUE rb_ary_new3 __((long,...));
|
||||
VALUE rb_ary_new4 _((long, const VALUE *));
|
||||
VALUE rb_values_new __((long,...));
|
||||
VALUE rb_values_new2 _((long, const VALUE *));
|
||||
VALUE rb_values_from_ary _((VALUE));
|
||||
VALUE rb_ary_from_values _((VALUE));
|
||||
VALUE rb_ary_freeze _((VALUE));
|
||||
VALUE rb_ary_aref _((int, VALUE*, VALUE));
|
||||
void rb_ary_store _((VALUE, long, VALUE));
|
||||
VALUE rb_ary_dup _((VALUE));
|
||||
VALUE rb_ary_to_ary _((VALUE));
|
||||
VALUE rb_ary_to_s _((VALUE));
|
||||
VALUE rb_ary_push _((VALUE, VALUE));
|
||||
VALUE rb_ary_pop _((VALUE));
|
||||
VALUE rb_ary_shift _((VALUE));
|
||||
VALUE rb_ary_unshift _((VALUE, VALUE));
|
||||
VALUE rb_ary_entry _((VALUE, long));
|
||||
VALUE rb_ary_each _((VALUE));
|
||||
VALUE rb_ary_join _((VALUE, VALUE));
|
||||
VALUE rb_ary_print_on _((VALUE, VALUE));
|
||||
VALUE rb_ary_reverse _((VALUE));
|
||||
VALUE rb_ary_sort _((VALUE));
|
||||
VALUE rb_ary_sort_bang _((VALUE));
|
||||
VALUE rb_ary_delete _((VALUE, VALUE));
|
||||
VALUE rb_ary_delete_at _((VALUE, long));
|
||||
VALUE rb_ary_clear _((VALUE));
|
||||
VALUE rb_ary_plus _((VALUE, VALUE));
|
||||
VALUE rb_ary_concat _((VALUE, VALUE));
|
||||
VALUE rb_ary_assoc _((VALUE, VALUE));
|
||||
VALUE rb_ary_rassoc _((VALUE, VALUE));
|
||||
VALUE rb_ary_includes _((VALUE, VALUE));
|
||||
VALUE rb_ary_cmp _((VALUE, VALUE));
|
||||
VALUE rb_check_array_value _((VALUE));
|
||||
VALUE rb_get_values_at _((VALUE, long, int, VALUE*, VALUE(*) _((VALUE,long))));
|
||||
void rb_mem_clear(register VALUE*, register long);
|
||||
VALUE rb_assoc_new(VALUE, VALUE);
|
||||
VALUE rb_check_array_type(VALUE);
|
||||
VALUE rb_ary_new(void);
|
||||
VALUE rb_ary_new2(long);
|
||||
VALUE rb_ary_new3(long,...);
|
||||
VALUE rb_ary_new4(long, const VALUE *);
|
||||
VALUE rb_values_new(long,...);
|
||||
VALUE rb_values_new2(long, const VALUE *);
|
||||
VALUE rb_values_from_ary(VALUE);
|
||||
VALUE rb_ary_from_values(VALUE);
|
||||
VALUE rb_ary_freeze(VALUE);
|
||||
VALUE rb_ary_aref(int, VALUE*, VALUE);
|
||||
void rb_ary_store(VALUE, long, VALUE);
|
||||
VALUE rb_ary_dup(VALUE);
|
||||
VALUE rb_ary_to_ary(VALUE);
|
||||
VALUE rb_ary_to_s(VALUE);
|
||||
VALUE rb_ary_push(VALUE, VALUE);
|
||||
VALUE rb_ary_pop(VALUE);
|
||||
VALUE rb_ary_shift(VALUE);
|
||||
VALUE rb_ary_unshift(VALUE, VALUE);
|
||||
VALUE rb_ary_entry(VALUE, long);
|
||||
VALUE rb_ary_each(VALUE);
|
||||
VALUE rb_ary_join(VALUE, VALUE);
|
||||
VALUE rb_ary_print_on(VALUE, VALUE);
|
||||
VALUE rb_ary_reverse(VALUE);
|
||||
VALUE rb_ary_sort(VALUE);
|
||||
VALUE rb_ary_sort_bang(VALUE);
|
||||
VALUE rb_ary_delete(VALUE, VALUE);
|
||||
VALUE rb_ary_delete_at(VALUE, long);
|
||||
VALUE rb_ary_clear(VALUE);
|
||||
VALUE rb_ary_plus(VALUE, VALUE);
|
||||
VALUE rb_ary_concat(VALUE, VALUE);
|
||||
VALUE rb_ary_assoc(VALUE, VALUE);
|
||||
VALUE rb_ary_rassoc(VALUE, VALUE);
|
||||
VALUE rb_ary_includes(VALUE, VALUE);
|
||||
VALUE rb_ary_cmp(VALUE, VALUE);
|
||||
VALUE rb_check_array_value(VALUE);
|
||||
VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long));
|
||||
/* bignum.c */
|
||||
VALUE rb_big_clone _((VALUE));
|
||||
void rb_big_2comp _((VALUE));
|
||||
VALUE rb_big_norm _((VALUE));
|
||||
VALUE rb_uint2big _((unsigned long));
|
||||
VALUE rb_int2big _((long));
|
||||
VALUE rb_uint2inum _((unsigned long));
|
||||
VALUE rb_int2inum _((long));
|
||||
VALUE rb_cstr_to_inum _((const char*, int, int));
|
||||
VALUE rb_str_to_inum _((VALUE, int, int));
|
||||
VALUE rb_cstr2inum _((const char*, int));
|
||||
VALUE rb_str2inum _((VALUE, int));
|
||||
VALUE rb_big2str _((VALUE, int));
|
||||
long rb_big2long _((VALUE));
|
||||
VALUE rb_big_clone(VALUE);
|
||||
void rb_big_2comp(VALUE);
|
||||
VALUE rb_big_norm(VALUE);
|
||||
VALUE rb_uint2big(unsigned long);
|
||||
VALUE rb_int2big(long);
|
||||
VALUE rb_uint2inum(unsigned long);
|
||||
VALUE rb_int2inum(long);
|
||||
VALUE rb_cstr_to_inum(const char*, int, int);
|
||||
VALUE rb_str_to_inum(VALUE, int, int);
|
||||
VALUE rb_cstr2inum(const char*, int);
|
||||
VALUE rb_str2inum(VALUE, int);
|
||||
VALUE rb_big2str(VALUE, int);
|
||||
long rb_big2long(VALUE);
|
||||
#define rb_big2int(x) rb_big2long(x)
|
||||
unsigned long rb_big2ulong _((VALUE));
|
||||
unsigned long rb_big2ulong(VALUE);
|
||||
#define rb_big2uint(x) rb_big2ulong(x)
|
||||
#if HAVE_LONG_LONG
|
||||
VALUE rb_ll2inum _((LONG_LONG));
|
||||
VALUE rb_ull2inum _((unsigned LONG_LONG));
|
||||
LONG_LONG rb_big2ll _((VALUE));
|
||||
unsigned LONG_LONG rb_big2ull _((VALUE));
|
||||
VALUE rb_ll2inum(LONG_LONG);
|
||||
VALUE rb_ull2inum(unsigned LONG_LONG);
|
||||
LONG_LONG rb_big2ll(VALUE);
|
||||
unsigned LONG_LONG rb_big2ull(VALUE);
|
||||
#endif /* HAVE_LONG_LONG */
|
||||
void rb_quad_pack _((char*,VALUE));
|
||||
VALUE rb_quad_unpack _((const char*,int));
|
||||
VALUE rb_dbl2big _((double));
|
||||
double rb_big2dbl _((VALUE));
|
||||
VALUE rb_big_cmp _((VALUE, VALUE));
|
||||
VALUE rb_big_eq _((VALUE, VALUE));
|
||||
VALUE rb_big_plus _((VALUE, VALUE));
|
||||
VALUE rb_big_minus _((VALUE, VALUE));
|
||||
VALUE rb_big_mul _((VALUE, VALUE));
|
||||
VALUE rb_big_div _((VALUE, VALUE));
|
||||
VALUE rb_big_modulo _((VALUE, VALUE));
|
||||
VALUE rb_big_divmod _((VALUE, VALUE));
|
||||
VALUE rb_big_pow _((VALUE, VALUE));
|
||||
VALUE rb_big_and _((VALUE, VALUE));
|
||||
VALUE rb_big_or _((VALUE, VALUE));
|
||||
VALUE rb_big_xor _((VALUE, VALUE));
|
||||
VALUE rb_big_lshift _((VALUE, VALUE));
|
||||
VALUE rb_big_rand _((VALUE, double*));
|
||||
void rb_quad_pack(char*,VALUE);
|
||||
VALUE rb_quad_unpack(const char*,int);
|
||||
VALUE rb_dbl2big(double);
|
||||
double rb_big2dbl(VALUE);
|
||||
VALUE rb_big_cmp(VALUE, VALUE);
|
||||
VALUE rb_big_eq(VALUE, VALUE);
|
||||
VALUE rb_big_plus(VALUE, VALUE);
|
||||
VALUE rb_big_minus(VALUE, VALUE);
|
||||
VALUE rb_big_mul(VALUE, VALUE);
|
||||
VALUE rb_big_div(VALUE, VALUE);
|
||||
VALUE rb_big_modulo(VALUE, VALUE);
|
||||
VALUE rb_big_divmod(VALUE, VALUE);
|
||||
VALUE rb_big_pow(VALUE, VALUE);
|
||||
VALUE rb_big_and(VALUE, VALUE);
|
||||
VALUE rb_big_or(VALUE, VALUE);
|
||||
VALUE rb_big_xor(VALUE, VALUE);
|
||||
VALUE rb_big_lshift(VALUE, VALUE);
|
||||
VALUE rb_big_rand(VALUE, double*);
|
||||
/* class.c */
|
||||
VALUE rb_class_boot _((VALUE));
|
||||
VALUE rb_class_new _((VALUE));
|
||||
VALUE rb_mod_init_copy _((VALUE, VALUE));
|
||||
VALUE rb_class_init_copy _((VALUE, VALUE));
|
||||
VALUE rb_singleton_class_clone _((VALUE));
|
||||
void rb_singleton_class_attached _((VALUE,VALUE));
|
||||
VALUE rb_make_metaclass _((VALUE, VALUE));
|
||||
void rb_check_inheritable _((VALUE));
|
||||
VALUE rb_class_inherited _((VALUE, VALUE));
|
||||
VALUE rb_define_class_id _((ID, VALUE));
|
||||
VALUE rb_module_new _((void));
|
||||
VALUE rb_define_module_id _((ID));
|
||||
VALUE rb_mod_included_modules _((VALUE));
|
||||
VALUE rb_mod_include_p _((VALUE, VALUE));
|
||||
VALUE rb_mod_ancestors _((VALUE));
|
||||
VALUE rb_class_instance_methods _((int, VALUE*, VALUE));
|
||||
VALUE rb_class_public_instance_methods _((int, VALUE*, VALUE));
|
||||
VALUE rb_class_protected_instance_methods _((int, VALUE*, VALUE));
|
||||
VALUE rb_class_private_instance_methods _((int, VALUE*, VALUE));
|
||||
VALUE rb_obj_singleton_methods _((int, VALUE*, VALUE));
|
||||
void rb_define_method_id _((VALUE, ID, VALUE (*)(ANYARGS), int));
|
||||
void rb_frozen_class_p _((VALUE));
|
||||
void rb_undef _((VALUE, ID));
|
||||
void rb_define_protected_method _((VALUE, const char*, VALUE (*)(ANYARGS), int));
|
||||
void rb_define_private_method _((VALUE, const char*, VALUE (*)(ANYARGS), int));
|
||||
void rb_define_singleton_method _((VALUE, const char*, VALUE(*)(ANYARGS), int));
|
||||
VALUE rb_singleton_class _((VALUE));
|
||||
VALUE rb_class_boot(VALUE);
|
||||
VALUE rb_class_new(VALUE);
|
||||
VALUE rb_mod_init_copy(VALUE, VALUE);
|
||||
VALUE rb_class_init_copy(VALUE, VALUE);
|
||||
VALUE rb_singleton_class_clone(VALUE);
|
||||
void rb_singleton_class_attached(VALUE,VALUE);
|
||||
VALUE rb_make_metaclass(VALUE, VALUE);
|
||||
void rb_check_inheritable(VALUE);
|
||||
VALUE rb_class_inherited(VALUE, VALUE);
|
||||
VALUE rb_define_class_id(ID, VALUE);
|
||||
VALUE rb_module_new(void);
|
||||
VALUE rb_define_module_id(ID);
|
||||
VALUE rb_mod_included_modules(VALUE);
|
||||
VALUE rb_mod_include_p(VALUE, VALUE);
|
||||
VALUE rb_mod_ancestors(VALUE);
|
||||
VALUE rb_class_instance_methods(int, VALUE*, VALUE);
|
||||
VALUE rb_class_public_instance_methods(int, VALUE*, VALUE);
|
||||
VALUE rb_class_protected_instance_methods(int, VALUE*, VALUE);
|
||||
VALUE rb_class_private_instance_methods(int, VALUE*, VALUE);
|
||||
VALUE rb_obj_singleton_methods(int, VALUE*, VALUE);
|
||||
void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);
|
||||
void rb_frozen_class_p(VALUE);
|
||||
void rb_undef(VALUE, ID);
|
||||
void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
|
||||
void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
|
||||
void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
|
||||
VALUE rb_singleton_class(VALUE);
|
||||
/* compar.c */
|
||||
int rb_cmpint _((VALUE, VALUE, VALUE));
|
||||
NORETURN(void rb_cmperr _((VALUE, VALUE)));
|
||||
int rb_cmpint(VALUE, VALUE, VALUE);
|
||||
NORETURN(void rb_cmperr(VALUE, VALUE));
|
||||
/* enum.c */
|
||||
/* enumerator.c */
|
||||
VALUE rb_enumeratorize _((VALUE, VALUE, int, VALUE *));
|
||||
VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *);
|
||||
#define RETURN_ENUMERATOR(obj, argc, argv) do { \
|
||||
if (!rb_block_given_p()) \
|
||||
return rb_enumeratorize(obj, ID2SYM(rb_frame_this_func()), \
|
||||
|
@ -150,17 +150,17 @@ VALUE rb_enumeratorize _((VALUE, VALUE, int, VALUE *));
|
|||
} while (0)
|
||||
/* error.c */
|
||||
RUBY_EXTERN int ruby_nerrs;
|
||||
VALUE rb_exc_new _((VALUE, const char*, long));
|
||||
VALUE rb_exc_new2 _((VALUE, const char*));
|
||||
VALUE rb_exc_new3 _((VALUE, VALUE));
|
||||
PRINTF_ARGS(NORETURN(void rb_loaderror __((const char*, ...))), 1, 2);
|
||||
PRINTF_ARGS(NORETURN(void rb_name_error __((ID, const char*, ...))), 2, 3);
|
||||
NORETURN(void rb_invalid_str _((const char*, const char*)));
|
||||
PRINTF_ARGS(void rb_compile_error __((const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(void rb_compile_error_append __((const char*, ...)), 1, 2);
|
||||
NORETURN(void rb_load_fail _((const char*)));
|
||||
NORETURN(void rb_error_frozen _((const char*)));
|
||||
void rb_check_frozen _((VALUE));
|
||||
VALUE rb_exc_new(VALUE, const char*, long);
|
||||
VALUE rb_exc_new2(VALUE, const char*);
|
||||
VALUE rb_exc_new3(VALUE, VALUE);
|
||||
PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);
|
||||
NORETURN(void rb_invalid_str(const char*, const char*));
|
||||
PRINTF_ARGS(void rb_compile_error(const char*, ...), 1, 2);
|
||||
PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2);
|
||||
NORETURN(void rb_load_fail(const char*));
|
||||
NORETURN(void rb_error_frozen(const char*));
|
||||
void rb_check_frozen(VALUE);
|
||||
/* eval.c */
|
||||
#ifdef NFDBITS
|
||||
typedef struct {
|
||||
|
@ -170,14 +170,14 @@ typedef struct {
|
|||
|
||||
#define HAVE_RB_FD_INIT 1
|
||||
|
||||
void rb_fd_init _((volatile rb_fdset_t *));
|
||||
void rb_fd_term _((rb_fdset_t *));
|
||||
void rb_fd_zero _((rb_fdset_t *));
|
||||
void rb_fd_set _((int, rb_fdset_t *));
|
||||
void rb_fd_clr _((int, rb_fdset_t *));
|
||||
int rb_fd_isset _((int, const rb_fdset_t *));
|
||||
void rb_fd_copy _((rb_fdset_t *, const fd_set *, int));
|
||||
int rb_fd_select _((int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *));
|
||||
void rb_fd_init(volatile rb_fdset_t *);
|
||||
void rb_fd_term(rb_fdset_t *);
|
||||
void rb_fd_zero(rb_fdset_t *);
|
||||
void rb_fd_set(int, rb_fdset_t *);
|
||||
void rb_fd_clr(int, rb_fdset_t *);
|
||||
int rb_fd_isset(int, const rb_fdset_t *);
|
||||
void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
|
||||
int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
|
||||
|
||||
#define rb_fd_ptr(f) ((f)->fdset)
|
||||
#define rb_fd_max(f) ((f)->maxfd)
|
||||
|
@ -199,132 +199,132 @@ typedef fd_set rb_fdset_t;
|
|||
#endif
|
||||
|
||||
RUBY_EXTERN struct RNode *ruby_current_node;
|
||||
void ruby_set_current_source _((void));
|
||||
NORETURN(void rb_exc_raise _((VALUE)));
|
||||
NORETURN(void rb_exc_fatal _((VALUE)));
|
||||
VALUE rb_f_exit _((int,VALUE*));
|
||||
VALUE rb_f_abort _((int,VALUE*));
|
||||
void rb_remove_method _((VALUE, const char*));
|
||||
void ruby_set_current_source(void);
|
||||
NORETURN(void rb_exc_raise(VALUE));
|
||||
NORETURN(void rb_exc_fatal(VALUE));
|
||||
VALUE rb_f_exit(int,VALUE*);
|
||||
VALUE rb_f_abort(int,VALUE*);
|
||||
void rb_remove_method(VALUE, const char*);
|
||||
#define rb_disable_super(klass, name) ((void)0)
|
||||
#define rb_enable_super(klass, name) ((void)0)
|
||||
#define HAVE_RB_DEFINE_ALLOC_FUNC 1
|
||||
void rb_define_alloc_func _((VALUE, VALUE (*)(VALUE)));
|
||||
void rb_undef_alloc_func _((VALUE));
|
||||
void rb_clear_cache _((void));
|
||||
void rb_clear_cache_by_class _((VALUE));
|
||||
void rb_alias _((VALUE, ID, ID));
|
||||
void rb_attr _((VALUE,ID,int,int,int));
|
||||
int rb_method_boundp _((VALUE, ID, int));
|
||||
VALUE rb_dvar_defined _((ID));
|
||||
VALUE rb_dvar_curr _((ID));
|
||||
VALUE rb_dvar_ref _((ID));
|
||||
void rb_dvar_asgn _((ID, VALUE));
|
||||
void rb_dvar_push _((ID, VALUE));
|
||||
VALUE *rb_svar _((int));
|
||||
VALUE rb_eval_cmd _((VALUE, VALUE, int));
|
||||
int rb_respond_to _((VALUE, ID));
|
||||
void rb_interrupt _((void));
|
||||
VALUE rb_apply _((VALUE, ID, VALUE));
|
||||
void rb_backtrace _((void));
|
||||
ID rb_frame_this_func _((void));
|
||||
VALUE rb_obj_instance_eval _((int, VALUE*, VALUE));
|
||||
VALUE rb_mod_module_eval _((int, VALUE*, VALUE));
|
||||
void rb_load _((VALUE, int));
|
||||
void rb_load_protect _((VALUE, int, int*));
|
||||
NORETURN(void rb_jump_tag _((int)));
|
||||
int rb_provided _((const char*));
|
||||
void rb_provide _((const char*));
|
||||
VALUE rb_f_require _((VALUE, VALUE));
|
||||
VALUE rb_require_safe _((VALUE, int));
|
||||
void rb_obj_call_init _((VALUE, int, VALUE*));
|
||||
VALUE rb_class_new_instance _((int, VALUE*, VALUE));
|
||||
VALUE rb_block_proc _((void));
|
||||
VALUE rb_f_lambda _((void));
|
||||
VALUE rb_proc_new _((VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE));
|
||||
VALUE rb_proc_call _((VALUE, VALUE));
|
||||
int rb_proc_arity _((VALUE));
|
||||
VALUE rb_obj_method _((VALUE, VALUE));
|
||||
VALUE rb_method_call _((int, VALUE*, VALUE));
|
||||
int rb_mod_method_arity _((VALUE, ID));
|
||||
int rb_obj_method_arity _((VALUE, ID));
|
||||
VALUE rb_protect _((VALUE (*)(VALUE), VALUE, int*));
|
||||
void rb_set_end_proc _((void (*)(VALUE), VALUE));
|
||||
void rb_mark_end_proc _((void));
|
||||
void rb_exec_end_proc _((void));
|
||||
void ruby_finalize _((void));
|
||||
NORETURN(void ruby_stop _((int)));
|
||||
int ruby_cleanup _((int));
|
||||
int ruby_exec _((void));
|
||||
void rb_gc_mark_threads _((void));
|
||||
void rb_thread_start_timer _((void));
|
||||
void rb_thread_stop_timer _((void));
|
||||
void rb_thread_schedule _((void));
|
||||
void rb_thread_wait_fd _((int));
|
||||
int rb_thread_fd_writable _((int));
|
||||
void rb_thread_fd_close _((int));
|
||||
int rb_thread_alone _((void));
|
||||
void rb_thread_polling _((void));
|
||||
void rb_thread_sleep _((int));
|
||||
void rb_thread_sleep_forever _((void));
|
||||
VALUE rb_thread_stop _((void));
|
||||
VALUE rb_thread_wakeup _((VALUE));
|
||||
VALUE rb_thread_run _((VALUE));
|
||||
VALUE rb_thread_kill _((VALUE));
|
||||
VALUE rb_thread_create _((VALUE (*)(ANYARGS), void*));
|
||||
void rb_thread_interrupt _((void));
|
||||
void rb_thread_trap_eval _((VALUE, int, int));
|
||||
void rb_thread_signal_raise _((char*));
|
||||
void rb_thread_signal_exit _((void));
|
||||
int rb_thread_select _((int, fd_set *, fd_set *, fd_set *, struct timeval *));
|
||||
void rb_thread_wait_for _((struct timeval));
|
||||
VALUE rb_thread_current _((void));
|
||||
VALUE rb_thread_main _((void));
|
||||
VALUE rb_thread_local_aref _((VALUE, ID));
|
||||
VALUE rb_thread_local_aset _((VALUE, ID, VALUE));
|
||||
void rb_thread_atfork _((void));
|
||||
VALUE rb_exec_recursive _((VALUE(*)(ANYARGS),VALUE,VALUE));
|
||||
void rb_define_alloc_func(VALUE, VALUE (*)(VALUE));
|
||||
void rb_undef_alloc_func(VALUE);
|
||||
void rb_clear_cache(void);
|
||||
void rb_clear_cache_by_class(VALUE);
|
||||
void rb_alias(VALUE, ID, ID);
|
||||
void rb_attr(VALUE,ID,int,int,int);
|
||||
int rb_method_boundp(VALUE, ID, int);
|
||||
VALUE rb_dvar_defined(ID);
|
||||
VALUE rb_dvar_curr(ID);
|
||||
VALUE rb_dvar_ref(ID);
|
||||
void rb_dvar_asgn(ID, VALUE);
|
||||
void rb_dvar_push(ID, VALUE);
|
||||
VALUE *rb_svar(int);
|
||||
VALUE rb_eval_cmd(VALUE, VALUE, int);
|
||||
int rb_respond_to(VALUE, ID);
|
||||
void rb_interrupt(void);
|
||||
VALUE rb_apply(VALUE, ID, VALUE);
|
||||
void rb_backtrace(void);
|
||||
ID rb_frame_this_func(void);
|
||||
VALUE rb_obj_instance_eval(int, VALUE*, VALUE);
|
||||
VALUE rb_mod_module_eval(int, VALUE*, VALUE);
|
||||
void rb_load(VALUE, int);
|
||||
void rb_load_protect(VALUE, int, int*);
|
||||
NORETURN(void rb_jump_tag(int));
|
||||
int rb_provided(const char*);
|
||||
void rb_provide(const char*);
|
||||
VALUE rb_f_require(VALUE, VALUE);
|
||||
VALUE rb_require_safe(VALUE, int);
|
||||
void rb_obj_call_init(VALUE, int, VALUE*);
|
||||
VALUE rb_class_new_instance(int, VALUE*, VALUE);
|
||||
VALUE rb_block_proc(void);
|
||||
VALUE rb_f_lambda(void);
|
||||
VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
|
||||
VALUE rb_proc_call(VALUE, VALUE);
|
||||
int rb_proc_arity(VALUE);
|
||||
VALUE rb_obj_method(VALUE, VALUE);
|
||||
VALUE rb_method_call(int, VALUE*, VALUE);
|
||||
int rb_mod_method_arity(VALUE, ID);
|
||||
int rb_obj_method_arity(VALUE, ID);
|
||||
VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
|
||||
void rb_set_end_proc(void (*)(VALUE), VALUE);
|
||||
void rb_mark_end_proc(void);
|
||||
void rb_exec_end_proc(void);
|
||||
void ruby_finalize(void);
|
||||
NORETURN(void ruby_stop(int));
|
||||
int ruby_cleanup(int);
|
||||
int ruby_exec(void);
|
||||
void rb_gc_mark_threads(void);
|
||||
void rb_thread_start_timer(void);
|
||||
void rb_thread_stop_timer(void);
|
||||
void rb_thread_schedule(void);
|
||||
void rb_thread_wait_fd(int);
|
||||
int rb_thread_fd_writable(int);
|
||||
void rb_thread_fd_close(int);
|
||||
int rb_thread_alone(void);
|
||||
void rb_thread_polling(void);
|
||||
void rb_thread_sleep(int);
|
||||
void rb_thread_sleep_forever(void);
|
||||
VALUE rb_thread_stop(void);
|
||||
VALUE rb_thread_wakeup(VALUE);
|
||||
VALUE rb_thread_run(VALUE);
|
||||
VALUE rb_thread_kill(VALUE);
|
||||
VALUE rb_thread_create(VALUE (*)(ANYARGS), void*);
|
||||
void rb_thread_interrupt(void);
|
||||
void rb_thread_trap_eval(VALUE, int, int);
|
||||
void rb_thread_signal_raise(char*);
|
||||
void rb_thread_signal_exit(void);
|
||||
int rb_thread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
|
||||
void rb_thread_wait_for(struct timeval);
|
||||
VALUE rb_thread_current(void);
|
||||
VALUE rb_thread_main(void);
|
||||
VALUE rb_thread_local_aref(VALUE, ID);
|
||||
VALUE rb_thread_local_aset(VALUE, ID, VALUE);
|
||||
void rb_thread_atfork(void);
|
||||
VALUE rb_exec_recursive(VALUE(*)(ANYARGS),VALUE,VALUE);
|
||||
/* file.c */
|
||||
int eaccess _((const char*, int));
|
||||
VALUE rb_file_s_expand_path _((int, VALUE *));
|
||||
VALUE rb_file_expand_path _((VALUE, VALUE));
|
||||
void rb_file_const _((const char*, VALUE));
|
||||
int rb_find_file_ext _((VALUE*, const char* const*));
|
||||
VALUE rb_find_file _((VALUE));
|
||||
char *rb_path_next _((const char *));
|
||||
char *rb_path_skip_prefix _((const char *));
|
||||
char *rb_path_last_separator _((const char *));
|
||||
char *rb_path_end _((const char *));
|
||||
int eaccess(const char*, int);
|
||||
VALUE rb_file_s_expand_path(int, VALUE *);
|
||||
VALUE rb_file_expand_path(VALUE, VALUE);
|
||||
void rb_file_const(const char*, VALUE);
|
||||
int rb_find_file_ext(VALUE*, const char* const*);
|
||||
VALUE rb_find_file(VALUE);
|
||||
char *rb_path_next(const char *);
|
||||
char *rb_path_skip_prefix(const char *);
|
||||
char *rb_path_last_separator(const char *);
|
||||
char *rb_path_end(const char *);
|
||||
/* gc.c */
|
||||
void ruby_set_stack_size _((size_t));
|
||||
NORETURN(void rb_memerror __((void)));
|
||||
int ruby_stack_check _((void));
|
||||
int ruby_stack_length _((VALUE**));
|
||||
char *rb_source_filename _((const char*));
|
||||
void rb_gc_mark_locations _((VALUE*, VALUE*));
|
||||
void rb_mark_tbl _((struct st_table*));
|
||||
void rb_mark_hash _((struct st_table*));
|
||||
void rb_gc_mark_maybe _((VALUE));
|
||||
void rb_gc_mark _((VALUE));
|
||||
void rb_gc_force_recycle _((VALUE));
|
||||
void rb_gc _((void));
|
||||
void rb_gc_copy_finalizer _((VALUE,VALUE));
|
||||
void rb_gc_finalize_deferred _((void));
|
||||
void rb_gc_call_finalizer_at_exit _((void));
|
||||
VALUE rb_gc_enable _((void));
|
||||
VALUE rb_gc_disable _((void));
|
||||
VALUE rb_gc_start _((void));
|
||||
void ruby_set_stack_size(size_t);
|
||||
NORETURN(void rb_memerror(void));
|
||||
int ruby_stack_check(void);
|
||||
int ruby_stack_length(VALUE**);
|
||||
char *rb_source_filename(const char*);
|
||||
void rb_gc_mark_locations(VALUE*, VALUE*);
|
||||
void rb_mark_tbl(struct st_table*);
|
||||
void rb_mark_hash(struct st_table*);
|
||||
void rb_gc_mark_maybe(VALUE);
|
||||
void rb_gc_mark(VALUE);
|
||||
void rb_gc_force_recycle(VALUE);
|
||||
void rb_gc(void);
|
||||
void rb_gc_copy_finalizer(VALUE,VALUE);
|
||||
void rb_gc_finalize_deferred(void);
|
||||
void rb_gc_call_finalizer_at_exit(void);
|
||||
VALUE rb_gc_enable(void);
|
||||
VALUE rb_gc_disable(void);
|
||||
VALUE rb_gc_start(void);
|
||||
/* hash.c */
|
||||
void st_foreach_safe _((struct st_table *, int (*)(ANYARGS), unsigned long));
|
||||
void rb_hash_foreach _((VALUE, int (*)(ANYARGS), VALUE));
|
||||
VALUE rb_hash _((VALUE));
|
||||
VALUE rb_hash_new _((void));
|
||||
VALUE rb_hash_freeze _((VALUE));
|
||||
VALUE rb_hash_aref _((VALUE, VALUE));
|
||||
VALUE rb_hash_aset _((VALUE, VALUE, VALUE));
|
||||
VALUE rb_hash_delete_if _((VALUE));
|
||||
VALUE rb_hash_delete _((VALUE,VALUE));
|
||||
int rb_path_check _((const char*));
|
||||
int rb_env_path_tainted _((void));
|
||||
void st_foreach_safe(struct st_table *, int (*)(ANYARGS), unsigned long);
|
||||
void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE);
|
||||
VALUE rb_hash(VALUE);
|
||||
VALUE rb_hash_new(void);
|
||||
VALUE rb_hash_freeze(VALUE);
|
||||
VALUE rb_hash_aref(VALUE, VALUE);
|
||||
VALUE rb_hash_aset(VALUE, VALUE, VALUE);
|
||||
VALUE rb_hash_delete_if(VALUE);
|
||||
VALUE rb_hash_delete(VALUE,VALUE);
|
||||
int rb_path_check(const char*);
|
||||
int rb_env_path_tainted(void);
|
||||
/* io.c */
|
||||
#define rb_defout rb_stdout
|
||||
RUBY_EXTERN VALUE rb_fs;
|
||||
|
@ -332,250 +332,250 @@ RUBY_EXTERN VALUE rb_output_fs;
|
|||
RUBY_EXTERN VALUE rb_rs;
|
||||
RUBY_EXTERN VALUE rb_default_rs;
|
||||
RUBY_EXTERN VALUE rb_output_rs;
|
||||
VALUE rb_io_write _((VALUE, VALUE));
|
||||
VALUE rb_io_gets _((VALUE));
|
||||
VALUE rb_io_getc _((VALUE));
|
||||
VALUE rb_io_ungetc _((VALUE, VALUE));
|
||||
VALUE rb_io_close _((VALUE));
|
||||
VALUE rb_io_flush _((VALUE));
|
||||
VALUE rb_io_eof _((VALUE));
|
||||
VALUE rb_io_binmode _((VALUE));
|
||||
VALUE rb_io_addstr _((VALUE, VALUE));
|
||||
VALUE rb_io_printf _((int, VALUE*, VALUE));
|
||||
VALUE rb_io_print _((int, VALUE*, VALUE));
|
||||
VALUE rb_io_puts _((int, VALUE*, VALUE));
|
||||
VALUE rb_file_open _((const char*, const char*));
|
||||
VALUE rb_gets _((void));
|
||||
void rb_write_error _((const char*));
|
||||
void rb_write_error2 _((const char*, long));
|
||||
VALUE rb_io_write(VALUE, VALUE);
|
||||
VALUE rb_io_gets(VALUE);
|
||||
VALUE rb_io_getc(VALUE);
|
||||
VALUE rb_io_ungetc(VALUE, VALUE);
|
||||
VALUE rb_io_close(VALUE);
|
||||
VALUE rb_io_flush(VALUE);
|
||||
VALUE rb_io_eof(VALUE);
|
||||
VALUE rb_io_binmode(VALUE);
|
||||
VALUE rb_io_addstr(VALUE, VALUE);
|
||||
VALUE rb_io_printf(int, VALUE*, VALUE);
|
||||
VALUE rb_io_print(int, VALUE*, VALUE);
|
||||
VALUE rb_io_puts(int, VALUE*, VALUE);
|
||||
VALUE rb_file_open(const char*, const char*);
|
||||
VALUE rb_gets(void);
|
||||
void rb_write_error(const char*);
|
||||
void rb_write_error2(const char*, long);
|
||||
/* marshal.c */
|
||||
VALUE rb_marshal_dump _((VALUE, VALUE));
|
||||
VALUE rb_marshal_load _((VALUE));
|
||||
VALUE rb_marshal_dump(VALUE, VALUE);
|
||||
VALUE rb_marshal_load(VALUE);
|
||||
/* numeric.c */
|
||||
void rb_num_zerodiv _((void));
|
||||
VALUE rb_num_coerce_bin _((VALUE, VALUE));
|
||||
VALUE rb_num_coerce_cmp _((VALUE, VALUE));
|
||||
VALUE rb_num_coerce_relop _((VALUE, VALUE));
|
||||
VALUE rb_float_new _((double));
|
||||
VALUE rb_num2fix _((VALUE));
|
||||
VALUE rb_fix2str _((VALUE, int));
|
||||
VALUE rb_dbl_cmp _((double, double));
|
||||
void rb_num_zerodiv(void);
|
||||
VALUE rb_num_coerce_bin(VALUE, VALUE);
|
||||
VALUE rb_num_coerce_cmp(VALUE, VALUE);
|
||||
VALUE rb_num_coerce_relop(VALUE, VALUE);
|
||||
VALUE rb_float_new(double);
|
||||
VALUE rb_num2fix(VALUE);
|
||||
VALUE rb_fix2str(VALUE, int);
|
||||
VALUE rb_dbl_cmp(double, double);
|
||||
/* object.c */
|
||||
int rb_eql _((VALUE, VALUE));
|
||||
VALUE rb_any_to_s _((VALUE));
|
||||
VALUE rb_inspect _((VALUE));
|
||||
VALUE rb_obj_is_instance_of _((VALUE, VALUE));
|
||||
VALUE rb_obj_is_kind_of _((VALUE, VALUE));
|
||||
VALUE rb_obj_alloc _((VALUE));
|
||||
VALUE rb_obj_clone _((VALUE));
|
||||
VALUE rb_obj_dup _((VALUE));
|
||||
VALUE rb_obj_init_copy _((VALUE,VALUE));
|
||||
VALUE rb_obj_taint _((VALUE));
|
||||
VALUE rb_obj_tainted _((VALUE));
|
||||
VALUE rb_obj_untaint _((VALUE));
|
||||
VALUE rb_obj_freeze _((VALUE));
|
||||
VALUE rb_obj_id _((VALUE));
|
||||
VALUE rb_obj_class _((VALUE));
|
||||
VALUE rb_class_real _((VALUE));
|
||||
VALUE rb_class_inherited_p _((VALUE, VALUE));
|
||||
VALUE rb_convert_type _((VALUE,int,const char*,const char*));
|
||||
VALUE rb_check_convert_type _((VALUE,int,const char*,const char*));
|
||||
VALUE rb_check_to_integer _((VALUE, const char *));
|
||||
VALUE rb_to_int _((VALUE));
|
||||
VALUE rb_Integer _((VALUE));
|
||||
VALUE rb_Float _((VALUE));
|
||||
VALUE rb_String _((VALUE));
|
||||
VALUE rb_Array _((VALUE));
|
||||
double rb_cstr_to_dbl _((const char*, int));
|
||||
double rb_str_to_dbl _((VALUE, int));
|
||||
int rb_eql(VALUE, VALUE);
|
||||
VALUE rb_any_to_s(VALUE);
|
||||
VALUE rb_inspect(VALUE);
|
||||
VALUE rb_obj_is_instance_of(VALUE, VALUE);
|
||||
VALUE rb_obj_is_kind_of(VALUE, VALUE);
|
||||
VALUE rb_obj_alloc(VALUE);
|
||||
VALUE rb_obj_clone(VALUE);
|
||||
VALUE rb_obj_dup(VALUE);
|
||||
VALUE rb_obj_init_copy(VALUE,VALUE);
|
||||
VALUE rb_obj_taint(VALUE);
|
||||
VALUE rb_obj_tainted(VALUE);
|
||||
VALUE rb_obj_untaint(VALUE);
|
||||
VALUE rb_obj_freeze(VALUE);
|
||||
VALUE rb_obj_id(VALUE);
|
||||
VALUE rb_obj_class(VALUE);
|
||||
VALUE rb_class_real(VALUE);
|
||||
VALUE rb_class_inherited_p(VALUE, VALUE);
|
||||
VALUE rb_convert_type(VALUE,int,const char*,const char*);
|
||||
VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
|
||||
VALUE rb_check_to_integer(VALUE, const char *);
|
||||
VALUE rb_to_int(VALUE);
|
||||
VALUE rb_Integer(VALUE);
|
||||
VALUE rb_Float(VALUE);
|
||||
VALUE rb_String(VALUE);
|
||||
VALUE rb_Array(VALUE);
|
||||
double rb_cstr_to_dbl(const char*, int);
|
||||
double rb_str_to_dbl(VALUE, int);
|
||||
/* parse.y */
|
||||
RUBY_EXTERN int ruby_sourceline;
|
||||
RUBY_EXTERN char *ruby_sourcefile;
|
||||
ID rb_id_attrset _((ID));
|
||||
void rb_gc_mark_parser _((void));
|
||||
int rb_is_const_id _((ID));
|
||||
int rb_is_instance_id _((ID));
|
||||
int rb_is_class_id _((ID));
|
||||
int rb_is_local_id _((ID));
|
||||
int rb_is_junk_id _((ID));
|
||||
VALUE rb_backref_get _((void));
|
||||
void rb_backref_set _((VALUE));
|
||||
VALUE rb_lastline_get _((void));
|
||||
void rb_lastline_set _((VALUE));
|
||||
VALUE rb_sym_all_symbols _((void));
|
||||
ID rb_id_attrset(ID);
|
||||
void rb_gc_mark_parser(void);
|
||||
int rb_is_const_id(ID);
|
||||
int rb_is_instance_id(ID);
|
||||
int rb_is_class_id(ID);
|
||||
int rb_is_local_id(ID);
|
||||
int rb_is_junk_id(ID);
|
||||
VALUE rb_backref_get(void);
|
||||
void rb_backref_set(VALUE);
|
||||
VALUE rb_lastline_get(void);
|
||||
void rb_lastline_set(VALUE);
|
||||
VALUE rb_sym_all_symbols(void);
|
||||
/* process.c */
|
||||
struct rb_exec_arg {
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
const char *prog;
|
||||
};
|
||||
int rb_proc_exec_n _((int, VALUE*, const char*));
|
||||
int rb_proc_exec _((const char*));
|
||||
VALUE rb_check_argv _((int, VALUE*));
|
||||
int rb_exec _((const struct rb_exec_arg*));
|
||||
int rb_fork _((int*, int (*)_((void*)), void*));
|
||||
VALUE rb_f_exec _((int,VALUE*));
|
||||
int rb_waitpid _((int,int*,int));
|
||||
void rb_syswait _((int));
|
||||
int rb_spawn _((int, VALUE*));
|
||||
VALUE rb_proc_times _((VALUE));
|
||||
VALUE rb_detach_process _((int));
|
||||
int rb_proc_exec_n(int, VALUE*, const char*);
|
||||
int rb_proc_exec(const char*);
|
||||
VALUE rb_check_argv(int, VALUE*);
|
||||
int rb_exec(const struct rb_exec_arg*);
|
||||
int rb_fork(int*, int (*)_((void*)), void*);
|
||||
VALUE rb_f_exec(int,VALUE*);
|
||||
int rb_waitpid(int,int*,int);
|
||||
void rb_syswait(int);
|
||||
int rb_spawn(int, VALUE*);
|
||||
VALUE rb_proc_times(VALUE);
|
||||
VALUE rb_detach_process(int);
|
||||
/* range.c */
|
||||
VALUE rb_range_new _((VALUE, VALUE, int));
|
||||
VALUE rb_range_beg_len _((VALUE, long*, long*, long, int));
|
||||
VALUE rb_length_by_each _((VALUE));
|
||||
VALUE rb_range_new(VALUE, VALUE, int);
|
||||
VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
|
||||
VALUE rb_length_by_each(VALUE);
|
||||
/* re.c */
|
||||
int rb_memcmp _((char*,char*,long));
|
||||
int rb_memcicmp _((char*,char*,long));
|
||||
long rb_memsearch _((char*,long,char*,long));
|
||||
VALUE rb_reg_nth_defined _((int, VALUE));
|
||||
VALUE rb_reg_nth_match _((int, VALUE));
|
||||
VALUE rb_reg_last_match _((VALUE));
|
||||
VALUE rb_reg_match_pre _((VALUE));
|
||||
VALUE rb_reg_match_post _((VALUE));
|
||||
VALUE rb_reg_match_last _((VALUE));
|
||||
VALUE rb_reg_new _((const char*, long, int));
|
||||
VALUE rb_reg_compile _((const char*, long, int));
|
||||
VALUE rb_reg_match _((VALUE, VALUE));
|
||||
VALUE rb_reg_match2 _((VALUE));
|
||||
int rb_reg_options _((VALUE));
|
||||
void rb_set_kcode _((const char*));
|
||||
const char* rb_get_kcode _((void));
|
||||
int rb_memcmp(char*,char*,long);
|
||||
int rb_memcicmp(char*,char*,long);
|
||||
long rb_memsearch(char*,long,char*,long);
|
||||
VALUE rb_reg_nth_defined(int, VALUE);
|
||||
VALUE rb_reg_nth_match(int, VALUE);
|
||||
VALUE rb_reg_last_match(VALUE);
|
||||
VALUE rb_reg_match_pre(VALUE);
|
||||
VALUE rb_reg_match_post(VALUE);
|
||||
VALUE rb_reg_match_last(VALUE);
|
||||
VALUE rb_reg_new(const char*, long, int);
|
||||
VALUE rb_reg_compile(const char*, long, int);
|
||||
VALUE rb_reg_match(VALUE, VALUE);
|
||||
VALUE rb_reg_match2(VALUE);
|
||||
int rb_reg_options(VALUE);
|
||||
void rb_set_kcode(const char*);
|
||||
const char* rb_get_kcode(void);
|
||||
/* ruby.c */
|
||||
RUBY_EXTERN VALUE rb_argv;
|
||||
RUBY_EXTERN VALUE rb_argv0;
|
||||
void rb_load_file _((const char*));
|
||||
void ruby_script _((const char*));
|
||||
void ruby_prog_init _((void));
|
||||
void ruby_set_argv _((int, char**));
|
||||
void ruby_process_options _((int, char**));
|
||||
void ruby_load_script _((void));
|
||||
void ruby_init_loadpath _((void));
|
||||
void ruby_incpush _((const char*));
|
||||
void rb_load_file(const char*);
|
||||
void ruby_script(const char*);
|
||||
void ruby_prog_init(void);
|
||||
void ruby_set_argv(int, char**);
|
||||
void ruby_process_options(int, char**);
|
||||
void ruby_load_script(void);
|
||||
void ruby_init_loadpath(void);
|
||||
void ruby_incpush(const char*);
|
||||
/* signal.c */
|
||||
VALUE rb_f_kill _((int, VALUE*));
|
||||
void rb_gc_mark_trap_list _((void));
|
||||
VALUE rb_f_kill(int, VALUE*);
|
||||
void rb_gc_mark_trap_list(void);
|
||||
#ifdef POSIX_SIGNAL
|
||||
#define posix_signal ruby_posix_signal
|
||||
void posix_signal _((int, RETSIGTYPE (*)(int)));
|
||||
void posix_signal(int, RETSIGTYPE (*)(int));
|
||||
#ifdef HAVE_NATIVETHREAD
|
||||
#define posix_nativethread_signal ruby_posix_nativethread_signal
|
||||
void posix_nativethread_signal _((int, RETSIGTYPE (*)(int)));
|
||||
void posix_nativethread_signal(int, RETSIGTYPE (*)(int));
|
||||
#endif
|
||||
#endif
|
||||
void rb_trap_exit _((void));
|
||||
void rb_trap_exec _((void));
|
||||
const char *ruby_signal_name _((int));
|
||||
void rb_trap_exit(void);
|
||||
void rb_trap_exec(void);
|
||||
const char *ruby_signal_name(int);
|
||||
/* sprintf.c */
|
||||
VALUE rb_f_sprintf _((int, const VALUE*));
|
||||
PRINTF_ARGS(VALUE rb_sprintf __((const char*, ...)), 1, 2);
|
||||
VALUE rb_vsprintf _((const char*, va_list));
|
||||
VALUE rb_str_format _((int, const VALUE *, VALUE));
|
||||
VALUE rb_f_sprintf(int, const VALUE*);
|
||||
PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
|
||||
VALUE rb_vsprintf(const char*, va_list);
|
||||
VALUE rb_str_format(int, const VALUE *, VALUE);
|
||||
/* string.c */
|
||||
VALUE rb_str_new _((const char*, long));
|
||||
VALUE rb_str_new2 _((const char*));
|
||||
VALUE rb_str_new3 _((VALUE));
|
||||
VALUE rb_str_new4 _((VALUE));
|
||||
VALUE rb_str_new5 _((VALUE, const char*, long));
|
||||
VALUE rb_tainted_str_new _((const char*, long));
|
||||
VALUE rb_tainted_str_new2 _((const char*));
|
||||
VALUE rb_str_buf_new _((long));
|
||||
VALUE rb_str_buf_new2 _((const char*));
|
||||
VALUE rb_str_buf_append _((VALUE, VALUE));
|
||||
VALUE rb_str_buf_cat _((VALUE, const char*, long));
|
||||
VALUE rb_str_buf_cat2 _((VALUE, const char*));
|
||||
VALUE rb_obj_as_string _((VALUE));
|
||||
VALUE rb_check_string_type _((VALUE));
|
||||
VALUE rb_str_dup _((VALUE));
|
||||
VALUE rb_str_locktmp _((VALUE));
|
||||
VALUE rb_str_unlocktmp _((VALUE));
|
||||
VALUE rb_str_dup_frozen _((VALUE));
|
||||
VALUE rb_str_plus _((VALUE, VALUE));
|
||||
VALUE rb_str_times _((VALUE, VALUE));
|
||||
VALUE rb_str_substr _((VALUE, long, long));
|
||||
void rb_str_modify _((VALUE));
|
||||
VALUE rb_str_freeze _((VALUE));
|
||||
VALUE rb_str_resize _((VALUE, long));
|
||||
VALUE rb_str_cat _((VALUE, const char*, long));
|
||||
VALUE rb_str_cat2 _((VALUE, const char*));
|
||||
VALUE rb_str_append _((VALUE, VALUE));
|
||||
VALUE rb_str_concat _((VALUE, VALUE));
|
||||
int rb_str_hash _((VALUE));
|
||||
int rb_str_cmp _((VALUE, VALUE));
|
||||
VALUE rb_str_upto _((VALUE, VALUE, int));
|
||||
void rb_str_update _((VALUE, long, long, VALUE));
|
||||
VALUE rb_str_inspect _((VALUE));
|
||||
VALUE rb_str_dump _((VALUE));
|
||||
VALUE rb_str_split _((VALUE, const char*));
|
||||
void rb_str_associate _((VALUE, VALUE));
|
||||
VALUE rb_str_associated _((VALUE));
|
||||
void rb_str_setter _((VALUE, ID, VALUE*));
|
||||
VALUE rb_str_intern _((VALUE));
|
||||
VALUE rb_str_new(const char*, long);
|
||||
VALUE rb_str_new2(const char*);
|
||||
VALUE rb_str_new3(VALUE);
|
||||
VALUE rb_str_new4(VALUE);
|
||||
VALUE rb_str_new5(VALUE, const char*, long);
|
||||
VALUE rb_tainted_str_new(const char*, long);
|
||||
VALUE rb_tainted_str_new2(const char*);
|
||||
VALUE rb_str_buf_new(long);
|
||||
VALUE rb_str_buf_new2(const char*);
|
||||
VALUE rb_str_buf_append(VALUE, VALUE);
|
||||
VALUE rb_str_buf_cat(VALUE, const char*, long);
|
||||
VALUE rb_str_buf_cat2(VALUE, const char*);
|
||||
VALUE rb_obj_as_string(VALUE);
|
||||
VALUE rb_check_string_type(VALUE);
|
||||
VALUE rb_str_dup(VALUE);
|
||||
VALUE rb_str_locktmp(VALUE);
|
||||
VALUE rb_str_unlocktmp(VALUE);
|
||||
VALUE rb_str_dup_frozen(VALUE);
|
||||
VALUE rb_str_plus(VALUE, VALUE);
|
||||
VALUE rb_str_times(VALUE, VALUE);
|
||||
VALUE rb_str_substr(VALUE, long, long);
|
||||
void rb_str_modify(VALUE);
|
||||
VALUE rb_str_freeze(VALUE);
|
||||
VALUE rb_str_resize(VALUE, long);
|
||||
VALUE rb_str_cat(VALUE, const char*, long);
|
||||
VALUE rb_str_cat2(VALUE, const char*);
|
||||
VALUE rb_str_append(VALUE, VALUE);
|
||||
VALUE rb_str_concat(VALUE, VALUE);
|
||||
int rb_str_hash(VALUE);
|
||||
int rb_str_cmp(VALUE, VALUE);
|
||||
VALUE rb_str_upto(VALUE, VALUE, int);
|
||||
void rb_str_update(VALUE, long, long, VALUE);
|
||||
VALUE rb_str_inspect(VALUE);
|
||||
VALUE rb_str_dump(VALUE);
|
||||
VALUE rb_str_split(VALUE, const char*);
|
||||
void rb_str_associate(VALUE, VALUE);
|
||||
VALUE rb_str_associated(VALUE);
|
||||
void rb_str_setter(VALUE, ID, VALUE*);
|
||||
VALUE rb_str_intern(VALUE);
|
||||
/* struct.c */
|
||||
VALUE rb_struct_new __((VALUE, ...));
|
||||
VALUE rb_struct_define __((const char*, ...));
|
||||
VALUE rb_struct_alloc _((VALUE, VALUE));
|
||||
VALUE rb_struct_aref _((VALUE, VALUE));
|
||||
VALUE rb_struct_aset _((VALUE, VALUE, VALUE));
|
||||
VALUE rb_struct_getmember _((VALUE, ID));
|
||||
VALUE rb_struct_iv_get _((VALUE, char*));
|
||||
VALUE rb_struct_s_members _((VALUE));
|
||||
VALUE rb_struct_members _((VALUE));
|
||||
VALUE rb_struct_new(VALUE, ...);
|
||||
VALUE rb_struct_define(const char*, ...);
|
||||
VALUE rb_struct_alloc(VALUE, VALUE);
|
||||
VALUE rb_struct_aref(VALUE, VALUE);
|
||||
VALUE rb_struct_aset(VALUE, VALUE, VALUE);
|
||||
VALUE rb_struct_getmember(VALUE, ID);
|
||||
VALUE rb_struct_iv_get(VALUE, char*);
|
||||
VALUE rb_struct_s_members(VALUE);
|
||||
VALUE rb_struct_members(VALUE);
|
||||
/* time.c */
|
||||
VALUE rb_time_new _((time_t, time_t));
|
||||
VALUE rb_time_new(time_t, time_t);
|
||||
/* variable.c */
|
||||
VALUE rb_mod_name _((VALUE));
|
||||
VALUE rb_class_path _((VALUE));
|
||||
void rb_set_class_path _((VALUE, VALUE, const char*));
|
||||
VALUE rb_path2class _((const char*));
|
||||
void rb_name_class _((VALUE, ID));
|
||||
VALUE rb_class_name _((VALUE));
|
||||
void rb_autoload _((VALUE, ID, const char*));
|
||||
void rb_autoload_load _((VALUE, ID));
|
||||
VALUE rb_autoload_p _((VALUE, ID));
|
||||
void rb_gc_mark_global_tbl _((void));
|
||||
VALUE rb_f_trace_var _((int, VALUE*));
|
||||
VALUE rb_f_untrace_var _((int, VALUE*));
|
||||
VALUE rb_f_global_variables _((void));
|
||||
void rb_alias_variable _((ID, ID));
|
||||
struct st_table* rb_generic_ivar_table _((VALUE));
|
||||
void rb_copy_generic_ivar _((VALUE,VALUE));
|
||||
void rb_mark_generic_ivar _((VALUE));
|
||||
void rb_mark_generic_ivar_tbl _((void));
|
||||
void rb_free_generic_ivar _((VALUE));
|
||||
VALUE rb_ivar_get _((VALUE, ID));
|
||||
VALUE rb_ivar_set _((VALUE, ID, VALUE));
|
||||
VALUE rb_ivar_defined _((VALUE, ID));
|
||||
VALUE rb_iv_set _((VALUE, const char*, VALUE));
|
||||
VALUE rb_iv_get _((VALUE, const char*));
|
||||
VALUE rb_attr_get _((VALUE, ID));
|
||||
VALUE rb_obj_instance_variables _((VALUE));
|
||||
VALUE rb_obj_remove_instance_variable _((VALUE, VALUE));
|
||||
void *rb_mod_const_at _((VALUE, void*));
|
||||
void *rb_mod_const_of _((VALUE, void*));
|
||||
VALUE rb_const_list _((void*));
|
||||
VALUE rb_mod_constants _((VALUE));
|
||||
VALUE rb_mod_remove_const _((VALUE, VALUE));
|
||||
int rb_const_defined _((VALUE, ID));
|
||||
int rb_const_defined_at _((VALUE, ID));
|
||||
int rb_const_defined_from _((VALUE, ID));
|
||||
VALUE rb_const_get _((VALUE, ID));
|
||||
VALUE rb_const_get_at _((VALUE, ID));
|
||||
VALUE rb_const_get_from _((VALUE, ID));
|
||||
void rb_const_set _((VALUE, ID, VALUE));
|
||||
VALUE rb_mod_constants _((VALUE));
|
||||
VALUE rb_mod_const_missing _((VALUE,VALUE));
|
||||
VALUE rb_cvar_defined _((VALUE, ID));
|
||||
VALUE rb_mod_name(VALUE);
|
||||
VALUE rb_class_path(VALUE);
|
||||
void rb_set_class_path(VALUE, VALUE, const char*);
|
||||
VALUE rb_path2class(const char*);
|
||||
void rb_name_class(VALUE, ID);
|
||||
VALUE rb_class_name(VALUE);
|
||||
void rb_autoload(VALUE, ID, const char*);
|
||||
void rb_autoload_load(VALUE, ID);
|
||||
VALUE rb_autoload_p(VALUE, ID);
|
||||
void rb_gc_mark_global_tbl(void);
|
||||
VALUE rb_f_trace_var(int, VALUE*);
|
||||
VALUE rb_f_untrace_var(int, VALUE*);
|
||||
VALUE rb_f_global_variables(void);
|
||||
void rb_alias_variable(ID, ID);
|
||||
struct st_table* rb_generic_ivar_table(VALUE);
|
||||
void rb_copy_generic_ivar(VALUE,VALUE);
|
||||
void rb_mark_generic_ivar(VALUE);
|
||||
void rb_mark_generic_ivar_tbl(void);
|
||||
void rb_free_generic_ivar(VALUE);
|
||||
VALUE rb_ivar_get(VALUE, ID);
|
||||
VALUE rb_ivar_set(VALUE, ID, VALUE);
|
||||
VALUE rb_ivar_defined(VALUE, ID);
|
||||
VALUE rb_iv_set(VALUE, const char*, VALUE);
|
||||
VALUE rb_iv_get(VALUE, const char*);
|
||||
VALUE rb_attr_get(VALUE, ID);
|
||||
VALUE rb_obj_instance_variables(VALUE);
|
||||
VALUE rb_obj_remove_instance_variable(VALUE, VALUE);
|
||||
void *rb_mod_const_at(VALUE, void*);
|
||||
void *rb_mod_const_of(VALUE, void*);
|
||||
VALUE rb_const_list(void*);
|
||||
VALUE rb_mod_constants(VALUE);
|
||||
VALUE rb_mod_remove_const(VALUE, VALUE);
|
||||
int rb_const_defined(VALUE, ID);
|
||||
int rb_const_defined_at(VALUE, ID);
|
||||
int rb_const_defined_from(VALUE, ID);
|
||||
VALUE rb_const_get(VALUE, ID);
|
||||
VALUE rb_const_get_at(VALUE, ID);
|
||||
VALUE rb_const_get_from(VALUE, ID);
|
||||
void rb_const_set(VALUE, ID, VALUE);
|
||||
VALUE rb_mod_constants(VALUE);
|
||||
VALUE rb_mod_const_missing(VALUE,VALUE);
|
||||
VALUE rb_cvar_defined(VALUE, ID);
|
||||
#define RB_CVAR_SET_4ARGS 1
|
||||
void rb_cvar_set _((VALUE, ID, VALUE, int));
|
||||
VALUE rb_cvar_get _((VALUE, ID));
|
||||
void rb_cv_set _((VALUE, const char*, VALUE));
|
||||
VALUE rb_cv_get _((VALUE, const char*));
|
||||
void rb_define_class_variable _((VALUE, const char*, VALUE));
|
||||
VALUE rb_mod_class_variables _((VALUE));
|
||||
VALUE rb_mod_remove_cvar _((VALUE, VALUE));
|
||||
void rb_cvar_set(VALUE, ID, VALUE, int);
|
||||
VALUE rb_cvar_get(VALUE, ID);
|
||||
void rb_cv_set(VALUE, const char*, VALUE);
|
||||
VALUE rb_cv_get(VALUE, const char*);
|
||||
void rb_define_class_variable(VALUE, const char*, VALUE);
|
||||
VALUE rb_mod_class_variables(VALUE);
|
||||
VALUE rb_mod_remove_cvar(VALUE, VALUE);
|
||||
/* version.c */
|
||||
void ruby_show_version _((void));
|
||||
void ruby_show_copyright _((void));
|
||||
void ruby_show_version(void);
|
||||
void ruby_show_copyright(void);
|
||||
|
||||
#endif /* RUBY_INTERN_H */
|
||||
|
|
8
io.c
8
io.c
|
@ -72,7 +72,7 @@
|
|||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
extern void Init_File _((void));
|
||||
extern void Init_File(void);
|
||||
|
||||
#ifdef __BEOS__
|
||||
# ifndef NOFILE
|
||||
|
@ -110,7 +110,7 @@ static ID id_write, id_read, id_getc, id_flush;
|
|||
|
||||
extern char *ruby_inplace_mode;
|
||||
|
||||
struct timeval rb_time_interval _((VALUE));
|
||||
struct timeval rb_time_interval(VALUE);
|
||||
|
||||
static VALUE filename, current_file;
|
||||
static int gets_lineno;
|
||||
|
@ -202,7 +202,7 @@ rb_io_check_closed(OpenFile *fptr)
|
|||
}
|
||||
}
|
||||
|
||||
static int io_fflush _((OpenFile *));
|
||||
static int io_fflush(OpenFile *);
|
||||
|
||||
static VALUE
|
||||
rb_io_get_io(VALUE io)
|
||||
|
@ -2693,7 +2693,7 @@ pipe_del_fptr(OpenFile *fptr)
|
|||
}
|
||||
|
||||
static void
|
||||
pipe_atexit _((void))
|
||||
pipe_atexit(void)
|
||||
{
|
||||
struct pipe_list *list = pipe_list;
|
||||
struct pipe_list *tmp;
|
||||
|
|
2
lex.c
2
lex.c
|
@ -1,7 +1,7 @@
|
|||
/* C code produced by gperf version 2.7.2 */
|
||||
/* Command-line: gperf -C -p -j1 -i 1 -g -o -t -N rb_reserved_word -k'1,3,$' keywords */
|
||||
struct kwtable {char *name; int id[2]; enum lex_state_e state;};
|
||||
const struct kwtable *rb_reserved_word _((const char *, unsigned int));
|
||||
const struct kwtable *rb_reserved_word(const char *, unsigned int);
|
||||
#ifndef RIPPER
|
||||
;
|
||||
|
||||
|
|
|
@ -113,7 +113,7 @@ class2path(VALUE klass)
|
|||
return path;
|
||||
}
|
||||
|
||||
static void w_long _((long, struct dump_arg*));
|
||||
static void w_long(long, struct dump_arg*);
|
||||
|
||||
static void
|
||||
w_nbyte(char *s, int n, struct dump_arg *arg)
|
||||
|
@ -327,7 +327,7 @@ w_unique(char *s, struct dump_arg *arg)
|
|||
w_symbol(rb_intern(s), arg);
|
||||
}
|
||||
|
||||
static void w_object _((VALUE,struct dump_arg*,int));
|
||||
static void w_object(VALUE,struct dump_arg*,int);
|
||||
|
||||
static int
|
||||
hash_each(VALUE key, VALUE value, struct dump_call_arg *arg)
|
||||
|
@ -738,7 +738,7 @@ struct load_arg {
|
|||
int taint;
|
||||
};
|
||||
|
||||
static VALUE r_object _((struct load_arg *arg));
|
||||
static VALUE r_object(struct load_arg *arg);
|
||||
|
||||
static int
|
||||
r_byte(struct load_arg *arg)
|
||||
|
|
54
missing.h
54
missing.h
|
@ -26,103 +26,103 @@ struct timeval {
|
|||
#endif
|
||||
|
||||
#ifndef HAVE_ACOSH
|
||||
extern double acosh _((double));
|
||||
extern double asinh _((double));
|
||||
extern double atanh _((double));
|
||||
extern double acosh(double);
|
||||
extern double asinh(double);
|
||||
extern double atanh(double);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_CRYPT
|
||||
extern char *crypt _((const char *, const char *));
|
||||
extern char *crypt(const char *, const char *);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_DUP2
|
||||
extern int dup2 _((int, int));
|
||||
extern int dup2(int, int);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_FINITE
|
||||
extern int finite _((double));
|
||||
extern int finite(double);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_FLOCK
|
||||
extern int flock _((int, int));
|
||||
extern int flock(int, int);
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifndef HAVE_FREXP
|
||||
extern double frexp _((double, int *));
|
||||
extern double frexp(double, int *);
|
||||
#endif
|
||||
*/
|
||||
|
||||
#ifndef HAVE_HYPOT
|
||||
extern double hypot _((double, double));
|
||||
extern double hypot(double, double);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_ERF
|
||||
extern double erf _((double));
|
||||
extern double erfc _((double));
|
||||
extern double erf(double);
|
||||
extern double erfc(double);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_ISINF
|
||||
# if defined(HAVE_FINITE) && defined(HAVE_ISNAN)
|
||||
# define isinf(x) (!finite(x) && !isnan(x))
|
||||
# else
|
||||
extern int isinf _((double));
|
||||
extern int isinf(double);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_ISNAN
|
||||
extern int isnan _((double));
|
||||
extern int isnan(double);
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifndef HAVE_MEMCMP
|
||||
extern int memcmp _((char *, char *, int));
|
||||
extern int memcmp(char *, char *, int);
|
||||
#endif
|
||||
*/
|
||||
|
||||
#ifndef HAVE_MEMMOVE
|
||||
extern void *memmove _((void *, void *, int));
|
||||
extern void *memmove(void *, void *, int);
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifndef HAVE_MODF
|
||||
extern double modf _((double, double *));
|
||||
extern double modf(double, double *);
|
||||
#endif
|
||||
*/
|
||||
|
||||
#ifndef HAVE_STRCASECMP
|
||||
extern int strcasecmp _((char *, char *));
|
||||
extern int strcasecmp(char *, char *);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRNCASECMP
|
||||
extern int strncasecmp _((char *, char *, int));
|
||||
extern int strncasecmp(char *, char *, int);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRCHR
|
||||
extern char *strchr _((char *, int));
|
||||
extern char *strrchr _((char *, int));
|
||||
extern char *strchr(char *, int);
|
||||
extern char *strrchr(char *, int);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRERROR
|
||||
extern char *strerror _((int));
|
||||
extern char *strerror(int);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRFTIME
|
||||
extern size_t strftime _((char *, size_t, const char *, const struct tm *));
|
||||
extern size_t strftime(char *, size_t, const char *, const struct tm *);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STRSTR
|
||||
extern char *strstr _((char *, char *));
|
||||
extern char *strstr(char *, char *);
|
||||
#endif
|
||||
|
||||
/*
|
||||
#ifndef HAVE_STRTOL
|
||||
extern long strtol _((char *, char **, int));
|
||||
extern long strtol(char *, char **, int);
|
||||
#endif
|
||||
*/
|
||||
|
||||
#ifndef HAVE_STRTOUL
|
||||
extern unsigned long strtoul _((char *, char **, int));
|
||||
extern unsigned long strtoul(char *, char **, int);
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_VSNPRINTF
|
||||
|
@ -131,8 +131,8 @@ extern unsigned long strtoul _((char *, char **, int));
|
|||
# else
|
||||
# include <varargs.h>
|
||||
# endif
|
||||
extern int snprintf __((char *, size_t n, char const *, ...));
|
||||
extern int vsnprintf _((char *, size_t n, char const *, va_list));
|
||||
extern int snprintf(char *, size_t n, char const *, ...);
|
||||
extern int vsnprintf(char *, size_t n, char const *, va_list);
|
||||
#endif
|
||||
|
||||
#endif /* MISSING_H */
|
||||
|
|
38
node.h
38
node.h
|
@ -352,27 +352,27 @@ typedef struct RNode {
|
|||
#define NOEX_UNDEF NOEX_NOSUPER
|
||||
#define NOEX_RECV 8
|
||||
|
||||
VALUE rb_parser_new _((void));
|
||||
VALUE rb_parser_end_seen_p _((VALUE));
|
||||
VALUE rb_parser_new(void);
|
||||
VALUE rb_parser_end_seen_p(VALUE);
|
||||
|
||||
NODE *rb_parser_compile_cstr _((volatile VALUE, const char*, const char*, int, int));
|
||||
NODE *rb_parser_compile_string _((volatile VALUE, const char*, VALUE, int));
|
||||
NODE *rb_parser_compile_file _((volatile VALUE, const char*, VALUE, int));
|
||||
NODE *rb_parser_compile_cstr(volatile VALUE, const char*, const char*, int, int);
|
||||
NODE *rb_parser_compile_string(volatile VALUE, const char*, VALUE, int);
|
||||
NODE *rb_parser_compile_file(volatile VALUE, const char*, VALUE, int);
|
||||
|
||||
NODE *rb_compile_cstr _((const char*, const char*, int, int));
|
||||
NODE *rb_compile_string _((const char*, VALUE, int));
|
||||
NODE *rb_compile_file _((const char*, VALUE, int));
|
||||
NODE *rb_compile_cstr(const char*, const char*, int, int);
|
||||
NODE *rb_compile_string(const char*, VALUE, int);
|
||||
NODE *rb_compile_file(const char*, VALUE, int);
|
||||
|
||||
void rb_add_method _((VALUE, ID, NODE *, int));
|
||||
NODE *rb_node_newnode _((enum node_type,VALUE,VALUE,VALUE));
|
||||
void rb_add_method(VALUE, ID, NODE *, int);
|
||||
NODE *rb_node_newnode(enum node_type,VALUE,VALUE,VALUE);
|
||||
|
||||
NODE* rb_method_node _((VALUE klass, ID id));
|
||||
int rb_node_arity _((NODE* node));
|
||||
NODE* rb_method_node(VALUE klass, ID id);
|
||||
int rb_node_arity(NODE* node);
|
||||
|
||||
struct global_entry *rb_global_entry _((ID));
|
||||
VALUE rb_gvar_get _((struct global_entry *));
|
||||
VALUE rb_gvar_set _((struct global_entry *, VALUE));
|
||||
VALUE rb_gvar_defined _((struct global_entry *));
|
||||
struct global_entry *rb_global_entry(ID);
|
||||
VALUE rb_gvar_get(struct global_entry *);
|
||||
VALUE rb_gvar_set(struct global_entry *, VALUE);
|
||||
VALUE rb_gvar_defined(struct global_entry *);
|
||||
|
||||
typedef unsigned int rb_event_t;
|
||||
|
||||
|
@ -387,9 +387,9 @@ typedef unsigned int rb_event_t;
|
|||
#define RUBY_EVENT_RAISE 0x80
|
||||
#define RUBY_EVENT_ALL 0xff
|
||||
|
||||
typedef void (*rb_event_hook_func_t) _((rb_event_t,NODE*,VALUE,ID,VALUE));
|
||||
void rb_add_event_hook _((rb_event_hook_func_t,rb_event_t));
|
||||
int rb_remove_event_hook _((rb_event_hook_func_t));
|
||||
typedef void (*rb_event_hook_func_t)(rb_event_t,NODE*,VALUE,ID,VALUE);
|
||||
void rb_add_event_hook(rb_event_hook_func_t,rb_event_t);
|
||||
int rb_remove_event_hook(rb_event_hook_func_t);
|
||||
|
||||
#if defined(__cplusplus)
|
||||
} /* extern "C" { */
|
||||
|
|
|
@ -2414,7 +2414,7 @@ fix_xor(VALUE x, VALUE y)
|
|||
return LONG2NUM(val);
|
||||
}
|
||||
|
||||
static VALUE fix_rshift _((VALUE, VALUE));
|
||||
static VALUE fix_rshift(VALUE, VALUE);
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
|
|
10
pack.c
10
pack.c
|
@ -330,7 +330,7 @@ endian()
|
|||
#define VTOHD(x,y) vtohd(x)
|
||||
#endif
|
||||
|
||||
unsigned long rb_big2ulong_pack _((VALUE x));
|
||||
unsigned long rb_big2ulong_pack(VALUE x);
|
||||
|
||||
static unsigned long
|
||||
num2i32(VALUE x)
|
||||
|
@ -364,11 +364,11 @@ num2i32(VALUE x)
|
|||
#endif
|
||||
static char *toofew = "too few arguments";
|
||||
|
||||
static void encodes _((VALUE,char*,long,int));
|
||||
static void qpencode _((VALUE,VALUE,long));
|
||||
static void encodes(VALUE,char*,long,int);
|
||||
static void qpencode(VALUE,VALUE,long);
|
||||
|
||||
static int uv_to_utf8 _((char*,unsigned long));
|
||||
static unsigned long utf8_to_uv _((char*,long*));
|
||||
static int uv_to_utf8(char*,unsigned long);
|
||||
static unsigned long utf8_to_uv(char*,long*);
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
#define EXIT_FAILURE 1
|
||||
#endif
|
||||
|
||||
struct timeval rb_time_interval _((VALUE));
|
||||
struct timeval rb_time_interval(VALUE);
|
||||
|
||||
#ifdef HAVE_SYS_WAIT_H
|
||||
# include <sys/wait.h>
|
||||
|
@ -1298,7 +1298,7 @@ proc_syswait(pid)
|
|||
int
|
||||
rb_fork(status, chfunc, charg)
|
||||
int *status;
|
||||
int (*chfunc) _((void *));
|
||||
int (*chfunc)(void *);
|
||||
void *charg;
|
||||
{
|
||||
int pid, err, state = 0;
|
||||
|
|
14
re.h
14
re.h
|
@ -28,15 +28,15 @@ struct RMatch {
|
|||
|
||||
#define RMATCH(obj) (R_CAST(RMatch)(obj))
|
||||
|
||||
VALUE rb_reg_regcomp _((VALUE));
|
||||
long rb_reg_search _((VALUE, VALUE, long, long));
|
||||
VALUE rb_reg_regsub _((VALUE, VALUE, struct re_registers *));
|
||||
long rb_reg_adjust_startpos _((VALUE, VALUE, long, long));
|
||||
void rb_match_busy _((VALUE));
|
||||
VALUE rb_reg_quote _((VALUE));
|
||||
VALUE rb_reg_regcomp(VALUE);
|
||||
long rb_reg_search(VALUE, VALUE, long, long);
|
||||
VALUE rb_reg_regsub(VALUE, VALUE, struct re_registers *);
|
||||
long rb_reg_adjust_startpos(VALUE, VALUE, long, long);
|
||||
void rb_match_busy(VALUE);
|
||||
VALUE rb_reg_quote(VALUE);
|
||||
|
||||
RUBY_EXTERN int ruby_ignorecase;
|
||||
|
||||
int rb_reg_mbclen2 _((unsigned int, VALUE));
|
||||
int rb_reg_mbclen2(unsigned int, VALUE);
|
||||
#define mbclen2(c,re) rb_reg_mbclen2((c),(re))
|
||||
#endif
|
||||
|
|
20
ruby.c
20
ruby.c
|
@ -41,9 +41,9 @@
|
|||
#endif
|
||||
|
||||
#ifndef HAVE_STRING_H
|
||||
char *strchr _((const char*,const char));
|
||||
char *strrchr _((const char*,const char));
|
||||
char *strstr _((const char*,const char*));
|
||||
char *strchr(const char*,const char);
|
||||
char *strrchr(const char*,const char);
|
||||
char *strstr(const char*,const char*);
|
||||
#endif
|
||||
|
||||
#include "util.h"
|
||||
|
@ -60,9 +60,9 @@ extern int ruby_yydebug;
|
|||
|
||||
char *ruby_inplace_mode = Qfalse;
|
||||
|
||||
static void load_stdin _((void));
|
||||
static void load_file _((const char *, int));
|
||||
static void forbid_setid _((const char *));
|
||||
static void load_stdin(void);
|
||||
static void load_file(const char *, int);
|
||||
static void forbid_setid(const char *);
|
||||
|
||||
static VALUE do_loop = Qfalse, do_print = Qfalse;
|
||||
static VALUE do_check = Qfalse, do_line = Qfalse;
|
||||
|
@ -354,7 +354,7 @@ add_modules(const char *mod)
|
|||
req_list_last = list;
|
||||
}
|
||||
|
||||
extern void Init_ext _((void));
|
||||
extern void Init_ext(void);
|
||||
|
||||
static void
|
||||
require_libraries(void)
|
||||
|
@ -450,7 +450,7 @@ process_sflag(void)
|
|||
sflag = 0;
|
||||
}
|
||||
|
||||
static void proc_options _((int argc, char **argv));
|
||||
static void proc_options(int argc, char **argv);
|
||||
|
||||
static char*
|
||||
moreswitches(char *s)
|
||||
|
@ -1199,8 +1199,8 @@ ruby_set_argv(int argc, char **argv)
|
|||
}
|
||||
}
|
||||
|
||||
NODE *rb_parser_append_print _((NODE*));
|
||||
NODE *rb_parser_while_loop _((NODE*, int, int));
|
||||
NODE *rb_parser_append_print(NODE*);
|
||||
NODE *rb_parser_while_loop(NODE*, int, int);
|
||||
|
||||
void
|
||||
ruby_process_options(int argc, char **argv)
|
||||
|
|
200
ruby.h
200
ruby.h
|
@ -146,19 +146,19 @@ typedef unsigned LONG_LONG ID;
|
|||
#define INT2FIX(i) ((VALUE)(((long)(i))<<1 | FIXNUM_FLAG))
|
||||
#define LONG2FIX(i) INT2FIX(i)
|
||||
#define rb_fix_new(v) INT2FIX(v)
|
||||
VALUE rb_int2inum _((long));
|
||||
VALUE rb_int2inum(long);
|
||||
#define INT2NUM(v) rb_int2inum(v)
|
||||
#define LONG2NUM(v) INT2NUM(v)
|
||||
#define rb_int_new(v) rb_int2inum(v)
|
||||
VALUE rb_uint2inum _((unsigned long));
|
||||
VALUE rb_uint2inum(unsigned long);
|
||||
#define UINT2NUM(v) rb_uint2inum(v)
|
||||
#define ULONG2NUM(v) UINT2NUM(v)
|
||||
#define rb_uint_new(v) rb_uint2inum(v)
|
||||
|
||||
#if HAVE_LONG_LONG
|
||||
VALUE rb_ll2inum _((LONG_LONG));
|
||||
VALUE rb_ll2inum(LONG_LONG);
|
||||
#define LL2NUM(v) rb_ll2inum(v)
|
||||
VALUE rb_ull2inum _((unsigned LONG_LONG));
|
||||
VALUE rb_ull2inum(unsigned LONG_LONG);
|
||||
#define ULL2NUM(v) rb_ull2inum(v)
|
||||
#endif
|
||||
|
||||
|
@ -229,20 +229,20 @@ VALUE rb_ull2inum _((unsigned LONG_LONG));
|
|||
|
||||
#define TYPE(x) rb_type((VALUE)(x))
|
||||
|
||||
void rb_check_type _((VALUE,int));
|
||||
void rb_check_type(VALUE,int);
|
||||
#define Check_Type(v,t) rb_check_type((VALUE)(v),t)
|
||||
|
||||
VALUE rb_str_to_str _((VALUE));
|
||||
VALUE rb_string_value _((volatile VALUE*));
|
||||
char *rb_string_value_ptr _((volatile VALUE*));
|
||||
char *rb_string_value_cstr _((volatile VALUE*));
|
||||
VALUE rb_str_to_str(VALUE);
|
||||
VALUE rb_string_value(volatile VALUE*);
|
||||
char *rb_string_value_ptr(volatile VALUE*);
|
||||
char *rb_string_value_cstr(volatile VALUE*);
|
||||
|
||||
#define StringValue(v) rb_string_value(&(v))
|
||||
#define StringValuePtr(v) rb_string_value_ptr(&(v))
|
||||
#define StringValueCStr(v) rb_string_value_cstr(&(v))
|
||||
|
||||
void rb_check_safe_obj _((VALUE));
|
||||
void rb_check_safe_str _((VALUE));
|
||||
void rb_check_safe_obj(VALUE);
|
||||
void rb_check_safe_str(VALUE);
|
||||
#define SafeStringValue(v) do {\
|
||||
StringValue(v);\
|
||||
rb_check_safe_obj(v);\
|
||||
|
@ -250,27 +250,27 @@ void rb_check_safe_str _((VALUE));
|
|||
/* obsolete macro - use SafeStringValue(v) */
|
||||
#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
|
||||
|
||||
VALUE rb_get_path _((VALUE));
|
||||
VALUE rb_get_path(VALUE);
|
||||
#define FilePathValue(v) ((v) = rb_get_path(v))
|
||||
|
||||
void rb_secure _((int));
|
||||
void rb_secure(int);
|
||||
RUBY_EXTERN int ruby_safe_level;
|
||||
#define rb_safe_level() (ruby_safe_level)
|
||||
void rb_set_safe_level _((int));
|
||||
void rb_secure_update _((VALUE));
|
||||
void rb_set_safe_level(int);
|
||||
void rb_secure_update(VALUE);
|
||||
|
||||
long rb_num2long _((VALUE));
|
||||
unsigned long rb_num2ulong _((VALUE));
|
||||
long rb_num2long(VALUE);
|
||||
unsigned long rb_num2ulong(VALUE);
|
||||
#define NUM2LONG(x) (FIXNUM_P(x)?FIX2LONG(x):rb_num2long((VALUE)x))
|
||||
#define NUM2ULONG(x) rb_num2ulong((VALUE)x)
|
||||
#if SIZEOF_INT < SIZEOF_LONG
|
||||
long rb_num2int _((VALUE));
|
||||
long rb_num2int(VALUE);
|
||||
#define NUM2INT(x) (FIXNUM_P(x)?FIX2INT(x):rb_num2int((VALUE)x))
|
||||
long rb_fix2int _((VALUE));
|
||||
long rb_fix2int(VALUE);
|
||||
#define FIX2INT(x) rb_fix2int((VALUE)x)
|
||||
unsigned long rb_num2uint _((VALUE));
|
||||
unsigned long rb_num2uint(VALUE);
|
||||
#define NUM2UINT(x) rb_num2uint(x)
|
||||
unsigned long rb_fix2uint _((VALUE));
|
||||
unsigned long rb_fix2uint(VALUE);
|
||||
#define FIX2UINT(x) rb_fix2uint(x)
|
||||
#else
|
||||
#define NUM2INT(x) ((int)NUM2LONG(x))
|
||||
|
@ -280,8 +280,8 @@ unsigned long rb_fix2uint _((VALUE));
|
|||
#endif
|
||||
|
||||
#if HAVE_LONG_LONG
|
||||
LONG_LONG rb_num2ll _((VALUE));
|
||||
unsigned LONG_LONG rb_num2ull _((VALUE));
|
||||
LONG_LONG rb_num2ll(VALUE);
|
||||
unsigned LONG_LONG rb_num2ull(VALUE);
|
||||
# define NUM2LL(x) (FIXNUM_P(x)?FIX2LONG(x):rb_num2ll((VALUE)x))
|
||||
# define NUM2ULL(x) rb_num2ull((VALUE)x)
|
||||
#endif
|
||||
|
@ -292,11 +292,11 @@ unsigned LONG_LONG rb_num2ull _((VALUE));
|
|||
# define NUM2OFFT(x) NUM2LONG(x)
|
||||
#endif
|
||||
|
||||
double rb_num2dbl _((VALUE));
|
||||
double rb_num2dbl(VALUE);
|
||||
#define NUM2DBL(x) rb_num2dbl((VALUE)(x))
|
||||
|
||||
/* obsolete API - use StringValue() */
|
||||
char *rb_str2cstr _((VALUE,long*));
|
||||
char *rb_str2cstr(VALUE,long*);
|
||||
/* obsolete API - use StringValuePtr() */
|
||||
#define STR2CSTR(x) rb_str2cstr((VALUE)(x),0)
|
||||
|
||||
|
@ -304,7 +304,7 @@ char *rb_str2cstr _((VALUE,long*));
|
|||
RSTRING(x)->ptr[0]:(char)(NUM2INT(x)&0xff))
|
||||
#define CHR2FIX(x) INT2FIX((long)((x)&0xff))
|
||||
|
||||
VALUE rb_newobj _((void));
|
||||
VALUE rb_newobj(void);
|
||||
#define NEWOBJ(obj,type) type *obj = (type*)rb_newobj()
|
||||
#define OBJSETUP(obj,c,t) do {\
|
||||
RBASIC(obj)->flags = (t);\
|
||||
|
@ -386,8 +386,8 @@ struct RFile {
|
|||
|
||||
struct RData {
|
||||
struct RBasic basic;
|
||||
void (*dmark) _((void*));
|
||||
void (*dfree) _((void*));
|
||||
void (*dmark)(void*);
|
||||
void (*dfree)(void*);
|
||||
void *data;
|
||||
};
|
||||
|
||||
|
@ -396,9 +396,9 @@ struct RData {
|
|||
/*
|
||||
#define RUBY_DATA_FUNC(func) ((void (*)_((void*)))func)
|
||||
*/
|
||||
typedef void (*RUBY_DATA_FUNC) _((void*));
|
||||
typedef void (*RUBY_DATA_FUNC)(void*);
|
||||
|
||||
VALUE rb_data_object_alloc _((VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC));
|
||||
VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
|
||||
|
||||
#define Data_Wrap_Struct(klass,mark,free,sval)\
|
||||
rb_data_object_alloc(klass,sval,(RUBY_DATA_FUNC)mark,(RUBY_DATA_FUNC)free)
|
||||
|
@ -487,98 +487,98 @@ struct RBignum {
|
|||
#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
|
||||
#define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
|
||||
|
||||
void rb_obj_infect _((VALUE,VALUE));
|
||||
void rb_obj_infect(VALUE,VALUE);
|
||||
|
||||
void rb_glob _((const char*,void(*)(const char*,VALUE),VALUE));
|
||||
void rb_glob(const char*,void(*)(const char*,VALUE),VALUE);
|
||||
|
||||
VALUE rb_define_class _((const char*,VALUE));
|
||||
VALUE rb_define_module _((const char*));
|
||||
VALUE rb_define_class_under _((VALUE, const char*, VALUE));
|
||||
VALUE rb_define_module_under _((VALUE, const char*));
|
||||
VALUE rb_define_class(const char*,VALUE);
|
||||
VALUE rb_define_module(const char*);
|
||||
VALUE rb_define_class_under(VALUE, const char*, VALUE);
|
||||
VALUE rb_define_module_under(VALUE, const char*);
|
||||
|
||||
void rb_include_module _((VALUE,VALUE));
|
||||
void rb_extend_object _((VALUE,VALUE));
|
||||
void rb_include_module(VALUE,VALUE);
|
||||
void rb_extend_object(VALUE,VALUE);
|
||||
|
||||
void rb_define_variable _((const char*,VALUE*));
|
||||
void rb_define_virtual_variable _((const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS)));
|
||||
void rb_define_hooked_variable _((const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS)));
|
||||
void rb_define_readonly_variable _((const char*,VALUE*));
|
||||
void rb_define_const _((VALUE,const char*,VALUE));
|
||||
void rb_define_global_const _((const char*,VALUE));
|
||||
void rb_define_variable(const char*,VALUE*);
|
||||
void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
|
||||
void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
|
||||
void rb_define_readonly_variable(const char*,VALUE*);
|
||||
void rb_define_const(VALUE,const char*,VALUE);
|
||||
void rb_define_global_const(const char*,VALUE);
|
||||
|
||||
#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))func)
|
||||
void rb_define_method _((VALUE,const char*,VALUE(*)(ANYARGS),int));
|
||||
void rb_define_module_function _((VALUE,const char*,VALUE(*)(ANYARGS),int));
|
||||
void rb_define_global_function _((const char*,VALUE(*)(ANYARGS),int));
|
||||
void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
|
||||
void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
|
||||
void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
|
||||
|
||||
void rb_undef_method _((VALUE,const char*));
|
||||
void rb_define_alias _((VALUE,const char*,const char*));
|
||||
void rb_define_attr _((VALUE,const char*,int,int));
|
||||
void rb_undef_method(VALUE,const char*);
|
||||
void rb_define_alias(VALUE,const char*,const char*);
|
||||
void rb_define_attr(VALUE,const char*,int,int);
|
||||
|
||||
void rb_global_variable _((VALUE*));
|
||||
void rb_gc_register_address _((VALUE*));
|
||||
void rb_gc_unregister_address _((VALUE*));
|
||||
void rb_global_variable(VALUE*);
|
||||
void rb_gc_register_address(VALUE*);
|
||||
void rb_gc_unregister_address(VALUE*);
|
||||
|
||||
ID rb_intern _((const char*));
|
||||
char *rb_id2name _((ID));
|
||||
ID rb_to_id _((VALUE));
|
||||
ID rb_intern(const char*);
|
||||
char *rb_id2name(ID);
|
||||
ID rb_to_id(VALUE);
|
||||
|
||||
char *rb_class2name _((VALUE));
|
||||
char *rb_obj_classname _((VALUE));
|
||||
char *rb_class2name(VALUE);
|
||||
char *rb_obj_classname(VALUE);
|
||||
|
||||
void rb_p _((VALUE));
|
||||
void rb_p(VALUE);
|
||||
|
||||
VALUE rb_eval_string _((const char*));
|
||||
VALUE rb_eval_string_protect _((const char*, int*));
|
||||
VALUE rb_eval_string_wrap _((const char*, int*));
|
||||
VALUE rb_funcall __((VALUE, ID, int, ...));
|
||||
VALUE rb_funcall2 _((VALUE, ID, int, const VALUE*));
|
||||
VALUE rb_funcall3 _((VALUE, ID, int, const VALUE*));
|
||||
int rb_scan_args __((int, const VALUE*, const char*, ...));
|
||||
VALUE rb_call_super _((int, const VALUE*));
|
||||
VALUE rb_eval_string(const char*);
|
||||
VALUE rb_eval_string_protect(const char*, int*);
|
||||
VALUE rb_eval_string_wrap(const char*, int*);
|
||||
VALUE rb_funcall(VALUE, ID, int, ...);
|
||||
VALUE rb_funcall2(VALUE, ID, int, const VALUE*);
|
||||
VALUE rb_funcall3(VALUE, ID, int, const VALUE*);
|
||||
int rb_scan_args(int, const VALUE*, const char*, ...);
|
||||
VALUE rb_call_super(int, const VALUE*);
|
||||
|
||||
VALUE rb_gv_set _((const char*, VALUE));
|
||||
VALUE rb_gv_get _((const char*));
|
||||
VALUE rb_iv_get _((VALUE, const char*));
|
||||
VALUE rb_iv_set _((VALUE, const char*, VALUE));
|
||||
VALUE rb_gv_set(const char*, VALUE);
|
||||
VALUE rb_gv_get(const char*);
|
||||
VALUE rb_iv_get(VALUE, const char*);
|
||||
VALUE rb_iv_set(VALUE, const char*, VALUE);
|
||||
|
||||
VALUE rb_equal _((VALUE,VALUE));
|
||||
VALUE rb_equal(VALUE,VALUE);
|
||||
|
||||
RUBY_EXTERN VALUE ruby_verbose, ruby_debug;
|
||||
|
||||
PRINTF_ARGS(NORETURN(void rb_raise __((VALUE, const char*, ...))), 2, 3);
|
||||
PRINTF_ARGS(NORETURN(void rb_fatal __((const char*, ...))), 1, 2);
|
||||
PRINTF_ARGS(NORETURN(void rb_bug __((const char*, ...))), 1, 2);
|
||||
NORETURN(void rb_sys_fail _((const char*)));
|
||||
NORETURN(void rb_iter_break _((void)));
|
||||
NORETURN(void rb_exit _((int)));
|
||||
NORETURN(void rb_notimplement _((void)));
|
||||
PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
|
||||
PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
|
||||
NORETURN(void rb_sys_fail(const char*));
|
||||
NORETURN(void rb_iter_break(void));
|
||||
NORETURN(void rb_exit(int));
|
||||
NORETURN(void rb_notimplement(void));
|
||||
|
||||
/* reports if `-w' specified */
|
||||
PRINTF_ARGS(void rb_warning __((const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
|
||||
/* reports if `-w' specified */
|
||||
PRINTF_ARGS(void rb_sys_warning __((const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
|
||||
/* reports always */
|
||||
PRINTF_ARGS(void rb_warn __((const char*, ...)), 1, 2);
|
||||
PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
|
||||
|
||||
VALUE rb_each _((VALUE));
|
||||
VALUE rb_yield _((VALUE));
|
||||
VALUE rb_yield_values __((int n, ...));
|
||||
VALUE rb_yield_splat _((VALUE));
|
||||
int rb_block_given_p _((void));
|
||||
void rb_need_block _((void));
|
||||
VALUE rb_iterate _((VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE));
|
||||
VALUE rb_rescue _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));
|
||||
VALUE rb_rescue2 __((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...));
|
||||
VALUE rb_ensure _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));
|
||||
VALUE rb_catch _((const char*,VALUE(*)(ANYARGS),VALUE));
|
||||
NORETURN(void rb_throw _((const char*,VALUE)));
|
||||
VALUE rb_each(VALUE);
|
||||
VALUE rb_yield(VALUE);
|
||||
VALUE rb_yield_values(int n, ...);
|
||||
VALUE rb_yield_splat(VALUE);
|
||||
int rb_block_given_p(void);
|
||||
void rb_need_block(void);
|
||||
VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
|
||||
VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
|
||||
VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
|
||||
VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
|
||||
VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
|
||||
NORETURN(void rb_throw(const char*,VALUE));
|
||||
|
||||
VALUE rb_require _((const char*));
|
||||
VALUE rb_require(const char*);
|
||||
|
||||
void ruby_init _((void));
|
||||
void ruby_options _((int, char**));
|
||||
NORETURN(void ruby_run _((void)));
|
||||
void ruby_init(void);
|
||||
void ruby_options(int, char**);
|
||||
NORETURN(void ruby_run(void));
|
||||
|
||||
RUBY_EXTERN VALUE rb_mKernel;
|
||||
RUBY_EXTERN VALUE rb_mComparable;
|
||||
|
@ -726,12 +726,12 @@ typedef DWORD rb_nativethread_t;
|
|||
# define HAVE_NATIVETHREAD
|
||||
#endif
|
||||
#ifdef HAVE_NATIVETHREAD
|
||||
int is_ruby_native_thread _((void));
|
||||
int is_ruby_native_thread(void);
|
||||
#else
|
||||
#define is_ruby_native_thread() (1)
|
||||
#endif
|
||||
#ifdef HAVE_NATIVETHREAD_KILL
|
||||
void ruby_native_thread_kill _((int));
|
||||
void ruby_native_thread_kill(int);
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
|
|
44
rubyio.h
44
rubyio.h
|
@ -27,7 +27,7 @@ typedef struct OpenFile {
|
|||
int pid; /* child's pid (for pipes) */
|
||||
int lineno; /* number of lines read */
|
||||
char *path; /* pathname for file */
|
||||
void (*finalize) _((struct OpenFile*,int)); /* finalize proc */
|
||||
void (*finalize)(struct OpenFile*,int); /* finalize proc */
|
||||
long refcnt;
|
||||
char *wbuf; /* wbuf_off + wbuf_len <= wbuf_capa */
|
||||
int wbuf_off;
|
||||
|
@ -81,28 +81,28 @@ typedef struct OpenFile {
|
|||
|
||||
FILE *rb_io_stdio_file(OpenFile *fptr);
|
||||
|
||||
FILE *rb_fopen _((const char*, const char*));
|
||||
FILE *rb_fdopen _((int, const char*));
|
||||
int rb_io_mode_flags _((const char*));
|
||||
int rb_io_modenum_flags _((int));
|
||||
void rb_io_check_writable _((OpenFile*));
|
||||
void rb_io_check_readable _((OpenFile*));
|
||||
int rb_io_fptr_finalize _((OpenFile*));
|
||||
void rb_io_synchronized _((OpenFile*));
|
||||
void rb_io_check_initialized _((OpenFile*));
|
||||
void rb_io_check_closed _((OpenFile*));
|
||||
int rb_io_wait_readable _((int));
|
||||
int rb_io_wait_writable _((int));
|
||||
FILE *rb_fopen(const char*, const char*);
|
||||
FILE *rb_fdopen(int, const char*);
|
||||
int rb_io_mode_flags(const char*);
|
||||
int rb_io_modenum_flags(int);
|
||||
void rb_io_check_writable(OpenFile*);
|
||||
void rb_io_check_readable(OpenFile*);
|
||||
int rb_io_fptr_finalize(OpenFile*);
|
||||
void rb_io_synchronized(OpenFile*);
|
||||
void rb_io_check_initialized(OpenFile*);
|
||||
void rb_io_check_closed(OpenFile*);
|
||||
int rb_io_wait_readable(int);
|
||||
int rb_io_wait_writable(int);
|
||||
|
||||
VALUE rb_io_taint_check _((VALUE));
|
||||
NORETURN(void rb_eof_error _((void)));
|
||||
VALUE rb_io_taint_check(VALUE);
|
||||
NORETURN(void rb_eof_error(void));
|
||||
|
||||
void rb_io_read_check _((OpenFile*));
|
||||
int rb_io_read_pending _((OpenFile*));
|
||||
void rb_read_check _((FILE*));
|
||||
void rb_io_read_check(OpenFile*);
|
||||
int rb_io_read_pending(OpenFile*);
|
||||
void rb_read_check(FILE*);
|
||||
|
||||
DEPRECATED(int rb_getc _((FILE*)));
|
||||
DEPRECATED(long rb_io_fread _((char *, long, FILE *)));
|
||||
DEPRECATED(long rb_io_fwrite _((const char *, long, FILE *)));
|
||||
DEPRECATED(int rb_read_pending _((FILE*)));
|
||||
DEPRECATED(int rb_getc(FILE*));
|
||||
DEPRECATED(long rb_io_fread(char *, long, FILE *));
|
||||
DEPRECATED(long rb_io_fwrite(const char *, long, FILE *));
|
||||
DEPRECATED(int rb_read_pending(FILE*));
|
||||
#endif
|
||||
|
|
|
@ -72,13 +72,13 @@ RUBY_EXTERN int rb_prohibit_interrupt;
|
|||
} while (0)
|
||||
#define ENABLE_INTS (rb_prohibit_interrupt--)
|
||||
|
||||
VALUE rb_with_disable_interrupt _((VALUE(*)(ANYARGS),VALUE));
|
||||
VALUE rb_with_disable_interrupt(VALUE(*)(ANYARGS),VALUE);
|
||||
|
||||
RUBY_EXTERN rb_atomic_t rb_trap_pending;
|
||||
void rb_trap_restore_mask _((void));
|
||||
void rb_trap_restore_mask(void);
|
||||
|
||||
RUBY_EXTERN int rb_thread_critical;
|
||||
void rb_thread_schedule _((void));
|
||||
void rb_thread_schedule(void);
|
||||
#if defined(HAVE_SETITIMER)
|
||||
RUBY_EXTERN int rb_thread_pending;
|
||||
# define CHECK_INTS do {\
|
||||
|
|
2
signal.c
2
signal.c
|
@ -445,7 +445,7 @@ sigsend_to_ruby_thread(int sig)
|
|||
#endif
|
||||
}
|
||||
|
||||
static RETSIGTYPE sighandler _((int));
|
||||
static RETSIGTYPE sighandler(int);
|
||||
static RETSIGTYPE
|
||||
sighandler(int sig)
|
||||
{
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
#define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */
|
||||
|
||||
static void fmt_setup _((char*,int,int,int,int));
|
||||
static void fmt_setup(char*,int,int,int,int);
|
||||
|
||||
static char*
|
||||
remove_sign_bits(char *str, int base)
|
||||
|
|
30
st.h
30
st.h
|
@ -38,21 +38,21 @@ enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK};
|
|||
# endif
|
||||
#endif
|
||||
|
||||
st_table *st_init_table _((struct st_hash_type *));
|
||||
st_table *st_init_table_with_size _((struct st_hash_type *, int));
|
||||
st_table *st_init_numtable _((void));
|
||||
st_table *st_init_numtable_with_size _((int));
|
||||
st_table *st_init_strtable _((void));
|
||||
st_table *st_init_strtable_with_size _((int));
|
||||
int st_delete _((st_table *, st_data_t *, st_data_t *));
|
||||
int st_delete_safe _((st_table *, st_data_t *, st_data_t *, st_data_t));
|
||||
int st_insert _((st_table *, st_data_t, st_data_t));
|
||||
int st_lookup _((st_table *, st_data_t, st_data_t *));
|
||||
int st_foreach _((st_table *, int (*)(ANYARGS), st_data_t));
|
||||
void st_add_direct _((st_table *, st_data_t, st_data_t));
|
||||
void st_free_table _((st_table *));
|
||||
void st_cleanup_safe _((st_table *, st_data_t));
|
||||
st_table *st_copy _((st_table *));
|
||||
st_table *st_init_table(struct st_hash_type *);
|
||||
st_table *st_init_table_with_size(struct st_hash_type *, int);
|
||||
st_table *st_init_numtable(void);
|
||||
st_table *st_init_numtable_with_size(int);
|
||||
st_table *st_init_strtable(void);
|
||||
st_table *st_init_strtable_with_size(int);
|
||||
int st_delete(st_table *, st_data_t *, st_data_t *);
|
||||
int st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t);
|
||||
int st_insert(st_table *, st_data_t, st_data_t);
|
||||
int st_lookup(st_table *, st_data_t, st_data_t *);
|
||||
int st_foreach(st_table *, int (*)(ANYARGS), st_data_t);
|
||||
void st_add_direct(st_table *, st_data_t, st_data_t);
|
||||
void st_free_table(st_table *);
|
||||
void st_cleanup_safe(st_table *, st_data_t);
|
||||
st_table *st_copy(st_table *);
|
||||
|
||||
#define ST_NUMCMP ((int (*)()) 0)
|
||||
#define ST_NUMHASH ((int (*)()) -2)
|
||||
|
|
6
string.c
6
string.c
|
@ -270,7 +270,7 @@ rb_obj_as_string(VALUE obj)
|
|||
return str;
|
||||
}
|
||||
|
||||
static VALUE rb_str_replace _((VALUE, VALUE));
|
||||
static VALUE rb_str_replace(VALUE, VALUE);
|
||||
|
||||
VALUE
|
||||
rb_str_dup(VALUE str)
|
||||
|
@ -1203,7 +1203,7 @@ rb_str_match(VALUE x, VALUE y)
|
|||
}
|
||||
|
||||
|
||||
static VALUE get_pat _((VALUE, int));
|
||||
static VALUE get_pat(VALUE, int);
|
||||
|
||||
|
||||
/*
|
||||
|
@ -2848,7 +2848,7 @@ trnext(struct tr *t)
|
|||
}
|
||||
}
|
||||
|
||||
static VALUE rb_str_delete_bang _((int,VALUE*,VALUE));
|
||||
static VALUE rb_str_delete_bang(int,VALUE*,VALUE);
|
||||
|
||||
static VALUE
|
||||
tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
|
||||
|
|
2
struct.c
2
struct.c
|
@ -14,7 +14,7 @@
|
|||
|
||||
VALUE rb_cStruct;
|
||||
|
||||
static VALUE struct_alloc _((VALUE));
|
||||
static VALUE struct_alloc(VALUE);
|
||||
|
||||
VALUE
|
||||
rb_struct_iv_get(VALUE c, char *name)
|
||||
|
|
6
time.c
6
time.c
|
@ -373,9 +373,9 @@ time_arg(int argc, VALUE *argv, struct tm *tm, time_t *usec)
|
|||
rb_raise(rb_eArgError, "argument out of range");
|
||||
}
|
||||
|
||||
static VALUE time_gmtime _((VALUE));
|
||||
static VALUE time_localtime _((VALUE));
|
||||
static VALUE time_get_tm _((VALUE, int));
|
||||
static VALUE time_gmtime(VALUE);
|
||||
static VALUE time_localtime(VALUE);
|
||||
static VALUE time_get_tm(VALUE, int);
|
||||
|
||||
static int
|
||||
leap_year_p(long y)
|
||||
|
|
2
util.c
2
util.c
|
@ -22,7 +22,7 @@
|
|||
|
||||
#include "util.h"
|
||||
#ifndef HAVE_STRING_H
|
||||
char *strchr _((char*,char));
|
||||
char *strchr(char*,char);
|
||||
#endif
|
||||
|
||||
unsigned long
|
||||
|
|
16
util.h
16
util.h
|
@ -35,32 +35,32 @@
|
|||
#endif
|
||||
|
||||
#define scan_oct ruby_scan_oct
|
||||
unsigned long scan_oct _((const char*, int, int*));
|
||||
unsigned long scan_oct(const char*, int, int*);
|
||||
#define scan_hex ruby_scan_hex
|
||||
unsigned long scan_hex _((const char*, int, int*));
|
||||
unsigned long scan_hex(const char*, int, int*);
|
||||
|
||||
#if defined(MSDOS) || defined(__CYGWIN32__) || defined(_WIN32)
|
||||
void ruby_add_suffix(VALUE str, char *suffix);
|
||||
#endif
|
||||
|
||||
void ruby_qsort _((void*, const int, const int, int (*)(), void*));
|
||||
void ruby_qsort(void*, const int, const int, int (*)(), void*);
|
||||
#define qsort(b,n,s,c,d) ruby_qsort(b,n,s,c,d)
|
||||
|
||||
void ruby_setenv _((const char*, const char*));
|
||||
void ruby_unsetenv _((const char*));
|
||||
void ruby_setenv(const char*, const char*);
|
||||
void ruby_unsetenv(const char*);
|
||||
#undef setenv
|
||||
#undef unsetenv
|
||||
#define setenv(name,val) ruby_setenv(name,val)
|
||||
#define unsetenv(name,val) ruby_unsetenv(name);
|
||||
|
||||
char *ruby_strdup _((const char*));
|
||||
char *ruby_strdup(const char*);
|
||||
#undef strdup
|
||||
#define strdup(s) ruby_strdup(s)
|
||||
|
||||
char *ruby_getcwd _((void));
|
||||
char *ruby_getcwd(void);
|
||||
#define my_getcwd() ruby_getcwd()
|
||||
|
||||
double ruby_strtod _((const char*, char **));
|
||||
double ruby_strtod(const char*, char **);
|
||||
#define strtod(s,e) ruby_strtod(s,e)
|
||||
|
||||
#endif /* UTIL_H */
|
||||
|
|
|
@ -1091,7 +1091,7 @@ rb_obj_remove_instance_variable(VALUE obj, VALUE name)
|
|||
return Qnil; /* not reached */
|
||||
}
|
||||
|
||||
NORETURN(static void uninitialized_constant _((VALUE, ID)));
|
||||
NORETURN(static void uninitialized_constant(VALUE, ID));
|
||||
static void
|
||||
uninitialized_constant(VALUE klass, ID id)
|
||||
{
|
||||
|
|
Loading…
Add table
Reference in a new issue