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

Diff for /mandoc/mansearch.c between version 1.58 and 1.61

version 1.58, 2015/10/06 18:32:19 version 1.61, 2015/11/06 21:19:09
Line 21 
Line 21 
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
   #include <err.h>
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
Line 34 
Line 35 
 #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 46 
Line 42 
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
   #include "mandoc_ohash.h"
 #include "manconf.h"  #include "manconf.h"
 #include "mansearch.h"  #include "mansearch.h"
   
Line 55  extern const char *const mansearch_keynames[];
Line 52  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))); \                  warnx("%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))); \                  warnx("%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))); \                  warnx("%s", sqlite3_errmsg((_db))); \
         } while (0)          } while (0)
   
 struct  expr {  struct  expr {
Line 92  static void   buildnames(const struct mansearch *,
Line 89  static void   buildnames(const struct mansearch *,
                                 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 *);
Line 120  mansearch_setup(int start)
Line 114  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;
                 }                  }
   
Line 140  mansearch_setup(int start)
Line 134  mansearch_setup(int start)
                 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;
         }          }
   
Line 172  mansearch(const struct mansearch *search,
Line 166  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;
Line 183  mansearch(const struct mansearch *search,
Line 176  mansearch(const struct mansearch *search,
                 return 0;                  return 0;
         }          }
   
         info.calloc = hash_calloc;  
         info.alloc = hash_alloc;  
         info.free = hash_free;  
         info.key_offset = offsetof(struct match, pageid);  
   
         cur = maxres = 0;          cur = maxres = 0;
         *res = NULL;          *res = NULL;
   
Line 233  mansearch(const struct mansearch *search,
Line 221  mansearch(const struct mansearch *search,
         for (i = 0; i < paths->sz; i++) {          for (i = 0; i < paths->sz; i++) {
                 if (chdir_status && paths->paths[i][0] != '/') {                  if (chdir_status && paths->paths[i][0] != '/') {
                         if ( ! getcwd_status) {                          if ( ! getcwd_status) {
                                 fprintf(stderr, "%s: getcwd: %s\n",                                  warnx("%s: getcwd: %s", paths->paths[i], buf);
                                     paths->paths[i], buf);  
                                 continue;                                  continue;
                         } else if (chdir(buf) == -1) {                          } else if (chdir(buf) == -1) {
                                 perror(buf);                                  perror(buf);
Line 251  mansearch(const struct mansearch *search,
Line 238  mansearch(const struct mansearch *search,
                     SQLITE_OPEN_READONLY, NULL);                      SQLITE_OPEN_READONLY, NULL);
   
                 if (SQLITE_OK != c) {                  if (SQLITE_OK != c) {
                         fprintf(stderr, "%s/%s: %s\n",                          warn("%s/%s", paths->paths[i], MANDOC_DB);
                             paths->paths[i], MANDOC_DB, strerror(errno));  
                         sqlite3_close(db);                          sqlite3_close(db);
                         continue;                          continue;
                 }                  }
Line 274  mansearch(const struct mansearch *search,
Line 260  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));                          warnx("%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 285  mansearch(const struct mansearch *search,
Line 271  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 316  mansearch(const struct mansearch *search,
Line 301  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 325  mansearch(const struct mansearch *search,
Line 310  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));                          warnx("%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));                          warnx("%s", sqlite3_errmsg(db));
   
                 for (mp = ohash_first(&htab, &idx);                  for (mp = ohash_first(&htab, &idx);
                                 NULL != mp;                                  NULL != mp;
Line 513  buildnames(const struct mansearch *search, struct manp
Line 498  buildnames(const struct mansearch *search, struct manp
                 globfree(&globinfo);                  globfree(&globinfo);
         }          }
         if (c != SQLITE_DONE)          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 none of the files is usable, use the first name. */
Line 563  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
Line 548  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 781  exprterm(const struct mansearch *search, char *buf, in
Line 766  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 797  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;
                 }                  }
Line 853  exprfree(struct expr *p)
Line 845  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.58  
changed lines
  Added in v.1.61
CVSweb