parsetree19 0.2

data/include/vm_core_mini.h

@@ -0,0 +1,369 @@
+/* Headers Exposing a little more of the 1.9 runtime and some 
+   method prototypes for extensions to the Thread class.
+*/
+#include <ruby.h>
+#include <signal.h>
+#include "thread_pthread.h"
+#include "node.h"
+
+/* From vm_core.h: */
+
+/* Frame information: */
+#define VM_FRAME_MAGIC_METHOD 0x11
+#define VM_FRAME_MAGIC_BLOCK  0x21
+#define VM_FRAME_MAGIC_CLASS  0x31
+#define VM_FRAME_MAGIC_TOP    0x41
+#define VM_FRAME_MAGIC_FINISH 0x51
+#define VM_FRAME_MAGIC_CFUNC  0x61
+#define VM_FRAME_MAGIC_PROC   0x71
+#define VM_FRAME_MAGIC_IFUNC  0x81
+#define VM_FRAME_MAGIC_EVAL   0x91
+#define VM_FRAME_MAGIC_LAMBDA 0xa1
+#define VM_FRAME_MAGIC_MASK_BITS   8
+#define VM_FRAME_MAGIC_MASK   (~(~0<<VM_FRAME_MAGIC_MASK_BITS))
+
+#define VM_FRAME_TYPE(cfp) ((cfp)->flag & VM_FRAME_MAGIC_MASK)
+
+#define VM_FRAME_TRACE_RETURN 0x01  /* Call trace hook on return. */
+#define VM_FRAME_TRACE_OFF    0x02  /* Turn of event hook tracing in this frame
+				       and any frames created from this one. */
+
+/* other frame flag */
+#define VM_FRAME_FLAG_PASSED 0x0100
+
+#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) (cfp+1)
+#define RUBYVM_CFUNC_FRAME_P(cfp) \
+  (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
+#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) (cfp-1)
+#define RUBY_VM_END_CONTROL_FRAME(th) \
+  ((rb_control_frame_t *)((th)->stack + (th)->stack_size))
+#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
+  ((void *)(ecfp) > (void *)(cfp))
+#define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
+  (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th)))
+
+#define RUBY_VM_IFUNC_P(ptr)        (BUILTIN_TYPE(ptr) == T_NODE)
+#define RUBY_VM_NORMAL_ISEQ_P(ptr) \
+  (ptr && !RUBY_VM_IFUNC_P(ptr))
+
+
+#if 1
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    ptr = (type*)DATA_PTR(obj); \
+} while (0)
+#else
+#define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct(obj, type, ptr)
+#endif
+#if 1
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    ptr = (type*)DATA_PTR(obj); \
+} while (0)
+#else
+#define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct(obj, type, ptr)
+#endif
+#define GetISeqPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_iseq_t, ptr)
+
+/* Opaque types (for now at least) */
+typedef struct iseq_catch_table_entry iseq_catch_table_entry_t;
+
+#ifndef NSIG
+# define NSIG (_SIGMAX + 1)      /* For QNX */
+#endif
+
+#define RUBY_NSIG NSIG
+
+typedef struct rb_compile_option_struct {
+    int inline_const_cache;
+    int peephole_optimization;
+    int tailcall_optimization;
+    int specialized_instruction;
+    int operands_unification;
+    int instructions_unification;
+    int stack_caching;
+    int trace_instruction;
+    int save_tree_node;
+    int save_compile_opts;
+    int debug_level;
+} rb_compile_option_t;
+
+/* Instruction sequence */
+typedef struct rb_iseq_struct {
+    /***************/
+    /* static data */
+    /***************/
+
+    VALUE type;          /* instruction sequence type */
+    VALUE name;          /* String: iseq name */
+    VALUE filename;      /* file information where this sequence from */
+    VALUE filepath;      /* real file path or nil */
+    VALUE *iseq;         /* iseq (insn number and operands) */
+    VALUE *iseq_encoded; /* encoded iseq */
+    unsigned long iseq_size;
+    VALUE mark_ary;     /* Array: includes operands which should be GC marked */
+    VALUE coverage;     /* coverage array */
+    unsigned short line_no;
+
+    /* insn info, must be freed */
+    struct iseq_insn_info_entry *insn_info_table;
+    size_t insn_info_size;
+
+    ID *local_table;            /* must free */
+    int local_table_size;
+
+    /* method, class frame: sizeof(vars) + 1, block frame: sizeof(vars) */
+    int local_size;
+
+    struct iseq_inline_cache_entry *ic_entries;
+    int ic_size;
+
+    /**
+     * argument information
+     *
+     *  def m(a1, a2, ..., aM,                    # mandatory
+     *        b1=(...), b2=(...), ..., bN=(...),  # optional
+     *        *c,                                 # rest
+     *        d1, d2, ..., dO,                    # post
+     *        &e)                                 # block
+     * =>
+     *
+     *  argc           = M
+     *  arg_rest       = M+N+1 // or -1 if no rest arg
+     *  arg_opts       = N
+     *  arg_opts_tbl   = [ (N entries) ]
+     *  arg_post_len   = O // 0 if no post arguments
+     *  arg_post_start = M+N+2
+     *  arg_block      = M+N + 1 + O + 1 // -1 if no block arg
+     *  arg_simple     = 0 if not simple arguments.
+     *                 = 1 if no opt, rest, post, block.
+     *                 = 2 if ambiguous block parameter ({|a|}).
+     *  arg_size       = argument size.
+     */
+
+    int argc;
+    int arg_simple;
+    int arg_rest;
+    int arg_block;
+    int arg_opts;
+    int arg_post_len;
+    int arg_post_start;
+    int arg_size;
+    VALUE *arg_opt_table;
+
+    size_t stack_max; /* for stack overflow check */
+
+    /* catch table */
+    iseq_catch_table_entry_t *catch_table;
+    int catch_table_size;
+
+    /* for child iseq */
+    struct rb_iseq_struct *parent_iseq;
+    struct rb_iseq_struct *local_iseq;
+
+    /****************/
+    /* dynamic data */
+    /****************/
+
+    VALUE self;
+    VALUE orig;                 /* non-NULL if its data have origin */
+
+    /* block inlining */
+    /*
+     * NODE *node;
+     * void *special_block_builder;
+     * void *cached_special_block_builder;
+     * VALUE cached_special_block;
+     */
+
+    /* klass/module nest information stack (cref) */
+    NODE *cref_stack;
+    VALUE klass;
+
+    /* misc */
+    ID defined_method_id;       /* for define_method */
+
+    /* used at compile time */
+    struct iseq_compile_data *compile_data;
+    /* Used to set a breakpoint at a VM instruction */
+    unsigned char *breakpoints; 
+
+    /* If this instruction sequence came from eval, the string of the
+       source as a String. */
+    VALUE source;
+
+    /* If we are saving tree nodes (a compile option), then tree_node
+       is the internal parse tree node representation for this
+       instruction sequence.
+    */
+    NODE *tree_node;
+} rb_iseq_t;
+
+enum ruby_special_exceptions {
+    ruby_error_reenter,
+    ruby_error_nomemory,
+    ruby_error_sysstack,
+    ruby_special_error_count
+};
+
+typedef struct rb_vm_struct {
+    VALUE self;
+
+    rb_thread_lock_t global_vm_lock;
+
+    struct rb_thread_struct *main_thread;
+    struct rb_thread_struct *running_thread;
+
+    st_table *living_threads;
+    VALUE thgroup_default;
+
+    int running;
+    int thread_abort_on_exception;
+    unsigned long trace_flag;
+    volatile int sleeper;
+
+    /* object management */
+    VALUE mark_object_ary;
+
+    VALUE special_exceptions[ruby_special_error_count];
+
+    /* load */
+    VALUE top_self;
+    VALUE load_path;
+    VALUE loaded_features;
+    struct st_table *loading_table;
+
+    /* signal */
+    struct {
+        VALUE cmd;
+        int safe;
+    } trap_list[RUBY_NSIG];
+
+    /* hook */
+    rb_event_hook_t *event_hooks;
+
+    int src_encoding_index;
+
+    VALUE verbose, debug, progname;
+    VALUE coverages;
+
+    struct unlinked_method_entry_list_entry *unlinked_method_entry_list;
+
+#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
+    struct rb_objspace *objspace;
+#endif
+} rb_vm_t;
+
+#include "method_mini.h"
+
+typedef struct {
+    VALUE *pc;                  /* cfp[0] */
+    VALUE *sp;                  /* cfp[1] */
+    VALUE *bp;                  /* cfp[2] */
+    rb_iseq_t *iseq;            /* cfp[3] */
+    VALUE flag;                 /* cfp[4] */
+    VALUE self;                 /* cfp[5] / block[0] */
+    VALUE *lfp;                 /* cfp[6] / block[1] */
+    VALUE *dfp;                 /* cfp[7] / block[2] */
+    rb_iseq_t *block_iseq;      /* cfp[8] / block[3] */
+    VALUE proc;                 /* cfp[9] / block[4] */
+    const rb_method_entry_t *me;/* cfp[10] */
+    short int tracing;          /* Bits to control per-frame event tracing. 
+				   See VM_FRAME_TRACE_xxx defines.
+				 */
+} rb_control_frame_t;
+
+typedef struct rb_block_struct {
+    VALUE self;                 /* share with method frame if it's only block */
+    VALUE *lfp;                 /* share with method frame if it's only block */
+    VALUE *dfp;                 /* share with method frame if it's only block */
+    rb_iseq_t *iseq;
+    VALUE proc;
+} rb_block_t;
+
+#define GetThreadPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_thread_t, ptr)
+
+#define GetProcPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_proc_t, ptr)
+
+typedef struct rb_thread_struct
+{
+    VALUE self;
+    rb_vm_t *vm;
+
+    /* execution information */
+    VALUE *stack;               /* must free, must mark. rb: seems to be nil. */
+    unsigned long stack_size;   /* Number of stack (or rb_control_frame_t) entries */
+    rb_control_frame_t *cfp;
+
+    int safe_level;
+    int raised_flag;
+    VALUE last_status; /* $? */
+
+    /* passing state */
+    int state;
+
+    /* tracer */
+    rb_event_hook_t *event_hooks;
+    rb_event_flag_t event_flags;
+    int tracing;  /* 0 if not tracing. If less than 0, skip that many
+                     C call/return pairs */
+    int exec_event_tracing;  /* 0 if not in rb_threadptr_evec_event_hooks. */
+    int trace_skip_insn_count; /* # of VM instructions to skip */
+
+    /* misc */
+    int method_missing_reason;
+    int abort_on_exception;
+
+    /* for rb_iterate */
+    const rb_block_t *passed_block;
+
+    /* for bmethod */
+    const rb_method_entry_t *passed_me;
+
+    /* for load(true) */
+    VALUE top_self;
+    VALUE top_wrapper;
+
+    /* eval env */
+    rb_block_t *base_block;
+
+    VALUE *local_lfp;
+    VALUE local_svar;
+
+    /* Lot's of other stuff ... 
+       thread control ... */
+} rb_thread_t;
+
+typedef struct {
+    rb_block_t block;
+
+    VALUE envval;               /* for GC mark */
+    VALUE blockprocval;
+    int safe_level;
+    int is_from_method;
+    int is_lambda;
+} rb_proc_t;
+
+#define GetEnvPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_env_t, ptr)
+
+typedef struct {
+    VALUE *env;
+    int env_size;
+    int local_size;
+    VALUE prev_envval;		/* for GC mark */
+    rb_block_t block;
+} rb_env_t;
+
+#define GetBindingPtr(obj, ptr) \
+  GetCoreDataFromValue(obj, rb_binding_t, ptr)
+
+typedef struct {
+    VALUE env;
+    VALUE filename;
+    unsigned short line_no;
+} rb_binding_t;
+
+#define GET_THREAD() ruby_current_thread
+extern rb_thread_t *ruby_current_thread;

