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

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

version 1.53, 2015/01/20 18:21:18 version 1.58, 2015/10/06 18:32:19
Line 7 
Line 7 
  * 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 24 
Line 24 
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.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 45 
Line 46 
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "manpath.h"  #include "manconf.h"
 #include "mansearch.h"  #include "mansearch.h"
   
 extern int mansearch_keymax;  extern int mansearch_keymax;
Line 120  mansearch_setup(int start)
Line 121  mansearch_setup(int start)
         if (start) {          if (start) {
                 if (NULL != pagecache) {                  if (NULL != pagecache) {
                         fprintf(stderr, "pagecache already enabled\n");                          fprintf(stderr, "pagecache already enabled\n");
                         return((int)MANDOCLEVEL_BADARG);                          return (int)MANDOCLEVEL_BADARG;
                 }                  }
   
                 pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,                  pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,
Line 130  mansearch_setup(int start)
Line 131  mansearch_setup(int start)
                 if (MAP_FAILED == pagecache) {                  if (MAP_FAILED == pagecache) {
                         perror("mmap");                          perror("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));                  fprintf(stderr, "pagecache: %s\n", sqlite3_errstr(c));
   
         } else if (NULL == pagecache) {          } else if (NULL == pagecache) {
                 fprintf(stderr, "pagecache missing\n");                  fprintf(stderr, "pagecache missing\n");
                 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");                  perror("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 162  mansearch(const struct mansearch *search,
Line 163  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 176  mansearch(const struct mansearch *search,
Line 176  mansearch(const struct mansearch *search,
         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;
   
           if (argc == 0 || (e = exprcomp(search, argc, argv)) == NULL) {
                   *sz = 0;
                   return 0;
           }
   
         info.calloc = hash_calloc;          info.calloc = hash_calloc;
         info.alloc = hash_alloc;          info.alloc = hash_alloc;
         info.free = hash_free;          info.free = hash_free;
         info.key_offset = offsetof(struct match, pageid);          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 205  mansearch(const struct mansearch *search,
Line 202  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 232  mansearch(const struct mansearch *search,
Line 229  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);                                  fprintf(stderr, "%s: getcwd: %s\n",
                         break;                                      paths->paths[i], buf);
                 } else if (-1 == chdir(paths->paths[i])) {                                  continue;
                           } else if (chdir(buf) == -1) {
                                   perror(buf);
                                   continue;
                           }
                   }
                   if (chdir(paths->paths[i]) == -1) {
                         perror(paths->paths[i]);                          perror(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);
Line 368  mansearch(const struct mansearch *search,
Line 373  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:                  perror(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 402  manpage_compare(const void *vp1, const void *vp2)
Line 402  manpage_compare(const void *vp1, const void *vp2)
   
         mp1 = vp1;          mp1 = vp1;
         mp2 = vp2;          mp2 = vp2;
         return( (diff = mp2->bits - mp1->bits) ? diff :          return (diff = mp2->bits - mp1->bits) ? diff :
                 (diff = mp1->sec - mp2->sec) ? diff :              (diff = mp1->sec - mp2->sec) ? diff :
                 strcasecmp(mp1->names, mp2->names));              strcasecmp(mp1->names, mp2->names);
 }  }
   
 static void  static void
Line 412  buildnames(const struct mansearch *search, struct manp
Line 412  buildnames(const struct mansearch *search, struct manp
                 sqlite3 *db, sqlite3_stmt *s,                  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;
         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 494  buildnames(const struct mansearch *search, struct manp
Line 495  buildnames(const struct mansearch *search, struct manp
                 sep2 = *arch == '\0' ? "" : "/";                  sep2 = *arch == '\0' ? "" : "/";
                 mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",                  mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",
                     path, sep1, sec, sep2, arch, name, fsec);                      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
                           free(mpage->file);
                   mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.*",
                       path, sep1, sec, sep2, arch, name);
                   globres = glob(mpage->file, 0, NULL, &globinfo);
                   free(mpage->file);
                   mpage->file = globres ? NULL :
                       mandoc_strdup(*globinfo.gl_pathv);
                   globfree(&globinfo);
         }          }
         if (c != SQLITE_DONE)          if (c != SQLITE_DONE)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  fprintf(stderr, "%s\n", 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 (prevsec != NULL) {          if (prevsec != NULL) {
Line 541  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
Line 565  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
         if (SQLITE_DONE != c)          if (SQLITE_DONE != c)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  fprintf(stderr, "%s\n", sqlite3_errmsg(db));
         sqlite3_reset(s);          sqlite3_reset(s);
         return(output);          return output;
 }  }
   
 /*  /*
Line 636  sql_statement(const struct expr *e)
Line 660  sql_statement(const struct expr *e)
                 needop = 1;                  needop = 1;
         }          }
   
         return(sql);          return sql;
 }  }
   
 /*  /*
Line 719  exprcomp(const struct mansearch *search, int argc, cha
Line 743  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))
                 return(first);                  return first;
   
 fail:  fail:
         if (NULL != first)          if (NULL != first)
                 exprfree(first);                  exprfree(first);
         return(NULL);          return NULL;
 }  }
   
 static struct expr *  static struct expr *
Line 737  exprterm(const struct mansearch *search, char *buf, in
Line 761  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 745  exprterm(const struct mansearch *search, char *buf, in
Line 769  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 783  exprterm(const struct mansearch *search, char *buf, in
Line 807  exprterm(const struct mansearch *search, char *buf, in
                         regerror(irc, &e->regexp, errbuf, sizeof(errbuf));                          regerror(irc, &e->regexp, errbuf, sizeof(errbuf));
                         fprintf(stderr, "regcomp: %s\n", errbuf);                          fprintf(stderr, "regcomp: %s\n", 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 810  exprterm(const struct mansearch *search, char *buf, in
Line 834  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 835  static void *
Line 859  static void *
 hash_calloc(size_t nmemb, size_t sz, void *arg)  hash_calloc(size_t nmemb, size_t sz, void *arg)
 {  {
   
         return(mandoc_calloc(nmemb, sz));          return mandoc_calloc(nmemb, sz);
 }  }
   
 static void *  static void *
 hash_alloc(size_t sz, void *arg)  hash_alloc(size_t sz, void *arg)
 {  {
   
         return(mandoc_malloc(sz));          return mandoc_malloc(sz);
 }  }
   
 static void  static void
Legend:
Removed from v.1.53  
changed lines
  Added in v.1.58
CVSweb