/* registry.cc
 *   by Will Wagner <wwagner@io.com>
 *   last updated 11 Aug 1997, 17:47:28 wwagner
 *
 * This file contains the method definitions for the SymbolTable and
 * Registry classes.
 *
 * Changes
 *   24 Jul 1997
 *     - Created the file.
 *
 *   29 Jul 1997
 *     - Minor updates; added Registry methods.
 *
 * Things to do
 *
 */

#include "registry.h"

/* Create the single registry object in this system. */
Registry registry;

/* SymbolTable methods */
int SymbolTable::hash(char *str) const
{
    unsigned int i = 0;

    while (*str)
	i = (i << 1) ^ *str++;
    return((int)(i % size));
}

int SymbolTable::ss_eql(const struct symbol_struct& ss, const char *str)
{
    return (!strcmp((*ss).name, str));
}

SymbolTable::SymbolTable(int hts)
    : hash_table()
{
    size = hts;
    hash_table.reserve(size);
}

SymbolTable::SymbolTable(const SymbolTable& st)
    : hash_table(st.hash_table)
{
    size = st.size;
    min_value = st.min_value;
    next_token_val = st.next_token_val;
}

SymbolTable::~SymbolTable()
{
    /* need to delete all the actual symbols that reside in the table */
}

int SymbolTable::SetMinValue(int nv)
{
    int tmp = min_value;

    min_value = nv;
    return tmp;
}

TOKEN SymbolTable::Add(char *str, int tn)
{
    int hv = hash(str);
    struct symbol_struct ss;

    if (tn == -1)
	ss.number = (next_token_val++);
    else
    {
	ss.number = tn;
	next_token_val = max(tn + 1, next_token_val);
    }
    ss.type = 0;
    ss.name = strdup(str);
    ss.meaning = NULL;
    hash_table[hv].push_back(ss);
    return (tn + min_value);
}

TOKEN SymbolTable::Find(char *str) const;
{
    int hv = hash(str);
    list<struct symbol_struct>::iterator ss;

    ss  = find_if(hash_table[hv].begin(), hash_table[hv].end(),
		  bind2nd(SymbolTable::ss_eql(), str));
    if (ss != hash_table[hv].end())
	return (*ss).number + min_value;
    return -1;
}

TOKEN SymbolTable::Type(char *str, TOKEN t) const
{
    int hv = hash(str);
    list<struct symbol_struct>::iterator ss;

    ss = find_if(hash_table[hv].begin(), hash_table[hv].end(),
		 bind2nd(SymbolTable::ss_eql(), str));
    if (ss != hash_table[hv].end())
    {
	if (t != -1)
	{
	    TOKEN tmp = (*ss).type;
	    (*ss).type = t;
	    return tmp;
	}
	else
	    return (*ss).type;
    }
    return -1;
}

void *SymbolTable::Means(char *str, void *m)
{
    int hv = hash(str);
    list<struct symbol_struct>::iterator ss;

    ss = find_if(hash_table[hv].begin(), hash_table[hv].end(),
		 bind2nd(SymbolTable::ss_eql(), str));
    if (ss != hash_table[hv].end())
    {
	if (m != NULL)
	{
	    void *tmp = (*ss).meaning;
	    (*ss).meaning = m;
	    return tmp;
	}
	else
	    return (*ss).meaning;
    }
    return NULL;
}

Registry::Registry()
{
}

Registry::~Registry()
{
}

void Registry::ReadCommandLine(int argc, char **argv)
{
}

void Registry::ReadEnvironment(void)
{
}

void Registry::ReadParamFile(char *)
{
}