[BACK]Return to mandocdb.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mandoc

Diff for /src/usr.bin/mandoc/mandocdb.c between version 1.39 and 1.40

version 1.39, 2012/04/15 11:14:38 version 1.40, 2012/04/15 13:26:14
Line 43 
Line 43 
 #define MANDOC_SRC        0x1  #define MANDOC_SRC        0x1
 #define MANDOC_FORM       0x2  #define MANDOC_FORM       0x2
   
   #define WARNING(_f, _b, _fmt, _args...) \
           do if (warnings) { \
                   fprintf(stderr, "%s: ", (_b)); \
                   fprintf(stderr, (_fmt), ##_args); \
                   if ('\0' != *(_f)) \
                           fprintf(stderr, ": %s", (_f)); \
                   fprintf(stderr, "\n"); \
           } while (/* CONSTCOND */ 0)
   
 /* Access to the mandoc database on disk. */  /* Access to the mandoc database on disk. */
   
 struct  mdb {  struct  mdb {
Line 111 
Line 120 
 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 *,
 static  void              index_prune(const struct of *, struct mdb *,  
                                 struct recs *);  
 static  void              ofile_argbuild(int, char *[], struct of **,  
                                 const char *);                                  const char *);
   static  void              index_prune(const struct of *, struct mdb *,
                                   struct recs *, const char *);
   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 **, char *);
 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 281 
Line 291 
         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;
           char             dirbuf[MAXPATHLEN];
         DB              *hash; /* temporary keyword hashtable */          DB              *hash; /* temporary keyword hashtable */
         BTREEINFO        info; /* btree configuration */          BTREEINFO        info; /* btree configuration */
         size_t           sz1, sz2;          size_t           sz1, sz2;
Line 385 
Line 394 
         dbuf.cp = mandoc_malloc(dbuf.size);          dbuf.cp = mandoc_malloc(dbuf.size);
   
         if (OP_TEST == op) {          if (OP_TEST == op) {
                 ofile_argbuild(argc, argv, &of, NULL);                  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;
         }          }
   
         if (OP_UPDATE == op || OP_DELETE == op) {          if (OP_UPDATE == op || OP_DELETE == op) {
                 if (NULL == realpath(dir, pbuf)) {                  strlcat(mdb.dbn, dir, MAXPATHLEN);
                         perror(dir);                  strlcat(mdb.dbn, "/", MAXPATHLEN);
                         exit((int)MANDOCLEVEL_BADARG);  
                 }  
                 if (strlcat(pbuf, "/", PATH_MAX) >= PATH_MAX) {  
                         fprintf(stderr, "%s: path too long\n", pbuf);  
                         exit((int)MANDOCLEVEL_BADARG);  
                 }  
   
                 strlcat(mdb.dbn, pbuf, MAXPATHLEN);  
                 sz1 = strlcat(mdb.dbn, MANDOC_DB, MAXPATHLEN);                  sz1 = strlcat(mdb.dbn, MANDOC_DB, MAXPATHLEN);
   
                 strlcat(mdb.idxn, pbuf, MAXPATHLEN);                  strlcat(mdb.idxn, dir, MAXPATHLEN);
                   strlcat(mdb.idxn, "/", MAXPATHLEN);
                 sz2 = strlcat(mdb.idxn, MANDOC_IDX, MAXPATHLEN);                  sz2 = strlcat(mdb.idxn, MANDOC_IDX, MAXPATHLEN);
   
                 if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {                  if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {
                         fprintf(stderr, "%s: path too long\n", mdb.idxn);                          fprintf(stderr, "%s: path too long\n", dir);
                         exit((int)MANDOCLEVEL_BADARG);                          exit((int)MANDOCLEVEL_BADARG);
                 }                  }
   
Line 425 
Line 428 
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 ofile_argbuild(argc, argv, &of, pbuf);                  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 444 
Line 447 
                                 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 459 
Line 462 
         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++) {
   
                 /*                  /*
                  * Go to the root of the respective manual tree.                   * Go to the root of the respective manual tree.
                  * This must work or no manuals may be found:                   * This must work or no manuals may be found:
Line 520 
Line 517 
                  * Search for manuals and fill the new database.                   * Search for manuals and fill the new database.
                  */                   */
   
                 ofile_dirbuild(".", "", "", 0, &of);                  strlcpy(dirbuf, dirs.paths[i], MAXPATHLEN);
                   ofile_dirbuild(".", "", "", 0, &of, dirbuf);
   
                 if (NULL != of) {                  if (NULL != of) {
                         index_merge(of, mp, &dbuf, &buf, hash,                          index_merge(of, mp, &dbuf, &buf, hash,
                              &mdb, &recs);                               &mdb, &recs, dirs.paths[i]);
                         ofile_free(of);                          ofile_free(of);
                         of = NULL;                          of = NULL;
                 }                  }
Line 575 
Line 573 
   
 usage:  usage:
         fprintf(stderr,          fprintf(stderr,
                 "usage: %s [-avvv] [-C file] | dir ... | -t file ...\n"                  "usage: %s [-av] [-C file] | dir ... | -t file ...\n"
                 "                        -d dir [file ...] | "                  "                        -d dir [file ...] | "
                 "-u dir [file ...]\n",                  "-u dir [file ...]\n",
                 progname);                  progname);
Line 586 
Line 584 
 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 */          DB              *files;  /* temporary file name table */
           char             emptystring[1] = {'\0'};
         struct mdoc     *mdoc;          struct mdoc     *mdoc;
         struct man      *man;          struct man      *man;
         const char      *fn, *msec, *march, *mtitle;  
         char            *p;          char            *p;
           const char      *fn, *msec, *march, *mtitle;
         uint64_t         mask;          uint64_t         mask;
         size_t           sv;          size_t           sv;
         unsigned         seq;          unsigned         seq;
Line 655 
Line 655 
                 skip = 0;                  skip = 0;
                 assert(of->sec);                  assert(of->sec);
                 assert(msec);                  assert(msec);
                 if (warnings)                  if (strcasecmp(msec, of->sec))
                         if (strcasecmp(msec, of->sec))                          WARNING(fn, basedir, "Section \"%s\" manual "
                                 fprintf(stderr, "%s: "                                  "in \"%s\" directory", msec, of->sec);
                                         "section \"%s\" manual "  
                                         "in \"%s\" directory\n",  
                                         fn, msec, of->sec);  
   
                 /*                  /*
                  * 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 679 
Line 675 
   
                 assert(of->arch);                  assert(of->arch);
                 assert(march);                  assert(march);
                 if (warnings)                  if (strcasecmp(march, of->arch))
                         if (strcasecmp(march, of->arch))                          WARNING(fn, basedir, "Architecture \"%s\" "
                                 fprintf(stderr, "%s: "                                  "manual in \"%s\" directory",
                                         "architecture \"%s\" manual "                                  march, of->arch);
                                         "in \"%s\" directory\n",  
                                         fn, march, of->arch);  
   
                 /*                  /*
                  * By default, skip a file if the title given                   * By default, skip a file if the title given
Line 720 
Line 714 
                         val.data = NULL;                          val.data = NULL;
                         val.size = 0;                          val.size = 0;
                         if (0 == skip)                          if (0 == skip)
                                 val.data = "";                                  val.data = emptystring;
                         else {                          else {
                                 ch = (*files->get)(files, &key, &val, 0);                                  ch = (*files->get)(files, &key, &val, 0);
                                 if (ch < 0) {                                  if (ch < 0) {
Line 774 
Line 768 
                 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 821 
Line 815 
                 }                  }
                 if (ch < 0) {                  if (ch < 0) {
                         perror("hash");                          perror("hash");
                         unlink(mdb->dbn);  
                         unlink(mdb->idxn);  
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
Line 841 
Line 833 
                 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);
         }          }
Line 856 
Line 848 
                 while (0 == (*files->seq)(files, &key, &val, seq)) {                  while (0 == (*files->seq)(files, &key, &val, seq)) {
                         seq = R_NEXT;                          seq = R_NEXT;
                         if (val.size)                          if (val.size)
                                 fprintf(stderr, "%s: probably "                                  WARNING((char *)val.data, basedir,
                                     "unreachable, title is %s\n",                                          "Probably unreachable, title "
                                     (char *)val.data, (char *)key.data);                                          "is %s", (char *)key.data);
                 }                  }
                 (*files->close)(files);                  (*files->close)(files);
         }          }
Line 871 
Line 863 
  * 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 946 
Line 939 
                 }                  }
   
                 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 1506 
Line 1500 
  * 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;
         size_t           len, plen, titlesz;          size_t           len, plen, titlesz;
   
         if (NULL == (stream = fopen(of->fname, "r"))) {          if (NULL == (stream = fopen(of->fname, "r"))) {
                 if (warnings)                  WARNING(of->fname, basedir, "%s", strerror(errno));
                         perror(of->fname);  
                 return;                  return;
         }          }
   
Line 1570 
Line 1563 
                 title[(int)titlesz - 1] = ' ';                  title[(int)titlesz - 1] = ' ';
         }          }
   
   
         /*          /*
          * If no page content can be found, or the input line           * If no page content can be found, or the input line
          * is already the next section header, or there is no           * is already the next section header, or there is no
Line 1579 
Line 1571 
          */           */
   
         if (NULL == title || '\0' == *title) {          if (NULL == title || '\0' == *title) {
                 if (warnings)                  WARNING(of->fname, basedir,
                         fprintf(stderr, "%s: cannot find NAME section\n",                          "Cannot find NAME section");
                                         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 1602 
Line 1593 
                 for (p += 2; ' ' == *p || '\b' == *p; p++)                  for (p += 2; ' ' == *p || '\b' == *p; p++)
                         /* Skip to next word. */ ;                          /* Skip to next word. */ ;
         } else {          } else {
                 if (warnings)                  WARNING(of->fname, basedir,
                         fprintf(stderr, "%s: no dash in title line\n",                          "No dash in title line");
                                         of->fname);  
                 p = title;                  p = title;
         }          }
   
Line 1631 
Line 1621 
 }  }
   
 static void  static void
 ofile_argbuild(int argc, char *argv[], struct of **of,  ofile_argbuild(int argc, char *argv[],
                 const char *basedir)                  struct of **of, const char *basedir)
 {  {
         char             buf[MAXPATHLEN];          char             buf[MAXPATHLEN];
         char             pbuf[PATH_MAX];  
         const char      *sec, *arch, *title;          const char      *sec, *arch, *title;
         char            *relpath, *p;          char            *p;
         int              i, src_form;          int              i, src_form;
         struct of       *nof;          struct of       *nof;
   
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 if (NULL == (relpath = realpath(argv[i], pbuf))) {  
                         perror(argv[i]);  
                         continue;  
                 }  
                 if (NULL != basedir) {  
                         if (strstr(pbuf, basedir) != pbuf) {  
                                 fprintf(stderr, "%s: file outside "  
                                     "base directory %s\n",  
                                     pbuf, basedir);  
                                 continue;  
                         }  
                         relpath = pbuf + strlen(basedir);  
                 }  
   
                 /*                  /*
                  * Try to infer the manual section, architecture and                   * Try to infer the manual section, architecture and
Line 1663 
Line 1639 
                  *   cat<section>[/<arch>]/<title>.0                   *   cat<section>[/<arch>]/<title>.0
                  */                   */
   
                 if (strlcpy(buf, relpath, sizeof(buf)) >= sizeof(buf)) {                  if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {
                         fprintf(stderr, "%s: path too long\n", relpath);                          fprintf(stderr, "%s: Path too long\n", argv[i]);
                         continue;                          continue;
                 }                  }
                 sec = arch = title = "";                  sec = arch = title = "";
Line 1696 
Line 1672 
                         break;                          break;
                 }                  }
                 if ('\0' == *title) {                  if ('\0' == *title) {
                         if (warnings)                          WARNING(argv[i], basedir,
                                 fprintf(stderr,                                  "Cannot deduce title from filename");
                                     "%s: cannot deduce title "  
                                     "from filename\n",  
                                     relpath);  
                         title = buf;                          title = buf;
                 }                  }
   
Line 1709 
Line 1682 
                  */                   */
   
                 nof = mandoc_calloc(1, sizeof(struct of));                  nof = mandoc_calloc(1, sizeof(struct of));
                 nof->fname = mandoc_strdup(relpath);                  nof->fname = mandoc_strdup(argv[i]);
                 nof->sec = mandoc_strdup(sec);                  nof->sec = mandoc_strdup(sec);
                 nof->arch = mandoc_strdup(arch);                  nof->arch = mandoc_strdup(arch);
                 nof->title = mandoc_strdup(title);                  nof->title = mandoc_strdup(title);
Line 1720 
Line 1693 
                  */                   */
   
                 if (verb > 1)                  if (verb > 1)
                         printf("%s: scheduling\n", relpath);                          printf("%s: scheduling\n", argv[i]);
   
                 if (NULL == *of) {                  if (NULL == *of) {
                         *of = nof;                          *of = nof;
                         (*of)->first = nof;                          (*of)->first = nof;
Line 1742 
Line 1716 
  */   */
 static void  static void
 ofile_dirbuild(const char *dir, const char* psec, const char *parch,  ofile_dirbuild(const char *dir, const char* psec, const char *parch,
                 int p_src_form, struct of **of)                  int p_src_form, struct of **of, char *basedir)
 {  {
         char             buf[MAXPATHLEN];          char             buf[MAXPATHLEN];
         size_t           sz;          size_t           sz;
Line 1754 
Line 1728 
         int              src_form;          int              src_form;
   
         if (NULL == (d = opendir(dir))) {          if (NULL == (d = opendir(dir))) {
                 if (warnings)                  WARNING("", dir, "%s", strerror(errno));
                         perror(dir);  
                 return;                  return;
         }          }
   
Line 1785 
Line 1758 
                                         src_form |= MANDOC_FORM;                                          src_form |= MANDOC_FORM;
                                         sec = fn + 3;                                          sec = fn + 3;
                                 } else {                                  } else {
                                         if (warnings) fprintf(stderr,                                          WARNING(fn, basedir, "Bad section");
                                             "%s/%s: bad section\n",  
                                             dir, fn);  
                                         if (use_all)                                          if (use_all)
                                                 sec = fn;                                                  sec = fn;
                                         else                                          else
Line 1795 
Line 1766 
                                 }                                  }
                         } else if ('\0' == *arch) {                          } else if ('\0' == *arch) {
                                 if (NULL != strchr(fn, '.')) {                                  if (NULL != strchr(fn, '.')) {
                                         if (warnings) fprintf(stderr,                                          WARNING(fn, basedir, "Bad architecture");
                                             "%s/%s: bad architecture\n",  
                                             dir, fn);  
                                         if (0 == use_all)                                          if (0 == use_all)
                                                 continue;                                                  continue;
                                 }                                  }
                                 arch = fn;                                  arch = fn;
                         } else {                          } else {
                                 if (warnings) fprintf(stderr, "%s/%s: "                                  WARNING(fn, basedir, "Excessive subdirectory");
                                     "excessive subdirectory\n", dir, fn);  
                                 if (0 == use_all)                                  if (0 == use_all)
                                         continue;                                          continue;
                         }                          }
Line 1812 
Line 1780 
                         buf[0] = '\0';                          buf[0] = '\0';
                         strlcat(buf, dir, MAXPATHLEN);                          strlcat(buf, dir, MAXPATHLEN);
                         strlcat(buf, "/", MAXPATHLEN);                          strlcat(buf, "/", MAXPATHLEN);
                           strlcat(basedir, "/", MAXPATHLEN);
                           strlcat(basedir, fn, MAXPATHLEN);
                         sz = strlcat(buf, fn, MAXPATHLEN);                          sz = strlcat(buf, fn, MAXPATHLEN);
   
                         if (MAXPATHLEN <= sz) {                          if (MAXPATHLEN <= sz) {
                                 if (warnings) fprintf(stderr, "%s/%s: "                                  WARNING(fn, basedir, "Path too long");
                                     "path too long\n", dir, fn);  
                                 continue;                                  continue;
                         }                          }
   
                         if (verb > 1)                          if (verb > 1)
                                 printf("%s: scanning\n", buf);                                  printf("%s: scanning\n", buf);
   
                         ofile_dirbuild(buf, sec, arch, src_form, of);                          ofile_dirbuild(buf, sec, arch,
                                           src_form, of, basedir);
   
                           p = strrchr(basedir, '/');
                           *p = '\0';
                         continue;                          continue;
                 }                  }
   
                 if (DT_REG != dp->d_type) {                  if (DT_REG != dp->d_type) {
                         if (warnings)                          WARNING(fn, basedir, "Not a regular file");
                                 fprintf(stderr,  
                                     "%s/%s: not a regular file\n",  
                                     dir, fn);  
                         continue;                          continue;
                 }                  }
                 if (!strcmp(MANDOC_DB, fn) || !strcmp(MANDOC_IDX, fn))                  if (!strcmp(MANDOC_DB, fn) || !strcmp(MANDOC_IDX, fn))
                         continue;                          continue;
                 if ('\0' == *psec) {                  if ('\0' == *psec) {
                         if (warnings)                          WARNING(fn, basedir, "File outside section");
                                 fprintf(stderr,  
                                     "%s/%s: file outside section\n",  
                                     dir, fn);  
                         if (0 == use_all)                          if (0 == use_all)
                                 continue;                                  continue;
                 }                  }
