yarv-diff:103
From: ko1 atdot.net
Date: 25 Sep 2005 02:05:15 -0000
Subject: [yarv-diff:103] r259 - in trunk: . lib missing rb
Author: ko1
Date: 2005-09-25 11:05:13 +0900 (Sun, 25 Sep 2005)
New Revision: 259
Added:
trunk/rb/mklog.rb
Modified:
trunk/ChangeLog
trunk/array.c
trunk/eval.c
trunk/eval_error.h
trunk/eval_intern.h
trunk/eval_jump.h
trunk/eval_proc.c
trunk/eval_safe.h
trunk/eval_thread.c
trunk/insnhelper.h
trunk/io.c
trunk/lib/fileutils.rb
trunk/missing/vsnprintf.c
trunk/pack.c
trunk/parse.y
trunk/process.c
trunk/signal.c
trunk/struct.c
trunk/test.rb
trunk/time.c
trunk/variable.c
trunk/version.h
trunk/vm.c
trunk/vm_macro.def
trunk/yarvcore.c
trunk/yarvcore.h
Log:
* some files : import from ruby 1.9.0 (2005-09-25)
* eval*, vm.c, vm_macro.def : remove frame, scope, ...
* yarvcore.c : remove yarv_block_given_p()
* yarvcore.h, insnhelper.h : move some macro from insnhelper.h to yarvcore.h
to use these in eval.c
Modified: trunk/ChangeLog
===================================================================
--- trunk/ChangeLog 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/ChangeLog 2005-09-25 02:05:13 UTC (rev 259)
@@ -4,6 +4,18 @@
# from Mon, 03 May 2004 01:24:19 +0900
#
+2005-09-25(Sun) 11:01:17 +0900 Koichi Sasada <ko1 atdot.net>
+
+ * some files : import from ruby 1.9.0 (2005-09-25)
+
+ * eval*, vm.c, vm_macro.def : remove frame, scope, ...
+
+ * yarvcore.c : remove yarv_block_given_p()
+
+ * yarvcore.h, insnhelper.h : move some macro from insnhelper.h to yarvcore.h
+ to use these in eval.c
+
+
2005-09-24(Sat) 15:51:42 +0900 Koichi Sasada <ko1 atdot.net>
* eval* : remove dependency to ruby_dyna_vars and ruby_class
Modified: trunk/array.c
===================================================================
--- trunk/array.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/array.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
array.c -
- $Author: matz $
- $Date: 2005/09/12 15:23:54 $
+ $Author: akr $
+ $Date: 2005/09/24 00:17:40 $
created at: Fri Aug 6 09:46:12 JST 1993
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -2006,7 +2006,7 @@
}
}
else if (elen != RARRAY(tmp)->len) {
- rb_raise(rb_eIndexError, "element size differs (%d should be %d)",
+ rb_raise(rb_eIndexError, "element size differs (%ld should be %ld)",
RARRAY(tmp)->len, elen);
}
for (j=0; j<elen; j++) {
Modified: trunk/eval.c
===================================================================
--- trunk/eval.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -17,8 +17,8 @@
/* for gc.c */
struct SCOPE *ruby_scope = 0;
struct RVarmap *ruby_dyna_vars = 0;
+struct FRAME *ruby_frame = 0;
-
struct tag *ruby_prot_tag;
VALUE rb_cProc;
VALUE rb_cBinding;
@@ -28,10 +28,14 @@
void bm_mark _((void *));
static VALUE proc_lambda _((void));
-static VALUE rb_f_block_given_p _((void));
+VALUE rb_f_block_given_p _((void));
static VALUE umethod_bind _((VALUE, VALUE));
static VALUE rb_mod_define_method _((int, VALUE*, VALUE));
+ID rb_frame_callee();
+static VALUE rb_frame_self();
+
+
static int scope_vmode;
#define SCOPE_PUBLIC 0
#define SCOPE_PRIVATE 1
@@ -56,11 +60,6 @@
extern int ruby_nerrs;
extern VALUE ruby_top_self;
-struct FRAME *ruby_frame;
-static struct FRAME *top_frame;
-
-unsigned long frame_unique = 0;
-
static VALUE ruby_wrapper; /* security wrapper */
#define PUSH_THREAD_TAG() \
@@ -152,8 +151,6 @@
ruby_thid = NATIVETHREAD_CURRENT();
#endif
- ruby_frame = top_frame = &frame;
-
#ifdef __MACOS__
rb_origenviron = 0;
#else
@@ -169,7 +166,6 @@
PUSH_TAG(PROT_NONE);
if ((state = EXEC_TAG()) == 0) {
rb_call_inits();
- ruby_frame->self = ruby_top_self;
#ifdef __MACOS__
_macruby_init();
#elif defined(__VMS)
@@ -353,16 +349,10 @@
ruby_top_self = rb_obj_clone(ruby_top_self);
rb_extend_object(ruby_top_self, ruby_wrapper);
- PUSH_FRAME();
- ruby_frame->callee = 0;
- ruby_frame->this_func = 0;
- ruby_frame->this_class = 0;
- ruby_frame->self = self;
val = rb_eval_string_protect(str, &status);
ruby_top_self = self;
- POP_FRAME();
ruby_wrapper = wrapper;
if (state) {
*state = status;
@@ -398,21 +388,12 @@
return val;
}
- PUSH_FRAME();
- ruby_frame->callee = 0;
- ruby_frame->this_func = 0;
- ruby_frame->this_class = 0;
- ruby_frame->self = ruby_top_self;
-
- ruby_safe_level = level;
-
PUSH_TAG(PROT_NONE);
if ((state = EXEC_TAG()) == 0) {
val = eval(ruby_top_self, cmd, Qnil, 0, 0);
}
ruby_safe_level = safe;
POP_TAG();
- POP_FRAME();
jump_tag_but_local_jump(state, val);
return val;
@@ -534,16 +515,12 @@
#define MATCH_DATA *rb_svar(node->nd_cnt)
-static void blk_free();
-
static VALUE
rb_obj_is_proc(proc)
VALUE proc;
{
- if (TYPE(proc) == T_DATA && RDATA(proc)->dfree == (RUBY_DATA_FUNC)blk_free) {
- return Qtrue;
- }
- return Qfalse;
+ // TODO: fix me
+ return Qtrue;
}
void
@@ -700,15 +677,9 @@
node_save = NEW_BEGIN(0);
}
tracing = 1;
- prev = ruby_frame;
- PUSH_FRAME();
- *ruby_frame = *prev;
- ruby_frame->prev = prev;
- ruby_frame->iter = 0; /* blocks not available anyway */
if (node) {
ruby_current_node = node;
- ruby_frame->node = node;
ruby_sourcefile = node->nd_file;
ruby_sourceline = nd_line(node);
}
@@ -735,7 +706,6 @@
}
if (raised) thread_set_raised();
POP_TAG();
- POP_FRAME();
tracing = 0;
ruby_current_node = node_save;
@@ -990,10 +960,7 @@
rb_trap_restore_mask();
if (tag != TAG_FATAL) {
- EXEC_EVENT_HOOK(RUBY_EVENT_RAISE, ruby_current_node,
- ruby_frame->self,
- ruby_frame->this_func,
- ruby_frame->this_class);
+ // EXEC_EVENT_HOOK(RUBY_EVENT_RAISE ...)
}
if (!prot_tag) {
error_print();
@@ -1106,13 +1073,8 @@
rb_raise_jump(mesg)
VALUE mesg;
{
- if (ruby_frame != top_frame) {
- PUSH_FRAME(); /* fake frame */
- *ruby_frame = *_frame.prev->prev;
- rb_longjmp(TAG_RAISE, mesg);
- POP_FRAME();
- }
- rb_longjmp(TAG_RAISE, mesg);
+ // TODO: fix me
+ rb_longjmp(TAG_RAISE, mesg);
}
void
@@ -1161,10 +1123,18 @@
*/
-static VALUE
+VALUE
rb_f_block_given_p()
{
- return yarv_block_given_p();
+ yarv_thread_t *th = GET_THREAD();
+ yarv_control_frame_t *cfp = th->cfp;
+ cfp = YARV_PERVIOUS_CONTROL_FRAME(cfp);
+ if(GC_GUARDED_PTR_REF(cfp->lfp[0])){
+ return Qtrue;
+ }
+ else{
+ return Qfalse;
+ }
}
VALUE rb_eThreadError;
@@ -1312,7 +1282,7 @@
GET_THREAD()->ifuncnode = node;
retval = (*it_proc)(data1);
}
- else if (state == TAG_BREAK && TAG_DST()) {
+ else if (state == TAG_BREAK /* TODO: more check */ ) {
retval = prot_tag->retval;
state = 0;
}
@@ -1582,7 +1552,6 @@
args[n++] = rb_ary_new4(argc-1, argv+1);
}
exc = rb_class_new_instance(n, args, exc);
- ruby_frame = ruby_frame->prev; /* pop frame for "method_missing" */
rb_exc_raise(exc);
}
@@ -1602,9 +1571,7 @@
last_call_status = call_status;
if (id == missing) {
- PUSH_FRAME();
rb_method_missing(argc, argv, obj);
- POP_FRAME();
}
else if (id == ID_ALLOCATOR) {
rb_raise(rb_eTypeError, "allocator undefined for %s", rb_class2name(obj));
@@ -1664,7 +1631,7 @@
if (TYPE(defined_class) == T_ICLASS) {
defined_class = RBASIC(defined_class)->klass;
}
- if (!rb_obj_is_kind_of(ruby_frame->self, rb_class_real(defined_class)))
+ if (!rb_obj_is_kind_of(rb_frame_self(), rb_class_real(defined_class)))
return method_missing(recv, mid, argc, argv, CSTAT_PROT);
}
}
@@ -1863,21 +1830,30 @@
ID
rb_frame_this_func()
{
- return ruby_frame->this_func;
+ // TOOD: UNSUPPORTED(rb_frame_this_func);
+ return 0;
}
ID
rb_frame_callee()
{
- return ruby_frame->callee;
+ UNSUPPORTED(rb_frame_callee);
+ return 0;
}
void
rb_frame_pop()
{
- ruby_frame = ruby_frame->prev;
+ UNSUPPORTED(rb_frame_pop);
}
+static VALUE
+rb_frame_self()
+{
+ UNSUPPORTED(rb_frame_self);
+ return Qnil;
+}
+
static NODE*
compile(src, file, line)
VALUE src;
@@ -1990,19 +1966,6 @@
}
if (!NIL_P(vfile)) file = RSTRING(vfile)->ptr;
- if (NIL_P(scope) && ruby_frame->prev) {
- struct FRAME *prev;
- VALUE val;
-
- prev = ruby_frame;
- PUSH_FRAME();
- *ruby_frame = *prev->prev;
- ruby_frame->prev = prev;
- val = eval(self, src, scope, file, line);
- POP_FRAME();
-
- return val;
- }
return eval(self, src, scope, file, line);
}
@@ -2017,22 +1980,13 @@
int state;
int mode;
- PUSH_FRAME();
- ruby_frame->self = _frame.prev->self;
- ruby_frame->callee = _frame.prev->callee;
- ruby_frame->this_func = _frame.prev->this_func;
- ruby_frame->this_class = _frame.prev->this_class;
- ruby_frame->argc = _frame.prev->argc;
- mode = scope_vmode;
- SCOPE_SET(SCOPE_PUBLIC);
PUSH_TAG(PROT_NONE);
if ((state = EXEC_TAG()) == 0) {
val = (*func)(args);
}
POP_TAG();
SCOPE_SET(mode);
- POP_FRAME();
if (state) JUMP_TAG(state);
return val;
@@ -2188,17 +2142,10 @@
self = rb_obj_clone(ruby_top_self);
rb_extend_object(self, ruby_wrapper);
}
- PUSH_FRAME();
- ruby_frame->callee = 0;
- ruby_frame->this_func = 0;
- ruby_frame->this_class = 0;
- ruby_frame->self = self;
/* default visibility is private at loading toplevel */
SCOPE_SET(SCOPE_PRIVATE);
PUSH_TAG(PROT_NONE);
state = EXEC_TAG();
- callee = ruby_frame->callee;
- this_func = ruby_frame->this_func;
last_node = ruby_current_node;
if (!ruby_current_node && ruby_sourcefile) {
last_node = NEW_BEGIN(0);
@@ -2207,15 +2154,12 @@
if (state == 0) {
yarv_load(RSTRING(fname)->ptr);
}
- ruby_frame->callee = callee;
- ruby_frame->this_func = this_func;
ruby_current_node = last_node;
ruby_sourcefile = 0;
ruby_set_current_source();
POP_TAG();
rb_prohibit_interrupt = prohibit_int;
- POP_FRAME();
ruby_wrapper = wrapper;
if (ruby_nerrs > 0) {
ruby_nerrs = 0;
@@ -2512,8 +2456,6 @@
saved.vmode = scope_vmode;
saved.node = ruby_current_node;
- saved.callee = ruby_frame->callee;
- saved.this_func = ruby_frame->this_func;
saved.safe = ruby_safe_level;
PUSH_TAG(PROT_NONE);
if ((state = EXEC_TAG()) == 0) {
@@ -2547,8 +2489,6 @@
ruby_current_node = 0;
ruby_sourcefile = rb_source_filename(RSTRING(path)->ptr);
ruby_sourceline = 0;
- ruby_frame->callee = 0;
- ruby_frame->this_func = 0;
SCOPE_SET(SCOPE_PUBLIC);
handle = (long)dln_load(RSTRING(path)->ptr);
rb_ary_push(ruby_dln_librefs, LONG2NUM(handle));
@@ -2562,8 +2502,6 @@
POP_TAG();
ruby_current_node = saved.node;
ruby_set_current_source();
- ruby_frame->this_func = saved.this_func;
- ruby_frame->callee = saved.callee;
SCOPE_SET(saved.vmode);
ruby_safe_level = saved.safe;
if (ftptr) {
@@ -3308,51 +3246,7 @@
rb_global_variable(&ruby_dln_librefs);
}
-static void
-frame_free(frame)
- struct FRAME *frame;
-{
- struct FRAME *tmp;
- frame = frame->prev;
- while (frame) {
- tmp = frame;
- frame = frame->prev;
- free(tmp);
- }
-}
-
-static void
-blk_free(data)
- struct BLOCK *data;
-{
- void *tmp;
-
- while (data) {
- frame_free(&data->frame);
- tmp = data;
- data = data->prev;
- free(tmp);
- }
-}
-
-static void
-frame_dup(frame)
- struct FRAME *frame;
-{
- struct FRAME *tmp;
-
- for (;;) {
- frame->tmp = 0; /* should not preserve tmp */
- if (!frame->prev) break;
- tmp = ALLOC(struct FRAME);
- *tmp = *frame->prev;
- frame->prev = tmp;
- frame = tmp;
- }
-}
-
-
VALUE
rb_dvar_defined(ID id)
{
Modified: trunk/eval_error.h
===================================================================
--- trunk/eval_error.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_error.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -39,9 +39,9 @@
{
ruby_set_current_source();
if (ruby_sourcefile) {
- if (ruby_frame->callee) {
+ if (rb_frame_callee()) {
warn_printf("%s:%d:in `%s'", ruby_sourcefile, ruby_sourceline,
- rb_id2name(ruby_frame->callee));
+ rb_id2name(rb_frame_callee()));
}
else if (ruby_sourceline == 0) {
warn_printf("%s", ruby_sourcefile);
@@ -231,15 +231,9 @@
warn_print(": retry outside of rescue clause\n");
break;
case TAG_THROW:
- if (prot_tag && prot_tag->frame && prot_tag->frame->node) {
- NODE *tag = prot_tag->frame->node;
- warn_printf("%s:%d: uncaught throw\n",
- tag->nd_file, nd_line(tag));
- }
- else {
+ // TODO: fix me
error_pos();
warn_printf(": unexpected throw\n");
- }
break;
case TAG_RAISE:
case TAG_FATAL:
Modified: trunk/eval_intern.h
===================================================================
--- trunk/eval_intern.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_intern.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,6 +2,9 @@
#ifndef EVAL_INTERN_H_INCLUDED
#define EVAL_INTERN_H_INCLUDED
+#define SDR2(cfp) vm_stack_dump_raw(GET_THREAD(), (cfp))
+#define SDR3() vm_stack_dump_raw(GET_THREAD(), GET_THREAD()->cfp)
+
#define UNSUPPORTED(func) \
{ \
volatile int *a = 0; \
@@ -196,25 +199,18 @@
struct tag {
rb_jmpbuf_t buf;
- struct FRAME *frame;
VALUE tag;
VALUE retval;
- struct SCOPE *scope;
- VALUE dst;
struct tag *prev;
- int blkid;
};
+
extern struct tag *ruby_prot_tag;
#define prot_tag ruby_prot_tag
#define PUSH_TAG(ptag) do { \
struct tag _tag; \
- _tag.retval = Qnil; \
- _tag.frame = ruby_frame; \
_tag.prev = prot_tag; \
_tag.tag = ptag; \
- _tag.dst = 0; \
- _tag.blkid = 0; \
prot_tag = &_tag
#define PROT_NONE Qfalse /* 0 */
@@ -228,7 +224,6 @@
#define EXEC_TAG() (FLUSH_REGISTER_WINDOWS, ruby_setjmp(prot_tag->buf))
#define JUMP_TAG(st) do { \
- ruby_frame = prot_tag->frame; \
ruby_longjmp(prot_tag->buf,(st)); \
} while (0)
@@ -236,8 +231,6 @@
prot_tag = _tag.prev; \
} while (0)
-#define TAG_DST() (_tag.dst == (VALUE)ruby_frame->uniq)
-
#define TAG_RETURN 0x1
#define TAG_BREAK 0x2
#define TAG_NEXT 0x3
@@ -256,55 +249,6 @@
#define YIELD_FUNC_AVALUE 1
#define YIELD_FUNC_SVALUE 2
-#define PUSH_FRAME() do { \
- struct FRAME _frame; \
- _frame.prev = ruby_frame; \
- _frame.tmp = 0; \
- _frame.node = ruby_current_node; \
- _frame.argc = 0; \
- _frame.flags = 0; \
- _frame.uniq = frame_unique++; \
- ruby_frame = &_frame
-
-#define POP_FRAME() \
- ruby_current_node = _frame.node; \
- ruby_frame = _frame.prev; \
-} while (0)
-
-#define BLOCK_D_SCOPE 1
-#define BLOCK_LAMBDA 2
-#define BLOCK_FROM_METHOD 4
-
-static struct BLOCK *ruby_block;
-static unsigned long block_unique = 0;
-
-#define PUSH_BLOCK(v,b) do { \
- struct BLOCK _block; \
- _block.var = (v); \
- _block.body = (b); \
- _block.self = self; \
- _block.frame = *ruby_frame; \
- _block.klass = ruby_class; \
- _block.cref = ruby_cref; \
- _block.frame.node = ruby_current_node;\
- _block.prev = ruby_block; \
- _block.outer = ruby_block; \
- _block.vmode = scope_vmode; \
- _block.flags = BLOCK_D_SCOPE; \
- _block.dyna_vars = ruby_dyna_vars; \
- _block.wrapper = ruby_wrapper; \
- _block.block_obj = 0; \
- _block.uniq = (b)?block_unique++:0; \
- if (b) { \
- prot_tag->blkid = _block.uniq; \
- } \
- ruby_block = &_block
-
-#define POP_BLOCK() \
- ruby_block = _block.prev; \
-} while (0)
-
-
struct ruby_env {
struct ruby_env *prev;
struct FRAME *frame;
@@ -315,33 +259,6 @@
NODE *cref;
};
-struct METHOD {
- VALUE klass, rklass;
- VALUE recv;
- ID id, oid;
- NODE *body;
-};
-
-struct BLOCK {
- NODE *var;
- NODE *body;
- VALUE self;
- struct FRAME frame;
- struct SCOPE *scope;
- VALUE klass;
- NODE *cref;
- int iter;
- int vmode;
- int flags;
- int uniq;
- struct RVarmap *dyna_vars;
- VALUE orig_thread;
- VALUE wrapper;
- VALUE block_obj;
- struct BLOCK *outer;
- struct BLOCK *prev;
-};
-
typedef struct thread * rb_thread_t;
extern unsigned long frame_unique;
@@ -352,10 +269,8 @@
extern VALUE rb_eSysStackError;
extern VALUE exception_error;
extern VALUE sysstack_error;
-extern struct FRAME *ruby_frame;
-
void rb_thread_cleanup _((void));
void rb_thread_wait_other_threads _((void));
Modified: trunk/eval_jump.h
===================================================================
--- trunk/eval_jump.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_jump.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -32,7 +32,6 @@
while (tt) {
if (tt->tag == tag) {
- tt->dst = tag;
tt->retval = value;
break;
}
@@ -108,7 +107,7 @@
if ((state = EXEC_TAG()) == 0) {
val = rb_yield_0(tag, 0, 0, 0, Qfalse);
}
- else if (state == TAG_THROW && tag == prot_tag->dst) {
+ else if (state == TAG_THROW /* TODO: fix me (more check) */) {
val = prot_tag->retval;
state = 0;
}
Modified: trunk/eval_proc.c
===================================================================
--- trunk/eval_proc.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_proc.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -4,30 +4,19 @@
#include "eval_intern.h"
+struct METHOD {
+ VALUE klass, rklass;
+ VALUE recv;
+ ID id, oid;
+ NODE *body;
+};
+
static VALUE rb_cUnboundMethod;
static VALUE rb_cMethod;
static VALUE bmcall _((VALUE, VALUE));
static int method_arity _((VALUE));
-static void
-blk_mark(data)
- struct BLOCK *data;
-{
- while (data) {
- rb_gc_mark_frame(&data->frame);
- rb_gc_mark((VALUE)data->scope);
- rb_gc_mark((VALUE)data->var);
- rb_gc_mark((VALUE)data->body);
- rb_gc_mark((VALUE)data->self);
- rb_gc_mark((VALUE)data->dyna_vars);
- rb_gc_mark((VALUE)data->cref);
- rb_gc_mark(data->wrapper);
- rb_gc_mark(data->block_obj);
- data = data->prev;
- }
-}
-
/*
* MISSING: documentation
*/
@@ -101,14 +90,8 @@
VALUE *argv;
VALUE bind;
{
- struct BLOCK *data;
- VALUE args[4];
-
- rb_scan_args(argc, argv, "12", &args[0], &args[2], &args[3]);
- args[1] = bind;
- Data_Get_Struct(bind, struct BLOCK, data);
-
- return rb_f_eval(argc+1, args, data->self);
+ UNSUPPORTED(bind_eval);
+ return Qnil;
}
#define PROC_TSHIFT (FL_USHIFT+1)
@@ -145,12 +128,34 @@
}
static VALUE
-proc_alloc(klass, proc)
- VALUE klass;
- int proc;
+proc_alloc(VALUE klass, int is_lambda)
{
- UNSUPPORTED(proc_alloc);
- return Qnil;
+ VALUE procval = Qnil;
+ yarv_thread_t *th = GET_THREAD();
+ yarv_control_frame_t *cfp;
+ yarv_block_t *block;
+
+ if((block = GC_GUARDED_PTR_REF(th->cfp->lfp[0])) != 0){
+ cfp = th->cfp;
+ block = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
+ }
+ else{
+ cfp = YARV_PERVIOUS_CONTROL_FRAME(th->cfp);
+ if((block = GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0){
+ if(is_lambda){
+ rb_warn("tried to create Proc object without a block");
+ }
+ }
+ else{
+ rb_raise(rb_eArgError, "tried to create Proc object without a block");
+ }
+ }
+ procval = th_make_proc(th, cfp, block);
+
+ if(is_lambda){
+ // TODO: lambda or proc
+ }
+ return procval;
}
/*
@@ -270,39 +275,7 @@
rb_proc_arity(proc)
VALUE proc;
{
- struct BLOCK *data;
- NODE *var, *list;
- int n;
-
- Data_Get_Struct(proc, struct BLOCK, data);
- var = data->var;
- if (var == 0) {
- if (data->body && nd_type(data->body) == NODE_IFUNC &&
- data->body->nd_cfnc == bmcall) {
- return method_arity(data->body->nd_tval);
- }
- return 0;
- }
- if (var == (NODE*)1) return 0;
- if (var == (NODE*)2) return 0;
- if (nd_type(var) == NODE_BLOCK_ARG) {
- var = var->nd_args;
- if (var == (NODE*)1) return 0;
- if (var == (NODE*)2) return 0;
- }
- switch (nd_type(var)) {
- default:
- return 1;
- case NODE_MASGN:
- list = var->nd_head;
- n = 0;
- while (list) {
- n++;
- list = list->nd_next;
- }
- if (var->nd_args) return -n-1;
- return n;
- }
+ UNSUPPORTED(rb_proc_arity);
}
/*
@@ -326,8 +299,7 @@
*/
static VALUE
-proc_arity(proc)
- VALUE proc;
+proc_arity(VALUE proc)
{
int arity = rb_proc_arity(proc);
return INT2FIX(arity);
@@ -342,24 +314,25 @@
*/
static VALUE
-proc_eq(self, other)
- VALUE self, other;
+proc_eq(VALUE self, VALUE other)
{
- struct BLOCK *data, *data2;
-
- if (self == other) return Qtrue;
- if (TYPE(other) != T_DATA) return Qfalse;
- if (RDATA(other)->dmark != (RUBY_DATA_FUNC)blk_mark) return Qfalse;
- if (CLASS_OF(self) != CLASS_OF(other)) return Qfalse;
- Data_Get_Struct(self, struct BLOCK, data);
- Data_Get_Struct(other, struct BLOCK, data2);
- if (data->body != data2->body) return Qfalse;
- if (data->var != data2->var) return Qfalse;
- if (data->scope != data2->scope) return Qfalse;
- if (data->dyna_vars != data2->dyna_vars) return Qfalse;
- if (data->flags != data2->flags) return Qfalse;
-
+ if(self == other){
return Qtrue;
+ }
+ else{
+ if(TYPE(other) != T_DATA &&
+ RBASIC(other)->klass == cYarvProc &&
+ CLASS_OF(self) == CLASS_OF(other)){
+ yarv_proc_t *p1, *p2;
+ GetProcVal(self, p1);
+ GetProcVal(other, p2);
+ if(p1->block.iseq == p2->block.iseq &&
+ p1->envval == p2->envval){
+ return Qtrue;
+ }
+ }
+ }
+ return Qfalse;
}
/*
@@ -370,19 +343,14 @@
*/
static VALUE
-proc_hash(self)
- VALUE self;
-{
- struct BLOCK *data;
- long hash;
-
- Data_Get_Struct(self, struct BLOCK, data);
- hash = (long)data->body;
- hash ^= (long)data->var;
- hash ^= data->frame.uniq << 16;
- hash ^= data->flags;
-
- return INT2FIX(hash);
+proc_hash(VALUE self){
+ int hash;
+ yarv_proc_t *proc;
+ GetProcVal(self, proc);
+ hash = (long)proc->block.iseq;
+ hash ^= (long)proc->envval;
+ hash ^= (long)proc->block.lfp >> 16;
+ return INT2FIX(hash);
}
/*
@@ -394,25 +362,26 @@
*/
static VALUE
-proc_to_s(self)
- VALUE self;
+proc_to_s(VALUE self)
{
- struct BLOCK *data;
- NODE *node;
- char *cname = rb_obj_classname(self);
- VALUE str;
+ VALUE str = 0;
+ yarv_proc_t *proc;
+ char *cname = rb_obj_classname(self);
- Data_Get_Struct(self, struct BLOCK, data);
- if ((node = data->frame.node) || (node = data->body)) {
- str = rb_sprintf("#<%s:%p@%s:%d>", cname, data->body,
- node->nd_file, nd_line(node));
- }
- else {
- str = rb_sprintf("#<%s:%p>", cname, data->body);
- }
- if (OBJ_TAINTED(self)) OBJ_TAINT(str);
+ GetProcVal(self, proc);
- return str;
+ if(proc->block.iseq){
+ str = rb_sprintf("#<%s:%p@%s:%d>", cname, proc->block.iseq,
+ "test", -1);
+ }
+ else {
+ str = rb_sprintf("#<%s:%p>", cname, proc->block.iseq);
+ }
+
+ if(OBJ_TAINTED(self)){
+ OBJ_TAINT(str);
+ }
+ return str;
}
/*
@@ -425,8 +394,7 @@
*/
static VALUE
-proc_to_self(self)
- VALUE self;
+proc_to_self(VALUE self)
{
return self;
}
@@ -452,7 +420,7 @@
proc_binding(proc)
VALUE proc;
{
- UNSUPPORTED(proc_alloc);
+ UNSUPPORTED(proc_binding);
return Qnil;
}
@@ -1044,12 +1012,7 @@
VALUE (*func)(ANYARGS); /* VALUE yieldarg[, VALUE procarg] */
VALUE val;
{
- struct BLOCK *data;
- VALUE proc = rb_iterate((VALUE(*)_((VALUE)))mproc, 0, func, val);
-
- Data_Get_Struct(proc, struct BLOCK, data);
- data->body->nd_state = YIELD_FUNC_AVALUE;
- return proc;
+ UNSUPPORTED(rb_proc_new);
}
/*
@@ -1060,35 +1023,20 @@
*/
static VALUE
-method_proc(method)
- VALUE method;
+method_proc(VALUE method)
{
- VALUE proc;
- struct METHOD *mdata;
- struct BLOCK *bdata;
-
- Data_Get_Struct(method, struct METHOD, mdata);
- if (nd_type(mdata->body) == NODE_BMETHOD) {
- return mdata->body->nd_cval;
- }
- proc = rb_iterate((VALUE(*)_((VALUE)))mproc, 0, bmcall, method);
- Data_Get_Struct(proc, struct BLOCK, bdata);
- bdata->body->nd_file = mdata->body->nd_file;
- nd_set_line(bdata->body, nd_line(mdata->body));
- bdata->body->nd_state = YIELD_FUNC_SVALUE;
- bdata->flags |= BLOCK_FROM_METHOD;
-
- return proc;
+ VALUE proc;
+ UNSUPPORTED(method_proc);
+ return proc;
}
static VALUE
-rb_obj_is_method(m)
- VALUE m;
+rb_obj_is_method(VALUE m)
{
- if (TYPE(m) == T_DATA && RDATA(m)->dmark == (RUBY_DATA_FUNC)bm_mark) {
- return Qtrue;
- }
- return Qfalse;
+ if (TYPE(m) == T_DATA && RDATA(m)->dmark == (RUBY_DATA_FUNC)bm_mark) {
+ return Qtrue;
+ }
+ return Qfalse;
}
/*
Modified: trunk/eval_safe.h
===================================================================
--- trunk/eval_safe.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_safe.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -40,9 +40,9 @@
int level;
{
if (level <= ruby_safe_level) {
- if (ruby_frame->callee) {
+ if (rb_frame_callee()) {
rb_raise(rb_eSecurityError, "Insecure operation `%s' at level %d",
- rb_id2name(ruby_frame->callee), ruby_safe_level);
+ rb_id2name(rb_frame_callee()), ruby_safe_level);
}
else {
rb_raise(rb_eSecurityError, "Insecure operation at level %d", ruby_safe_level);
@@ -62,9 +62,9 @@
VALUE x;
{
if (ruby_safe_level > 0 && OBJ_TAINTED(x)){
- if (ruby_frame->callee) {
+ if (rb_frame_callee()) {
rb_raise(rb_eSecurityError, "Insecure operation - %s",
- rb_id2name(ruby_frame->callee));
+ rb_id2name(rb_frame_callee()));
}
else {
rb_raise(rb_eSecurityError, "Insecure operation: -r");
Modified: trunk/eval_thread.c
===================================================================
--- trunk/eval_thread.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/eval_thread.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -492,7 +492,6 @@
th->win32_exception_list = win32_get_exception_list();
#endif
- th->frame = ruby_frame;
th->flags &= THREAD_FLAGS_MASK;
th->tag = prot_tag;
// th->tracing = tracing;
@@ -563,7 +562,6 @@
#endif
rb_trap_immediate = 0; /* inhibit interrupts from here */
- ruby_frame = th->frame;
prot_tag = th->tag;
// tracing = th->tracing;
ruby_errinfo = th->errinfo;
@@ -1581,7 +1579,6 @@
struct ruby_env *ip;
{
ip->tag = prot_tag;
- ip->frame = ruby_frame;
ip->prev = curr_thread->anchor;
curr_thread->anchor = ip;
}
@@ -2661,7 +2658,7 @@
return Qfalse;
}
else {
- VALUE list = rb_hash_aref(hash, ID2SYM(ruby_frame->this_func));
+ VALUE list = rb_hash_aref(hash, ID2SYM(rb_frame_this_func()));
if (NIL_P(list) || TYPE(list) != T_ARRAY) return Qfalse;
return rb_ary_includes(list, rb_obj_id(obj));
@@ -2675,7 +2672,7 @@
VALUE hash = rb_thread_local_aref(rb_thread_current(), recursive_key);
VALUE list, sym;
- sym = ID2SYM(ruby_frame->this_func);
+ sym = ID2SYM(rb_frame_this_func());
if (NIL_P(hash) || TYPE(hash) != T_HASH) {
hash = rb_hash_new();
rb_thread_local_aset(rb_thread_current(), recursive_key, hash);
@@ -2697,7 +2694,7 @@
VALUE hash = rb_thread_local_aref(rb_thread_current(), recursive_key);
VALUE list, sym;
- sym = ID2SYM(ruby_frame->this_func);
+ sym = ID2SYM(rb_frame_this_func());
if (NIL_P(hash) || TYPE(hash) != T_HASH) {
VALUE symname = rb_inspect(sym);
VALUE thrname = rb_inspect(rb_thread_current());
Modified: trunk/insnhelper.h
===================================================================
--- trunk/insnhelper.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/insnhelper.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -152,10 +152,6 @@
#define CHECK_STACK_OVERFLOW(th, cfp, margin) \
(((VALUE *)(cfp)->sp) + (margin) >= ((VALUE *)cfp))
-#define GET_BLOCK_PTR_IN_CFP(cfp) ((yarv_block_t *)(&(cfp)->self))
-#define GET_CFP_FROM_BLOCK_PTR(b) \
- ((yarv_control_frame_t *)((VALUE *)(b) - 5))
-
/**********************************************************/
/* deal with control flow 3: exception */
/**********************************************************/
Modified: trunk/io.c
===================================================================
--- trunk/io.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/io.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
io.c -
- $Author: ocean $
- $Date: 2005/09/20 08:14:56 $
+ $Author: akr $
+ $Date: 2005/09/24 00:17:41 $
created at: Fri Oct 15 18:08:59 JST 1993
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -1079,7 +1079,7 @@
rb_io_inspect(VALUE obj)
{
OpenFile *fptr;
- char *buf, *cname, *st = "";
+ char *cname, *st = "";
fptr = RFILE(rb_io_taint_check(obj))->fptr;
if (!fptr || !fptr->path) return rb_any_to_s(obj);
Modified: trunk/lib/fileutils.rb
===================================================================
--- trunk/lib/fileutils.rb 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/lib/fileutils.rb 2005-09-25 02:05:13 UTC (rev 259)
@@ -118,7 +118,7 @@
def cd(dir, options = {}, &block) # :yield: dir
fu_check_options options, :verbose
fu_output_message "cd #{dir}" if options[:verbose]
- Dir.chdir(dir, &block) unless options[:noop]
+ Dir.chdir(dir, &block)
fu_output_message 'cd -' if options[:verbose] and block
end
module_function :cd
@@ -1080,7 +1080,7 @@
def path
if @path
- @path
+ File.path(@path)
else
join(@prefix, @rel)
end
@@ -1486,6 +1486,9 @@
OPT_TABLE.keys.select {|m| OPT_TABLE[m].include?(opt.to_s) }
end
+ METHODS = singleton_methods() - %w( private_module_function
+ commands options have_option? options_of collect_method )
+
#
# This module has all methods of FileUtils module, but it outputs messages
# before acting. This equates to passing the <tt>:verbose</tt> flag to
@@ -1500,9 +1503,15 @@
def #{name}(*args)
super(*fu_update_option(args, :verbose => true))
end
+ private :#{name}
EOS
end
extend self
+ class << self
+ ::FileUtils::METHODS.each do |m|
+ public m
+ end
+ end
end
#
@@ -1519,9 +1528,15 @@
def #{name}(*args)
super(*fu_update_option(args, :noop => true))
end
+ private :#{name}
EOS
end
extend self
+ class << self
+ ::FileUtils::METHODS.each do |m|
+ public m
+ end
+ end
end
#
@@ -1539,9 +1554,15 @@
def #{name}(*args)
super(*fu_update_option(args, :noop => true, :verbose => true))
end
+ private :#{name}
EOS
end
extend self
+ class << self
+ ::FileUtils::METHODS.each do |m|
+ public m
+ end
+ end
end
end
Modified: trunk/missing/vsnprintf.c
===================================================================
--- trunk/missing/vsnprintf.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/missing/vsnprintf.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -220,13 +220,14 @@
int uio_resid;
};
+#if !defined(HAVE_VSNPRINTF) || !defined(HAVE_SNPRINTF)
/*
* Write some memory regions. Return zero on success, EOF on error.
*
* This routine is large and unsightly, but most of the ugliness due
* to the three different kinds of output buffering is handled here.
*/
-static BSD__sfvwrite(fp, uio)
+static int BSD__sfvwrite(fp, uio)
register FILE *fp;
register struct __suio *uio;
{
@@ -293,11 +294,8 @@
*/
}
return (0);
-
-err:
- fp->_flags |= __SERR;
- return (EOF);
}
+#endif
/*
* Actual printf innards.
Modified: trunk/pack.c
===================================================================
--- trunk/pack.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/pack.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
pack.c -
- $Author: ocean $
- $Date: 2005/09/14 06:32:32 $
+ $Author: akr $
+ $Date: 2005/09/24 00:17:41 $
created at: Thu Feb 10 15:17:05 JST 1994
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -2056,7 +2056,7 @@
rb_raise(rb_eArgError, "malformed UTF-8 character");
}
if (n > *lenp) {
- rb_raise(rb_eArgError, "malformed UTF-8 character (expected %d bytes, given %d bytes)",
+ rb_raise(rb_eArgError, "malformed UTF-8 character (expected %ld bytes, given %ld bytes)",
n, *lenp);
}
*lenp = n--;
Modified: trunk/parse.y
===================================================================
--- trunk/parse.y 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/parse.y 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
parse.y -
- $Author: aamine $
- $Date: 2005/09/19 05:49:08 $
+ $Author: ocean $
+ $Date: 2005/09/25 00:39:22 $
created at: Fri May 28 18:02:42 JST 1993
Copyright (C) 1993-2004 Yukihiro Matsumoto
@@ -218,7 +218,7 @@
int parser_heredoc_end;
int parser_command_start;
int parser_lex_gets_ptr;
- VALUE (*parser_lex_gets) _((struct parser_params*,VALUE));
+ VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
struct local_vars *parser_lvtbl;
int parser_ruby__end__seen;
#ifndef RIPPER
@@ -244,7 +244,7 @@
int has_shebang;
};
-static int parser_yyerror _((struct parser_params*, const char*));
+static int parser_yyerror(struct parser_params*, const char*);
#define yyerror(msg) parser_yyerror(parser, msg)
#define YYPARSE_PARAM parser_v
@@ -286,115 +286,114 @@
#define ruby_debug_lines (parser->debug_lines)
#endif
-static int yylex _((void*, void*));
+static int yylex(void*, void*);
#ifndef RIPPER
#define yyparse parser_yyparse
#define yydebug ruby_yydebug
-static NODE *cond_gen _((struct parser_params*,NODE*));
+static NODE *cond_gen(struct parser_params*,NODE*);
#define cond(node) cond_gen(parser, node)
-static NODE *logop_gen _((struct parser_params*,enum node_type,NODE*,NODE*));
+static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
#define logop(type,node1,node2) logop_gen(parser, type, node1, node2)
-static int cond_negative _((NODE**));
+static int cond_negative(NODE**);
-static NODE *newline_node _((NODE*));
-static void fixpos _((NODE*,NODE*));
+static NODE *newline_node(NODE*);
+static void fixpos(NODE*,NODE*);
-static int value_expr_gen _((struct parser_params*,NODE*));
-static void void_expr_gen _((struct parser_params*,NODE*));
-static NODE *remove_begin _((NODE*));
+static int value_expr_gen(struct parser_params*,NODE*);
+static void void_expr_gen(struct parser_params*,NODE*);
+static NODE *remove_begin(NODE*);
#define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
#define void_expr(node) void_expr_gen(parser, (node) = remove_begin(node))
-static void void_stmts_gen _((struct parser_params*,NODE*));
+static void void_stmts_gen(struct parser_params*,NODE*);
#define void_stmts(node) void_stmts_gen(parser, node)
-static void reduce_nodes _((NODE**));
-static void block_dup_check _((NODE*));
+static void reduce_nodes(NODE**);
+static void block_dup_check(NODE*);
-static NODE *block_append _((NODE*,NODE*));
-static NODE *list_append _((NODE*,NODE*));
-static NODE *list_concat _((NODE*,NODE*));
-static NODE *arg_concat _((NODE*,NODE*));
-static NODE *literal_concat _((NODE*,NODE*));
-static NODE *new_evstr _((NODE*));
-static NODE *evstr2dstr _((NODE*));
+static NODE *block_append(NODE*,NODE*);
+static NODE *list_append(NODE*,NODE*);
+static NODE *list_concat(NODE*,NODE*);
+static NODE *arg_concat(NODE*,NODE*);
+static NODE *literal_concat(NODE*,NODE*);
+static NODE *new_evstr(NODE*);
+static NODE *evstr2dstr(NODE*);
-static NODE *call_op_gen _((struct parser_params*,NODE*,ID,int,NODE*));
+static NODE *call_op_gen(struct parser_params*,NODE*,ID,int,NODE*);
#define call_op(recv,id,narg,arg1) call_op_gen(parser, recv,id,narg,arg1)
-static NODE *new_args_gen _((struct parser_params*,VALUE,NODE*,NODE*,NODE*));
+static NODE *new_args_gen(struct parser_params*,VALUE,NODE*,NODE*,NODE*);
#define new_args(f,o,r,b) new_args_gen(parser, f,o,r,b)
-static void shadowing_lvar_gen _((struct parser_params*,ID));
+static void shadowing_lvar_gen(struct parser_params*,ID);
#define shadowing_lvar(name) shadowing_lvar_gen(parser, name)
-static NODE *negate_lit _((NODE*));
-static NODE *ret_args _((NODE*));
-static NODE *arg_blk_pass _((NODE*,NODE*));
-static NODE *new_call _((NODE*,ID,NODE*));
-static NODE *new_fcall_gen _((struct parser_params*,ID,NODE*));
+static NODE *negate_lit(NODE*);
+static NODE *ret_args(NODE*);
+static NODE *arg_blk_pass(NODE*,NODE*);
+static NODE *new_call(NODE*,ID,NODE*);
+static NODE *new_fcall_gen(struct parser_params*,ID,NODE*);
#define new_fcall(id,args) new_fcall_gen(parser, id, args)
-static NODE *new_super _((NODE*));
-static NODE *new_yield _((NODE*));
+static NODE *new_super(NODE*);
+static NODE *new_yield(NODE*);
-static NODE *gettable_gen _((struct parser_params*,ID));
+static NODE *gettable_gen(struct parser_params*,ID);
#define gettable(id) gettable_gen(parser,id)
-static NODE *assignable_gen _((struct parser_params*,ID,NODE*));
+static NODE *assignable_gen(struct parser_params*,ID,NODE*);
#define assignable(id,node) assignable_gen(parser, id, node)
-static NODE *new_bv_gen _((struct parser_params*,ID,NODE*));
+static NODE *new_bv_gen(struct parser_params*,ID,NODE*);
#define new_bv(id,node) new_bv_gen(parser, id, node)
-static NODE *aryset_gen _((struct parser_params*,NODE*,NODE*));
+static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
#define aryset(node1,node2) aryset_gen(parser, node1, node2)
-static NODE *attrset_gen _((struct parser_params*,NODE*,ID));
+static NODE *attrset_gen(struct parser_params*,NODE*,ID);
#define attrset(node,id) attrset_gen(parser, node, id)
-static void rb_backref_error _((NODE*));
-static NODE *node_assign_gen _((struct parser_params*,NODE*,NODE*));
+static void rb_backref_error(NODE*);
+static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
#define node_assign(node1, node2) node_assign_gen(parser, node1, node2)
-static NODE *match_op_gen _((struct parser_params*,NODE*,NODE*));
+static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
#define match_op(node1,node2) match_op_gen(parser, node1, node2)
-static void local_push_gen _((struct parser_params*,int));
+static void local_push_gen(struct parser_params*,int);
#define local_push(top) local_push_gen(parser,top)
-static void local_pop_gen _((struct parser_params*));
+static void local_pop_gen(struct parser_params*);
#define local_pop() local_pop_gen(parser)
-static int local_append_gen _((struct parser_params*, ID));
+static int local_append_gen(struct parser_params*, ID);
#define local_append(id) local_append_gen(parser, id)
-static int local_cnt_gen _((struct parser_params*, ID));
+static int local_cnt_gen(struct parser_params*, ID);
#define local_cnt(id) local_cnt_gen(parser, id)
-static int local_id_gen _((struct parser_params*, ID));
+static int local_id_gen(struct parser_params*, ID);
#define local_id(id) local_id_gen(parser, id)
-static ID *local_tbl_gen _((struct parser_params*));
+static ID *local_tbl_gen(struct parser_params*);
#define local_tbl() local_tbl_gen(parser)
-static ID internal_id _((void));
+static ID internal_id(void);
-static int dyna_push_gen _((struct parser_params*));
+static int dyna_push_gen(struct parser_params*);
#define dyna_push() dyna_push_gen(parser)
-static void dyna_pop_gen _((struct parser_params*, struct RVarmap*));
+static void dyna_pop_gen(struct parser_params*, struct RVarmap*);
#define dyna_pop(vars) dyna_pop_gen(parser, vars)
-static int dyna_in_block_gen _((struct parser_params*));
+static int dyna_in_block_gen(struct parser_params*);
#define dyna_in_block() dyna_in_block_gen(parser)
-static NODE *dyna_init_gen _((struct parser_params*, NODE*, int));
+static NODE *dyna_init_gen(struct parser_params*, NODE*, int);
#define dyna_init(node, pre) dyna_init_gen(parser, node, pre)
-static void dyna_var_gen _((struct parser_params*,ID));
+static void dyna_var_gen(struct parser_params*,ID);
#define dyna_var(id) dyna_var_gen(parser, id)
-static void dyna_check_gen _((struct parser_params*,ID));
+static void dyna_check_gen(struct parser_params*,ID);
#define dyna_check(id) dyna_check_gen(parser, id)
-static int dvar_defined_gen _((struct parser_params*,ID));
+static int dvar_defined_gen(struct parser_params*,ID);
#define dvar_defined(id) dvar_defined_gen(parser, id)
-static int dvar_curr_gen _((struct parser_params*,ID));
+static int dvar_curr_gen(struct parser_params*,ID);
#define dvar_curr(id) dvar_curr_gen(parser, id)
-
-static void top_local_init_gen _((struct parser_params*));
+static void top_local_init_gen(struct parser_params*);
#define top_local_init() top_local_init_gen(parser)
-static void top_local_setup_gen _((struct parser_params*));
+static void top_local_setup_gen(struct parser_params*);
#define top_local_setup() top_local_setup_gen(parser)
#else
#define remove_begin(node) (node)
#endif /* !RIPPER */
-static int lvar_defined_gen _((struct parser_params*, ID));
+static int lvar_defined_gen(struct parser_params*, ID);
#define lvar_defined(id) lvar_defined_gen(parser, id)
#define RE_OPTION_ONCE (1<<16)
@@ -420,12 +419,12 @@
#include "eventids2.c"
static ID ripper_id_gets;
-static VALUE ripper_dispatch0 _((struct parser_params*,ID));
-static VALUE ripper_dispatch1 _((struct parser_params*,ID,VALUE));
-static VALUE ripper_dispatch2 _((struct parser_params*,ID,VALUE,VALUE));
-static VALUE ripper_dispatch3 _((struct parser_params*,ID,VALUE,VALUE,VALUE));
-static VALUE ripper_dispatch4 _((struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE));
-static VALUE ripper_dispatch5 _((struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE));
+static VALUE ripper_dispatch0(struct parser_params*,ID);
+static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
+static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
+static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
+static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
+static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
#define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
#define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), a)
@@ -437,8 +436,8 @@
#define yyparse ripper_yyparse
#define yydebug ripper_yydebug
-static VALUE ripper_intern _((const char*));
-static VALUE ripper_id2sym _((ID));
+static VALUE ripper_intern(const char*);
+static VALUE ripper_id2sym(ID);
#define arg_new() dispatch0(arglist_new)
#define arg_add(l,a) dispatch2(arglist_add, l, a)
@@ -488,15 +487,15 @@
# define rb_warnS(fmt,a) ripper_warnS(parser, fmt, a)
# define rb_warning0(fmt) ripper_warning0(parser, fmt)
# define rb_warningS(fmt,a) ripper_warningS(parser, fmt, a)
-static void ripper_warn0 _((struct parser_params*, const char*));
-static void ripper_warnI _((struct parser_params*, const char*, int));
-static void ripper_warnS _((struct parser_params*, const char*, const char*));
-static void ripper_warning0 _((struct parser_params*, const char*));
-static void ripper_warningS _((struct parser_params*, const char*, const char*));
+static void ripper_warn0(struct parser_params*, const char*);
+static void ripper_warnI(struct parser_params*, const char*, int);
+static void ripper_warnS(struct parser_params*, const char*, const char*);
+static void ripper_warning0(struct parser_params*, const char*);
+static void ripper_warningS(struct parser_params*, const char*, const char*);
#endif
#ifdef RIPPER
-static void ripper_compile_error _((struct parser_params*, const char *fmt, ...));
+static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
# define rb_compile_error ripper_compile_error
# define compile_error ripper_compile_error
# define PARSER_ARG parser,
@@ -1193,7 +1192,7 @@
/*%
%*/
}
- opt_block_param { $<num>$ = vtable_size(lvtbl->dvars);}
+ opt_block_param {$<num>$ = vtable_size(lvtbl->dvars);}
compstmt
'}'
{
@@ -4441,13 +4440,10 @@
# undef yylval
# define yylval (*((YYSTYPE*)(parser->parser_yylval)))
-#ifndef RIPPER
-static VALUE rb_parser_s_new _((void));
-#endif
-static int parser_regx_options _((struct parser_params*));
-static int parser_tokadd_string _((struct parser_params*,int,int,int,long*));
-static int parser_parse_string _((struct parser_params*,NODE*));
-static int parser_here_document _((struct parser_params*,NODE*));
+static int parser_regx_options(struct parser_params*);
+static int parser_tokadd_string(struct parser_params*,int,int,int,long*);
+static int parser_parse_string(struct parser_params*,NODE*);
+static int parser_here_document(struct parser_params*,NODE*);
# define nextc() parser_nextc(parser)
# define pushback(c) parser_pushback(parser, c)
@@ -4478,11 +4474,11 @@
# define set_yylval_node(x) yylval.node = x
# define yylval_id() yylval.id
#else
-# define set_yylval_str(x) x
-# define set_yylval_num(x) x
-# define set_yylval_id(x) x
-# define set_yylval_literal(x) x
-# define set_yylval_node(x) x
+# define set_yylval_str(x) (void)(x)
+# define set_yylval_num(x) (void)(x)
+# define set_yylval_id(x) (void)(x)
+# define set_yylval_literal(x) (void)(x)
+# define set_yylval_node(x) (void)(x)
# define yylval_id() SYM2ID(yylval.val)
#endif
@@ -4583,7 +4579,7 @@
return 0;
}
-static void parser_prepare _((struct parser_params *parser));
+static void parser_prepare(struct parser_params *parser);
#ifndef RIPPER
static NODE*
@@ -4593,7 +4589,6 @@
int line;
{
int n;
- NODE *node = 0;
const char *kcode_save;
if (!compile_for_eval && rb_safe_level() == 0 &&
@@ -4638,7 +4633,7 @@
}
#endif /* !RIPPER */
-static VALUE lex_get_str _((struct parser_params *, VALUE));
+static VALUE lex_get_str(struct parser_params *, VALUE);
static VALUE
lex_get_str(parser, s)
struct parser_params *parser;
@@ -4721,7 +4716,7 @@
return rb_parser_compile_string(vparser, f, rb_str_new(s, len), line);
}
-static VALUE lex_io_gets _((struct parser_params *, VALUE));
+static VALUE lex_io_gets(struct parser_params *, VALUE);
static VALUE
lex_io_gets(parser, io)
struct parser_params *parser;
@@ -5514,9 +5509,9 @@
/* emacsen -*- hack */
#ifndef RIPPER
-typedef void (*rb_pragma_setter_t) _((struct parser_params *parser, const char *name, const char *val));
+typedef void (*rb_pragma_setter_t)(struct parser_params *parser, const char *name, const char *val);
-static void pragma_encoding _((struct parser_params *, const char *, const char *));
+static void pragma_encoding(struct parser_params *, const char *, const char *);
static void
pragma_encoding(parser, name, val)
struct parser_params *parser;
@@ -7451,7 +7446,7 @@
{
switch (nd_type(node)) {
case NODE_NTH_REF:
- rb_compile_error("Can't set variable $%d", node->nd_nth);
+ rb_compile_error("Can't set variable $%ld", node->nd_nth);
break;
case NODE_BACK_REF:
rb_compile_error("Can't set variable $%c", (int)node->nd_nth);
@@ -7810,7 +7805,7 @@
if (!e_option_supplied()) parser_warning(node, str);
}
-static NODE *cond0 _((struct parser_params*,NODE*));
+static NODE *cond0(struct parser_params*,NODE*);
static NODE*
range_op(parser, node)
@@ -8131,20 +8126,6 @@
}
static NODE*
-fcall_gen(parser, m, a)
- struct parser_params *parser;
- ID m;
- NODE *a;
-{
- if (is_local_id(m)) {
- if ((dyna_in_block() && dvar_defined(m)) || local_id(m)) {
- return NEW_CALL(gettable(m), rb_intern("call"), a);
- }
- }
- return NEW_FCALL(m,a);
-}
-
-static NODE*
new_fcall_gen(parser, m, a)
struct parser_params *parser;
ID m;
@@ -8255,10 +8236,10 @@
extern int rb_dvar_current();
-extern int rb_scope_local_tbl_size();
-extern ID rb_scope_local_tbl_id(int i);
-extern int rb_scope_setup(int len);
-extern void rb_scope_setup_local_tbl(ID *tbl);
+extern int rb_scope_local_tbl_size _(());
+extern ID rb_scope_local_tbl_id _((int i));
+extern int rb_scope_setup _((int len));
+extern void rb_scope_setup_local_tbl _((ID *tbl));
static void
top_local_init_gen(parser)
@@ -8296,7 +8277,6 @@
lvtbl->dvars = vtable_alloc(lvtbl->dvars);
}
vtable_add(lvtbl->dvars, id);
-
if(!vtable_included(lvtbl->dnames, id)){
if(!lvtbl->dnames){
lvtbl->dnames = vtable_alloc(0);
@@ -8882,7 +8862,7 @@
#ifdef RIPPER
#ifdef RIPPER_DEBUG
-extern int rb_is_pointer_to_heap _((VALUE));
+extern int rb_is_pointer_to_heap(VALUE);
/* :nodoc: */
static VALUE
@@ -9164,7 +9144,7 @@
rb_str_new2(fmt), rb_str_new2(str));
}
-static VALUE ripper_lex_get_generic _((struct parser_params *, VALUE));
+static VALUE ripper_lex_get_generic(struct parser_params *, VALUE);
static VALUE
ripper_lex_get_generic(parser, src)
@@ -9174,7 +9154,7 @@
return rb_funcall(src, ripper_id_gets, 0);
}
-static VALUE ripper_s_allocate _((VALUE));
+static VALUE ripper_s_allocate(VALUE);
static VALUE
ripper_s_allocate(klass)
@@ -9272,7 +9252,7 @@
return flag;
}
-extern VALUE rb_thread_pass _((void));
+extern VALUE rb_thread_pass(void);
struct ripper_args {
struct parser_params *parser;
@@ -9398,7 +9378,7 @@
#endif
void
-Init_ripper()
+Init_ripper(void)
{
VALUE Ripper;
@@ -9419,8 +9399,8 @@
#endif
ripper_id_gets = rb_intern("gets");
- ripper_init_eventids1();
- ripper_init_eventids2();
+ ripper_init_eventids1(Ripper);
+ ripper_init_eventids2(Ripper);
/* ensure existing in symbol table */
rb_intern("||");
rb_intern("&&");
Modified: trunk/process.c
===================================================================
--- trunk/process.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/process.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
process.c -
- $Author: ocean $
- $Date: 2005/09/14 08:30:15 $
+ $Author: akr $
+ $Date: 2005/09/24 16:36:11 $
created at: Tue Aug 10 14:30:50 JST 1993
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -1938,22 +1938,29 @@
/*
* call-seq:
* Process.setrlimit(resource, cur_limit, max_limit) => nil
+ * Process.setrlimit(resource, cur_limit) => nil
*
* Sets the resource limit of the process.
* _cur_limit_ means current (soft) limit and
* _max_limit_ means maximum (hard) limit.
*
+ * If _max_limit_ is not given, _cur_limit_ is used.
+ *
* _resource_ indicates the kind of resource to limit.
- * Although the list of resources are OS dependent,
- * SUSv3 defines following resources.
+ * The list of resources are OS dependent.
+ * Ruby may support following resources.
*
- * [Process::RLIMIT_CORE] core size (bytes)
- * [Process::RLIMIT_CPU] CPU time (seconds)
- * [Process::RLIMIT_DATA] data segment (bytes)
- * [Process::RLIMIT_FSIZE] file size (bytes)
- * [Process::RLIMIT_NOFILE] file descriptors (number)
- * [Process::RLIMIT_STACK] stack size (bytes)
- * [Process::RLIMIT_AS] total available memory (bytes)
+ * [Process::RLIMIT_CORE] core size (bytes) (SUSv3)
+ * [Process::RLIMIT_CPU] CPU time (seconds) (SUSv3)
+ * [Process::RLIMIT_DATA] data segment (bytes) (SUSv3)
+ * [Process::RLIMIT_FSIZE] file size (bytes) (SUSv3)
+ * [Process::RLIMIT_NOFILE] file descriptors (number) (SUSv3)
+ * [Process::RLIMIT_STACK] stack size (bytes) (SUSv3)
+ * [Process::RLIMIT_AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
+ * [Process::RLIMIT_MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
+ * [Process::RLIMIT_NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux)
+ * [Process::RLIMIT_RSS] resident memory size (bytes) (4.2BSD, GNU/Linux)
+ * [Process::RLIMIT_SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD)
*
* Other <code>Process::RLIMIT_???</code> constants may be defined.
*
@@ -1966,13 +1973,18 @@
*/
static VALUE
-proc_setrlimit(VALUE obj, VALUE resource, VALUE rlim_cur, VALUE rlim_max)
+proc_setrlimit(int argc, VALUE *argv, VALUE obj)
{
#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
+ VALUE resource, rlim_cur, rlim_max;
struct rlimit rlim;
rb_secure(2);
+ rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max);
+ if (rlim_max == Qnil)
+ rlim_max = rlim_cur;
+
rlim.rlim_cur = NUM2RLIM(rlim_cur);
rlim.rlim_max = NUM2RLIM(rlim_max);
@@ -3626,7 +3638,7 @@
rb_define_module_function(rb_mProcess, "getrlimit", proc_getrlimit, 1);
#endif
#ifdef HAVE_SETRLIMIT
- rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, 3);
+ rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, -1);
#endif
#ifdef RLIM2NUM
#ifdef RLIM_INFINITY
Added: trunk/rb/mklog.rb
===================================================================
--- trunk/rb/mklog.rb 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/rb/mklog.rb 2005-09-25 02:05:13 UTC (rev 259)
@@ -0,0 +1,15 @@
+files = []
+`svn diff`.each{|line|
+ if /\+\+\+ (.+)\t\(working copy\)/ =~ line
+ files << $1
+ end
+ puts line
+}
+
+#"%Y-%m-%d(%a) %H:%M:%S %Z"
+puts "#{Time.now.strftime('%Y-%m-%d(%a) %H:%M:%S +0900')} Koichi Sasada <ko1 atdot.net>"
+puts
+files.sort.each{|file|
+ puts "\t* #{file} : "
+ puts
+}
Property changes on: trunk/rb/mklog.rb
___________________________________________________________________
Name: svn:executable
+ *
Modified: trunk/signal.c
===================================================================
--- trunk/signal.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/signal.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
signal.c -
- $Author: ocean $
- $Date: 2005/09/14 08:30:16 $
+ $Author: akr $
+ $Date: 2005/09/24 23:11:11 $
created at: Tue Dec 20 10:13:44 JST 1994
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -423,15 +423,15 @@
}
}
+#if defined(HAVE_NATIVETHREAD) && defined(HAVE_NATIVETHREAD_KILL)
static void
sigsend_to_ruby_thread(int sig)
{
-#ifdef HAVE_NATIVETHREAD_KILL
-# ifdef HAVE_SIGPROCMASK
+#ifdef HAVE_SIGPROCMASK
sigset_t mask, old_mask;
-# else
+#else
int mask, old_mask;
-# endif
+#endif
#ifdef HAVE_SIGPROCMASK
sigfillset(&mask);
@@ -442,8 +442,8 @@
#endif
ruby_native_thread_kill(sig);
+}
#endif
-}
static RETSIGTYPE sighandler(int);
static RETSIGTYPE
@@ -571,7 +571,7 @@
trap(struct trap_arg *arg)
{
sighandler_t func, oldfunc;
- VALUE command, tmp, oldcmd;
+ VALUE command, oldcmd;
int sig = -1;
char *s;
Modified: trunk/struct.c
===================================================================
--- trunk/struct.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/struct.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
struct.c -
- $Author: ocean $
- $Date: 2005/09/14 06:32:32 $
+ $Author: akr $
+ $Date: 2005/09/24 00:17:41 $
created at: Tue Mar 22 18:44:30 JST 1995
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -48,7 +48,7 @@
VALUE members = rb_struct_s_members(rb_obj_class(s));
if (RSTRUCT(s)->len != RARRAY(members)->len) {
- rb_raise(rb_eTypeError, "struct size differs (%d required %d given)",
+ rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
RARRAY(members)->len, RSTRUCT(s)->len);
}
return members;
@@ -583,7 +583,7 @@
rb_struct_modify(s);
len = RARRAY(members)->len;
if (RSTRUCT(s)->len != RARRAY(members)->len) {
- rb_raise(rb_eTypeError, "struct size differs (%d required %d given)",
+ rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
RARRAY(members)->len, RSTRUCT(s)->len);
}
for (i=0; i<len; i++) {
Modified: trunk/test.rb
===================================================================
--- trunk/test.rb 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/test.rb 2005-09-25 02:05:13 UTC (rev 259)
@@ -1,3 +1,14 @@
+p lambda{}
+
+__END__
+pr = proc{
+ p 1
+}
+
+pr.call
+
+__END__
+
def proc &pr
pr
end
Modified: trunk/time.c
===================================================================
--- trunk/time.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/time.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -2,8 +2,8 @@
time.c -
- $Author: ocean $
- $Date: 2005/09/14 06:32:32 $
+ $Author: akr $
+ $Date: 2005/09/24 23:45:46 $
created at: Tue Dec 28 14:31:59 JST 1993
Copyright (C) 1993-2003 Yukihiro Matsumoto
@@ -1896,6 +1896,7 @@
}
if ((p & (1<<31)) == 0) {
+ gmt = 0;
sec = p;
usec = s;
}
Modified: trunk/variable.c
===================================================================
--- trunk/variable.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/variable.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -1164,7 +1164,7 @@
struct st_table *tbl;
if (!rb_is_const_id(id)) {
- rb_raise(rb_eNameError, "autoload must be constant name", rb_id2name(id));
+ rb_raise(rb_eNameError, "autoload must be constant name: %s", rb_id2name(id));
}
if (!file || !*file) {
rb_raise(rb_eArgError, "empty file name");
Modified: trunk/version.h
===================================================================
--- trunk/version.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/version.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -1,14 +1,14 @@
#define RUBY_VERSION "1.9.0"
-#define RUBY_RELEASE_DATE "2005-09-23"
+#define RUBY_RELEASE_DATE "2005-09-25"
#define RUBY_VERSION_CODE 190
-#define RUBY_RELEASE_CODE 20050923
+#define RUBY_RELEASE_CODE 20050925
#define RUBY_VERSION_MAJOR 1
#define RUBY_VERSION_MINOR 9
#define RUBY_VERSION_TEENY 0
#define RUBY_RELEASE_YEAR 2005
#define RUBY_RELEASE_MONTH 9
-#define RUBY_RELEASE_DAY 23
+#define RUBY_RELEASE_DAY 25
RUBY_EXTERN const char ruby_version[];
RUBY_EXTERN const char ruby_release_date[];
Modified: trunk/vm.c
===================================================================
--- trunk/vm.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/vm.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -828,14 +828,9 @@
struct tag {
rb_jmpbuf_t buf;
- struct FRAME *frame;
- struct iter *iter;
VALUE tag;
VALUE retval;
- struct SCOPE *scope;
- VALUE dst;
struct tag *prev;
- int blkid;
};
#if YARVEXT
@@ -844,18 +839,21 @@
RUBY_EXTERN struct tag *ruby_prot_tag;
#endif
-#define PUSH_TAG(ptag) do { \
- _tag.prev = ruby_prot_tag; \
- _tag.iter = ruby_prot_tag->iter; \
- _tag.frame = ruby_frame; \
- _tag.tag = ptag; \
- ruby_prot_tag = &_tag; \
-} while(0)
+#define PUSH_TAG(ptag) do { \
+ struct tag _tag; \
+ _tag.prev = ruby_prot_tag; \
+ _tag.tag = ptag; \
+ ruby_prot_tag = &_tag
-#define POP_TAG() do { \
- ruby_prot_tag = ruby_prot_tag->prev; \
-} while(0)
+#define POP_TAG() \
+ ruby_prot_tag = _tag.prev; \
+} while (0)
+#define POP_TAG2() \
+ ruby_prot_tag = _tag.prev; \
+
+
+
#define EXEC_TAG() \
(FLUSH_REGISTER_WINDOWS, setjmp(ruby_prot_tag->buf))
@@ -1213,7 +1211,7 @@
else{
th->cfp++;
ruby_errinfo = err;
- POP_TAG();
+ POP_TAG2();
JUMP_TAG(state);
}
}
Modified: trunk/vm_macro.def
===================================================================
--- trunk/vm_macro.def 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/vm_macro.def 2005-09-25 02:05:13 UTC (rev 259)
@@ -60,7 +60,6 @@
reg_cfp->sp -= num + 1;
- ruby_frame->this_func = id; /* for coerse calculation */
val = call_cfunc(mn->nd_cfnc, recv, mn->nd_argc, num,
reg_cfp->sp + 1);
Modified: trunk/yarvcore.c
===================================================================
--- trunk/yarvcore.c 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/yarvcore.c 2005-09-25 02:05:13 UTC (rev 259)
@@ -105,16 +105,6 @@
yarvCurrentRunningThread = th;
}
-/* rb_block_given */
-int yarv_block_given_p(){
- if(GC_GUARDED_PTR_REF(GET_THREAD()->cfp->lfp[0])){
- return 1;
- }
- else{
- return 0;
- }
-}
-
VALUE th_invoke_yield(yarv_thread_t *th, int argc, VALUE *argv);
/* rb_yield_values */
Modified: trunk/yarvcore.h
===================================================================
--- trunk/yarvcore.h 2005-09-24 06:52:46 UTC (rev 258)
+++ trunk/yarvcore.h 2005-09-25 02:05:13 UTC (rev 259)
@@ -387,7 +387,14 @@
#define YARV_METHOD_NODE NODE_METHOD
+#define YARV_PERVIOUS_CONTROL_FRAME(cfp) (cfp+1)
+#define YARV_NEXT_CONTROL_FRAME(cfp) (cfp-1)
+#define GET_BLOCK_PTR_IN_CFP(cfp) ((yarv_block_t *)(&(cfp)->self))
+#define GET_CFP_FROM_BLOCK_PTR(b) \
+ ((yarv_control_frame_t *)((VALUE *)(b) - 5))
+
+
/* defined? */
#define DEFINED_IVAR INT2FIX(1)
#define DEFINED_GVAR INT2FIX(2)
--
ML: yarv-diff quickml.atdot.net
Info: http://www.atdot.net/~ko1/quickml