readapt 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295695183ba788850e623e648d35a63a4c9ecbf43c3c94c1dc927669fd5c2b9f
-  data.tar.gz: ac4e9d7285ba410753e5a20e0043ca4fa805d491c48a3bc02a6337ecec801454
+  metadata.gz: e59a68966e356664acd69d2d4800e4052ca1573ad28ccc5b754d299541f6673b
+  data.tar.gz: 443c6a7c9a099e60471fb2858868d21a5a320b8e9a52abf4823efb10c810f841
 SHA512:
-  metadata.gz: eea4ad41e690bc2f3ee820dde72da7555d8d856a722f3607a8defe35fb134128ca3af70a3711d9cd8db77a074d54003631b6946f533687cd2523af4b67bd1847
-  data.tar.gz: 83801884e0a1a8f043920ced5938c5095cb0a98c10c9e9cb4fa530600a67024a7aa5d443ea5499d11c194b438b5126bc4571793565b8d675cbe8dfe657d46d73
+  metadata.gz: 71f2043df9c0b0e8e07d83597dcdc88a5025b022e642225ec2b3e908a19004028606ef7d8aae91cba9865b36549f77e127e04e19e1f47127626398d9f02dca12
+  data.tar.gz: b2773a63a86505811cb71fe1da7490984a033283c0fa0cc91c20e1dd126ad4a515a9a33f45525b5a2024ebfb6af4d5acb98e9869736c03c9cada8bea5ec68dfb

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.2.0 - February 24, 2021
+- Pause on exceptions
+- Refactored lookup tables
+
 # 1.1.1 - December 15, 2020
 - Update rake
 - Fix Encoding::UndefinedConversionError (#8)

data/ext/readapt/breakpoints.c

@@ -1,8 +1,8 @@
 #include "ruby.h"
-#include "hash_table.h"
+#include "lookup_table.h"
 
 static VALUE m_Breakpoints;
-ht_hash_table *ht;
+lt_lookup_table *ht;
 
 void breakpoints_set(char *file, long *lines)
 {
@@ -20,7 +20,7 @@ static VALUE breakpoints_set_s(VALUE self, VALUE file, VALUE lines)
     {
         ll[i] = NUM2LONG(rb_ary_entry(lines, i));
     }
-    ht_insert(ht, StringValueCStr(file), ll, length);
+    lt_insert(ht, StringValueCStr(file), ll, length);
     free(ll);
     return Qnil;
 }
@@ -37,10 +37,10 @@ static VALUE breakpoints_delete_s(VALUE self, VALUE file)
 
 int breakpoints_match(char *file, long line)
 {
-    ht_long_array *lines;
+    lt_long_array *lines;
     long i;
 
-    lines = ht_search(ht, file);
+    lines = lt_search(ht, file);
     if (lines != NULL)
     {
         for (i = 0; i < lines->size; i++)
@@ -61,8 +61,8 @@ static VALUE breakpoints_match_s(VALUE self, VALUE file, VALUE line)
 
 static VALUE breakpoints_clear_s(VALUE self)
 {
-    ht_del_hash_table(ht);
-    ht = ht_new();
+    lt_del_lookup_table(ht);
+    ht = lt_new();
     return Qnil;
 }
 
@@ -79,5 +79,5 @@ void initialize_breakpoints(VALUE m_Readapt)
     rb_define_singleton_method(m_Breakpoints, "match", breakpoints_match_s, 2);
     rb_define_singleton_method(m_Breakpoints, "clear", breakpoints_clear_s, 0);
 
-    ht = ht_new(); // TODO Need to free?
+    ht = lt_new(); // TODO Need to free?
 }

data/ext/readapt/{hash_table.c → lookup_table.c}

@@ -2,19 +2,19 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "hash_table.h"
+#include "lookup_table.h"
 
-static ht_long_array *copy_array(const long *value, const long size)
+static lt_long_array *copy_array(const long *value, const long size)
 {
     long i;
     long *items = malloc(sizeof(long) * size);
-    ht_long_array *result;
+    lt_long_array *result;
 
     for (i = 0; i < size; i++)
     {
         items[i] = value[i];
     }
-    result = malloc(sizeof(ht_long_array));
+    result = malloc(sizeof(lt_long_array));
     result->items = (size ? items : NULL);
     result->size = size;
     return result;
@@ -23,9 +23,9 @@ static ht_long_array *copy_array(const long *value, const long size)
 /*
  * Initialize a new item
  */
-static ht_item *ht_new_item(char *key, const long *value, const long size)
+static lt_item *lt_new_item(char *key, const long *value, const long size)
 {
-    ht_item *i = malloc(sizeof(ht_item));
+    lt_item *i = malloc(sizeof(lt_item));
     i->key = malloc(sizeof(char) * (strlen(key) + 1));
     strcpy(i->key, key);
     i->value = copy_array(value, size);
@@ -33,9 +33,9 @@ static ht_item *ht_new_item(char *key, const long *value, const long size)
 }
 
 /*
- * Delete the ht_item
+ * Delete the lt_item
  */
-static void ht_del_item(ht_item *i)
+static void lt_del_item(lt_item *i)
 {
     free(i->key);
     free(i->value->items);
@@ -43,35 +43,35 @@ static void ht_del_item(ht_item *i)
 }
 
 /*
- * Initialize a new empty hash table
+ * Initialize a new empty lookup table
  */
-ht_hash_table *ht_new()
+lt_lookup_table *lt_new()
 {
-    ht_hash_table *ht = malloc(sizeof(ht_hash_table));
+    lt_lookup_table *ht = malloc(sizeof(lt_lookup_table));
     ht->items = NULL;
     ht->size = 0;
     return ht;
 }
 
 /*
- * Delete the hash table
+ * Delete the lookup table
  */
-void ht_del_hash_table(ht_hash_table *ht)
+void lt_del_lookup_table(lt_lookup_table *ht)
 {
     int i;
-    ht_item *item;
+    lt_item *item;
 
     // Iterate through items and delete any that are found
     for (i = 0; i < ht->size; i++)
     {
         item = ht->items[i];
-        ht_del_item(item);
+        lt_del_item(item);
     }
     free(ht->items);
     free(ht);
 }
 
-static ht_long_array *ht_search_part(ht_hash_table *ht, char *key, long cursor, long next)
+static lt_long_array *lt_search_part(lt_lookup_table *ht, char *key, long cursor, long next)
 {
     int cmp;
 
@@ -94,37 +94,37 @@ static ht_long_array *ht_search_part(ht_hash_table *ht, char *key, long cursor,
         }
         else if (cmp < 0)
         {
-            return ht_search_part(ht, key, next + 1, next + ((ht->size - next) / 2));
+            return lt_search_part(ht, key, next + 1, next + ((ht->size - next) / 2));
         }
         else
         {
-            return ht_search_part(ht, key, cursor + 1, next / 2);
+            return lt_search_part(ht, key, cursor + 1, next / 2);
         }
     }
-    return ht_search_part(ht, key, cursor + 1, next / 2);
+    return lt_search_part(ht, key, cursor + 1, next / 2);
 }
 
-static ht_long_array *ht_search_key(ht_hash_table *ht, char *key)
+static lt_long_array *lt_search_key(lt_lookup_table *ht, char *key)
 {
-    return ht_search_part(ht, key, 0, ht->size / 2);
+    return lt_search_part(ht, key, 0, ht->size / 2);
 }
 
-static void ht_delete_key(ht_hash_table *ht, char *key)
+static void lt_delete_key(lt_lookup_table *ht, char *key)
 {
-    ht_long_array *found;
-    ht_item **tmp;
+    lt_long_array *found;
+    lt_item **tmp;
     long i;
     long cursor = 0;
 
-    found = ht_search_key(ht, key);
+    found = lt_search_key(ht, key);
     if (found)
     {
-        tmp = malloc(sizeof(ht_item) * (ht->size - 1));
+        tmp = malloc(sizeof(lt_item) * (ht->size - 1));
         for (i = 0; i < ht->size; i++)
         {
             if (ht->items[i]->key == key)
             {
-                ht_del_item(ht->items[i]);
+                lt_del_item(ht->items[i]);
             }
             else
             {
@@ -138,24 +138,24 @@ static void ht_delete_key(ht_hash_table *ht, char *key)
     }
 }
 
-static void ht_insert_key(ht_hash_table *ht, char *key, const long *value, const long size)
+static void lt_insert_key(lt_lookup_table *ht, char *key, const long *value, const long size)
 {
-    ht_item *item;
-    ht_item **tmp;
+    lt_item *item;
+    lt_item **tmp;
     long i;
     long cursor = 0;
     int inserted = 0;
     int cmp;
 
-    ht_delete_key(ht, key);
+    lt_delete_key(ht, key);
 
     if (size == 0)
     {
         return;
     }
 
-    item = ht_new_item(key, value, size);
-    tmp = malloc(sizeof(ht_item) * (ht->size + 1));
+    item = lt_new_item(key, value, size);
+    tmp = malloc(sizeof(lt_item) * (ht->size + 1));
 
     for (i = 0; i < ht->size; i++)
     {
@@ -187,25 +187,25 @@ static void ht_insert_key(ht_hash_table *ht, char *key, const long *value, const
 }
 
 /*
- * Add an item to the hash table
+ * Add an item to the lookup table
  */
-void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size)
+void lt_insert(lt_lookup_table *ht, char *key, const long *value, const long size)
 {
-    ht_insert_key(ht, key, value, size);
+    lt_insert_key(ht, key, value, size);
 }
 
 /*
  * Get the key's value or NULL if it doesn't exist
  */
-ht_long_array *ht_search(ht_hash_table *ht, char *key)
+lt_long_array *lt_search(lt_lookup_table *ht, char *key)
 {
-    return ht_search_key(ht, key);
+    return lt_search_key(ht, key);
 }
 
 /*
  * Delete the key's item if it exists
  */
-void ht_delete(ht_hash_table *ht, char *key)
+void lt_delete(lt_lookup_table *ht, char *key)
 {
-    ht_delete_key(ht, key);
+    lt_delete_key(ht, key);
 }

data/ext/readapt/lookup_table.h

@@ -0,0 +1,30 @@
+#ifndef LOOKUP_TABLE_H_
+#define LOOKUP_TABLE_H_
+
+typedef struct lt_long_array
+{
+    long *items;
+    long size;
+} lt_long_array;
+
+// lt_item is an item in the lookup table
+typedef struct lt_item
+{
+    char *key;
+    lt_long_array *value;
+} lt_item;
+
+typedef struct lt_lookup_table
+{
+    long size;
+    lt_item **items;
+} lt_lookup_table;
+
+lt_lookup_table *lt_new();
+void lt_del_lookup_table(lt_lookup_table *ht);
+
+void lt_insert(lt_lookup_table *ht, char *key, const long *value, const long size);
+lt_long_array *lt_search(lt_lookup_table *ht, char *key);
+void lt_delete(lt_lookup_table *h, char *key);
+
+#endif // LOOKUP_TABLE_H_

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;
@@ -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/lib/readapt/breakpoint.rb

@@ -13,6 +13,7 @@ module Readapt
       @hit_condition = hit_condition
     end
 
+    # @return [Integer]
     def hit_cursor
       @hit_cursor ||= 0
     end

data/lib/readapt/finder.rb

@@ -1,14 +1,28 @@
 require 'pathname'
 
 module Readapt
+  # Methods to find a program in the current directory or one of the
+  # environment paths.
+  #
   module Finder
     module_function
 
+    # Get the program's fully qualified path. Search first in the current
+    # directory, then the environment paths.
+    #
+    # @raise [LoadError] if the program was not found
+    #
+    # @param program [String] The name of the program
+    # @return [String] The fully qualified path
     def find program
       return program if File.exist?(program)
       which(program) || raise(LoadError, "#{program} is not a valid Ruby file or program")
     end
 
+    # Search the environment paths for the given program.
+    #
+    # @param program [String] The name of the program
+    # @return [String] The fully qualified path, or nil if it was not found
     def which program
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
         exe = File.join(path, program)

data/lib/readapt/thread.rb

@@ -9,6 +9,7 @@ module Readapt
     # @return [Symbol]
     attr_accessor :control
 
+    # @return [String]
     def name
       @name ||= begin
         @@next_id += 1
@@ -16,6 +17,7 @@ module Readapt
       end
     end
 
+    # @return [Object]
     def object
       ObjectSpace._id2ref(id)
     end

data/lib/readapt/version.rb

@@ -1,3 +1,3 @@
 module Readapt
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: readapt
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Fred Snyder
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-15 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -121,10 +121,10 @@ files:
 - ext/readapt/extconf.rb
 - ext/readapt/frame.c
 - ext/readapt/frame.h
-- ext/readapt/hash_table.c
-- ext/readapt/hash_table.h
 - ext/readapt/inspector.c
 - ext/readapt/inspector.h
+- ext/readapt/lookup_table.c
+- ext/readapt/lookup_table.h
 - ext/readapt/monitor.c
 - ext/readapt/monitor.h
 - ext/readapt/normalize.c

data/ext/readapt/hash_table.h

@@ -1,30 +0,0 @@
-#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_