readapt 0.8.0 → 1.2.0

data/ext/readapt/monitor.c

@@ -14,6 +14,7 @@ static VALUE tpCall;
 static VALUE tpReturn;
 static VALUE tpThreadBegin;
 static VALUE tpThreadEnd;
+static VALUE tpRaise;
 static VALUE debugProc;
 static int firstLineEvent = 0;
 static char *entryFile;
@@ -52,7 +53,7 @@ monitor_debug(const char *file, const long line, VALUE tracepoint, thread_refere
 	gc_disabled = rb_gc_disable();
 	thread_reference_build_frames(ptr);
 	snapshot = rb_funcall(c_Snapshot, rb_intern("new"), 4,
-		LONG2NUM(ptr->id),
+		INT2NUM(ptr->id),
 		rb_str_new_cstr(file),
 		INT2NUM(line),
 		ID2SYM(event)
@@ -99,7 +100,6 @@ process_line_event(VALUE tracepoint, void *data)
 
 		arg = rb_tracearg_from_tracepoint(tracepoint);
 		tmp = rb_tracearg_path(arg);
-		// tp_file = normalize_path_new_cstr(StringValueCStr(tmp));
 		tp_file = StringValueCStr(tmp);
 		normalize_path(tp_file);
 		tmp = rb_tracearg_lineno(arg);
@@ -136,8 +136,6 @@ process_line_event(VALUE tracepoint, void *data)
 		{
 			monitor_debug(tp_file, tp_line, tracepoint, ptr, dapEvent);
 		}
-
-		// free(tp_file);
 	}
 }
 
@@ -210,6 +208,40 @@ process_thread_end_event(VALUE tracepoint, void *data)
 	}
 }
 
+static void
+process_raise_event(VALUE tracepoint, void *data)
+{
+	rb_trace_arg_t *arg;
+	VALUE exception;
+	VALUE ref;
+	thread_reference_t *ptr;
+	VALUE tmp;
+	char *tp_file;
+	long tp_line;
+
+	ref = thread_current_reference();
+	if (ref != Qnil)
+	{
+		arg = rb_tracearg_from_tracepoint(tracepoint);
+		exception = rb_tracearg_raised_exception(arg);
+		if (rb_class_inherited_p(rb_obj_class(exception), rb_eStandardError)) {
+			ptr = thread_reference_pointer(ref);
+			tmp = rb_tracearg_path(arg);
+			tp_file = StringValueCStr(tmp);
+			normalize_path(tp_file);
+			tmp = rb_tracearg_lineno(arg);
+			tp_line = NUM2INT(tmp);
+			monitor_debug(
+				tp_file,
+				tp_line,
+				tracepoint,
+				ptr,
+				rb_intern("raise")
+			);
+		}
+	}
+}
+
 static VALUE
 monitor_enable_s(VALUE self, VALUE file)
 {
@@ -218,7 +250,6 @@ monitor_enable_s(VALUE self, VALUE file)
 
 	if (rb_block_given_p()) {
 		debugProc = rb_block_proc();
-		rb_global_variable(&debugProc);
 	} else {
 		rb_raise(rb_eArgError, "must be called with a block");
 	}
@@ -250,6 +281,7 @@ monitor_enable_s(VALUE self, VALUE file)
 	rb_tracepoint_enable(tpReturn);
 	rb_tracepoint_enable(tpThreadBegin);
 	rb_tracepoint_enable(tpThreadEnd);
+	rb_tracepoint_enable(tpRaise);
 	return previous;
 }
 
@@ -264,6 +296,7 @@ monitor_disable_s(VALUE self)
 	rb_tracepoint_disable(tpReturn);
 	rb_tracepoint_disable(tpThreadBegin);
 	rb_tracepoint_disable(tpThreadEnd);
+	rb_tracepoint_disable(tpRaise);
 
 	free(entryFile);
 	entryFile = NULL;
@@ -304,6 +337,7 @@ void initialize_monitor(VALUE m_Readapt)
 	tpReturn = rb_tracepoint_new(Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END | RUBY_EVENT_C_RETURN, process_return_event, NULL);
 	tpThreadBegin = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_BEGIN, process_thread_begin_event, NULL);
 	tpThreadEnd = rb_tracepoint_new(Qnil, RUBY_EVENT_THREAD_END, process_thread_end_event, NULL);
+	tpRaise = rb_tracepoint_new(Qnil, RUBY_EVENT_RAISE, process_raise_event, NULL);
 	debugProc = Qnil;
 
 	id_continue = rb_intern("continue");
@@ -316,4 +350,7 @@ void initialize_monitor(VALUE m_Readapt)
 	rb_global_variable(&tpReturn);
 	rb_global_variable(&tpThreadBegin);
 	rb_global_variable(&tpThreadEnd);
