]> git.xonotic.org Git - xonotic/gmqcc.git/blobdiff - util.c
Rename
[xonotic/gmqcc.git] / util.c
diff --git a/util.c b/util.c
index 4b641a679bd1251d80696b68a6144b64e24e2621..1810adfce16c94d710e063db835d5d15e21cd911 100644 (file)
--- a/util.c
+++ b/util.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
  *     Dale Weiler
  *     Wolfgang Bumiller
  *
@@ -54,20 +54,18 @@ void *util_memory_a(size_t byte, unsigned int line, const char *file) {
         mem_start->prev = info;
     mem_start = info;
 
-    util_debug("MEM", "allocation:   % 8u (bytes) address 0x%08X @ %s:%u\n", byte, data, file, line);
     mem_at++;
     mem_ab += info->byte;
 
     return data;
 }
 
-void util_memory_d(void *ptrn, unsigned int line, const char *file) {
+void util_memory_d(void *ptrn) {
     struct memblock_t *info = NULL;
 
     if (!ptrn) return;
     info = ((struct memblock_t*)ptrn - 1);
 
-    util_debug("MEM", "released:     % 8u (bytes) address 0x%08X @ %s:%u\n", info->byte, ptrn, file, line);
     mem_db += info->byte;
     mem_dt++;
 
@@ -89,18 +87,16 @@ void *util_memory_r(void *ptrn, size_t byte, unsigned int line, const char *file
     if (!ptrn)
         return util_memory_a(byte, line, file);
     if (!byte) {
-        util_memory_d(ptrn, line, file);
+        util_memory_d(ptrn);
         return NULL;
     }
 
     oldinfo = ((struct memblock_t*)ptrn - 1);
     newinfo = ((struct memblock_t*)malloc(sizeof(struct memblock_t) + byte));
 
-    util_debug("MEM", "reallocation: % 8u -> %u (bytes) address 0x%08X -> 0x%08X @ %s:%u\n", oldinfo->byte, byte, ptrn, (void*)(newinfo+1), file, line);
-
     /* new data */
     if (!newinfo) {
-        util_memory_d(oldinfo+1, line, file);
+        util_memory_d(oldinfo+1);
         return NULL;
     }
 
@@ -136,7 +132,7 @@ void *util_memory_r(void *ptrn, size_t byte, unsigned int line, const char *file
 void util_meminfo() {
     struct memblock_t *info;
 
-    if (!opts.memchk)
+    if (!OPTS_OPTION_BOOL(OPTION_MEMCHK))
         return;
 
     for (info = mem_start; info; info = info->next) {
@@ -179,10 +175,10 @@ char *util_strdup(const char *s) {
 
 void util_debug(const char *area, const char *ms, ...) {
     va_list  va;
-    if (!opts.debug)
+    if (!OPTS_OPTION_BOOL(OPTION_DEBUG))
         return;
 
-    if (!strcmp(area, "MEM") && !opts.memchk)
+    if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK))
         return;
 
     va_start(va, ms);
@@ -573,6 +569,146 @@ void util_htdel(hash_table_t *ht) {
     mem_d(ht);
 }
 
+/*
+ * A basic implementation of a hash-set.  Unlike a hashtable, a hash
+ * set doesn't maintain key-value pairs.  It simply maintains a key
+ * that can be set, removed, and checked for.
+ *
+ * See EXPOSED interface comment below 
+ */
+#define GMQCC_HASHSET_PRIME0 0x0049
+#define GMQCC_HASHSET_PRIME1 0x1391
+
+static int util_hsput(hash_set_t *set, void *item) {
+    size_t hash = (size_t)item; /* shouldn't drop the bits */
+    size_t iter;
+
+    /* a == 0 || a == 1 */
+    if (hash >> 1)
+        return -1;
+
+    iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+    /* while (set->items[iter] != 0 && set->items[iter] != 1) */
+    while  (!(set->items[iter] >> 1)) {
+        if (set->items[iter] == hash)
+            return 0;
+
+        iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+    }
+
+    set->total ++;
+    set->items[iter] = hash;
+
+    return 1;
+}
+
+static void util_hsupdate(hash_set_t *set) {
+    size_t *old;
+    size_t  end;
+    size_t  itr;
+
+    /* time to rehash? */
+    if ((float)set->total >= (size_t)((double)set->capacity * 0.85)) {
+        old = set->items;
+        end = set->capacity;
+
+        set->bits ++;
+        set->capacity = (size_t)(1 << set->bits);
+        set->mask     = set->capacity - 1;
+        set->items    = mem_a(set->capacity * sizeof(size_t));
+        set->total    = 0;
+
+        /*assert(set->items);*/
+
+        /*
+         * this shouldn't be slow?  if so unroll it a little perhaps
+         * (shouldn't be though)
+         */
+        for (itr = 0; itr < end; itr++)
+            util_hsput(set, (void*)old[itr]);
+
+        mem_d(old);
+    }
+}
+
+/*
+ * EXPOSED interface: all of these functions are exposed to the outside
+ * for use. The stuff above is static because it's the "internal" mechanics
+ * for syncronizing the set for updating, and putting data into the set.
+ */   
+int util_hsadd(hash_set_t *set, void *item) {
+    int run = util_hsput(set, item); /* inlined */
+    util_hsupdate(set);
+
+    return run;
+}
+
+/* remove item in set */
+int util_hsrem(hash_set_t *set, void *item) {
+    size_t hash = (size_t)item;
+    size_t iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+    while  (set->items[iter]) {
+        if (set->items[iter] == hash) {
+            set->items[iter] =  1;
+            set->total       --;
+
+            return 1;
+        }
+        iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+    }
+
+    return 0;
+}
+
+/* check if item is set */
+int util_hshas(hash_set_t *set, void *item) {
+    size_t hash = (size_t)item;
+    size_t iter = set->mask & (GMQCC_HASHSET_PRIME0 * hash);
+
+    while  (set->items[iter]) {
+        if (set->items[iter] == hash)
+            return 1;
+
+        iter = set->mask & (iter + GMQCC_HASHSET_PRIME1);
+    }
+
+    return 0;
+}
+
+hash_set_t *util_hsnew(void) {
+    hash_set_t *set;
+
+    if (!(set = mem_a(sizeof(hash_set_t))))
+        return NULL;
+
+    set->bits     = 3;
+    set->total    = 0;
+    set->capacity = (size_t)(1 << set->bits);
+    set->mask     = set->capacity - 1;
+    set->items    = mem_a(set->capacity * sizeof(size_t));
+
+    if (!set->items) {
+        util_hsdel(set);
+        return NULL;
+    }
+
+    return set;
+}
+
+void util_hsdel(hash_set_t *set) {
+    if (!set) return;
+
+    if (set->items)
+        mem_d(set->items);
+
+    mem_d(set);
+}
+#undef GMQCC_HASHSET_PRIME0
+#undef GMQCC_HASHSET_PRIME1
+
+
 /*
  * Portable implementation of vasprintf/asprintf. Assumes vsnprintf
  * exists, otherwise compiler error.
@@ -634,8 +770,6 @@ int util_vasprintf(char **dat, const char *fmt, va_list args) {
         *dat = tmp;
         return len;
     #endif
-    /* never reached ... */
-    return -1;
 }
 int util_asprintf(char **ret, const char *fmt, ...) {
     va_list  args;