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

Diff for /mandoc/mandocdb.c between version 1.45 and 1.49.2.12

version 1.45, 2012/03/23 05:45:45 version 1.49.2.12, 2014/03/19 22:09:29
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2011, 2012 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 19 
Line 19 
 #include "config.h"  #include "config.h"
 #endif  #endif
   
 #include <sys/param.h>  
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
Line 28 
Line 27 
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
   #include <limits.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdint.h>  #include <stdint.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #if defined(__linux__)  #if defined(__APPLE__)
   # include <libkern/OSByteOrder.h>
   #elif defined(__linux__)
 # include <endian.h>  # include <endian.h>
   #elif defined(__sun)
   # include <sys/byteorder.h>
   # include <sys/stat.h>
   #else
   # include <sys/endian.h>
   #endif
   
   #if defined(__linux__) || defined(__sun)
 # include <db_185.h>  # include <db_185.h>
 #elif defined(__APPLE__)  
 # include <libkern/OSByteOrder.h>  
 # include <db.h>  
 #else  #else
 # include <db.h>  # include <db.h>
 #endif  #endif
Line 56 
Line 63 
 #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 {
         char              idxn[MAXPATHLEN]; /* index db filename */          char              idxn[PATH_MAX]; /* index db filename */
         char              dbn[MAXPATHLEN]; /* keyword db filename */          char              dbn[PATH_MAX]; /* keyword db filename */
         DB               *idx; /* index recno database */          DB               *idx; /* index recno database */
         DB               *db; /* keyword btree database */          DB               *db; /* keyword btree database */
 };  };
Line 133  static void    hash_put(DB *, const struct buf *, uint
Line 131  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 *, const char *);                                  struct recs *);
 static  void              ofile_argbuild(int, char *[],  static  void              ofile_argbuild(int, char *[], struct of **,
                                 struct of **, const char *);                                  const char *);
 static  void              ofile_dirbuild(const char *, const char *,  static  void              ofile_dirbuild(const char *, const char *,
                                 const char *, int, struct of **, char *);                                  const char *, int, struct of **);
 static  void              ofile_free(struct of *);  static  void              ofile_free(struct of *);
 static  void              pformatted(DB *, struct buf *, struct buf *,  static  void              pformatted(DB *, struct buf *,
                                 const struct of *, const char *);                                  struct buf *, const struct of *);
 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 291  static const struct mdoc_handler mdocs[MDOC_MAX] = {
Line 288  static const struct mdoc_handler mdocs[MDOC_MAX] = {
 };  };
   
 static  const char       *progname;  static  const char       *progname;
   static  int               mparse_options;  /* abort the parse early */
 static  int               use_all;  /* Use all directories and files. */  static  int               use_all;  /* Use all directories and files. */
 static  int               verb;  /* Output verbosity level. */  static  int               verb;  /* Output verbosity level. */
 static  int               warnings;  /* Potential problems in manuals. */  static  int               warnings;  /* Potential problems in manuals. */
Line 304  main(int argc, char *argv[])
Line 302  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;
         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, ipath;
         struct buf       buf, /* keyword buffer */          struct buf       buf, /* keyword buffer */
                          dbuf; /* description buffer */                           dbuf; /* description buffer */
         struct of       *of; /* list of files for processing */          struct of       *of; /* list of files for processing */
