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

Diff for /mandoc/mansearch.c between version 1.40 and 1.51

version 1.40, 2014/08/05 12:34:08 version 1.51, 2014/11/27 01:58:21
Line 15 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
 #include <sys/mman.h>  #include <sys/mman.h>
   #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
Line 32 
Line 32 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #ifdef HAVE_OHASH  #if HAVE_OHASH
 #include <ohash.h>  #include <ohash.h>
 #else  #else
 #include "compat_ohash.h"  #include "compat_ohash.h"
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; /* 0 == catpage */          int              form; /* bit field: formatted, zipped? */
 };  };
   
 static  void             buildnames(struct manpage *, sqlite3 *,  static  void             buildnames(struct manpage *, sqlite3 *,
Line 123  mansearch_setup(int start)
Line 124  mansearch_setup(int start)
                 }                  }
   
                 pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,                  pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,
                     PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);                      PROT_READ | PROT_WRITE,
                       MAP_SHARED | MAP_ANON, -1, 0);
   
                 if (MAP_FAILED == pagecache) {                  if (MAP_FAILED == pagecache) {
                         perror("mmap");                          perror("mmap");
Line 158  int
Line 160  int
 mansearch(const struct mansearch *search,  mansearch(const struct mansearch *search,
                 const struct manpaths *paths,                  const struct manpaths *paths,
                 int argc, char *argv[],                  int argc, char *argv[],
                 const char *outkey,  
                 struct manpage **res, size_t *sz)                  struct manpage **res, size_t *sz)
 {  {
         int              fd, rc, c, indexbit;          int              fd, rc, c, indexbit;
Line 194  mansearch(const struct mansearch *search,
Line 195  mansearch(const struct mansearch *search,
                 goto out;                  goto out;
   
         outbit = 0;          outbit = 0;
         if (NULL != outkey) {          if (NULL != search->outkey) {
                 for (indexbit = 0, iterbit = 1;                  for (indexbit = 0, iterbit = 1;
                      indexbit < mansearch_keymax;                       indexbit < mansearch_keymax;
                      indexbit++, iterbit <<= 1) {                       indexbit++, iterbit <<= 1) {
                         if (0 == strcasecmp(outkey,                          if (0 == strcasecmp(search->outkey,
                             mansearch_keynames[indexbit])) {                              mansearch_keynames[indexbit])) {
                                 outbit = iterbit;                                  outbit = iterbit;
                                 break;                                  break;
Line 301  mansearch(const struct mansearch *search,
Line 302  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(                                  mp->desc = mandoc_strdup((const char *)
                                     sqlite3_column_text(s, 0));                                      sqlite3_column_text(s, 0));
                         ohash_insert(&htab, idx, mp);                          ohash_insert(&htab, idx, mp);
                 }                  }
Line 335  mansearch(const struct mansearch *search,
Line 337  mansearch(const struct mansearch *search,
                                     maxres, sizeof(struct manpage));                                      maxres, sizeof(struct manpage));
                         }                          }
                         mpage = *res + cur;                          mpage = *res + cur;
                           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(mpage, db, s, mp->pageid,
Line 351  mansearch(const struct mansearch *search,
Line 355  mansearch(const struct mansearch *search,
                 sqlite3_finalize(s2);                  sqlite3_finalize(s2);
                 sqlite3_close(db);                  sqlite3_close(db);
                 ohash_delete(&htab);                  ohash_delete(&htab);
   
                   /*
                    * In man(1) mode, prefer matches in earlier trees
                    * over matches in later trees.
                    */
   
                   if (cur && search->firstmatch)
                           break;
         }          }
         qsort(*res, cur, sizeof(struct manpage), manpage_compare);          qsort(*res, cur, sizeof(struct manpage), manpage_compare);
         rc = 1;          rc = 1;
Line 366  out:
Line 378  out:
         return(rc);          return(rc);
 }  }
   
   void
   mansearch_free(struct manpage *res, size_t sz)
   {
           size_t   i;
   
           for (i = 0; i < sz; i++) {
                   free(res[i].file);
                   free(res[i].names);
                   free(res[i].output);
           }
           free(res);
   }
   
 static int  static int
 manpage_compare(const void *vp1, const void *vp2)  manpage_compare(const void *vp1, const void *vp2)
 {  {
Line 374  manpage_compare(const void *vp1, const void *vp2)
Line 399  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
Line 406  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 432  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
   
                 /* Fetch the next name. */                  /* Fetch the next name. */
   
                 sec = sqlite3_column_text(s, 0);                  sec = (const char *)sqlite3_column_text(s, 0);
                 arch = sqlite3_column_text(s, 1);                  arch = (const char *)sqlite3_column_text(s, 1);
                 name = sqlite3_column_text(s, 2);                  name = (const char *)sqlite3_column_text(s, 2);
   
                 /* Remember the first section found. */                  /* Remember the first section found. */
   
Line 446  buildnames(struct manpage *mpage, sqlite3 *db, sqlite3
Line 472  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) {                  if (form & FORM_SRC) {
                         sep1 = "man";                          sep1 = "man";
                         fsec = sec;                          fsec = sec;
                 } else {                  } else {
                         sep1 = "cat";                          sep1 = "cat";
                         fsec = "0";                          fsec = "0";
                 }                  }
                 sep2 = '\0' == *arch ? "" : "/";                  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 (SQLITE_DONE != c)          if (c != SQLITE_DONE)
                 fprintf(stderr, "%s\n", sqlite3_errmsg(db));                  fprintf(stderr, "%s\n", sqlite3_errmsg(db));
         sqlite3_reset(s);          sqlite3_reset(s);
   
         /* 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 497  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
Line 523  buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pag
                         oldoutput = output;                          oldoutput = output;
                         sep1 = " # ";                          sep1 = " # ";
                 }                  }
                 data = sqlite3_column_text(s, 1);                  data = (const char *)sqlite3_column_text(s, 1);
                 mandoc_asprintf(&newoutput, "%s%s%s",                  mandoc_asprintf(&newoutput, "%s%s%s",
                     oldoutput, sep1, data);                      oldoutput, sep1, data);
                 free(output);                  free(output);
Line 565  sql_statement(const struct expr *e)
Line 591  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 586  sql_statement(const struct expr *e)
Line 614  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 738  exprterm(const struct mansearch *search, char *buf, in
Line 765  exprterm(const struct mansearch *search, char *buf, in
   
         e = mandoc_calloc(1, sizeof(struct expr));          e = mandoc_calloc(1, sizeof(struct expr));
   
         if (MANSEARCH_MAN & search->flags) {          if (search->argmode == ARG_NAME) {
                 e->bits = search->deftype;                  e->bits = TYPE_Nm;
                 e->substr = buf;                  e->substr = buf;
                 e->equal = 1;                  e->equal = 1;
                 return(e);                  return(e);
         }          }
   
         /*          /*
          * Look for an '=' or '~' operator,           * Separate macro keys from search string.
          * unless forced to some fixed macro keys.           * If needed, request regular expression handling
            * by setting e->substr to NULL.
          */           */
   
         if (MANSEARCH_WHATIS & search->flags)          if (search->argmode == ARG_WORD) {
                 val = NULL;                  e->bits = TYPE_Nm;
         else                  e->substr = NULL;
                 val = strpbrk(buf, "=~");                  mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", buf);
                   cs = 0;
         if (NULL == val) {          } else if ((val = strpbrk(buf, "=~")) == NULL) {
                 e->bits = search->deftype;                  e->bits = TYPE_Nm | TYPE_Nd;
                 e->substr = buf;                  e->substr = buf;
   
         /*  
          * Found an operator.  
          * Regexp search is requested by !e->substr.  
          */  
   
         } else {          } else {
                 if (val == buf)                  if (val == buf)
                         e->bits = search->deftype;                          e->bits = TYPE_Nm | TYPE_Nd;
                 if ('=' == *val)                  if ('=' == *val)
                         e->substr = val + 1;                          e->substr = val + 1;
                 *val++ = '\0';                  *val++ = '\0';
Line 776  exprterm(const struct mansearch *search, char *buf, in
Line 798  exprterm(const struct mansearch *search, char *buf, in
   
         /* Compile regular expressions. */          /* Compile regular expressions. */
   
         if (MANSEARCH_WHATIS & search->flags) {  
                 e->substr = NULL;  
                 mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", buf);  
         }  
   
         if (NULL == e->substr) {          if (NULL == e->substr) {
                 irc = regcomp(&e->regexp, val,                  irc = regcomp(&e->regexp, val,
                     REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE));                      REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE));
                 if (MANSEARCH_WHATIS & search->flags)                  if (search->argmode == ARG_WORD)
                         free(val);                          free(val);
                 if (irc) {                  if (irc) {
                         regerror(irc, &e->regexp, errbuf, sizeof(errbuf));                          regerror(irc, &e->regexp, errbuf, sizeof(errbuf));
Legend:
Removed from v.1.40  
changed lines
  Added in v.1.51
CVSweb