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

Diff for /mandoc/mandocdb.c between version 1.64 and 1.65

version 1.64, 2013/06/06 17:51:31 version 1.65, 2013/06/06 19:00:28
Line 130  static void  dbprune(void);
Line 130  static void  dbprune(void);
 static  void     fileadd(struct of *);  static  void     fileadd(struct of *);
 static  int      filecheck(const char *);  static  int      filecheck(const char *);
 static  void     filescan(const char *);  static  void     filescan(const char *);
 static  struct str *hashget(const char *, size_t);  
 static  void    *hash_alloc(size_t, void *);  static  void    *hash_alloc(size_t, void *);
 static  void     hash_free(void *, size_t, void *);  static  void     hash_free(void *, size_t, void *);
 static  void    *hash_halloc(size_t, void *);  static  void    *hash_halloc(size_t, void *);
Line 312  int
Line 311  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         int               ch, i;          int               ch, i;
         unsigned int      index;          unsigned int      slot;
         size_t            j, sz;          size_t            j, sz;
         const char       *path_arg;          const char       *path_arg;
         struct str       *s;          struct str       *s;
Line 493  out:
Line 492  out:
         manpath_free(&dirs);          manpath_free(&dirs);
         mchars_free(mc);          mchars_free(mc);
         mparse_free(mp);          mparse_free(mp);
         for (s = ohash_first(&strings, &index);          for (s = ohash_first(&strings, &slot); NULL != s;
                         NULL != s; s = ohash_next(&strings, &index)) {               s = ohash_next(&strings, &slot)) {
                 if (s->utf8 != s->key)                  if (s->utf8 != s->key)
                         free(s->utf8);                          free(s->utf8);
                 free(s);                  free(s);
Line 784  filescan(const char *file)
Line 783  filescan(const char *file)
 static int  static int
 filecheck(const char *name)  filecheck(const char *name)
 {  {
         unsigned int     index;  
   
         index = ohash_qlookup(&filenames, name);          return(NULL != ohash_find(&filenames,
         return(NULL != ohash_find(&filenames, index));                          ohash_qlookup(&filenames, name)));
 }  }
   
 /*  /*
Line 797  filecheck(const char *name)
Line 795  filecheck(const char *name)
 static void  static void
 fileadd(struct of *of)  fileadd(struct of *of)
 {  {
         unsigned int     index;          unsigned int     slot;
   
         index = ohash_qlookup(&filenames, of->file);          slot = ohash_qlookup(&filenames, of->file);
         assert(NULL == ohash_find(&filenames, index));          assert(NULL == ohash_find(&filenames, slot));
         ohash_insert(&filenames, index, of);          ohash_insert(&filenames, slot, of);
 }  }
   
 /*  /*
Line 812  inocheck(const struct stat *st)
Line 810  inocheck(const struct stat *st)
 {  {
         struct id        id;          struct id        id;
         uint32_t         hash;          uint32_t         hash;
         unsigned int     index;  
   
         memset(&id, 0, sizeof(id));          memset(&id, 0, sizeof(id));
         id.ino = hash = st->st_ino;          id.ino = hash = st->st_ino;
         id.dev = st->st_dev;          id.dev = st->st_dev;
         index = ohash_lookup_memory  
                 (&inos, (char *)&id, sizeof(id), hash);  
   
         return(NULL != ohash_find(&inos, index));          return(NULL != ohash_find(&inos, ohash_lookup_memory(
                           &inos, (char *)&id, sizeof(id), hash)));
 }  }
   
 /*  /*
Line 832  static void
Line 828  static void
 inoadd(const struct stat *st, struct of *of)  inoadd(const struct stat *st, struct of *of)
 {  {
         uint32_t         hash;          uint32_t         hash;
         unsigned int     index;          unsigned int     slot;
   
         of->id.ino = hash = st->st_ino;          of->id.ino = hash = st->st_ino;
         of->id.dev = st->st_dev;          of->id.dev = st->st_dev;
         index = ohash_lookup_memory          slot = ohash_lookup_memory
                 (&inos, (char *)&of->id, sizeof(of->id), hash);                  (&inos, (char *)&of->id, sizeof(of->id), hash);
   
         assert(NULL == ohash_find(&inos, index));          assert(NULL == ohash_find(&inos, slot));
         ohash_insert(&inos, index, of);          ohash_insert(&inos, slot, of);
 }  }
   
 static void  static void
Line 1547  static char *
Line 1543  static char *
 stradds(const char *cp, size_t sz)  stradds(const char *cp, size_t sz)
 {  {
         struct str      *s;          struct str      *s;
         unsigned int     index;          unsigned int     slot;
         const char      *end;          const char      *end;
   
         if (NULL != (s = hashget(cp, sz)))          end = cp + sz;
           slot = ohash_qlookupi(&strings, cp, &end);
           if (NULL != (s = ohash_find(&strings, slot)))
                 return(s->key);                  return(s->key);
   
         s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);          s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);
         memcpy(s->key, cp, sz);          memcpy(s->key, cp, sz);
           ohash_insert(&strings, slot, s);
         end = cp + sz;  
         index = ohash_qlookupi(&strings, cp, &end);  
         assert(NULL == ohash_find(&strings, index));  
         ohash_insert(&strings, index, s);  
         return(s->key);          return(s->key);
 }  }
   
 static struct str *  
 hashget(const char *cp, size_t sz)  
 {  
         unsigned int     index;  
         const char      *end;  
   
         end = cp + sz;  
         index = ohash_qlookupi(&strings, cp, &end);  
         return(ohash_find(&strings, index));  
 }  
   
 /*  /*
  * Add a word to the current parse sequence.   * Add a word to the current parse sequence.
  * Within the hashtable of strings, we maintain a list of strings that   * Within the hashtable of strings, we maintain a list of strings that
Line 1587  static void
Line 1570  static void
 putkeys(const struct of *of, const char *cp, size_t sz, uint64_t v)  putkeys(const struct of *of, const char *cp, size_t sz, uint64_t v)
 {  {
         struct str      *s;          struct str      *s;
         unsigned int     index;          unsigned int     slot;
         const char      *end;          const char      *end;
   
         if (0 == sz)          if (0 == sz)
                 return;                  return;
   
         s = hashget(cp, sz);          end = cp + sz;
           slot = ohash_qlookupi(&strings, cp, &end);
           s = ohash_find(&strings, slot);
   
         if (NULL != s && of == s->of) {          if (NULL != s && of == s->of) {
                 s->mask |= v;                  s->mask |= v;
Line 1601  putkeys(const struct of *of, const char *cp, size_t sz
Line 1586  putkeys(const struct of *of, const char *cp, size_t sz
         } else if (NULL == s) {          } else if (NULL == s) {
                 s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);                  s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);
                 memcpy(s->key, cp, sz);                  memcpy(s->key, cp, sz);
                 end = cp + sz;                  ohash_insert(&strings, slot, s);
                 index = ohash_qlookupi(&strings, cp, &end);  
                 assert(NULL == ohash_find(&strings, index));  
                 ohash_insert(&strings, index, s);  
         }          }
   
         s->next = words;          s->next = words;
Line 1791  dbindex(struct mchars *mc, int form, const struct of *
Line 1773  dbindex(struct mchars *mc, int form, const struct of *
   
         desc = "";          desc = "";
         if (NULL != of->desc) {          if (NULL != of->desc) {
                 key = hashget(of->desc, strlen(of->desc));                  key = ohash_find(&strings,
                           ohash_qlookup(&strings, of->desc));
                 assert(NULL != key);                  assert(NULL != key);
                 if (NULL == key->utf8)                  if (NULL == key->utf8)
                         utf8key(mc, key);                          utf8key(mc, key);
Legend:
Removed from v.1.64  
changed lines
  Added in v.1.65
CVSweb