Line 330  main(int argc, char *argv[])
Line 329  main(int argc, char *argv[])
         hash = NULL;          hash = NULL;
         op = OP_DEFAULT;          op = OP_DEFAULT;
         dir = NULL;          dir = NULL;
           mparse_options = MPARSE_SO;
   
         while (-1 != (ch = getopt(argc, argv, "aC:d:tu:vW")))          while (-1 != (ch = getopt(argc, argv, "aC:d:Qtu:vW")))
                 switch (ch) {                  switch (ch) {
                 case ('a'):                  case ('a'):
                         use_all = 1;                          use_all = 1;
Line 354  main(int argc, char *argv[])
Line 354  main(int argc, char *argv[])
                         dir = optarg;                          dir = optarg;
                         op = OP_UPDATE;                          op = OP_UPDATE;
                         break;                          break;
                   case ('Q'):
                           mparse_options |= MPARSE_QUICK;
                           break;
                 case ('t'):                  case ('t'):
                         dup2(STDOUT_FILENO, STDERR_FILENO);                          dup2(STDOUT_FILENO, STDERR_FILENO);
                         if (op) {                          if (op) {
Line 396  main(int argc, char *argv[])
Line 399  main(int argc, char *argv[])
         info.lorder = 4321;          info.lorder = 4321;
         info.flags = R_DUP;          info.flags = R_DUP;
   
         mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);          mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL, NULL);
   
         memset(&buf, 0, sizeof(struct buf));          memset(&buf, 0, sizeof(struct buf));
         memset(&dbuf, 0, sizeof(struct buf));          memset(&dbuf, 0, sizeof(struct buf));
Line 407  main(int argc, char *argv[])
Line 410  main(int argc, char *argv[])
         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, ".");                  ofile_argbuild(argc, argv, &of, NULL);
                 if (NULL == of)                  if (NULL == of)
                         goto out;                          goto out;
                 index_merge(of, mp, &dbuf, &buf,                  index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);
                                 hash, &mdb, &recs, ".");  
                 goto out;                  goto out;
         }          }
   
         if (OP_UPDATE == op || OP_DELETE == op) {          if (OP_UPDATE == op || OP_DELETE == op) {
                 strlcat(mdb.dbn, dir, MAXPATHLEN);                  if (NULL == realpath(dir, pbuf)) {
                 strlcat(mdb.dbn, "/", MAXPATHLEN);                          perror(dir);
                 sz1 = strlcat(mdb.dbn, MANDOC_DB, 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.idxn, dir, MAXPATHLEN);                  strlcat(mdb.dbn, pbuf, PATH_MAX);
                 strlcat(mdb.idxn, "/", MAXPATHLEN);                  sz1 = strlcat(mdb.dbn, MANDOC_DB, PATH_MAX);
                 sz2 = strlcat(mdb.idxn, MANDOC_IDX, MAXPATHLEN);  
   
                 if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {                  strlcat(mdb.idxn, pbuf, PATH_MAX);
                         fprintf(stderr, "%s: path too long\n", dir);                  sz2 = strlcat(mdb.idxn, MANDOC_IDX, PATH_MAX);
   
                   if (sz1 >= PATH_MAX || sz2 >= PATH_MAX) {
                           fprintf(stderr, "%s: path too long\n", mdb.idxn);
                         exit((int)MANDOCLEVEL_BADARG);                          exit((int)MANDOCLEVEL_BADARG);
                 }                  }
   
Line 441  main(int argc, char *argv[])
Line 450  main(int argc, char *argv[])
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 ofile_argbuild(argc, argv, &of, dir);                  ofile_argbuild(argc, argv, &of, pbuf);
   
                 if (NULL == of)                  if (NULL == of)
                         goto out;                          goto out;
   
                 index_prune(of, &mdb, &recs, dir);                  index_prune(of, &mdb, &recs);
   
                 /*                  /*
                  * Go to the root of the respective manual tree.                   * Go to the root of the respective manual tree.
Line 460  main(int argc, char *argv[])
Line 469  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, dir);                                          &mdb, &recs);
                 }                  }
   
                 goto out;                  goto out;
Line 475  main(int argc, char *argv[])
Line 484  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++) {
                         dirs.paths[i] = mandoc_strdup(argv[i]);                          if (NULL == (cp = realpath(argv[i], pbuf))) {
                                   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 (ipath = 0; ipath < dirs.sz; ipath++) {
   
                 /*                  /*
                  * 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:
                  * They are indexed relative to the root.                   * They are indexed relative to the root.
                  */                   */
   
                 if (-1 == chdir(dirs.paths[i])) {                  if (-1 == chdir(dirs.paths[ipath])) {
                         perror(dirs.paths[i]);                          perror(dirs.paths[ipath]);
                         exit((int)MANDOCLEVEL_SYSERR);                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
   
                 strlcpy(mdb.dbn, MANDOC_DB, MAXPATHLEN);                  /* Create a new database in two temporary files. */
                 strlcpy(mdb.idxn, MANDOC_IDX, MAXPATHLEN);  
   
                 flags = O_CREAT | O_TRUNC | O_RDWR;                  flags = O_CREAT | O_EXCL | O_RDWR;
                 mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);                  while (NULL == mdb.db) {
                 mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);                          strlcpy(mdb.dbn, MANDOC_DB, PATH_MAX);
                           strlcat(mdb.dbn, ".XXXXXXXXXX", PATH_MAX);
                 if (NULL == mdb.db) {                          if (NULL == mktemp(mdb.dbn)) {
                         perror(mdb.dbn);                                  perror(mdb.dbn);
                         exit((int)MANDOCLEVEL_SYSERR);                                  exit((int)MANDOCLEVEL_SYSERR);
                 } else if (NULL == mdb.idx) {                          }
                         perror(mdb.idxn);                          mdb.db = dbopen(mdb.dbn, flags, 0644,
                         exit((int)MANDOCLEVEL_SYSERR);                                          DB_BTREE, &info);
                           if (NULL == mdb.db && EEXIST != errno) {
                                   perror(mdb.dbn);
                                   exit((int)MANDOCLEVEL_SYSERR);
                           }
                 }                  }
                   while (NULL == mdb.idx) {
                           strlcpy(mdb.idxn, MANDOC_IDX, PATH_MAX);
                           strlcat(mdb.idxn, ".XXXXXXXXXX", PATH_MAX);
                           if (NULL == mktemp(mdb.idxn)) {
                                   perror(mdb.idxn);
                                   unlink(mdb.dbn);
                                   exit((int)MANDOCLEVEL_SYSERR);
                           }
                           mdb.idx = dbopen(mdb.idxn, flags, 0644,
                                           DB_RECNO, NULL);
                           if (NULL == mdb.idx && EEXIST != errno) {
                                   perror(mdb.idxn);
                                   unlink(mdb.dbn);
                                   exit((int)MANDOCLEVEL_SYSERR);
                           }
                   }
   
                 /*                  /*
                  * Search for manuals and fill the new database.                   * Search for manuals and fill the new database.
                  */                   */
   
                 strlcpy(dirbuf, dirs.paths[i], MAXPATHLEN);                  ofile_dirbuild(".", "", "", 0, &of);
                 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, dirs.paths[i]);                               &mdb, &recs);
                         ofile_free(of);                          ofile_free(of);
                         of = NULL;                          of = NULL;
                 }                  }