data/test/unit/test_parse_tree_for_meth.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require_relative '../../ext/parse_tree'
+
+def five; 5 end
+
+class TestParseTree < Test::Unit::TestCase
+  def setup
+    @processor = ParseTree19.new(false)
+  end
+
+  def test_parse_tree_for_method
+
+    def six
+      x = 2
+      y = 3
+      return x * y
+    end
+
+    [
+     [:five,      
+      [:scope, [:args, 0, [:args_aux]], [:lit, 5]]],
+
+     [:six, 
+      [:scope, [:args, 0, [:args_aux]], 
+       [:block, [:lasgn, :x, [:lit, 2]], 
+        [:block, [:lasgn, :y, [:lit, 3]], 
+         [:block, [:call, :*, [:lvar, :x], [:array, 1, [:lvar, :y]]]]]]]]
+    ].each do |meth, expected|
+      actual  = @processor.parse_tree_for_method(method(meth), true)
+      assert_equal expected, actual
+    end
+  end
+end

data/test/unit/test_parse_tree_for_str.rb

@@ -0,0 +1,162 @@
+require 'test/unit'
+require_relative '../../ext/parse_tree'
+
+class TestParseTree < Test::Unit::TestCase
+  def setup
+    @processor = ParseTree19.new(false)
+  end
+
+  def test_parse_tree_for_str
+    # The order of the ops below is the order they appear in
+    # add_to_parse_tree.inc/node.c
+    # Note: if you ever wanted have a Ruby expression that causes
+    # a given parse node to be created, see below.
+    [
+     # block:
+     ['foo; bar',      [:scope, [:block, [:vcall, :foo], 
+                                 [:block, [:vcall, :bar]]]]],
+
+     # if:
+     ['true if nil',   [:scope, [:if, [:nil], [:true]]]],
+     ['if nil then true else false end', 
+      [:scope, [:if, [:nil], [:true], [:false]]]],
+
+     # Need case, when, opt_n
+
+     ['5 while false', [:scope, [:while, [:false], [:lit, 5]]]],
+     ['4 until true',  [:scope, [:until, [:true], [:lit, 4]]]],
+     
+     # iter:
+     ['x { 5 }', 
+      [:scope, [:iter, [:fcall, :x], [:scope, [:lit, 5]]]]],
+
+     # Need for
+       
+     ['break',         [:scope, [:break]]],
+     ['break 1',       [:scope, [:break, [:lit, 1]]]],
+     ['next',          [:scope, [:next]]],
+     ['next 1',        [:scope, [:next,  [:lit, 1]]]],
+     ['return',        [:scope, [:return]]],
+     ['return 4',      [:scope, [:return, [:lit, 4]]]],
+
+     ['redo',          [:scope, [:redo]]],
+     ['retry',         [:scope, [:retry]]],
+
+     # begin
+     ['begin; 1 ; end', 
+      [:scope, [:block, [:begin], [:block, [:lit, 1]]]]],
+
+     # rescue and resbody
+     ['begin; 1 ; rescue; 2; else 3; end',
+      [:scope, [:rescue, [:block, [:begin], [:block, [:lit, 1]]], 
+                [:resbody, [:lit, 2]], [:lit, 3]]]],
+
+     # ensure
+     ['begin; 1 ; ensure; 2; end',
+      [:scope, [:ensure, [:block, [:begin], [:block, [:lit, 1]]], 
+                [:block, [:begin], [:block, [:lit, 2]]]]]],
+
+     # and
+     ['true and nil',  [:scope, [:and, [:true], [:nil]]]],
+     # or
+     ['true or false', [:scope, [:or,  [:true], [:false]]]],
+
+     # lasgn
+     ['x = 5',         [:scope, [:lasgn,  :x,   [:lit, 5]]]],
+     # dasgn:
+     ['x = nil; 1.times { x = 5 }',
+      [:scope, [:block, [:lasgn, :x, [:nil]],
+                [:block, [:iter, [:call, :times, [:lit, 1]], 
+                          [:scope, [:dasgn, :x, [:lit, 5]]]]]]]],
+     # dasgn_cur:
+     ['1.times { x = 5 }',
+      [:scope, [:iter, [:call, :times, [:lit, 1]], 
+                [:scope, [:dasgn_curr, :x, [:lit, 5]]]]]],
+
+     ['@x = 5',      [:scope, [:iasgn,  :@x,  [:lit, 5]]]],
+     ['@@x = 5',     [:scope, [:cvasgn, :@@x, [:lit, 5]]]],
+
+     ['$x = 5',      [:scope, [:gasgn,  :$x,  [:lit, 5]]]],
+
+     ['x &&= 1',     [:scope, [:op_asgn_and,  
+                               [:lvar, :x], [:lasgn, :x, [:lit, 1]]]]],
+     ['x ||= 1',     [:scope, [:op_asgn_or,   
+                               [:lvar, :x], [:lasgn, :x, [:lit, 1]]]]],
+
+     # op_asgn1
+     # 'ary[1] += 2'
+
+     # call:
+     ['x.foo',         [:scope, [:call, :foo, [:vcall, :x]]]],
+       
+     # For fcall, see iter above.
+
+     ['foo',           [:scope, [:vcall, :foo]]],
+
+     ['super',         [:scope, [:zsuper]]],
+
+     # array
+     ['[1]',           [:scope, [:array, 1, [:lit, 1]]]],
+
+     # values array 1st item is not predictable.
+
+     # zarray
+     ['[]',            [:scope, [:zarray]]],
+
+     # hash
+     ['{}',            [:scope, [:hash]]],
+
+     ['yield',         [:scope, [:yield]]],
+
+     # For lvar, see x ||= 1
+
+     # dvar: 
+     ['1.times { x = 1; x }',
+      [:scope, [:iter, [:call, :times, [:lit, 1]], 
+                [:scope, [:block, [:dasgn_curr, :x, [:lit, 1]], 
+                          [:block, [:dvar, :x]]]]]]],
+
+     ['@x',            [:scope, [:ivar,  :@x]]],
+     ['X',             [:scope, [:const, :X]]],
+     ['@@X',           [:scope, [:cvar,  :@@X]]],
+     ['$x',            [:scope, [:gvar,  :$x]]],
+
+     ["5",             [:scope, [:lit, 5]]],
+     ["'5'",           [:scope, [:str, '5']]],
+     ['%x(5)',         [:scope, [:xstr, '5']]],
+     ['"#{5}"',        [:scope, [:dstr, nil, [:evstr, [:lit, 5]]]]],
+     ['`#{5}`',        [:scope, [:dxstr, nil, [:evstr, [:lit, 5]]]]],
+     ['/#{5}/',        [:scope, [:dregx, '', [:evstr, [:lit, 5]]]]],
+     ['/#{5}/o',       [:scope, [:dregx_once, '', [:evstr, [:lit, 5]]]]],
+     [':"#{5}"',       [:scope, [:dsym, nil, [:evstr, [:lit, 5]]]]],
+
+     ['alias a b',     [:scope, [:alias, [:lit, :a], [:lit, :b]]]],
+     ['alias $a $b',   [:scope, [:valias, :$a, :$b]]],
+
+     ['undef foo',     [:scope, [:undef, [:lit, :foo]]]],
+
+     # dot2
+     ['1..5.each{ 5 }',
+      [:scope, [:dot2, [:lit, 1], 
+                [:iter, [:call, :each, [:lit, 5]], [:scope, [:lit, 5]]]]]],
+     # dot3
+     ['1...5.each{ 5 }',
+      [:scope, [:dot3, [:lit, 1], 
+                [:iter, [:call, :each, [:lit, 5]], [:scope, [:lit, 5]]]]]],
+
+     # Need flip2 and flip3
+
+     ['self',          [:scope, [:self]]],
+     ['nil',           [:scope, [:nil]]],
+     ['true',          [:scope, [:true]]],
+     ['false',         [:scope, [:false]]],
+
+     ['M::Foo',        [:scope, [:colon2, :Foo, [:const, :M]]]],
+     ['::Foo',         [:scope, [:colon3, :Foo]]],
+     ['defined?(5)',   [:scope, [:defined, [:lit, 5]]]],
+    ].each do |test_str, expected|
+      actual   = @processor.parse_tree_for_str test_str, '(string)', 1
+      assert_equal expected, actual
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: parsetree19
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- R. Bernstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: "\n\
+  rb-parsetree is the C extension part of ParseTree for Ruby 1.9.\n"
+email: rockyb@rubyforge.org
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.md
+- ext/parse_tree.c
+files: 
+- README.md
+- Rakefile
+- NEWS
+- ChangeLog
+- include/thread_pthread.h
+- include/node.h
+- include/method_mini.h
+- include/ruby19_externs.h
+- include/vm_core_mini.h
+- ext/parse_tree.c
+- ext/add_to_parse_tree.inc
+- test/unit/test_parse_tree_for_str.rb
+- test/unit/test_parse_tree_for_meth.rb
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://github.com/rocky/rb-parsetree19/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 2frame
+      version: 1.9.2frame
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Frame introspection
+test_files: []
+