diff --git a/util.cpp b/util.cpp
index a7eaa2e3d..bee35495b 100644
--- a/util.cpp
+++ b/util.cpp
@@ -1,7 +1,7 @@
 /** \file util.c
 	Generic utilities library.
 
-	Contains datastructures such as hash tables, automatically growing array lists, priority queues, etc.
+	Contains datastructures such as automatically growing array lists, priority queues, etc.
 */
 
 #include "config.h"
@@ -36,11 +36,6 @@
 */
 #define MIN_SIZE 32
 
-/**
-   Minimum size for hash tables
-*/
-#define HASH_MIN_SIZE 7
-
 /**
    Maximum number of characters that can be inserted using a single
    call to sb_printf. This is needed since vswprintf doesn't tell us
@@ -100,487 +95,6 @@ int maxi( int a,
 	return a>b?a:b;
 }
 
-
-/* Hash table functions */
-
-void hash_init2( hash_table_t *h,
-				int (*hash_func)(void *key),
-				 int (*compare_func)(void *key1, void *key2),
-				 size_t capacity)
-{
-	size_t sz = 32;
-	while( sz < (capacity*4/3) )
-		sz*=2;
-	/*
-	  Make sure the size is a Mersenne number. Should hopfully be a
-	  reasonably good size with regard to avoiding patterns of collisions.
-	*/
-	sz--;
-	
-
-	h->arr = (hash_struct_t *)malloc( sizeof(hash_struct_t)*sz );
-	if( !h->arr )
-	{
-		oom_handler( h );
-		return;
-	}
-	
-	h->size = sz;
-	for( size_t i=0; i< sz; i++ )
-		h->arr[i].key = 0;
-	h->count=0;
-	h->hash_func = hash_func;
-	h->compare_func = compare_func;
-	h->cache=-1;
-}
-
-void hash_init( hash_table_t *h,
-				int (*hash_func)(void *key),
-				int (*compare_func)(void *key1, void *key2) )
-{
-	h->arr = 0;
-	h->size = 0;
-	h->count=0;
-	h->hash_func = hash_func;
-	h->compare_func = compare_func;
-	h->cache=-1;
-}
-
-
-void hash_destroy( hash_table_t *h )
-{
-	free( h->arr );
-}
-
-/**
-   Search for the specified hash key in the table
-   \return index in the table, or to the first free index if the key is not in the table
-*/
-static int hash_search( hash_table_t *h,
-						void *key )
-{
-	int hv;
-	int pos;
-
-	if( h->cache>=0 && h->arr[h->cache].key)
-	{
-		if( h->compare_func( h->arr[h->cache].key, key ) )
-		{
-			return h->cache;
-		}
-	}
-
-	hv = h->hash_func( key );
-	pos = (hv & 0x7fffffff) % h->size;
-	while(1)
-	{
-		if( (h->arr[pos].key == 0 ) ||
-			( h->compare_func( h->arr[pos].key, key ) ) )
-		{
-			h->cache = pos;
-			return pos;
-		}
-		pos++;
-		pos %= h->size;
-	}
-}
-
-/**
-   Reallocate the hash array. This is quite expensive, as every single entry has to be rehashed and moved.
-*/
-static int hash_realloc( hash_table_t *h,
-						 int sz )
-{
-
-	/* Avoid reallocating when using pathetically small tables */
-	if( ( sz < h->size ) && (h->size < HASH_MIN_SIZE))
-		return 1;
-	sz = maxi( sz, HASH_MIN_SIZE );
-	
-	hash_struct_t *old_arr = h->arr;
-	int old_size = h->size;
-	
-	int i;
-
-	h->cache = -1;
-	h->arr = (hash_struct_t *)malloc( sizeof( hash_struct_t) * sz );
-	if( h->arr == 0 )
-	{
-		h->arr = old_arr;
-		oom_handler( h );
-		return 0;
-	}
-
-	memset( h->arr,
-			0,
-			sizeof( hash_struct_t) * sz );
-	h->size = sz;
-
-	for( i=0; i<old_size; i++ )
-	{
-		if( old_arr[i].key != 0 )
-		{
-			int pos = hash_search( h, old_arr[i].key );
-			h->arr[pos].key = old_arr[i].key;
-			h->arr[pos].data = old_arr[i].data;
-		}
-	}
-	free( old_arr );
-
-	return 1;
-}
-
-
-int hash_put( hash_table_t *h,
-			  const void *key,
-			  const void *data )
-{
-	int pos;
-	
-	if( (float)(h->count+1)/h->size > 0.75f )
-	{
-		if( !hash_realloc( h, (h->size+1) * 2 -1 ) )
-		{
-			return 0;
-		}
-	}
-
-	pos = hash_search( h, (void *)key );
-
-	if( h->arr[pos].key == 0 )
-	{
-		h->count++;
-	}
-
-	h->arr[pos].key = (void *)key;
-	h->arr[pos].data = (void *)data;
-	return 1;
-}
-
-void *hash_get( hash_table_t *h,
-				const void *key )
-{
-	if( !h->count )
-		return 0;
-	
-	int pos = hash_search( h, (void *)key );	
-	if( h->arr[pos].key == 0 )
-	{
-		return 0;
-	}
-	else
-	{
-		void *res =h->arr[pos].data;
-		return res;
-	}
-}
-
-void *hash_get_key( hash_table_t *h,
-					const void *key )
-{	
-	if( !h->count )
-		return 0;
-	
-	int pos = hash_search( h, (void *)key );
-	if( h->arr[pos].key == 0 )
-		return 0;
-	else
-		return h->arr[pos].key;
-}
-
-int hash_get_count( hash_table_t *h)
-{
-	return h->count;
-}
-
-void hash_remove( hash_table_t *h,
-				  const void *key,
-				  void **old_key,
-				  void **old_val )
-{
-	if( !h->count )
-	{
-
-		if( old_key != 0 )
-			*old_key = 0;
-		if( old_val != 0 )
-			*old_val = 0;
-		return;
-	}
-
-	int pos = hash_search( h, (void *)key );
-	int next_pos;
-
-	if( h->arr[pos].key == 0 )
-	{
-
-		if( old_key != 0 )
-			*old_key = 0;
-		if( old_val != 0 )
-			*old_val = 0;
-		return;
-	}
-
-	h->count--;
-
-	if( old_key != 0 )
-		*old_key = h->arr[pos].key;
-	if( old_val != 0 )
-		*old_val = h->arr[pos].data;
-
-	h->arr[pos].key = 0;
-
-	next_pos = pos+1;
-	next_pos %= h->size;
-
-	while( h->arr[next_pos].key != 0 )
-	{
-
-		int hv = h->hash_func( h->arr[next_pos].key );
-		int ideal_pos = ( hv  & 0x7fffffff) % h->size;
-		int dist_old = (next_pos - ideal_pos + h->size)%h->size;
-		int dist_new = (pos - ideal_pos + h->size)%h->size;
-		if ( dist_new < dist_old )
-		{
-			h->arr[pos].key = h->arr[next_pos].key;
-			h->arr[pos].data = h->arr[next_pos].data;
-			h->arr[next_pos].key = 0;
-			pos = next_pos;
-		}
-		next_pos++;
-
-		next_pos %= h->size;
-
-	}
-
-	if( (float)(h->count+1)/h->size < 0.2f && h->count < 63 )
-	{
-		hash_realloc( h, (h->size+1) / 2 -1 );
-	}
-
-	return;
-}
-
-int hash_contains( hash_table_t *h,
-				   const void *key )
-{
-	if( !h->count )
-		return 0;
-	
-	int pos = hash_search( h, (void *)key );
-	return h->arr[pos].key != 0;
-}
-
-/**
-   Push hash value into array_list_t
-*/
-static void hash_put_data( void *key,
-						   void *data,
-						   void *al )
-{
-	al_push( (array_list_t *)al,
-			 data );
-}
-
-
-void hash_get_data( hash_table_t *h,
-					array_list_t *arr )
-{
-	hash_foreach2( h, &hash_put_data, arr );
-}
-
-/**
-   Push hash key into array_list_t
-*/
-static void hash_put_key( void *key, void *data, void *al )
-{
-	al_push( (array_list_t *)al, key );
-}
-
-
-void hash_get_keys( hash_table_t *h,
-					array_list_t *arr )
-{
-	hash_foreach2( h, &hash_put_key, arr );
-}
-
-void hash_foreach( hash_table_t *h,
-				   void (*func)( void *, void *) )
-{
-	int i;
-	for( i=0; i<h->size; i++ )
-	{
-		if( h->arr[i].key != 0 )
-		{
-			func( h->arr[i].key, h->arr[i].data );
-		}
-	}
-}
-
-void hash_foreach2( hash_table_t *h,
-					void (*func)( void *, void *, void * ),
-					void *aux )
-{
-	int i;
-	for( i=0; i<h->size; i++ )
-	{
-		if( h->arr[i].key != 0 )
-		{
-			func( h->arr[i].key, h->arr[i].data, aux );
-		}
-	}
-}
-
-
-/**
-   Helper function for hash_wcs_func
-*/
-static unsigned int rotl1( unsigned int in )
-{
-	return (in<<1|in>>31);
-}
-
-/**
-   Helper function for hash_wcs_func
-*/
-static unsigned int rotl5( unsigned int in )
-{
-	return (in<<5|in>>27);
-}
-
-/**
-   Helper function for hash_wcs_func
-*/
-static unsigned int rotl30( unsigned int in )
-{
-	return (in<<30|in>>2);
-}
-
-/**
-   The number of words of input used in each lap by the sha-like
-   string hashing algorithm. 
-*/
-#define WORD_COUNT 16
-
-int hash_wcs_func( void *data )
-{
-	const wchar_t *in = (const wchar_t *)data;
-	unsigned int a,b,c,d,e;
-	int t;
-	unsigned int k0=0x5a827999u;	
-	unsigned int k1 =0x6ed9eba1u;
-	
-	unsigned int w[2*WORD_COUNT];	
-	
-	/*
-	  Same constants used by sha1
-	*/
-	a=0x67452301u;
-	b=0xefcdab89u;
-	c=0x98badcfeu;
-	d=0x10325476u;
-	e=0xc3d2e1f0u;
-	
-	if( data == 0 )
-		return 0;
-	
-	while( *in )
-	{
-		int i;
-
-		/*
-		  Read WORD_COUNT words of data into w
-		*/
-		for( i=0; i<WORD_COUNT; i++ )
-		{
-			if( !*in)
-			{
-				/*
-				  We have reached EOF, fill in the rest with zeroes
-				*/
-				for( ;i<WORD_COUNT; i++ )
-					w[i]=0;
-			}
-			else
-				w[i]=*in++;
-			
-		}
-		
-		/*
-		  And fill up the rest by rotating the previous content
-		*/
-		for( i=WORD_COUNT; i<(2*WORD_COUNT); i++ )
-		{
-			w[i]=rotl1(w[i-1]^w[i-(WORD_COUNT/2)]^w[i-(WORD_COUNT/2-1)]^w[i-WORD_COUNT]);
-		}
-
-		/*
-		  Only 2*WORD_COUNT laps, not 80 like in sha1. Only two types
-		  of laps, not 4 like in sha1
-		*/
-		for( t=0; t<WORD_COUNT; t++ )
-		{
-			unsigned int temp;
-			temp = (rotl5(a)+(b^c^d)+e+w[t]+k0);
-			e=d;
-			d=c;
-			c=rotl30(b);
-			b=a;
-			a=temp;
-		}
-		for( t=WORD_COUNT; t<(2*WORD_COUNT); t++ )
-		{
-			unsigned int temp;
-			temp = (rotl5(a)+((b&c)|(b&d)|(c&d))+e+w[t]+k1);
-			e=d;
-			d=c;
-			c=rotl30(b);
-			b=a;
-			a=temp;
-		}
-	}
-
-	/*
-	  Implode from 160 to 32 bit hash and return
-	*/
-	return a^b^c^d^e;
-}
-
-int hash_wcs_cmp( void *a, void *b )
-{
-	return wcscmp((wchar_t *)a,(wchar_t *)b) == 0;
-}
-
-int hash_str_cmp( void *a, void *b )
-{
-	return strcmp((char *)a,(char *)b) == 0;
-}
-
-int hash_str_func( void *data )
-{
-	int res = 0x67452301u;
-	const char *str = (const char *)data;	
-
-	while( *str )
-		res = (18499*rotl5(res)) ^ *str++;
-	
-	return res;
-}
-
-int hash_ptr_func( void *data )
-{
-	return (int)(long) data;
-}
-
-/**
-   Hash comparison function suitable for direct pointer comparison
-*/
-int hash_ptr_cmp( void *a,
-                  void *b )
-{
-	return a == b;
-}
-
 /**
    Real implementation of all al_push_* versions. Pushes arbitrary
    element to end of list.
diff --git a/util.h b/util.h
index 652107775..625c950d0 100644
--- a/util.h
+++ b/util.h
@@ -42,50 +42,6 @@ typedef union
 }
 	anything_t;
 
-/**
-   Internal struct used by hash_table_t.
-*/
-typedef struct
-{
-	/** Hash key*/
-	void *key;
-	/** Value */
-	void *data;
-}
-	hash_struct_t;
-
-/**
-   Data structure for the hash table implementaion. A hash table allows for
-   retrieval and removal of any element in O(1), so long as a proper
-   hash function is supplied.
-
-   The hash table is implemented using a single hash function and
-   element storage directly in the array. When a collision occurs, the
-   hashtable iterates until a zero element is found. When the table is
-   75% full, it will automatically reallocate itself. This
-   reallocation takes O(n) time. The table is guaranteed to never be
-   more than 75% full or less than 30% full (Unless the table is
-   nearly empty). Its size is always a Mersenne number.
-
-*/
-
-typedef struct hash_table
-{
-	/** The array containing the data */
-	hash_struct_t *arr;
-	/** A simple one item cache. This should always point to the index of the last item to be used */
-	int cache;	
-	/** Number of elements */
-	int count;
-	/** Length of array */
-	int size;
-	/** Hash function */
-	int (*hash_func)( void *key );
-	/** Comparison function */
-	int (*compare_func)( void *key1, void *key2 );
-}
-	hash_table_t;
-
 /**
    Data structure for an automatically resizing dynamically allocated
    priority queue. A priority queue allows quick retrieval of the
@@ -193,128 +149,6 @@ int mini( int a, int b );
   to never be less than 50% full. 
 */
 
