evalhook 0.2.0 → 0.3.0

data/ext/evalhook_base/evalhook_base.c

@@ -1,795 +0,0 @@
-/*
-
-This file is part of the evalhook project, http://github.com/tario/evalhook
-
-Copyright (c) 2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
-
-evalhook is free software: you can redistribute it and/or modify
-it under the terms of the gnu general public license as published by
-the free software foundation, either version 3 of the license, or
-(at your option) any later version.
-
-evalhook is distributed in the hope that it will be useful,
-but without any warranty; without even the implied warranty of
-merchantability or fitness for a particular purpose.  see the
-gnu general public license for more details.
-
-you should have received a copy of the gnu general public license
-along with evalhook.  if not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-#include <ruby.h>
-#include <env.h>
-#include <node.h>
-
-VALUE m_EvalHook ;
-VALUE c_HookHandler;
-
-#define nd_3rd   u3.node
-
-ID method_call;
-ID method_hooked_method;
-ID method_local_hooked_method;
-ID method_private_hooked_method;
-ID method_public_hooked_method;
-ID method_protected_hooked_method;
-ID method_public, method_private, method_protected;
-
-ID method_set_hook_handler;
-
-struct BLOCK {
-    NODE *var;
-    NODE *body;
-    VALUE self;
-    struct FRAME frame;
-    struct SCOPE *scope;
-    VALUE klass;
-    NODE *cref;
-    int iter;
-    int vmode;
-    int flags;
-    int uniq;
-    struct RVarmap *dyna_vars;
-    VALUE orig_thread;
-    VALUE wrapper;
-    VALUE block_obj;
-    struct BLOCK *outer;
-    struct BLOCK *prev;
-};
-
-struct METHOD {
-    VALUE klass, rklass;
-    VALUE recv;
-    ID id, oid;
-    int safe_level;
-    NODE *body;
-};
-
-
-void process_node(NODE* node, VALUE handler);
-
-void patch_local_call_node(NODE* node, VALUE handler) {
-	NODE* args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_mid)));
-	NODE* args2 = NEW_LIST(NEW_LIT(handler));
-
-	node->nd_recv = NEW_CALL(NEW_SELF(), method_local_hooked_method, args1);
-	node->nd_recv = NEW_CALL(node->nd_recv, method_set_hook_handler, args2);
-	node->nd_mid = method_call;
-
-	nd_set_type(node, NODE_CALL);
-}
-
-void patch_call_node(NODE* node, VALUE handler) {
-	NODE* args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_mid)));
-	NODE* args2 = NEW_LIST(NEW_LIT(handler));
-
-	node->nd_recv = NEW_CALL(node->nd_recv, method_hooked_method, args1);
-	node->nd_recv = NEW_CALL(node->nd_recv, method_set_hook_handler, args2);
-
-	node->nd_mid = method_call;
-}
-
-struct global_entry {
-    struct global_variable *var;
-    ID id;
-};
-
-void process_individual_node(NODE* node, VALUE handler) {
-	ID id = node->nd_mid;
-
-	switch (nd_type(node)) {
-		case NODE_XSTR:{
-
-			NODE* args1 = NEW_LIST(NEW_LIT(node->nd_lit));
-			node->nd_recv = NEW_LIT(handler);
-			node->nd_mid = rb_intern("hooked_xstr");
-			node->nd_args = args1;
-
-			nd_set_type(node, NODE_CALL);
-			break;
-		}
-		case NODE_DXSTR:{
-
-			NODE* newnode = malloc(sizeof(NODE));
-
-			memcpy(newnode, node, sizeof(NODE));
-			nd_set_type(newnode, NODE_DSTR);
-
-			NODE* args1 = NEW_LIST(newnode);
-
-			node->nd_recv = NEW_LIT(handler);
-			node->nd_mid = rb_intern("hooked_xstr");
-			node->nd_args = args1;
-
-			nd_set_type(node, NODE_CALL);
-
-			break;
-		}
-		case NODE_COLON3: {
-
-			ID const_id = node->u2.id;
-
-			VALUE two_points = rb_str_new2("::");
-			VALUE base_namespace_sym = rb_funcall(handler, rb_intern("base_namespace"),0);
-			VALUE base_namespace_str = rb_funcall(base_namespace_sym, rb_intern("to_s"), 0);
-			VALUE base_namespace_array = rb_funcall(base_namespace_str, rb_intern("split"), 1, two_points);
-
-			if (RARRAY(base_namespace_array)->len == 1) {
-				node->nd_mid = const_id;
-				node->nd_head = NEW_CONST(SYM2ID(base_namespace_sym));
-			} else {
-				node->nd_mid = const_id;
-
-				NODE* prevnode;
-
-				int i;
-				for (i=0; i<RARRAY(base_namespace_array)->len; ++i) {
-
-
-					VALUE curr = rb_ary_entry(base_namespace_array, i);
-
-					ID curr_id =
-						SYM2ID(rb_funcall(curr, rb_intern("to_sym"), 0) );
-
-					if (i==0) {
-						prevnode = NEW_CONST(curr_id);
-					} else {
-						prevnode = NEW_COLON2(prevnode, curr_id);
-					}
-				}
-
-				node->nd_head = prevnode;
-			}
-
-			nd_set_type(node, NODE_COLON2);
-			break;
-		}
-/*		case NODE_LASGN:
-		case NODE_IASGN:
-		case NODE_DASGN:
-		case NODE_CVASGN:
-		case NODE_CVDECL:*/
-		case NODE_GASGN: {
-
-				NODE* args1;
-				NODE* args2 = NEW_LIST(node->nd_value);
-
-				if (node->nd_entry != 0) {
-					args1 = NEW_LIST(NEW_LIT(ID2SYM(node->nd_entry->id)));
-				} else {
-					args1 = NEW_LIST(NEW_LIT(ID2SYM(rb_intern("unknown_global"))));
-				}
-
-				node->nd_recv = NEW_CALL(NEW_LIT(handler), rb_intern("hooked_gasgn"), args1);
-				node->nd_mid = rb_intern("set_value");
-				node->nd_args = args2;
-
-				nd_set_type(node, NODE_CALL);
-			break;
-		}
-		case NODE_CDECL: {
-
-			NODE* else_node = node->nd_else;
-			NODE* head_node = node->nd_head;
-			NODE* base_class;
-
-			ID vid;
-
-			if (node->nd_vid == 0) {
-				base_class = else_node;
-				vid = node->nd_else->nd_mid;
-			} else {
-				base_class = NEW_LIT( (ruby_cref->nd_clss));
-				vid = node->nd_vid;
-			}
-
-
-			NODE* args1 = NEW_LIST(base_class);
-			NODE* args2 = NEW_LIST(NEW_LIT(ID2SYM(vid)));
-			NODE* args3 = NEW_LIST(node->nd_value);
-
-			node->nd_recv = NEW_CALL(NEW_LIT(handler), rb_intern("hooked_cdecl"), args1);
-			node->nd_recv = NEW_CALL(node->nd_recv, rb_intern("set_id"), args2);
-			node->nd_mid = rb_intern("set_value");
-			node->nd_args = args3;
-
-			nd_set_type(node, NODE_CALL);
-			break;
-		}
-
-
-		case NODE_SUPER:
-		case NODE_ZSUPER: {
-			node->nd_mid = rb_intern("hooked_super");
-			node->nd_recv = NEW_LIT(handler);
-			nd_set_type(node, NODE_CALL);
-			break;
-		}
-		case NODE_FCALL: {
-			if (id == method_public) break;
-			if (id == method_private) break;
-			if (id == method_protected) break;
-
-			patch_local_call_node(node, handler);
-			break;
-		}
-
-		case NODE_CALL: {
-			patch_call_node(node, handler);
-			break;
-
-		}
-		case NODE_VCALL: {
-			if (id == method_public) break;
-			if (id == method_private) break;
-			if (id == method_protected) break;
-
-			patch_local_call_node(node, handler);
-
-			break;
-		}
-	}
-}
-
-void process_recursive_node(NODE* node, VALUE handler ) {
-
-  switch (nd_type(node)) {
-
-    case NODE_BLOCK:
-      {
-        while (node) {
-          process_node(node->nd_head, handler);
-          node = node->nd_next;
-        }
-      }
-      break;
-
-    case NODE_FBODY:
-    case NODE_DEFINED:
-    case NODE_COLON2:
-      process_node(node->nd_head, handler);
-      break;
-
-    case NODE_MATCH2:
-    case NODE_MATCH3:
-      process_node(node->nd_recv, handler);
-      process_node(node->nd_value, handler);
-      break;
-
-    case NODE_BEGIN:
-    case NODE_OPT_N:
-    case NODE_NOT:
-      process_node(node->nd_body, handler);
-      break;
-
-    case NODE_IF:
-      process_node(node->nd_cond, handler);
-      if (node->nd_body) {
-	      process_node(node->nd_body, handler);
-      }
-      if (node->nd_else) {
-	      process_node(node->nd_else, handler);
-      }
-      break;
-
-  case NODE_CASE:
-    if (node->nd_head != NULL) {
-      process_node(node->nd_head, handler);
-    }
-    node = node->nd_body;
-    while (node) {
-      process_node(node, handler);
-      if (nd_type(node) == NODE_WHEN) {                 /* when */
-        node = node->nd_next;
-      } else {
-        break;                                          /* else */
-      }
-    }
-    break;
-
-  case NODE_WHEN:
-    process_node(node->nd_head, handler);
-    if (node->nd_body) {
-      process_node(node->nd_body, handler);
-    }
-    break;
-
-  case NODE_WHILE:
-  case NODE_UNTIL:
-    process_node(node->nd_cond, handler);
-    if (node->nd_body) {
-      process_node(node->nd_body, handler);
-    }
-    break;
-
-  case NODE_BLOCK_PASS:
-    process_node(node->nd_body, handler);
-    process_node(node->nd_iter, handler);
-    break;
-
-  case NODE_ITER:
-  case NODE_FOR:
-    process_node(node->nd_iter, handler);
-    if (node->nd_var != (NODE *)1
-        && node->nd_var != (NODE *)2
-        && node->nd_var != NULL) {
-	    process_node(node->nd_var, handler);
-    }
-    process_node(node->nd_body, handler);
-    break;
-
-  case NODE_BREAK:
-  case NODE_NEXT:
-    if (node->nd_stts)
-	    process_node(node->nd_stts, handler);
-
-    break;
-
-  case NODE_YIELD:
-    if (node->nd_stts)
-      process_node(node->nd_stts, handler);
-
-    break;
-
-  case NODE_RESCUE:
-    process_node(node->nd_1st, handler);
-    process_node(node->nd_2nd, handler);
-    process_node(node->nd_3rd, handler);
-    break;
-
-  /*
-  // rescue body:
-  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
-  // stmt rescue stmt
-  // a = b rescue c
-  */
-
-  case NODE_RESBODY:
-      if (node->nd_3rd) {
-        process_node(node->nd_3rd, handler);
-      }
-      process_node(node->nd_2nd, handler);
-      process_node(node->nd_1st, handler);
-    break;
-
-  case NODE_ENSURE:
-    process_node(node->nd_head, handler);
-    if (node->nd_ensr) {
-    process_node(node->nd_ensr, handler);
-    }
-    break;
-
-  case NODE_AND:
-  case NODE_OR:
-      process_node(node->nd_1st, handler);
-      process_node(node->nd_2nd, handler);
-    break;
-
-  case NODE_FLIP2:
-  case NODE_FLIP3:
-    process_node(node->nd_beg, handler);
-    process_node(node->nd_end, handler);
-    break;
-
-  case NODE_DOT2:
-  case NODE_DOT3:
-    process_node(node->nd_beg, handler);
-    process_node(node->nd_end, handler);
-    break;
-
-  case NODE_RETURN:
-    if (node->nd_stts)
-      process_node(node->nd_stts, handler);
-    break;
-
-  case NODE_ARGSCAT:
-  case NODE_ARGSPUSH:
-    process_node(node->nd_head, handler);
-    process_node(node->nd_body, handler);
-    break;
-
-  case NODE_CALL:
-  case NODE_FCALL:
-  case NODE_VCALL:
-    if (nd_type(node) != NODE_FCALL) {
-    	if (node->nd_recv) process_node(node->nd_recv, handler);
-	 }
-     if (node->nd_args || nd_type(node) != NODE_FCALL) {
-      	if (node->nd_args) process_node(node->nd_args, handler);
-     }
-    break;
-
-  case NODE_SUPER:
-    process_node(node->nd_args, handler);
-    break;
-
-  case NODE_BMETHOD:
-    {
-      struct BLOCK *data;
-      Data_Get_Struct(node->nd_cval, struct BLOCK, data);
-
-      if (data->var == 0 || data->var == (NODE *)1 || data->var == (NODE *)2) {
-      } else {
-	      process_node(data->var, handler);
-      }
-      process_node(data->body, handler);
-    }
-    break;
-
-#if RUBY_VERSION_CODE < 190
-  case NODE_DMETHOD:
-    {
-      struct METHOD *data;
-      Data_Get_Struct(node->nd_cval, struct METHOD, data);
-      process_node(data->body, handler);
-
-      break;
-    }
-#endif
-
-  case NODE_METHOD:
-    // You should not ever get here. parse_tree_for_meth passes nd_body
-    process_node(node->nd_body, handler);
-    break;
-
-  case NODE_SCOPE:
-    process_node(node->nd_next, handler);
-    break;
-
-  case NODE_OP_ASGN1:
-    process_node(node->nd_recv, handler);
-#if RUBY_VERSION_CODE < 185
-    process_node(node->nd_args->nd_next, handler);
-#else
-    process_node(node->nd_args->nd_2nd, handler);
-#endif
-    process_node(node->nd_args->nd_head, handler);
-    break;
-
-  case NODE_OP_ASGN2:
-    process_node(node->nd_recv, handler);
-    process_node(node->nd_value, handler);
-    break;
-
-  case NODE_OP_ASGN_AND:
-  case NODE_OP_ASGN_OR:
-    process_node(node->nd_head, handler);
-    process_node(node->nd_value, handler);
-    break;
-
-  case NODE_MASGN:
-    if (node->nd_head) {
-    process_node(node->nd_head, handler);
-    }
-    if (node->nd_args) {
-      if (node->nd_args != (NODE *)-1) {
-	    process_node(node->nd_args, handler);
-      }
-    }
-    if (node->nd_value) {
-	    process_node(node->nd_value, handler);
-    }
-    break;
-
-  case NODE_LASGN:
-  case NODE_IASGN:
-  case NODE_DASGN:
-  case NODE_CVASGN:
-  case NODE_CVDECL:
-  case NODE_GASGN:
-    process_node(node->nd_value, handler);
-    break;
-
-  case NODE_CDECL:
-    if (node->nd_vid) {
-    } else {
-      process_node(node->nd_else, handler);
-    }
-    process_node(node->nd_value, handler);
-    break;
-
-  case NODE_DASGN_CURR:
-    if (node->nd_value) {
-      process_node(node->nd_value, handler);
-    }
-    break;
-
-  case NODE_ALIAS:            /* u1 u2 (alias :blah :blah2) */
-#if RUBY_VERSION_CODE < 185
-#else
-    process_node(node->nd_1st, handler);
-    process_node(node->nd_2nd, handler);
-#endif
-    break;
-
-  case NODE_UNDEF:            /* u2    (undef name, ...) */
-#if RUBY_VERSION_CODE < 185
-#else
-    process_node(node->nd_value, handler);
-#endif
-    break;
-
-  case NODE_HASH:
-    {
-      NODE *list;
-
-      list = node->nd_head;
-      while (list) {
-	    process_node(list->nd_head, handler);
-        list = list->nd_next;
-      }
-    }
-    break;
-
-  case NODE_ARRAY:
-      while (node) {
-	    process_node(node->nd_head, handler);
-        node = node->nd_next;
-      }
-    break;
-
-  case NODE_DSTR:
-  case NODE_DSYM:
-  case NODE_DXSTR:
-  case NODE_DREGX:
-  case NODE_DREGX_ONCE:
-    {
-      NODE *list = node->nd_next;
-      while (list) {
-        if (list->nd_head) {
-		  process_node(list->nd_head, handler);
-        }
-        list = list->nd_next;
-      }
-    }
-    break;
-
-  case NODE_DEFN:
-  case NODE_DEFS:
-    if (node->nd_defn) {
-      if (nd_type(node) == NODE_DEFS)
-	    process_node(node->nd_recv, handler);
-
-      process_node(node->nd_defn, handler);
-    }
-    break;
-
-  case NODE_CLASS:
-  case NODE_MODULE:
-    if (nd_type(node->nd_cpath) == NODE_COLON2 && ! node->nd_cpath->nd_vid) {
-    } else {
-      process_node(node->nd_cpath, handler);
-    }
-
-    if (nd_type(node) == NODE_CLASS) {
-      if (node->nd_super) {
-        process_node(node->nd_super, handler);
-      }
-    }
-    process_node(node->nd_body, handler);
-    break;
-
-  case NODE_SCLASS:
-    process_node(node->nd_recv, handler);
-    process_node(node->nd_body, handler);
-    break;
-
-  case NODE_ARGS: {
-    NODE *optnode;
-    optnode = node->nd_opt;
-    if (optnode) {
-	  process_node(node->nd_opt, handler);
-    }
-  }  break;
-
-  case NODE_NEWLINE:
-    process_node(node->nd_next, handler);
-    break;
-
-  case NODE_SPLAT:
-  case NODE_TO_ARY:
-  case NODE_SVALUE:             /* a = b, c */
-    process_node(node->nd_head, handler);
-    break;
-
-  case NODE_ATTRASGN:           /* literal.meth = y u1 u2 u3 */
-    /* node id node */
-    if (node->nd_1st == RNODE(1)) {
-//      add_to_parse_tree(self, current, NEW_SELF(), locals);
-    } else {
-        process_node(node->nd_1st, handler);
-    }
-    process_node(node->nd_3rd, handler);
-    break;
-
-  case NODE_EVSTR:
-    process_node(node->nd_2nd, handler);
-    break;
-
-
-#if RUBY_VERSION_CODE >= 190
-  case NODE_ERRINFO:
-  case NODE_VALUES:
-  case NODE_PRELUDE:
-  case NODE_LAMBDA:
-    puts("no worky in 1.9 yet");
-    break;
-#endif
-
-  /* Nodes we found but have yet to decypher */
-  /* I think these are all runtime only... not positive but... */
-  case NODE_MEMO:               /* enum.c zip */
-  case NODE_CREF:
-  /* #defines: */
-  /* case NODE_LMASK: */
-  /* case NODE_LSHIFT: */
-  default:
-    break;
-  }
-}
-
-void process_node(NODE* node, VALUE handler) {
-	if (node) {
-	process_recursive_node(node, handler);
-	process_individual_node(node, handler);
-	}
-}
-
-VALUE hook_method_tree(VALUE self, VALUE rb_method) {
-
-	struct METHOD* method;
-	Data_Get_Struct(rb_method,struct METHOD,method);
-
-	NODE* node = method->body->nd_defn;
-	process_node(node, self);
-
-	return Qnil;
-}
-
-
-VALUE hook_block(VALUE self, VALUE handler) {
-	process_node(ruby_frame->node->nd_recv, handler);
-}
-
-VALUE caller_method(VALUE self, VALUE rblevel) {
-	int level = FIX2INT(rblevel);
-
-	struct FRAME* frame = ruby_frame;
-	while(level--) frame = frame->prev;
-
-	return ID2SYM(frame->orig_func);
-}
-
-VALUE caller_class(VALUE self, VALUE rblevel) {
-	int level = FIX2INT(rblevel);
-
-	struct FRAME* frame = ruby_frame;
-	while(level--) frame = frame->prev;
-
-	return frame->last_class;
-}
-
-VALUE caller_obj(VALUE self, VALUE rblevel) {
-	int level = FIX2INT(rblevel);
-
-	struct FRAME* frame = ruby_frame;
-	while(level--) frame = frame->prev;
-
-	return frame->self;
-}
-
-
-static void
-blk_mark(data)
-    struct BLOCK *data;
-{
-    while (data) {
-	rb_gc_mark_frame(&data->frame);
-	rb_gc_mark((VALUE)data->scope);
-	rb_gc_mark((VALUE)data->var);
-	rb_gc_mark((VALUE)data->body);
-	rb_gc_mark((VALUE)data->self);
-	rb_gc_mark((VALUE)data->dyna_vars);
-	rb_gc_mark((VALUE)data->cref);
-	rb_gc_mark(data->wrapper);
-	rb_gc_mark(data->block_obj);
-	data = data->prev;
-    }
-}
-
-static void
-blk_free(data)
-    struct BLOCK *data;
-{
-    void *tmp;
-
-    while (data) {
-	frame_free(&data->frame);
-	tmp = data;
-	data = data->prev;
-	free(tmp);
-    }
-}
-
-
-VALUE validate_syntax(VALUE self, VALUE code) {
-
-	NODE* node = rb_compile_string("(eval)", code, 1);
-
-	if (node == 0) {
-		rb_raise(rb_eSyntaxError,"");
-	}
-
-	return Qnil;
-}
-
-
-extern void Init_evalhook_base() {
-	m_EvalHook = rb_define_module("EvalHook");
-
-/*
-Class to create hook instances for specific handling of method calls and/or const and global assignment
-
-=== Example:
-
-Hook of method calls
-
-	require "rubygems"
-	require "evalhook"
-
-	class Hook < EvalHook::HookHandler
-		def handle_method(klass, recv, method_name)
-			print "called #{klass}##{method_name} over #{recv}\n"
-			nil
-		end
-	end
-
-	h = Hook.new
-	h.evalhook('print "hello world\n"')
-
-
-
-
-See README for more examples
-
-*/
-	c_HookHandler = rb_define_class_under(m_EvalHook, "HookHandler", rb_cObject);
-
-	rb_define_singleton_method(m_EvalHook, "hook_block", hook_block, 1);
-	rb_define_singleton_method(m_EvalHook, "validate_syntax", validate_syntax, 1);
-
-	rb_define_method(c_HookHandler, "hook_method_tree", hook_method_tree, 1);
-
-	rb_define_method(c_HookHandler, "caller_method", caller_method, 1);
-	rb_define_method(c_HookHandler, "caller_class", caller_class, 1);
-	rb_define_method(c_HookHandler, "caller_obj", caller_obj, 1);
-
-	method_local_hooked_method = rb_intern("local_hooked_method");
-	method_hooked_method = rb_intern("hooked_method");
-	method_call = rb_intern("call");
-	method_private = rb_intern("private");
-	method_public = rb_intern("public");
-	method_protected = rb_intern("protected");
-	method_set_hook_handler = rb_intern("set_hook_handler");
-}