ruby-internal 0.6.0

data/ext/internal/tag/extconf.rb

@@ -0,0 +1,3 @@
+$: << '../../'
+require 'mkmf-ruby-internal'
+create_ruby_internal_makefile 'internal/tag/tag'

data/ext/internal/tag/tag.c

@@ -0,0 +1,17 @@
+#include <ruby.h>
+#include "tag.h"
+
+void Init_tag()
+{
+  VALUE rb_mTag = rb_define_module("Tag");
+  rb_define_const(rb_mTag, "RETURN", INT2NUM(TAG_RETURN));
+  rb_define_const(rb_mTag, "BREAK",  INT2NUM(TAG_BREAK));
+  rb_define_const(rb_mTag, "NEXT",   INT2NUM(TAG_NEXT));
+  rb_define_const(rb_mTag, "RETRY",  INT2NUM(TAG_RETRY));
+  rb_define_const(rb_mTag, "REDO",   INT2NUM(TAG_REDO));
+  rb_define_const(rb_mTag, "RAISE",  INT2NUM(TAG_RAISE));
+  rb_define_const(rb_mTag, "THROW",  INT2NUM(TAG_THROW));
+  rb_define_const(rb_mTag, "FATAL",  INT2NUM(TAG_FATAL));
+  rb_define_const(rb_mTag, "MASK",   INT2NUM(TAG_MASK));
+}
+

data/ext/internal/tag/tag.h.rpp

@@ -0,0 +1,22 @@
+#include <ruby.h>
+
+#ifdef RUBY_VM
+#include "eval_intern.h"
+#endif
+
+#ruby <<END
+  $: << '../..'
+  require 'ruby_source_dir'
+  eval_c_location = "#{RUBY_SOURCE_DIR}/eval.c"
+
+  File.open(eval_c_location) do |eval_c|
+    while (line = eval_c.gets) != nil do
+      case line
+      when /^#define TAG_/
+        puts line
+      end
+    end
+  end
+
+  nil
+END

data/ext/internal/thread/extconf.rb

@@ -0,0 +1,3 @@
+$: << '../../'
+require 'mkmf-ruby-internal'
+create_ruby_internal_makefile 'internal/thread/thread'

data/ext/internal/thread/thread.c

@@ -0,0 +1,107 @@
+#include <ruby.h>
+
+#ifdef RUBY_VM
+#include "vm_core.h"
+#include "eval_intern.h"
+#include "internal/vm/control_frame/control_frame.h"
+#endif
+
+#ifdef RUBY_VM
+
+static VALUE rb_cVmControlFrame;
+
+/* TODO: also defined in control_frame.c */
+void mark_ruby_internal_control_frame(
+    struct RubyInternalControlFrame * cfp)
+{
+  rb_gc_mark(cfp->thread);
+}
+
+/*
+ * call-seq:
+ *   thread.cfp = RubyVM::ControlFrame
+ *
+ * Returns the thread's control frame.
+ */
+static VALUE thread_cfp(VALUE self)
+{
+  rb_thread_t * th;
+  rb_control_frame_t * prev_cfp;
+
+  GetThreadPtr(self, th);
+
+  /* TODO: Not sure how many control frames back to go to get the one we
+   * want */
+  prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+  if((void *)(th->stack + th->stack_size) == (void *)prev_cfp)
+  {
+    return Qnil;
+  }
+  else
+  {
+    struct RubyInternalControlFrame * cfp;
+    VALUE cfp_v;
+
+    cfp_v = Data_Make_Struct(
+        rb_cVmControlFrame,
+        struct RubyInternalControlFrame,
+        mark_ruby_internal_control_frame,
+        free, 
+        cfp);
+
+    cfp->control_frame = prev_cfp;
+    cfp->thread = self;
+
+    return cfp_v;
+  }
+}
+
+/* For Ludicrous */
+void * ruby_current_thread_jmp_buf()
+{
+  /* jmp_buf is guaranteed to be an array type that can decay to a
+   * pointer */
+  rb_thread_t * const th = GET_THREAD();
+  return th->tag->buf;
+}
+
+/* For Ludicrous */
+void * ruby_current_thread_tag(void * tag)
+{
+  rb_thread_t * const th = GET_THREAD();
+  return th->tag;
+}
+
+/* For Ludicrous */
+void ruby_set_current_thread_tag(void * tag)
+{
+  rb_thread_t * const th = GET_THREAD();
+  th->tag = tag;
+}
+
+#endif
+
+void Init_thread(void)
+{
+  /* For rdoc: rb_cThread = rb_define_class("Thread", rb_cObject); */
+
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+
+  rb_require("internal/vm/control_frame");
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  rb_cVmControlFrame = rb_const_get(rb_cRubyVM, rb_intern("ControlFrame"));
+
+  rb_define_method(rb_cThread, "cfp", thread_cfp, 0);
+#endif
+}
+

