/*
 * Copyright (C) 2010 Dan Carpenter.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "smatch.h"
#include "cwchash/hashtable.h"

static inline unsigned int djb2_hash(void *ky)
{
	char *str = (char *)ky;
	unsigned long hash = 5381;
	int c;

	while ((c = *str++))
		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

        return hash;
}

static inline int equalkeys(void *k1, void *k2)
{
	return !strcmp((char *)k1, (char *)k2);
}

#define DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type) \
void add_##_name(struct hashtable *table, const char *look_for, _item_type *value) \
{                                                               \
	_list_type *list;                                       \
	char *key;                                              \
                                                                \
	key = alloc_string(look_for);                           \
	list = search_##_name(table, key);                      \
	if (!list) {                                            \
		add_ptr_list(&list, value);                     \
	} else {                                                \
		remove_##_name(table, key);                     \
		add_ptr_list(&list, value);                     \
	}                                                       \
	insert_##_name(table, key, list);                       \
}

static inline struct hashtable *create_function_hashtable(int size)
{
	return create_hashtable(size, djb2_hash, equalkeys);
}

static inline void destroy_function_hashtable(struct hashtable *table)
{
	hashtable_destroy(table, 0);
}

#define DEFINE_FUNCTION_HASHTABLE(_name, _item_type, _list_type)   \
	DEFINE_HASHTABLE_INSERT(insert_##_name, char, _list_type); \
	DEFINE_HASHTABLE_SEARCH(search_##_name, char, _list_type); \
	DEFINE_HASHTABLE_REMOVE(remove_##_name, char, _list_type); \
	DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type);

#define DEFINE_FUNCTION_HASHTABLE_STATIC(_name, _item_type, _list_type)   \
	static DEFINE_HASHTABLE_INSERT(insert_##_name, char, _list_type); \
	static DEFINE_HASHTABLE_SEARCH(search_##_name, char, _list_type); \
	static DEFINE_HASHTABLE_REMOVE(remove_##_name, char, _list_type); \
	static DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type);

#define DEFINE_STRING_HASHTABLE_STATIC(_name)   \
	static DEFINE_HASHTABLE_INSERT(insert_##_name, char, int); \
	static DEFINE_HASHTABLE_SEARCH(search_##_name, char, int); \
	static struct hashtable *_name

static inline void load_hashtable_helper(const char *file, int (*insert_func)(struct hashtable *, char *, int *), struct hashtable *table)
{
	char filename[256];
	struct token *token;
	char *name;

	snprintf(filename, sizeof(filename), "%s.%s", option_project_str, file);
	token = get_tokens_file(filename);
	if (!token)
		return;
	if (token_type(token) != TOKEN_STREAMBEGIN)
		return;
	token = token->next;
	while (token_type(token) != TOKEN_STREAMEND) {
		if (token_type(token) != TOKEN_IDENT)
			return;
		name = alloc_string(show_ident(token->ident));
		insert_func(table, name, (void *)1);
		token = token->next;
	}
	clear_token_alloc();
}

#define load_strings(file, _table) load_hashtable_helper(file, insert_##_table, _table)