readapt 0.7.1 → 0.8.0

data/ext/readapt/normalize.h

@@ -3,5 +3,5 @@
 
 void initialize_normalize(VALUE);
 char *normalize_path_new_cstr(char *str);
-
+void normalize_path(char *str);
 #endif

data/ext/readapt/readapt.c

@@ -3,6 +3,7 @@
 #include "monitor.h"
 #include "normalize.h"
 #include "breakpoints.h"
+#include "frame.h"
 
 static VALUE m_Readapt;
 
@@ -12,5 +13,6 @@ void Init_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.
+ */
+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);
+}

data/ext/readapt/stack.h

@@ -0,0 +1,20 @@
+#ifndef STACK_H_
+#define STACK_H_
+
+#include "stddef.h"
+
+typedef struct stack_struct {
+    int size;
+    size_t elem_size;
+    void (*free_func)(void *);
+    int capacity;
+    void **elements;
+} stack_t;
+
+stack_t *stack_alloc(size_t elem_size, void(*free_func)(void*));
+void stack_push(stack_t *stack, void *element);
+void *stack_peek(stack_t *stack);
+void stack_pop(stack_t *stack);
+void stack_free(stack_t *stack);
+
+#endif

data/ext/readapt/threads.c

@@ -1,15 +1,23 @@
 #include "ruby.h"
 #include "ruby/debug.h"
 #include "threads.h"
+#include "frame.h"
+#include "inspector.h"
 
+static VALUE c_Thread;
 static VALUE threads;
 
-void thread_reference_free(void* data)
+static void thread_reference_free(void* data)
 {
-	free(data);
+	thread_reference_t* thr;
+
+	thr = data;
+	// stack_free(thr->calls);
+	stack_free(thr->frames);
+	free(thr);
 }
 
-size_t thread_reference_size(const void* data)
+static size_t thread_reference_size(const void* data)
 {
 	return sizeof(thread_reference_t);
 }
@@ -25,20 +33,16 @@ static const rb_data_type_t thread_reference_type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-void initialize_threads()
-{
-	threads = rb_hash_new();
-	rb_global_variable(&threads);
-}
-
-VALUE thread_reference_new(VALUE thr)
+static VALUE thread_reference_new(VALUE thr)
 {
 	thread_reference_t *data = malloc(sizeof(thread_reference_t));
-	VALUE obj = TypedData_Make_Struct(rb_cData, thread_reference_t, &thread_reference_type, data);
+	VALUE obj = TypedData_Make_Struct(c_Thread, thread_reference_t, &thread_reference_type, data);
 	data->id = NUM2LONG(rb_funcall(thr, rb_intern("object_id"), 0));
-	data->depth = 0;
 	data->cursor = 0;
+	data->depth = 0;
 	data->control = rb_intern("continue");
+	data->frames = stack_alloc(sizeof(frame_t), frame_free);
+	// data->calls = stack_alloc(sizeof(frame_t), NULL);
 	return obj;
 }
 
@@ -75,8 +79,7 @@ VALUE thread_add_reference(VALUE thr)
 
 VALUE thread_delete_reference(VALUE thr)
 {
-	rb_hash_delete(threads, thr);
-	return Qnil;
+	return rb_hash_delete(threads, rb_obj_id(thr));
 }
 
 void thread_pause()
@@ -95,7 +98,94 @@ void thread_pause()
 	}
 }
 
-void thread_reset()
+void thread_clear()
 {
 	rb_funcall(threads, rb_intern("clear"), 0);
 }