Line 1853 
Line 1820 
   
                 suffix = strrchr(fn, '.');                  suffix = strrchr(fn, '.');
                 if (NULL == suffix) {                  if (NULL == suffix) {
                         if (warnings)                          WARNING(fn, basedir, "No filename suffix");
                                 fprintf(stderr,  
                                     "%s/%s: no filename suffix\n",  
                                     dir, fn);  
                         if (0 == use_all)                          if (0 == use_all)
                                 continue;                                  continue;
                 } else if ((MANDOC_SRC & src_form &&                  } else if ((MANDOC_SRC & src_form &&
                                 strcmp(suffix + 1, psec)) ||                                  strcmp(suffix + 1, psec)) ||
                             (MANDOC_FORM & src_form &&                              (MANDOC_FORM & src_form &&
                                 strcmp(suffix + 1, "0"))) {                                  strcmp(suffix + 1, "0"))) {
                         if (warnings)                          WARNING(fn, basedir, "Wrong filename suffix");
                                 fprintf(stderr,  
                                     "%s/%s: wrong filename suffix\n",  
                                     dir, fn);  
                         if (0 == use_all)                          if (0 == use_all)
                                 continue;                                  continue;
                         if ('0' == suffix[1])                          if ('0' == suffix[1])
Line 1900 
Line 1861 
                         strlcat(buf, "/", MAXPATHLEN);                          strlcat(buf, "/", MAXPATHLEN);
                         sz = strlcat(buf, fn, MAXPATHLEN);                          sz = strlcat(buf, fn, MAXPATHLEN);
                         if (sz >= MAXPATHLEN) {                          if (sz >= MAXPATHLEN) {
                                 if (warnings) fprintf(stderr,                                  WARNING(fn, basedir, "Path too long");
                                     "%s/%s: path too long\n",  
                                     dir, fn);  
                                 continue;                                  continue;
                         }                          }
                         q = strrchr(buf, '.');                          q = strrchr(buf, '.');
Line 1910 
Line 1869 
                                 *q = '\0';                                  *q = '\0';
                                 sz = strlcat(buf, psec, MAXPATHLEN);                                  sz = strlcat(buf, psec, MAXPATHLEN);
                                 if (sz >= MAXPATHLEN) {                                  if (sz >= MAXPATHLEN) {
                                         if (warnings) fprintf(stderr,                                          WARNING(fn, basedir, "Path too long");
                                             "%s/%s: path too long\n",  
                                             dir, fn);  
                                         continue;                                          continue;
                                 }                                  }
                                 if (0 == access(buf, R_OK))                                  if (0 == access(buf, R_OK))
Line 1928 
Line 1885 
                 }                  }
                 sz = strlcat(buf, fn, MAXPATHLEN);                  sz = strlcat(buf, fn, MAXPATHLEN);
                 if (sz >= MAXPATHLEN) {                  if (sz >= MAXPATHLEN) {
                         if (warnings) fprintf(stderr,                          WARNING(fn, basedir, "Path too long");
                             "%s/%s: path too long\n", dir, fn);  
                         continue;                          continue;
                 }                  }
   
Legend:
Removed from v.1.39  
changed lines
  Added in v.1.40