readapt 0.7.1 → 1.1.1

data/ext/readapt/breakpoints.h

@@ -1,12 +1,11 @@
-#ifndef BREAKPOINTS_H_
-#define BREAKPOINTS_H_
-
-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
+#ifndef BREAKPOINTS_H_
+#define BREAKPOINTS_H_
+
+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);
+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

@@ -1,212 +1,211 @@
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "hash_table.h"
-#include "ruby.h"
-
-static ht_long_array *copy_array(const long *value, const long size)
-{
-    long i;
-    long *items = malloc(sizeof(long) * size);
-    ht_long_array *result;
-
-    for (i = 0; i < size; i++)
-    {
-        items[i] = value[i];
-    }
-    result = malloc(sizeof(ht_long_array));
-    result->items = (size ? items : NULL);
-    result->size = size;
-    return result;
-}
-
-/*
- * Initialize a new item
- */
-static ht_item *ht_new_item(char *key, const long *value, const long size)
-{
-    ht_item *i = malloc(sizeof(ht_item));
-    i->key = malloc(sizeof(char) * (strlen(key) + 1));
-    strcpy(i->key, key);
-    i->value = copy_array(value, size);
-    return i;
-}
-
-/*
- * Delete the ht_item
- */
-static void ht_del_item(ht_item *i)
-{
-    free(i->key);
-    free(i->value->items);
-    free(i);
-}
-
-/*
- * Initialize a new empty hash table
- */
-ht_hash_table *ht_new()
-{
-    ht_hash_table *ht = malloc(sizeof(ht_hash_table));
-    ht->items = NULL;
-    ht->size = 0;
-    return ht;
-}
-
-/*
- * Delete the hash table
- */
-void ht_del_hash_table(ht_hash_table *ht)
-{
-    int i;
-    ht_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);
-    }
-    free(ht->items);
-    free(ht);
-}
-
-static ht_long_array *ht_search_part(ht_hash_table *ht, char *key, long cursor, long next)
-{
-    int cmp;
-
-    if (cursor >= ht->size)
-    {
-        return NULL;
-    }
-
-    cmp = strcmp(ht->items[cursor]->key, key);
-    if (cmp == 0)
-    {
-        return ht->items[cursor]->value;
-    }
-    if (next > cursor && next < ht->size)
-    {
-        cmp = strcmp(ht->items[next]->key, key);
-        if (cmp == 0)
-        {
-            return ht->items[next]->value;
-        }
-        else if (cmp < 0)
-        {
-            return ht_search_part(ht, key, next + 1, next + ((ht->size - next) / 2));
-        }
-        else
-        {
-            return ht_search_part(ht, key, cursor + 1, next / 2);
-        }
-    }
-    return ht_search_part(ht, key, cursor + 1, next / 2);
-}
-
-static ht_long_array *ht_search_key(ht_hash_table *ht, char *key)
-{
-    return ht_search_part(ht, key, 0, ht->size / 2);
-}
-
-static void ht_delete_key(ht_hash_table *ht, char *key)
-{
-    ht_long_array *found;
-    ht_item **tmp;
-    long i;
-    long cursor = 0;
-
-    found = ht_search_key(ht, key);
-    if (found)
-    {
-        tmp = malloc(sizeof(ht_item) * (ht->size - 1));
-        for (i = 0; i < ht->size; i++)
-        {
-            if (ht->items[i]->key == key)
-            {
-                ht_del_item(ht->items[i]);
-            }
-            else
-            {
-                tmp[cursor] = ht->items[cursor];
-                cursor++;
-            }
-        }
-        free(ht->items);
-        ht->items = tmp;
-        ht->size--;
-    }
-}
-
-static void ht_insert_key(ht_hash_table *ht, char *key, const long *value, const long size)
-{
-    ht_item *item;
-    ht_item **tmp;
-    long i;
-    long cursor = 0;
-    int inserted = 0;
-    int cmp;
-
-    ht_delete_key(ht, key);
-
-    if (size == 0)
-    {
-        return;
-    }
-
-    item = ht_new_item(key, value, size);
-    tmp = malloc(sizeof(ht_item) * (ht->size + 1));
-
-    for (i = 0; i < ht->size; i++)
-    {
-        if (!inserted)
-        {
-            cmp = strcmp(item->key, ht->items[i]->key);
-            if (cmp > 0)
-            {
-                tmp[cursor] = item;
-                cursor++;
-                inserted = 1;
-            }
-            tmp[cursor] = ht->items[i];
-            cursor++;
-        }
-        else
-        {
-            tmp[cursor] = ht->items[i];
-            cursor++;
-        }
-    }
-    if (!inserted)
-    {
-        tmp[ht->size] = item;
-    }
-    free(ht->items);
-    ht->items = tmp;
-    ht->size++;
-}
-
-/*
- * Add an item to the hash table
- */
-void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size)
-{
-    ht_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)
-{
-    return ht_search_key(ht, key);
-}
-
-/*
- * Delete the key's item if it exists
- */
-void ht_delete(ht_hash_table *ht, char *key)
-{
-    ht_delete_key(ht, key);
-}
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "hash_table.h"
+
+static ht_long_array *copy_array(const long *value, const long size)
+{
+    long i;
+    long *items = malloc(sizeof(long) * size);
+    ht_long_array *result;
+
+    for (i = 0; i < size; i++)
+    {
+        items[i] = value[i];
+    }
+    result = malloc(sizeof(ht_long_array));
+    result->items = (size ? items : NULL);
+    result->size = size;
+    return result;
+}
+
+/*
+ * Initialize a new item
+ */
+static ht_item *ht_new_item(char *key, const long *value, const long size)
+{
+    ht_item *i = malloc(sizeof(ht_item));
+    i->key = malloc(sizeof(char) * (strlen(key) + 1));
+    strcpy(i->key, key);
+    i->value = copy_array(value, size);
+    return i;
+}
+
+/*
+ * Delete the ht_item
+ */
+static void ht_del_item(ht_item *i)
+{
+    free(i->key);
+    free(i->value->items);
+    free(i);
+}
+
+/*
+ * Initialize a new empty hash table
+ */
+ht_hash_table *ht_new()
+{
+    ht_hash_table *ht = malloc(sizeof(ht_hash_table));
+    ht->items = NULL;
+    ht->size = 0;
+    return ht;
+}
+
+/*
+ * Delete the hash table
+ */
+void ht_del_hash_table(ht_hash_table *ht)
+{
+    int i;
+    ht_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);
+    }
+    free(ht->items);
+    free(ht);
+}
+
+static ht_long_array *ht_search_part(ht_hash_table *ht, char *key, long cursor, long next)
+{
+    int cmp;
+
+    if (cursor >= ht->size)
+    {
+        return NULL;
+    }
+
+    cmp = strcmp(ht->items[cursor]->key, key);
+    if (cmp == 0)
+    {
+        return ht->items[cursor]->value;
+    }
+    if (next > cursor && next < ht->size)
+    {
+        cmp = strcmp(ht->items[next]->key, key);
+        if (cmp == 0)
+        {
+            return ht->items[next]->value;
+        }
+        else if (cmp < 0)
+        {
+            return ht_search_part(ht, key, next + 1, next + ((ht->size - next) / 2));
+        }
+        else
+        {
+            return ht_search_part(ht, key, cursor + 1, next / 2);
+        }
+    }
+    return ht_search_part(ht, key, cursor + 1, next / 2);
+}
+
+static ht_long_array *ht_search_key(ht_hash_table *ht, char *key)
+{
+    return ht_search_part(ht, key, 0, ht->size / 2);
+}
+
+static void ht_delete_key(ht_hash_table *ht, char *key)
+{
+    ht_long_array *found;
+    ht_item **tmp;
+    long i;
+    long cursor = 0;
+
+    found = ht_search_key(ht, key);
+    if (found)
+    {
+        tmp = malloc(sizeof(ht_item) * (ht->size - 1));
+        for (i = 0; i < ht->size; i++)
+        {
+            if (ht->items[i]->key == key)
+            {
+                ht_del_item(ht->items[i]);
+            }
+            else
+            {
+                tmp[cursor] = ht->items[cursor];
+                cursor++;
+            }
+        }
+        free(ht->items);
+        ht->items = tmp;
+        ht->size--;
+    }
+}
+
+static void ht_insert_key(ht_hash_table *ht, char *key, const long *value, const long size)
+{
+    ht_item *item;
+    ht_item **tmp;
+    long i;
+    long cursor = 0;
+    int inserted = 0;
+    int cmp;
+
+    ht_delete_key(ht, key);
+
+    if (size == 0)
+    {
+        return;
+    }
+
+    item = ht_new_item(key, value, size);
+    tmp = malloc(sizeof(ht_item) * (ht->size + 1));
+
+    for (i = 0; i < ht->size; i++)
+    {
+        if (!inserted)
+        {
+            cmp = strcmp(item->key, ht->items[i]->key);
+            if (cmp > 0)
+            {
+                tmp[cursor] = item;
+                cursor++;
+                inserted = 1;
+            }
+            tmp[cursor] = ht->items[i];
+            cursor++;
+        }
+        else
+        {
+            tmp[cursor] = ht->items[i];
+            cursor++;
+        }
+    }
+    if (!inserted)
+    {
+        tmp[ht->size] = item;
+    }
+    free(ht->items);
+    ht->items = tmp;
+    ht->size++;
+}
+
+/*
+ * Add an item to the hash table
+ */
+void ht_insert(ht_hash_table *ht, char *key, const long *value, const long size)
+{
+    ht_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)
+{
+    return ht_search_key(ht, key);
+}
+
+/*
+ * Delete the key's item if it exists
+ */
+void ht_delete(ht_hash_table *ht, char *key)
+{
+    ht_delete_key(ht, key);
+}