home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / ispell-4.0-src.lha / ispell-4.0 / access.c next >
C/C++ Source or Header  |  1993-06-01  |  14KB  |  738 lines
  1. /* Copyright (C) 1990, 1993 Free Software Foundation, Inc.
  2.  
  3.    This file is part of GNU ISPELL.
  4.  
  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 2, or (at your option)
  8.    any later version.
  9.  
  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU General Public License
  16.    along with this program; if not, write to the Free Software
  17.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include <stdio.h>
  20.  
  21. #ifdef HAVE_MALLOC_H
  22. #include <malloc.h>
  23. #endif
  24.  
  25. #include "ispell.h"
  26. #include "hash.h"
  27. #include "build.h"
  28. #include "good.h"
  29.  
  30. #ifdef __STDC__
  31.  
  32. void lexload (FILE *, unsigned long);
  33. int lexsize (void);
  34. void set_bitvec (unsigned char *, unsigned short);
  35. void lexdump (FILE *);
  36.  
  37. #else
  38.  
  39. extern void lexload ();
  40. extern int lexsize ();
  41. extern void lexdump ();
  42. extern void set_bitvec ();
  43.  
  44. #endif
  45.  
  46.  
  47. hash_index hashsize;
  48.  
  49. #ifndef min
  50. #define min(a,b) ((a) < (b) ? (a) : (b))
  51. #endif
  52.  
  53. /* there are 3 tables:
  54.  *
  55.  * all are addressed by unsigned shorts
  56.  *  htbl  hashsize hash table entries
  57.  *  ftbl  hashsize flag entries
  58.  *  stbl  <= 64K bytes of strings
  59.  */
  60. #if iAPX286 && (LARGE_M || HUGE_M)
  61. #define SMALL
  62. #endif
  63. #ifdef SMALL
  64. #define MAXMALLOC 32768
  65.  
  66. struct hash_table_entry **htbls;
  67. /* number of whole hash_table_entries that fit in a table */
  68. #define HTE_PER_TABLE ((MAXMALLOC-1) / sizeof (struct hash_table_entry))
  69. #if 0
  70. struct hash_table_entry *
  71. find_hte (h)
  72.      hash_index h;
  73. {
  74.   unsigned short tbl;
  75.   unsigned short off;
  76.   tbl = h / HTE_PER_TABLE;
  77.   off = h % HTE_PER_TABLE;
  78.  
  79.   return (htbls[tbl] + off);
  80. }
  81.  
  82. #endif
  83. #define H_TO_HTE(h) (htbls[(h)/HTE_PER_TABLE] + ((h)%HTE_PER_TABLE))
  84.  
  85. unsigned short **ftbls;
  86. #define FLAGS_PER_TABLE ((MAXMALLOC-1) / sizeof (unsigned short))
  87. #if 0
  88. unsigned short *
  89. find_flags (h)
  90.      hash_index h;
  91. {
  92.   unsigned short tbl;
  93.   unsigned short off;
  94.   tbl = h / FLAGS_PER_TABLE;
  95.   off = h % FLAGS_PER_TABLE;
  96.   return (ftbls[tbl] + off);
  97. }
  98.  
  99. #endif
  100. #define H_TO_FLAGS(h) (ftbls[(h)/FLAGS_PER_TABLE] + ((h)%FLAGS_PER_TABLE))
  101.  
  102. comp_char **stbls;
  103. #define BYTES_PER_TABLE MAXMALLOC
  104. #if 0
  105. comp_char *
  106. find_string (index)
  107.      str_index index;
  108. {
  109.   unsigned short tbl;
  110.   unsigned short off;
  111.   tbl = index / BYTES_PER_TABLE;
  112.   off = index % BYTES_PER_TABLE;
  113.   return (stbls[tbl] + off);
  114. }
  115.  
  116. #endif
  117. #define INDEX_TO_STRING(index) (stbls[(index)/BYTES_PER_TABLE]+((index)%BYTES_PER_TABLE))
  118. #else
  119. #undef SMALL
  120. struct hash_table_entry *htbl;
  121. unsigned short *ftbl;
  122. comp_char *stbl;
  123.  
  124. #define H_TO_HTE(h) (htbl + (h))
  125. #define H_TO_FLAGS(h) (ftbl + (h))
  126. #define INDEX_TO_STRING(index) (stbl + (index))
  127. #endif
  128.  
  129. #define HASH_NEXT(h) (H_TO_HTE(h)->next)
  130. #define HASH_EMPTY_P(h) (H_TO_HTE(h)->next == HASH_EMPTY)
  131.  
  132. struct hash_table_entry proto_hte;
  133.  
  134. static str_index stbl_size;
  135. static str_index stbl_index;
  136.  
  137. char *
  138. alloc (n)
  139.   unsigned int n;
  140. {
  141.   char *p;
  142.   p = (char *) xcalloc (n, 1);
  143.   return (p);
  144. }
  145.  
  146. void
  147. alloc_tables (hsize, ssize)
  148.   unsigned long hsize, ssize;
  149. {
  150.   hash_index h;
  151. #ifdef SMALL
  152.   unsigned short u, x;
  153.   int i;
  154. #endif
  155.  
  156.   stbl_size = ssize;
  157.   stbl_index = 0;
  158.  
  159. #ifdef SMALL
  160.   u = (ssize + BYTES_PER_TABLE - 1) / BYTES_PER_TABLE;
  161.   stbls = (comp_char **) alloc (u * sizeof (comp_char *));
  162.   u = ssize;
  163.   i = 0;
  164.   while (u != 0)
  165.     {
  166.       x = min (u, BYTES_PER_TABLE);
  167.       stbls[i] = (comp_char *) alloc (x);
  168.       u -= x;
  169.       i++;
  170.     }
  171.   u = (hsize + FLAGS_PER_TABLE - 1) / FLAGS_PER_TABLE;
  172.   ftbls = (unsigned short **) alloc (u * sizeof (unsigned short *));
  173.   u = hsize;
  174.   i = 0;
  175.   while (u != 0)
  176.     {
  177.       x = min (u, FLAGS_PER_TABLE);
  178.       ftbls[i] = (unsigned short *) alloc (x * sizeof (unsigned short));
  179.       u -= x;
  180.       i++;
  181.     }
  182.   u = (hsize + HTE_PER_TABLE - 1) / HTE_PER_TABLE;
  183.   htbls = (struct hash_table_entry **)
  184.     alloc (u * sizeof (struct hash_table_entry *));
  185.   u = hsize;
  186.   i = 0;
  187.   while (u != 0)
  188.     {
  189.       x = min (u, HTE_PER_TABLE);
  190.       htbls[i] = (struct hash_table_entry *)
  191.     alloc (x * sizeof (struct hash_table_entry));
  192.       u -= x;
  193.       i++;
  194.     }
  195. #else
  196.   htbl = (struct hash_table_entry *)
  197.     alloc ((unsigned) (hsize * sizeof proto_hte));
  198.   ftbl = (unsigned short *)
  199.     alloc ((unsigned) (hsize * sizeof (unsigned short)));
  200.   stbl = (comp_char *) alloc ((unsigned) ssize);
  201. #endif
  202.  
  203.   for (h = 0; h < hsize; h++)
  204.     HASH_NEXT (h) = HASH_EMPTY;
  205. }
  206.  
  207. str_index
  208. copy_out_string (s, n)
  209.   comp_char *s;
  210.   int n;
  211. {
  212.   str_index index;
  213.   comp_char *cp;
  214.  
  215. #ifdef SMALL
  216.   unsigned short t1, t2;
  217.   t1 = stbl_index / BYTES_PER_TABLE;
  218.   t2 = (stbl_index + n) / BYTES_PER_TABLE;
  219.   if (t1 != t2)
  220.     stbl_index += BYTES_PER_TABLE - stbl_index % BYTES_PER_TABLE;
  221. #endif
  222.   if (stbl_index + n > stbl_size)
  223.     {
  224.       (void) fprintf (stderr, "string table overflow\n");
  225.       exit (1);
  226.     }
  227.  
  228.   index = stbl_index;
  229.   stbl_index += n;
  230.  
  231.   cp = INDEX_TO_STRING (index);
  232.   while (n--)
  233.     *cp++ = *s++;
  234.  
  235.   return (index);
  236. }
  237.  
  238. /* returns index of end of chain */
  239. hash_index
  240. hash_find_end (index)
  241.      hash_index index;
  242. {
  243.   hash_index next, cur;
  244.  
  245.   for (cur = index, next = HASH_NEXT (index);
  246.        next < HASH_SPECIAL;
  247.        cur = next, next = HASH_NEXT (next))
  248.     ;
  249.   return (cur);
  250. }
  251.  
  252. /* clobbers whatever is there */
  253. void
  254. hash_store (index, htep)
  255.   hash_index index;
  256.   struct hash_table_entry *htep;
  257. {
  258.   *H_TO_HTE (index) = *htep;
  259. }
  260.  
  261. void
  262. hash_retrieve (index, htep)
  263.   hash_index index;
  264.   struct hash_table_entry *htep;
  265. {
  266.   *htep = *H_TO_HTE (index);
  267. }
  268.  
  269. /* updates the next field */
  270. void
  271. hash_set_next (index, new_next)
  272.   hash_index index;
  273.   hash_index new_next;
  274. {
  275.   if (new_next < HASH_SPECIAL && new_next >= hashsize)
  276.     {
  277.       (void) fprintf (stderr, "bad index to set_next %x\n", new_next);
  278.       exit (1);
  279.     }
  280.   HASH_NEXT (index) = new_next;
  281. }
  282.  
  283. int
  284. hash_emptyp (h)
  285.   hash_index h;
  286. {
  287.   return (HASH_EMPTY_P (h));
  288. }
  289.  
  290. void
  291. store_flags (hindex, flags)
  292.      hash_index hindex;
  293.      unsigned short flags;
  294. {
  295.   *H_TO_FLAGS (hindex) = flags;
  296. }
  297.  
  298.  
  299. int
  300. hash_init (name)
  301.   char *name;
  302. {
  303.   FILE *in;
  304.   struct hash_header hhdr;
  305.   int i, j, c, bit;
  306. #ifdef SMALL
  307.   hash_index h;
  308.   unsigned short flags;
  309.   unsigned short u;
  310.   unsigned short x;
  311.   struct hash_table_entry hte;
  312.   long l;
  313. #endif
  314. #ifdef MSDOS
  315.   if ((in = fopen (name, "rb")) == NULL)
  316.     return (-1);
  317. #else
  318.   if ((in = fopen (name, "r")) == NULL)
  319.     return (-1);
  320. #endif
  321.   if (fread ((char *) &hhdr, (int) sizeof hhdr, 1, in) != 1)
  322.     goto bad;
  323.  
  324.   if (hhdr.magic != HMAGIC)
  325.     goto bad;
  326.   if (hhdr.version != VERSION)
  327.     {
  328.       (void) fprintf (stderr,
  329.               "ispell: wanted dict version %d, got %d\n",
  330.               VERSION, hhdr.version);
  331.       goto bad;
  332.     }
  333.  
  334.   for (i = 0; i < 32; i++)
  335.     {
  336.       for (j = 0, bit = 1; j < 8; j++, bit <<= 1)
  337.     {
  338.       if (hhdr.used[i] & bit)
  339.         {
  340.           c = i * 8 + j;
  341.           if (near_map[c] == 0)
  342.         near_miss_letters[nnear_miss_letters++]
  343.           = c;
  344.         }
  345.     }
  346.     }
  347.  
  348.   lexload (in, hhdr.lexletters);
  349.  
  350.   if (ftell (in) != sizeof hhdr + hhdr.lexsize)
  351.     {
  352.       (void) fprintf (stderr, "bad dictionary file\n");
  353.       exit (1);
  354.     }
  355.  
  356.   hashsize = hhdr.hashsize;
  357.   alloc_tables (hhdr.hashsize, hhdr.stblsize);
  358.  
  359. #ifdef SMALL
  360.   l = (long) hashsize *sizeof hte;
  361.   i = 0;
  362.   while (l != 0)
  363.     {
  364.       x = min (l, HTE_PER_TABLE * sizeof hte);
  365.       if (fread ((char *) htbls[i], 1, (int) x, in) != (int) x)
  366.     goto bad;
  367.       l -= x;
  368.       i++;
  369.     }
  370.   l = (long) hashsize *sizeof flags;
  371.   i = 0;
  372.   while (l != 0)
  373.     {
  374.       x = min (l, FLAGS_PER_TABLE * sizeof flags);
  375.       if (fread ((char *) ftbls[i], 1, (int) x, in) != (int) x)
  376.     goto bad;
  377.       l -= x;
  378.       i++;
  379.     }
  380.   u = stbl_size;
  381.   i = 0;
  382.   while (u != 0)
  383.     {
  384.       x = min (u, BYTES_PER_TABLE);
  385.       if (fread ((char *) stbls[i], 1, (int) x, in) != (int) x)
  386.     goto bad;
  387.       u -= x;
  388.       i++;
  389.     }
  390. #else
  391.   if (fread ((char *) htbl, (int) sizeof *htbl, (int) hashsize, in) !=
  392.       (int) hashsize)
  393.     goto bad;
  394.   if (fread ((char *) ftbl, (int) sizeof *ftbl, (int) hashsize, in) !=
  395.       (int) h