+
+static VALUE thread_allocate_s(VALUE self)
+{
+	thread_reference_t *data = malloc(sizeof(thread_reference_t));
+	data->control = rb_intern("continue");
+	data->depth = 0;
+	data->cursor = 0;
+	data->frames = stack_alloc(sizeof(frame_t), frame_free);
+	// data->calls = stack_alloc(sizeof(frame_t), NULL);
+	data->id = 0;
+	return TypedData_Wrap_Struct(self, &thread_reference_type, data);
+}
+
+static VALUE thread_all_s(VALUE self)
+{
+	return rb_funcall(threads, rb_intern("values"), 0);
+}
+
+static VALUE thread_find_s(VALUE self, VALUE id)
+{
+	return thread_reference_id(id);
+}
+
+static VALUE thread_include_s(VALUE self, VALUE id)
+{
+	return rb_funcall(threads, rb_intern("include?"), 1, id);
+}
+
+static VALUE thread_id_m(VALUE self)
+{
+	thread_reference_t *data = thread_reference_pointer(self);
+	return LONG2NUM(data->id);
+}
+
+static VALUE frames_m(VALUE self)
+{
+	thread_reference_t *data;
+	VALUE ary;
+	VALUE frm;
+	int i;
+	frame_t *fd;
+
+	ary = rb_ary_new();
+	data = thread_reference_pointer(self);
+	for (i = data->frames->size - 1; i >= 0; i--)
+	{
+		fd = data->frames->elements[i];
+		// TODO This condition should probably not be necessary.
+		if (fd->binding != Qnil)
+		{
+			frm = frame_new_from_data(fd);
+			rb_ary_push(ary, frm);
+		}
+	}
+
+	return ary;
+}
+
+void thread_reference_build_frames(thread_reference_t *ptr)
+{
+	inspector_inspect(ptr);
+}
+
+void thread_reference_clear_frames(thread_reference_t *ptr)
+{
+	// TODO This is probably suboptimal
+	// while (ptr->frames->size > 0)
+	// {
+	// 	stack_pop(ptr->frames);
+	// }
+	stack_free(ptr->frames);
+	ptr->frames = stack_alloc(sizeof(frame_t), frame_free);
+}
+
+void initialize_threads(VALUE m_Readapt)
+{
+	c_Thread = rb_define_class_under(m_Readapt, "Thread", rb_cData);
+	rb_define_alloc_func(c_Thread, thread_allocate_s);
+	rb_define_method(c_Thread, "id", thread_id_m, 0);
+	rb_define_method(c_Thread, "frames", frames_m, 0);
+	rb_define_singleton_method(c_Thread, "all", thread_all_s, 0);
+	rb_define_singleton_method(c_Thread, "find", thread_find_s, 1);
+	rb_define_singleton_method(c_Thread, "include?", thread_include_s, 1);
+
+	threads = rb_hash_new();
+	rb_global_variable(&threads);
+}

data/ext/readapt/threads.h

@@ -1,21 +1,28 @@
 #ifndef THREADS_H_
 #define THREADS_H_
 
+#include "ruby.h"
+#include "frame.h"
+#include "stack.h"
+
 typedef struct thread_reference_struct {
 	long id;
-	int depth;
 	int cursor;
+	int depth;
 	ID control;
+	stack_t *frames;
 } thread_reference_t;
 
-void initialize_threads();
+void initialize_threads(VALUE);
 VALUE thread_current_reference();
 VALUE thread_reference(VALUE);
 VALUE thread_reference_id(VALUE);
 VALUE thread_add_reference(VALUE);
 VALUE thread_delete_reference(VALUE);
 thread_reference_t *thread_reference_pointer(VALUE);
+void thread_reference_build_frames(thread_reference_t *);
+void thread_reference_clear_frames(thread_reference_t *);
 void thread_pause();
-void thread_reset();
+void thread_clear();
 
 #endif

data/lib/readapt.rb

@@ -1,8 +1,8 @@
 require 'backport'
 
 require 'readapt/version'
+require 'readapt/readapt'
 require 'readapt/breakpoint'
-require 'readapt/location'
 require 'readapt/thread'
 require 'readapt/frame'
 require 'readapt/monitor'
@@ -12,7 +12,6 @@ require 'readapt/debugger'
 require 'readapt/message'
 require 'readapt/variable'
 require 'readapt/adapter'
-require 'readapt/readapt'
 require 'readapt/shell'
 
 module Readapt

data/lib/readapt/adapter.rb

@@ -69,9 +69,9 @@ module Readapt
         envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
         write envelope
       end
-    rescue Exception => e
-      STDERR.puts e.message
-      STDERR.puts e.backtrace
+    rescue RuntimeError => e
+      STDERR.puts "[#{e.class}] #{e.message}"
+      STDERR.puts e.backtrace.join
     end
   end
 

data/lib/readapt/breakpoint.rb

@@ -3,11 +3,18 @@ module Readapt
     attr_reader :source
     attr_reader :line
     attr_reader :condition
+    attr_reader :hit_condition
+    attr_writer :hit_cursor
 
-    def initialize source, line, condition
+    def initialize source, line, condition, hit_condition
       @source = source
       @line = line
       @condition = condition
+      @hit_condition = hit_condition
+    end
+
+    def hit_cursor
+      @hit_cursor ||= 0
     end
   end
 end

data/lib/readapt/debugger.rb

@@ -15,7 +15,6 @@ module Readapt
 
     def initialize machine = Machine.new
       @stack = []
-      @threads = {}
       @frames = {}
       @running = false
       @attached = false
@@ -37,11 +36,11 @@ module Readapt
 
     # @return [Readapt::Thread]
     def thread id
-      @threads[id] || Thread::NULL_THREAD
+      Thread.find(id)
     end
 
     def threads
-      @threads.values
+      Thread.all
     end
 
     def frame id
@@ -74,7 +73,7 @@ module Readapt
       end
       yield if block_given?
     rescue StandardError => e
