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

Diff for /mandoc/mandocdb.c between version 1.43 and 1.44

version 1.43, 2011/12/31 18:47:52 version 1.44, 2012/03/23 05:07:35
Line 123  static void    hash_put(DB *, const struct buf *, uint
Line 123  static void    hash_put(DB *, const struct buf *, uint
 static  void              hash_reset(DB **);  static  void              hash_reset(DB **);
 static  void              index_merge(const struct of *, struct mparse *,  static  void              index_merge(const struct of *, struct mparse *,
                                 struct buf *, struct buf *, DB *,                                  struct buf *, struct buf *, DB *,
                                 struct mdb *, struct recs *);                                  struct mdb *, struct recs *,
                                   const char *);
 static  void              index_prune(const struct of *, struct mdb *,  static  void              index_prune(const struct of *, struct mdb *,
                                 struct recs *);                                  struct recs *, const char *);
 static  void              ofile_argbuild(int, char *[], struct of **);  static  void              ofile_argbuild(int, char *[],
                                   struct of **, const char *);
 static  void              ofile_dirbuild(const char *, const char *,  static  void              ofile_dirbuild(const char *, const char *,
                                 const char *, int, struct of **);                                  const char *, int, struct of **);
 static  void              ofile_free(struct of *);  static  void              ofile_free(struct of *);
 static  void              pformatted(DB *, struct buf *,  static  void              pformatted(DB *, struct buf *, struct buf *,
                                 struct buf *, const struct of *);                                  const struct of *, const char *);
 static  int               pman_node(MAN_ARGS);  static  int               pman_node(MAN_ARGS);
 static  void              pmdoc_node(MDOC_ARGS);  static  void              pmdoc_node(MDOC_ARGS);
 static  int               pmdoc_head(MDOC_ARGS);  static  int               pmdoc_head(MDOC_ARGS);
Line 292  main(int argc, char *argv[])
Line 294  main(int argc, char *argv[])
         struct recs      recs;          struct recs      recs;
         enum op          op; /* current operation */          enum op          op; /* current operation */
         const char      *dir;          const char      *dir;
         char            *cp;  
         char             pbuf[PATH_MAX];  
         int              ch, i, flags;          int              ch, i, flags;
         DB              *hash; /* temporary keyword hashtable */          DB              *hash; /* temporary keyword hashtable */
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
Line 382  main(int argc, char *argv[])
Line 382  main(int argc, char *argv[])
         }          }
   
         memset(&info, 0, sizeof(BTREEINFO));          memset(&info, 0, sizeof(BTREEINFO));
           info.lorder = 4321;
         info.flags = R_DUP;          info.flags = R_DUP;
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
Line 394  main(int argc, char *argv[])
Line 395  main(int argc, char *argv[])
         buf.cp = mandoc_malloc(buf.size);          buf.cp = mandoc_malloc(buf.size);
         dbuf.cp = mandoc_malloc(dbuf.size);          dbuf.cp = mandoc_malloc(dbuf.size);
   
         flags = O_CREAT | O_RDWR;  
         if (OP_DEFAULT == op || OP_CONFFILE == op)  
                 flags |= O_TRUNC;  
   
         if (OP_TEST == op) {          if (OP_TEST == op) {
                 ofile_argbuild(argc, argv, &of);                  ofile_argbuild(argc, argv, &of, ".");
                 if (NULL == of)                  if (NULL == of)
                         goto out;                          goto out;
                 index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);                  index_merge(of, mp, &dbuf, &buf,
                                   hash, &mdb, &recs, ".");
                 goto out;                  goto out;
         }          }
   
Line 420  main(int argc, char *argv[])
Line 418  main(int argc, char *argv[])
                         exit((int)MANDOCLEVEL_BADARG);                          exit((int)MANDOCLEVEL_BADARG);
                 }                  }
   
                   flags = O_CREAT | O_RDWR;
                 mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);                  mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);
                 mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);                  mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);
   