data/ext/internal/vm/constants/constants.c

@@ -0,0 +1,33 @@
+#include <ruby.h>
+
+#ifdef RUBY_VM
+#include "vm_core.h"
+#endif
+
+void Init_constants(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  rb_define_const(rb_cRubyVM, "CALL_ARGS_SPLAT_BIT", INT2NUM(VM_CALL_ARGS_SPLAT_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_ARGS_BLOCKARG_BIT", INT2NUM(VM_CALL_ARGS_BLOCKARG_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_FCALL_BIT", INT2NUM(VM_CALL_FCALL_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_VCALL_BIT", INT2NUM(VM_CALL_VCALL_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_TAILCALL_BIT", INT2NUM(VM_CALL_TAILCALL_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_TAILRECURSION_BIT", INT2NUM(VM_CALL_TAILRECURSION_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_SUPER_BIT", INT2NUM(VM_CALL_SUPER_BIT));
+  rb_define_const(rb_cRubyVM, "CALL_SEND_BIT", INT2NUM(VM_CALL_SEND_BIT));
+  rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_VMCORE", INT2NUM(VM_SPECIAL_OBJECT_VMCORE));
+  rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_CBASE", INT2NUM(VM_SPECIAL_OBJECT_CBASE));
+#endif
+}
+

data/ext/internal/vm/constants/extconf.rb

@@ -0,0 +1,3 @@
+$: << '../../..'
+require 'mkmf-ruby-internal'
+create_ruby_internal_makefile 'internal/vm/constants/constants'

data/ext/internal/vm/control_frame/control_frame.c

@@ -0,0 +1,185 @@
+#include "control_frame.h"
+#include <ruby.h>
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+/* TODO: Using this class is dangerous, because the control frame can be
+ * popped but a reference kept around to it.  It will still point to
+ * valid memory, but the data itself will be invalid.
+ */
+
+static VALUE rb_cVmControlFrame;
+
+void mark_ruby_internal_control_frame(
+    struct RubyInternalControlFrame * cfp)
+{
+  rb_gc_mark(cfp->thread);
+}
+
+/*
+ * call-seq:
+ *   control_frame.iseq => RubyVM::InstructionSequence
+ *
+ * Return the frame's iseq member.
+ */
+static VALUE control_frame_iseq(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  return (VALUE)cfp->control_frame->iseq;
+}
+
+/*
+ * call-seq:
+ *   control_frame.self => Object
+ *
+ * Return the frame's self member.
+ */
+static VALUE control_frame_self(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  return cfp->control_frame->self;
+}
+
+/*
+ * call-seq:
+ *   control_frame.block_iseq => RubyVM::InstructionSequence or nil
+ *
+ * Return the frame's block_iseq member.
+ */
+static VALUE control_frame_block_iseq(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  if(cfp->control_frame->proc)
+  {
+    return (VALUE)cfp->control_frame->block_iseq;
+  }
+  else
+  {
+    return Qfalse;
+  }
+}
+
+/*
+ * call-seq:
+ *   control_frame.proc => ?
+ *
+ * Return the frame's proc member.
+ */
+static VALUE control_frame_proc(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  return cfp->control_frame->proc;
+}
+
+/*
+ * call-seq:
+ *   control_frame.method_id => Symbol or nil
+ *
+ * Return the frame's method_id member.
+ */
+static VALUE control_frame_method_id(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  if(cfp->control_frame->method_id)
+  {
+    return ID2SYM(cfp->control_frame->method_id);
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *   control_frame.method_class => Class
+ *
+ * Return the frame's method_class member.
+ */
+static VALUE control_frame_method_class(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+  return cfp->control_frame->method_class;
+}
+
+/*
+ * call-seq:
+ *   control_frame.prev => RubyVM::ControlFrame
+ *
+ * Return the frame's prev member.
+ */
+static VALUE control_frame_prev(VALUE control_frame)
+{
+  struct RubyInternalControlFrame * cfp;
+  rb_thread_t * th;
+  rb_control_frame_t * prev_cfp;
+
+  Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
+
+  GetThreadPtr(cfp->thread, th);
+
+  prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp->control_frame);
+
+  printf("current: %p\n", cfp->control_frame);
+  printf("prev: %p\n", prev_cfp);
+  printf("th->stack: %p\n", th->stack);
+  printf("th->stack + th->stack_size: %p\n", th->stack + th->stack_size);
+
+  if((void *)(th->stack + th->stack_size) == (void *)prev_cfp)
+  {
+    return Qnil;
+  }
+  else
+  {
+    VALUE cfp_v;
+    struct RubyInternalControlFrame * new_cfp;
+
+    cfp_v = Data_Make_Struct(
+        rb_cVmControlFrame,
+        struct RubyInternalControlFrame,
+        mark_ruby_internal_control_frame,
+        free,
+        new_cfp);
+
+    new_cfp->control_frame = prev_cfp;
+    new_cfp->thread = cfp->thread;
+
+    return cfp_v;
+  }
+}
+
+#endif
+
+void Init_control_frame(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  rb_cVmControlFrame = rb_define_class_under(rb_cRubyVM, "ControlFrame", rb_cObject);
+  rb_define_method(rb_cVmControlFrame, "iseq", control_frame_iseq, 0);
+  rb_define_method(rb_cVmControlFrame, "self", control_frame_self, 0);
+  rb_define_method(rb_cVmControlFrame, "block_iseq", control_frame_block_iseq, 0);
+  rb_define_method(rb_cVmControlFrame, "proc", control_frame_proc, 0);
+  rb_define_method(rb_cVmControlFrame, "method_id", control_frame_method_id, 0);
+  rb_define_method(rb_cVmControlFrame, "method_class", control_frame_method_class, 0);
+  rb_define_method(rb_cVmControlFrame, "prev", control_frame_prev, 0);
+#endif
+}
+

data/ext/internal/vm/control_frame/control_frame.h

@@ -0,0 +1,18 @@
+#ifndef RUBY_INTERNAL__VM__CONTROL_FRAME__CONTROL_FRAME_H
+#define RUBY_INTERNAL__VM__CONTROL_FRAME__CONTROL_FRAME_H
+
+#include <ruby.h>
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+struct RubyInternalControlFrame
+{
+  rb_control_frame_t * control_frame;
+  VALUE thread;
+};
+
+#endif
+
+#endif

data/ext/internal/vm/control_frame/extconf.rb

@@ -0,0 +1,3 @@
+$: << '../../..'
+require 'mkmf-ruby-internal'
+create_ruby_internal_makefile 'internal/vm/control_frame/control_frame'

data/ext/internal/vm/extconf.rb

@@ -0,0 +1,3 @@
+$: << '../..'
+require 'mkmf-ruby-internal'
+create_ruby_internal_makefile 'internal/vm/vm'

data/ext/internal/vm/inline_cache/extconf.rb

@@ -0,0 +1,6 @@
+$: << '../../..'
+require 'mkmf-ruby-internal'
+
+have_header('ruby/node.h') or have_header('node.h')
+
+create_ruby_internal_makefile 'internal/vm/inline_cache/inline_cache'

data/ext/internal/vm/inline_cache/inline_cache.c

@@ -0,0 +1,79 @@
+#include "internal/node/ruby_internal_node.h"
+#include "internal/node/nodeinfo.h"
+#include <ruby.h>
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+/*
+ * call-seq:
+ *   inline_cache.class => nil
+ *
+ * Currently returns nil, because returning the real class can cause the
+ * interpreter to crash.
+ */
+static VALUE inline_cache_klass(VALUE self)
+{
+  /* TODO: returning the real value can crash the interpreter */
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   inline_cache.value => Object
+ *
+ * Returns the ic_cache member of the inline cache.
+ */
+static VALUE inline_cache_value(VALUE self)
+{
+  IC inline_cache = unwrap_node(self);
+  return inline_cache->ic_value;
+}
+
+/*
+ * call-seq:
+ *   inline_cache.vmstat => object
+ *
+ * Returns the ic_vmstat member of the inline cache.
+ */
+static VALUE inline_cache_vmstat(VALUE self)
+{
+  IC inline_cache = unwrap_node(self);
+  return INT2NUM(inline_cache->ic_vmstat);
+}
+
+#endif
+
+void Init_inline_cache(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cNode;
+  VALUE rb_cRubyVM;
+
+  rb_require("internal/node/node");
+
+  rb_cNode = rb_define_class("Node", rb_cObject);
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  VALUE rb_cInlineCache = rb_define_class_under(rb_cRubyVM, "InlineCache", rb_cNode);
+  rb_define_method(rb_cInlineCache, "klass", inline_cache_klass, 0);
+  rb_define_method(rb_cInlineCache, "value", inline_cache_value, 0);
+  rb_define_method(rb_cInlineCache, "vmstat", inline_cache_vmstat, 0);
+  VALUE inline_cache_members = rb_ary_new();
+  rb_ary_push(inline_cache_members, rb_str_new2("klass"));
+  rb_ary_push(inline_cache_members, rb_str_new2("value"));
+  rb_ary_push(inline_cache_members, rb_str_new2("vmstat"));
+  rb_iv_set(rb_cInlineCache, "__member__", inline_cache_members);
+  rb_define_singleton_method(rb_cInlineCache, "members", node_s_members, 0);
+#endif
+}
+