Line 525  main(int argc, char *argv[])
Line 558  main(int argc, char *argv[])
                 (*mdb.idx->close)(mdb.idx);                  (*mdb.idx->close)(mdb.idx);
                 mdb.db = NULL;                  mdb.db = NULL;
                 mdb.idx = NULL;                  mdb.idx = NULL;
   
                   /*
                    * Replace the old database with the new one.
                    * This is not perfectly atomic,
                    * but i cannot think of a better way.
                    */
   
                   if (-1 == rename(mdb.dbn, MANDOC_DB)) {
                           perror(MANDOC_DB);
                           unlink(mdb.dbn);
                           unlink(mdb.idxn);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
                   if (-1 == rename(mdb.idxn, MANDOC_IDX)) {
                           perror(MANDOC_IDX);
                           unlink(MANDOC_DB);
                           unlink(MANDOC_IDX);
                           unlink(mdb.idxn);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
         }          }
   
 out:  out:
Line 547  out:
Line 600  out:
   
 usage:  usage:
         fprintf(stderr,          fprintf(stderr,
                 "usage: %s [-avvv] [-C file] | dir ... | -t file ...\n"                  "usage: %s [-aQvvv] [-C file] | dir ... | -t file ...\n"
                 "                        -d dir [file ...] | "                  "                        -d dir [file ...] | "
                 "-u dir [file ...]\n",                  "-u dir [file ...]\n",
                 progname);                  progname);
