ruby-internal 0.6.0 → 0.7.0

data/ext/cached/ruby-1.9.1/internal/vm/instruction/insns_info.h

@@ -185,10 +185,9 @@ enum ruby_vminsn_type {
 
   BIN(answer)                    = 78,
 
+  VM_INSTRUCTION_SIZE            = 79
 };
 
-#define VM_INSTRUCTION_SIZE 79
-
 /** -*-c-*-
   This file contains instruction information for yarv instruction sequence.
   

data/ext/cached/ruby-1.9.1/internal/vm/iseq/iseq_load.inc

@@ -0,0 +1,356 @@
+#ifndef ruby_internal_iseq_load__inc_
+#define ruby_internal_iseq_load__inc_
+
+#include "internal/yarv-headers/gc.h"
+#include "internal/yarv-headers/iseq.h"
+
+static void
+compile_data_free(struct iseq_compile_data *compile_data)
+{
+    if (compile_data) {
+	struct iseq_compile_data_storage *cur, *next;
+	cur = compile_data->storage_head;
+	while (cur) {
+	    next = cur->next;
+	    ruby_xfree(cur);
+	    cur = next;
+	}
+	ruby_xfree(compile_data);
+    }
+}
+static void
+iseq_free(void *ptr)
+{
+    rb_iseq_t *iseq;
+    RUBY_FREE_ENTER("iseq");
+
+    if (ptr) {
+	iseq = ptr;
+	if (!iseq->orig) {
+	    /* It's possible that strings are freed
+	     * GC_INFO("%s @ %s\n", RSTRING_PTR(iseq->name),
+	     *                      RSTRING_PTR(iseq->filename));
+	     */
+	    if (iseq->iseq != iseq->iseq_encoded) {
+		RUBY_FREE_UNLESS_NULL(iseq->iseq_encoded);
+	    }
+
+	    RUBY_FREE_UNLESS_NULL(iseq->iseq);
+	    RUBY_FREE_UNLESS_NULL(iseq->insn_info_table);
+	    RUBY_FREE_UNLESS_NULL(iseq->local_table);
+	    RUBY_FREE_UNLESS_NULL(iseq->catch_table);
+	    RUBY_FREE_UNLESS_NULL(iseq->arg_opt_table);
+	    compile_data_free(iseq->compile_data);
+	}
+	ruby_xfree(ptr);
+    }
+    RUBY_FREE_LEAVE("iseq");
+}
+static void
+iseq_mark(void *ptr)
+{
+    rb_iseq_t *iseq;
+    RUBY_MARK_ENTER("iseq");
+
+    if (ptr) {
+	iseq = ptr;
+	RUBY_GC_INFO("%s @ %s\n", RSTRING_PTR(iseq->name), RSTRING_PTR(iseq->filename));
+	RUBY_MARK_UNLESS_NULL(iseq->mark_ary);
+	RUBY_MARK_UNLESS_NULL(iseq->name);
+	RUBY_MARK_UNLESS_NULL(iseq->filename);
+	RUBY_MARK_UNLESS_NULL((VALUE)iseq->cref_stack);
+	RUBY_MARK_UNLESS_NULL(iseq->klass);
+	RUBY_MARK_UNLESS_NULL(iseq->coverage);
+/* 	RUBY_MARK_UNLESS_NULL((VALUE)iseq->node); */
+/*	RUBY_MARK_UNLESS_NULL(iseq->cached_special_block); */
+	RUBY_MARK_UNLESS_NULL(iseq->orig);
+
+	if (iseq->compile_data != 0) {
+	    RUBY_MARK_UNLESS_NULL(iseq->compile_data->mark_ary);
+	    RUBY_MARK_UNLESS_NULL(iseq->compile_data->err_info);
+	    RUBY_MARK_UNLESS_NULL(iseq->compile_data->catch_table_ary);
+	}
+    }
+    RUBY_MARK_LEAVE("iseq");
+}
+static VALUE
+iseq_alloc(VALUE klass)
+{
+    VALUE volatile obj;
+    rb_iseq_t *iseq;
+
+    obj = Data_Make_Struct(klass, rb_iseq_t, iseq_mark, iseq_free, iseq);
+    MEMZERO(iseq, rb_iseq_t, 1);
+    return obj;
+}
+static void
+set_relation(rb_iseq_t *iseq, const VALUE parent)
+{
+    const int type = iseq->type;
+    rb_thread_t *th = GET_THREAD();
+
+    /* set class nest stack */
+    if (type == ISEQ_TYPE_TOP) {
+	/* toplevel is private */
+	iseq->cref_stack = NEW_BLOCK(th->top_wrapper ? th->top_wrapper : rb_cObject);
+	iseq->cref_stack->nd_file = 0;
+	iseq->cref_stack->nd_visi = NOEX_PRIVATE;
+    }
+    else if (type == ISEQ_TYPE_METHOD || type == ISEQ_TYPE_CLASS) {
+	iseq->cref_stack = NEW_BLOCK(0); /* place holder */
+	iseq->cref_stack->nd_file = 0;
+    }
+    else if (RTEST(parent)) {
+	rb_iseq_t *piseq;
+	GetISeqPtr(parent, piseq);
+	iseq->cref_stack = piseq->cref_stack;
+    }
+
+    if (type == ISEQ_TYPE_TOP ||
+	type == ISEQ_TYPE_METHOD || type == ISEQ_TYPE_CLASS) {
+	iseq->local_iseq = iseq;
+    }
+    else if (RTEST(parent)) {
+	rb_iseq_t *piseq;
+	GetISeqPtr(parent, piseq);
+	iseq->local_iseq = piseq->local_iseq;
+    }
+
+    if (RTEST(parent)) {
+	rb_iseq_t *piseq;
+	GetISeqPtr(parent, piseq);
+	iseq->parent_iseq = piseq;
+    }
+}
+static VALUE
+prepare_iseq_build(rb_iseq_t *iseq,
+		   VALUE name, VALUE filename,
+		   VALUE parent, VALUE type, VALUE block_opt,
+		   const rb_compile_option_t *option)
+{
+    OBJ_FREEZE(name);
+    OBJ_FREEZE(filename);
+
+    iseq->name = name;
+    iseq->filename = filename;
+    iseq->defined_method_id = 0;
+    iseq->mark_ary = rb_ary_new();
+    RBASIC(iseq->mark_ary)->klass = 0;
+
+    iseq->type = type;
+    iseq->arg_rest = -1;
+    iseq->arg_block = -1;
+    iseq->klass = 0;
+
+    /*
+     * iseq->special_block_builder = GC_GUARDED_PTR_REF(block_opt);
+     * iseq->cached_special_block_builder = 0;
+     * iseq->cached_special_block = 0;
+     */
+
+    iseq->compile_data = ALLOC(struct iseq_compile_data);
+    MEMZERO(iseq->compile_data, struct iseq_compile_data, 1);
+    iseq->compile_data->mark_ary = rb_ary_new();
+    RBASIC(iseq->compile_data->mark_ary)->klass = 0;
+
+    iseq->compile_data->storage_head = iseq->compile_data->storage_current =
+      (struct iseq_compile_data_storage *)
+	ALLOC_N(char, INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE +
+		sizeof(struct iseq_compile_data_storage));
+
+    iseq->compile_data->catch_table_ary = rb_ary_new();
+    iseq->compile_data->storage_head->pos = 0;
+    iseq->compile_data->storage_head->next = 0;
+    iseq->compile_data->storage_head->size =
+      INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE;
+    iseq->compile_data->storage_head->buff =
+      (char *)(&iseq->compile_data->storage_head->buff + 1);
+    iseq->compile_data->option = option;
+
+    set_relation(iseq, parent);
+
+    iseq->coverage = Qfalse;
+    if (!GET_THREAD()->parse_in_eval) {
+	extern VALUE rb_get_coverages(void);
+	VALUE coverages = rb_get_coverages();
+	if (RTEST(coverages)) {
+	    iseq->coverage = rb_hash_lookup(coverages, filename);
+	    if (NIL_P(iseq->coverage)) iseq->coverage = Qfalse;
+	}
+    }
+
+    return Qtrue;
+}
+static VALUE
+cleanup_iseq_build(rb_iseq_t *iseq)
+{
+    struct iseq_compile_data *data = iseq->compile_data;
+    VALUE err = data->err_info;
+    iseq->compile_data = 0;
+    compile_data_free(data);
+
+    if (RTEST(err)) {
+	rb_funcall2(err, rb_intern("set_backtrace"), 1, &iseq->filename);
+	rb_exc_raise(err);
+    }
+    return Qtrue;
+}
+static rb_compile_option_t COMPILE_OPTION_DEFAULT = {
+    OPT_INLINE_CONST_CACHE, /* int inline_const_cache; */
+    OPT_PEEPHOLE_OPTIMIZATION, /* int peephole_optimization; */
+    OPT_TAILCALL_OPTIMIZATION, /* int tailcall_optimization */
+    OPT_SPECIALISED_INSTRUCTION, /* int specialized_instruction; */
+    OPT_OPERANDS_UNIFICATION, /* int operands_unification; */
+    OPT_INSTRUCTIONS_UNIFICATION, /* int instructions_unification; */
+    OPT_STACK_CACHING, /* int stack_caching; */
+    OPT_TRACE_INSTRUCTION, /* int trace_instruction */
+};
+static const rb_compile_option_t COMPILE_OPTION_FALSE = {0};
+static void
+make_compile_option(rb_compile_option_t *option, VALUE opt)
+{
+    if (opt == Qnil) {
+	*option = COMPILE_OPTION_DEFAULT;
+    }
+    else if (opt == Qfalse) {
+	*option = COMPILE_OPTION_FALSE;
+    }
+    else if (opt == Qtrue) {
+	memset(option, 1, sizeof(rb_compile_option_t));
+    }
+    else if (CLASS_OF(opt) == rb_cHash) {
+	*option = COMPILE_OPTION_DEFAULT;
+
+#define SET_COMPILE_OPTION(o, h, mem) \
+  { VALUE flag = rb_hash_aref(h, ID2SYM(rb_intern(#mem))); \
+      if (flag == Qtrue)  { o->mem = 1; } \
+      else if (flag == Qfalse)  { o->mem = 0; } \
+  }
+#define SET_COMPILE_OPTION_NUM(o, h, mem) \
+  { VALUE num = rb_hash_aref(opt, ID2SYM(rb_intern(#mem))); \
+      if (!NIL_P(num)) o->mem = NUM2INT(num); \
+  }
+	SET_COMPILE_OPTION(option, opt, inline_const_cache);
+	SET_COMPILE_OPTION(option, opt, peephole_optimization);
+	SET_COMPILE_OPTION(option, opt, tailcall_optimization);
+	SET_COMPILE_OPTION(option, opt, specialized_instruction);
+	SET_COMPILE_OPTION(option, opt, operands_unification);
+	SET_COMPILE_OPTION(option, opt, instructions_unification);
+	SET_COMPILE_OPTION(option, opt, stack_caching);
+	SET_COMPILE_OPTION(option, opt, trace_instruction);
+	SET_COMPILE_OPTION_NUM(option, opt, debug_level);
+#undef SET_COMPILE_OPTION
+#undef SET_COMPILE_OPTION_NUM
+    }
+    else {
+	rb_raise(rb_eTypeError, "Compile option must be Hash/true/false/nil");
+    }
+}
+static VALUE
+make_compile_option_value(rb_compile_option_t *option)
+{
+    VALUE opt = rb_hash_new();
+#define SET_COMPILE_OPTION(o, h, mem) \
+  rb_hash_aset(h, ID2SYM(rb_intern(#mem)), o->mem ? Qtrue : Qfalse)
+#define SET_COMPILE_OPTION_NUM(o, h, mem) \
+  rb_hash_aset(h, ID2SYM(rb_intern(#mem)), INT2NUM(o->mem))
+    {
+	SET_COMPILE_OPTION(option, opt, inline_const_cache);
+	SET_COMPILE_OPTION(option, opt, peephole_optimization);
+	SET_COMPILE_OPTION(option, opt, tailcall_optimization);
+	SET_COMPILE_OPTION(option, opt, specialized_instruction);
+	SET_COMPILE_OPTION(option, opt, operands_unification);
+	SET_COMPILE_OPTION(option, opt, instructions_unification);
+	SET_COMPILE_OPTION(option, opt, stack_caching);
+	SET_COMPILE_OPTION_NUM(option, opt, debug_level);
+    }
+#undef SET_COMPILE_OPTION
+#undef SET_COMPILE_OPTION_NUM
+    return opt;
+}
+#define CHECK_ARRAY(v)   rb_convert_type(v, T_ARRAY, "Array", "to_ary")
+#define CHECK_STRING(v)  rb_convert_type(v, T_STRING, "String", "to_str")
+#define CHECK_SYMBOL(v)  rb_convert_type(v, T_SYMBOL, "Symbol", "to_sym")
+static inline VALUE CHECK_INTEGER(VALUE v) {NUM2LONG(v); return v;}
+static VALUE
+iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
+{
+    VALUE iseqval = iseq_alloc(self);
+
+    VALUE magic, version1, version2, format_type, misc;
+    VALUE name, filename;
+    VALUE type, body, locals, args, exception;
+
+    VALUE iseq_type;
+    struct st_table *type_map = 0;
+    rb_iseq_t *iseq;
+    rb_compile_option_t option;
+    int i = 0;
+
+    /* [magic, major_version, minor_version, format_type, misc,
+     *  name, filename,
+     *  type, locals, args, exception_table, body]
+     */
+
+    data        = CHECK_ARRAY(data);
+
+    magic       = CHECK_STRING(rb_ary_entry(data, i++));
+    version1    = CHECK_INTEGER(rb_ary_entry(data, i++));
+    version2    = CHECK_INTEGER(rb_ary_entry(data, i++));
+    format_type = CHECK_INTEGER(rb_ary_entry(data, i++));
+    misc        = rb_ary_entry(data, i++); /* TODO */
+
+    name        = CHECK_STRING(rb_ary_entry(data, i++));
+    filename    = CHECK_STRING(rb_ary_entry(data, i++));
+
+    type        = CHECK_SYMBOL(rb_ary_entry(data, i++));
+    locals      = CHECK_ARRAY(rb_ary_entry(data, i++));
+
+    args        = rb_ary_entry(data, i++);
+    if (FIXNUM_P(args) || (args = CHECK_ARRAY(args))) {
+	/* */
+    }
+
+    exception   = CHECK_ARRAY(rb_ary_entry(data, i++));
+    body        = CHECK_ARRAY(rb_ary_entry(data, i++));
+
+    GetISeqPtr(iseqval, iseq);
+    iseq->self = iseqval;
+
+    if (type_map == 0) {
+	type_map = st_init_numtable();
+	st_insert(type_map, ID2SYM(rb_intern("top")), ISEQ_TYPE_TOP);
+	st_insert(type_map, ID2SYM(rb_intern("method")), ISEQ_TYPE_METHOD);
+	st_insert(type_map, ID2SYM(rb_intern("block")), ISEQ_TYPE_BLOCK);
+	st_insert(type_map, ID2SYM(rb_intern("class")), ISEQ_TYPE_CLASS);
+	st_insert(type_map, ID2SYM(rb_intern("rescue")), ISEQ_TYPE_RESCUE);
+	st_insert(type_map, ID2SYM(rb_intern("ensure")), ISEQ_TYPE_ENSURE);
+	st_insert(type_map, ID2SYM(rb_intern("eval")), ISEQ_TYPE_EVAL);
+	st_insert(type_map, ID2SYM(rb_intern("main")), ISEQ_TYPE_MAIN);
+	st_insert(type_map, ID2SYM(rb_intern("defined_guard")), ISEQ_TYPE_DEFINED_GUARD);
+    }
+
+    if (st_lookup(type_map, type, &iseq_type) == 0) {
+	const char *typename = rb_id2name(type);
+	if (typename)
+	    rb_raise(rb_eTypeError, "unsupport type: :%s", typename);
+	else
+	    rb_raise(rb_eTypeError, "unsupport type: %p", (void *)type);
+    }
+
+    if (parent == Qnil) {
+	parent = 0;
+    }
+
+    make_compile_option(&option, opt);
+    prepare_iseq_build(iseq, name, filename,
+		       parent, iseq_type, 0, &option);
+
+    rb_iseq_build_from_ary(iseq, locals, args, exception, body);
+
+    cleanup_iseq_build(iseq);
+    return iseqval;
+}
+
+#endif
+

data/ext/cached/ruby-1.9.1/internal/yarv-headers/eval_intern.h

@@ -67,7 +67,12 @@ char *strrchr(const char *, const char);
 #define ruby_setjmp(env) RUBY_SETJMP(env)
 #define ruby_longjmp(env,val) RUBY_LONGJMP(env,val)
 #ifdef __CYGWIN__
-int _setjmp(), _longjmp();
+# ifndef _setjmp
+int _setjmp(jmp_buf);
+# endif
+# ifndef _longjmp
+NORETURN(void _longjmp(jmp_buf, int));
+# endif
 #endif
 
 #include <sys/types.h>
@@ -162,9 +167,9 @@ enum ruby_tag_type {
 #define GET_THROWOBJ_CATCH_POINT(obj) ((VALUE*)RNODE((obj))->u2.value)
 #define GET_THROWOBJ_STATE(obj)       ((int)RNODE((obj))->u3.value)
 
-#define SCOPE_TEST(f)  (vm_cref()->nd_visi & (f))
-#define SCOPE_CHECK(f) (vm_cref()->nd_visi == (f))
-#define SCOPE_SET(f)   (vm_cref()->nd_visi = (f))
+#define SCOPE_TEST(f)  (rb_vm_cref()->nd_visi & (f))
+#define SCOPE_CHECK(f) (rb_vm_cref()->nd_visi == (f))
+#define SCOPE_SET(f)   (rb_vm_cref()->nd_visi = (f))
 
 #define CHECK_STACK_OVERFLOW(cfp, margin) do \
   if (((VALUE *)(cfp)->sp) + (margin) + sizeof(rb_control_frame_t) >= ((VALUE *)cfp)) { \
@@ -193,12 +198,13 @@ VALUE rb_make_exception(int argc, VALUE *argv);
 NORETURN(void rb_fiber_start(void));
 
 NORETURN(void rb_print_undef(VALUE, ID, int));
-NORETURN(void vm_localjump_error(const char *,VALUE, int));
-NORETURN(void vm_jump_tag_but_local_jump(int, VALUE));
+NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
+NORETURN(void rb_vm_jump_tag_but_local_jump(int, VALUE));
+NORETURN(void rb_raise_method_missing(rb_thread_t *th, int argc, VALUE *argv,
+				      VALUE obj, int call_status));
 
-VALUE vm_make_jump_tag_but_local_jump(int state, VALUE val);
-NODE *vm_cref(void);
-rb_control_frame_t *vm_get_ruby_level_caller_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
+VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
+NODE *rb_vm_cref(void);
 VALUE rb_obj_is_proc(VALUE);
 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);

data/ext/cached/ruby-1.9.1/internal/yarv-headers/id.h

@@ -3,8 +3,8 @@
 
   id.h - 
 
-  $Author: ko1 $
-  created at: Thu Jul 12 04:38:07 2007
+  $Author: nobu $
+  created at: Sun Oct 19 21:12:51 2008
 
   Copyright (C) 2007 Koichi Sasada
 
@@ -31,6 +31,10 @@
 #define symIFUNC ID2SYM(idIFUNC)
 #define symCFUNC ID2SYM(idCFUNC)
 
+#if !defined tLAST_TOKEN && defined YYTOKENTYPE
+#define tLAST_TOKEN tLAST_TOKEN
+#endif
+
 enum ruby_method_ids {
 #ifndef tLAST_TOKEN
     tUPLUS = 321,
@@ -65,70 +69,6 @@ enum ruby_method_ids {
     id_core_define_singleton_method = 374,
     id_core_set_postexe = 375,
     tLAST_TOKEN = 376,
-#elif tUPLUS != 321
-#error tUPLUS differs
-#elif tUMINUS != 322
-#error tUMINUS differs
-#elif tPOW != 323
-#error tPOW differs
-#elif tCMP != 324
-#error tCMP differs
-#elif tEQ != 325
-#error tEQ differs
-#elif tEQQ != 326
-#error tEQQ differs
-#elif tNEQ != 327
-#error tNEQ differs
-#elif tGEQ != 328
-#error tGEQ differs
-#elif tLEQ != 329
-#error tLEQ differs
-#elif tANDOP != 330
-#error tANDOP differs
-#elif tOROP != 331
-#error tOROP differs
-#elif tMATCH != 332
-#error tMATCH differs
-#elif tNMATCH != 333
-#error tNMATCH differs
-#elif tDOT2 != 334
-#error tDOT2 differs
-#elif tDOT3 != 335
-#error tDOT3 differs
-#elif tAREF != 336
-#error tAREF differs
-#elif tASET != 337
-#error tASET differs
-#elif tLSHFT != 338
-#error tLSHFT differs
-#elif tRSHFT != 339
-#error tRSHFT differs
-#elif tLAMBDA != 352
-#error tLAMBDA differs
-#elif idNULL != 365
-#error idNULL differs
-#elif idRespond_to != 366
-#error idRespond_to differs
-#elif idIFUNC != 367
-#error idIFUNC differs
-#elif idCFUNC != 368
-#error idCFUNC differs
-#elif idThrowState != 369
-#error idThrowState differs
-#elif id_core_set_method_alias != 370
-#error id_core_set_method_alias differs
-#elif id_core_set_variable_alias != 371
-#error id_core_set_variable_alias differs
-#elif id_core_undef_method != 372
-#error id_core_undef_method differs
-#elif id_core_define_method != 373
-#error id_core_define_method differs
-#elif id_core_define_singleton_method != 374
-#error id_core_define_singleton_method differs
-#elif id_core_set_postexe != 375
-#error id_core_set_postexe differs
-#elif tLAST_TOKEN != 376
-#error tLAST_TOKEN differs
 #endif
     idPLUS = '+',
     idMINUS = '-',
@@ -181,4 +121,43 @@ enum ruby_method_ids {
     TOKEN2ID(Initialize)
 };
 
+#ifdef tLAST_TOKEN
+struct ruby_method_ids_check {
+#define ruby_method_id_check_for(name, value) \
+    int checking_for_##name[name == value ? 1 : -1]
+ruby_method_id_check_for(tUPLUS, 321);
+ruby_method_id_check_for(tUMINUS, 322);
+ruby_method_id_check_for(tPOW, 323);
+ruby_method_id_check_for(tCMP, 324);
+ruby_method_id_check_for(tEQ, 325);
+ruby_method_id_check_for(tEQQ, 326);
+ruby_method_id_check_for(tNEQ, 327);
+ruby_method_id_check_for(tGEQ, 328);
+ruby_method_id_check_for(tLEQ, 329);
+ruby_method_id_check_for(tANDOP, 330);
+ruby_method_id_check_for(tOROP, 331);
+ruby_method_id_check_for(tMATCH, 332);
+ruby_method_id_check_for(tNMATCH, 333);
+ruby_method_id_check_for(tDOT2, 334);
+ruby_method_id_check_for(tDOT3, 335);
+ruby_method_id_check_for(tAREF, 336);
+ruby_method_id_check_for(tASET, 337);
+ruby_method_id_check_for(tLSHFT, 338);
+ruby_method_id_check_for(tRSHFT, 339);
+ruby_method_id_check_for(tLAMBDA, 352);
+ruby_method_id_check_for(idNULL, 365);
+ruby_method_id_check_for(idRespond_to, 366);
+ruby_method_id_check_for(idIFUNC, 367);
+ruby_method_id_check_for(idCFUNC, 368);
+ruby_method_id_check_for(idThrowState, 369);
+ruby_method_id_check_for(id_core_set_method_alias, 370);
+ruby_method_id_check_for(id_core_set_variable_alias, 371);
+ruby_method_id_check_for(id_core_undef_method, 372);
+ruby_method_id_check_for(id_core_define_method, 373);
+ruby_method_id_check_for(id_core_define_singleton_method, 374);
+ruby_method_id_check_for(id_core_set_postexe, 375);
+ruby_method_id_check_for(tLAST_TOKEN, 376);
+};
+#endif
+
 #endif /* RUBY_ID_H */

data/ext/cached/ruby-1.9.1/internal/yarv-headers/iseq.h

@@ -2,7 +2,7 @@
 
   iseq.h -
 
-  $Author: ko1 $
+  $Author: yugui $
   created at: 04/01/01 23:36:57 JST
 
   Copyright (C) 2004-2008 Koichi Sasada
@@ -12,7 +12,15 @@
 #ifndef RUBY_COMPILE_H
 #define RUBY_COMPILE_H
 
-VALUE iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt);
+/* compile.c */
+VALUE rb_iseq_compile_node(VALUE self, NODE *node);
+int rb_iseq_translate_threaded_code(rb_iseq_t *iseq);
+VALUE rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE locals, VALUE args,
+			     VALUE exception, VALUE body);
+
+/* iseq.c */
+VALUE ruby_iseq_load(VALUE data, VALUE parent, VALUE opt);
+struct st_table *ruby_insn_make_insn_table(void);
 
 #define ISEQ_TYPE_TOP    INT2FIX(1)
 #define ISEQ_TYPE_METHOD INT2FIX(2)
@@ -21,7 +29,8 @@ VALUE iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt);
 #define ISEQ_TYPE_RESCUE INT2FIX(5)
 #define ISEQ_TYPE_ENSURE INT2FIX(6)
 #define ISEQ_TYPE_EVAL   INT2FIX(7)
-#define ISEQ_TYPE_DEFINED_GUARD INT2FIX(8)
+#define ISEQ_TYPE_MAIN   INT2FIX(8)
+#define ISEQ_TYPE_DEFINED_GUARD INT2FIX(9)
 
 #define CATCH_TYPE_RESCUE INT2FIX(1)
 #define CATCH_TYPE_ENSURE INT2FIX(2)

data/ext/cached/ruby-1.9.1/internal/yarv-headers/node.h

@@ -2,7 +2,7 @@
 
   node.h -
 
-  $Author: ko1 $
+  $Author: yugui $
   created at: Fri May 28 15:14:02 JST 1993
 
   Copyright (C) 1993-2007 Yukihiro Matsumoto
@@ -468,7 +468,7 @@ typedef struct RNode {
 
 #define NOEX_UNDEF     NOEX_NOSUPER
 
-#define NOEX_MODFUNC   0x10
+#define NOEX_MODFUNC   0x12
 #define NOEX_SUPER     0x20
 #define NOEX_VCALL     0x40