Line 431  main(int argc, char *argv[])
Line 430  main(int argc, char *argv[])
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 ofile_argbuild(argc, argv, &of);                  ofile_argbuild(argc, argv, &of, dir);
   
                 if (NULL == of)                  if (NULL == of)
                         goto out;                          goto out;
   
                 index_prune(of, &mdb, &recs);                  index_prune(of, &mdb, &recs, dir);
   
                 /*                  /*
                  * Go to the root of the respective manual tree.                   * Go to the root of the respective manual tree.
Line 450  main(int argc, char *argv[])
Line 449  main(int argc, char *argv[])
                                 exit((int)MANDOCLEVEL_SYSERR);                                  exit((int)MANDOCLEVEL_SYSERR);
                         }                          }
                         index_merge(of, mp, &dbuf, &buf, hash,                          index_merge(of, mp, &dbuf, &buf, hash,
                                         &mdb, &recs);                                          &mdb, &recs, dir);
                 }                  }
   
                 goto out;                  goto out;
Line 465  main(int argc, char *argv[])
Line 464  main(int argc, char *argv[])
         if (argc > 0) {          if (argc > 0) {
                 dirs.paths = mandoc_calloc(argc, sizeof(char *));                  dirs.paths = mandoc_calloc(argc, sizeof(char *));
                 dirs.sz = argc;                  dirs.sz = argc;
                 for (i = 0; i < argc; i++) {                  for (i = 0; i < argc; i++)
                         if (NULL == (cp = realpath(argv[i], pbuf))) {                          dirs.paths[i] = mandoc_strdup(argv[i]);
                                 perror(argv[i]);  
                                 goto out;  
                         }  
                         dirs.paths[i] = mandoc_strdup(cp);  
                 }  
         } else          } else
                 manpath_parse(&dirs, dir, NULL, NULL);                  manpath_parse(&dirs, dir, NULL, NULL);
   
         for (i = 0; i < dirs.sz; i++) {          for (i = 0; i < dirs.sz; i++) {
                 mdb.idxn[0] = mdb.dbn[0] = '\0';                  /*
                    * Go to the root of the respective manual tree.
                    * This must work or no manuals may be found:
                    * They are indexed relative to the root.
                    */
   
                 strlcat(mdb.dbn, dirs.paths[i], MAXPATHLEN);                  if (-1 == chdir(dirs.paths[i])) {
                 strlcat(mdb.dbn, "/", MAXPATHLEN);                          perror(dirs.paths[i]);
                 sz1 = strlcat(mdb.dbn, MANDOC_DB, MAXPATHLEN);                          exit((int)MANDOCLEVEL_SYSERR);
   
                 strlcat(mdb.idxn, dirs.paths[i], MAXPATHLEN);  
                 strlcat(mdb.idxn, "/", MAXPATHLEN);  
                 sz2 = strlcat(mdb.idxn, MANDOC_IDX, MAXPATHLEN);  
   
                 if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {  
                         fprintf(stderr, "%s: path too long\n",  
                                         dirs.paths[i]);  
                         exit((int)MANDOCLEVEL_BADARG);  
                 }                  }
   
                 if (mdb.db)                  strlcpy(mdb.dbn, MANDOC_DB, MAXPATHLEN);
                         (*mdb.db->close)(mdb.db);                  strlcpy(mdb.idxn, MANDOC_IDX, MAXPATHLEN);
                 if (mdb.idx)  
                         (*mdb.idx->close)(mdb.idx);  
   
                   flags = O_CREAT | O_TRUNC | O_RDWR;
                 mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);                  mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);
                 mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);                  mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);
   
Line 508  main(int argc, char *argv[])
Line 496  main(int argc, char *argv[])
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 ofile_free(of);  
                 of = NULL;  
   
                 if (-1 == chdir(dirs.paths[i])) {  
                         perror(dirs.paths[i]);  
                         exit((int)MANDOCLEVEL_SYSERR);  
                 }  
   
                 ofile_dirbuild(".", "", "", 0, &of);  
                 if (NULL == of)  
                         continue;  
   
                 /*                  /*
                  * Go to the root of the respective manual tree.                   * Search for manuals and fill the new database.
                  * This must work or no manuals may be found (they're  
                  * indexed relative to the root).  
                  */                   */
   
                 if (-1 == chdir(dirs.paths[i])) {                  ofile_dirbuild(".", "", "", 0, &of);
                         perror(dirs.paths[i]);  
                         exit((int)MANDOCLEVEL_SYSERR);                  if (NULL != of) {
                           index_merge(of, mp, &dbuf, &buf, hash,
                                &mdb, &recs, dirs.paths[i]);
                           ofile_free(of);
                           of = NULL;
                 }                  }
   
                 index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);                  (*mdb.db->close)(mdb.db);
                   (*mdb.idx->close)(mdb.idx);
                   mdb.db = NULL;
                   mdb.idx = NULL;
         }          }
   
 out:  out:
