[BACK]Return to mdoc_hash.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/Attic/mdoc_hash.c between version 1.8 and 1.9

version 1.8, 2009/07/20 20:49:22 version 1.9, 2009/09/16 14:40:56
Line 18 
Line 18 
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
   #include <limits.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <stdio.h>  #include <stdio.h>
 #include <string.h>  #include <string.h>
   
 #include "libmdoc.h"  #include "libmdoc.h"
   
 #define ADJUST_MAJOR(x)                                         \  static  unsigned char   table[27 * 12];
         do if (37 == (x))                                       \  
                 (x) = 0;                /* %   -> 00 */         \  
         else if (91 > (x))                                      \  
                 (x) -= 64;              /* A-Z -> 01 - 26 */    \  
         else                                                    \  
                 (x) -= 70;              /* a-z -> 27 - 52 */    \  
         while (/*CONSTCOND*/0)  
   
 #define ADJUST_MINOR(y)                                         \  
         do if (49 == (y))                                       \  
                 (y) = 0;                /* 1   -> 00 */         \  
         else if (91 > (y))                                      \  
                 (y) -= 65;              /* A-Z -> 00 - 25 */    \  
         else                                                    \  
                 (y) -= 97;              /* a-z -> 00 - 25 */    \  
         while (/*CONSTCOND*/0)  
   
 #define INDEX(maj, min)                                         \  
         ((maj) * 26 * 3) + ((min) * 3)  
   
 #define SLOTCMP(slot, val)                                      \  
         (mdoc_macronames[(slot)][0] == (val)[0] &&              \  
          mdoc_macronames[(slot)][1] == (val)[1] &&              \  
          (0 == (val)[2] ||                                      \  
           mdoc_macronames[(slot)][2] == (val)[2]))  
   
   
 void  void
 mdoc_hash_free(void *htab)  mdoc_hash_init(void)
 {  {
           int              i, j, major;
           const char      *p;
   
         free(htab);          memset(table, UCHAR_MAX, sizeof(table));
 }  
   
   
   
 void *  
 mdoc_hash_alloc(void)  
 {  
         int               i, major, minor, ind;  
         const void      **htab;  
   
         htab = calloc(26 * 3 * 52, sizeof(struct mdoc_macro *));  
         if (NULL == htab)  
                 return(NULL);  
   
         for (i = 0; i < MDOC_MAX; i++) {          for (i = 0; i < MDOC_MAX; i++) {
                 major = mdoc_macronames[i][0];                  p = mdoc_macronames[i];
                 assert(isalpha((u_char)major) || 37 == major);  
   
                 ADJUST_MAJOR(major);                  if (isalpha((u_char)p[1]))
                           major = 12 * (tolower((u_char)p[1]) - 97);
                   else
                           major = 12 * 26;
   
                 minor = mdoc_macronames[i][1];                  for (j = 0; j < 12; j++)
                 assert(isalpha((u_char)minor) || 49 == minor);                          if (UCHAR_MAX == table[major + j]) {
                                   table[major + j] = i;
                                   break;
                           }
   
                 ADJUST_MINOR(minor);                  assert(j < 12);
   
                 ind = INDEX(major, minor);  
   
                 if (NULL == htab[ind]) {  
                         htab[ind] = &mdoc_macros[i];  
                         continue;  
                 }  
   
                 if (NULL == htab[++ind]) {  
                         htab[ind] = &mdoc_macros[i];  
                         continue;  
                 }  
   
                 assert(NULL == htab[++ind]);  
                 htab[ind] = &mdoc_macros[i];  
         }          }
   
         return((void *)htab);  
 }  }
   
   
 int  int
 mdoc_hash_find(const void *arg, const char *tmp)  mdoc_hash_find(const char *p)
 {  {
         int               major, minor, ind, slot;          int               major, i, j;
         const void      **htab;  
   
         htab = /* LINTED */          if (0 == p[0])
                 (const void **)arg;  
   
         if (0 == (major = tmp[0]))  
                 return(MDOC_MAX);                  return(MDOC_MAX);
         if (0 == (minor = tmp[1]))          if ( ! isalpha((u_char)p[0]) && '%' != p[0])
                 return(MDOC_MAX);                  return(MDOC_MAX);
   
         if (tmp[2] && tmp[3])          if (isalpha((u_char)p[1]))
                   major = 12 * (tolower((u_char)p[1]) - 97);
           else if ('1' == p[1])
                   major = 12 * 26;
           else
                 return(MDOC_MAX);                  return(MDOC_MAX);
   
         if (37 != major && ! isalpha((u_char)major))          if (p[2] && p[3])
                 return(MDOC_MAX);                  return(MDOC_MAX);
         if (49 != minor && ! isalpha((u_char)minor))  
                 return(MDOC_MAX);  
   
         ADJUST_MAJOR(major);          for (j = 0; j < 12; j++) {
         ADJUST_MINOR(minor);                  if (UCHAR_MAX == (i = table[major + j]))
                           break;
         ind = INDEX(major, minor);                  if (0 == strcmp(p, mdoc_macronames[i]))
                           return(i);
         if (ind < 0 || ind >= 26 * 3 * 52)  
                 return(MDOC_MAX);  
   
         if (htab[ind]) {  
                 slot = htab[ind] - /* LINTED */  
                         (void *)mdoc_macros;  
                 assert(0 == (size_t)slot % sizeof(struct mdoc_macro));  
                 slot /= sizeof(struct mdoc_macro);  
                 if (SLOTCMP(slot, tmp))  
                         return(slot);  
                 ind++;  
         }          }
   
         if (htab[ind]) {  
                 slot = htab[ind] - /* LINTED */  
                         (void *)mdoc_macros;  
                 assert(0 == (size_t)slot % sizeof(struct mdoc_macro));  
                 slot /= sizeof(struct mdoc_macro);  
                 if (SLOTCMP(slot, tmp))  
                         return(slot);  
                 ind++;  
         }  
   
         if (NULL == htab[ind])  
                 return(MDOC_MAX);  
         slot = htab[ind] - /* LINTED */  
                 (void *)mdoc_macros;  
         assert(0 == (size_t)slot % sizeof(struct mdoc_macro));  
         slot /= sizeof(struct mdoc_macro);  
         if (SLOTCMP(slot, tmp))  
                 return(slot);  
   
         return(MDOC_MAX);          return(MDOC_MAX);
 }  }
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.9
CVSweb