home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Elysian Archive
/
AmigaElysianArchive.iso
/
wp_dtp
/
ispell.lha
/
buildhash.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-12-28
|
11KB
|
582 lines
/*
* buildhash.c - make a hash table for ispell
*
* Pace Willisson, 1983
*/
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <proto/all.h>
#include "config.h"
#include "ispell.h"
char rootword[BUFSIZ];
struct dent *lastdent;
char *hashstrings;
struct hashheader hashheader;
char tempfile[200];
#define NSTAT 100
int numwords, hashsize;
struct dent *hashtbl;
char *Dfile;
char *Hfile;
char Cfile[MAXPATHLEN];
char Sfile[MAXPATHLEN];
void main (int argc, char **argv)
{
FILE *countf;
FILE *statf;
int stats[NSTAT];
int i;
if (argc > 1)
{
++argv;
Dfile = *argv;
if (argc > 2)
{
++argv;
Hfile = *argv;
}
else
Hfile = DEFHASH;
}
else
{
Dfile = DEFDICT;
Hfile = DEFHASH;
}
sprintf (Cfile, "%s.cnt", Dfile);
sprintf (Sfile, "%s.stat", Dfile);
if (access (Dfile, 2) < 0)
{
fprintf (stderr, "No dictionary (%s)\n", Dfile);
exit (1);
}
if (access (Cfile, 2) < 0)
newcount ();
if ((countf = fopen (Cfile, "r")) == NULL)
{
fprintf (stderr, "No count file\n");
exit (1);
}
numwords = 0;
fscanf (countf, "%d", &numwords);
fclose (countf);
if (numwords == 0)
{
fprintf (stderr, "Bad count file\n");
exit (1);
}
hashsize = numwords;
readdict ();
if ((statf = fopen (Sfile, "w")) == NULL)
{
fprintf (stderr, "Can't create %s\n", Sfile);
exit (1);
}
for (i = 0; i < NSTAT; i++)
stats[i] = 0;
for (i = 0; i < hashsize; i++)
{
struct dent *dp;
int j;
if (hashtbl[i].used == 0)
{
stats[0]++;
}
else
{
for (j = 1, dp = &hashtbl[i]; dp->next != NULL; j++, dp = dp->next)
;
if (j >= NSTAT)
j = NSTAT - 1;
stats[j]++;
}
}
for (i = 0; i < NSTAT; i++)
fprintf (statf, "%d: %d\n", i, stats[i]);
fclose (statf);
filltable ();
output ();
exit (0);
}
void output (void)
{
FILE *outfile;
struct hashheader hashheader;
int strptr, n, i;
if ((outfile = fopen (Hfile, "w")) == NULL)
{
fprintf (stderr, "can't create %s\n", Hfile);
return;
}
hashheader.magic = MAGIC;
hashheader.stringsize = 0;
hashheader.tblsize = hashsize;
fwrite ((char *)&hashheader, sizeof (hashheader), 1, outfile);
strptr = 0;
for (i = 0; i < hashsize; i++)
{
n = strlen (hashtbl[i].word) + 1;
#ifdef CAPITALIZE
if (hashtbl[i].followcase)
n += (hashtbl[i].word[n] & 0xFF) * (n + 1) + 1;
#endif
fwrite (hashtbl[i].word, n, 1, outfile);
hashtbl[i].word = (char *) strptr;
strptr += n;
}
/* Pad file to a struct dent boundary for efficiency. */
n = (strptr + sizeof hashheader) % sizeof (struct dent);
if (n != 0)
{
n = sizeof (struct dent) - n;
strptr += n;
while (--n >= 0)
putc ('\0', outfile);
}
for (i = 0; i < hashsize; i++)
{
if (hashtbl[i].next != 0)
{
int x;
x = hashtbl[i].next - hashtbl;
hashtbl[i].next = (struct dent *) x;
}
else
{
hashtbl[i].next = (struct dent *) - 1;
}
}
fwrite ((char *)hashtbl, sizeof (struct dent), hashsize, outfile);
hashheader.stringsize = strptr;
rewind (outfile);
fwrite ((char *)&hashheader, sizeof (hashheader), 1, outfile);
fclose (outfile);
}
void filltable (void)
{
struct dent *freepointer, *nextword, *dp;
int i;
for (freepointer = hashtbl; freepointer->used; freepointer++)
;
for (nextword = hashtbl, i = numwords; i != 0; nextword++, i--)
{
if (nextword->used == 0)
{
continue;
}
if (nextword->next == NULL)
{
continue;
}
if (nextword->next >= hashtbl && nextword->next < hashtbl + hashsize)
{
continue;
}
dp = nextword;
while (dp->next)
{
if (freepointer > hashtbl + hashsize)
{
fprintf (stderr, "table overflow\n");
getchar ();
break;
}
*freepointer = *(dp->next);
dp->next = freepointer;
dp = freepointer;
while (freepointer->used)
freepointer++;
}
}
}
void readdict (void)
{
struct dent d;
register struct dent *dp;
char lbuf[100];
FILE *dictf;
int i;
int h;
int len;
register char *p;
if ((dictf = fopen (Dfile, "r")) == NULL)
{
fprintf (stderr, "Can't open dictionary\n");
exit (1);
}
hashtbl = (struct dent *) calloc (numwords, sizeof (struct dent));
if (hashtbl == NULL)
{
fprintf (stderr, "couldn't allocate hash table\n");
exit (1);
}
i = 0;
while (fgets (lbuf, sizeof lbuf, dictf) != NULL)
{
if ((i & 1023) == 0)
{
printf ("%d ", i);
fflush (stdout);
}
i++;
p = &lbuf[strlen (lbuf) - 1];
if (*p == '\n')
*p = 0;
if (makedent (lbuf, &d) < 0)
continue;
len = strlen (lbuf);
#ifdef CAPITALIZE
if (d.followcase)
d.word = malloc (2 * len + 4);
else
d.word = malloc (len + 1);
#else
d.word = malloc (len + 1);
#endif
if (d.word == NULL)
{
fprintf (stderr, "couldn't allocate space for word %s\n", lbuf);
exit (1);
}
strcpy (d.word, lbuf);
#ifdef CAPITALIZE
if (d.followcase)
{
p = d.word + len + 1;
*p++ = 1; /* Count of capitalizations */
*p++ = '-'; /* Don't keep in pers dict */
strcpy (p, lbuf);
}
for (p = d.word; *p; p++)
{
if (mylower (*p))
*p = toupper (*p);
}
#endif
h = hash (d.word, len, hashsize);
dp = &hashtbl[h];
if (dp->used == 0)
{
*dp = d;
}
else
{
#ifdef CAPITALIZE
while (dp != NULL && strcmp (dp->word, d.word) != 0)
dp = dp->next;
if (dp != NULL)
{
if (d.followcase
|| (dp->followcase && !d.allcaps
&& !d.capitalize))
{
/* Add a specific capitalization */
if (dp->followcase)
{
p = &dp->word[len + 1];
(*p)++; /* Bump counter */
dp->word = realloc (dp->word,
((*p & 0xFF) + 1) * (len + 2));
if (dp->word == NULL)
{
fprintf (stderr,
"couldn't allocate space for word %s\n",
lbuf);
exit (1);
}
p = &dp->word[len + 1];
p += ((*p & 0xFF) - 1) * (len + 2) + 1;
*p++ = '-';
strcpy (p,
d.followcase ? &d.word[len + 3] : lbuf);
}
else
{
/* d.followcase must be true */
/* thus, d.capitalize and d.allcaps are */
/* clear */
free (dp->word);
dp->word = d.word;
dp->followcase = 1;
dp->k_followcase = 1;
/* Code later will clear dp->allcaps. */
}
}
/* Combine two capitalizations. If d was */
/* allcaps, dp remains unchanged */
if (d.allcaps == 0)
{
/* dp is the entry that will be kept. If */
/* dp is followcase, the capitalize flag */
/* reflects whether capitalization "may" */
/* occur. If not, it reflects whether it */
/* "must" occur. */
if (d.capitalize)
{ /* ie lbuf was cap'd */
if (dp->followcase)
dp->capitalize = 1; /* May */
else if (dp->allcaps) /* ie not lcase */
dp->capitalize = 1; /* Must */
}
else
{ /* lbuf was followc or all-lc */
if (!dp->followcase)
dp->capitalize = 0; /* May */
}
dp->k_capitalize = dp->capitalize;
dp->allcaps = 0;
dp->k_allcaps = 0;
}
}
else
{
#endif
dp = (struct dent *) malloc (sizeof (struct dent));
if (dp == NULL)
{
fprintf (stderr,
"couldn't allocate space for collision\n");
exit (1);
}
*dp = d;
dp->next = hashtbl[h].next;
hashtbl[h].next = dp;
}
}
#ifdef CAPITALIZE
}
#endif
printf ("\n");
}
/*
* fill in the flags in d, and put a null after the word in s
*/
int makedent (char *lbuf, struct dent *d)
{
char *p;
d->next = NULL;
d->used = 1;
d->v_flag = 0;
d->n_flag = 0;
d->x_flag = 0;
d->h_flag = 0;
d->y_flag = 0;
d->g_flag = 0;
d->j_flag = 0;
d->d_flag = 0;
d->t_flag = 0;
d->r_flag = 0;
d->z_flag = 0;
d->s_flag = 0;
d->p_flag = 0;
d->m_flag = 0;
d->keep = 0;
#ifdef CAPITALIZE
d->allcaps = 0;
d->capitalize = 0;
d->followcase = 0;
/*
** Figure out the capitalization rules from the capitalization of
** the sample entry. Only one of followcase, allcaps, and capitalize
** will be set. Combinations are generated by higher-level code.
*/
for (p = lbuf; *p && *p != '/'; p++)
{
if (mylower (*p))
break;
}
if (*p == '\0' || *p == '/')
d->allcaps = 1;
else
{
for (; *p && *p != '/'; p++)
{
if (myupper (*p))
break;
}
if (*p == '\0' || *p == '/')
{
/*
** No uppercase letters follow the lowercase ones.
** If the first two letters are capitalized, it's
** "followcase". If the first one is capitalized, it's
** "capitalize".
*/
if (myupper (lbuf[0]))
{
if (myupper (lbuf[1]))
d->followcase = 1;
else
d->capitalize = 1;
}
}
else
d->followcase = 1; /* .../lower/upper */
}
d->k_allcaps = d->allcaps;
d->k_capitalize = d->capitalize;
d->k_followcase = d->followcase;
#endif
p = strchr (lbuf, '/');
if (p != NULL)
*p = 0;
if (strlen (lbuf) > WORDLEN - 1)
{
printf ("%s: word too big\n", lbuf);
return (-1);
}
if (p == NULL)
return (0);
p++;
while (*p != '\0' && *p != '\n')
{
if (mylower (*p))
*p = toupper (*p);
switch (*p)
{
case 'V':
d->v_flag = 1;
break;
case 'N':
d->n_flag = 1;
break;
case 'X':
d->x_flag = 1;
break;
case 'H':
d->h_flag = 1;
break;
case 'Y':
d->y_flag = 1;
break;
case 'G':
d->g_flag = 1;
break;
case 'J':
d->j_flag = 1;
break;
case 'D':
d->d_flag = 1;
break;
case 'T':
d->t_flag = 1;
break;
case 'R':
d->r_flag = 1;
break;
case 'Z':
d->z_flag = 1;
break;
case 'S':
d->s_flag = 1;
break;
case 'P':
d->p_flag = 1;
break;
case 'M':
d->m_flag = 1;
break;
case 0:
fprintf (stderr, "no flags on word %s\n", lbuf);
continue;
default:
fprintf (stderr, "unknown flag %c word %s\n",
*p, lbuf);
break;
}
p++;
if (*p == '/') /* Handle old-format dictionaries too */
p++;
}
return (0);
}
void newcount (void)
{
char buf[200];
char lastbuf[200];
FILE *d;
int i;
register char *cp;
fprintf (stderr, "Counting words in dictionary ...\n");
if ((d = fopen (Dfile, "r")) == NULL)
{
fprintf (stderr, "Can't open dictionary\n");
exit (1);
}
for (i = 0, lastbuf[0] = '\0'; fgets (buf, sizeof buf, d);)
{
for (cp = buf; *cp; cp++)
{
if (mylower (*cp))
*cp = toupper (*cp);
}
if (strcmp (buf, lastbuf) != 0)
{
if ((++i & 1023) == 0)
{
printf ("%d ", i);
fflush (stdout);
}
strcpy (lastbuf, buf);
}
}
fclose (d);
printf ("\n%d words\n", i);
if ((d = fopen (Cfile, "w")) == NULL)
{
fprintf (stderr, "can't create %s\n", Cfile);
exit (1);
}
fprintf (d, "%d\n", i);
fclose (d);
}