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

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

version 1.65, 2013/06/06 19:00:28 version 1.66, 2013/06/07 01:01:34
Line 84  enum form {
Line 84  enum form {
 struct  str {  struct  str {
         char            *utf8; /* key in UTF-8 form */          char            *utf8; /* key in UTF-8 form */
         const struct of *of; /* if set, the owning parse */          const struct of *of; /* if set, the owning parse */
         struct str      *next; /* next in owning parse sequence */  
         uint64_t         mask; /* bitmask in sequence */          uint64_t         mask; /* bitmask in sequence */
         char             key[]; /* the string itself */          char             key[]; /* the string itself */
 };  };
Line 100  struct of {
Line 99  struct of {
         enum form        dform; /* path-cued form */          enum form        dform; /* path-cued form */
         enum form        sform; /* suffix-cued form */          enum form        sform; /* suffix-cued form */
         char             file[PATH_MAX]; /* filename rel. to manpath */          char             file[PATH_MAX]; /* filename rel. to manpath */
         const char      *desc; /* parsed description */          char            *desc; /* parsed description */
         const char      *sec; /* suffix-cued section (or empty) */          char            *name; /* name (from filename) (not empty) */
         const char      *dsec; /* path-cued section (or empty) */          char            *sec; /* suffix-cued section (or empty) */
         const char      *arch; /* path-cued arch. (or empty) */          char            *dsec; /* path-cued section (or empty) */
         const char      *name; /* name (from filename) (not empty) */          char            *arch; /* path-cued arch. (or empty) */
 };  };
   
 enum    stmt {  enum    stmt {
Line 138  static int  inocheck(const struct stat *);
Line 137  static int  inocheck(const struct stat *);
 static  void     ofadd(int, const char *, const char *, const char *,  static  void     ofadd(int, const char *, const char *, const char *,
                         const char *, const char *, const struct stat *);                          const char *, const char *, const struct stat *);
 static  void     offree(void);  static  void     offree(void);
 static  void     ofmerge(struct mchars *, struct mparse *);  static  void     ofmerge(struct mchars *, struct mparse *,
                           struct ohash_info*);
 static  void     parse_catpage(struct of *);  static  void     parse_catpage(struct of *);
 static  void     parse_man(struct of *, const struct man_node *);  static  void     parse_man(struct of *, const struct man_node *);
 static  void     parse_mdoc(struct of *, const struct mdoc_node *);  static  void     parse_mdoc(struct of *, const struct mdoc_node *);
Line 160  static void  putkeys(const struct of *, 
Line 160  static void  putkeys(const struct of *, 
 static  void     putmdockey(const struct of *,  static  void     putmdockey(const struct of *,
                         const struct mdoc_node *, uint64_t);                          const struct mdoc_node *, uint64_t);
 static  void     say(const char *, const char *, ...);  static  void     say(const char *, const char *, ...);
 static  char    *stradd(const char *);  
 static  char    *stradds(const char *, size_t);  
 static  int      treescan(void);  static  int      treescan(void);
 static  size_t   utf8(unsigned int, char [7]);  static  size_t   utf8(unsigned int, char [7]);
 static  void     utf8key(struct mchars *, struct str *);  static  void     utf8key(struct mchars *, struct str *);
Line 178  static struct ohash  inos; /* table of inodes/devices 
Line 176  static struct ohash  inos; /* table of inodes/devices 
 static  struct ohash     filenames; /* table of filenames */  static  struct ohash     filenames; /* table of filenames */
 static  struct ohash     strings; /* table of all strings */  static  struct ohash     strings; /* table of all strings */
 static  struct of       *ofs = NULL; /* vector of files to parse */  static  struct of       *ofs = NULL; /* vector of files to parse */
 static  struct str      *words = NULL; /* word list in current parse */  
 static  sqlite3         *db = NULL; /* current database */  static  sqlite3         *db = NULL; /* current database */
 static  sqlite3_stmt    *stmts[STMT__MAX]; /* current statements */  static  sqlite3_stmt    *stmts[STMT__MAX]; /* current statements */
   
Line 311  int
Line 308  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         int               ch, i;          int               ch, i;
         unsigned int      slot;  
         size_t            j, sz;          size_t            j, sz;
         const char       *path_arg;          const char       *path_arg;
         struct str       *s;  
         struct mchars    *mc;          struct mchars    *mc;
         struct manpaths   dirs;          struct manpaths   dirs;
         struct mparse    *mp;          struct mparse    *mp;
Line 406  main(int argc, char *argv[])
Line 401  main(int argc, char *argv[])
                 MANDOCLEVEL_FATAL, NULL, NULL, NULL);                  MANDOCLEVEL_FATAL, NULL, NULL, NULL);
         mc = mchars_alloc();          mc = mchars_alloc();
   
         ohash_init(&strings, 6, &str_info);  
         ohash_init(&inos, 6, &ino_info);          ohash_init(&inos, 6, &ino_info);
         ohash_init(&filenames, 6, &filename_info);          ohash_init(&filenames, 6, &filename_info);
   
Line 430  main(int argc, char *argv[])
Line 424  main(int argc, char *argv[])
                 if (OP_TEST != op)                  if (OP_TEST != op)
                         dbprune();                          dbprune();
                 if (OP_DELETE != op)                  if (OP_DELETE != op)
                         ofmerge(mc, mp);                          ofmerge(mc, mp, &str_info);
                 dbclose(1);                  dbclose(1);
         } else {          } else {
                 /*                  /*
Line 460  main(int argc, char *argv[])
Line 454  main(int argc, char *argv[])
                                 dirs.paths[j][--sz] = '\0';                                  dirs.paths[j][--sz] = '\0';
                         if (0 == sz)                          if (0 == sz)
                                 continue;                                  continue;
   
                           if (j) {
                                   ohash_init(&inos, 6, &ino_info);
                                   ohash_init(&filenames, 6, &filename_info);
                           }
   
                         if (0 == set_basedir(dirs.paths[j]))                          if (0 == set_basedir(dirs.paths[j]))
                                 goto out;                                  goto out;
                         if (0 == treescan())                          if (0 == treescan())
Line 478  main(int argc, char *argv[])
Line 478  main(int argc, char *argv[])
                         SQL_EXEC("PRAGMA synchronous = OFF");                          SQL_EXEC("PRAGMA synchronous = OFF");
 #endif  #endif
   
                         ofmerge(mc, mp);                          ofmerge(mc, mp, &str_info);
                         dbclose(0);                          dbclose(0);
                         offree();  
                         ohash_delete(&inos);                          if (j + 1 < dirs.sz) {
                         ohash_init(&inos, 6, &ino_info);                                  ohash_delete(&inos);
                         ohash_delete(&filenames);                                  ohash_delete(&filenames);
                         ohash_init(&filenames, 6, &filename_info);                                  offree();
                           }
                 }                  }
         }          }
 out:  out:
Line 492  out:
Line 493  out:
         manpath_free(&dirs);          manpath_free(&dirs);
         mchars_free(mc);          mchars_free(mc);
         mparse_free(mp);          mparse_free(mp);
         for (s = ohash_first(&strings, &slot); NULL != s;  
              s = ohash_next(&strings, &slot)) {  
                 if (s->utf8 != s->key)  
                         free(s->utf8);  
                 free(s);  
         }  
         ohash_delete(&strings);  
         ohash_delete(&inos);          ohash_delete(&inos);
         ohash_delete(&filenames);          ohash_delete(&filenames);
         offree();          offree();
Line 536  treescan(void)
Line 530  treescan(void)
         FTSENT          *ff;          FTSENT          *ff;
         int              dform;          int              dform;
         char            *sec;          char            *sec;
         const char      *dsec, *arch, *cp, *name, *path;          const char      *dsec, *arch, *cp, *path;
         const char      *argv[2];          const char      *argv[2];
   
         argv[0] = ".";          argv[0] = ".";
Line 604  treescan(void)
Line 598  treescan(void)
                                 if (warnings)                                  if (warnings)
                                         say(path, "Wrong filename suffix");                                          say(path, "Wrong filename suffix");
                                 continue;                                  continue;
                         } else {                          } else
                                 sec[-1] = '\0';                                  sec[-1] = '\0';
                                 sec = stradd(sec);                          ofadd(dform, path, ff->fts_name, dsec, sec,
                         }                                          arch, ff->fts_statp);
                         name = stradd(ff->fts_name);  
                         ofadd(dform, path,  
                                 name, dsec, sec, arch, ff->fts_statp);  
                         continue;                          continue;
                 } else if (FTS_D != ff->fts_info &&                  } else if (FTS_D != ff->fts_info &&
                                 FTS_DP != ff->fts_info) {                                  FTS_DP != ff->fts_info) {
Line 637  treescan(void)
Line 628  treescan(void)
   
                         if (0 == strncmp(cp, "man", 3)) {                          if (0 == strncmp(cp, "man", 3)) {
                                 dform = FORM_SRC;                                  dform = FORM_SRC;
                                 dsec = stradd(cp + 3);                                  dsec = cp + 3;
                         } else if (0 == strncmp(cp, "cat", 3)) {                          } else if (0 == strncmp(cp, "cat", 3)) {
                                 dform = FORM_CAT;                                  dform = FORM_CAT;
                                 dsec = stradd(cp + 3);                                  dsec = cp + 3;
                         }                          }
   
                         if (NULL != dsec || use_all)                          if (NULL != dsec || use_all)
Line 657  treescan(void)
Line 648  treescan(void)
                          */                           */
                         arch = NULL;                          arch = NULL;
                         if (FTS_DP != ff->fts_info && NULL != dsec)                          if (FTS_DP != ff->fts_info && NULL != dsec)
                                 arch = stradd(ff->fts_name);                                  arch = ff->fts_name;
                         break;                          break;
                 default:                  default:
                         if (FTS_DP == ff->fts_info || use_all)                          if (FTS_DP == ff->fts_info || use_all)
Line 867  ofadd(int dform, const char *file, const char *name, c
Line 858  ofadd(int dform, const char *file, const char *name, c
   
         of = mandoc_calloc(1, sizeof(struct of));          of = mandoc_calloc(1, sizeof(struct of));
         strlcpy(of->file, file, PATH_MAX);          strlcpy(of->file, file, PATH_MAX);
         of->name = name;          of->name = mandoc_strdup(name);
         of->sec = sec;          of->sec = mandoc_strdup(sec);
         of->dsec = dsec;          of->dsec = mandoc_strdup(dsec);
         of->arch = arch;          of->arch = mandoc_strdup(arch);
         of->sform = sform;          of->sform = sform;
         of->dform = dform;          of->dform = dform;
         of->next = ofs;          of->next = ofs;
Line 892  offree(void)
Line 883  offree(void)
   
         while (NULL != (of = ofs)) {          while (NULL != (of = ofs)) {
                 ofs = of->next;                  ofs = of->next;
                   free(of->name);
                   free(of->sec);
                   free(of->dsec);
                   free(of->arch);
                 free(of);                  free(of);
         }          }
 }  }
Line 904  offree(void)
Line 899  offree(void)
  * and filename to determine whether the file is parsable or not.   * and filename to determine whether the file is parsable or not.
  */   */
 static void  static void
 ofmerge(struct mchars *mc, struct mparse *mp)  ofmerge(struct mchars *mc, struct mparse *mp,
                   struct ohash_info *infop)
 {  {
         int              form;          int              form;
         size_t           sz;          size_t           sz;
Line 945  ofmerge(struct mchars *mc, struct mparse *mp)
Line 941  ofmerge(struct mchars *mc, struct mparse *mp)
                         }                          }
                 }                  }
   
                 words = NULL;                  ohash_init(&strings, 6, infop);
                 mparse_reset(mp);                  mparse_reset(mp);
                 mdoc = NULL;                  mdoc = NULL;
                 man = NULL;                  man = NULL;
Line 1023  ofmerge(struct mchars *mc, struct mparse *mp)
Line 1019  ofmerge(struct mchars *mc, struct mparse *mp)
                 if (NULL != mdoc) {                  if (NULL != mdoc) {
                         if (NULL != (cp = mdoc_meta(mdoc)->name))                          if (NULL != (cp = mdoc_meta(mdoc)->name))
                                 putkey(of, cp, TYPE_Nm);                                  putkey(of, cp, TYPE_Nm);
                           assert(NULL == of->desc);
                         parse_mdoc(of, mdoc_node(mdoc));                          parse_mdoc(of, mdoc_node(mdoc));
                           putkey(of, NULL != of->desc ?
                                   of->desc : of->name, TYPE_Nd);
                 } else if (NULL != man)                  } else if (NULL != man)
                         parse_man(of, man_node(man));                          parse_man(of, man_node(man));
                 else                  else
                         parse_catpage(of);                          parse_catpage(of);
   
                 dbindex(mc, form, of);                  dbindex(mc, form, of);
                   ohash_delete(&strings);
         }          }
 }  }
   
