cast_off 0.2.1 → 0.2.3

data/ext/cast_off/generated_c_include/iter_api.h

@@ -61,7 +61,7 @@ static rb_iseq_t *construct_iter_api_iseq(VALUE (*fptr)(ANYARGS), ID mid)
 
   rb_ary_push(val, rb_str_new2("<compiled>")); /* name */
   rb_ary_push(val, rb_str_new2("<compiled>")); /* filename */
-  rb_ary_push(val, rb_str_new2("<compiled>")); /* filepath */
+  rb_ary_push(val, Qnil); /* filepath */
   rb_ary_push(val, INT2FIX(-1)); /* line_no */
   rb_ary_push(val, ID2SYM(rb_intern("method"))); /* type */
 

data/ext/cast_off/generated_c_include/vm_api.h

@@ -580,11 +580,13 @@ static int should_be_call_directly_p(VALUE (*fptr)(ANYARGS))
 }
 NOINLINE(static int should_be_call_directly_p(VALUE (*fptr)(ANYARGS)));
 
-#define cast_off_get_constant(klass, id)  cast_off_get_ev_const(self, cast_off_orig_iseq->cref_stack, (klass), (id))
+#define cast_off_const_defined(klass, id) cast_off_get_ev_const(self, cast_off_orig_iseq->cref_stack, (klass), (id), 1)
+#define cast_off_get_constant(klass, id)  cast_off_get_ev_const(self, cast_off_orig_iseq->cref_stack, (klass), (id), 0)
 #define cast_off_get_cvar_base()          vm_get_cvar_base(cast_off_orig_iseq->cref_stack)
 
+#if defined(RUBY_1_9_3)
 static VALUE
-cast_off_get_ev_const(VALUE self, NODE *root_cref, VALUE orig_klass, ID id)
+cast_off_get_ev_const(VALUE self, NODE *root_cref, VALUE orig_klass, ID id, int is_defined)
 {
   VALUE val;
 
@@ -615,10 +617,15 @@ search_continue:
           if (val == Qundef) {
             if (am == klass) break;
             am = klass;
+            if (is_defined) return 1;
             rb_autoload_load(klass, id);
             goto search_continue;
           } else {
-            return val;
+            if (is_defined) {
+              return 1;
+            } else {
+              return val;
+            }
           }
         }
       }
@@ -630,14 +637,90 @@ search_continue:
     } else {
         klass = CLASS_OF(self);
     }
-    return rb_const_get(klass, id);
+    if (is_defined) {
+      return rb_const_defined(klass, id);
+    } else {
+      return rb_const_get(klass, id);
+    }
   } else {
     vm_check_if_namespace(orig_klass);
-    return rb_const_get(orig_klass, id); /* FIXME */
-    /* return rb_public_const_get_from(orig_klass, id); */
+    if (is_defined) {
+      return rb_const_defined(orig_klass, id); /* FIXME */
+      /* return rb_public_const_defined_from(orig_klass, id); */
+    } else {
+      return rb_const_get(orig_klass, id); /* FIXME */
+      /* return rb_public_const_get_from(orig_klass, id); */
+    }
+  }
+}
+NOINLINE(static VALUE cast_off_get_ev_const(VALUE self, NODE *root_cref, VALUE orig_klass, ID id, int is_defined));
+#elif defined(RUBY_1_9_2)
+static VALUE
+cast_off_get_ev_const(VALUE self, NODE *cref, VALUE orig_klass, ID id, int is_defined)
+{
+  VALUE val;
+
+  if (orig_klass == Qnil) {
+    /* in current lexical scope */
+    const NODE *root_cref = NULL;
+    VALUE klass = orig_klass;
+
+    while (cref && cref->nd_next) {
+      if (!(cref->flags & NODE_FL_CREF_PUSHED_BY_EVAL)) {
+        klass = cref->nd_clss;
+        if (root_cref == NULL)
+          root_cref = cref;
+      }
+      cref = cref->nd_next;
+
+      if (!NIL_P(klass)) {
+        VALUE am = 0;
+search_continue:
+        if (RCLASS_IV_TBL(klass) &&
+            st_lookup(RCLASS_IV_TBL(klass), id, &val)) {
+          if (val == Qundef) {
+            if (am == klass) break;
+            am = klass;
+            rb_autoload_load(klass, id);
+            goto search_continue;
+          } else {
+            if (is_defined) {
+              return 1;
+            } else {
+              return val;
+            }
+          }
+        }
+      }
+    }
+
+    /* search self */
+    if (root_cref && !NIL_P(root_cref->nd_clss)) {
+      klass = root_cref->nd_clss;
+    } else {
+      VALUE thval = rb_thread_current();
+      rb_thread_t *th = DATA_PTR(thval);
+      klass = CLASS_OF(th->cfp->self);
+    }
+    if (is_defined) {
+      return rb_const_defined(klass, id);
+    } else {
+      return rb_const_get(klass, id);
+    }
+  }
+  else {
+    vm_check_if_namespace(orig_klass);
+    if (is_defined) {
+      return rb_const_defined(orig_klass, id); /* FIXME */
+      /* return rb_public_const_defined_from(orig_klass, id); */
+    } else {
+      return rb_const_get(orig_klass, id); /* FIXME */
+      /* return rb_const_get_from(orig_klass, id); */
+    }
   }
 }