+	rb_global_variable(&tpRaise);
+
+	rb_global_variable(&debugProc);
 }

data/ext/readapt/normalize.c

@@ -1,59 +1,59 @@
-#include "ruby.h"
-#include "ruby/debug.h"
-#include <ctype.h>
-
-static int isWindows;
-
-static int
-checkIfWindows()
-{
-    VALUE regexp, result;
-    
-    regexp = rb_reg_new("/cygwin|mswin|mingw|bccwin|wince|emx/", 37, 0);
-    result = rb_reg_match(regexp, rb_str_new_cstr(RUBY_PLATFORM));
-    return result == Qnil ? 0 : 1;
-}
-
-void normalize_path(char *str)
-{
-    long i, len;
-
-    if (isWindows)
-    {
-        str[0] = toupper(str[0]);
-        len = strlen(str);
-        for (i = 2; i < len; i++)
-        {
-            if (str[i] == '\\')
-            {
-                str[i] = '/';
-            }
-        }
-    }
-}
-
-char *normalize_path_new_cstr(char *str)
-{
-    char *buffer;
-
-    buffer = malloc((strlen(str) + 1) * sizeof(char));
-    strcpy(buffer, str);
-    normalize_path(buffer);
-    return buffer;
-}
-
-static VALUE
-normalize_path_s(VALUE self, VALUE str)
-{
-    char *path = normalize_path_new_cstr(StringValueCStr(str));
-    VALUE result = rb_str_new_cstr(path);
-    free(path);
-    return result;
-}
-
-void initialize_normalize(VALUE m_Readapt)
-{
-    isWindows = checkIfWindows();
-    
-    rb_define_singleton_method(m_Readapt, "normalize_path", normalize_path_s, 1);
-}
+#include "ruby.h"
+#include "ruby/debug.h"
+#include <ctype.h>
+
+static int isWindows;
+
+static int
+checkIfWindows()
+{
+    VALUE regexp, result;
+    
+    regexp = rb_reg_new("/cygwin|mswin|mingw|bccwin|wince|emx/", 37, 0);
+    result = rb_reg_match(regexp, rb_str_new_cstr(RUBY_PLATFORM));
+    return result == Qnil ? 0 : 1;
+}
+
+void normalize_path(char *str)
+{
+    long i, len;
+
+    if (isWindows)
+    {
+        str[0] = toupper(str[0]);
+        len = strlen(str);
+        for (i = 2; i < len; i++)
+        {
+            if (str[i] == '\\')
+            {
+                str[i] = '/';
+            }
+        }
+    }
+}
+
+char *normalize_path_new_cstr(char *str)
+{
+    char *buffer;
+
+    buffer = malloc((strlen(str) + 1) * sizeof(char));
+    strcpy(buffer, str);
+    normalize_path(buffer);
+    return buffer;
+}
+
+static VALUE
+normalize_path_s(VALUE self, VALUE str)
+{
+    char *path = normalize_path_new_cstr(StringValueCStr(str));
+    VALUE result = rb_str_new_cstr(path);
+    free(path);
+    return result;
+}
+
+void initialize_normalize(VALUE m_Readapt)
+{
+    isWindows = checkIfWindows();
+    
+    rb_define_singleton_method(m_Readapt, "normalize_path", normalize_path_s, 1);
+}

data/ext/readapt/normalize.h

@@ -1,7 +1,7 @@
-#ifndef NORMALIZE_H_
-#define NORMALIZE_H_
-
-void initialize_normalize(VALUE);
-char *normalize_path_new_cstr(char *str);
-void normalize_path(char *str);
-#endif
+#ifndef NORMALIZE_H_
+#define NORMALIZE_H_
+
+void initialize_normalize(VALUE);
+char *normalize_path_new_cstr(char *str);
+void normalize_path(char *str);
+#endif

data/ext/readapt/readapt.c

@@ -1,18 +1,18 @@
-#include "ruby.h"
-#include "ruby/debug.h"
-#include "monitor.h"
-#include "normalize.h"
-#include "breakpoints.h"
-#include "frame.h"
-
-static VALUE m_Readapt;
-
-void Init_readapt()
-{
-	m_Readapt = rb_define_module("Readapt");
-
-	initialize_normalize(m_Readapt);
-	initialize_breakpoints(m_Readapt);
-	initialize_frame(m_Readapt);
-	initialize_monitor(m_Readapt);
-}
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "monitor.h"
+#include "normalize.h"
+#include "breakpoints.h"
+#include "frame.h"
+
+static VALUE m_Readapt;
+
+void Init_readapt()
+{
+	m_Readapt = rb_define_module("Readapt");
+
+	initialize_normalize(m_Readapt);
+	initialize_breakpoints(m_Readapt);
+	initialize_frame(m_Readapt);
+	initialize_monitor(m_Readapt);
+}

