sdsykes-ferret 0.11.6.19

data/ext/hashset.c

@@ -0,0 +1,170 @@
+#include "hashset.h"
+#include <string.h>
+
+/*
+ * The HashSet contains an array +elems+ of the elements that have been added.
+ * It always has +size+ elements so +size+ ane +elems+ can be used to iterate
+ * over all alements in the HashSet. It also uses a HashTable to keep track of
+ * which elements have been added and their index in the +elems+ array.
+ */
+static HashSet *hs_alloc(void (*free_elem) (void *p))
+{
+    HashSet *hs = ALLOC(HashSet);
+    hs->size = 0;
+    hs->capa = HS_MIN_SIZE;
+    hs->elems = ALLOC_N(void *, HS_MIN_SIZE);
+    hs->free_elem_i = free_elem ? free_elem : &dummy_free;
+    return hs;
+}
+
+HashSet *hs_new(unsigned long (*hash)(const void *p),
+                int (*eq)(const void *p1, const void *p2),
+                void (*free_elem)(void *p))
+{
+    HashSet *hs = hs_alloc(free_elem);
+    hs->ht = h_new(hash, eq, NULL, &free);
+    return hs;
+}
+
+HashSet *hs_new_str(void (*free_elem) (void *p))
+{
+    HashSet *hs = hs_alloc(free_elem);
+    hs->ht = h_new_str((free_ft) NULL, &free);
+    return hs;
+}
+
+void hs_free(HashSet *hs)
+{
+    h_destroy(hs->ht);
+    free(hs->elems);
+    free(hs);
+}
+
+void hs_clear(HashSet *hs)
+{
+    int i;
+    for (i = hs->size - 1; i >= 0; i--) {
+        hs_del(hs, hs->elems[i]);
+    }
+}
+
+void hs_destroy(HashSet *hs)
+{
+    int i;
+    if (hs->free_elem_i != &dummy_free) {
+        for (i = 0; i < hs->size; i++) {
+            hs->free_elem_i(hs->elems[i]);
+        }
+    }
+    h_destroy(hs->ht);
+    free(hs->elems);
+    free(hs);
+}
+
+int hs_add(HashSet *hs, void *elem)
+{
+    int has_elem = h_has_key(hs->ht, elem);
+    if (has_elem == HASH_KEY_EQUAL) {
+        /* We don't want to keep two of the same elem so free if necessary */
+        hs->free_elem_i(elem);
+    }
+    else if (has_elem == HASH_KEY_SAME) {
+        /* No need to do anything */
+    }
+    else {
+        /* add the elem to the array, resizing if necessary */
+        if (hs->size >= hs->capa) {
+            hs->capa *= 2;
+            REALLOC_N(hs->elems, void *, hs->capa);
+        }
+        hs->elems[hs->size] = elem;
+        h_set(hs->ht, elem, imalloc(hs->size));
+        hs->size++;
+    }
+    return has_elem;
+}
+
+int hs_add_safe(HashSet *hs, void *elem)
+{
+    int has_elem = h_has_key(hs->ht, elem);
+    if (has_elem == HASH_KEY_EQUAL) {
+        /* element can't be added */
+        return false;
+    }
+    else if (has_elem == HASH_KEY_SAME) {
+        /* the exact same element has already been added */
+        return true;
+    }
+    else {
+        /* add the elem to the array, resizing if necessary */
+        if (hs->size >= hs->capa) {
+            hs->capa *= 2;
+            REALLOC_N(hs->elems, void *, hs->capa);
+        }
+        hs->elems[hs->size] = elem;
+        h_set(hs->ht, elem, imalloc(hs->size));
+        hs->size++;
+        return true;
+    }
+}
+
+int hs_del(HashSet *hs, void *elem)
+{
+    void *tmp_elem = hs_rem(hs, elem);
+    if (tmp_elem != NULL) {
+        hs->free_elem_i(tmp_elem);
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+void *hs_rem(HashSet *hs, void *elem)
+{
+    void *ret_elem;
+    int *index = (int *)h_get(hs->ht, elem);
+    if (index == NULL) {
+        return NULL;
+    }
+    else {
+        int i = *index;
+        int j;
+        ret_elem = hs->elems[i];
+        h_del(hs->ht, elem);
+        hs->size--;
+        for (j = i; j < hs->size; j++) {
+            hs->elems[j] = hs->elems[j+1];
+            h_set(hs->ht, hs->elems[j], imalloc(j));
+        }
+        return ret_elem;
+    }
+}
+
+int hs_exists(HashSet *hs, void *elem)
+{
+    return h_has_key(hs->ht, elem);
+}
+
+HashSet *hs_merge(HashSet *hs, HashSet * other)
+{
+    int i;
+    for (i = 0; i < other->size; i++) {
+        hs_add(hs, other->elems[i]);
+    }
+    /* Now free the other hashset. It is no longer needed. No need, however, to
+     * delete the elements as they're either destroyed or in the new hash set */
+    hs_free(other);
+    return hs;
+}
+
+void *hs_orig(HashSet *hs, void *elem)
+{
+    int *index = h_get(hs->ht, elem);
+    if (index) {
+        return hs->elems[*index];
+    }
+    else {
+        return NULL;
+    }
+}

data/ext/hashset.h

@@ -0,0 +1,187 @@
+#ifndef FRT_HASHSET_H
+#define FRT_HASHSET_H
+
+#include "hash.h"
+#include "global.h"
+
+#define HS_MIN_SIZE 4
+
+typedef struct HashSet
+{
+    /* used internally to allocate space to elems */
+    int capa;
+
+    /* the number of elements in the HashSet */
+    int size;
+
+    /* the elements in the HashSet. The elements will be found in the order
+     * they were added and can be iterated over from 0 to .size */ 
+    void **elems;
+
+    /* HashTable used internally */
+    HashTable *ht;
+
+    /* Internal: Frees elements added to the HashSet. Should never be NULL */
+    void (*free_elem_i)(void *p);
+} HashSet;
+
+/**
+ * Create a new HashSet. The function will allocate a HashSet Struct setting
+ * the functions used to hash the objects it will contain and the eq function.
+ * This should be used for non-string types.
+ *
+ * @param hash function to hash objects added to the HashSet
+ * @param eq function to determine whether two items are equal
+ * @param free_elem function used to free elements as added to the HashSet
+ *   when the HashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated HashSet structure
+ */
+extern HashSet *hs_new(unsigned long (*hash)(const void *p),
+                       int (*eq)(const void *p1, const void *p2),
+                       void (*free_elem)(void *p));
+
+/**
+ * Create a new HashSet specifically for strings. This will create a HashSet
+ * as if you used hs_new with the standard string hash and eq functions.
+ *
+ * @param free_elem function used to free elements as added to the HashSet
+ *   when the HashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated HashSet structure
+ */
+extern HashSet *hs_new_str(void (*free_elem) (void *p));
+
+/**
+ * Free the memory allocated by the HashSet, but don't free the elements added
+ * to the HashSet. If you'd like to free everything in the HashSet you should
+ * use hs_destroy
+ *
+ * @param hs the HashSet to free
+ */
+extern void hs_free(HashSet *self);
+
+/**
+ * Destroy the HashSet including all elements added to the HashSet. If you'd
+ * like to free the memory allocated to the HashSet without touching the
+ * elements in the HashSet then use hs_free
+ *
+ * @param hs the HashSet to destroy
+ */
+extern void hs_destroy(HashSet *self);
+
+/**
+ * WARNING: this function may destroy some elements if you add them to a
+ * HashSet were equivalent elements already exist, depending on how free_elem
+ * was set.
+ *
+ * Add the element to the HashSet whether or not it was already in the
+ * HashSet.
+ *
+ * When a element is added to the HashTable where it already exists, free_elem
+ * is called on it, ie the element you tried to add might get destroyed.
+ *
+ * @param hs the HashSet to add the element to
+ * @param elem the element to add to the HashSet
+ * @return one of three values;
+ *   <pre>
+ *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the HashSet.
+ *                              This value is equal to 0 or false
+ *     HASH_KEY_SAME            the element was identical (same memory
+ *                              pointer) to an existing element so no freeing
+ *                              was done
+ *     HASH_KEY_EQUAL           the element was equal to an element already in
+ *                              the HashSet so the new_elem was freed if
+ *                              free_elem was set
+ *   </pre>
+ */
+extern int hs_add(HashSet *self, void *elem);
+
+/**
+ * Add element to the HashSet. If the element already existed in the HashSet
+ * and the new element was equal but not the same (same pointer/memory) then
+ * don't add the element and return false, otherwise return true.
+ *
+ * @param hs the HashSet to add the element to
+ * @param elem the element to add to the HashSet
+ * @return true if the element was successfully added or false otherwise
+ */
+extern int hs_add_safe(HashSet *self, void *elem);
+
+/**
+ * Delete the element from the HashSet. Returns true if the item was
+ * successfully deleted or false if the element never existed.
+ *
+ * @param hs the HashSet to delete from
+ * @param elem the element to delete
+ * @return true if the element was deleted or false if the element never
+ *   existed
+ */
+extern int hs_del(HashSet *self, void *elem);
+
+/**
+ * Remove an item from the HashSet without actually freeing the item. This
+ * function should return the item itself so that it can be freed later if
+ * necessary.
+ *
+ * @param hs the HashSet to remove the element from.
+ * @param elem the element to remove
+ * @param the element that was removed or NULL otherwise
+ */
+extern void *hs_rem(HashSet *self, void *elem);
+
+/**
+ * Check if the element exists and return the appropriate value described
+ * bellow.
+ *
+ * @param hs the HashSet to check in
+ * @param elem the element to check for
+ * @return one of the following values
+ * <pre>
+ *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the HashSet.
+ *                              This value is equal to 0 or false
+ *     HASH_KEY_SAME            the element was identical (same memory
+ *                              pointer) to an existing element so no freeing
+ *                              was done
+ *     HASH_KEY_EQUAL           the element was equal to an element already in
+ *                              the HashSet so the new_elem was freed if
+ *                              free_elem was set
+ *   </pre>
+ */
+extern int hs_exists(HashSet *self, void *elem);
+
+/**
+ * Merge two HashSets. When a merge is done the merger (self) HashTable is
+ * returned and the mergee is destroyed. All elements from mergee that were
+ * not found in merger (self) will be added to self, otherwise they will be
+ * destroyed.
+ * 
+ * @param self the HashSet to merge into
+ * @param other HastSet to be merged into self
+ * @return the merged HashSet
+ */
+extern HashSet *hs_merge(HashSet *self, HashSet *other);
+
+/** 
+ * Return the original version of +elem+. So if you allocate two elements
+ * which are equal and add the first to the HashSet, calling this function
+ * with the second element will return the first element from the HashSet.
+ */
+extern void *hs_orig(HashSet *self, void *elem);
+
+/**
+ * Clear all elements from the HashSet. If free_elem was set then use it to
+ * free all elements as they are cleared. After the method is called, the
+ * HashSets size will be 0.
+ *
+ * @param self the HashSet to clear
+ */
+extern void hs_clear(HashSet *self);
+
+/* TODO: finish these functions.
+int hs_osf(HashSet *hs, void *elem);
+HashSet hs_or(HashSet *hs1, HashSet *h2);
+HashSet hs_excl_or(HashSet *hs1, HashSet *h2);
+HashSet hs_and(HashSet *hs1, HashSet *h2);
+HashSet hs_mask(HashSet *hs1, HashSet *h2);
+*/
+
+#endif

data/ext/header.h

@@ -0,0 +1,58 @@
+
+#include <limits.h>
+
+#include "api.h"
+
+#define MAXINT INT_MAX
+#define MININT INT_MIN
+
+#define HEAD 2*sizeof(int)
+
+#define SIZE(p)        ((int *)(p))[-1]
+#define SET_SIZE(p, n) ((int *)(p))[-1] = n
+#define CAPACITY(p)    ((int *)(p))[-2]
+
+struct among
+{   int s_size;     /* number of chars in string */
+    symbol * s;       /* search string */
+    int substring_i;/* index to longest matching substring */
+    int result;     /* result of the lookup */
+    int (* function)(struct SN_env *);
+};
+
+extern symbol * create_s(void);
+extern void lose_s(symbol * p);
+
+extern int skip_utf8(const symbol * p, int c, int lb, int l, int n);
+
+extern int in_grouping_U(struct SN_env * z, unsigned char * s, int min, int max);
+extern int in_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max);
+extern int out_grouping_U(struct SN_env * z, unsigned char * s, int min, int max);
+extern int out_grouping_b_U(struct SN_env * z, unsigned char * s, int min, int max);
+
+extern int in_grouping(struct SN_env * z, unsigned char * s, int min, int max);
+extern int in_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
+extern int out_grouping(struct SN_env * z, unsigned char * s, int min, int max);
+extern int out_grouping_b(struct SN_env * z, unsigned char * s, int min, int max);
+
+extern int eq_s(struct SN_env * z, int s_size, symbol * s);
+extern int eq_s_b(struct SN_env * z, int s_size, symbol * s);
+extern int eq_v(struct SN_env * z, symbol * p);
+extern int eq_v_b(struct SN_env * z, symbol * p);
+
+extern int find_among(struct SN_env * z, struct among * v, int v_size);
+extern int find_among_b(struct SN_env * z, struct among * v, int v_size);
+
+extern int replace_s(struct SN_env * z, int c_bra, int c_ket, int s_size, const symbol * s, int * adjustment);
+extern int slice_from_s(struct SN_env * z, int s_size, symbol * s);
+extern int slice_from_v(struct SN_env * z, symbol * p);
+extern int slice_del(struct SN_env * z);
+
+extern int insert_s(struct SN_env * z, int bra, int ket, int s_size, symbol * s);
+extern int insert_v(struct SN_env * z, int bra, int ket, symbol * p);
+
+extern symbol * slice_to(struct SN_env * z, symbol * p);
+extern symbol * assign_to(struct SN_env * z, symbol * p);
+
+extern void debug(struct SN_env * z, int number, int line_count);
+

data/ext/helper.c

@@ -0,0 +1,62 @@
+#include "helper.h"
+
+int hlp_string_diff(register const char *const s1,
+                           register const char *const s2)
+{
+    register int i = 0;
+    while (s1[i] && (s1[i] == s2[i])) {
+        i++;
+    }
+    return i;
+}
+
+f_i32 float2int(float f)
+{
+    union { f_i32 i; float f; } tmp;
+    tmp.f = f;
+    return tmp.i;
+}
+
+float int2float(f_i32 i32)
+{
+    union { f_i32 i; float f; } tmp;
+    tmp.i = i32;
+    return tmp.f;
+}
+
+float byte2float(unsigned char b)
+{
+    if (b == 0) {
+        return 0.0;
+    }
+    else {
+        f_u32 mantissa = b & 0x07;
+        f_u32 exponent = (b >> 3) & 0x1f;
+
+        return int2float((mantissa << 21) | ((exponent + 48) << 24));
+    }
+}
+
+unsigned char float2byte(float f)
+{
+    if (f <= 0.0) {
+        return 0;
+    }
+    else {
+        /* correctly order the bytes for encoding */
+        f_u32 i32 = float2int(f);
+        int mantissa = (i32 & 0xEf0000) >> 21;
+        int exponent = ((i32 >> 24) - 48);
+
+        if (exponent > 0x1f) {
+            exponent = 0x1f;   /* 0x1f = 31 = 0b00011111 */
+            mantissa = 0x07;   /* 0x07 =  7 = 0b00000111 */
+        }
+
+        if (exponent < 0) {
+            exponent = 0;
+            mantissa = 1;
+        }
+        return ((exponent<<3) | mantissa);
+    }
+}