-NOINLINE(static VALUE cast_off_get_ev_const(VALUE self, NODE *root_cref, VALUE orig_klass, ID id));
+NOINLINE(static VALUE cast_off_get_ev_const(VALUE self, NODE *cref, VALUE orig_klass, ID id, int is_defined));
+#endif
 
 #if 0
 /* should be mark cache->obj */

data/ext/cast_off/ruby_source/1.9.2/debug.h

@@ -0,0 +1,36 @@
+/**********************************************************************
+
+  debug.h - YARV Debug function interface
+
+  $Author: akr $
+  created at: 04/08/25 02:33:49 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_DEBUG_H
+#define RUBY_DEBUG_H
+
+#include "ruby/ruby.h"
+#include "node.h"
+
+#define dpv(h,v) ruby_debug_print_value(-1, 0, h, v)
+#define dp(v)    ruby_debug_print_value(-1, 0, "", v)
+#define dpi(i)   ruby_debug_print_id(-1, 0, "", i)
+#define dpn(n)   ruby_debug_print_node(-1, 0, "", n)
+
+#define bp()     ruby_debug_breakpoint()
+
+VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);
+ID    ruby_debug_print_id(int level, int debug_level, const char *header, ID id);
+NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);
+int   ruby_debug_print_indent(int level, int debug_level, int indent_level);
+void  ruby_debug_breakpoint(void);
+void  ruby_debug_gc_check_func(void);
+
+#ifdef RUBY_DEBUG_ENV
+void ruby_set_debug_option(const char *str);
+#endif
+
+#endif /* RUBY_DEBUG_H */

data/ext/cast_off/ruby_source/1.9.2/eval_intern.h

