readapt 0.7.1 → 1.1.1

data/ext/readapt/hash_table.h

@@ -1,32 +1,30 @@
-#ifndef HASH_TABLE_H_
-#define HASH_TABLE_H_
-
-#include "ruby.h"
-
-typedef struct ht_long_array
-{
-    long *items;
-    long size;
-} ht_long_array;
-
-// ht_item is an item in the hash table
-typedef struct ht_item
-{
-    char *key;
-    ht_long_array *value;
-} ht_item;
-
-typedef struct ht_hash_table
-{
-    long size;
-    ht_item **items;
-} ht_hash_table;
-
-ht_hash_table *ht_new();
-void ht_del_hash_table(ht_hash_table *ht);
-
-void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size);
-ht_long_array *ht_search(ht_hash_table *ht, char *key);
-void ht_delete(ht_hash_table *h, char *key);
-
-#endif // HASH_TABLE_H_
+#ifndef HASH_TABLE_H_
+#define HASH_TABLE_H_
+
+typedef struct ht_long_array
+{
+    long *items;
+    long size;
+} ht_long_array;
+
+// ht_item is an item in the hash table
+typedef struct ht_item
+{
+    char *key;
+    ht_long_array *value;
+} ht_item;
+
+typedef struct ht_hash_table
+{
+    long size;
+    ht_item **items;
+} ht_hash_table;
+
+ht_hash_table *ht_new();
+void ht_del_hash_table(ht_hash_table *ht);
+
+void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size);
+ht_long_array *ht_search(ht_hash_table *ht, char *key);
+void ht_delete(ht_hash_table *h, char *key);
+
+#endif // HASH_TABLE_H_

data/ext/readapt/inspector.c

@@ -0,0 +1,51 @@
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "frame.h"
+#include "threads.h"
+#include "normalize.h"
+
+static VALUE process_inspection(const rb_debug_inspector_t *inspector, void *ptr)
+{
+    VALUE locations;
+    long i_size;
+    long i;
+    VALUE loc;
+    VALUE path;
+    int line;
+    VALUE bnd;
+    thread_reference_t *data;
+    frame_t *frm;
+    VALUE iseq;
+
+    data = ptr;
+
+    locations = rb_debug_inspector_backtrace_locations(inspector);
+    i_size = locations == Qnil ? 0 : RARRAY_LENINT(locations);
+    for (i = i_size - 1; i >= 0; i--)
+    {
+        iseq = rb_debug_inspector_frame_iseq_get(inspector, i);
+        if (iseq != Qnil)
+        {
+            loc = rb_ary_entry(locations, i);
+            path = rb_funcall(loc, rb_intern("absolute_path"), 0);
+            line = NUM2INT(rb_funcall(loc, rb_intern("lineno"), 0));
+            bnd = rb_debug_inspector_frame_binding_get(inspector, i);
+
+            frm = malloc(sizeof(frame_t));
+            frm->file = normalize_path_new_cstr(StringValueCStr(path));
+            frm->line = line;
+            frm->binding = bnd;
+            stack_push(data->frames, frm);
+        }
+    }
+
+    return Qnil;
+}
+
+/**
+ * Get an array of frames from the Ruby debug inspector.
+ */
+void inspector_inspect(thread_reference_t *data)
+{
+    rb_debug_inspector_open(process_inspection, (void *)data);
+}

data/ext/readapt/inspector.h

@@ -0,0 +1,8 @@
+#ifndef INSPECTOR_H_
+#define INSPECTOR_H_
+
+#include "ruby.h"
+
+void inspector_inspect(thread_reference_t *);
+
+#endif

data/ext/readapt/monitor.c

