Subversion Repositories or1k

/*

 * sym.c -- Symbol Table module

 *

 * Copyright (c) GoAhead Software Inc., 1995-2000. All Rights Reserved.

 *

 * See the file "license.txt" for usage and redistribution license requirements

 */

/******************************** Description *********************************/

/*

 *      This module implements a highly efficient generic symbol table with

 *      update and access routines. Symbols are simple character strings and

 *      the values they take can be flexible types as defined by value_t.

 *      This modules allows multiple symbol tables to be created.

 */

/********************************* Includes ***********************************/

#if UEMF

        #include        "uemf.h"

#else

        #include        "basic/basicInternal.h"

#endif

/********************************* Defines ************************************/

typedef struct {                                                /* Symbol table descriptor */

        int             inuse;                                          /* Is this entry in use */

        int             hash_size;                                      /* Size of the table below */

        sym_t   **hash_table;                           /* Allocated at run time */

} sym_tabent_t;

/********************************* Globals ************************************/

static sym_tabent_t     **sym;                          /* List of symbol tables */

static int                      symMax;                         /* One past the max symbol table */

static int                      symOpenCount = 0;        /* Count of apps using sym */

static int                      htIndex;                        /* Current location in table */

static sym_t*           next;                           /* Next symbol in iteration */

/**************************** Forward Declarations ****************************/

static int              hashIndex(sym_tabent_t *tp, char_t *name);

static sym_t    *hash(sym_tabent_t *tp, char_t *name);

static int              calcPrime(int size);

/*********************************** Code *************************************/

/*

 *      Open the symbol table subSystem.

 */

int symSubOpen()

{

        if (++symOpenCount == 1) {

                symMax = 0;

                sym = NULL;

        }

        return 0;

}

/******************************************************************************/

/*

 *      Close the symbol table subSystem.

 */

void symSubClose()

{

        if (--symOpenCount <= 0) {

                symOpenCount = 0;

        }

}

/******************************************************************************/

/*

 *      Create a symbol table.

 */

sym_fd_t symOpen(int hash_size)

{

        sym_fd_t                sd;

        sym_tabent_t    *tp;

        a_assert(hash_size > 2);

/*

 *      Create a new handle for this symbol table

 */

        if ((sd = hAlloc((void***) &sym)) < 0) {

                return -1;

        }

/*

 *      Create a new symbol table structure and zero

 */

        if ((tp = (sym_tabent_t*) balloc(B_L, sizeof(sym_tabent_t))) == NULL) {

                symMax = hFree((void***) &sym, sd);

                return -1;

        }

        memset(tp, 0, sizeof(sym_tabent_t));

        if (sd >= symMax) {

                symMax = sd + 1;

        }

        a_assert(0 <= sd && sd < symMax);

        sym[sd] = tp;

/*

 *      Now create the hash table for fast indexing.

 */

        tp->hash_size = calcPrime(hash_size);

        tp->hash_table = (sym_t**) balloc(B_L, tp->hash_size * sizeof(sym_t*));

        a_assert(tp->hash_table);

        memset(tp->hash_table, 0, tp->hash_size * sizeof(sym_t*));

        return sd;

}

/******************************************************************************/

/*

 *      Close this symbol table. Call a cleanup function to allow the caller

 *      to free resources associated with each symbol table entry.

 */

void symClose(sym_fd_t sd)

{

        sym_tabent_t    *tp;

        sym_t                   *sp, *forw;

        int                             i;

        a_assert(0 <= sd && sd < symMax);

        tp = sym[sd];

        a_assert(tp);

/*

 *      Free all symbols in the hash table, then the hash table itself.

 */

        for (i = 0; i < tp->hash_size; i++) {

                for (sp = tp->hash_table[i]; sp; sp = forw) {

                        forw = sp->forw;

                        valueFree(&sp->name);

                        valueFree(&sp->content);

                        bfree(B_L, (void*) sp);

                        sp = forw;

                }

        }

        bfree(B_L, (void*) tp->hash_table);

        symMax = hFree((void***) &sym, sd);

        bfree(B_L, (void*) tp);

}

/******************************************************************************/