@@ -0,0 +1,232 @@
+#ifndef RUBY_EVAL_INTERN_H
+#define RUBY_EVAL_INTERN_H
+
+#include "ruby/ruby.h"
+#include "vm_core.h"
+
+#define PASS_PASSED_BLOCK_TH(th) do { \
+    (th)->passed_block = GC_GUARDED_PTR_REF((rb_block_t *)(th)->cfp->lfp[0]); \
+    (th)->cfp->flag |= VM_FRAME_FLAG_PASSED; \
+} while (0)
+
+#define PASS_PASSED_BLOCK() do { \
+    rb_thread_t * const __th__ = GET_THREAD(); \
+    PASS_PASSED_BLOCK_TH(__th__); \
+} while (0)
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+#include <stdio.h>
+#include <setjmp.h>
+
+#ifdef __APPLE__
+#include <crt_externs.h>
+#endif
+
+/* Make alloca work the best possible way.  */
+#ifdef __GNUC__
+# ifndef atarist
+#  ifndef alloca
+#   define alloca __builtin_alloca
+#  endif
+# endif	/* atarist */
+#else
+# ifdef HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+#pragma alloca
+#  else
+#   ifndef alloca		/* predefined by HP cc +Olibcalls */
+void *alloca();
+#   endif
+#  endif /* AIX */
+# endif	/* HAVE_ALLOCA_H */
+#endif /* __GNUC__ */
+
+#ifndef HAVE_STRING_H
+char *strrchr(const char *, const char);
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_NET_SOCKET_H
+#include <net/socket.h>
+#endif
+
+#define ruby_setjmp(env) RUBY_SETJMP(env)
+#define ruby_longjmp(env,val) RUBY_LONGJMP(env,val)
+#ifdef __CYGWIN__
+# ifndef _setjmp
+int _setjmp(jmp_buf);
+# endif
+# ifndef _longjmp
+NORETURN(void _longjmp(jmp_buf, int));
+# endif
+#endif
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+
+/*
+  Solaris sys/select.h switches select to select_large_fdset to support larger
+  file descriptors if FD_SETSIZE is larger than 1024 on 32bit environment.
+  But Ruby doesn't change FD_SETSIZE because fd_set is allocated dynamically.
+  So following definition is required to use select_large_fdset.
+*/
+#ifdef HAVE_SELECT_LARGE_FDSET
+#define select(n, r, w, e, t) select_large_fdset(n, r, w, e, t)
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#include <sys/stat.h>
+
+#define SAVE_ROOT_JMPBUF(th, stmt) do \
+  if (ruby_setjmp((th)->root_jmpbuf) == 0) { \
+      stmt; \
+  } \
+  else { \
+      rb_fiber_start(); \
+  } while (0)
+
+#define TH_PUSH_TAG(th) do { \
+  rb_thread_t * const _th = th; \
+  struct rb_vm_tag _tag; \
+  _tag.tag = 0; \
+  _tag.prev = _th->tag; \
+  _th->tag = &_tag;
+
+#define TH_POP_TAG() \
+  _th->tag = _tag.prev; \
+} while (0)
+
+#define TH_POP_TAG2() \
+  _th->tag = _tag.prev
+
+#define PUSH_TAG() TH_PUSH_TAG(GET_THREAD())
+#define POP_TAG()      TH_POP_TAG()
+
+#define TH_EXEC_TAG() ruby_setjmp(_th->tag->buf)
+
+#define EXEC_TAG() \
+  TH_EXEC_TAG()
+
+#define TH_JUMP_TAG(th, st) do { \
+  ruby_longjmp(th->tag->buf,(st)); \
+} while (0)
+
+#define JUMP_TAG(st) TH_JUMP_TAG(GET_THREAD(), st)
+
+enum ruby_tag_type {
+    RUBY_TAG_RETURN	= 0x1,
+    RUBY_TAG_BREAK	= 0x2,
+    RUBY_TAG_NEXT	= 0x3,
+    RUBY_TAG_RETRY	= 0x4,
+    RUBY_TAG_REDO	= 0x5,
+    RUBY_TAG_RAISE	= 0x6,
+    RUBY_TAG_THROW	= 0x7,
+    RUBY_TAG_FATAL	= 0x8,
+    RUBY_TAG_MASK	= 0xf
+};
+#define TAG_RETURN	RUBY_TAG_RETURN
+#define TAG_BREAK	RUBY_TAG_BREAK
+#define TAG_NEXT	RUBY_TAG_NEXT
+#define TAG_RETRY	RUBY_TAG_RETRY
+#define TAG_REDO	RUBY_TAG_REDO
+#define TAG_RAISE	RUBY_TAG_RAISE
+#define TAG_THROW	RUBY_TAG_THROW
+#define TAG_FATAL	RUBY_TAG_FATAL
+#define TAG_MASK	RUBY_TAG_MASK
+
+#define NEW_THROW_OBJECT(val, pt, st) \
+  ((VALUE)rb_node_newnode(NODE_LIT, (VALUE)(val), (VALUE)(pt), (VALUE)(st)))
+#define SET_THROWOBJ_CATCH_POINT(obj, val) \
+  (RNODE((obj))->u2.value = (val))
+#define SET_THROWOBJ_STATE(obj, val) \
+  (RNODE((obj))->u3.value = (val))
+
+#define GET_THROWOBJ_VAL(obj)         ((VALUE)RNODE((obj))->u1.value)
+#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)  (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 *)((char *)(((VALUE *)(cfp)->sp) + (margin)) + sizeof(rb_control_frame_t)) >= ((VALUE *)cfp)) { \
+      rb_exc_raise(sysstack_error); \
+  } \
+while (0)
+
+void rb_thread_cleanup(void);
+void rb_thread_wait_other_threads(void);
+
+enum {
+    RAISED_EXCEPTION = 1,
+    RAISED_STACKOVERFLOW = 2,
+    RAISED_NOMEMORY = 4
+};
+int rb_threadptr_set_raised(rb_thread_t *th);
+int rb_threadptr_reset_raised(rb_thread_t *th);
+#define rb_thread_raised_set(th, f)   ((th)->raised_flag |= (f))
+#define rb_thread_raised_reset(th, f) ((th)->raised_flag &= ~(f))
+#define rb_thread_raised_p(th, f)     (((th)->raised_flag & (f)) != 0)
+#define rb_thread_raised_clear(th)    ((th)->raised_flag = 0)
+
+VALUE rb_f_eval(int argc, VALUE *argv, VALUE self);
+VALUE rb_make_exception(int argc, VALUE *argv);
+
+NORETURN(void rb_fiber_start(void));
+
+NORETURN(void rb_print_undef(VALUE, ID, int));
+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 rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
+NODE *rb_vm_cref(void);
+VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename, VALUE filepath);
+void rb_vm_set_progname(VALUE filename);
+void rb_thread_terminate_all(void);
+VALUE rb_vm_top_self();
+VALUE rb_vm_cbase(void);
+int rb_vm_get_sourceline(const rb_control_frame_t *);
+void rb_trap_restore_mask(void);
+
+#ifndef CharNext		/* defined as CharNext[AW] on Windows. */
+#define CharNext(p) ((p) + mblen(p, RUBY_MBCHAR_MAXSIZE))
+#endif
+
+#if defined DOSISH || defined __CYGWIN__
+static inline void
+translit_char(char *p, int from, int to)
+{
+    while (*p) {
+	if ((unsigned char)*p == from)
+	    *p = to;
+	p = CharNext(p);
+    }
+}
+#endif
+
+#endif /* RUBY_EVAL_INTERN_H */