Line 565  usage:
Line 546  usage:
 void  void
 index_merge(const struct of *of, struct mparse *mp,  index_merge(const struct of *of, struct mparse *mp,
                 struct buf *dbuf, struct buf *buf, DB *hash,                  struct buf *dbuf, struct buf *buf, DB *hash,
                 struct mdb *mdb, struct recs *recs)                  struct mdb *mdb, struct recs *recs,
                   const char *basedir)
 {  {
         recno_t          rec;          recno_t          rec;
         int              ch, skip;          int              ch, skip;
         DBT              key, val;          DBT              key, val;
           DB              *files;  /* temporary file name table */
           char             emptystring[1] = {'\0'};
         struct mdoc     *mdoc;          struct mdoc     *mdoc;
         struct man      *man;          struct man      *man;
           char            *p;
         const char      *fn, *msec, *march, *mtitle;          const char      *fn, *msec, *march, *mtitle;
         uint64_t         mask;          uint64_t         mask;
         size_t           sv;          size_t           sv;
Line 579  index_merge(const struct of *of, struct mparse *mp,
Line 564  index_merge(const struct of *of, struct mparse *mp,
         uint64_t         vbuf[2];          uint64_t         vbuf[2];
         char             type;          char             type;
   
           if (warnings) {
                   files = NULL;
                   hash_reset(&files);
           }
   
         rec = 0;          rec = 0;
         for (of = of->first; of; of = of->next) {          for (of = of->first; of; of = of->next) {
                 fn = of->fname;                  fn = of->fname;
Line 615  index_merge(const struct of *of, struct mparse *mp,
Line 605  index_merge(const struct of *of, struct mparse *mp,
                 }                  }
   
                 /*                  /*
                  * By default, skip a file if the manual section                   * Check whether the manual section given in a file
                  * given in the file disagrees with the directory                   * agrees with the directory where the file is located.
                  * where the file is located.                   * Some manuals have suffixes like (3p) on their
                    * section number either inside the file or in the
                    * directory name, some are linked into more than one
                    * section, like encrypt(1) = makekey(8).  Do not skip
                    * manuals for such reasons.
                  */                   */
   
                 skip = 0;                  skip = 0;
                 assert(of->sec);                  assert(of->sec);
                 assert(msec);                  assert(msec);
                 if (strcasecmp(msec, of->sec)) {                  if (warnings && strcasecmp(msec, of->sec))
                         if (warnings)                          fprintf(stderr, "%s: section \"%s\" manual "
                                 fprintf(stderr, "%s: "  
                                         "section \"%s\" manual "  
                                         "in \"%s\" directory\n",                                          "in \"%s\" directory\n",
                                         fn, msec, of->sec);                                          fn, msec, of->sec);
                         skip = 1;  
                 }  
   
   
                 /*                  /*
                  * Manual page directories exist for each kernel                   * Manual page directories exist for each kernel
                  * architecture as returned by machine(1).                   * architecture as returned by machine(1).
Line 649  index_merge(const struct of *of, struct mparse *mp,
Line 640  index_merge(const struct of *of, struct mparse *mp,
   
                 assert(of->arch);                  assert(of->arch);
                 assert(march);                  assert(march);
                 if (strcasecmp(march, of->arch)) {                  if (warnings && strcasecmp(march, of->arch))
                         if (warnings)                          fprintf(stderr, "%s: architecture \"%s\" manual "
                                 fprintf(stderr, "%s: "  
                                         "architecture \"%s\" manual "  
                                         "in \"%s\" directory\n",                                          "in \"%s\" directory\n",
                                         fn, march, of->arch);                                          fn, march, of->arch);
                         march = of->arch;  
                 }  
   
                 /*                  /*
                  * By default, skip a file if the title given                   * By default, skip a file if the title given
                  * in the file disagrees with the file name.                   * in the file disagrees with the file name.
                  * If both agree, use the file name as the title,                   * Do not warn, this happens for all MLINKs.
                  * because the one in the file usually is all caps.  
                  */                   */
   
                 assert(of->title);                  assert(of->title);
                 assert(mtitle);                  assert(mtitle);
                 if (strcasecmp(mtitle, of->title)) {                  if (strcasecmp(mtitle, of->title))
                         if (warnings)  
                                 fprintf(stderr, "%s: "  
                                         "title \"%s\" in file "  
                                         "but \"%s\" in filename\n",  
                                         fn, mtitle, of->title);  
                         skip = 1;                          skip = 1;
                 } else  
                         mtitle = of->title;  
   
                   /*
                    * Build a title string for the file.  If it matches
                    * the location of the file, remember the title as
                    * found; else, remember it as missing.
                    */
   
                   if (warnings) {
                           buf->len = 0;
                           buf_appendb(buf, mtitle, strlen(mtitle));
                           buf_appendb(buf, "(", 1);
                           buf_appendb(buf, msec, strlen(msec));
                           if ('\0' != *march) {
                                   buf_appendb(buf, "/", 1);
                                   buf_appendb(buf, march, strlen(march));
                           }
                           buf_appendb(buf, ")", 2);
                           for (p = buf->cp; '\0' != *p; p++)
                                   *p = tolower(*p);
                           key.data = buf->cp;
                           key.size = buf->len;
                           val.data = NULL;
                           val.size = 0;
                           if (0 == skip)
                                   val.data = emptystring;
                           else {
                                   ch = (*files->get)(files, &key, &val, 0);
                                   if (ch < 0) {
                                           perror("hash");
                                           exit((int)MANDOCLEVEL_SYSERR);
                                   } else if (ch > 0) {
                                           val.data = (void *)fn;
                                           val.size = strlen(fn) + 1;
                                   } else
                                           val.data = NULL;
                           }
                           if (NULL != val.data &&
                               (*files->put)(files, &key, &val, 0) < 0) {
                                   perror("hash");
                                   exit((int)MANDOCLEVEL_SYSERR);
                           }
                   }
   
                 if (skip && !use_all)                  if (skip && !use_all)
                         continue;                          continue;
   
                 /*                  /*
                  * The index record value consists of a nil-terminated                   * The index record value consists of a nil-terminated
                  * filename, a nil-terminated manual section, and a                   * filename, a nil-terminated manual section, and a
                  * nil-terminated description.  Since the description                   * nil-terminated description.  Use the actual
                  * may not be set, we set a sentinel to see if we're                   * location of the file, such that the user can find
                  * going to write a nil byte in its place.                   * it with man(1).  Since the description may not be
                    * set, we set a sentinel to see if we're going to
                    * write a nil byte in its place.
                  */                   */
   
                 dbuf->len = 0;                  dbuf->len = 0;
                 type = mdoc ? 'd' : (man ? 'a' : 'c');                  type = mdoc ? 'd' : (man ? 'a' : 'c');
                 buf_appendb(dbuf, &type, 1);                  buf_appendb(dbuf, &type, 1);
                 buf_appendb(dbuf, fn, strlen(fn) + 1);                  buf_appendb(dbuf, fn, strlen(fn) + 1);
                 buf_appendb(dbuf, msec, strlen(msec) + 1);                  buf_appendb(dbuf, of->sec, strlen(of->sec) + 1);
                 buf_appendb(dbuf, mtitle, strlen(mtitle) + 1);                  buf_appendb(dbuf, of->title, strlen(of->title) + 1);
                 buf_appendb(dbuf, march, strlen(march) + 1);                  buf_appendb(dbuf, of->arch, strlen(of->arch) + 1);
   
                 sv = dbuf->len;                  sv = dbuf->len;
   
Line 710  index_merge(const struct of *of, struct mparse *mp,
Line 733  index_merge(const struct of *of, struct mparse *mp,
                 else if (man)                  else if (man)
                         pman_node(hash, buf, dbuf, man_node(man));                          pman_node(hash, buf, dbuf, man_node(man));
                 else                  else
                         pformatted(hash, buf, dbuf, of);                          pformatted(hash, buf, dbuf, of, basedir);
   
                 /* Test mode, do not access any database. */                  /* Test mode, do not access any database. */
   
Line 718  index_merge(const struct of *of, struct mparse *mp,
Line 741  index_merge(const struct of *of, struct mparse *mp,
                         continue;                          continue;
   
                 /*                  /*
                    * Make sure the file name is always registered
                    * as an .Nm search key.
                    */
                   buf->len = 0;
                   buf_append(buf, of->title);
                   hash_put(hash, buf, TYPE_Nm);
   
                   /*
                  * Reclaim an empty index record, if available.                   * Reclaim an empty index record, if available.
                  * Use its record number for all new btree nodes.                   * Use its record number for all new btree nodes.
                  */                   */
Line 767  index_merge(const struct of *of, struct mparse *mp,
Line 798  index_merge(const struct of *of, struct mparse *mp,
                 val.size = dbuf->len;                  val.size = dbuf->len;
   
                 if (verb)                  if (verb)
                         printf("%s: adding to index\n", fn);                          printf("%s: Adding to index: %s\n", basedir, fn);
   
                 dbt_put(mdb->idx, mdb->idxn, &key, &val);                  dbt_put(mdb->idx, mdb->idxn, &key, &val);
         }          }
   
           /*
            * Iterate the remembered file titles and check that
            * all files can be found by their main title.
            */
   
           if (warnings) {
                   seq = R_FIRST;
                   while (0 == (*files->seq)(files, &key, &val, seq)) {
                           seq = R_NEXT;
                           if (val.size)
                                   fprintf(stderr, "%s: probably "
                                       "unreachable, title is %s\n",
                                       (char *)val.data, (char *)key.data);
                   }
                   (*files->close)(files);
           }
 }  }
   
 /*  /*
Line 780  index_merge(const struct of *of, struct mparse *mp,
Line 828  index_merge(const struct of *of, struct mparse *mp,
  * in `idx' (zeroing its value size).   * in `idx' (zeroing its value size).
  */   */
 static void  static void
 index_prune(const struct of *ofile, struct mdb *mdb, struct recs *recs)  index_prune(const struct of *ofile, struct mdb *mdb,
                   struct recs *recs, const char *basedir)
 {  {
         const struct of *of;          const struct of *of;
         const char      *fn;          const char      *fn;
Line 855  index_prune(const struct of *ofile, struct mdb *mdb, s
Line 904  index_prune(const struct of *ofile, struct mdb *mdb, s
                 }                  }
   
                 if (verb)                  if (verb)
                         printf("%s: deleting from index\n", fn);                          printf("%s: Deleting from index: %s\n",
                                           basedir, fn);
   
                 val.size = 0;                  val.size = 0;
                 ch = (*mdb->idx->put)(mdb->idx, &key, &val, R_CURSOR);                  ch = (*mdb->idx->put)(mdb->idx, &key, &val, R_CURSOR);
Line 1367  pman_node(MAN_ARGS)
Line 1417  pman_node(MAN_ARGS)
  * By necessity, this involves rather crude guesswork.   * By necessity, this involves rather crude guesswork.
  */   */
 static void  static void
 pformatted(DB *hash, struct buf *buf,  pformatted(DB *hash, struct buf *buf, struct buf *dbuf,
                 struct buf *dbuf, const struct of *of)                  const struct of *of, const char *basedir)
 {  {
         FILE            *stream;          FILE            *stream;
         char            *line, *p, *title;          char            *line, *p, *title;
Line 1441  pformatted(DB *hash, struct buf *buf, 
Line 1491  pformatted(DB *hash, struct buf *buf, 
   
         if (NULL == title || '\0' == *title) {          if (NULL == title || '\0' == *title) {
                 if (warnings)                  if (warnings)
                         fprintf(stderr, "%s: cannot find NAME section\n",                          fprintf(stderr, "%s: Cannot find NAME "
                                         of->fname);                                  "section: %s\n", basedir, of->fname);
                 buf_appendb(dbuf, buf->cp, buf->size);                  buf_appendb(dbuf, buf->cp, buf->size);
                 hash_put(hash, buf, TYPE_Nd);                  hash_put(hash, buf, TYPE_Nd);
                 fclose(stream);                  fclose(stream);
Line 1464  pformatted(DB *hash, struct buf *buf, 
Line 1514  pformatted(DB *hash, struct buf *buf, 
                         /* Skip to next word. */ ;                          /* Skip to next word. */ ;
         } else {          } else {
                 if (warnings)                  if (warnings)
                         fprintf(stderr, "%s: no dash in title line\n",                          fprintf(stderr, "%s/%s: No dash in "
                                         of->fname);                                  "title line\n", basedir, of->fname);
                 p = title;                  p = title;
         }          }
   
Line 1492  pformatted(DB *hash, struct buf *buf, 
Line 1542  pformatted(DB *hash, struct buf *buf, 
 }  }
   
 static void  static void
 ofile_argbuild(int argc, char *argv[], struct of **of)  ofile_argbuild(int argc, char *argv[],
                   struct of **of, const char *basedir)
 {  {
         char             buf[MAXPATHLEN];          char             buf[MAXPATHLEN];
         const char      *sec, *arch, *title;          const char      *sec, *arch, *title;
Line 1510  ofile_argbuild(int argc, char *argv[], struct of **of)
Line 1561  ofile_argbuild(int argc, char *argv[], struct of **of)
                  */                   */
   
                 if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {                  if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {
                         fprintf(stderr, "%s: path too long\n", argv[i]);                          fprintf(stderr, "%s: Path too long\n", argv[i]);
                         continue;                          continue;
                 }                  }
                 sec = arch = title = "";                  sec = arch = title = "";
Line 1543  ofile_argbuild(int argc, char *argv[], struct of **of)
Line 1594  ofile_argbuild(int argc, char *argv[], struct of **of)
                 }                  }
                 if ('\0' == *title) {                  if ('\0' == *title) {
                         if (warnings)                          if (warnings)
                                 fprintf(stderr,                                  fprintf(stderr, "%s/%s: Cannot deduce "
                                     "%s: cannot deduce title "                                          "title from filename\n",
                                     "from filename\n",                                          basedir, argv[i]);
                                     argv[i]);  
                         title = buf;                          title = buf;
                 }                  }
   
Line 1565  ofile_argbuild(int argc, char *argv[], struct of **of)
Line 1615  ofile_argbuild(int argc, char *argv[], struct of **of)
                  * Add the structure to the list.                   * Add the structure to the list.
                  */                   */
   
                 if (verb > 1)  
                         printf("%s: scheduling\n", argv[i]);  
                 if (NULL == *of) {                  if (NULL == *of) {
                         *of = nof;                          *of = nof;
                         (*of)->first = nof;                          (*of)->first = nof;
Line 1582  ofile_argbuild(int argc, char *argv[], struct of **of)
Line 1630  ofile_argbuild(int argc, char *argv[], struct of **of)
  * Recursively build up a list of files to parse.   * Recursively build up a list of files to parse.
  * We use this instead of ftw() and so on because I don't want global   * We use this instead of ftw() and so on because I don't want global
  * variables hanging around.   * variables hanging around.
  * This ignores the whatis.db and whatis.index files, but assumes that   * This ignores the mandocdb.db and mandocdb.index files, but assumes that
  * everything else is a manual.   * everything else is a manual.
  * Pass in a pointer to a NULL structure for the first invocation.   * Pass in a pointer to a NULL structure for the first invocation.
  */   */
Line 1666  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1714  ofile_dirbuild(const char *dir, const char* psec, cons
                                 continue;                                  continue;
                         }                          }
   
                         if (verb > 1)  
                                 printf("%s: scanning\n", buf);  
   
                         ofile_dirbuild(buf, sec, arch, src_form, of);                          ofile_dirbuild(buf, sec, arch, src_form, of);
                         continue;                          continue;
                 }                  }
Line 1797  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1842  ofile_dirbuild(const char *dir, const char* psec, cons
                 /*                  /*
                  * Add the structure to the list.                   * Add the structure to the list.
                  */                   */
   
                 if (verb > 1)  
                         printf("%s: scheduling\n", buf);  
   
                 if (NULL == *of) {                  if (NULL == *of) {
                         *of = nof;                          *of = nof;
Legend:
Removed from v.1.43  
changed lines
  Added in v.1.44
CVSweb