readapt 1.0.0 → 1.1.0

data/ext/readapt/hash_table.h

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

@@ -1,51 +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);
-}
+#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

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

data/ext/readapt/monitor.c

@@ -52,7 +52,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)

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.
- */
-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);
-}
+#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);
+}