readapt 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d414f01a0f666c2b96e522ca8eaed42a796cbb929c46d13e813837cad1bafc0
-  data.tar.gz: 18be9da48ce7f0ea2d2c1bcf038492fc73945617f9b650c51fedb69ae0aef8f5
+  metadata.gz: 660628a66dff5d1b46364c85d7ef3f115693463c1a94b18854ca79c7521a5b86
+  data.tar.gz: 4cbbffc522a4907d1819846262c473add5e76404f04bb3c654829301c704e821
 SHA512:
-  metadata.gz: aa3fdb1fc8fc12a58dfec52c6f3cabe7876165efcbc56f88ee0c1f5ce1f734e79a2b53f4340be9f4ade0491c96ac0aec0683007022f93c598a70b25ef6b2606d
-  data.tar.gz: 3087142261e3e42add244d763dd1555db7f0318839896e342d4cddada267a8538801cf66c1bb952e8f11e26166a50d6b8efcb216fbab7d1d7f1be381acd0e147
+  metadata.gz: 5f36dd16bf2e1a396eda01205e80fa5bf0d6ff3a12064297cbd6cba2f2f3643fb527a31c76c659bd4c49c32ae620d7dba72ede08ba677d0187cef0ba9b6b0ec5
+  data.tar.gz: 1e21ac739a23df49966a15a7b99477c5e0e795a8bc9600f779a9cd9c9ff58aa3c11b5a57fb4c9fb9732cf04287fa8614a99ecc561526fc6d20d9b73b4a305690

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.8.0 - November 9, 2019
+- Multiple frames
+- Flush output on disconnect
+- Use Ruby debug inspector for stack frames
+- Faster line processing
+- Monitor disables GC
+
 # 0.7.1 - October 13, 2019
 - Debugger sets program name
 

data/Rakefile

@@ -12,14 +12,3 @@ task :default => :spec
 Rake::ExtensionTask.new "readapt" do |ext|
   ext.lib_dir = "lib/readapt"
 end
-
-namespace :install do
-  desc 'Install on Windows'
-  task :win do
-    Dir.mktmpdir do |tmp|
-      gemfile = File.join(tmp, 'readapt.gem')
-      system("gem build readapt.gemspec -o #{gemfile}") &&
-        system("gem install #{gemfile}")
-    end
-  end
-end

data/ext/readapt/breakpoints.c

@@ -54,11 +54,6 @@ int breakpoints_match(char *file, long line)
     return 0;
 }
 
