#include <stdio.h>
#include <string.h>
#include "symbol.h"
#include "emalloc.h"

struct symbol {
    /* various stuff about type, etc, would go here in a compiler */
    char *name;
    int index;
    int first_seen;  /* stmt # in which symbol is earliest-seen */
    int last_seen;  /* stmt # in which symbol is latest-seen */
    struct symbol *next;  /* next symbol in the same bucket (leave this) */
};
static int nsymbols = 0;


#define HASHSIZE 67
static struct symbol *bucket[HASHSIZE];  /* default init to null pointers */

static int hash(char *name)
{
    int retval = 0;
    char *p;

    for (p = name; *p; p++)
        retval = (retval + (*p & 255)) % HASHSIZE;
    return retval;
}


struct symbol *symbol_lookup(char *name)
{
    struct symbol *p, **buc;

    buc = &bucket[hash(name)];
    for (p = *buc; p && strcmp(p->name, name); p = p->next)
        ;

    if (p == NULL) {
        /* create the symbol */
        p = (struct symbol *)emalloc(sizeof(struct symbol));
        p->name = emalloc(strlen(name) + 1);
        strcpy(p->name, name);
        p->first_seen = p->last_seen = -1;

        /* link it in */
        p->next = *buc;
        *buc = p;

        /* keep count */
        nsymbols++;
    }

    return p;
}


char *symbol_getname(struct symbol *p)
{
    return p->name;
}


void symbol_setindex(struct symbol *p, int i)
{
    p->index = i;
}


int symbol_getindex(struct symbol *p)
{
    return p->index;
}


int symbol_count()
{
    return nsymbols;
}

void symbol_set_seen(struct symbol *p, int stmt)
{
    if (p->first_seen == -1)
        p->first_seen = p->last_seen = stmt;
    else if (p->first_seen > stmt)
        p->first_seen = stmt;
    else if (p->last_seen < stmt)
        p->last_seen = stmt;
}

int live_range_is_overlapping(struct symbol *p, struct symbol *q)
{
    return !(p->last_seen < q->first_seen || q->last_seen < p->first_seen);
}



/* iterator class */
struct symbol_iter {
    int bucket;
    struct symbol *cur;
};

struct symbol_iter *new_symbol_iter()
{
    struct symbol_iter *p = (struct symbol_iter *)emalloc(sizeof(struct symbol_iter));
    p->bucket = -1;
    p->cur = NULL;
    return p;
}

struct symbol *first_symbol(struct symbol_iter *p)
{
    p->bucket = -1;
    p->cur = NULL;
    return next_symbol(p);
}

struct symbol *next_symbol(struct symbol_iter *p)
{
    if (p->cur)
        p->cur = p->cur->next;
    if (!p->cur) {
        while (++p->bucket < HASHSIZE && !(p->cur = bucket[p->bucket]))
            ;
    }
    return p->cur;
}