indentation tabs to spaces

1 files changed, 131 insertions, 131 deletions

diff --git a/src/htgen.h b/src/htgen.h
index f3e57c3..c12ed71 100644
--- a/src/htgen.h
+++ b/src/htgen.h
@@ -45,7 +45,7 @@
 
 XXH64_hash_t ihash_hash_int(int i)
 {
-	return XXH3_64bits(&i, sizeof(int));
+  return XXH3_64bits(&i, sizeof(int));
 }
 
 #define HT_PREFIX ihash_
@@ -172,33 +172,33 @@ typedef HT_HASHTYPE HT__HASHTYPE;
 
 typedef struct {
 #ifndef HT_VAL_STATIC_LEN
-	size_t vallen;
+  size_t vallen;
 #endif
 
-	HT_VALTYPE val;
+  HT_VALTYPE val;
 
 #ifndef HT_KEY_STATIC_LEN
-	size_t keylen;
+  size_t keylen;
 #endif
 
-	HT_KEYTYPE key;
-	HT__HASHTYPE hash;
+  HT_KEYTYPE key;
+  HT__HASHTYPE hash;
 
-	bool full:1;
-	bool deleted:1;
+  bool full:1;
+  bool deleted:1;
 } HT__NODE;
 
 
 struct HT__TAG {
-	size_t capacity; /* hash table capacity (number of elements in table) */
-	size_t rsize;    /* real size (number of elements full) */
-	size_t asize;    /* active size (number of elements full and not deleted) */
+  size_t capacity; /* hash table capacity (number of elements in table) */
+  size_t rsize;    /* real size (number of elements full) */
+  size_t asize;    /* active size (number of elements full and not deleted) */
 
 #ifndef HT__LOADFACTOR_FIXED
-	float load_factor;
+  float load_factor;
 #endif
 
-	HT__NODE *table;
+  HT__NODE *table;
 };
 
 size_t HT__NS(_next_po2)(size_t in)