Line 558  usage:
Line 611  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 */          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;
           char            *p;
         uint64_t         mask;          uint64_t         mask;
         size_t           sv;          size_t           sv;
         unsigned         seq;          unsigned         seq;
         uint64_t         vbuf[2];          uint64_t         vbuf[2];
         char             type;          char             type;
   
           static char      emptystring[] = "";
   
         if (warnings) {          if (warnings) {
                 files = NULL;                  files = NULL;
                 hash_reset(&files);                  hash_reset(&files);
Line 629  index_merge(const struct of *of, struct mparse *mp,
Line 682  index_merge(const struct of *of, struct mparse *mp,
                 skip = 0;                  skip = 0;
                 assert(of->sec);                  assert(of->sec);
                 assert(msec);                  assert(msec);
                 if (strcasecmp(msec, of->sec))                  if (warnings)
                         WARNING(fn, basedir, "Section \"%s\" manual "                          if (strcasecmp(msec, of->sec))
                                 "in \"%s\" directory", msec, of->sec);                                  fprintf(stderr, "%s: "
                                           "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 649  index_merge(const struct of *of, struct mparse *mp,
Line 706  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)
                         WARNING(fn, basedir, "Architecture \"%s\" "                          if (strcasecmp(march, of->arch))
                                 "manual in \"%s\" directory",                                  fprintf(stderr, "%s: "
                                 march, of->arch);                                          "architecture \"%s\" manual "
                                           "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 682  index_merge(const struct of *of, struct mparse *mp,
Line 741  index_merge(const struct of *of, struct mparse *mp,
                         }                          }
                         buf_appendb(buf, ")", 2);                          buf_appendb(buf, ")", 2);
                         for (p = buf->cp; '\0' != *p; p++)                          for (p = buf->cp; '\0' != *p; p++)
                                 *p = tolower(*p);                                  *p = tolower((unsigned char)*p);
                         key.data = buf->cp;                          key.data = buf->cp;
                         key.size = buf->len;                          key.size = buf->len;
                         val.data = NULL;                          val.data = NULL;
Line 742  index_merge(const struct of *of, struct mparse *mp,
Line 801  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, basedir);                          pformatted(hash, buf, dbuf, of);
   
                 /* Test mode, do not access any database. */                  /* Test mode, do not access any database. */
   
Line 789  index_merge(const struct of *of, struct mparse *mp,
Line 848  index_merge(const struct of *of, struct mparse *mp,
                 }                  }
                 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 807  index_merge(const struct of *of, struct mparse *mp,
Line 868  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: %s\n", basedir, fn);                          printf("%s: adding to index\n", fn);
   
                 dbt_put(mdb->idx, mdb->idxn, &key, &val);                  dbt_put(mdb->idx, mdb->idxn, &key, &val);
         }          }
Line 837  index_merge(const struct of *of, struct mparse *mp,
Line 898  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,  index_prune(const struct of *ofile, struct mdb *mdb, struct recs *recs)
                 struct recs *recs, const char *basedir)  
 {  {
         const struct of *of;          const struct of *of;
         const char      *fn;          const char      *fn;
Line 913  index_prune(const struct of *ofile, struct mdb *mdb, 
Line 973  index_prune(const struct of *ofile, struct mdb *mdb, 
                 }                  }
   
                 if (verb)                  if (verb)
                         printf("%s: Deleting from index: %s\n",                          printf("%s: deleting from index\n", fn);
                                         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 1323  static int
Line 1382  static int
 pman_node(MAN_ARGS)  pman_node(MAN_ARGS)
 {  {
         const struct man_node *head, *body;          const struct man_node *head, *body;
         const char      *start, *sv;          char            *start, *sv, *title;
         size_t           sz;          size_t           sz, titlesz;
   
         if (NULL == n)          if (NULL == n)
                 return(0);                  return(0);
Line 1347  pman_node(MAN_ARGS)
Line 1406  pman_node(MAN_ARGS)
                                 NULL != (body = body->child) &&                                  NULL != (body = body->child) &&
                                 MAN_TEXT == body->type) {                                  MAN_TEXT == body->type) {
   
                         assert(body->string);                          title = NULL;
                         start = sv = body->string;                          titlesz = 0;
                           /*
                            * Suck the entire NAME section into memory.
                            * Yes, we might run away.
                            * But too many manuals have big, spread-out
                            * NAME sections over many lines.
                            */
                           for ( ; NULL != body; body = body->next) {
                                   if (MAN_TEXT != body->type)
                                           break;
                                   if (0 == (sz = strlen(body->string)))
                                           continue;
                                   title = mandoc_realloc
                                           (title, titlesz + sz + 1);
                                   memcpy(title + titlesz, body->string, sz);
                                   titlesz += sz + 1;
                                   title[(int)titlesz - 1] = ' ';
                           }
                           if (NULL == title)
                                   return(0);
   
                           title = mandoc_realloc(title, titlesz + 1);
                           title[(int)titlesz] = '\0';
   
                           /* Skip leading space.  */
   
                           sv = title;
                           while (isspace((unsigned char)*sv))
                                   sv++;
   
                           if (0 == (sz = strlen(sv))) {
                                   free(title);
                                   return(0);
                           }
   
                           /* Erase trailing space. */
   
                           start = &sv[sz - 1];
                           while (start > sv && isspace((unsigned char)*start))
                                   *start-- = '\0';
   
                           if (start == sv) {
                                   free(title);
                                   return(0);
                           }
   
                           start = sv;
   
                         /*                          /*
                          * Go through a special heuristic dance here.                           * Go through a special heuristic dance here.
                          * This is why -man manuals are great!                           * This is why -man manuals are great!
Line 1386  pman_node(MAN_ARGS)
Line 1491  pman_node(MAN_ARGS)
   
                         if (sv == start) {                          if (sv == start) {
                                 buf_append(buf, start);                                  buf_append(buf, start);
                                   free(title);
                                 return(1);                                  return(1);
                         }                          }
   
                         while (' ' == *start)                          while (isspace((unsigned char)*start))
                                 start++;                                  start++;
   
                         if (0 == strncmp(start, "-", 1))                          if (0 == strncmp(start, "-", 1))
Line 1411  pman_node(MAN_ARGS)
Line 1517  pman_node(MAN_ARGS)
                         buf_appendb(buf, start, sz);                          buf_appendb(buf, start, sz);
   
                         hash_put(hash, buf, TYPE_Nd);                          hash_put(hash, buf, TYPE_Nd);
                           free(title);
                 }                  }
         }          }
   
Line 1426  pman_node(MAN_ARGS)
Line 1533  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, struct buf *dbuf,  pformatted(DB *hash, struct buf *buf,
                 const struct of *of, const char *basedir)                  struct buf *dbuf, const struct of *of)
 {  {
         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"))) {
                 WARNING(of->fname, basedir, "%s", strerror(errno));                  if (warnings)
                           perror(of->fname);
                 return;                  return;
         }          }
   
Line 1489  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
Line 1597  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
                 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 1497  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
Line 1606  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
          */           */
   
         if (NULL == title || '\0' == *title) {          if (NULL == title || '\0' == *title) {
                 WARNING(of->fname, basedir,                  if (warnings)
                         "Cannot find NAME section");                          fprintf(stderr, "%s: cannot find NAME section\n",
                                           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 1519  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
Line 1629  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
                 for (p += 2; ' ' == *p || '\b' == *p; p++)                  for (p += 2; ' ' == *p || '\b' == *p; p++)
                         /* Skip to next word. */ ;                          /* Skip to next word. */ ;
         } else {          } else {
                 WARNING(of->fname, basedir,                  if (warnings)
                         "No dash in title line");                          fprintf(stderr, "%s: no dash in title line\n",
                                           of->fname);
                 p = title;                  p = title;
         }          }
   
Line 1547  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
Line 1658  pformatted(DB *hash, struct buf *buf, struct buf *dbuf
 }  }
   
 static void  static void
 ofile_argbuild(int argc, char *argv[],  ofile_argbuild(int argc, char *argv[], struct of **of,
                 struct of **of, const char *basedir)                  const char *basedir)
 {  {
         char             buf[MAXPATHLEN];          char             buf[PATH_MAX];
           char             pbuf[PATH_MAX];
         const char      *sec, *arch, *title;          const char      *sec, *arch, *title;
         char            *p;          char            *relpath, *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 1565  ofile_argbuild(int argc, char *argv[], 
Line 1690  ofile_argbuild(int argc, char *argv[], 
                  *   cat<section>[/<arch>]/<title>.0                   *   cat<section>[/<arch>]/<title>.0
                  */                   */
   
                 if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {                  if (strlcpy(buf, relpath, sizeof(buf)) >= sizeof(buf)) {
                         fprintf(stderr, "%s: Path too long\n", argv[i]);                          fprintf(stderr, "%s: path too long\n", relpath);
                         continue;                          continue;
                 }                  }
                 sec = arch = title = "";                  sec = arch = title = "";
Line 1598  ofile_argbuild(int argc, char *argv[], 
Line 1723  ofile_argbuild(int argc, char *argv[], 
                         break;                          break;
                 }                  }
                 if ('\0' == *title) {                  if ('\0' == *title) {
                         WARNING(argv[i], basedir,                          if (warnings)
                                 "Cannot deduce title from filename");                                  fprintf(stderr,
                                       "%s: cannot deduce title "
                                       "from filename\n",
                                       relpath);
                         title = buf;                          title = buf;
                 }                  }
   
Line 1608  ofile_argbuild(int argc, char *argv[], 
Line 1736  ofile_argbuild(int argc, char *argv[], 
                  */                   */
   
                 nof = mandoc_calloc(1, sizeof(struct of));                  nof = mandoc_calloc(1, sizeof(struct of));
                 nof->fname = mandoc_strdup(argv[i]);                  nof->fname = mandoc_strdup(relpath);
                 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 1633  ofile_argbuild(int argc, char *argv[], 
Line 1761  ofile_argbuild(int argc, char *argv[], 
  * 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 mandocdb.db and mandocdb.index files, but assumes that   * This ignores the mandoc.db and mandoc.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.
  */   */
 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, char *basedir)                  int p_src_form, struct of **of)
 {  {
         char             buf[MAXPATHLEN];          char             buf[PATH_MAX];
   #if defined(__sun)
           struct stat      sb;
   #endif
         size_t           sz;          size_t           sz;
         DIR             *d;          DIR             *d;
         const char      *fn, *sec, *arch;          const char      *fn, *sec, *arch;
Line 1651  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1782  ofile_dirbuild(const char *dir, const char* psec, cons
         int              src_form;          int              src_form;
   
         if (NULL == (d = opendir(dir))) {          if (NULL == (d = opendir(dir))) {
                 WARNING("", dir, "%s", strerror(errno));                  if (warnings)
                           perror(dir);
                 return;                  return;
         }          }
   
Line 1663  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1795  ofile_dirbuild(const char *dir, const char* psec, cons
   
                 src_form = p_src_form;                  src_form = p_src_form;
   
   #if defined(__sun)
                   stat(dp->d_name, &sb);
                   if (S_IFDIR & sb.st_mode) {
   #else
                 if (DT_DIR == dp->d_type) {                  if (DT_DIR == dp->d_type) {
   #endif
                         sec = psec;                          sec = psec;
                         arch = parch;                          arch = parch;
   
Line 1681  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1818  ofile_dirbuild(const char *dir, const char* psec, cons
                                         src_form |= MANDOC_FORM;                                          src_form |= MANDOC_FORM;
                                         sec = fn + 3;                                          sec = fn + 3;
                                 } else {                                  } else {
                                         WARNING(fn, basedir, "Bad section");                                          if (warnings) fprintf(stderr,
                                               "%s/%s: bad section\n",
                                               dir, fn);
                                         if (use_all)                                          if (use_all)
                                                 sec = fn;                                                  sec = fn;
                                         else                                          else
Line 1689  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1828  ofile_dirbuild(const char *dir, const char* psec, cons
                                 }                                  }
                         } else if ('\0' == *arch) {                          } else if ('\0' == *arch) {
                                 if (NULL != strchr(fn, '.')) {                                  if (NULL != strchr(fn, '.')) {
                                         WARNING(fn, basedir, "Bad architecture");                                          if (warnings) fprintf(stderr,
                                               "%s/%s: bad architecture\n",
                                               dir, fn);
                                         if (0 == use_all)                                          if (0 == use_all)
                                                 continue;                                                  continue;
                                 }                                  }
                                 arch = fn;                                  arch = fn;
                         } else {                          } else {
                                 WARNING(fn, basedir, "Excessive subdirectory");                                  if (warnings) fprintf(stderr, "%s/%s: "
                                       "excessive subdirectory\n", dir, fn);
                                 if (0 == use_all)                                  if (0 == use_all)
                                         continue;                                          continue;
                         }                          }
   
                         buf[0] = '\0';                          buf[0] = '\0';
                         strlcat(buf, dir, MAXPATHLEN);                          strlcat(buf, dir, PATH_MAX);
                         strlcat(buf, "/", MAXPATHLEN);                          strlcat(buf, "/", PATH_MAX);
                         strlcat(basedir, "/", MAXPATHLEN);                          sz = strlcat(buf, fn, PATH_MAX);
                         strlcat(basedir, fn, MAXPATHLEN);  
                         sz = strlcat(buf, fn, MAXPATHLEN);  
   
                         if (MAXPATHLEN <= sz) {                          if (PATH_MAX <= sz) {
                                 WARNING(fn, basedir, "Path too long");                                  if (warnings) fprintf(stderr, "%s/%s: "
                                       "path too long\n", dir, fn);
                                 continue;                                  continue;
                         }                          }
   
                         ofile_dirbuild(buf, sec, arch,                          ofile_dirbuild(buf, sec, arch, src_form, of);
                                         src_form, of, basedir);  
   
                         p = strrchr(basedir, '/');  
                         *p = '\0';  
                         continue;                          continue;
                 }                  }
   
   #if defined(__sun)
                   if (0 == S_IFREG & sb.st_mode) {
   #else
                 if (DT_REG != dp->d_type) {                  if (DT_REG != dp->d_type) {
                         WARNING(fn, basedir, "Not a regular file");  #endif
                           if (warnings)
                                   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) {
                         WARNING(fn, basedir, "File outside section");                          if (warnings)
                                   fprintf(stderr,
                                       "%s/%s: file outside section\n",
                                       dir, fn);
                         if (0 == use_all)                          if (0 == use_all)
                                 continue;                                  continue;
                 }                  }
Line 1740  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1887  ofile_dirbuild(const char *dir, const char* psec, cons
   
                 suffix = strrchr(fn, '.');                  suffix = strrchr(fn, '.');
                 if (NULL == suffix) {                  if (NULL == suffix) {
                         WARNING(fn, basedir, "No filename suffix");                          if (warnings)
                                   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"))) {
                         WARNING(fn, basedir, "Wrong filename suffix");                          if (warnings)
                                   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 1766  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1919  ofile_dirbuild(const char *dir, const char* psec, cons
                 if (0 == use_all && MANDOC_FORM & src_form &&                  if (0 == use_all && MANDOC_FORM & src_form &&
                                 '\0' != *psec) {                                  '\0' != *psec) {
                         buf[0] = '\0';                          buf[0] = '\0';
                         strlcat(buf, dir, MAXPATHLEN);                          strlcat(buf, dir, PATH_MAX);
                         p = strrchr(buf, '/');                          p = strrchr(buf, '/');
                         if ('\0' != *parch && NULL != p)                          if ('\0' != *parch && NULL != p)
                                 for (p--; p > buf; p--)                                  for (p--; p > buf; p--)
Line 1778  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1931  ofile_dirbuild(const char *dir, const char* psec, cons
                                 p++;                                  p++;
                         if (0 == strncmp("cat", p, 3))                          if (0 == strncmp("cat", p, 3))
                                 memcpy(p, "man", 3);                                  memcpy(p, "man", 3);
                         strlcat(buf, "/", MAXPATHLEN);                          strlcat(buf, "/", PATH_MAX);
                         sz = strlcat(buf, fn, MAXPATHLEN);                          sz = strlcat(buf, fn, PATH_MAX);
                         if (sz >= MAXPATHLEN) {                          if (sz >= PATH_MAX) {
                                 WARNING(fn, basedir, "Path too long");                                  if (warnings) fprintf(stderr,
                                       "%s/%s: path too long\n",
                                       dir, fn);
                                 continue;                                  continue;
                         }                          }
                         q = strrchr(buf, '.');                          q = strrchr(buf, '.');
                         if (NULL != q && p < q++) {                          if (NULL != q && p < q++) {
                                 *q = '\0';                                  *q = '\0';
                                 sz = strlcat(buf, psec, MAXPATHLEN);                                  sz = strlcat(buf, psec, PATH_MAX);
                                 if (sz >= MAXPATHLEN) {                                  if (sz >= PATH_MAX) {
                                         WARNING(fn, basedir, "Path too long");                                          if (warnings) fprintf(stderr,
                                               "%s/%s: path too long\n",
                                               dir, fn);
                                         continue;                                          continue;
                                 }                                  }
                                 if (0 == access(buf, R_OK))                                  if (0 == access(buf, R_OK))
Line 1800  ofile_dirbuild(const char *dir, const char* psec, cons
Line 1957  ofile_dirbuild(const char *dir, const char* psec, cons
                 buf[0] = '\0';                  buf[0] = '\0';
                 assert('.' == dir[0]);                  assert('.' == dir[0]);
                 if ('/' == dir[1]) {                  if ('/' == dir[1]) {
                         strlcat(buf, dir + 2, MAXPATHLEN);                          strlcat(buf, dir + 2, PATH_MAX);
                         strlcat(buf, "/", MAXPATHLEN);                          strlcat(buf, "/", PATH_MAX);
                 }                  }
                 sz = strlcat(buf, fn, MAXPATHLEN);                  sz = strlcat(buf, fn, PATH_MAX);
                 if (sz >= MAXPATHLEN) {                  if (sz >= PATH_MAX) {
                         WARNING(fn, basedir, "Path too long");                          if (warnings) fprintf(stderr,
                               "%s/%s: path too long\n", dir, fn);
                         continue;                          continue;
                 }                  }
   
Legend:
Removed from v.1.45  
changed lines
  Added in v.1.49.2.12
CVSweb