Line 1096  parse_catpage(struct of *of)
Line 1096  parse_catpage(struct of *of)
         if (NULL == title || '\0' == *title) {          if (NULL == title || '\0' == *title) {
                 if (warnings)                  if (warnings)
                         say(of->file, "Cannot find NAME section");                          say(of->file, "Cannot find NAME section");
                   assert(NULL == of->desc);
                   of->desc = mandoc_strdup(of->name);
                 putkey(of, of->name, TYPE_Nd);                  putkey(of, of->name, TYPE_Nd);
                 fclose(stream);                  fclose(stream);
                 free(title);                  free(title);
Line 1134  parse_catpage(struct of *of)
Line 1136  parse_catpage(struct of *of)
                 plen -= 2;                  plen -= 2;
         }          }
   
         of->desc = stradd(p);          assert(NULL == of->desc);
         putkey(of, p, TYPE_Nd);          of->desc = mandoc_strdup(p);
           putkey(of, of->desc, TYPE_Nd);
         fclose(stream);          fclose(stream);
         free(title);          free(title);
 }  }
Line 1299  parse_man(struct of *of, const struct man_node *n)
Line 1302  parse_man(struct of *of, const struct man_node *n)
                                 start++;                                  start++;
   
                         assert(NULL == of->desc);                          assert(NULL == of->desc);
                         of->desc = stradd(start);                          of->desc = mandoc_strdup(start);
                         putkey(of, start, TYPE_Nd);                          putkey(of, of->desc, TYPE_Nd);
                         free(title);                          free(title);
                         return;                          return;
                 }                  }
