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

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

version 1.57, 2015/04/01 12:48:33 version 1.58, 2015/10/06 18:32:19
Line 121  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 131  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 180  mansearch(const struct mansearch *search,
Line 180  mansearch(const struct mansearch *search,
   
         if (argc == 0 || (e = exprcomp(search, argc, argv)) == NULL) {          if (argc == 0 || (e = exprcomp(search, argc, argv)) == NULL) {
                 *sz = 0;                  *sz = 0;
                 return(0);                  return 0;
         }          }
   
         info.calloc = hash_calloc;          info.calloc = hash_calloc;
Line 378  mansearch(const struct mansearch *search,
Line 378  mansearch(const struct mansearch *search,
         exprfree(e);          exprfree(e);
         free(sql);          free(sql);
         *sz = cur;          *sz = cur;
         return(1);          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 565  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 660  sql_statement(const struct expr *e)
Line 660  sql_statement(const struct expr *e)
                 needop = 1;                  needop = 1;
         }          }
   
         return(sql);          return sql;
 }  }
   
 /*  /*
Line 743  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 761  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 769  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 807  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 834  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 859  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.57  
changed lines
  Added in v.1.58

CVSweb