-// int breakpoints_match(char *file, long line)
-// {
-//     return breakpoints_match_id(rb_intern(file), line);
-// }
-
 static VALUE breakpoints_match_s(VALUE self, VALUE file, VALUE line)
 {
     return breakpoints_match(StringValueCStr(file), NUM2LONG(line)) == 0 ? Qfalse : Qtrue;

data/ext/readapt/breakpoints.h

@@ -6,7 +6,6 @@ void initialize_breakpoints(VALUE m_Readapt);
 void breakpoints_set(char *file, long *lines);
 void breakpoints_delete(char *file);
 int breakpoints_match(char *file, long line);
-// int breakpoints_match_id(ht_key file, long line);
 long breakpoints_files();
 
 #endif

data/ext/readapt/frame.c

@@ -0,0 +1,137 @@
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "frame.h"
+#include "normalize.h"
+
+static VALUE c_Frame;
+
+void frame_free(void *data)
+{
+    frame_t *frm = data;
+
+    free(frm->file);
+    free(frm);
+}
+
+static size_t
+frame_size(const void *data)
+{
+    return sizeof(frame_t);
+}
+
+static const rb_data_type_t frame_type = {
+    .wrap_struct_name = "frame_data",
+    .function = {
+        .dmark = NULL,
+        .dfree = frame_free,
+        .dsize = frame_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE frame_allocate_s(VALUE self)
+{
+    VALUE obj;
+    frame_t *data = malloc(sizeof(frame_t));
+    obj = TypedData_Wrap_Struct(self, &frame_type, data);
+    data->file = NULL;
+    data->line = 0;
+    data->binding = Qnil;
+    return obj;
+}
+
+VALUE frame_allocate()
+{
+    return frame_allocate_s(c_Frame);
+}
+
+frame_t *frame_data_from_tracepoint(VALUE tracepoint)
+{
+    frame_t *data;
+    VALUE tmp;
+    rb_trace_arg_t *tracearg;
+    char *file;
+    int line;
+
+    data = malloc(sizeof(frame_t));
+    tracearg = rb_tracearg_from_tracepoint(tracepoint);
+    tmp = rb_tracearg_path(tracearg);
+    file = (tmp == Qnil ? NULL : normalize_path_new_cstr(StringValueCStr(tmp)));
+    line = NUM2INT(rb_tracearg_lineno(tracearg));
+
+    data->file = file;
+    data->line = line;
+    data->binding = Qnil;
+
+    return data;
+}
+
+VALUE frame_initialize_m(VALUE self, VALUE file, VALUE line, VALUE binding)
+{
+    frame_t *data;
+    TypedData_Get_Struct(self, frame_t, &frame_type, data);
+    if (file == Qnil)
+    {
+        data->file = NULL;
+    }
+    else
+    {
+        data->file = normalize_path_new_cstr(StringValueCStr(file));
+    }
+    data->line = NUM2INT(line);
+    data->binding = binding;
+    return self;
+}
+
+VALUE frame_new_from_data(frame_t *data)
+{
+    VALUE obj;
+
+    obj = frame_allocate();
+    frame_initialize_m(
+        obj,
+        rb_str_new_cstr(data->file),
+        INT2NUM(data->line),
+        data->binding);
+
+    return obj;
+}
+
+VALUE frame_file_m(VALUE self)
+{
+    frame_t *data;
+    VALUE str = Qnil;
+
+    TypedData_Get_Struct(self, frame_t, &frame_type, data);
+    if (data->file)
+    {
+        str = rb_str_new_cstr(data->file);
+        rb_obj_freeze(str);
+    }
+    return str;
+}
+
+VALUE frame_line_m(VALUE self)
+{
+    frame_t *data;
+    TypedData_Get_Struct(self, frame_t, &frame_type, data);
+    return INT2NUM(data->line);
+}
+
+VALUE frame_binding_m(VALUE self)
+{
+    frame_t *data;
+    TypedData_Get_Struct(self, frame_t, &frame_type, data);
+    return data->binding;
+}
+
+void initialize_frame(VALUE m_Readapt)
+{
+    c_Frame = rb_define_class_under(m_Readapt, "Frame", rb_cData);
+    rb_define_alloc_func(c_Frame, frame_allocate_s);
+    rb_define_method(c_Frame, "initialize", frame_initialize_m, 3);
+    rb_define_method(c_Frame, "file", frame_file_m, 0);
+    rb_define_method(c_Frame, "line", frame_line_m, 0);
+    rb_define_method(c_Frame, "frame_binding", frame_binding_m, 0);
+}

data/ext/readapt/frame.h

@@ -0,0 +1,17 @@
+#ifndef FRAME_H_
+#define FRAME_H_
+
+#include "ruby.h"
+
+typedef struct frame_struct {
+    char *file;
+    int line;
+    VALUE binding;
+} frame_t;
+
+void initialize_frame(VALUE);
+frame_t *frame_data_from_tracepoint(VALUE);
+VALUE frame_new_from_data(frame_t *);
+void frame_free(void *);
+
+#endif

data/ext/readapt/hash_table.c

@@ -3,7 +3,6 @@
 #include <string.h>
 
 #include "hash_table.h"
-#include "ruby.h"
 
 static ht_long_array *copy_array(const long *value, const long size)
 {

data/ext/readapt/hash_table.h

@@ -1,8 +1,6 @@
 #ifndef HASH_TABLE_H_
 #define HASH_TABLE_H_
 
-#include "ruby.h"
-
 typedef struct ht_long_array
 {
     long *items;

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,
+	// 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,
 		LONG2NUM(ptr->id),
-		bid,
 		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

@@ -14,25 +14,31 @@ checkIfWindows()
     return result == Qnil ? 0 : 1;
 }
 
-char *normalize_path_new_cstr(char *str)
+void normalize_path(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);
+        str[0] = toupper(str[0]);
+        len = strlen(str);
         for (i = 2; i < len; i++)
         {
-            if (buffer[i] == '\\')
+            if (str[i] == '\\')
             {
-                buffer[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;
 }