data/ext/readapt/stack.c

@@ -1,86 +1,86 @@
-#include <stdlib.h>
-#include "stack.h"
-
-#define STACK_CAPACITY 20
-
-/**
- * Allocate a stack. The `elem_size` is the expected size of each element,
- * e.g., `sizeof(some_struct)`. The optional `free_func` argument is a pointer
- * to a function that will be called when an element is popped off the stack.
- */
-stack_t *stack_alloc(size_t elem_size, void (*free_func)(void *))
-{
-    stack_t *s = malloc(sizeof(stack_t));
-    s->elem_size = elem_size;
-    s->free_func = free_func;
-    s->size = 0;
-    s->capacity = 0;
-    return s;
-}
-
-/**
- * Add an element to the end of the stack
- */
-void stack_push(stack_t *stack, void *element)
-{
-    if (stack->size == stack->capacity)
-    {
-        if (stack->capacity == 0)
-        {
-            stack->capacity = STACK_CAPACITY;
-            stack->elements = malloc(stack->elem_size * stack->capacity);
-        }
-        else
-        {
-            stack->capacity += STACK_CAPACITY;
-            stack->elements = realloc(stack->elements, stack->elem_size * stack->capacity);
-        }
-    }
-    stack->elements[stack->size] = element;
-    stack->size++;
-}
-
-/**
- * Get a pointer to the last element in the stack.
- */
-void *stack_peek(stack_t *stack)
-{
-    return stack->size == 0 ? NULL : stack->elements[stack->size - 1];
-}
-
-/**
- * Pop the last element off the stack and pass it to free_func.
- */
-void stack_pop(stack_t *stack)
-{
-    void *e;
-
-    if (stack->size > 0)
-    {
-        e = stack->elements[stack->size - 1];
-        if (stack->free_func)
-        {
-            stack->free_func(e);
-        }
-        // stack->elements[stack->size - 1] = NULL;
-        stack->size--;
-    }
-}
-
-/**
- * Free the stack from memory. If it still contains any elements, pass them to
- * free_func.
- */
-void stack_free(stack_t *stack)
-{
-    int i;
-
-    if (stack->free_func)
-    {
-        for (i = 0; i < stack->size; i++)
-        {
-            stack->free_func(stack->elements[i]);
-        }
-    }
-    free(stack);
-}
+#include <stdlib.h>
+#include "stack.h"
+
+#define STACK_CAPACITY 20
+
+/**
+ * Allocate a stack. The `elem_size` is the expected size of each element,
+ * e.g., `sizeof(some_struct)`. The optional `free_func` argument is a pointer
+ * to a function that will be called when an element is popped off the stack.
+ */
+readapt_stack_t *stack_alloc(size_t elem_size, void (*free_func)(void *))
+{
+    readapt_stack_t *s = malloc(sizeof(readapt_stack_t));
+    s->elem_size = elem_size;
+    s->free_func = free_func;
+    s->size = 0;
+    s->capacity = 0;
+    return s;
+}
+
+/**
+ * Add an element to the end of the stack
+ */
+void stack_push(readapt_stack_t *stack, void *element)
+{
+    if (stack->size == stack->capacity)
+    {
+        if (stack->capacity == 0)
+        {
+            stack->capacity = STACK_CAPACITY;
+            stack->elements = malloc(stack->elem_size * stack->capacity);
+        }
+        else
+        {
+            stack->capacity += STACK_CAPACITY;
+            stack->elements = realloc(stack->elements, stack->elem_size * stack->capacity);
+        }
+    }
+    stack->elements[stack->size] = element;
+    stack->size++;
+}
+
+/**
+ * Get a pointer to the last element in the stack.
+ */
+void *stack_peek(readapt_stack_t *stack)
+{
+    return stack->size == 0 ? NULL : stack->elements[stack->size - 1];
+}
+
+/**
+ * Pop the last element off the stack and pass it to free_func.
+ */
+void stack_pop(readapt_stack_t *stack)
+{
+    void *e;
+
+    if (stack->size > 0)
+    {
+        e = stack->elements[stack->size - 1];
+        if (stack->free_func)
+        {
+            stack->free_func(e);
+        }
+        // stack->elements[stack->size - 1] = NULL;
+        stack->size--;
+    }
+}
+
+/**
+ * Free the stack from memory. If it still contains any elements, pass them to
+ * free_func.
+ */
+void stack_free(readapt_stack_t *stack)
+{
+    int i;
+
+    if (stack->free_func)
+    {
+        for (i = 0; i < stack->size; i++)
+        {
+            stack->free_func(stack->elements[i]);
+        }
+    }
+    free(stack);
+}