-/**
-   Initialize a hash table. The hash function must never return the value 0.
-*/
-void hash_init( hash_table_t *h,
-				int (*hash_func)( void *key),
-				int (*compare_func)( void *key1, void *key2 ) );
-
-/**
-   Initialize a hash table. The hash function must never return the value 0.
-*/
-void hash_init2( hash_table_t *h,
-				int (*hash_func)( void *key ),
-				 int (*compare_func)( void *key1, void *key2 ),
-				 size_t capacity);
-
-/**
-   Destroy the hash table and free associated memory.
-*/
-void hash_destroy( hash_table_t *h );
-/**
-   Set the key/value pair for the hashtable. 
-*/
-int hash_put( hash_table_t *h, 
-			  const void *key,
-			  const void *data );
-/**
-   Returns the data with the associated key, or 0 if no such key is in the hashtable
-*/
-void *hash_get( hash_table_t *h,
-				const void *key );
-/**
-   Returns the hash tables version of the specified key
-*/
-void *hash_get_key( hash_table_t *h, 
-					const void *key );
-
-/**
-   Returns the number of key/data pairs in the table.
-*/
-int hash_get_count( hash_table_t *h);
-/**
-   Remove the specified key from the hash table if it exists. Do nothing if it does not exist.
-
-   \param h The hashtable
-   \param key The key
-   \param old_key If not 0, a pointer to the old key will be stored at the specified address
-   \param old_data If not 0, a pointer to the data will be stored at the specified address
-*/
-void hash_remove( hash_table_t *h, 
-				  const void *key, 
-				  void **old_key,
-				  void **old_data );
-
-/**
-   Checks whether the specified key is in the hash table
-*/
-int hash_contains( hash_table_t *h, 
-				   const void *key );
-
-/**
-   Appends all keys in the table to the specified list
-*/
-void hash_get_keys( hash_table_t *h,
-					array_list_t *arr );
-
-/**
-   Appends all data elements in the table to the specified list
-*/
-void hash_get_data( hash_table_t *h,
-					array_list_t *arr );
-
-/**
-   Call the function func for each key/data pair in the table
-*/
-void hash_foreach( hash_table_t *h, 
-				   void (*func)( void *, void * ) );
-
-/**
-   Same as hash_foreach, but the function func takes an additional
-   argument, which is provided by the caller in the variable aux 
-*/
-void hash_foreach2( hash_table_t *h, void (*func)( void *, 
-												   void *, 
-												   void *), 
-					void *aux );
-
-/**
-   Hash function suitable for character strings. 
-*/
-int hash_str_func( void *data );
-/**
-   Hash comparison function suitable for character strings
-*/
-int hash_str_cmp( void *a,
-				  void *b );
-
-/**
-   Hash function suitable for wide character strings. Uses a version
-   of the sha cryptographic function which is simplified in order to
-   returns a 32-bit number.
-*/
-int hash_wcs_func( void *data );
-
-/**
-   Hash comparison function suitable for wide character strings
-*/
-int hash_wcs_cmp( void *a, 
-				  void *b );
-
-/**
-   Hash function suitable for direct pointer comparison
-*/
-int hash_ptr_func( void *data );
-
-
-/**
-   Hash comparison function suitable for direct pointer comparison
-*/
-int hash_ptr_cmp( void *a,
-                  void *b );
-
-
 /**
    Append element to list