readapt 1.4.0 → 1.4.1

data/ext/readapt/lookup_table.h

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

data/ext/readapt/stack.h

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