ruby-changes:5047
From: ko1 <ko1@a...>
Date: Fri, 23 May 2008 01:19:40 +0900 (JST)
Subject: [ruby-changes:5047] Ruby:r16540 (trunk): * eval.c, eval_intern.h, include/ruby/intern.h, include/ruby/ruby.h,
ko1 2008-05-23 01:19:14 +0900 (Fri, 23 May 2008)
New Revision: 16540
Modified files:
trunk/ChangeLog
trunk/eval.c
trunk/eval_intern.h
trunk/include/ruby/intern.h
trunk/include/ruby/ruby.h
trunk/version.h
trunk/vm.c
trunk/vm_core.h
trunk/vm_insnhelper.c
Log:
* eval.c, eval_intern.h, include/ruby/intern.h, include/ruby/ruby.h,
vm.c, vm_core.h, vm_insnhelper.c: remove pointless "const".
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/include/ruby/ruby.h?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/version.h?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/ChangeLog?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/eval.c?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/vm_core.h?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/vm.c?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/vm_insnhelper.c?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/include/ruby/intern.h?r1=16540&r2=16539&diff_format=u
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/eval_intern.h?r1=16540&r2=16539&diff_format=u
Index: eval_intern.h
===================================================================
--- eval_intern.h (revision 16539)
+++ eval_intern.h (revision 16540)
@@ -222,21 +222,19 @@
NORETURN(void rb_raise_jump(VALUE));
NORETURN(void rb_print_undef(VALUE, ID, int));
-NORETURN(void vm_localjump_error(const char * const, const VALUE, const int));
-NORETURN(void vm_jump_tag_but_local_jump(const int, const VALUE));
+NORETURN(void vm_localjump_error(const char *,VALUE, int));
+NORETURN(void vm_jump_tag_but_local_jump(int, VALUE));
-NODE *vm_cref_push(rb_thread_t * const th, const VALUE, const int);
-NODE *vm_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE * cref_stack);
-VALUE vm_make_jump_tag_but_local_jump(const int state, VALUE val);
+NODE *vm_cref_push(rb_thread_t * th, VALUE, int);
+NODE *vm_set_special_cref(rb_thread_t *th, VALUE *lfp, NODE *cref_stack);
+VALUE vm_make_jump_tag_but_local_jump(int state, VALUE val);
NODE *ruby_cref(void);
rb_control_frame_t *vm_get_ruby_level_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
VALUE rb_obj_is_proc(VALUE);
-void rb_vm_check_redefinition_opt_method(NODE * const node);
-VALUE rb_vm_call_cfunc(const VALUE recv, VALUE (* const func)(VALUE),
- const VALUE arg, rb_block_t * const blockptr,
- const VALUE filename);
+void rb_vm_check_redefinition_opt_method(const NODE *node);
+VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename);
void rb_thread_terminate_all(void);
-void rb_vm_set_eval_stack(rb_thread_t * const, const VALUE iseq, NODE * const cref);
+void rb_vm_set_eval_stack(rb_thread_t *, VALUE iseq, const NODE *cref);
VALUE rb_vm_top_self();
VALUE rb_vm_cbase(void);
Index: include/ruby/intern.h
===================================================================
--- include/ruby/intern.h (revision 16539)
+++ include/ruby/intern.h (revision 16540)
@@ -277,7 +277,7 @@
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 (* const)(VALUE), const VALUE, int* const);
+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);
@@ -438,9 +438,9 @@
int rb_sym_interned_p(VALUE);
void rb_gc_mark_symbols(void);
VALUE rb_backref_get(void);
-void rb_backref_set(const VALUE);
+void rb_backref_set(VALUE);
VALUE rb_lastline_get(void);
-void rb_lastline_set(const VALUE);
+void rb_lastline_set(VALUE);
VALUE rb_sym_all_symbols(void);
/* process.c */
void rb_last_status_set(int status, rb_pid_t pid);
@@ -662,7 +662,7 @@
VALUE rb_time_succ(VALUE);
void Init_stack(VALUE*);
void rb_frame_pop(void);
-int rb_frame_method_id_and_class(ID * const idp, VALUE * const klassp);
+int rb_frame_method_id_and_class(ID *idp, VALUE *klassp);
#if defined(__cplusplus)
#if 0
Index: include/ruby/ruby.h
===================================================================
--- include/ruby/ruby.h (revision 16539)
+++ include/ruby/ruby.h (revision 16540)
@@ -788,7 +788,7 @@
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(const int, const VALUE* const);
+VALUE rb_call_super(int, const VALUE*);
VALUE rb_gv_set(const char*, VALUE);
VALUE rb_gv_get(const char*);
@@ -817,17 +817,17 @@
typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*);
-VALUE rb_each(const VALUE);
-VALUE rb_yield(const VALUE);
-VALUE rb_yield_values(const int n, ...);
-VALUE rb_yield_values2(const int n, VALUE * const argv);
-VALUE rb_yield_splat(const VALUE);
+VALUE rb_each(VALUE);
+VALUE rb_yield(VALUE);
+VALUE rb_yield_values(int n, ...);
+VALUE rb_yield_values2(int n, const VALUE *argv);
+VALUE rb_yield_splat(VALUE);
int rb_block_given_p(void);
void rb_need_block(void);
-VALUE rb_iterate(VALUE(* const)(VALUE),const VALUE,VALUE(* const)(ANYARGS),const VALUE);
-VALUE rb_block_call(const VALUE,const ID,const int,VALUE* const,VALUE(* const)(ANYARGS),const VALUE);
-VALUE rb_rescue(VALUE(* const)(ANYARGS),const VALUE,VALUE(* const)(ANYARGS),const VALUE);
-VALUE rb_rescue2(VALUE(* const)(ANYARGS),const VALUE,VALUE(* const)(ANYARGS),VALUE,...);
+VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_block_call(VALUE,ID,int,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);
VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
Index: ChangeLog
===================================================================
--- ChangeLog (revision 16539)
+++ ChangeLog (revision 16540)
@@ -1,3 +1,8 @@
+Fri May 23 01:15:09 2008 Koichi Sasada <ko1@a...>
+
+ * eval.c, eval_intern.h, include/ruby/intern.h, include/ruby/ruby.h,
+ vm.c, vm_core.h, vm_insnhelper.c: remove pointless "const".
+
Thu May 22 23:45:17 2008 Yusuke Endoh <mame@t...>
* compile.c (get_destination_insn, get_next_insn, get_prev_insn):
Index: vm_core.h
===================================================================
--- vm_core.h (revision 16539)
+++ vm_core.h (revision 16540)
@@ -586,7 +586,7 @@
/* VM related object allocate functions */
/* TODO: should be static functions */
-VALUE rb_thread_alloc(const VALUE klass);
+VALUE rb_thread_alloc(VALUE klass);
VALUE rb_proc_alloc(VALUE klass);
/* for debug */
@@ -598,28 +598,22 @@
/* functions about thread/vm execution */
-VALUE rb_iseq_eval(const VALUE iseqval);
+VALUE rb_iseq_eval(VALUE iseqval);
void rb_enable_interrupt(void);
void rb_disable_interrupt(void);
-int rb_thread_method_id_and_class(rb_thread_t * const th, ID * const idp,
- VALUE * const klassp);
+int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp);
-VALUE vm_eval_body(rb_thread_t * const th);
-VALUE vm_invoke_proc(rb_thread_t *const th, rb_proc_t * const proc,
- const VALUE self, const int argc, const VALUE * const argv,
- rb_block_t * const blockptr);
-VALUE vm_make_proc(rb_thread_t * const th, rb_control_frame_t *const cfp,
- rb_block_t * const block);
-VALUE vm_make_env_object(rb_thread_t * const th, rb_control_frame_t *cfp);
-VALUE vm_backtrace(rb_thread_t * const, int);
+VALUE vm_eval_body(rb_thread_t *th);
+VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self,
+ int argc, const VALUE *argv, rb_block_t *blockptr);
+VALUE vm_make_proc(rb_thread_t *th, rb_control_frame_t *cfp, const rb_block_t *block);
+VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
+VALUE vm_backtrace(rb_thread_t *, int);
-VALUE vm_yield(rb_thread_t * const th, const int argc,
- const VALUE * const argv);
-VALUE vm_yield_with_cref(rb_thread_t * const th, const int argc,
- const VALUE * const argv, NODE * const cref);
-VALUE vm_call0(rb_thread_t * const th, const VALUE klass, const VALUE recv,
- const VALUE id, const ID oid, const int argc,
- const VALUE * const argv, NODE *const body, const int nosuper);
+VALUE vm_yield(rb_thread_t *th, int argc, const VALUE *argv);
+VALUE vm_yield_with_cref(rb_thread_t *th, int argc, const VALUE *argv, const NODE *cref);
+VALUE vm_call0(rb_thread_t *th, VALUE klass, VALUE recv, VALUE id, ID oid,
+ int argc, const VALUE *argv, const NODE *body, int nosuper);
int vm_get_sourceline(rb_control_frame_t *);
Index: eval.c
===================================================================
--- eval.c (revision 16539)
+++ eval.c (revision 16540)
@@ -14,7 +14,7 @@
#include "eval_intern.h"
VALUE proc_invoke(VALUE, VALUE, VALUE, VALUE);
-VALUE rb_binding_new();
+VALUE rb_binding_new(void);
VALUE rb_f_block_given_p(void);
@@ -34,7 +34,7 @@
static VALUE eval_string(VALUE, VALUE, VALUE, const char *, int);
-static inline VALUE rb_yield_0(const int argc, const VALUE * const argv);
+static inline VALUE rb_yield_0(int argc, const VALUE *argv);
static VALUE rb_call(VALUE, VALUE, ID, int, const VALUE *, int);
#include "eval_error.c"
@@ -909,13 +909,13 @@
}
static inline VALUE
-rb_yield_0(const int argc, const VALUE * const argv)
+rb_yield_0(int argc, const VALUE * argv)
{
return vm_yield(GET_THREAD(), argc, argv);
}
VALUE
-rb_yield(const VALUE val)
+rb_yield(VALUE val)
{
volatile VALUE tmp = val;
if (val == Qundef) {
@@ -928,7 +928,7 @@
}
VALUE
-rb_yield_values(const int n, ...)
+rb_yield_values(int n, ...)
{
int i;
VALUE *argv;
@@ -950,13 +950,13 @@
}
VALUE
-rb_yield_values2(const int argc, VALUE * const argv)
+rb_yield_values2(int argc, const VALUE *argv)
{
return rb_yield_0(argc, argv);
}
VALUE
-rb_yield_splat(const VALUE values)
+rb_yield_splat(VALUE values)
{
VALUE tmp = rb_check_array_type(values);
volatile VALUE v;
@@ -1000,8 +1000,8 @@
}
VALUE
-rb_iterate(VALUE (* const it_proc) (VALUE), const VALUE data1,
- VALUE (* const bl_proc) (ANYARGS), VALUE const data2)
+rb_iterate(VALUE (* it_proc) (VALUE), VALUE data1,
+ VALUE (* bl_proc) (ANYARGS), VALUE data2)
{
int state;
volatile VALUE retval = Qnil;
@@ -1069,9 +1069,9 @@
};
static VALUE
-iterate_method(const VALUE obj)
+iterate_method(VALUE obj)
{
- const struct iter_method_arg * const arg =
+ const struct iter_method_arg * arg =
(struct iter_method_arg *) obj;
return rb_call(CLASS_OF(arg->obj), arg->obj, arg->mid,
@@ -1079,8 +1079,8 @@
}
VALUE
-rb_block_call(const VALUE obj, const ID mid, const int argc, VALUE * const argv,
- VALUE (*const bl_proc) (ANYARGS), const VALUE data2)
+rb_block_call(VALUE obj, ID mid, int argc, VALUE * argv,
+ VALUE (*bl_proc) (ANYARGS), VALUE data2)
{
struct iter_method_arg arg;
@@ -1092,17 +1092,17 @@
}
VALUE
-rb_each(const VALUE obj)
+rb_each(VALUE obj)
{
return rb_call(CLASS_OF(obj), obj, idEach, 0, 0, CALL_FCALL);
}
VALUE
-rb_rescue2(VALUE (* const b_proc) (ANYARGS), const VALUE data1,
- VALUE (* const r_proc) (ANYARGS), VALUE data2, ...)
+rb_rescue2(VALUE (* b_proc) (ANYARGS), VALUE data1,
+ VALUE (* r_proc) (ANYARGS), VALUE data2, ...)
{
int state;
- rb_thread_t * const th = GET_THREAD();
+ rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th->cfp;
volatile VALUE result;
volatile VALUE e_info = th->errinfo;
@@ -1160,15 +1160,15 @@
}
VALUE
-rb_rescue(VALUE (* const b_proc)(ANYARGS), const VALUE data1,
- VALUE (* const r_proc)(ANYARGS), const VALUE data2)
+rb_rescue(VALUE (* b_proc)(ANYARGS), VALUE data1,
+ VALUE (* r_proc)(ANYARGS), VALUE data2)
{
return rb_rescue2(b_proc, data1, r_proc, data2, rb_eStandardError,
(VALUE)0);
}
VALUE
-rb_protect(VALUE (* const proc) (VALUE), const VALUE data, int * const state)
+rb_protect(VALUE (* proc) (VALUE), VALUE data, int * state)
{
VALUE result = Qnil; /* OK */
int status;
Index: vm.c
===================================================================
--- vm.c (revision 16539)
+++ vm.c (revision 16540)
@@ -49,7 +49,7 @@
/* control stack frame */
static inline VALUE
-rb_vm_set_finish_env(rb_thread_t * const th)
+rb_vm_set_finish_env(rb_thread_t * th)
{
vm_push_frame(th, 0, FRAME_MAGIC_FINISH,
Qnil, th->cfp->lfp[0], 0,
@@ -59,7 +59,7 @@
}
void
-rb_vm_set_top_stack(rb_thread_t * const th, const VALUE iseqval)
+rb_vm_set_top_stack(rb_thread_t * th, VALUE iseqval)
{
rb_iseq_t *iseq;
GetISeqPtr(iseqval, iseq);
@@ -77,7 +77,7 @@
}
void
-rb_vm_set_eval_stack(rb_thread_t * const th, const VALUE iseqval, NODE * const cref)
+rb_vm_set_eval_stack(rb_thread_t * th, VALUE iseqval, const NODE *cref)
{
rb_iseq_t *iseq;
rb_block_t * const block = th->base_block;
@@ -162,7 +162,7 @@
return obj;
}
-static VALUE check_env_value(const VALUE envval);
+static VALUE check_env_value(VALUE envval);
static int
check_env(rb_env_t * const env)
@@ -186,7 +186,7 @@
}
static VALUE
-check_env_value(const VALUE envval)
+check_env_value(VALUE envval)
{
rb_env_t *env;
GetEnvPtr(envval, env);
@@ -200,7 +200,7 @@
static VALUE
vm_make_env_each(rb_thread_t * const th, rb_control_frame_t * const cfp,
- VALUE * const envptr, VALUE * const endptr)
+ VALUE *envptr, VALUE * const endptr)
{
VALUE envval, penvval = 0;
rb_env_t *env;
@@ -317,7 +317,7 @@
}
VALUE
-vm_make_env_object(rb_thread_t * const th, rb_control_frame_t *cfp)
+vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp)
{
VALUE envval;
@@ -348,9 +348,8 @@
/* Proc */
static VALUE
-vm_make_proc_from_block(rb_thread_t * const th,
- rb_control_frame_t * const cfp,
- rb_block_t * const block)
+vm_make_proc_from_block(rb_thread_t *th, rb_control_frame_t *cfp,
+ rb_block_t *block)
{
VALUE procval;
rb_control_frame_t *bcfp;
@@ -367,8 +366,8 @@
}
VALUE
-vm_make_proc(rb_thread_t * const th,
- rb_control_frame_t * const cfp, rb_block_t * const block)
+vm_make_proc(rb_thread_t *th,
+ rb_control_frame_t *cfp, const rb_block_t *block)
{
VALUE procval, envval, blockprocval = 0;
rb_proc_t *proc;
@@ -415,9 +414,8 @@
/* C -> Ruby: method */
VALUE
-vm_call0(rb_thread_t * const th, const VALUE klass, const VALUE recv,
- const VALUE id, const ID oid, const int argc, const VALUE * const argv,
- NODE * const body, const int nosuper)
+vm_call0(rb_thread_t * th, VALUE klass, VALUE recv, VALUE id, ID oid,
+ int argc, const VALUE *argv, const NODE *body, int nosuper)
{
VALUE val;
rb_block_t *blockptr = 0;
@@ -540,7 +538,7 @@
}
VALUE
-rb_call_super(const int argc, const VALUE * const argv)
+rb_call_super(int argc, const VALUE *argv)
{
PASS_PASSED_BLOCK();
return vm_call_super(GET_THREAD(), argc, argv);
@@ -549,9 +547,9 @@
/* C -> Ruby: block */
static inline VALUE
-invoke_block_from_c(rb_thread_t * const th, rb_block_t * const block,
- const VALUE self, const int argc, const VALUE * const argv,
- rb_block_t * const blockptr, NODE * const cref)
+invoke_block_from_c(rb_thread_t *th, rb_block_t *block,
+ VALUE self, int argc, const VALUE *argv,
+ rb_block_t *blockptr, const NODE *cref)
{
if (BUILTIN_TYPE(block->iseq) != T_NODE) {
rb_iseq_t *iseq = block->iseq;
@@ -588,7 +586,7 @@
}
static inline rb_block_t *
-check_block(rb_thread_t * const th)
+check_block(rb_thread_t *th)
{
rb_block_t *blockptr = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
@@ -600,24 +598,22 @@
}
VALUE
-vm_yield_with_cref(rb_thread_t * const th, const int argc,
- const VALUE * const argv, NODE * const cref)
+vm_yield_with_cref(rb_thread_t *th, int argc, const VALUE *argv, const NODE *cref)
{
rb_block_t *blockptr = check_block(th);
return invoke_block_from_c(th, blockptr, blockptr->self, argc, argv, 0, cref);
}
VALUE
-vm_yield(rb_thread_t * const th, const int argc, const VALUE * const argv)
+vm_yield(rb_thread_t *th, int argc, const VALUE *argv)
{
- rb_block_t * const blockptr = check_block(th);
+ rb_block_t *blockptr = check_block(th);
return invoke_block_from_c(th, blockptr, blockptr->self, argc, argv, 0, 0);
}
VALUE
-vm_invoke_proc(rb_thread_t * const th, rb_proc_t * const proc,
- const VALUE self, const int argc, const VALUE * const argv,
- rb_block_t * const blockptr)
+vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self,
+ int argc, const VALUE *argv, rb_block_t * blockptr)
{
VALUE val = Qundef;
int state;
@@ -659,8 +655,7 @@
/* special variable */
VALUE
-vm_cfp_svar_get(rb_thread_t * const th, rb_control_frame_t *cfp,
- const VALUE key)
+vm_cfp_svar_get(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key)
{
while (cfp->pc == 0) {
cfp++;
@@ -669,8 +664,7 @@
}
void
-vm_cfp_svar_set(rb_thread_t * const th, rb_control_frame_t *cfp,
- const VALUE key, const VALUE val)
+vm_cfp_svar_set(rb_thread_t *th, rb_control_frame_t *cfp, VALUE key, const VALUE val)
{
while (cfp->pc == 0) {
cfp++;
@@ -679,16 +673,16 @@
}
static VALUE
-vm_svar_get(const VALUE key)
+vm_svar_get(VALUE key)
{
- rb_thread_t * const th = GET_THREAD();
+ rb_thread_t *th = GET_THREAD();
return vm_cfp_svar_get(th, th->cfp, key);
}
static void
-vm_svar_set(const VALUE key, const VALUE val)
+vm_svar_set(VALUE key, VALUE val)
{
- rb_thread_t * const th = GET_THREAD();
+ rb_thread_t *th = GET_THREAD();
vm_cfp_svar_set(th, th->cfp, key, val);
}
@@ -699,7 +693,7 @@
}
void
-rb_backref_set(const VALUE val)
+rb_backref_set(VALUE val)
{
vm_svar_set(1, val);
}
@@ -711,7 +705,7 @@
}
void
-rb_lastline_set(const VALUE val)
+rb_lastline_set(VALUE val)
{
vm_svar_set(0, val);
}
@@ -741,10 +735,9 @@
}
static VALUE
-vm_backtrace_each(rb_thread_t * const th,
- rb_control_frame_t * const limit_cfp,
- rb_control_frame_t *cfp,
- char * file, int line_no, const VALUE ary)
+vm_backtrace_each(rb_thread_t *th,
+ rb_control_frame_t *limit_cfp, rb_control_frame_t *cfp,
+ const char * file, int line_no, VALUE ary)
{
VALUE str;
@@ -773,7 +766,7 @@
}
VALUE
-vm_backtrace(rb_thread_t * const th, int lev)
+vm_backtrace(rb_thread_t *th, int lev)
{
VALUE ary;
rb_control_frame_t *cfp = th->cfp;
@@ -838,7 +831,7 @@
#endif
NODE *
-vm_cref_push(rb_thread_t * const th, const VALUE klass, const int noex)
+vm_cref_push(rb_thread_t *th, VALUE klass, int noex)
{
NODE *cref = NEW_BLOCK(klass);
rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
@@ -850,7 +843,7 @@
}
static inline VALUE
-vm_get_cbase(rb_iseq_t * const iseq, VALUE * const lfp, VALUE * const dfp)
+vm_get_cbase(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
{
NODE *cref = vm_get_cref(iseq, lfp, dfp);
VALUE klass = Qundef;
@@ -876,8 +869,7 @@
/* jump */
static VALUE
-make_localjump_error(const char *mesg,
- const VALUE value, const int reason)
+make_localjump_error(const char *mesg, VALUE value, int reason)
{
extern VALUE rb_eLocalJumpError;
VALUE exc = rb_exc_new2(rb_eLocalJumpError, mesg);
@@ -909,15 +901,14 @@
}
void
-vm_localjump_error(const char * const mesg, const VALUE value,
- const int reason)
+vm_localjump_error(const char *mesg, VALUE value, int reason)
{
VALUE exc = make_localjump_error(mesg, value, reason);
rb_exc_raise(exc);
}
VALUE
-vm_make_jump_tag_but_local_jump(const int state, VALUE val)
+vm_make_jump_tag_but_local_jump(int state, VALUE val)
{
VALUE result = Qnil;
@@ -949,7 +940,7 @@
}
void
-vm_jump_tag_but_local_jump(const int state, const VALUE val)
+vm_jump_tag_but_local_jump(int state, VALUE val)
{
VALUE exc = vm_make_jump_tag_but_local_jump(state, val);
if (val != Qnil) {
@@ -958,13 +949,13 @@
JUMP_TAG(state);
}
-NORETURN(static void vm_iter_break(rb_thread_t * const th));
+NORETURN(static void vm_iter_break(rb_thread_t *th));
static void
-vm_iter_break(rb_thread_t * const th)
+vm_iter_break(rb_thread_t *th)
{
- rb_control_frame_t * const cfp = th->cfp;
- VALUE * const dfp = GC_GUARDED_PTR_REF(*cfp->dfp);
+ rb_control_frame_t *cfp = th->cfp;
+ VALUE *dfp = GC_GUARDED_PTR_REF(*cfp->dfp);
th->state = TAG_BREAK;
th->errinfo = (VALUE)NEW_THROW_OBJECT(Qnil, (VALUE)dfp, TAG_BREAK);
@@ -983,7 +974,7 @@
static st_table *vm_opt_method_table = 0;
void
-rb_vm_check_redefinition_opt_method(NODE * const node)
+rb_vm_check_redefinition_opt_method(const NODE *node)
{
VALUE bop;
@@ -993,7 +984,7 @@
}
static void
-add_opt_method(const VALUE klass, const ID mid, const VALUE bop)
+add_opt_method(VALUE klass, ID mid, VALUE bop)
{
NODE *node;
if (st_lookup(RCLASS_M_TBL(klass), mid, (void *)&node) &&
@@ -1140,7 +1131,7 @@
VALUE
-vm_eval_body(rb_thread_t * const th)
+vm_eval_body(rb_thread_t *th)
{
int state;
VALUE result, err;
@@ -1348,9 +1339,9 @@
/* misc */
VALUE
-rb_iseq_eval(const VALUE iseqval)
+rb_iseq_eval(VALUE iseqval)
{
- rb_thread_t * const th = GET_THREAD();
+ rb_thread_t *th = GET_THREAD();
VALUE val;
volatile VALUE tmp;
@@ -1365,8 +1356,8 @@
}
int
-rb_thread_method_id_and_class(rb_thread_t * const th,
- ID * const idp, VALUE * const klassp)
+rb_thread_method_id_and_class(rb_thread_t *th,
+ ID *idp, VALUE *klassp)
{
rb_control_frame_t *cfp = th->cfp;
rb_iseq_t *iseq = cfp->iseq;
@@ -1395,7 +1386,7 @@
}
int
-rb_frame_method_id_and_class(ID * const idp, VALUE * const klassp)
+rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
{
return rb_thread_method_id_and_class(GET_THREAD(), idp, klassp);
}
@@ -1425,9 +1416,8 @@
}
VALUE
-rb_vm_call_cfunc(const VALUE recv, VALUE (* const func)(VALUE),
- const VALUE arg, rb_block_t * const blockptr,
- const VALUE filename)
+rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg,
+ const rb_block_t *blockptr, VALUE filename)
{
rb_thread_t *th = GET_THREAD();
rb_control_frame_t *reg_cfp = th->cfp;
@@ -1443,7 +1433,7 @@
}
int
-rb_vm_cfunc_funcall_p(rb_control_frame_t * const cfp)
+rb_vm_cfunc_funcall_p(rb_control_frame_t * cfp)
{
if (vm_cfunc_flags(cfp) & (VM_CALL_FCALL_BIT | VM_CALL_VCALL_BIT))
return Qtrue;
@@ -1453,7 +1443,7 @@
/* vm */
static void
-vm_free(void * const ptr)
+vm_free(void *ptr)
{
RUBY_FREE_ENTER("vm");
if (ptr) {
@@ -1470,8 +1460,7 @@
}
static int
-vm_mark_each_thread_func(st_data_t const key, st_data_t const value,
- st_data_t const dummy)
+vm_mark_each_thread_func(st_data_t key, st_data_t value, st_data_t dummy)
{
VALUE thval = (VALUE)key;
rb_gc_mark(thval);
@@ -1488,7 +1477,7 @@
}
void
-rb_vm_mark(void * const ptr)
+rb_vm_mark(void *ptr)
{
RUBY_MARK_ENTER("vm");
RUBY_GC_INFO("-------------------------------------------------\n");
@@ -1515,7 +1504,7 @@
}
static void
-vm_init2(rb_vm_t * const vm)
+vm_init2(rb_vm_t *vm)
{
MEMZERO(vm, rb_vm_t, 1);
}
@@ -1530,7 +1519,7 @@
int thread_recycle_stack_count = 0;
static VALUE *
-thread_recycle_stack(const int size)
+thread_recycle_stack(int size)
{
if (thread_recycle_stack_count) {
return thread_recycle_stack_slot[--thread_recycle_stack_count];
@@ -1545,7 +1534,7 @@
#endif
void
-rb_thread_recycle_stack_release(VALUE * const stack)
+rb_thread_recycle_stack_release(VALUE *stack)
{
#if USE_THREAD_DATA_RECYCLE
if (thread_recycle_stack_count < RECYCLE_MAX) {
@@ -1570,7 +1559,7 @@
#endif
static void
-thread_free(void * const ptr)
+thread_free(void *ptr)
{
rb_thread_t *th;
RUBY_FREE_ENTER("thread");
@@ -1608,10 +1597,10 @@
RUBY_FREE_LEAVE("thread");
}
-void rb_gc_mark_machine_stack(rb_thread_t * const th);
+void rb_gc_mark_machine_stack(rb_thread_t *th);
void
-rb_thread_mark(void * const ptr)
+rb_thread_mark(void *ptr)
{
rb_thread_t *th = NULL;
RUBY_MARK_ENTER("thread");
@@ -1665,7 +1654,7 @@
}
static VALUE
-thread_alloc(const VALUE klass)
+thread_alloc(VALUE klass)
{
VALUE volatile obj;
#ifdef USE_THREAD_RECYCLE
@@ -1680,7 +1669,7 @@
}
static void
-th_init2(rb_thread_t * const th)
+th_init2(rb_thread_t *th)
{
/* allocate thread stack */
th->stack_size = RUBY_VM_THREAD_STACK_SIZE;
@@ -1700,13 +1689,13 @@
}
static void
-th_init(rb_thread_t * const th)
+th_init(rb_thread_t *th)
{
th_init2(th);
}
static VALUE
-ruby_thread_init(const VALUE self)
+ruby_thread_init(VALUE self)
{
rb_thread_t *th;
rb_vm_t *vm = GET_THREAD()->vm;
@@ -1722,7 +1711,7 @@
}
VALUE
-rb_thread_alloc(const VALUE klass)
+rb_thread_alloc(VALUE klass)
{
VALUE self = thread_alloc(klass);
ruby_thread_init(self);
@@ -1870,8 +1859,8 @@
Init_BareVM(void)
{
/* VM bootstrap: phase 1 */
- rb_vm_t * const vm = malloc(sizeof(*vm));
- rb_thread_t * const th = malloc(sizeof(*th));
+ rb_vm_t * vm = malloc(sizeof(*vm));
+ rb_thread_t * th = malloc(sizeof(*th));
MEMZERO(th, rb_thread_t, 1);
rb_thread_set_current_raw(th);
@@ -1896,7 +1885,7 @@
/* top self */
static VALUE
-main_to_s(const VALUE obj)
+main_to_s(VALUE obj)
{
return rb_str_new2("main");
}
Index: version.h
===================================================================
--- version.h (revision 16539)
+++ version.h (revision 16540)
@@ -1,7 +1,7 @@
#define RUBY_VERSION "1.9.0"
-#define RUBY_RELEASE_DATE "2008-05-22"
+#define RUBY_RELEASE_DATE "2008-05-23"
#define RUBY_VERSION_CODE 190
-#define RUBY_RELEASE_CODE 20080522
+#define RUBY_RELEASE_CODE 20080523
#define RUBY_PATCHLEVEL 0
#define RUBY_VERSION_MAJOR 1
@@ -9,7 +9,7 @@
#define RUBY_VERSION_TEENY 0
#define RUBY_RELEASE_YEAR 2008
#define RUBY_RELEASE_MONTH 5
-#define RUBY_RELEASE_DAY 22
+#define RUBY_RELEASE_DAY 23
#ifdef RUBY_EXTERN
RUBY_EXTERN const char ruby_version[];
Index: vm_insnhelper.c
===================================================================
--- vm_insnhelper.c (revision 16539)
+++ vm_insnhelper.c (revision 16540)
@@ -21,10 +21,10 @@
#endif
static inline rb_control_frame_t *
-vm_push_frame(rb_thread_t * const th, const rb_iseq_t * const iseq,
- const VALUE type, const VALUE self, const VALUE specval,
- const VALUE * const pc, VALUE *sp, VALUE *lfp,
- int const local_size)
+vm_push_frame(rb_thread_t * th, const rb_iseq_t * iseq,
+ VALUE type, VALUE self, VALUE specval,
+ const VALUE *pc, VALUE *sp, VALUE *lfp,
+ int local_size)
{
rb_control_frame_t * const cfp = th->cfp = th->cfp - 1;
int i;
@@ -70,7 +70,7 @@
}
static inline void
-vm_pop_frame(rb_thread_t * const th)
+vm_pop_frame(rb_thread_t *th)
{
#if COLLECT_PROFILE
rb_control_frame_t *cfp = th->cfp;
@@ -99,9 +99,8 @@
/* method dispatch */
static inline int
-vm_callee_setup_arg(rb_thread_t * const th, const rb_iseq_t * const iseq,
- const int orig_argc, VALUE * const orig_argv,
- rb_block_t ** const block)
+vm_callee_setup_arg(rb_thread_t *th, const rb_iseq_t * iseq,
+ int orig_argc, VALUE * orig_argv, rb_block_t **block)
{
const int m = iseq->argc;
@@ -174,7 +173,7 @@
/* block arguments */
if (block && iseq->arg_block != -1) {
VALUE blockval = Qnil;
- rb_block_t * const blockptr = *block;
+ const rb_block_t *blockptr = *block;
if (argc != 0) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)",
@@ -205,9 +204,8 @@
}
static inline int
-caller_setup_args(const rb_thread_t * const th,
- rb_control_frame_t * const cfp, const VALUE flag, int argc,
- rb_iseq_t * const blockiseq, rb_block_t ** const block)
+caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
+ int argc, rb_iseq_t *blockiseq, rb_block_t **block)
{
rb_block_t *blockptr = 0;
@@ -270,8 +268,8 @@
}
static inline VALUE
-call_cfunc(VALUE (* const func)(), const VALUE recv,
- const int len, const int argc, const VALUE * const argv)
+call_cfunc(VALUE (*func)(), VALUE recv,
+ int len, int argc, const VALUE *argv)
{
/* printf("len: %d, argc: %d\n", len, argc); */
@@ -358,9 +356,9 @@
}
static inline VALUE
-vm_call_cfunc(rb_thread_t * const th, rb_control_frame_t * const reg_cfp,
- const int num, const ID id, const VALUE recv, const VALUE klass,
- const VALUE flag, const NODE * const mn, const rb_block_t * const blockptr)
+vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp,
+ int num, ID id, VALUE recv, VALUE klass,
+ VALUE flag, const NODE *mn, const rb_block_t *blockptr)
{
VALUE val;
@@ -388,7 +386,7 @@
}
static inline int
-vm_cfunc_flags(const rb_control_frame_t * const cfp)
+vm_cfunc_flags(const rb_control_frame_t *cfp)
{
if (RUBYVM_CFUNC_FRAME_P(cfp))
return cfp->flag >> FRAME_MAGIC_MASK_BITS;
@@ -396,9 +394,8 @@
}
static inline VALUE
-vm_call_bmethod(rb_thread_t * const th, const ID id, const VALUE procval,
- const VALUE recv, const VALUE klass, const int argc, VALUE *argv,
- rb_block_t * const blockptr)
+vm_call_bmethod(rb_thread_t *th, ID id, VALUE procval, VALUE recv,
+ VALUE klass, int argc, VALUE *argv, rb_block_t *blockptr)
{
rb_control_frame_t *cfp = th->cfp;
rb_proc_t *proc;
@@ -414,8 +411,8 @@
}
static inline VALUE
-vm_method_missing(rb_thread_t * const th, const ID id, const VALUE recv,
- const int num, rb_block_t * const blockptr, const int opt)
+vm_method_missing(rb_thread_t *th, ID id, VALUE recv,
+ int num, rb_block_t *blockptr, int opt)
{
rb_control_frame_t * const reg_cfp = th->cfp;
VALUE *argv = STACK_ADDR_FROM_TOP(num + 1);
@@ -651,8 +648,8 @@
}
static inline VALUE
-vm_yield_with_cfunc(rb_thread_t *const th, rb_block_t * const block,
- const VALUE self, const int argc, const VALUE * const argv)
+vm_yield_with_cfunc(rb_thread_t *th, rb_block_t *block,
+ VALUE self, int argc, const VALUE *argv)
{
NODE *ifunc = (NODE *) block->iseq;
VALUE val;
@@ -680,9 +677,9 @@
}
static inline int
-vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t * const iseq,
- const int orig_argc, VALUE * const argv,
- rb_block_t *blockptr, const int lambda)
+vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t *iseq,
+ int orig_argc, VALUE *argv,
+ rb_block_t *blockptr, int lambda)
{
if (0) { /* for debug */
printf(" argc: %d\n", orig_argc);
@@ -799,8 +796,7 @@
}
static VALUE
-vm_invoke_block(rb_thread_t * const th, rb_control_frame_t *const reg_cfp,
- const rb_num_t num, const rb_num_t flag)
+vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_num_t flag)
{
rb_block_t * const block = GET_BLOCK_PTR();
rb_iseq_t *iseq;
@@ -840,7 +836,7 @@
/* svar */
static inline NODE *
-lfp_svar_place(rb_thread_t * const th, VALUE * const lfp)
+lfp_svar_place(rb_thread_t *th, VALUE *lfp)
{
NODE *svar;
@@ -862,7 +858,7 @@
}
static VALUE
-lfp_svar_get(rb_thread_t * const th, VALUE * const lfp, const VALUE key)
+lfp_svar_get(rb_thread_t *th, VALUE *lfp, VALUE key)
{
NODE *svar = lfp_svar_place(th, lfp);
@@ -885,8 +881,7 @@
}
static void
-lfp_svar_set(rb_thread_t * const th, VALUE * const lfp,
- const VALUE key, const VALUE val)
+lfp_svar_set(rb_thread_t *th, VALUE *lfp, VALUE key, VALUE val)
{
NODE *svar = lfp_svar_place(th, lfp);
@@ -909,8 +904,7 @@
}
static inline VALUE
-vm_getspecial(rb_thread_t * const th, VALUE * const lfp,
- const VALUE key, const rb_num_t type)
+vm_getspecial(rb_thread_t *th, VALUE *lfp, VALUE key, rb_num_t type)
{
VALUE val;
@@ -950,8 +944,7 @@
}
static NODE *
-vm_get_cref(const rb_iseq_t * const iseq,
- const VALUE * const lfp, const VALUE *dfp)
+vm_get_cref(const rb_iseq_t *iseq, const VALUE *lfp, const VALUE *dfp)
{
NODE *cref = 0;
@@ -975,7 +968,7 @@
static inline void
-vm_check_if_namespace(const VALUE klass)
+vm_check_if_namespace(VALUE klass)
{
switch (TYPE(klass)) {
case T_CLASS:
@@ -988,14 +981,14 @@
}
static inline VALUE
-vm_get_ev_const(rb_thread_t * const th, const rb_iseq_t * const iseq,
- const VALUE orig_klass, const ID id, const int is_defined)
+vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
+ VALUE orig_klass, ID id, int is_defined)
{
VALUE val;
if (orig_klass == Qnil) {
/* in current lexical scope */
- const NODE * const root_cref = vm_get_cref(iseq, th->cfp->lfp, th->cfp->dfp);
+ const NODE *root_cref = vm_get_cref(iseq, th->cfp->lfp, th->cfp->dfp);
const NODE *cref = root_cref;
VALUE klass = orig_klass;
@@ -1069,9 +1062,8 @@
}
static inline void
-vm_define_method(rb_thread_t * const th, const VALUE obj, const ID id,
- rb_iseq_t * const miseq, const rb_num_t is_singleton,
- NODE * const cref)
+vm_define_method(rb_thread_t *th, VALUE obj, ID id, rb_iseq_t *miseq,
+ rb_num_t is_singleton, NODE *cref)
{
NODE *newbody;
VALUE klass = cref->nd_clss;
@@ -1110,7 +1102,7 @@
}
static inline NODE *
-vm_method_search(const VALUE id, const VALUE klass, const IC ic)
+vm_method_search(VALUE id, VALUE klass, IC ic)
{
NODE *mn;
@@ -1134,7 +1126,7 @@
}
static inline VALUE
-vm_search_normal_superclass(VALUE klass, const VALUE recv)
+vm_search_normal_superclass(VALUE klass, VALUE recv)
{
if (BUILTIN_TYPE(klass) == T_CLASS) {
klass = RCLASS_SUPER(klass);
@@ -1153,9 +1145,9 @@
}
static void
-vm_search_superclass(rb_control_frame_t *const reg_cfp, rb_iseq_t * ip,
- const VALUE recv, const VALUE sigval,
- ID * const idp, VALUE * const klassp)
+vm_search_superclass(rb_control_frame_t *reg_cfp, rb_iseq_t *ip,
+ VALUE recv, VALUE sigval,
+ ID *idp, VALUE *klassp)
{
ID id;
VALUE klass;
@@ -1201,8 +1193,8 @@
}
static VALUE
-vm_throw(rb_thread_t *const th, rb_control_frame_t * const reg_cfp,
- const rb_num_t throw_state, const VALUE throwobj)
+vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp,
+ rb_num_t throw_state, VALUE throwobj)
{
rb_num_t state = throw_state & 0xff;
rb_num_t flag = throw_state & 0x8000;
@@ -1347,8 +1339,7 @@
}
static inline void
-vm_expandarray(rb_control_frame_t * const cfp, VALUE ary,
- const int num, const int flag)
+vm_expandarray(rb_control_frame_t *cfp, VALUE ary, int num, int flag)
{
int is_splat = flag & 0x01;
int space_size = num + is_splat;
@@ -1409,7 +1400,7 @@
}
static inline int
-check_cfunc(const NODE * const mn, const void * const func)
+check_cfunc(const NODE *mn, const void *func)
{
if (mn && nd_type(mn->nd_body) == NODE_CFUNC &&
mn->nd_body->nd_cfnc == func) {
@@ -1421,7 +1412,7 @@
}
static inline VALUE
-opt_eq_func(const VALUE recv, const VALUE obj, const IC ic)
+opt_eq_func(VALUE recv, VALUE obj, IC ic)
{
VALUE val = Qundef;
--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/