-      STDERR.puts e.message
+      STDERR.puts "[#{e.class}] #{e.message}"
       STDERR.puts e.backtrace.join("\n")
     rescue SystemExit
       # Ignore
@@ -82,6 +81,8 @@ module Readapt
       Monitor.stop
       @running = false
       set_original_args
+      STDOUT.flush
+      STDERR.flush
       changed
       send_event 'terminated', nil
     end
@@ -94,11 +95,11 @@ module Readapt
     end
 
     def get_breakpoint source, line
-      @breakpoints["#{source}:#{line}"] || Breakpoint.new(source, line, nil)
+      @breakpoints["#{source}:#{line}"] || Breakpoint.new(source, line, nil, 0)
     end
 
-    def set_breakpoint source, line, condition
-      @breakpoints["#{source}:#{line}"] = Breakpoint.new(source, line, condition)
+    def set_breakpoint source, line, condition, hitcount
+      @breakpoints["#{source}:#{line}"] = Breakpoint.new(source, line, condition, hitcount)
     end
 
     def clear_breakpoints source
@@ -121,9 +122,9 @@ module Readapt
     # @param [Snapshot]
     # return [void]
     def debug snapshot
+      sleep 0.001 # @todo Trying to let thread data sync
       if snapshot.event == :thread_begin || snapshot.event == :entry
-        @threads[snapshot.thread_id] ||= Thread.new(snapshot.thread_id)
-        thr = @threads[snapshot.thread_id]
+        thr = Thread.find(snapshot.thread_id)
         thr.control = :continue
         send_event('thread', {
           reason: 'started',
@@ -133,47 +134,66 @@ module Readapt
       elsif snapshot.event == :thread_end
         thr = thread(snapshot.thread_id)
         thr.control = :continue
-        @threads.delete snapshot.thread_id
+        # @threads.delete snapshot.thread_id
         send_event('thread', {
           reason: 'exited',
           threadId: snapshot.thread_id
         })
         snapshot.control = :continue
-      # elsif snapshot.event == :entry
-      #   snapshot.control = :continue
       else
+        confirmed_pause = true
+        thread = self.thread(snapshot.thread_id)
         if snapshot.event == :breakpoint
           bp = get_breakpoint(snapshot.file, snapshot.line)
           unless bp.condition.nil? || bp.condition.empty?
             # @type [Binding]
-            bnd = ObjectSpace._id2ref(snapshot.binding_id)
+            bnd = thread.frames.first.frame_binding
             begin
               unless bnd.eval(bp.condition)
-                snapshot.control = :continue
-                return
+                confirmed_pause = false
               end
             rescue Exception => e
               STDERR.puts "Breakpoint condition raised an error"
               STDERR.puts "#{snapshot.file}:#{snapshot.line} - `#{bp.condition}`"
               STDERR.puts "[#{e.class}] #{e.message}"
-              snapshot.control = :continue
-              return
+              confirmed_pause = false
+            end
+          end
+          unless !confirmed_pause || bp.hit_condition.nil? || bp.hit_condition.empty?
+            bp.hit_cursor += 1
+            bnd = thread.frames.first.frame_binding
+            begin
+              hit_count = bnd.eval(bp.hit_condition)
+              if bp.hit_cursor == hit_count
+                bp.hit_cursor = 0
+              else
+                confirmed_pause = false
+              end
+            rescue Exception => e
+              STDERR.puts "Breakpoint condition raised an error"
+              STDERR.puts "#{snapshot.file}:#{snapshot.line} - `#{bp.condition}`"
+              STDERR.puts "[#{e.class}] #{e.message}"
+              confirmed_pause = false
             end
           end
         end
-        changed
-        thread = self.thread(snapshot.thread_id)
-        thread.control = :pause
-        frame = Frame.new(Location.new(snapshot.file, snapshot.line), snapshot.binding_id)
-        thread.frames.push frame
-        @frames[frame.local_id] = frame
-        send_event('stopped', {
-          reason: snapshot.event,
-          threadId: ::Thread.current.object_id
-        })
-        sleep 0.01 until thread.control != :pause || !@threads.key?(thread.id)
-        @frames.delete frame.local_id
-        thread.frames.delete frame
+        if confirmed_pause
+          changed
+          thread.control = :pause
+          thread.frames.each do |frm|
+            @frames[frm.local_id] = frm
+          end
+          send_event('stopped', {
+            reason: snapshot.event,
+            threadId: thread.id
+          })
+          sleep 0.01 until thread.control != :pause || !Thread.include?(thread.id)
+          thread.frames.each do |frm|
+            @frames.delete frm.local_id
+          end
+        else
+          thread.control = :continue
+        end
         snapshot.control = thread.control
       end
     end