/*

 *      Return the first symbol in the hashtable if there is one. This call is used

 *      as the first step in traversing the table. A call to symFirst should be

 *      followed by calls to symNext to get all the rest of the entries.

 */

sym_t* symFirst(sym_fd_t sd)

{

        sym_tabent_t    *tp;

        sym_t                   *sp, *forw;

        int                             i;

        a_assert(0 <= sd && sd < symMax);

        tp = sym[sd];

        a_assert(tp);

/*

 *      Find the first symbol in the hashtable and return a pointer to it.

 */

        for (i = 0; i < tp->hash_size; i++) {

                for (sp = tp->hash_table[i]; sp; sp = forw) {

                        forw = sp->forw;

                        if (forw == NULL) {

                                htIndex = i + 1;

                                next = tp->hash_table[htIndex];

                        } else {

                                htIndex = i;

                                next = forw;

                        }

                        return sp;

                }

        }

        return NULL;

}

/******************************************************************************/

/*

 *      Return the next symbol in the hashtable if there is one. See symFirst.

 */

sym_t* symNext(sym_fd_t sd)

{

        sym_tabent_t    *tp;

        sym_t                   *sp, *forw;

        int                             i;

        a_assert(0 <= sd && sd < symMax);

        tp = sym[sd];

        a_assert(tp);

/*

 *      Find the first symbol in the hashtable and return a pointer to it.

 */

        for (i = htIndex; i < tp->hash_size; i++) {

                for (sp = next; sp; sp = forw) {

                        forw = sp->forw;

                        if (forw == NULL) {

                                htIndex = i + 1;

                                next = tp->hash_table[htIndex];

                        } else {

                                htIndex = i;

                                next = forw;

                        }

                        return sp;

                }

                next = tp->hash_table[i + 1];

        }

        return NULL;

}

/******************************************************************************/

/*

 *      Lookup a symbol and return a pointer to the symbol entry. If not present

 *      then return a NULL.

 */

sym_t *symLookup(sym_fd_t sd, char_t *name)

{

        sym_tabent_t    *tp;

        sym_t                   *sp;

        char_t                  *cp;

        a_assert(0 <= sd && sd < symMax);

        if ((tp = sym[sd]) == NULL) {

                return NULL;

        }

        if (name == NULL || *name == '\0') {

                return NULL;

        }

/*

 *      Do an initial hash and then follow the link chain to find the right entry

 */

        for (sp = hash(tp, name); sp; sp = sp->forw) {

                cp = sp->name.value.string;

                if (cp[0] == name[0] && gstrcmp(cp, name) == 0) {

                        break;

                }

        }

        return sp;

}

/******************************************************************************/

/*

 *      Enter a symbol into the table. If already there, update its value.

 *      Always succeeds if memory available. We allocate a copy of "name" here

 *      so it can be a volatile variable. The value "v" is just a copy of the

 *      passed in value, so it MUST be persistent.

 */

sym_t *symEnter(sym_fd_t sd, char_t *name, value_t v, int arg)

{

        sym_tabent_t    *tp;

        sym_t                   *sp, *last;

        char_t                  *cp;

        int                             hindex;

        a_assert(name);

        a_assert(0 <= sd && sd < symMax);

        tp = sym[sd];

        a_assert(tp);

/*

 *      Calculate the first daisy-chain from the hash table. If non-zero, then

 *      we have daisy-chain, so scan it and look for the symbol.

 */

        last = NULL;

        hindex = hashIndex(tp, name);

        if ((sp = tp->hash_table[hindex]) != NULL) {

                for (; sp; sp = sp->forw) {

                        cp = sp->name.value.string;

                        if (cp[0] == name[0] && gstrcmp(cp, name) == 0) {

                                break;

                        }

                        last = sp;

                }

                if (sp) {

/*

 *                      Found, so update the value

 *                      If the caller stores handles which require freeing, they

 *                      will be lost here. It is the callers responsibility to free

 *                      resources before overwriting existing contents. We will here

 *                      free allocated strings which occur due to value_instring().

 *                      We should consider providing the cleanup function on the open rather

 *                      than the close and then we could call it here and solve the problem.

 */

                        if (sp->content.valid) {

                                valueFree(&sp->content);

                        }

                        sp->content = v;

                        sp->arg = arg;

                        return sp;

                }

/*

 *              Not found so allocate and append to the daisy-chain

 */

                sp = (sym_t*) balloc(B_L, sizeof(sym_t));

                if (sp == NULL) {

                        return NULL;

                }

                sp->name = valueString(name, VALUE_ALLOCATE);

                sp->content = v;

                sp->forw = (sym_t*) NULL;

                sp->arg = arg;

                last->forw = sp;

        } else {

/*

 *              Daisy chain is empty so we need to start the chain

 */

                sp = (sym_t*) balloc(B_L, sizeof(sym_t));

                if (sp == NULL) {

                        return NULL;

                }

                tp->hash_table[hindex] = sp;

                tp->hash_table[hashIndex(tp, name)] = sp;

                sp->forw = (sym_t*) NULL;

                sp->content = v;

                sp->arg = arg;

                sp->name = valueString(name, VALUE_ALLOCATE);

        }

        return sp;

}

