parsetree19 0.2

data/ext/extconf.rb

@@ -0,0 +1,8 @@
+require "mkmf"
+
+config_file = File.join(File.dirname(__FILE__), 'config_options')
+load config_file if File.exist?(config_file)
+
+# Temporary: to turn off optimization
+# $CFLAGS='-fno-strict-aliasing -g -fPIC'
+create_makefile("parse_tree")

data/ext/parse_tree.c

@@ -0,0 +1,149 @@
+/* What release we got? */
+#define PARSETREE19_VERSION "0.2"  
+#include "../include/vm_core_mini.h"   /* Pulls in ruby.h and node.h */
+#include "../include/ruby19_externs.h" 
+
+/* Turn a Ruby node string, e.g. "NODE_FALSE" into a symbol that ParseTree
+   uses, e.g. :false. */
+static VALUE 
+pt_node_name(const char *name)
+{
+    if (0 == strncmp(name, "NODE_", strlen("NODE_"))) { 
+	const char * name_sans_node = &name[strlen("NODE_")];
+	return 
+	    rb_funcall(
+		rb_funcall(rb_str_new2(name_sans_node), rb_intern("downcase"), 
+			   0),
+		rb_intern("to_sym"), 0);
+    } else {
+	rb_bug("pt_node_name: node %s name should start with NODE_", name);
+	return Qnil;
+    }
+}
+
+static VALUE 
+wrap_into_node(const char * name, VALUE val) 
+{
+    VALUE n = rb_ary_new();
+    rb_ary_push(n, pt_node_name(name));
+    if (val) rb_ary_push(n, val);
+    return n;
+}
+
+#include "add_to_parse_tree.inc" 
+
+static VALUE 
+parse_tree_for_node(VALUE self, NODE *node, VALUE tree)
+{
+    VALUE result = rb_ary_new();
+
+    if (Qfalse == tree)
+	result = rb_parser_dump_tree(node, 0);
+    else
+	result = add_to_parse_tree(self, result, node, NULL);
+    return (result);
+}
+
+static VALUE 
+parse_tree_for_iseq_internal(VALUE self, rb_iseq_t *iseq, VALUE tree)
+{
+    VALUE result = rb_ary_new();
+
+    if (iseq->tree_node) {
+	if (Qfalse == tree)
+	    result = rb_parser_dump_tree(iseq->tree_node, 0);
+	else
+	    result = add_to_parse_tree(self, result, iseq->tree_node, NULL);
+	return (result);
+    } else 
+	return Qnil;
+}
+
+static VALUE 
+parse_tree_for_iseq(VALUE self, VALUE iseqval, VALUE tree)
+{
+    rb_iseq_t *iseq;
+    VALUE result = rb_ary_new();
+
+    GetISeqPtr(iseqval, iseq);
+    parse_tree_for_iseq_internal(self, iseq, tree);
+}
+
+/* Defined in Ruby 1.9 proc.c */
+extern rb_iseq_t *rb_method_get_iseq(VALUE method);
+
+static VALUE 
+parse_tree_for_method(VALUE self, VALUE method, VALUE tree)
+{
+    rb_iseq_t *iseq = rb_method_get_iseq(method);
+    parse_tree_for_iseq_internal(self, iseq, tree);
+}
+
+static VALUE 
+parse_tree_common(VALUE self, VALUE source, VALUE filename, VALUE line,
+                  VALUE tree)
+{
+    VALUE tmp;
+    VALUE result = rb_ary_new();
+    NODE *node = NULL;
+
+#ifdef FIXED
+    rb_thread_t *th = GET_THREAD();
+    int critical;
+#endif
+
+    tmp = rb_check_string_type(filename);
+    if (NIL_P(tmp)) {
+	filename = rb_str_new2("(string)");
+    }
+
+    if (NIL_P(line)) {
+	line = LONG2FIX(1);
+    }
+
+#ifdef FIXED
+    ruby_nerrs = 0;
+    critical = rb_thread_critical;
+    rb_thread_critical = Qtrue;
+    th->parse_in_eval++;
+#endif
+
+    StringValue(source);
+    node = rb_compile_string(StringValuePtr(filename), source, NUM2INT(line));
+
+#ifdef FIXED
+    th->parse_in_eval--;
+    rb_thread_critical = critical;
+    if (ruby_nerrs > 0) {
+	ruby_nerrs = 0;
+	rb_exc_raise(th->errinfo);
+    }
+#endif
+
+    return parse_tree_for_node(self, node, tree);
+}
+
+static VALUE 
+parse_tree_for_str(VALUE self, VALUE source, VALUE filename, VALUE line) 
+{
+    return parse_tree_common(self, source, filename, line, Qtrue);
+}
+
+static VALUE 
+parse_tree_dump(VALUE self, VALUE source, VALUE filename, VALUE line) 
+{
+    return parse_tree_common(self, source, filename, line, Qfalse);
+}
+
+void Init_parse_tree(void) 
+{
+    VALUE c = rb_define_class("ParseTree19", rb_cObject);
+    rb_define_method(c, "parse_tree_for_iseq", 
+		     (VALUE(*)(ANYARGS))parse_tree_for_iseq, 2);
+    rb_define_method(c, "parse_tree_for_method", 
+		     (VALUE(*)(ANYARGS))parse_tree_for_method, 2);
+    rb_define_method(c, "parse_tree_for_str", 
+		     (VALUE(*)(ANYARGS))parse_tree_for_str, 3);
+    rb_define_method(c, "parse_tree_dump", 
+		     (VALUE(*)(ANYARGS))parse_tree_dump, 3);
+}

data/include/method_mini.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ From Ruby 1.9's method.h. 
+
+  Copyright (C) 2009 Koichi Sasada
+
+**********************************************************************/
+#ifndef METHOD_H
+#define METHOD_H
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80
+} rb_method_flag_t;
+
+#define NOEX_SAFE(n) ((int)((n) >> 8) & 0x0F)
+#define NOEX_WITH(n, s) ((s << 8) | (n) | (ruby_running ? 0 : NOEX_BASIC))
+#define NOEX_WITH_SAFE(n) NOEX_WITH(n, rb_safe_level())
+
+/* method data type */
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING   /* wrapper for method_missing(id) */
+} rb_method_type_t;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    int argc; /* This should probably be called "arity" since it is based
+		 on the static prototype, not the supplied arguments
+		 at runtime. */
+    int actual_argc; /* This probably should be called argc. It is the
+			argument count at runtime.*/
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location;
+} rb_method_attr_t;
+
+/* typedef struct rb_iseq_struct rb_iseq_t; */
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t *iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL
+	} optimize_type;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+struct unlinked_method_entry_list_entry {
+    struct unlinked_method_entry_list_entry *next;
+    rb_method_entry_t *me;
+};
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+
+#endif /* METHOD_H */