jk-ferret 0.11.8.2

data/ext/hashset.c

@@ -0,0 +1,192 @@
+#include "hashset.h"
+#include <string.h>
+#include "internal.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 Hash to keep track of
+ * which elements have been added and their index in the +elems+ array.
+ */
+static HashSet *hs_alloc(free_ft free_func)
+{
+    HashSet *hs = ALLOC(HashSet);
+    hs->size = 0;
+    hs->first = hs->last = NULL;
+    hs->free_elem_i = free_func ? free_func : &dummy_free;
+    return hs;
+}
+
+HashSet *hs_new(hash_ft hash_func, eq_ft eq_func, free_ft free_func)
+{
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new(hash_func, eq_func, NULL, NULL);
+    return hs;
+}
+
+HashSet *hs_new_str(free_ft free_func)
+{
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new_str((free_ft) NULL, NULL);
+    return hs;
+}
+
+HashSet *hs_new_ptr(free_ft free_func)
+{
+    HashSet *hs = hs_alloc(free_func);
+    hs->ht = h_new_ptr(NULL);
+    return hs;
+}
+
+static INLINE void clear(HashSet *hs, bool destroy)
+{
+    HashSetEntry *curr, *next = hs->first;
+    free_ft do_free = destroy ? hs->free_elem_i : &dummy_free;
+    while (NULL != (curr = next)) {
+        next = curr->next;
+        do_free(curr->elem);
+        free(curr);
+    }
+    hs->first = hs->last = NULL;
+    hs->size = 0;
+}
+
+void hs_clear(HashSet *hs)
+{
+    clear(hs, true);
+    h_clear(hs->ht);
+}
+
+void hs_free(HashSet *hs)
+{
+    clear(hs, false);
+    h_destroy(hs->ht);
+    free(hs);
+}
+
+void hs_destroy(HashSet *hs)
+{
+    clear(hs, true);
+    h_destroy(hs->ht);
+    free(hs);
+}
+
+static INLINE void append(HashSet *hs, void *elem)
+{
+    HashSetEntry *entry = ALLOC(HashSetEntry);
+    entry->elem = elem;
+    entry->prev = hs->last;
+    entry->next = NULL;
+    if (!hs->first) {
+        hs->first = hs->last = entry;
+    }
+    else {
+        hs->last->next = entry;
+        hs->last = entry;
+    }
+    h_set(hs->ht, elem, entry);
+    hs->size++;
+}
+
+HashKeyStatus hs_add(HashSet *hs, void *elem)
+{
+    HashKeyStatus has_elem = h_has_key(hs->ht, elem);
+    switch (has_elem)
+    {
+        /* We don't want to keep two of the same elem so free if necessary */
+        case HASH_KEY_EQUAL:
+            hs->free_elem_i(elem);
+            return has_elem;
+
+        /* No need to do anything */
+        case HASH_KEY_SAME:
+            return has_elem;
+
+        /* add the elem to the array, resizing if necessary */
+        case HASH_KEY_DOES_NOT_EXIST:
+            break;
+
+    }
+
+    append(hs, elem);
+    return has_elem;
+}
+
+int hs_add_safe(HashSet *hs, void *elem)
+{
+    switch(h_has_key(hs->ht, elem))
+    {
+        /* element can't be added */
+        case HASH_KEY_EQUAL: return false;
+
+        /* the exact same element has already been added */
+        case HASH_KEY_SAME : return true;
+
+        /* add the elem to the array, resizing if necessary */
+        case HASH_KEY_DOES_NOT_EXIST : break;
+    }
+    append(hs, elem);
+    return true;
+}
+
+void *hs_rem(HashSet *hs, const void *elem)
+{
+    void *return_elem;
+    HashSetEntry *entry = (HashSetEntry *)h_get(hs->ht, elem);
+    if (entry == NULL) return NULL;
+
+    if (hs->first == hs->last) {
+        hs->first = hs->last = NULL;
+    }
+    else if (hs->first == entry) {
+        hs->first = entry->next;
+        hs->first->prev = NULL;
+    }
+    else if (hs->last == entry) {
+        hs->last = entry->prev;
+        hs->last->next = NULL;
+    }
+    else {
+        entry->prev->next = entry->next;
+        entry->next->prev = entry->prev;
+    }
+    return_elem = entry->elem;
+    h_del(hs->ht, return_elem);
+    free(entry);
+    hs->size--;
+    return return_elem;
+}
+
+int hs_del(HashSet *hs, const void *elem)
+{
+    void *tmp_elem = hs_rem(hs, elem);
+    if (tmp_elem != NULL) {
+        hs->free_elem_i(tmp_elem);
+        return 1;
+    }
+    return 0;
+}
+
+HashKeyStatus hs_exists(HashSet *hs, const void *elem)
+{
+    return h_has_key(hs->ht, elem);
+}
+
+HashSet *hs_merge(HashSet *hs, HashSet * other)
+{
+    HashSetEntry *entry = other->first;
+    for (; entry != NULL; entry = entry->next) {
+        hs_add(hs, entry->elem);
+    }
+    /* Now free the other hashset. It is no longer needed. No need, however,
+     * to delete the elements as they were either destroyed or added to the
+     * new hashset.  */
+    hs_free(other);
+    return hs;
+}
+
+void *hs_orig(HashSet *hs, const void *elem)
+{
+    HashSetEntry *entry = (HashSetEntry *)h_get(hs->ht, elem);
+    return entry ? entry->elem : NULL;
+}

