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

Diff for /mandoc/mandocdb.c between version 1.223 and 1.249

version 1.223, 2016/07/29 15:23:57 version 1.249, 2017/05/05 15:17:32
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011-2016 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2011-2017 Ingo Schwarze <schwarze@openbsd.org>
    * Copyright (c) 2016 Ed Maste <emaste@freebsd.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 84  struct mpage {
Line 85  struct mpage {
         char            *arch;    /* architecture from file content */          char            *arch;    /* architecture from file content */
         char            *title;   /* title from file content */          char            *title;   /* title from file content */
         char            *desc;    /* description from file content */          char            *desc;    /* description from file content */
           struct mpage    *next;    /* singly linked list */
         struct mlink    *mlinks;  /* singly linked list */          struct mlink    *mlinks;  /* singly linked list */
         int              name_head_done;          int              name_head_done;
         enum form        form;    /* format from file content */          enum form        form;    /* format from file content */
Line 108  typedef int (*mdoc_fp)(struct mpage *, const struct ro
Line 110  typedef int (*mdoc_fp)(struct mpage *, const struct ro
 struct  mdoc_handler {  struct  mdoc_handler {
         mdoc_fp          fp; /* optional handler */          mdoc_fp          fp; /* optional handler */
         uint64_t         mask;  /* set unless handler returns 0 */          uint64_t         mask;  /* set unless handler returns 0 */
           int              taboo;  /* node flags that must not be set */
 };  };
   
   
Line 118  static void  dbadd_mlink(const struct mlink *mlink);
Line 121  static void  dbadd_mlink(const struct mlink *mlink);
 static  void     dbprune(struct dba *);  static  void     dbprune(struct dba *);
 static  void     dbwrite(struct dba *);  static  void     dbwrite(struct dba *);
 static  void     filescan(const char *);  static  void     filescan(const char *);
   #if HAVE_FTS_COMPARE_CONST
   static  int      fts_compare(const FTSENT *const *, const FTSENT *const *);
   #else
   static  int      fts_compare(const FTSENT **, const FTSENT **);
   #endif
 static  void     mlink_add(struct mlink *, const struct stat *);  static  void     mlink_add(struct mlink *, const struct stat *);
 static  void     mlink_check(struct mpage *, struct mlink *);  static  void     mlink_check(struct mpage *, struct mlink *);
 static  void     mlink_free(struct mlink *);  static  void     mlink_free(struct mlink *);
Line 151  static int  parse_mdoc_Xr(struct mpage *, const struct
Line 159  static int  parse_mdoc_Xr(struct mpage *, const struct
 static  void     putkey(const struct mpage *, char *, uint64_t);  static  void     putkey(const struct mpage *, char *, uint64_t);
 static  void     putkeys(const struct mpage *, char *, size_t, uint64_t);  static  void     putkeys(const struct mpage *, char *, size_t, uint64_t);
 static  void     putmdockey(const struct mpage *,  static  void     putmdockey(const struct mpage *,
                         const struct roff_node *, uint64_t);                          const struct roff_node *, uint64_t, int);
 static  int      render_string(char **, size_t *);  static  int      render_string(char **, size_t *);
 static  void     say(const char *, const char *, ...)  static  void     say(const char *, const char *, ...)
                         __attribute__((__format__ (printf, 2, 3)));                          __attribute__((__format__ (__printf__, 2, 3)));
 static  int      set_basedir(const char *, int);  static  int      set_basedir(const char *, int);
 static  int      treescan(void);  static  int      treescan(void);
 static  size_t   utf8(unsigned int, char [7]);  static  size_t   utf8(unsigned int, char [7]);
Line 168  static int   write_utf8; /* write UTF-8 output; else A
Line 176  static int   write_utf8; /* write UTF-8 output; else A
 static  int              exitcode; /* to be returned by main */  static  int              exitcode; /* to be returned by main */
 static  enum op          op; /* operational mode */  static  enum op          op; /* operational mode */
 static  char             basedir[PATH_MAX]; /* current base directory */  static  char             basedir[PATH_MAX]; /* current base directory */
   static  struct mpage    *mpage_head; /* list of distinct manual pages */
 static  struct ohash     mpages; /* table of distinct manual pages */  static  struct ohash     mpages; /* table of distinct manual pages */
 static  struct ohash     mlinks; /* table of directory entries */  static  struct ohash     mlinks; /* table of directory entries */
 static  struct ohash     names; /* table of all names */  static  struct ohash     names; /* table of all names */
 static  struct ohash     strings; /* table of all strings */  static  struct ohash     strings; /* table of all strings */
 static  uint64_t         name_mask;  static  uint64_t         name_mask;
   
 static  const struct mdoc_handler mdocs[MDOC_MAX] = {  static  const struct mdoc_handler __mdocs[MDOC_MAX - MDOC_Dd] = {
         { NULL, 0 },  /* Ap */          { NULL, 0, NODE_NOPRT },  /* Dd */
         { NULL, 0 },  /* Dd */          { NULL, 0, NODE_NOPRT },  /* Dt */
         { NULL, 0 },  /* Dt */          { NULL, 0, NODE_NOPRT },  /* Os */
         { NULL, 0 },  /* Os */          { parse_mdoc_Sh, TYPE_Sh, 0 }, /* Sh */
         { parse_mdoc_Sh, TYPE_Sh }, /* Sh */          { parse_mdoc_head, TYPE_Ss, 0 }, /* Ss */
         { parse_mdoc_head, TYPE_Ss }, /* Ss */          { NULL, 0, 0 },  /* Pp */
         { NULL, 0 },  /* Pp */          { NULL, 0, 0 },  /* D1 */
         { NULL, 0 },  /* D1 */          { NULL, 0, 0 },  /* Dl */
         { NULL, 0 },  /* Dl */          { NULL, 0, 0 },  /* Bd */
         { NULL, 0 },  /* Bd */          { NULL, 0, 0 },  /* Ed */
         { NULL, 0 },  /* Ed */          { NULL, 0, 0 },  /* Bl */
         { NULL, 0 },  /* Bl */          { NULL, 0, 0 },  /* El */
         { NULL, 0 },  /* El */          { NULL, 0, 0 },  /* It */
         { NULL, 0 },  /* It */          { NULL, 0, 0 },  /* Ad */
         { NULL, 0 },  /* Ad */          { NULL, TYPE_An, 0 },  /* An */
         { NULL, TYPE_An },  /* An */          { NULL, 0, 0 },  /* Ap */
         { NULL, TYPE_Ar },  /* Ar */          { NULL, TYPE_Ar, 0 },  /* Ar */
         { NULL, TYPE_Cd },  /* Cd */          { NULL, TYPE_Cd, 0 },  /* Cd */
         { NULL, TYPE_Cm },  /* Cm */          { NULL, TYPE_Cm, 0 },  /* Cm */
         { NULL, TYPE_Dv },  /* Dv */          { NULL, TYPE_Dv, 0 },  /* Dv */
         { NULL, TYPE_Er },  /* Er */          { NULL, TYPE_Er, 0 },  /* Er */
         { NULL, TYPE_Ev },  /* Ev */          { NULL, TYPE_Ev, 0 },  /* Ev */
         { NULL, 0 },  /* Ex */          { NULL, 0, 0 },  /* Ex */
         { NULL, TYPE_Fa },  /* Fa */          { NULL, TYPE_Fa, 0 },  /* Fa */
         { parse_mdoc_Fd, 0 },  /* Fd */          { parse_mdoc_Fd, 0, 0 },  /* Fd */
         { NULL, TYPE_Fl },  /* Fl */          { NULL, TYPE_Fl, 0 },  /* Fl */
         { parse_mdoc_Fn, 0 },  /* Fn */          { parse_mdoc_Fn, 0, 0 },  /* Fn */
         { NULL, TYPE_Ft },  /* Ft */          { NULL, TYPE_Ft, 0 },  /* Ft */
         { NULL, TYPE_Ic },  /* Ic */          { NULL, TYPE_Ic, 0 },  /* Ic */
         { NULL, TYPE_In },  /* In */          { NULL, TYPE_In, 0 },  /* In */
         { NULL, TYPE_Li },  /* Li */          { NULL, TYPE_Li, 0 },  /* Li */
         { parse_mdoc_Nd, 0 },  /* Nd */          { parse_mdoc_Nd, 0, 0 },  /* Nd */
         { parse_mdoc_Nm, 0 },  /* Nm */          { parse_mdoc_Nm, 0, 0 },  /* Nm */
         { NULL, 0 },  /* Op */          { NULL, 0, 0 },  /* Op */
         { NULL, 0 },  /* Ot */          { NULL, 0, 0 },  /* Ot */
         { NULL, TYPE_Pa },  /* Pa */          { NULL, TYPE_Pa, NODE_NOSRC },  /* Pa */
         { NULL, 0 },  /* Rv */          { NULL, 0, 0 },  /* Rv */
         { NULL, TYPE_St },  /* St */          { NULL, TYPE_St, 0 },  /* St */
         { parse_mdoc_Va, TYPE_Va },  /* Va */          { parse_mdoc_Va, TYPE_Va, 0 },  /* Va */
         { parse_mdoc_Va, TYPE_Vt },  /* Vt */          { parse_mdoc_Va, TYPE_Vt, 0 },  /* Vt */
         { parse_mdoc_Xr, 0 },  /* Xr */          { parse_mdoc_Xr, 0, 0 },  /* Xr */
         { NULL, 0 },  /* %A */          { NULL, 0, 0 },  /* %A */
         { NULL, 0 },  /* %B */          { NULL, 0, 0 },  /* %B */
         { NULL, 0 },  /* %D */          { NULL, 0, 0 },  /* %D */
         { NULL, 0 },  /* %I */          { NULL, 0, 0 },  /* %I */
         { NULL, 0 },  /* %J */          { NULL, 0, 0 },  /* %J */
         { NULL, 0 },  /* %N */          { NULL, 0, 0 },  /* %N */
         { NULL, 0 },  /* %O */          { NULL, 0, 0 },  /* %O */
         { NULL, 0 },  /* %P */          { NULL, 0, 0 },  /* %P */
         { NULL, 0 },  /* %R */          { NULL, 0, 0 },  /* %R */
         { NULL, 0 },  /* %T */          { NULL, 0, 0 },  /* %T */
         { NULL, 0 },  /* %V */          { NULL, 0, 0 },  /* %V */
         { NULL, 0 },  /* Ac */          { NULL, 0, 0 },  /* Ac */
         { NULL, 0 },  /* Ao */          { NULL, 0, 0 },  /* Ao */
         { NULL, 0 },  /* Aq */          { NULL, 0, 0 },  /* Aq */
         { NULL, TYPE_At },  /* At */          { NULL, TYPE_At, 0 },  /* At */
         { NULL, 0 },  /* Bc */          { NULL, 0, 0 },  /* Bc */
         { NULL, 0 },  /* Bf */          { NULL, 0, 0 },  /* Bf */
         { NULL, 0 },  /* Bo */          { NULL, 0, 0 },  /* Bo */
         { NULL, 0 },  /* Bq */          { NULL, 0, 0 },  /* Bq */
         { NULL, TYPE_Bsx },  /* Bsx */          { NULL, TYPE_Bsx, NODE_NOSRC },  /* Bsx */
         { NULL, TYPE_Bx },  /* Bx */          { NULL, TYPE_Bx, NODE_NOSRC },  /* Bx */
         { NULL, 0 },  /* Db */          { NULL, 0, 0 },  /* Db */
         { NULL, 0 },  /* Dc */          { NULL, 0, 0 },  /* Dc */
         { NULL, 0 },  /* Do */          { NULL, 0, 0 },  /* Do */
         { NULL, 0 },  /* Dq */          { NULL, 0, 0 },  /* Dq */
         { NULL, 0 },  /* Ec */          { NULL, 0, 0 },  /* Ec */
         { NULL, 0 },  /* Ef */          { NULL, 0, 0 },  /* Ef */
         { NULL, TYPE_Em },  /* Em */          { NULL, TYPE_Em, 0 },  /* Em */
         { NULL, 0 },  /* Eo */          { NULL, 0, 0 },  /* Eo */
         { NULL, TYPE_Fx },  /* Fx */          { NULL, TYPE_Fx, NODE_NOSRC },  /* Fx */
         { NULL, TYPE_Ms },  /* Ms */          { NULL, TYPE_Ms, 0 },  /* Ms */
         { NULL, 0 },  /* No */          { NULL, 0, 0 },  /* No */
         { NULL, 0 },  /* Ns */          { NULL, 0, 0 },  /* Ns */
         { NULL, TYPE_Nx },  /* Nx */          { NULL, TYPE_Nx, NODE_NOSRC },  /* Nx */
         { NULL, TYPE_Ox },  /* Ox */          { NULL, TYPE_Ox, NODE_NOSRC },  /* Ox */
         { NULL, 0 },  /* Pc */          { NULL, 0, 0 },  /* Pc */
         { NULL, 0 },  /* Pf */          { NULL, 0, 0 },  /* Pf */
         { NULL, 0 },  /* Po */          { NULL, 0, 0 },  /* Po */
         { NULL, 0 },  /* Pq */          { NULL, 0, 0 },  /* Pq */
         { NULL, 0 },  /* Qc */          { NULL, 0, 0 },  /* Qc */
         { NULL, 0 },  /* Ql */          { NULL, 0, 0 },  /* Ql */
         { NULL, 0 },  /* Qo */          { NULL, 0, 0 },  /* Qo */
         { NULL, 0 },  /* Qq */          { NULL, 0, 0 },  /* Qq */
         { NULL, 0 },  /* Re */          { NULL, 0, 0 },  /* Re */
         { NULL, 0 },  /* Rs */          { NULL, 0, 0 },  /* Rs */
         { NULL, 0 },  /* Sc */          { NULL, 0, 0 },  /* Sc */
         { NULL, 0 },  /* So */          { NULL, 0, 0 },  /* So */
         { NULL, 0 },  /* Sq */          { NULL, 0, 0 },  /* Sq */
         { NULL, 0 },  /* Sm */          { NULL, 0, 0 },  /* Sm */
         { NULL, 0 },  /* Sx */          { NULL, 0, 0 },  /* Sx */
         { NULL, TYPE_Sy },  /* Sy */          { NULL, TYPE_Sy, 0 },  /* Sy */
         { NULL, TYPE_Tn },  /* Tn */          { NULL, TYPE_Tn, 0 },  /* Tn */
         { NULL, 0 },  /* Ux */          { NULL, 0, NODE_NOSRC },  /* Ux */
         { NULL, 0 },  /* Xc */          { NULL, 0, 0 },  /* Xc */
         { NULL, 0 },  /* Xo */          { NULL, 0, 0 },  /* Xo */
         { parse_mdoc_Fo, 0 },  /* Fo */          { parse_mdoc_Fo, 0, 0 },  /* Fo */
         { NULL, 0 },  /* Fc */          { NULL, 0, 0 },  /* Fc */
         { NULL, 0 },  /* Oo */          { NULL, 0, 0 },  /* Oo */
         { NULL, 0 },  /* Oc */          { NULL, 0, 0 },  /* Oc */
         { NULL, 0 },  /* Bk */          { NULL, 0, 0 },  /* Bk */
         { NULL, 0 },  /* Ek */          { NULL, 0, 0 },  /* Ek */
         { NULL, 0 },  /* Bt */          { NULL, 0, 0 },  /* Bt */
         { NULL, 0 },  /* Hf */          { NULL, 0, 0 },  /* Hf */
         { NULL, 0 },  /* Fr */          { NULL, 0, 0 },  /* Fr */
         { NULL, 0 },  /* Ud */          { NULL, 0, 0 },  /* Ud */
         { NULL, TYPE_Lb },  /* Lb */          { NULL, TYPE_Lb, NODE_NOSRC },  /* Lb */
         { NULL, 0 },  /* Lp */          { NULL, 0, 0 },  /* Lp */
         { NULL, TYPE_Lk },  /* Lk */          { NULL, TYPE_Lk, 0 },  /* Lk */
         { NULL, TYPE_Mt },  /* Mt */          { NULL, TYPE_Mt, NODE_NOSRC },  /* Mt */
         { NULL, 0 },  /* Brq */          { NULL, 0, 0 },  /* Brq */
         { NULL, 0 },  /* Bro */          { NULL, 0, 0 },  /* Bro */
         { NULL, 0 },  /* Brc */          { NULL, 0, 0 },  /* Brc */
         { NULL, 0 },  /* %C */          { NULL, 0, 0 },  /* %C */
         { NULL, 0 },  /* Es */          { NULL, 0, 0 },  /* Es */
         { NULL, 0 },  /* En */          { NULL, 0, 0 },  /* En */
         { NULL, TYPE_Dx },  /* Dx */          { NULL, TYPE_Dx, NODE_NOSRC },  /* Dx */
         { NULL, 0 },  /* %Q */          { NULL, 0, 0 },  /* %Q */
         { NULL, 0 },  /* br */          { NULL, 0, 0 },  /* %U */
         { NULL, 0 },  /* sp */          { NULL, 0, 0 },  /* Ta */
         { NULL, 0 },  /* %U */  
         { NULL, 0 },  /* Ta */  
         { NULL, 0 },  /* ll */  
 };  };
   static  const struct mdoc_handler *const mdocs = __mdocs - MDOC_Dd;
   
   
 int  int
Line 426  mandocdb(int argc, char *argv[])
Line 433  mandocdb(int argc, char *argv[])
                 if (OP_TEST != op && 0 == set_basedir(path_arg, 1))                  if (OP_TEST != op && 0 == set_basedir(path_arg, 1))
                         goto out;                          goto out;
   
                 if ((dba = dba_read(MANDOC_DB)) != NULL) {                  dba = nodb ? dba_new(128) : dba_read(MANDOC_DB);
                   if (dba != NULL) {
                         /*                          /*
                          * The existing database is usable.  Process                           * The existing database is usable.  Process
                          * all files specified on the command-line.                           * all files specified on the command-line.
Line 443  mandocdb(int argc, char *argv[])
Line 451  mandocdb(int argc, char *argv[])
                         use_all = 1;                          use_all = 1;
                         for (i = 0; i < argc; i++)                          for (i = 0; i < argc; i++)
                                 filescan(argv[i]);                                  filescan(argv[i]);
                         if (OP_TEST != op)                          if (nodb == 0)
                                 dbprune(dba);                                  dbprune(dba);
                 } else {                  } else {
                         /*                          /* Database missing or corrupt. */
                          * Database missing or corrupt.                          if (op != OP_UPDATE || errno != ENOENT)
                          * Recreate from scratch.                                  say(MANDOC_DB, "%s: Automatically recreating"
                          */                                      " from scratch", strerror(errno));
                         exitcode = (int)MANDOCLEVEL_OK;                          exitcode = (int)MANDOCLEVEL_OK;
                         op = OP_DEFAULT;                          op = OP_DEFAULT;
                         if (0 == treescan())                          if (0 == treescan())
Line 538  usage:
Line 546  usage:
 }  }
   
 /*  /*
    * To get a singly linked list in alpha order while inserting entries
    * at the beginning, process directory entries in reverse alpha order.
    */
   static int
   #if HAVE_FTS_COMPARE_CONST
   fts_compare(const FTSENT *const *a, const FTSENT *const *b)
   #else
   fts_compare(const FTSENT **a, const FTSENT **b)
   #endif
   {
           return -strcmp((*a)->fts_name, (*b)->fts_name);
   }
   
   /*
  * Scan a directory tree rooted at "basedir" for manpages.   * Scan a directory tree rooted at "basedir" for manpages.
  * We use fts(), scanning directory parts along the way for clues to our   * We use fts(), scanning directory parts along the way for clues to our
  * section and architecture.   * section and architecture.
Line 565  treescan(void)
Line 587  treescan(void)
         const char      *argv[2];          const char      *argv[2];
   
         argv[0] = ".";          argv[0] = ".";
         argv[1] = (char *)NULL;          argv[1] = NULL;
   
         f = fts_open((char * const *)argv,          f = fts_open((char * const *)argv, FTS_PHYSICAL | FTS_NOCHDIR,
             FTS_PHYSICAL | FTS_NOCHDIR, NULL);              fts_compare);
         if (f == NULL) {          if (f == NULL) {
                 exitcode = (int)MANDOCLEVEL_SYSERR;                  exitcode = (int)MANDOCLEVEL_SYSERR;
                 say("", "&fts_open");                  say("", "&fts_open");
Line 848  filescan(const char *file)
Line 870  filescan(const char *file)
         }          }
   
         /*          /*
            * In test mode or when the original name is absolute
            * but outside our tree, guess the base directory.
            */
   
           if (op == OP_TEST || (start == buf && *start == '/')) {
                   if (strncmp(buf, "man/", 4) == 0)
                           start = buf + 4;
                   else if ((start = strstr(buf, "/man/")) != NULL)
                           start += 5;
                   else
                           start = buf;
           }
   
           /*
          * First try to guess our directory structure.           * First try to guess our directory structure.
          * If we find a separator, try to look for man* or cat*.           * If we find a separator, try to look for man* or cat*.
          * If we find one of these and what's underneath is a directory,           * If we find one of these and what's underneath is a directory,
Line 934  mlink_add(struct mlink *mlink, const struct stat *st)
Line 970  mlink_add(struct mlink *mlink, const struct stat *st)
                 mpage->inodev.st_ino = inodev.st_ino;                  mpage->inodev.st_ino = inodev.st_ino;
                 mpage->inodev.st_dev = inodev.st_dev;                  mpage->inodev.st_dev = inodev.st_dev;
                 mpage->form = FORM_NONE;                  mpage->form = FORM_NONE;
                   mpage->next = mpage_head;
                   mpage_head = mpage;
                 ohash_insert(&mpages, slot, mpage);                  ohash_insert(&mpages, slot, mpage);
         } else          } else
                 mlink->next = mpage->mlinks;                  mlink->next = mpage->mlinks;
Line 957  mpages_free(void)
Line 995  mpages_free(void)
 {  {
         struct mpage    *mpage;          struct mpage    *mpage;
         struct mlink    *mlink;          struct mlink    *mlink;
         unsigned int     slot;  
   
         mpage = ohash_first(&mpages, &slot);          while ((mpage = mpage_head) != NULL) {
         while (NULL != mpage) {                  while ((mlink = mpage->mlinks) != NULL) {
                 while (NULL != (mlink = mpage->mlinks)) {  
                         mpage->mlinks = mlink->next;                          mpage->mlinks = mlink->next;
                         mlink_free(mlink);                          mlink_free(mlink);
                 }                  }
                   mpage_head = mpage->next;
                 free(mpage->sec);                  free(mpage->sec);
                 free(mpage->arch);                  free(mpage->arch);
                 free(mpage->title);                  free(mpage->title);
                 free(mpage->desc);                  free(mpage->desc);
                 free(mpage);                  free(mpage);
                 mpage = ohash_next(&mpages, &slot);  
         }          }
 }  }
   
Line 1047  mlink_check(struct mpage *mpage, struct mlink *mlink)
Line 1083  mlink_check(struct mpage *mpage, struct mlink *mlink)
          * architectures.           * architectures.
          * A few manuals are even shared across completely           * A few manuals are even shared across completely
          * different architectures, for example fdformat(1)           * different architectures, for example fdformat(1)
          * on amd64, i386, sparc, and sparc64.           * on amd64, i386, and sparc64.
          */           */
   
         if (strcasecmp(mpage->arch, mlink->arch))          if (strcasecmp(mpage->arch, mlink->arch))
Line 1090  mpages_merge(struct dba *dba, struct mparse *mp)
Line 1126  mpages_merge(struct dba *dba, struct mparse *mp)
         char                    *sodest;          char                    *sodest;
         char                    *cp;          char                    *cp;
         int                      fd;          int                      fd;
         unsigned int             pslot;  
   
         mpage = ohash_first(&mpages, &pslot);          for (mpage = mpage_head; mpage != NULL; mpage = mpage->next) {
         while (mpage != NULL) {  
                 mlinks_undupe(mpage);                  mlinks_undupe(mpage);
                 if ((mlink = mpage->mlinks) == NULL) {                  if ((mlink = mpage->mlinks) == NULL)
                         mpage = ohash_next(&mpages, &pslot);  
                         continue;                          continue;
                 }  
   
                 name_mask = NAME_MASK;                  name_mask = NAME_MASK;
                 mandoc_ohash_init(&names, 4, offsetof(struct str, key));                  mandoc_ohash_init(&names, 4, offsetof(struct str, key));
Line 1119  mpages_merge(struct dba *dba, struct mparse *mp)
Line 1151  mpages_merge(struct dba *dba, struct mparse *mp)
                 if (mlink->dform != FORM_CAT || mlink->fform != FORM_CAT) {                  if (mlink->dform != FORM_CAT || mlink->fform != FORM_CAT) {
                         mparse_readfd(mp, fd, mlink->file);                          mparse_readfd(mp, fd, mlink->file);
                         close(fd);                          close(fd);
                           fd = -1;
                         mparse_result(mp, &man, &sodest);                          mparse_result(mp, &man, &sodest);
                 }                  }
   
Line 1175  mpages_merge(struct dba *dba, struct mparse *mp)
Line 1208  mpages_merge(struct dba *dba, struct mparse *mp)
                         mpage->title = mandoc_strdup(man->meta.title);                          mpage->title = mandoc_strdup(man->meta.title);
                 } else if (man != NULL && man->macroset == MACROSET_MAN) {                  } else if (man != NULL && man->macroset == MACROSET_MAN) {
                         man_validate(man);                          man_validate(man);
                         mpage->form = FORM_SRC;                          if (*man->meta.msec != '\0' ||
                         mpage->sec = mandoc_strdup(man->meta.msec);                              *man->meta.title != '\0') {
                         mpage->arch = mandoc_strdup(mlink->arch);                                  mpage->form = FORM_SRC;
                         mpage->title = mandoc_strdup(man->meta.title);                                  mpage->sec = mandoc_strdup(man->meta.msec);
                 } else {                                  mpage->arch = mandoc_strdup(mlink->arch);
                                   mpage->title = mandoc_strdup(man->meta.title);
                           } else
                                   man = NULL;
                   }
   
                   assert(mpage->desc == NULL);
                   if (man == NULL) {
                         mpage->form = FORM_CAT;                          mpage->form = FORM_CAT;
                         mpage->sec = mandoc_strdup(mlink->dsec);                          mpage->sec = mandoc_strdup(mlink->dsec);
                         mpage->arch = mandoc_strdup(mlink->arch);                          mpage->arch = mandoc_strdup(mlink->arch);
                         mpage->title = mandoc_strdup(mlink->name);                          mpage->title = mandoc_strdup(mlink->name);
                 }                          parse_cat(mpage, fd);
                   } else if (man->macroset == MACROSET_MDOC)
                 assert(mpage->desc == NULL);  
                 if (man != NULL && man->macroset == MACROSET_MDOC)  
                         parse_mdoc(mpage, &man->meta, man->first);                          parse_mdoc(mpage, &man->meta, man->first);
                 else if (man != NULL)  
                         parse_man(mpage, &man->meta, man->first);  
                 else                  else
                         parse_cat(mpage, fd);                          parse_man(mpage, &man->meta, man->first);
                 if (mpage->desc == NULL)                  if (mpage->desc == NULL) {
                         mpage->desc = mandoc_strdup(mpage->mlinks->name);                          mpage->desc = mandoc_strdup(mlink->name);
                           if (warnings)
                                   say(mlink->file, "No one-line description, "
                                       "using filename \"%s\"", mlink->name);
                   }
   
                 if (warnings && !use_all)                  for (mlink = mpage->mlinks;
                         for (mlink = mpage->mlinks; mlink;                       mlink != NULL;
                              mlink = mlink->next)                       mlink = mlink->next) {
                           putkey(mpage, mlink->name, NAME_FILE);
                           if (warnings && !use_all)
                                 mlink_check(mpage, mlink);                                  mlink_check(mpage, mlink);
                   }
   
                 dbadd(dba, mpage);                  dbadd(dba, mpage);
                 mlink = mpage->mlinks;  
   
 nextpage:  nextpage:
                 ohash_delete(&strings);                  ohash_delete(&strings);
                 ohash_delete(&names);                  ohash_delete(&names);
                 mpage = ohash_next(&mpages, &pslot);  
         }          }
 }  }
   
Line 1215  static void
Line 1256  static void
 parse_cat(struct mpage *mpage, int fd)  parse_cat(struct mpage *mpage, int fd)
 {  {
         FILE            *stream;          FILE            *stream;
         char            *line, *p, *title;          struct mlink    *mlink;
           char            *line, *p, *title, *sec;
         size_t           linesz, plen, titlesz;          size_t           linesz, plen, titlesz;
         ssize_t          len;          ssize_t          len;
         int              offs;          int              offs;
   
         stream = (-1 == fd) ?          mlink = mpage->mlinks;
             fopen(mpage->mlinks->file, "r") :          stream = fd == -1 ? fopen(mlink->file, "r") : fdopen(fd, "r");
             fdopen(fd, "r");          if (stream == NULL) {
         if (NULL == stream) {                  if (fd != -1)
                 if (-1 != fd)  
                         close(fd);                          close(fd);
                 if (warnings)                  if (warnings)
                         say(mpage->mlinks->file, "&fopen");                          say(mlink->file, "&fopen");
                 return;                  return;
         }          }
   
         line = NULL;          line = NULL;
         linesz = 0;          linesz = 0;
   
         /* Skip to first blank line. */          /* Parse the section number from the header line. */
   
         while (getline(&line, &linesz, stream) != -1)          while (getline(&line, &linesz, stream) != -1) {
                 if (*line == '\n')                  if (*line == '\n')
                           continue;
                   if ((sec = strchr(line, '(')) == NULL)
                         break;                          break;
                   if ((p = strchr(++sec, ')')) == NULL)
                           break;
                   free(mpage->sec);
                   mpage->sec = mandoc_strndup(sec, p - sec);
                   if (warnings && *mlink->dsec != '\0' &&
                       strcasecmp(mpage->sec, mlink->dsec))
                           say(mlink->file,
                               "Section \"%s\" manual in %s directory",
                               mpage->sec, mlink->dsec);
                   break;
           }
   
           /* Skip to first blank line. */
   
           while (line == NULL || *line != '\n')
                   if (getline(&line, &linesz, stream) == -1)
                           break;
   
         /*          /*
          * Assume the first line that is not indented           * Assume the first line that is not indented
          * is the first section header.  Skip to it.           * is the first section header.  Skip to it.
Line 1283  parse_cat(struct mpage *mpage, int fd)
Line 1343  parse_cat(struct mpage *mpage, int fd)
   
         if (NULL == title || '\0' == *title) {          if (NULL == title || '\0' == *title) {
                 if (warnings)                  if (warnings)
                         say(mpage->mlinks->file,                          say(mlink->file, "Cannot find NAME section");
                             "Cannot find NAME section");  
                 fclose(stream);                  fclose(stream);
                 free(title);                  free(title);
                 return;                  return;
Line 1303  parse_cat(struct mpage *mpage, int fd)
Line 1362  parse_cat(struct mpage *mpage, int fd)
                         /* Skip to next word. */ ;                          /* Skip to next word. */ ;
         } else {          } else {
                 if (warnings)                  if (warnings)
                         say(mpage->mlinks->file,                          say(mlink->file, "No dash in title line, "
                             "No dash in title line");                              "reusing \"%s\" as one-line description", title);
                 p = title;                  p = title;
         }          }
   
Line 1341  putkey(const struct mpage *mpage, char *value, uint64_
Line 1400  putkey(const struct mpage *mpage, char *value, uint64_
  */   */
 static void  static void
 putmdockey(const struct mpage *mpage,  putmdockey(const struct mpage *mpage,
         const struct roff_node *n, uint64_t m)          const struct roff_node *n, uint64_t m, int taboo)
 {  {
   
         for ( ; NULL != n; n = n->next) {          for ( ; NULL != n; n = n->next) {
                   if (n->flags & taboo)
                           continue;
                 if (NULL != n->child)                  if (NULL != n->child)
                         putmdockey(mpage, n->child, m);                          putmdockey(mpage, n->child, m, taboo);
                 if (n->type == ROFFT_TEXT)                  if (n->type == ROFFT_TEXT)
                         putkey(mpage, n->string, m);                          putkey(mpage, n->string, m);
         }          }
Line 1482  parse_mdoc(struct mpage *mpage, const struct roff_meta
Line 1543  parse_mdoc(struct mpage *mpage, const struct roff_meta
         const struct roff_node *n)          const struct roff_node *n)
 {  {
   
         assert(NULL != n);          for (n = n->child; n != NULL; n = n->next) {
         for (n = n->child; NULL != n; n = n->next) {                  if (n->tok == TOKEN_NONE ||
                       n->tok < ROFF_MAX ||
                       n->flags & mdocs[n->tok].taboo)
                           continue;
                   assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
                 switch (n->type) {                  switch (n->type) {
                 case ROFFT_ELEM:                  case ROFFT_ELEM:
                 case ROFFT_BLOCK:                  case ROFFT_BLOCK:
                 case ROFFT_HEAD:                  case ROFFT_HEAD:
                 case ROFFT_BODY:                  case ROFFT_BODY:
                 case ROFFT_TAIL:                  case ROFFT_TAIL:
                         if (NULL != mdocs[n->tok].fp)                          if (mdocs[n->tok].fp != NULL &&
                                if (0 == (*mdocs[n->tok].fp)(mpage, meta, n))                              (*mdocs[n->tok].fp)(mpage, meta, n) == 0)
                                        break;                                  break;
                         if (mdocs[n->tok].mask)                          if (mdocs[n->tok].mask)
                                 putmdockey(mpage, n->child,                                  putmdockey(mpage, n->child,
                                     mdocs[n->tok].mask);                                      mdocs[n->tok].mask, mdocs[n->tok].taboo);
                         break;                          break;
                 default:                  default:
                         assert(n->type != ROFFT_ROOT);  
                         continue;                          continue;
                 }                  }
                 if (NULL != n->child)                  if (NULL != n->child)
Line 1663  parse_mdoc_Nm(struct mpage *mpage, const struct roff_m
Line 1727  parse_mdoc_Nm(struct mpage *mpage, const struct roff_m
 {  {
   
         if (SEC_NAME == n->sec)          if (SEC_NAME == n->sec)
                 putmdockey(mpage, n->child, NAME_TITLE);                  putmdockey(mpage, n->child, NAME_TITLE, 0);
         else if (n->sec == SEC_SYNOPSIS && n->type == ROFFT_HEAD) {          else if (n->sec == SEC_SYNOPSIS && n->type == ROFFT_HEAD) {
                 if (n->child == NULL)                  if (n->child == NULL)
                         putkey(mpage, meta->name, NAME_SYN);                          putkey(mpage, meta->name, NAME_SYN);
                 else                  else
                         putmdockey(mpage, n->child, NAME_SYN);                          putmdockey(mpage, n->child, NAME_SYN, 0);
         }          }
         if ( ! (mpage->name_head_done ||          if ( ! (mpage->name_head_done ||
             n->child == NULL || n->child->string == NULL ||              n->child == NULL || n->child->string == NULL ||
             strcasecmp(n->child->string, meta->title))) {              strcasecmp(n->child->string, meta->title))) {
                 putkey(mpage, n->child->string, ROFFT_HEAD);                  putkey(mpage, n->child->string, NAME_HEAD);
                 mpage->name_head_done = 1;                  mpage->name_head_done = 1;
         }          }
         return 0;          return 0;
Line 1721  putkeys(const struct mpage *mpage, char *cp, size_t sz
Line 1785  putkeys(const struct mpage *mpage, char *cp, size_t sz
                         name_mask &= ~NAME_FIRST;                          name_mask &= ~NAME_FIRST;
                 if (debug > 1)                  if (debug > 1)
                         say(mpage->mlinks->file,                          say(mpage->mlinks->file,
                             "Adding name %*s, bits=0x%llu", (int)sz, cp, v);                              "Adding name %*s, bits=0x%llx", (int)sz, cp,
                               (unsigned long long)v);
         } else {          } else {
                 htab = &strings;                  htab = &strings;
                 if (debug > 1)                  if (debug > 1)
Line 1993  dbadd(struct dba *dba, struct mpage *mpage)
Line 2058  dbadd(struct dba *dba, struct mpage *mpage)
         cp = mpage->desc;          cp = mpage->desc;
         i = strlen(cp);          i = strlen(cp);
         mustfree = render_string(&cp, &i);          mustfree = render_string(&cp, &i);
         mpage->dba = dba_page_new(dba->pages, mlink->name, mpage->sec,          mpage->dba = dba_page_new(dba->pages,
             *mpage->arch == '\0' ? mlink->arch : mpage->arch,              *mpage->arch == '\0' ? mlink->arch : mpage->arch,
             cp, mlink->file, mpage->form);              cp, mlink->file, mpage->form);
         if (mustfree)          if (mustfree)
                 free(cp);                  free(cp);
           dba_page_add(mpage->dba, DBP_SECT, mpage->sec);
   
         while (mlink != NULL) {          while (mlink != NULL) {
                 dbadd_mlink(mlink);                  dbadd_mlink(mlink);
Legend:
Removed from v.1.223  
changed lines
  Added in v.1.249
CVSweb