/******************************************************************************/

/*

 *      Delete a symbol from a table

 */

int symDelete(sym_fd_t sd, char_t *name)

{

        sym_tabent_t    *tp;

        sym_t                   *sp, *last;

        char_t                  *cp;

        int                             hindex;

        a_assert(name && *name);

        a_assert(0 <= sd && sd < symMax);

        tp = sym[sd];

        a_assert(tp);

/*

 *      Calculate the first daisy-chain from the hash table. If non-zero, then

 *      we have daisy-chain, so scan it and look for the symbol.

 */

        last = NULL;

        hindex = hashIndex(tp, name);

        if ((sp = tp->hash_table[hindex]) != NULL) {

                for ( ; sp; sp = sp->forw) {

                        cp = sp->name.value.string;

                        if (cp[0] == name[0] && gstrcmp(cp, name) == 0) {

                                break;

                        }

                        last = sp;

                }

        }

        if (sp == (sym_t*) NULL) {                              /* Not Found */

                return -1;

        }

/*

 *      Unlink and free the symbol. Last will be set if the element to be deleted

 *      is not first in the chain.

 */

        if (last) {

                last->forw = sp->forw;

        } else {

                tp->hash_table[hindex] = sp->forw;

        }

        valueFree(&sp->name);

        valueFree(&sp->content);

        bfree(B_L, (void*) sp);

        return 0;

}

/******************************************************************************/

/*

 *      Hash a symbol and return a pointer to the hash daisy-chain list

 *      All symbols reside on the chain (ie. none stored in the hash table itself)

 */

static sym_t *hash(sym_tabent_t *tp, char_t *name)

{

        a_assert(tp);

        return tp->hash_table[hashIndex(tp, name)];

}

/******************************************************************************/

/*

 *      Compute the hash function and return an index into the hash table

 *      We use a basic additive function that is then made modulo the size of the

 *      table.

 */

static int hashIndex(sym_tabent_t *tp, char_t *name)

{

        unsigned int    sum;

        int                             i;

        a_assert(tp);

/*

 *      Add in each character shifted up progressively by 7 bits. The shift

 *      amount is rounded so as to not shift too far. It thus cycles with each

 *      new cycle placing character shifted up by one bit.

 */

        i = 0;

        sum = 0;

        while (*name) {

                sum += (((int) *name++) << i);

                i = (i + 7) % (BITS(int) - BITSPERBYTE);

        }

        return sum % tp->hash_size;

}

/******************************************************************************/

/*

 *      Check if this number is a prime

 */

static int isPrime(int n)

{

        int             i, max;

        a_assert(n > 0);

        max = n / 2;

        for (i = 2; i <= max; i++) {

                if (n % i == 0) {

                        return 0;

                }

        }

        return 1;

}

/******************************************************************************/

/*

 *      Calculate the largest prime smaller than size.

 */

static int calcPrime(int size)

{

        int count;

        a_assert(size > 0);

        for (count = size; count > 0; count--) {

                if (isPrime(count)) {

                        return count;

                }

        }

        return 1;

}

/******************************************************************************/