source: vendor/flex/2.5.33/sym.c

/* sym - symbol table routines */

/*  Copyright (c) 1990 The Regents of the University of California. */
/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */
/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */
/*  to contract no. DE-AC03-76SF00098 between the United States */
/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */
/*  modification, are permitted provided that the following conditions */
/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */
/*     notice, this list of conditions and the following disclaimer. */
/*  2. Redistributions in binary form must reproduce the above copyright */
/*     notice, this list of conditions and the following disclaimer in the */
/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */
/*  may be used to endorse or promote products derived from this software */
/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/*  PURPOSE. */

#include "flexdef.h"

/* Variables for symbol tables:
 * sctbl - start-condition symbol table
 * ndtbl - name-definition symbol table
 * ccltab - character class text symbol table
 */

struct hash_entry {
        struct hash_entry *prev, *next;
        char   *name;
        char   *str_val;
        int     int_val;
};

typedef struct hash_entry **hash_table;

#define NAME_TABLE_HASH_SIZE 101
#define START_COND_HASH_SIZE 101
#define CCL_HASH_SIZE 101

static struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
static struct hash_entry *sctbl[START_COND_HASH_SIZE];
static struct hash_entry *ccltab[CCL_HASH_SIZE];


/* declare functions that have forward references */

static int addsym PROTO ((register char[], char *, int, hash_table, int));
static struct hash_entry *findsym PROTO ((register const char *sym,
                                          hash_table table,

                                          int table_size));
static int hashfunct PROTO ((register const char *, int));


/* addsym - add symbol and definitions to symbol table
 *
 * -1 is returned if the symbol already exists, and the change not made.
 */

static int addsym (sym, str_def, int_def, table, table_size)
     register char sym[];
     char   *str_def;
     int     int_def;
     hash_table table;
     int     table_size;
{
        int     hash_val = hashfunct (sym, table_size);
        register struct hash_entry *sym_entry = table[hash_val];
        register struct hash_entry *new_entry;
        register struct hash_entry *successor;

        while (sym_entry) {
                if (!strcmp (sym, sym_entry->name)) {   /* entry already exists */
                        return -1;
                }

                sym_entry = sym_entry->next;
        }

        /* create new entry */
        new_entry = (struct hash_entry *)
                flex_alloc (sizeof (struct hash_entry));

        if (new_entry == NULL)
                flexfatal (_("symbol table memory allocation failed"));

        if ((successor = table[hash_val]) != 0) {
                new_entry->next = successor;
                successor->prev = new_entry;
        }
        else
                new_entry->next = NULL;

        new_entry->prev = NULL;
        new_entry->name = sym;
        new_entry->str_val = str_def;
        new_entry->int_val = int_def;

        table[hash_val] = new_entry;

        return 0;
}


/* cclinstal - save the text of a character class */

void    cclinstal (ccltxt, cclnum)
     Char    ccltxt[];
     int     cclnum;
{
        /* We don't bother checking the return status because we are not
         * called unless the symbol is new.
         */

        (void) addsym ((char *) copy_unsigned_string (ccltxt),
                       (char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
}


/* ccllookup - lookup the number associated with character class text
 *
 * Returns 0 if there's no CCL associated with the text.
 */

int     ccllookup (ccltxt)
     Char    ccltxt[];
{
        return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
}


/* findsym - find symbol in symbol table */

static struct hash_entry *findsym (sym, table, table_size)
     register const char *sym;
     hash_table table;
     int     table_size;
{
        static struct hash_entry empty_entry = {
                (struct hash_entry *) 0, (struct hash_entry *) 0,
                (char *) 0, (char *) 0, 0,
        };
        register struct hash_entry *sym_entry =

                table[hashfunct (sym, table_size)];

        while (sym_entry) {
                if (!strcmp (sym, sym_entry->name))
                        return sym_entry;
                sym_entry = sym_entry->next;
        }

        return &empty_entry;
}


/* hashfunct - compute the hash value for "str" and hash size "hash_size" */

static int hashfunct (str, hash_size)
     register const char *str;
     int     hash_size;
{
        register int hashval;
        register int locstr;

        hashval = 0;
        locstr = 0;

        while (str[locstr]) {
                hashval = (hashval << 1) + (unsigned char) str[locstr++];
                hashval %= hash_size;
        }

        return hashval;
}


/* ndinstal - install a name definition */

void    ndinstal (name, definition)
     const char *name;
     Char    definition[];
{

        if (addsym (copy_string (name),
                    (char *) copy_unsigned_string (definition), 0,
                    ndtbl, NAME_TABLE_HASH_SIZE))
                        synerr (_("name defined twice"));
}


/* ndlookup - lookup a name definition
 *
 * Returns a nil pointer if the name definition does not exist.
 */

Char   *ndlookup (nd)
     const char *nd;
{
        return (Char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
}


/* scextend - increase the maximum number of start conditions */

void    scextend ()
{
        current_max_scs += MAX_SCS_INCREMENT;

        ++num_reallocs;

        scset = reallocate_integer_array (scset, current_max_scs);
        scbol = reallocate_integer_array (scbol, current_max_scs);
        scxclu = reallocate_integer_array (scxclu, current_max_scs);
        sceof = reallocate_integer_array (sceof, current_max_scs);
        scname = reallocate_char_ptr_array (scname, current_max_scs);
}


/* scinstal - make a start condition
 *
 * NOTE
 *    The start condition is "exclusive" if xcluflg is true.
 */

void    scinstal (str, xcluflg)
     const char *str;
     int     xcluflg;
{

        if (++lastsc >= current_max_scs)
                scextend ();

        scname[lastsc] = copy_string (str);

        if (addsym (scname[lastsc], (char *) 0, lastsc,
                    sctbl, START_COND_HASH_SIZE))
                        format_pinpoint_message (_
                                                 ("start condition %s declared twice"),
str);

        scset[lastsc] = mkstate (SYM_EPSILON);
        scbol[lastsc] = mkstate (SYM_EPSILON);
        scxclu[lastsc] = xcluflg;
        sceof[lastsc] = false;
}


/* sclookup - lookup the number associated with a start condition
 *
 * Returns 0 if no such start condition.
 */

int     sclookup (str)
     const char *str;
{
        return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
}