data/ext/cast_off/ruby_source/1.9.2/gc.h

@@ -0,0 +1,77 @@
+
+#ifndef RUBY_GC_H
+#define RUBY_GC_H 1
+
+#if defined(__x86_64__) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__("movq\t%%rsp, %0" : "=r" (*p))
+#elif defined(__i386) && defined(__GNUC__)
+#define SET_MACHINE_STACK_END(p) __asm__("movl\t%%esp, %0" : "=r" (*p))
+#else
+NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
+#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
+#define USE_CONSERVATIVE_STACK_END
+#endif
+
+/* for GC debug */
+
+#ifndef RUBY_MARK_FREE_DEBUG
+#define RUBY_MARK_FREE_DEBUG 0
+#endif
+
+#if RUBY_MARK_FREE_DEBUG
+extern int ruby_gc_debug_indent;
+
+static void
+rb_gc_debug_indent(void)
+{
+    printf("%*s", ruby_gc_debug_indent, "");
+}
+
+static void
+rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
+{
+    if (st == 0) {
+	ruby_gc_debug_indent--;
+    }
+    rb_gc_debug_indent();
+    printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
+
+    if (st) {
+	ruby_gc_debug_indent++;
+    }
+
+    fflush(stdout);
+}
+
+#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", msg, 1, ptr)
+#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", msg, 0, ptr)
+#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", msg, 1, ptr)
+#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", msg, 0, ptr)
+#define RUBY_GC_INFO         rb_gc_debug_indent(); printf
+
+#else
+#define RUBY_MARK_ENTER(msg)
+#define RUBY_MARK_LEAVE(msg)
+#define RUBY_FREE_ENTER(msg)
+#define RUBY_FREE_LEAVE(msg)
+#define RUBY_GC_INFO if(0)printf
+#endif
+
+#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
+#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
+
+#if STACK_GROW_DIRECTION > 0
+# define STACK_UPPER(x, a, b) a
+#elif STACK_GROW_DIRECTION < 0
+# define STACK_UPPER(x, a, b) b
+#else
+RUBY_EXTERN int ruby_stack_grow_direction;
+int ruby_get_stack_grow_direction(volatile VALUE *addr);
+# define stack_growup_p(x) (			\
+	(ruby_stack_grow_direction ?		\
+	 ruby_stack_grow_direction :		\
+	 ruby_get_stack_grow_direction(x)) > 0)
+# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? a : b)
+#endif
+
+#endif /* RUBY_GC_H */