source: trunk/athena/bin/ispell/lookup.c @ 1102

/*
 * lookup.c - see if a word appears in the dictionary
 *
 * Pace Willisson, 1983
 */

#include <stdio.h>
#include "ispell.h"
#include "config.h"


struct dent *treelookup();
struct dent *hashtbl;
int hashsize;

extern char hashname[];

static inited = 0;

linit ()
{
        int hashfd;
        struct hashheader hashheader;
        register int i;
        register struct dent *dp;

        if (inited)
                return(-1);

        if ((hashfd = open (hashname, 0)) < 0) {
                fprintf (stderr, "can't open %s\r\n", hashname);
                return (-1);
        }

        hashsize = read (hashfd, &hashheader, sizeof hashheader);
        if (hashsize == 0) {
                /*
                 * Empty file - create an empty dummy table.  We
                 * actually have to have one entry since the hash
                 * algorithm involves a divide by the table size
                 * (actually modulo, but zero is still unacceptable).
                 * So we create an entry with a word of all lowercase,
                 * which can't match because the comparison string has
                 * been converted to uppercase by then.
                 */
                (void) close (hashfd);
                hashsize = 1;           /* This prevents divides by zero */
                hashtbl = (struct dent *) calloc (1, sizeof (struct dent));
                if (hashtbl == NULL) {
                        (void) fprintf (stderr,
                            "Couldn't allocate space for hash table\n");
                        return (-1);
                }
                hashtbl[0].word = "xxxxxxxxxxx";
                hashtbl[0].next = NULL;
                hashtbl[0].keep = 0;
                hashtbl[0].used = 1;
                /* The flag bits don't matter, but calloc cleared them. */
                inited = 1;
                return 0;
        }
        else if (hashsize < 0  ||  hashheader.magic != MAGIC) {
                fprintf (stderr, "Illegal format hash table\r\n");
                return (-1);
        }
        hashstrings = (char *) malloc (hashheader.stringsize);
        hashtbl = (struct dent *) malloc (hashheader.tblsize * sizeof (struct dent));
        if (hashtbl == NULL  ||  hashstrings == NULL) {
                (void) fprintf (stderr,
                    "Couldn't allocate space for hash table\n");
                return (-1);
        }
        hashsize = hashheader.tblsize;

        (void) read (hashfd, hashstrings, hashheader.stringsize);
        (void) read (hashfd, hashtbl, hashheader.tblsize * sizeof (struct dent));
        (void) close (hashfd);

        for (i = hashsize, dp = hashtbl;  --i >= 0;  dp++) {
                dp->word = &hashstrings [ (int)(dp->word) ];
                if (dp->next == (struct dent *) -1)
                        dp->next = NULL;
                else
                        dp->next = &hashtbl [ (int)(dp->next) ];
        }

        inited = 1;
        return (0);
}

/* n is length of s */
struct dent *
lookup (s, n, dotree)
register char *s;
{
        int i;
        register struct dent *dp;
        register char *s1, *s2;

        dp = &hashtbl [ hash (s, n, hashsize) ];
        for (  ; dp != NULL; dp = dp->next) {
                /* quick strcmp, but only for equality */
                s1 = dp->word;
                s2 = s;
                while (*s1 == *s2++)
                        if (*s1++=='\0') {
                                lastdent = dp;
                                return (lastdent);
                        }
        }
        if (dotree) {
                i = s[n];
                s[n] = '\0';
                if ((dp = treelookup (s)) != NULL)
                        lastdent = dp;
                s[n] = i;
                return dp;
        }
        else
                return NULL;
}