@@ -211,55 +211,55 @@ size_t HT__NS(_next_po2)(size_t in)
 HT__TYPE *HT__NS(new)(void)
 {
 #ifdef HT__LOADFACTOR_FIXED
-	return HT__NS(create)(0);
+  return HT__NS(create)(0);
 #else
-	return HT__NS(create)(0, HT_LOADFACTOR_DEF);
+  return HT__NS(create)(0, HT_LOADFACTOR_DEF);
 #endif
 }
 
 HT__TYPE *HT__NS(create)(HT__CREATE_SIG)
 {
-	HT__TYPE *ht = HT_CALLOC(1, sizeof(HT__TYPE));
-	if (!ht) return NULL;
+  HT__TYPE *ht = HT_CALLOC(1, sizeof(HT__TYPE));
+  if (!ht) return NULL;
 
 #ifndef HT_LOADFACTOR
-	if (load_factor < 0.0f || load_factor > 1.0f) {
-		goto cleanup;
-	} else if (load_factor == 0.0f) {
-		load_factor = HT_LOADFACTOR_DEF;
-	}
+  if (load_factor < 0.0f || load_factor > 1.0f) {
+    goto cleanup;
+  } else if (load_factor == 0.0f) {
+    load_factor = HT_LOADFACTOR_DEF;
+  }
 
-	ht->load_factor = load_factor;
+  ht->load_factor = load_factor;
 #endif
 
-	if (cap == 0) {
+  if (cap == 0) {
     cap = 16;
   } else {
     cap = HT__NS(_next_po2)(cap);
   }
 
-	ht->capacity = cap;
-	ht->table = HT_CALLOC(cap, sizeof(HT__NODE));
-	if (!ht->table) {
-		goto cleanup;
-	}
+  ht->capacity = cap;
+  ht->table = HT_CALLOC(cap, sizeof(HT__NODE));
+  if (!ht->table) {
+    goto cleanup;
+  }
 
-	return ht;
+  return ht;
 
 cleanup:
-	HT_FREE(ht->table);
-	HT_FREE(ht);
-	return NULL;
+  HT_FREE(ht->table);
+  HT_FREE(ht);
+  return NULL;
 }
 
 void HT__NS(free)(HT__TYPE *ht)
 {
-	if (!ht) return;
+  if (!ht) return;
 
   HT__NS(clear)(ht);
 
-	free(ht->table);
-	free(ht);
+  free(ht->table);
+  free(ht);
 }
 
 void HT__NS(clear)(HT__TYPE *ht)
@@ -277,92 +277,92 @@ void HT__NS(clear)(HT__TYPE *ht)
 
 HT__NODE *HT__NS(_search)(HT__NODE *table, size_t tablecap, const HT__HASHTYPE hash, HT_KEYTYPE_CREF key, size_t keylen, bool vacant)
 {
-	size_t tryidx = (size_t)((uintmax_t)hash % tablecap);
-	size_t start = tryidx;
+  size_t tryidx = (size_t)((uintmax_t)hash % tablecap);
+  size_t start = tryidx;
 
-	HT__NODE *node;
+  HT__NODE *node;
 
-	fprintf(stderr, "debug: trying %zu for " HT_KEY_FMT "\n", tryidx, key);
+  fprintf(stderr, "debug: trying %zu for " HT_KEY_FMT "\n", tryidx, key);
 
-	do {
-		node = table + tryidx;
+  do {
+    node = table + tryidx;
 
-		if (node->full && !node->deleted && node->hash == hash && HT_KEY_EQ(node->key, HT__NODE_KEYLEN(node), key, keylen)) {
-			fprintf(stderr, "found node %zu: matches\n", tryidx);
-			return node;
-		}
+    if (node->full && !node->deleted && node->hash == hash && HT_KEY_EQ(node->key, HT__NODE_KEYLEN(node), key, keylen)) {
+      fprintf(stderr, "found node %zu: matches\n", tryidx);
+      return node;
+    }
 
-		if (vacant) {
-			if (!node->full || node->deleted) {
-				fprintf(stderr, "found node %zu: empty\n", tryidx);
-				return node;
-			}
-		}
+    if (vacant) {
+      if (!node->full || node->deleted) {
+        fprintf(stderr, "found node %zu: empty\n", tryidx);
+        return node;
+      }
+    }
 
-		tryidx = (tryidx + 1) % tablecap;
-	} while (tryidx != start);
+    tryidx = (tryidx + 1) % tablecap;
+  } while (tryidx != start);
 
-	return NULL;
+  return NULL;
 }
 
 int HT__NS(_node_set)(HT__TYPE *ht, HT__NODE *node, const HT__HASHTYPE hash, HT_KEYTYPE_CREF key, size_t keylen, HT_VALTYPE_CREF val, size_t vallen)
 {
-	if (node->full) {
-		if (!node->deleted) {
-			/* same key already present! replace */
-			HT_VAL_FREE(node->val);
+  if (node->full) {
+    if (!node->deleted) {
+      /* same key already present! replace */
+      HT_VAL_FREE(node->val);
 
-			node->val = HT_VAL_COPY(val, vallen);
-			if (!node->val) return -1;
+      node->val = HT_VAL_COPY(val, vallen);
+      if (!node->val) return -1;
 
-			HT__NODE_VALLEN_SET(node, vallen);
+      HT__NODE_VALLEN_SET(node, vallen);
 
-			/* size left unchanged (key replaced) */
-			return 0;
-		}
+      /* size left unchanged (key replaced) */
+      return 0;
+    }
 
-		node->key = HT_KEY_COPY(key, keylen);
-		HT__NODE_KEYLEN_SET(node, keylen);
-		node->hash = hash;
+    node->key = HT_KEY_COPY(key, keylen);
+    HT__NODE_KEYLEN_SET(node, keylen);
+    node->hash = hash;
 
-		node->val = HT_VAL_COPY(val, vallen);
-		HT__NODE_VALLEN_SET(node, vallen);
+    node->val = HT_VAL_COPY(val, vallen);
+    HT__NODE_VALLEN_SET(node, vallen);
 
-		if (!node->val || !node->key) {
-			HT_KEY_FREE(node->key);
-			HT_VAL_FREE(node->val);
-			return -1;
-		}
+    if (!node->val || !node->key) {
+      HT_KEY_FREE(node->key);
+      HT_VAL_FREE(node->val);
+      return -1;
+    }
 
-		node->deleted = false; /* node is now filled */
-		++ht->asize;
-		return 0;
-	}
+    node->deleted = false; /* node is now filled */
+    ++ht->asize;
+    return 0;
+  }
 
-	/* fully new key */
+  /* fully new key */
 
-	node->key = HT_KEY_COPY(key, keylen);
-	HT__NODE_KEYLEN_SET(node, keylen);
-	node->hash = hash;
+  node->key = HT_KEY_COPY(key, keylen);
+  HT__NODE_KEYLEN_SET(node, keylen);
+  node->hash = hash;
 
-	node->val = HT_VAL_COPY(val, vallen);
-	HT__NODE_VALLEN_SET(node, vallen);
+  node->val = HT_VAL_COPY(val, vallen);
+  HT__NODE_VALLEN_SET(node, vallen);
 
-	if (!node->val || !node->key) {
-		HT_KEY_FREE(node->key);
-		HT_VAL_FREE(node->val);
-		return -1;
-	}
+  if (!node->val || !node->key) {
+    HT_KEY_FREE(node->key);
+    HT_VAL_FREE(node->val);
+    return -1;
+  }
 
-	node->deleted = false;
-	node->full = true;
+  node->deleted = false;
+  node->full = true;
 
-	++ht->rsize;
-	++ht->asize;
+  ++ht->rsize;
+  ++ht->asize;
 
-	if (!node->val) return -1;
+  if (!node->val) return -1;
 
-	return 0;
+  return 0;
 }
 
 int HT__NS(_rehash)(HT__TYPE *ht, size_t newcap)
@@ -394,67 +394,67 @@ cleanup:
 
 int HT__NS(put)(HT__TYPE *ht, HT_KEYTYPE_CREF key, HT_VALTYPE_CREF val)
 {
-	return HT__NS(putn)(ht, key, 0, val, 0);
+  return HT__NS(putn)(ht, key, 0, val, 0);
 }
 
 int HT__NS(putn)(HT__TYPE *ht, HT_KEYTYPE_CREF key, size_t keylen, HT_VALTYPE_CREF val, size_t vallen)
 {
   if (ht->capacity * HT__LOADFACTOR(ht) < (ht->asize + 1)) {
     if (HT__NS(_rehash)(ht, ht->capacity << 1) < 0) return -1;
-	}
+  }
 
-	if (!keylen) keylen = HT__GUESS_KEYLEN(key);
-	if (!vallen) vallen = HT__GUESS_VALLEN(val);
+  if (!keylen) keylen = HT__GUESS_KEYLEN(key);
+  if (!vallen) vallen = HT__GUESS_VALLEN(val);
 
-	const HT__HASHTYPE hash = HT_KEY_HASH(key, keylen);
+  const HT__HASHTYPE hash = HT_KEY_HASH(key, keylen);
 
-	HT__NODE *node = HT__NS(_search)(ht->table, ht->capacity, hash, key, keylen, true);
+  HT__NODE *node = HT__NS(_search)(ht->table, ht->capacity, hash, key, keylen, true);
 
-	if (!node) { /* no vacant slots found */
-		return -1; /* table is full or something! */
-	}
+  if (!node) { /* no vacant slots found */
+    return -1; /* table is full or something! */
+  }
 
-	return HT__NS(_node_set)(ht, node, hash, key, keylen, val, vallen);
+  return HT__NS(_node_set)(ht, node, hash, key, keylen, val, vallen);
 }
 
 HT_VALTYPE HT__NS(get)(HT__TYPE *ht, HT_KEYTYPE_CREF key, bool *found)
 {
-	return HT__NS(getn)(ht, key, 0, found);
+  return HT__NS(getn)(ht, key, 0, found);
 }
 
 HT_VALTYPE HT__NS(getn)(HT__TYPE *ht, HT_KEYTYPE_CREF key, size_t keylen, bool *found)
 {
-	if (!keylen) keylen = HT__GUESS_KEYLEN(key);
+  if (!keylen) keylen = HT__GUESS_KEYLEN(key);
 
-	const HT__HASHTYPE hash = HT_KEY_HASH(key, keylen);
-	HT__NODE *node = HT__NS(_search)(ht->table, ht->capacity, hash, key, keylen, false);
+  const HT__HASHTYPE hash = HT_KEY_HASH(key, keylen);
+  HT__NODE *node = HT__NS(_search)(ht->table, ht->capacity, hash, key, keylen, false);
 
-	if (!node) {
-		if (found) *found = false;
-		return HT_VAL_SENTINEL;
-	}
+  if (!node) {
+    if (found) *found = false;
+    return HT_VAL_SENTINEL;
+  }
 
-	*found = true;
-	return node->val;
+  *found = true;
+  return node->val;
 }
 
 void HT__NS(_debug_table)(HT__TYPE *ht)
 {
-	fprintf(stderr, HT__STR(HT__TYPE) " debug: cap: %zu, asize: %zu, rsize: %zu, lf: %f\n",
-		ht->capacity, ht->asize, ht->rsize, HT__LOADFACTOR(ht));
-	
-	for (size_t n = 0; n < ht->capacity; ++n) {
-		fprintf(stderr, "%zu: ", n);
-		if (ht->table[n].full) {
-			if (ht->table[n].deleted) {
-				fprintf(stderr, "(deleted)\n");
-			} else {
-				fprintf(stderr, "(full " HT_KEY_FMT ":" HT_VAL_FMT ")\n", ht->table[n].key, ht->table[n].val);
-			}
-		} else {
-			fprintf(stderr, "(empty)\n");
-		}
-	}
+  fprintf(stderr, HT__STR(HT__TYPE) " debug: cap: %zu, asize: %zu, rsize: %zu, lf: %f\n",
+    ht->capacity, ht->asize, ht->rsize, HT__LOADFACTOR(ht));
+  
+  for (size_t n = 0; n < ht->capacity; ++n) {
+    fprintf(stderr, "%zu: ", n);
+    if (ht->table[n].full) {
+      if (ht->table[n].deleted) {
+        fprintf(stderr, "(deleted)\n");
+      } else {
+        fprintf(stderr, "(full " HT_KEY_FMT ":" HT_VAL_FMT ")\n", ht->table[n].key, ht->table[n].val);
+      }
+    } else {
+      fprintf(stderr, "(empty)\n");
+    }
+  }
 }
 
 #endif