data/ext/hashset.h

@@ -0,0 +1,215 @@
+#ifndef FRT_HASHSET_H
+#define FRT_HASHSET_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "hash.h"
+#include "global.h"
+
+#define FRT_HS_MIN_SIZE 4
+typedef struct FrtHashSetEntry {
+    void *elem;
+    struct FrtHashSetEntry *next;
+    struct FrtHashSetEntry *prev;
+} FrtHashSetEntry;
+
+typedef struct FrtHashSet
+{
+    /* the number of elements in the instance */
+    int size;
+
+    /* the first element in the list of elements in the FrtHashSet. The elements
+     * will be listed in the order they were added and can be iterated over by
+     * following the ->next pointer */
+    FrtHashSetEntry *first;
+
+    /* the last element in the list of elements in the FrtHashSet. This is used
+     * internally to add elements to the list. */
+    FrtHashSetEntry *last;
+
+    /* Hash used internally */
+    FrtHash *ht;
+
+    /* Internal: Frees elements added to the FrtHashSet. Should never be NULL */
+    frt_free_ft free_elem_i;
+} FrtHashSet;
+
+/**
+ * Create a new FrtHashSet. The function will allocate a FrtHashSet 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 FrtHashSet
+ * @param eq function to determine whether two items are equal
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new(frt_hash_ft hash_func,
+                                 frt_eq_ft eq_func,
+                                 frt_free_ft free_func);
+
+/**
+ * Create a new FrtHashSet specifically for strings. This will create a
+ * FrtHashSet as if you used frt_hs_new with the standard string hash and eq
+ * functions.
+ *
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new_str(frt_free_ft free_func);
+
+/**
+ * Create a new FrtHashSet specifically for pointers. Note that the only way
+ * two pointers will be considered equal is if they have the same address. So
+ * you can add the string "key" twice if it is stored at two different
+ * addresses.
+ *
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new_ptr(frt_free_ft free_func);
+
+/**
+ * Free the memory allocated by the FrtHashSet, but don't free the elements added
+ * to the FrtHashSet. If you'd like to free everything in the FrtHashSet you should
+ * use frt_hs_destroy
+ *
+ * @param hs the FrtHashSet to free
+ */
+extern void frt_hs_free(FrtHashSet *self);
+
+/**
+ * Destroy the FrtHashSet including all elements added to the FrtHashSet. If you'd
+ * like to free the memory allocated to the FrtHashSet without touching the
+ * elements in the FrtHashSet then use frt_hs_free
+ *
+ * @param hs the FrtHashSet to destroy
+ */
+extern void frt_hs_destroy(FrtHashSet *self);
+
+/**
+ * WARNING: this function may destroy some elements if you add them to a
+ * FrtHashSet were equivalent elements already exist, depending on how free_elem
+ * was set.
+ *
+ * Add the element to the FrtHashSet whether or not it was already in the
+ * FrtHashSet.
+ *
+ * When a element is added to the Hash where it already exists, free_elem
+ * is called on it, ie the element you tried to add might get destroyed.
+ *
+ * @param hs the FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
+ * @return one of three values;
+ *   <pre>
+ *     HASH_KEY_DOES_NOT_EXIST  the element was not already in the FrtHashSet.
+ *                              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 FrtHashSet so the new_elem was freed if
+ *                              free_elem was set
+ *   </pre>
+ */
+extern FrtHashKeyStatus frt_hs_add(FrtHashSet *self, void *elem);
+
+/**
+ * Add element to the FrtHashSet. If the element already existed in the FrtHashSet
+ * 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 FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
+ * @return true if the element was successfully added or false otherwise
+ */
+extern int frt_hs_add_safe(FrtHashSet *self, void *elem);
+
+/**
+ * Delete the element from the FrtHashSet. Returns true if the item was
+ * successfully deleted or false if the element never existed.
+ *
+ * @param hs the FrtHashSet 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 frt_hs_del(FrtHashSet *self, const void *elem);
+
+/**
+ * Remove an item from the FrtHashSet without actually freeing the item. This
+ * function should return the item itself so that it can be freed later if
+ * necessary.
+ *
+ * @param hs the FrtHashSet to remove the element from.
+ * @param elem the element to remove
+ * @param the element that was removed or NULL otherwise
+ */
+extern void *frt_hs_rem(FrtHashSet *self, const void *elem);
+
+/**
+ * Check if the element exists and return the appropriate value described
+ * bellow.
+ *
+ * @param hs the FrtHashSet 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 FrtHashSet.
+ *                              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 FrtHashSet so the new_elem was freed if
+ *                              free_elem was set
+ *   </pre>
+ */
+extern FrtHashKeyStatus frt_hs_exists(FrtHashSet *self, const void *elem);
+
+/**
+ * Merge two HashSets. When a merge is done the merger (self) Hash 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 FrtHashSet to merge into
+ * @param other HastSet to be merged into self
+ * @return the merged FrtHashSet
+ */
+extern FrtHashSet *frt_hs_merge(FrtHashSet *self, FrtHashSet *other);
+
+/**
+ * Return the original version of +elem+. So if you allocate two elements
+ * which are equal and add the first to the FrtHashSet, calling this function
+ * with the second element will return the first element from the FrtHashSet.
+ */
+extern void *frt_hs_orig(FrtHashSet *self, const void *elem);
+
+/**
+ * Clear all elements from the FrtHashSet. 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 FrtHashSet to clear
+ */
+extern void frt_hs_clear(FrtHashSet *self);
+
+/* TODO: finish implementing these functions FrtHashSet
+int hs_osf(FrtHashSet *hs, void *elem);
+FrtHashSet hs_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_excl_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_and(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_mask(FrtHashSet *hs1, FrtHashSet *h2);
+*/
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#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 */
+    const 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, const unsigned char * s, int min, int max, int repeat);
+extern int in_grouping_b_U(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+extern int out_grouping_U(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+extern int out_grouping_b_U(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+
+extern int in_grouping(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+extern int in_grouping_b(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+extern int out_grouping(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+extern int out_grouping_b(struct SN_env * z, const unsigned char * s, int min, int max, int repeat);
+
+extern int eq_s(struct SN_env * z, int s_size, const symbol * s);
+extern int eq_s_b(struct SN_env * z, int s_size, const symbol * s);
+extern int eq_v(struct SN_env * z, const symbol * p);
+extern int eq_v_b(struct SN_env * z, const symbol * p);
+
+extern int find_among(struct SN_env * z, const struct among * v, int v_size);
+extern int find_among_b(struct SN_env * z, const 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, const symbol * s);
+extern int slice_from_v(struct SN_env * z, const 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, const symbol * s);
+extern int insert_v(struct SN_env * z, int bra, int ket, const 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);
+