@@ -46,18 +46,16 @@ static int match_step(thread_reference_t *ptr)
 static ID
 monitor_debug(const char *file, const long line, VALUE tracepoint, thread_reference_t *ptr, ID event)
 {
-	VALUE bind, bid, snapshot, result;
+	VALUE snapshot, result, gc_disabled;
 
-	bind = rb_funcall(tracepoint, rb_intern("binding"), 0);
-	bid = rb_funcall(bind, rb_intern("object_id"), 0);
-	snapshot = rb_funcall(c_Snapshot, rb_intern("new"), 7,
-		LONG2NUM(ptr->id),
-		bid,
+	// Disable garbage collection to avoid segfaults in Frame#frame_binding
+	gc_disabled = rb_gc_disable();
+	thread_reference_build_frames(ptr);
+	snapshot = rb_funcall(c_Snapshot, rb_intern("new"), 4,
+		INT2NUM(ptr->id),
 		rb_str_new_cstr(file),
 		INT2NUM(line),
-		Qnil,
-		ID2SYM(event),
-		INT2NUM(ptr->depth)
+		ID2SYM(event)
 	);
 	rb_io_flush(rb_stdout);
 	rb_io_flush(rb_stderr);
@@ -68,33 +66,44 @@ monitor_debug(const char *file, const long line, VALUE tracepoint, thread_refere
 		ptr->cursor = ptr->depth;
 		ptr->control = result;
 	}
+	thread_reference_clear_frames(ptr);
+	if (!RTEST(gc_disabled))
+	{
+		rb_gc_enable();
+	}
 	return result;
 }
 
 static void
 process_line_event(VALUE tracepoint, void *data)
 {
-	VALUE ref, tmp;
-	char *tp_file;
-	long tp_line;
+	VALUE ref;
 	thread_reference_t *ptr;
-	rb_trace_arg_t *tp;
+	rb_trace_arg_t *arg;
 	int threadPaused;
 	ID dapEvent;
+	VALUE tmp;
+	char *tp_file;
+	long tp_line;
 
 	ref = thread_current_reference();
 	if (ref != Qnil)
 	{
 		ptr = thread_reference_pointer(ref);
 		threadPaused = (ptr->control == id_pause);
+
 		if (firstLineEvent && ptr->control == id_continue && breakpoints_files() == 0)
 		{
 			return;
 		}
-		tp = rb_tracearg_from_tracepoint(tracepoint);
-		tmp = rb_tracearg_path(tp);
-		tp_file = normalize_path_new_cstr(StringValueCStr(tmp));
-		tp_line = NUM2LONG(rb_tracearg_lineno(tp));
+
+		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);
+		tp_line = NUM2INT(tmp);
 
 		dapEvent = id_continue;
 		if (!firstLineEvent)
@@ -128,7 +137,7 @@ process_line_event(VALUE tracepoint, void *data)
 			monitor_debug(tp_file, tp_line, tracepoint, ptr, dapEvent);
 		}
 
-		free(tp_file);
+		// free(tp_file);
 	}
 }
 
@@ -163,7 +172,7 @@ process_return_event(VALUE tracepoint, void *data)
 static void
 process_thread_begin_event(VALUE tracepoint, void *data)
 {
-	VALUE list, here, prev, ref;
+	VALUE list, here, ref;
 	thread_reference_t *ptr;
 
 	list = rb_funcall(rb_cThread, rb_intern("list"), 0);
@@ -189,12 +198,15 @@ process_thread_end_event(VALUE tracepoint, void *data)
 	thread_reference_t *ptr;
 
 	thr = rb_thread_current();
-	ref = thread_reference(thr);
-	if (ref != Qnil)
+	if (thr != Qnil)
 	{
-		ptr = thread_reference_pointer(ref);
-		monitor_debug("", 0, tracepoint, ptr, rb_intern("thread_end"));
-		thread_delete_reference(thr);
+		ref = thread_reference(thr);
+		if (ref != Qnil)
+		{
+			ptr = thread_reference_pointer(ref);
+			monitor_debug("", 0, tracepoint, ptr, rb_intern("thread_end"));
+			thread_delete_reference(thr);
+		}
 	}
 }
 
@@ -255,6 +267,7 @@ monitor_disable_s(VALUE self)
 
 	free(entryFile);
 	entryFile = NULL;
+	thread_clear();
 
 	return previous;
 }
@@ -280,15 +293,15 @@ void initialize_monitor(VALUE m_Readapt)
 	m_Monitor = rb_define_module_under(m_Readapt, "Monitor");
 	c_Snapshot = rb_define_class_under(m_Readapt, "Snapshot", rb_cObject);
 
-	initialize_threads();
+	initialize_threads(m_Readapt);
 
 	rb_define_singleton_method(m_Monitor, "start", monitor_enable_s, 1);
 	rb_define_singleton_method(m_Monitor, "stop", monitor_disable_s, 0);
 	rb_define_singleton_method(m_Monitor, "pause", monitor_pause_s, 1);
 
 	tpLine = rb_tracepoint_new(Qnil, RUBY_EVENT_LINE, process_line_event, NULL);
-	tpCall = rb_tracepoint_new(Qnil, RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS, process_call_event, NULL);
-	tpReturn = rb_tracepoint_new(Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END, process_return_event, NULL);
+	tpCall = rb_tracepoint_new(Qnil, RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS | RUBY_EVENT_C_CALL, process_call_event, NULL);
+	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);
 	debugProc = Qnil;

data/ext/readapt/normalize.c

@@ -1,53 +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;
-}
-
-char *normalize_path_new_cstr(char *str)
-{
-    char *buffer;
-    long i, len;
-
-    buffer = malloc((strlen(str) + 1) * sizeof(char));
-    strcpy(buffer, str);
-    if (isWindows)
-    {
-        buffer[0] = toupper(buffer[0]);
-        len = strlen(buffer);
-        for (i = 2; i < len; i++)
-        {
-            if (buffer[i] == '\\')
-            {
-                buffer[i] = '/';
-            }
-        }
-    }
-    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);
-
-#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,16 +1,18 @@
-#include "ruby.h"
-#include "ruby/debug.h"
-#include "monitor.h"
-#include "normalize.h"
-#include "breakpoints.h"
-
-static VALUE m_Readapt;
-
-void Init_readapt()
-{
-	m_Readapt = rb_define_module("Readapt");
-
-	initialize_normalize(m_Readapt);
-	initialize_breakpoints(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

@@ -0,0 +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.
+ */
+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);
+}