Line 1455  static int
Line 1458  static int
 parse_mdoc_Nd(struct of *of, const struct mdoc_node *n)  parse_mdoc_Nd(struct of *of, const struct mdoc_node *n)
 {  {
         size_t           sz;          size_t           sz;
         char            *sv, *desc;  
   
         if (MDOC_BODY != n->type)          if (MDOC_BODY != n->type)
                 return(0);                  return(0);
Line 1465  parse_mdoc_Nd(struct of *of, const struct mdoc_node *n
Line 1467  parse_mdoc_Nd(struct of *of, const struct mdoc_node *n
          * into the document table.           * into the document table.
          */           */
   
         desc = NULL;  
         for (n = n->child; NULL != n; n = n->next) {          for (n = n->child; NULL != n; n = n->next) {
                 if (MDOC_TEXT == n->type) {                  if (MDOC_TEXT == n->type) {
                         sz = strlen(n->string) + 1;                          if (NULL != of->desc) {
                         if (NULL != (sv = desc))                                  sz = strlen(of->desc) +
                                 sz += strlen(desc) + 1;                                       strlen(n->string) + 2;
                         desc = mandoc_realloc(desc, sz);                                  of->desc = mandoc_realloc(of->desc, sz);
                         if (NULL != sv)                                  strlcat(of->desc, " ", sz);
                                 strlcat(desc, " ", sz);                                  strlcat(of->desc, n->string, sz);
                         else                          } else
                                 *desc = '\0';                                  of->desc = mandoc_strdup(n->string);
                         strlcat(desc, n->string, sz);  
                 }                  }
                 if (NULL != n->child)                  if (NULL != n->child)
                         parse_mdoc_Nd(of, n);                          parse_mdoc_Nd(of, n);
         }          }
   
         of->desc = NULL != desc ? stradd(desc) : NULL;  
         free(desc);  
         return(1);          return(1);
 }  }
   
Line 1521  parse_mdoc_body(struct of *of, const struct mdoc_node 
Line 1518  parse_mdoc_body(struct of *of, const struct mdoc_node 
 }  }
   
 /*  /*
  * See stradds().   * Add a string to the hash table for the current manual.
    * Each string has a bitmask telling which macros it belongs to.
    * When we finish the manual, we'll dump the table.
  */   */
 static char *  
 stradd(const char *cp)  
 {  
   
         return(stradds(cp, strlen(cp)));  
 }  
   
 /*  
  * This looks up or adds a string to the string table.  
  * The string table is a table of all strings encountered during parse  
  * or file scan.  
  * In using it, we avoid having thousands of (e.g.) "cat1" string  
  * allocations for the "of" table.  
  * We also have a layer atop the string table for keeping track of words  
  * in a parse sequence (see putkeys()).  
  */  
 static char *  
 stradds(const char *cp, size_t sz)  
 {  
         struct str      *s;  
         unsigned int     slot;  
         const char      *end;  
   
         end = cp + sz;  
         slot = ohash_qlookupi(&strings, cp, &end);  
         if (NULL != (s = ohash_find(&strings, slot)))  
                 return(s->key);  
   
         s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);  
         memcpy(s->key, cp, sz);  
         ohash_insert(&strings, slot, s);  
         return(s->key);  
 }  
   
 /*  
  * Add a word to the current parse sequence.  
  * Within the hashtable of strings, we maintain a list of strings that  
  * are currently indexed.  
  * Each of these ("words") has a bitmask modified within the parse.  
  * When we finish a parse, we'll dump the list, then remove the head  
  * entry -- since the next parse will have a new "of", it can keep track  
  * of its entries without conflict.  
  */  
 static void  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)
 {  {
Line 1588  putkeys(const struct of *of, const char *cp, size_t sz
Line 1544  putkeys(const struct of *of, const char *cp, size_t sz
                 memcpy(s->key, cp, sz);                  memcpy(s->key, cp, sz);
                 ohash_insert(&strings, slot, s);                  ohash_insert(&strings, slot, s);
         }          }
   
         s->next = words;  
         s->of = of;          s->of = of;
         s->mask = v;          s->mask = v;
         words = s;  
 }  }
   
 /*  /*
Line 1764  dbindex(struct mchars *mc, int form, const struct of *
Line 1717  dbindex(struct mchars *mc, int form, const struct of *
         const char      *desc;          const char      *desc;
         int64_t          recno;          int64_t          recno;
         size_t           i;          size_t           i;
           unsigned int     slot;
   
         if (verb)          if (verb)
                 say(of->file, "Adding to index");                  say(of->file, "Adding to index");
Line 1793  dbindex(struct mchars *mc, int form, const struct of *
Line 1747  dbindex(struct mchars *mc, int form, const struct of *
         recno = sqlite3_last_insert_rowid(db);          recno = sqlite3_last_insert_rowid(db);
         sqlite3_reset(stmts[STMT_INSERT_DOC]);          sqlite3_reset(stmts[STMT_INSERT_DOC]);
   
         for (key = words; NULL != key; key = key->next) {          for (key = ohash_first(&strings, &slot); NULL != key;
                key = ohash_next(&strings, &slot)) {
                 assert(key->of == of);                  assert(key->of == of);
                 if (NULL == key->utf8)                  if (NULL == key->utf8)
                         utf8key(mc, key);                          utf8key(mc, key);
Line 1803  dbindex(struct mchars *mc, int form, const struct of *
Line 1758  dbindex(struct mchars *mc, int form, const struct of *
                 SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, recno);                  SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, recno);
                 SQL_STEP(stmts[STMT_INSERT_KEY]);                  SQL_STEP(stmts[STMT_INSERT_KEY]);
                 sqlite3_reset(stmts[STMT_INSERT_KEY]);                  sqlite3_reset(stmts[STMT_INSERT_KEY]);
                   if (key->utf8 != key->key)
                           free(key->utf8);
                   free(key);
         }          }
   
         SQL_EXEC("END TRANSACTION");          SQL_EXEC("END TRANSACTION");

Legend:
Removed from v.1.65  
changed lines
  Added in v.1.66

CVSweb