#include <stdlib.h>

 #include <string.h>

 #include "types.h"

 void

 array_init(struct array *array)

 {

 	memset(array, 0, sizeof *array);

 }

 void

 array_release(struct array *array)

 {

 	free(array->data);

 }

 void *

 array_add(struct array *array, int size)

 {

 	int alloc;

 	void *data, *p;

 	if (array->alloc > 0)

 		alloc = array->alloc;

 	else

 		alloc = 16;

 	while (alloc < array->size + size)

 		alloc *= 2;

 	if (array->alloc < alloc) {

 		data = realloc(array->data, alloc);

 		if (data == NULL)

 			return 0;

 		array->data = data;

 		array->alloc = alloc;

 	}

 	p = array->data + array->size;

 	array->size += size;

 	return p;

 }

 /* RAZOR_IMMEDIATE and RAZOR_ENTRY_LAST must have the same value */

 #define RAZOR_ENTRY_LAST 0x80

 #define RAZOR_IMMEDIATE  0x80

 #define RAZOR_EMPTY_LIST 0xff

 void

 list_set_empty(struct list_head *head)

 {

 	head->list_ptr = ~0;

 	head->flags = RAZOR_EMPTY_LIST;

 }

 void

 list_set_ptr(struct list_head *head, uint32_t ptr)

 {

 	head->list_ptr = ptr;

 	head->flags = 0;

 }

 void

 list_set_array(struct list_head *head, struct array *pool,

 	       struct array *items, int force_indirect)

 {

 	struct list *p;

 	if (!force_indirect) {

 		if (items->size == 0) {

 			list_set_empty(head);

 			return;

 		} else if (items->size == sizeof (uint32_t)) {

 			head->list_ptr = *(uint32_t *) items->data;

 			head->flags = RAZOR_IMMEDIATE;

 			return;

 		}

 	}

 	p = array_add(pool, items->size);

 	memcpy(p, items->data, items->size);

 	p[items->size / sizeof *p - 1].flags = RAZOR_ENTRY_LAST;

 	list_set_ptr(head, p - (struct list *) pool->data);

 }

 struct list *

 list_first(struct list_head *head, struct array *pool)

 {

 	if (head->flags == RAZOR_EMPTY_LIST)

 		return NULL;

 	else if (head->flags == RAZOR_IMMEDIATE)

 		return (struct list *) head;

 	else

 		return (struct list *) pool->data + head->list_ptr;

 }

 struct list *

 list_next(struct list *list)

 {

 	if (list->flags)

 		return NULL;

 	return ++list;

 }

 void

 list_remap_pool(struct array *pool, uint32_t *map)

 {

 	struct list *p, *end;

 	end = pool->data + pool->size;

 	for (p = pool->data; p < end; p++)

 		p->data = map[p->data];

 }

 void

 list_remap_head(struct list_head *head, uint32_t *map)

 {

 	if (head->flags == RAZOR_IMMEDIATE)

 		head->list_ptr = map[head->list_ptr];

 }

 void

 hashtable_init(struct hashtable *table, struct array *pool)

 {

 	array_init(&table->buckets);

 	table->pool = pool;

 }

 void

 hashtable_release(struct hashtable *table)

 {

 	array_release(&table->buckets);

 }

 static unsigned int

 hash_string(const char *key)

 {

 	const char *p;

 	unsigned int hash = 0;

 	for (p = key; *p; p++)

 		hash = (hash * 617) ^ *p;

 	return hash;

 }

 uint32_t

 hashtable_lookup(struct hashtable *table, const char *key)

 {

 	unsigned int mask, start, i;

 	uint32_t *b;

 	char *pool;

 	pool = table->pool->data;

 	mask = table->buckets.alloc - 1;

 	start = hash_string(key) * sizeof(uint32_t);

 	for (i = 0; i < table->buckets.alloc; i += sizeof *b) {

 		b = table->buckets.data + ((start + i) & mask);

 		if (*b == 0)

 			return 0;

 		if (strcmp(key, &pool[*b]) == 0)

 			return *b;

 	}

 	return 0;

 }

 static void

 do_insert(struct hashtable *table, uint32_t value)

 {

 	unsigned int mask, start, i;

 	uint32_t *b;

 	const char *key;

 	key = (char *) table->pool->data + value;

 	mask = table->buckets.alloc - 1;

 	start = hash_string(key) * sizeof(uint32_t);

 	for (i = 0; i < table->buckets.alloc; i += sizeof *b) {

 		b = table->buckets.data + ((start + i) & mask);

 		if (*b == 0) {

 			*b = value;

 			break;

 		}

 	}

 }

 static uint32_t

 add_to_string_pool(struct hashtable *table, const char *key)

 {

 	int len;

 	char *p;

 	len = strlen(key) + 1;

 	p = array_add(table->pool, len);

 	memcpy(p, key, len);

 	return p - (char *) table->pool->data;

 }

 uint32_t

 hashtable_insert(struct hashtable *table, const char *key)

 {

 	uint32_t value, *buckets, *b, *end;

 	int alloc;

 	alloc = table->buckets.alloc;

 	array_add(&table->buckets, 4 * sizeof *buckets);

 	if (alloc != table->buckets.alloc) {

 		end = table->buckets.data + alloc;

 		memset(end, 0, table->buckets.alloc - alloc);

 		for (b = table->buckets.data; b < end; b++) {

 			value = *b;

 			if (value != 0) {

 				*b = 0;

 				do_insert(table, value);

 			}

 		}

 	}

 	value = add_to_string_pool(table, key);

 	do_insert (table, value);

 	return value;

 }

 uint32_t

 hashtable_tokenize(struct hashtable *table, const char *string)

 {

 	uint32_t token;

 	if (string == NULL)

 		string = "";

 	token = hashtable_lookup(table, string);

 	if (token != 0)

 		return token;

 	return hashtable_insert(table, string);

 }

 void

 bitarray_init(struct bitarray *bitarray, int size, int initial_value)

 {

 	int bytes = ((size + 31) / 32) * 4;

 	bitarray->bits = malloc(bytes);

 	memset(bitarray->bits, initial_value ? 0xff : 0x00, bytes);

 }

 void

 bitarray_release(struct bitarray *bitarray)

 {

 	free(bitarray->bits);

 }

 void

 bitarray_set(struct bitarray *bitarray, int bit, int value)

 {

 	if (value)

 		bitarray->bits[bit >> 5] |= 1 << (bit & 31);

 	else

 		bitarray->bits[bit >> 5] &= ~(1 << (bit & 31));

 }

 int

 bitarray_get(struct bitarray *bitarray, int bit)

 {

 	return (bitarray->bits[bit >> 5] & (1 << (bit & 31))) != 0;

 }