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

Diff for /mandoc/mansearch.c between version 1.49 and 1.65

version 1.49, 2014/11/11 19:04:55 version 1.65, 2016/07/09 15:24:19
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2013, 2014, 2015 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
  * copyright notice and this permission notice appear in all copies.   * copyright notice and this permission notice appear in all copies.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Line 21 
Line 21 
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
   #if HAVE_ERR
   #include <err.h>
   #endif
   #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <glob.h>
 #include <limits.h>  #include <limits.h>
 #include <regex.h>  #include <regex.h>
 #include <stdio.h>  #include <stdio.h>
Line 32 
Line 36 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #if HAVE_OHASH  
 #include <ohash.h>  
 #else  
 #include "compat_ohash.h"  
 #endif  
 #include <sqlite3.h>  #include <sqlite3.h>
 #ifndef SQLITE_DETERMINISTIC  #ifndef SQLITE_DETERMINISTIC
 #define SQLITE_DETERMINISTIC 0  #define SQLITE_DETERMINISTIC 0
Line 44 
Line 43 
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "manpath.h"  #include "mandoc_ohash.h"
   #include "manconf.h"
 #include "mansearch.h"  #include "mansearch.h"
   
 extern int mansearch_keymax;  extern int mansearch_keymax;
Line 53  extern const char *const mansearch_keynames[];
Line 53  extern const char *const mansearch_keynames[];
 #define SQL_BIND_TEXT(_db, _s, _i, _v) \  #define SQL_BIND_TEXT(_db, _s, _i, _v) \
         do { if (SQLITE_OK != sqlite3_bind_text \          do { if (SQLITE_OK != sqlite3_bind_text \
                 ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \                  ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \
                 fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \                  errx((int)MANDOCLEVEL_SYSERR, "%s", sqlite3_errmsg((_db))); \
         } while (0)          } while (0)
 #define SQL_BIND_INT64(_db, _s, _i, _v) \  #define SQL_BIND_INT64(_db, _s, _i, _v) \
         do { if (SQLITE_OK != sqlite3_bind_int64 \          do { if (SQLITE_OK != sqlite3_bind_int64 \
                 ((_s), (_i)++, (_v))) \                  ((_s), (_i)++, (_v))) \
                 fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \                  errx((int)MANDOCLEVEL_SYSERR, "%s", sqlite3_errmsg((_db))); \
         } while (0)          } while (0)
 #define SQL_BIND_BLOB(_db, _s, _i, _v) \  #define SQL_BIND_BLOB(_db, _s, _i, _v) \
         do { if (SQLITE_OK != sqlite3_bind_blob \          do { if (SQLITE_OK != sqlite3_bind_blob \
                 ((_s), (_i)++, (&_v), sizeof(_v), SQLITE_STATIC)) \                  ((_s), (_i)++, (&_v), sizeof(_v), SQLITE_STATIC)) \
                 fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \                  errx((int)MANDOCLEVEL_SYSERR, "%s", sqlite3_errmsg((_db))); \
         } while (0)          } while (0)
   
 struct  expr {  struct  expr {
Line 79  struct expr {
Line 79  struct expr {
   
 struct  match {  struct  match {
         uint64_t         pageid; /* identifier in database */          uint64_t         pageid; /* identifier in database */
           uint64_t         bits; /* name type mask */
         char            *desc; /* manual page description */          char            *desc; /* manual page description */
         int              form; /* bit field: formatted, zipped? */          int              form; /* bit field: formatted, zipped? */
 };  };
   
 static  void             buildnames(struct manpage *, sqlite3 *,  static  void             buildnames(const struct mansearch *,
                                   struct manpage *, sqlite3 *,
                                 sqlite3_stmt *, uint64_t,                                  sqlite3_stmt *, uint64_t,
                                 const char *, int form);                                  const char *, int form);
 static  char            *buildoutput(sqlite3 *, sqlite3_stmt *,  static  char            *buildoutput(sqlite3 *, sqlite3_stmt *,
                                  uint64_t, uint64_t);                                   uint64_t, uint64_t);
 static  void            *hash_alloc(size_t, void *);  
 static  void             hash_free(void *, void *);  
 static  void            *hash_calloc(size_t, size_t, void *);  
 static  struct expr     *exprcomp(const struct mansearch *,  static  struct expr     *exprcomp(const struct mansearch *,
                                 int, char *[]);                                  int, char *[]);
 static  void             exprfree(struct expr *);  static  void             exprfree(struct expr *);
 static  struct expr     *exprspec(struct expr *, uint64_t,  
                                  const char *, const char *);  
 static  struct expr     *exprterm(const struct mansearch *, char *, int);  static  struct expr     *exprterm(const struct mansearch *, char *, int);
 static  int              manpage_compare(const void *, const void *);  static  int              manpage_compare(const void *, const void *);
 static  void             sql_append(char **sql, size_t *sz,  static  void             sql_append(char **sql, size_t *sz,
Line 118  mansearch_setup(int start)
Line 115  mansearch_setup(int start)
   
         if (start) {          if (start) {
                 if (NULL != pagecache) {                  if (NULL != pagecache) {
                         fprintf(stderr, "pagecache already enabled\n");                          warnx("pagecache already enabled");
                         return((int)MANDOCLEVEL_BADARG);                          return (int)MANDOCLEVEL_BADARG;
                 }                  }
   
                 pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,                  pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,
Line 127  mansearch_setup(int start)
Line 124  mansearch_setup(int start)
                     MAP_SHARED | MAP_ANON, -1, 0);                      MAP_SHARED | MAP_ANON, -1, 0);
   
                 if (MAP_FAILED == pagecache) {                  if (MAP_FAILED == pagecache) {
                         perror("mmap");                          warn("mmap");
                         pagecache = NULL;                          pagecache = NULL;
                         return((int)MANDOCLEVEL_SYSERR);                          return (int)MANDOCLEVEL_SYSERR;
                 }                  }
   
                 c = sqlite3_config(SQLITE_CONFIG_PAGECACHE,                  c = sqlite3_config(SQLITE_CONFIG_PAGECACHE,
                     pagecache, PC_PAGESIZE, PC_NUMPAGES);                      pagecache, PC_PAGESIZE, PC_NUMPAGES);
   
                 if (SQLITE_OK == c)                  if (SQLITE_OK == c)
                         return((int)MANDOCLEVEL_OK);                          return (int)MANDOCLEVEL_OK;
   
                 fprintf(stderr, "pagecache: %s\n", sqlite3_errstr(c));                  warnx("pagecache: %s", sqlite3_errstr(c));
   
         } else if (NULL == pagecache) {          } else if (NULL == pagecache) {
                 fprintf(stderr, "pagecache missing\n");                  warnx("pagecache missing");
                 return((int)MANDOCLEVEL_BADARG);                  return (int)MANDOCLEVEL_BADARG;
         }          }
   
         if (-1 == munmap(pagecache, PC_PAGESIZE * PC_NUMPAGES)) {          if (-1 == munmap(pagecache, PC_PAGESIZE * PC_NUMPAGES)) {
                 perror("munmap");                  warn("munmap");
                 pagecache = NULL;                  pagecache = NULL;
                 return((int)MANDOCLEVEL_SYSERR);                  return (int)MANDOCLEVEL_SYSERR;
         }          }
   
         pagecache = NULL;          pagecache = NULL;
         return((int)MANDOCLEVEL_OK);          return (int)MANDOCLEVEL_OK;
 }  }
   
 int  int
Line 161  mansearch(const struct mansearch *search,
Line 158  mansearch(const struct mansearch *search,
                 int argc, char *argv[],                  int argc, char *argv[],
                 struct manpage **res, size_t *sz)                  struct manpage **res, size_t *sz)
 {  {
         int              fd, rc, c, indexbit;  
         int64_t          pageid;          int64_t          pageid;
         uint64_t         outbit, iterbit;          uint64_t         outbit, iterbit;
         char             buf[PATH_MAX];          char             buf[PATH_MAX];
Line 171  mansearch(const struct mansearch *search,
Line 167  mansearch(const struct mansearch *search,
         sqlite3         *db;          sqlite3         *db;
         sqlite3_stmt    *s, *s2;          sqlite3_stmt    *s, *s2;
         struct match    *mp;          struct match    *mp;
         struct ohash_info info;  
         struct ohash     htab;          struct ohash     htab;
         unsigned int     idx;          unsigned int     idx;
         size_t           i, j, cur, maxres;          size_t           i, j, cur, maxres;
           int              c, chdir_status, getcwd_status, indexbit;
   
         info.calloc = hash_calloc;          if (argc == 0 || (e = exprcomp(search, argc, argv)) == NULL) {
         info.alloc = hash_alloc;                  *sz = 0;
         info.free = hash_free;                  return 0;
         info.key_offset = offsetof(struct match, pageid);          }
   
         *sz = cur = maxres = 0;          cur = maxres = 0;
         sql = NULL;  
         *res = NULL;          *res = NULL;
         fd = -1;  
         e = NULL;  
         rc = 0;  
   
         if (0 == argc)  
                 goto out;  
         if (NULL == (e = exprcomp(search, argc, argv)))  
                 goto out;  
   
         outbit = 0;  
         if (NULL != search->outkey) {          if (NULL != search->outkey) {
                   outbit = TYPE_Nd;
                 for (indexbit = 0, iterbit = 1;                  for (indexbit = 0, iterbit = 1;
                      indexbit < mansearch_keymax;                       indexbit < mansearch_keymax;
                      indexbit++, iterbit <<= 1) {                       indexbit++, iterbit <<= 1) {
Line 204  mansearch(const struct mansearch *search,
Line 191  mansearch(const struct mansearch *search,
                                 break;                                  break;
                         }                          }
                 }                  }
         }          } else
                   outbit = 0;
   
         /*          /*
          * Save a descriptor to the current working directory.           * Remember the original working directory, if possible.
          * Since pathnames in the "paths" variable might be relative,           * This will be needed if the second or a later directory
          * and we'll be chdir()ing into them, we need to keep a handle           * is given as a relative path.
          * on our current directory from which to start the chdir().           * Do not error out if the current directory is not
            * searchable: Maybe it won't be needed after all.
          */           */
   
         if (NULL == getcwd(buf, PATH_MAX)) {          if (getcwd(buf, PATH_MAX) == NULL) {
                 perror("getcwd");                  getcwd_status = 0;
                 goto out;                  (void)strlcpy(buf, strerror(errno), sizeof(buf));
         } else if (-1 == (fd = open(buf, O_RDONLY, 0))) {          } else
                 perror(buf);                  getcwd_status = 1;
                 goto out;  
         }  
   
         sql = sql_statement(e);          sql = sql_statement(e);
   
Line 231  mansearch(const struct mansearch *search,
Line 218  mansearch(const struct mansearch *search,
          * scan it for our match expression.           * scan it for our match expression.
          */           */
   
           chdir_status = 0;
         for (i = 0; i < paths->sz; i++) {          for (i = 0; i < paths->sz; i++) {
                 if (-1 == fchdir(fd)) {                  if (chdir_status && paths->paths[i][0] != '/') {
                         perror(buf);                          if ( ! getcwd_status) {
                         free(*res);                                  warnx("%s: getcwd: %s", paths->paths[i], buf);
                         break;                                  continue;
                 } else if (-1 == chdir(paths->paths[i])) {                          } else if (chdir(buf) == -1) {
                         perror(paths->paths[i]);                                  warn("%s", buf);
                                   continue;
                           }
                   }
                   if (chdir(paths->paths[i]) == -1) {
                           warn("%s", paths->paths[i]);
                         continue;                          continue;
                 }                  }
                   chdir_status = 1;
   
                 c = sqlite3_open_v2(MANDOC_DB, &db,                  c = sqlite3_open_v2(MANDOC_DB, &db,
                     SQLITE_OPEN_READONLY, NULL);                      SQLITE_OPEN_READONLY, NULL);
   
                 if (SQLITE_OK != c) {                  if (SQLITE_OK != c) {
                         perror(MANDOC_DB);                          warn("%s/%s", paths->paths[i], MANDOC_DB);
                         sqlite3_close(db);                          sqlite3_close(db);
                         continue;                          continue;
                 }                  }
Line 267  mansearch(const struct mansearch *search,
Line 261  mansearch(const struct mansearch *search,
                 j = 1;                  j = 1;
                 c = sqlite3_prepare_v2(db, sql, -1, &s, NULL);                  c = sqlite3_prepare_v2(db, sql, -1, &s, NULL);
                 if (SQLITE_OK != c)                  if (SQLITE_OK != c)
                         fprintf(stderr, "%s\n", sqlite3_errmsg(db));                          errx((int)MANDOCLEVEL_SYSERR,
                               "%s", sqlite3_errmsg(db));
   
                 for (ep = e; NULL != ep; ep = ep->next) {                  for (ep = e; NULL != ep; ep = ep->next) {
                         if (NULL == ep->substr) {                          if (NULL == ep->substr) {
Line 278  mansearch(const struct mansearch *search,
Line 273  mansearch(const struct mansearch *search,
                                 SQL_BIND_INT64(db, s, j, ep->bits);                                  SQL_BIND_INT64(db, s, j, ep->bits);
                 }                  }
   
                 memset(&htab, 0, sizeof(struct ohash));                  mandoc_ohash_init(&htab, 4, offsetof(struct match, pageid));
                 ohash_init(&htab, 4, &info);  
   
                 /*                  /*
                  * Hash each entry on its [unique] document identifier.                   * Hash each entry on its [unique] document identifier.
Line 301  mansearch(const struct mansearch *search,
Line 295  mansearch(const struct mansearch *search,
                         mp = mandoc_calloc(1, sizeof(struct match));                          mp = mandoc_calloc(1, sizeof(struct match));
                         mp->pageid = pageid;                          mp->pageid = pageid;
                         mp->form = sqlite3_column_int(s, 1);                          mp->form = sqlite3_column_int(s, 1);
                           mp->bits = sqlite3_column_int64(s, 3);
                         if (TYPE_Nd == outbit)                          if (TYPE_Nd == outbit)
                                 mp->desc = mandoc_strdup((const char *)                                  mp->desc = mandoc_strdup((const char *)
                                     sqlite3_column_text(s, 0));                                      sqlite3_column_text(s, 0));
Line 308  mansearch(const struct mansearch *search,
Line 303  mansearch(const struct mansearch *search,
                 }                  }
   
                 if (SQLITE_DONE != c)                  if (SQLITE_DONE != c)
                         fprintf(stderr, "%s\n", sqlite3_errmsg(db));                          warnx("%s", sqlite3_errmsg(db));
   
                 sqlite3_finalize(s);                  sqlite3_finalize(s);
   
Line 317  mansearch(const struct mansearch *search,
Line 312  mansearch(const struct mansearch *search,
                     "WHERE pageid=? ORDER BY sec, arch, name",                      "WHERE pageid=? ORDER BY sec, arch, name",
                     -1, &s, NULL);                      -1, &s, NULL);
                 if (SQLITE_OK != c)                  if (SQLITE_OK != c)
                         fprintf(stderr, "%s\n", sqlite3_errmsg(db));                          errx((int)MANDOCLEVEL_SYSERR,
                               "%s", sqlite3_errmsg(db));
   
                 c = sqlite3_prepare_v2(db,                  c = sqlite3_prepare_v2(db,
                     "SELECT bits, key, pageid FROM keys "                      "SELECT bits, key, pageid FROM keys "
                     "WHERE pageid=? AND bits & ?",                      "WHERE pageid=? AND bits & ?",
                     -1, &s2, NULL);                      -1, &s2, NULL);
                 if (SQLITE_OK != c)                  if (SQLITE_OK != c)
                         fprintf(stderr, "%s\n", sqlite3_errmsg(db));                          errx((int)MANDOCLEVEL_SYSERR,
                               "%s", sqlite3_errmsg(db));
   
                 for (mp = ohash_first(&htab, &idx);                  for (mp = ohash_first(&htab, &idx);
                                 NULL != mp;                                  NULL != mp;
Line 336  mansearch(const struct mansearch *search,
Line 333  mansearch(const struct mansearch *search,
                         }                          }
                         mpage = *res + cur;                          mpage = *res + cur;
                         mpage->ipath = i;                          mpage->ipath = i;
                           mpage->bits = mp->bits;
                         mpage->sec = 10;                          mpage->sec = 10;
                         mpage->form = mp->form;                          mpage->form = mp->form;
                         buildnames(mpage, db, s, mp->pageid,                          buildnames(search, mpage, db, s, mp->pageid,
                             paths->paths[i], mp->form);                              paths->paths[i], mp->form);
                         mpage->output = TYPE_Nd & outbit ?                          if (mpage->names != NULL) {
                             mp->desc : outbit ?                                  mpage->output = TYPE_Nd & outbit ?
                             buildoutput(db, s2, mp->pageid, outbit) : NULL;                                      mp->desc : outbit ?
                                       buildoutput(db, s2, mp->pageid, outbit) :
                                       NULL;
                                   cur++;
                           }
                         free(mp);                          free(mp);
                         cur++;  
                 }                  }
   
                 sqlite3_finalize(s);                  sqlite3_finalize(s);
Line 362  mansearch(const struct mansearch *search,
Line 362  mansearch(const struct mansearch *search,
                         break;                          break;
         }          }
         qsort(*res, cur, sizeof(struct manpage), manpage_compare);          qsort(*res, cur, sizeof(struct manpage), manpage_compare);
         rc = 1;          if (chdir_status && getcwd_status && chdir(buf) == -1)
 out:                  warn("%s", buf);
         if (-1 != fd) {  
                 if (-1 == fchdir(fd))  
                         perror(buf);  
                 close(fd);  
         }  
         exprfree(e);          exprfree(e);
         free(sql);          free(sql);
         *sz = cur;          *sz = cur;
         return(rc);          return 1;
 }  }
   
 void  void
Line 396  manpage_compare(const void *vp1, const void *vp2)
Line 391  manpage_compare(const void *vp1, const void *vp2)
   
         mp1 = vp1;          mp1 = vp1;
         mp2 = vp2;          mp2 = vp2;
         diff = mp1->sec - mp2->sec;          return (diff = mp2->bits - mp1->bits) ? diff :
         return(diff ? diff : strcasecmp(mp1->names, mp2->names));              (diff = mp1->sec - mp2->sec) ? diff :
               strcasecmp(mp1->names, mp2->names);
 }  }
   
 static void  static void
 buildnames(struct manpage *mpage, sqlite3 *db, sqlite3_stmt *s,  buildnames(const struct mansearch *search, struct manpage *mpage,
                   sqlite3 *db, sqlite3_stmt *s,
                 uint64_t pageid, const char *path, int form)                  uint64_t pageid, const char *path, int form)
 {  {
         char            *newnames, *prevsec, *prevarch;          glob_t           globinfo;
           char            *firstname, *newnames, *prevsec, *prevarch;
         const char      *oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;          const char      *oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;
         const char      *gzip;  
         size_t           i;          size_t           i;
         int              c;          int              c, globres;
   
         mpage->file = NULL;          mpage->file = NULL;
         mpage->names = NULL;          mpage->names = NULL;
         prevsec = prevarch = NULL;          firstname = prevsec = prevarch = NULL;
         i = 1;          i = 1;
         SQL_BIND_INT64(db, s, i, pageid);          SQL_BIND_INT64(db, s, i, pageid);
         while (SQLITE_ROW == (c = sqlite3_step(s))) {          while (SQLITE_ROW == (c = sqlite3_step(s))) {
Line 427  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 424  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
                         sep1 = ", ";                          sep1 = ", ";
                 }                  }
   
                 /* Fetch the next name. */                  /* Fetch the next name, rejecting sec/arch mismatches. */
   
                 sec = (const char *)sqlite3_column_text(s, 0);                  sec = (const char *)sqlite3_column_text(s, 0);
                   if (search->sec != NULL && strcasecmp(sec, search->sec))
                           continue;
                 arch = (const char *)sqlite3_column_text(s, 1);                  arch = (const char *)sqlite3_column_text(s, 1);
                   if (search->arch != NULL && *arch != '\0' &&
                       strcasecmp(arch, search->arch))
                           continue;
                 name = (const char *)sqlite3_column_text(s, 2);                  name = (const char *)sqlite3_column_text(s, 2);
   
                 /* Remember the first section found. */                  /* Remember the first section found. */
Line 469  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 471  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
   
                 /* Also save the first file name encountered. */                  /* Also save the first file name encountered. */
   
                 if (NULL != mpage->file)                  if (mpage->file != NULL)
                         continue;                          continue;
   
                 if (form & FORM_SRC) {                  if (form & FORM_SRC) {
Line 479  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 481  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
                         sep1 = "cat";                          sep1 = "cat";
                         fsec = "0";                          fsec = "0";
                 }                  }
                 if (form & FORM_GZ)                  sep2 = *arch == '\0' ? "" : "/";
                         gzip = ".gz";                  mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",
                       path, sep1, sec, sep2, arch, name, fsec);
                   if (access(mpage->file, R_OK) != -1)
                           continue;
   
                   /* Handle unusual file name extensions. */
   
                   if (firstname == NULL)
                           firstname = mpage->file;
                 else                  else
                         gzip = "";                          free(mpage->file);
                 sep2 = '\0' == *arch ? "" : "/";                  mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.*",
                 mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s%s",                      path, sep1, sec, sep2, arch, name);
                     path, sep1, sec, sep2, arch, name, fsec, gzip);                  globres = glob(mpage->file, 0, NULL, &globinfo);
                   free(mpage->file);
                   mpage->file = globres ? NULL :
                       mandoc_strdup(*globinfo.gl_pathv);
                   globfree(&globinfo);
         }          }
         if (SQLITE_DONE != c)          if (c != SQLITE_DONE)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  warnx("%s", sqlite3_errmsg(db));
         sqlite3_reset(s);          sqlite3_reset(s);
   
           /* If none of the files is usable, use the first name. */
   
           if (mpage->file == NULL)
                   mpage->file = firstname;
           else if (mpage->file != firstname)
                   free(firstname);
   
         /* Append one final section to the names. */          /* Append one final section to the names. */
   
         if (NULL != prevsec) {          if (prevsec != NULL) {
                 sep2 = '\0' == *prevarch ? "" : "/";                  sep2 = *prevarch == '\0' ? "" : "/";
                 mandoc_asprintf(&newnames, "%s(%s%s%s)",                  mandoc_asprintf(&newnames, "%s(%s%s%s)",
                     mpage->names, prevsec, sep2, prevarch);                      mpage->names, prevsec, sep2, prevarch);
                 free(mpage->names);                  free(mpage->names);
Line 531  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
Line 552  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
                 output = newoutput;                  output = newoutput;
         }          }
         if (SQLITE_DONE != c)          if (SQLITE_DONE != c)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  warnx("%s", sqlite3_errmsg(db));
         sqlite3_reset(s);          sqlite3_reset(s);
         return(output);          return output;
 }  }
   
 /*  /*
Line 592  sql_statement(const struct expr *e)
Line 613  sql_statement(const struct expr *e)
         size_t           sz;          size_t           sz;
         int              needop;          int              needop;
   
         sql = mandoc_strdup(          sql = mandoc_strdup(e->equal ?
             "SELECT desc, form, pageid FROM mpages WHERE ");              "SELECT desc, form, pageid, bits "
                   "FROM mpages NATURAL JOIN names WHERE " :
               "SELECT desc, form, pageid, 0 FROM mpages WHERE ");
         sz = strlen(sql);          sz = strlen(sql);
   
         for (needop = 0; NULL != e; e = e->next) {          for (needop = 0; NULL != e; e = e->next) {
Line 613  sql_statement(const struct expr *e)
Line 636  sql_statement(const struct expr *e)
                         ? "pageid IN (SELECT pageid FROM names "                          ? "pageid IN (SELECT pageid FROM names "
                           "WHERE name REGEXP ?)"                            "WHERE name REGEXP ?)"
                         : e->equal                          : e->equal
                         ? "pageid IN (SELECT pageid FROM names "                          ? "name = ? "
                           "WHERE name = ?)"  
                         : "pageid IN (SELECT pageid FROM names "                          : "pageid IN (SELECT pageid FROM names "
                           "WHERE name MATCH ?)")                            "WHERE name MATCH ?)")
                     : (NULL == e->substr                      : (NULL == e->substr
Line 627  sql_statement(const struct expr *e)
Line 649  sql_statement(const struct expr *e)
                 needop = 1;                  needop = 1;
         }          }
   
         return(sql);          return sql;
 }  }
   
 /*  /*
Line 643  exprcomp(const struct mansearch *search, int argc, cha
Line 665  exprcomp(const struct mansearch *search, int argc, cha
         struct expr     *first, *prev, *cur, *next;          struct expr     *first, *prev, *cur, *next;
   
         first = cur = NULL;          first = cur = NULL;
         logic = igncase = toclose = 0;          logic = igncase = toopen = toclose = 0;
         toopen = NULL != search->sec || NULL != search->arch;  
   
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 if (0 == strcmp("(", argv[i])) {                  if (0 == strcmp("(", argv[i])) {
Line 710  exprcomp(const struct mansearch *search, int argc, cha
Line 731  exprcomp(const struct mansearch *search, int argc, cha
   
                 toopen = logic = igncase = 0;                  toopen = logic = igncase = 0;
         }          }
         if (toopen || logic || igncase || toclose)          if ( ! (toopen || logic || igncase || toclose))
                 goto fail;                  return first;
   
         if (NULL != search->sec || NULL != search->arch)  
                 cur->close++;  
         if (NULL != search->arch)  
                 cur = exprspec(cur, TYPE_arch, search->arch, "^(%s|any)$");  
         if (NULL != search->sec)  
                 exprspec(cur, TYPE_sec, search->sec, "^%s$");  
   
         return(first);  
   
 fail:  fail:
         if (NULL != first)          if (NULL != first)
                 exprfree(first);                  exprfree(first);
         return(NULL);          return NULL;
 }  }
   
 static struct expr *  static struct expr *
 exprspec(struct expr *cur, uint64_t key, const char *value,  
                 const char *format)  
 {  
         char     errbuf[BUFSIZ];  
         char    *cp;  
         int      irc;  
   
         mandoc_asprintf(&cp, format, value);  
         cur->next = mandoc_calloc(1, sizeof(struct expr));  
         cur = cur->next;  
         cur->and = 1;  
         cur->bits = key;  
         if (0 != (irc = regcomp(&cur->regexp, cp,  
             REG_EXTENDED | REG_NOSUB | REG_ICASE))) {  
                 regerror(irc, &cur->regexp, errbuf, sizeof(errbuf));  
                 fprintf(stderr, "regcomp: %s\n", errbuf);  
                 cur->substr = value;  
         }  
         free(cp);  
         return(cur);  
 }  
   
 static struct expr *  
 exprterm(const struct mansearch *search, char *buf, int cs)  exprterm(const struct mansearch *search, char *buf, int cs)
 {  {
         char             errbuf[BUFSIZ];          char             errbuf[BUFSIZ];
Line 761  exprterm(const struct mansearch *search, char *buf, in
Line 750  exprterm(const struct mansearch *search, char *buf, in
         int              i, irc;          int              i, irc;
   
         if ('\0' == *buf)          if ('\0' == *buf)
                 return(NULL);                  return NULL;
   
         e = mandoc_calloc(1, sizeof(struct expr));          e = mandoc_calloc(1, sizeof(struct expr));
   
Line 769  exprterm(const struct mansearch *search, char *buf, in
Line 758  exprterm(const struct mansearch *search, char *buf, in
                 e->bits = TYPE_Nm;                  e->bits = TYPE_Nm;
                 e->substr = buf;                  e->substr = buf;
                 e->equal = 1;                  e->equal = 1;
                 return(e);                  return e;
         }          }
   
         /*          /*
Line 781  exprterm(const struct mansearch *search, char *buf, in
Line 770  exprterm(const struct mansearch *search, char *buf, in
         if (search->argmode == ARG_WORD) {          if (search->argmode == ARG_WORD) {
                 e->bits = TYPE_Nm;                  e->bits = TYPE_Nm;
                 e->substr = NULL;                  e->substr = NULL;
   #if HAVE_REWB_BSD
                 mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", buf);                  mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", buf);
   #elif HAVE_REWB_SYSV
                   mandoc_asprintf(&val, "\\<%s\\>", buf);
   #else
                   mandoc_asprintf(&val,
                       "(^|[^a-zA-Z01-9_])%s([^a-zA-Z01-9_]|$)", buf);
   #endif
                 cs = 0;                  cs = 0;
         } else if ((val = strpbrk(buf, "=~")) == NULL) {          } else if ((val = strpbrk(buf, "=~")) == NULL) {
                 e->bits = TYPE_Nm | TYPE_Nd;                  e->bits = TYPE_Nm | TYPE_Nd;
Line 805  exprterm(const struct mansearch *search, char *buf, in
Line 801  exprterm(const struct mansearch *search, char *buf, in
                         free(val);                          free(val);
                 if (irc) {                  if (irc) {
                         regerror(irc, &e->regexp, errbuf, sizeof(errbuf));                          regerror(irc, &e->regexp, errbuf, sizeof(errbuf));
                         fprintf(stderr, "regcomp: %s\n", errbuf);                          warnx("regcomp: %s", errbuf);
                         free(e);                          free(e);
                         return(NULL);                          return NULL;
                 }                  }
         }          }
   
         if (e->bits)          if (e->bits)
                 return(e);                  return e;
   
         /*          /*
          * Parse out all possible fields.           * Parse out all possible fields.
Line 834  exprterm(const struct mansearch *search, char *buf, in
Line 830  exprterm(const struct mansearch *search, char *buf, in
                 if (i == mansearch_keymax) {                  if (i == mansearch_keymax) {
                         if (strcasecmp(key, "any")) {                          if (strcasecmp(key, "any")) {
                                 free(e);                                  free(e);
                                 return(NULL);                                  return NULL;
                         }                          }
                         e->bits |= ~0ULL;                          e->bits |= ~0ULL;
                 }                  }
         }          }
   
         return(e);          return e;
 }  }
   
 static void  static void
Line 853  exprfree(struct expr *p)
Line 849  exprfree(struct expr *p)
                 free(p);                  free(p);
                 p = pp;                  p = pp;
         }          }
 }  
   
 static void *  
 hash_calloc(size_t nmemb, size_t sz, void *arg)  
 {  
   
         return(mandoc_calloc(nmemb, sz));  
 }  
   
 static void *  
 hash_alloc(size_t sz, void *arg)  
 {  
   
         return(mandoc_malloc(sz));  
 }  
   
 static void  
 hash_free(void *p, void *arg)  
 {  
   
         free(p);  
 }  }
Legend:
Removed from v.1.49  
changed lines
  Added in v.1.65
CVSweb