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

Diff for /mandoc/Attic/apropos_db.c between version 1.15 and 1.29

version 1.15, 2011/11/28 09:44:05 version 1.29, 2012/03/23 05:07:35
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"
   #endif
   
 #include <assert.h>  #include <assert.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <regex.h>  #include <regex.h>
Line 24 
Line 28 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #ifdef __linux__  #if defined(__linux__)
   # include <endian.h>
 # include <db_185.h>  # include <db_185.h>
   #elif defined(__APPLE__)
   # include <libkern/OSByteOrder.h>
   # include <db.h>
 #else  #else
 # include <db.h>  # include <db.h>
 #endif  #endif
Line 52  struct expr {
Line 60  struct expr {
         int              regex; /* is regex? */          int              regex; /* is regex? */
         int              index; /* index in match array */          int              index; /* index in match array */
         uint64_t         mask; /* type-mask */          uint64_t         mask; /* type-mask */
         int              cs; /* is case-sensitive? */  
         int              and; /* is rhs of logical AND? */          int              and; /* is rhs of logical AND? */
         char            *v; /* search value */          char            *v; /* search value */
         regex_t          re; /* compiled re, if regex */          regex_t          re; /* compiled re, if regex */
Line 110  static const struct type types[] = {
Line 117  static const struct type types[] = {
         { TYPE_Va, "Va" },          { TYPE_Va, "Va" },
         { TYPE_Va, "Vt" },          { TYPE_Va, "Vt" },
         { TYPE_Xr, "Xr" },          { TYPE_Xr, "Xr" },
         { INT_MAX, "any" },          { UINT64_MAX, "any" },
         { 0, NULL }          { 0, NULL }
 };  };
   
 static  DB      *btree_open(void);  static  DB      *btree_open(void);
 static  int      btree_read(const DBT *,  static  int      btree_read(const DBT *, const DBT *,
                         const struct mchars *, char **);                          const struct mchars *,
                           uint64_t *, recno_t *, char **);
 static  int      expreval(const struct expr *, int *);  static  int      expreval(const struct expr *, int *);
 static  void     exprexec(const struct expr *,  static  void     exprexec(const struct expr *,
                         const char *, uint64_t, struct rec *);                          const char *, uint64_t, struct rec *);
Line 145  btree_open(void)
Line 153  btree_open(void)
         DB              *db;          DB              *db;
   
         memset(&info, 0, sizeof(BTREEINFO));          memset(&info, 0, sizeof(BTREEINFO));
           info.lorder = 4321;
         info.flags = R_DUP;          info.flags = R_DUP;
   
         db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);          db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);
Line 159  btree_open(void)
Line 168  btree_open(void)
  * Return 0 if the database is insane, else 1.   * Return 0 if the database is insane, else 1.
  */   */
 static int  static int
 btree_read(const DBT *v, const struct mchars *mc, char **buf)  btree_read(const DBT *k, const DBT *v, const struct mchars *mc,
                   uint64_t *mask, recno_t *rec, char **buf)
 {  {
           uint64_t         vbuf[2];
   
         /* Sanity: are we nil-terminated? */          /* Are our sizes sane? */
           if (k->size < 2 || sizeof(vbuf) != v->size)
                   return(0);
   
         assert(v->size > 0);          /* Is our string nil-terminated? */
           if ('\0' != ((const char *)k->data)[(int)k->size - 1])
         if ('\0' != ((char *)v->data)[(int)v->size - 1])  
                 return(0);                  return(0);
   
         norm_string((char *)v->data, mc, buf);          norm_string((const char *)k->data, mc, buf);
           memcpy(vbuf, v->data, v->size);
           *mask = betoh64(vbuf[0]);
           *rec  = betoh64(vbuf[1]);
         return(1);          return(1);
 }  }
   
Line 182  btree_read(const DBT *v, const struct mchars *mc, char
Line 197  btree_read(const DBT *v, const struct mchars *mc, char
 static size_t  static size_t
 norm_utf8(unsigned int cp, char out[7])  norm_utf8(unsigned int cp, char out[7])
 {  {
         size_t           rc;          int              rc;
   
         rc = 0;          rc = 0;
   
Line 223  norm_utf8(unsigned int cp, char out[7])
Line 238  norm_utf8(unsigned int cp, char out[7])
                 return(0);                  return(0);
   
         out[rc] = '\0';          out[rc] = '\0';
         return(rc);          return((size_t)rc);
 }  }
   
 /*  /*
Line 350  index_read(const DBT *key, const DBT *val, int index,
Line 365  index_read(const DBT *key, const DBT *val, int index,
 {  {
         size_t           left;          size_t           left;
         char            *np, *cp;          char            *np, *cp;
           char             type;
   
 #define INDEX_BREAD(_dst) \  #define INDEX_BREAD(_dst) \
         do { \          do { \
Line 360  index_read(const DBT *key, const DBT *val, int index,
Line 376  index_read(const DBT *key, const DBT *val, int index,
                 cp = np + 1; \                  cp = np + 1; \
         } while (/* CONSTCOND */ 0)          } while (/* CONSTCOND */ 0)
   
         left = val->size;          if (0 == (left = val->size))
         cp = (char *)val->data;                  return(0);
   
         rec->res.rec = *(recno_t *)key->data;          cp = val->data;
           assert(sizeof(recno_t) == key->size);
           memcpy(&rec->res.rec, key->data, key->size);
         rec->res.volume = index;          rec->res.volume = index;
   
         INDEX_BREAD(rec->res.type);          if ('d' == (type = *cp++))
                   rec->res.type = RESTYPE_MDOC;
           else if ('a' == type)
                   rec->res.type = RESTYPE_MAN;
           else if ('c' == type)
                   rec->res.type = RESTYPE_CAT;
           else
                   return(0);
   
           left--;
         INDEX_BREAD(rec->res.file);          INDEX_BREAD(rec->res.file);
         INDEX_BREAD(rec->res.cat);          INDEX_BREAD(rec->res.cat);
         INDEX_BREAD(rec->res.title);          INDEX_BREAD(rec->res.title);
Line 443  single_search(struct rectree *tree, const struct opts 
Line 470  single_search(struct rectree *tree, const struct opts 
                 struct mchars *mc, int vol)                  struct mchars *mc, int vol)
 {  {
         int              root, leaf, ch;          int              root, leaf, ch;
         uint64_t         mask;  
         DBT              key, val;          DBT              key, val;
         DB              *btree, *idx;          DB              *btree, *idx;
         char            *buf;          char            *buf;
         recno_t          rec;  
         struct rec      *rs;          struct rec      *rs;
         struct rec       r;          struct rec       r;
         struct db_val   *vbuf;          uint64_t         mask;
           recno_t          rec;
   
         root    = -1;          root    = -1;
         leaf    = -1;          leaf    = -1;
Line 470  single_search(struct rectree *tree, const struct opts 
Line 496  single_search(struct rectree *tree, const struct opts 
         }          }
   
         while (0 == (ch = (*btree->seq)(btree, &key, &val, R_NEXT))) {          while (0 == (ch = (*btree->seq)(btree, &key, &val, R_NEXT))) {
                 if (key.size < 2 || sizeof(struct db_val) != val.size)                  if ( ! btree_read(&key, &val, mc, &mask, &rec, &buf))
                         break;                          break;
                 if ( ! btree_read(&key, mc, &buf))  
                         break;  
   
                 vbuf = val.data;  
                 rec = vbuf->rec;  
                 mask = vbuf->mask;  
   
                 /*                  /*
                  * See if this keyword record matches any of the                   * See if this keyword record matches any of the
                  * expressions we have stored.                   * expressions we have stored.
Line 534  single_search(struct rectree *tree, const struct opts 
Line 554  single_search(struct rectree *tree, const struct opts 
   
                 if (opts->cat && strcasecmp(opts->cat, r.res.cat))                  if (opts->cat && strcasecmp(opts->cat, r.res.cat))
                         continue;                          continue;
                 if (opts->arch && strcasecmp(opts->arch, r.res.arch))  
                         continue;  
   
                   if (opts->arch && *r.res.arch)
                           if (strcasecmp(opts->arch, r.res.arch))
                                   continue;
   
                 tree->node = rs = mandoc_realloc                  tree->node = rs = mandoc_realloc
                         (rs, (tree->len + 1) * sizeof(struct rec));                          (rs, (tree->len + 1) * sizeof(struct rec));
   
                 memcpy(&rs[tree->len], &r, sizeof(struct rec));                  memcpy(&rs[tree->len], &r, sizeof(struct rec));
                   memset(&r, 0, sizeof(struct rec));
                 rs[tree->len].matches =                  rs[tree->len].matches =
                         mandoc_calloc(terms, sizeof(int));                          mandoc_calloc(terms, sizeof(int));
   
Line 556  single_search(struct rectree *tree, const struct opts 
Line 579  single_search(struct rectree *tree, const struct opts 
                 } else                  } else
                         root = tree->len;                          root = tree->len;
   
                 memset(&r, 0, sizeof(struct rec));  
                 tree->len++;                  tree->len++;
         }          }
   
Line 564  single_search(struct rectree *tree, const struct opts 
Line 586  single_search(struct rectree *tree, const struct opts 
         (*idx->close)(idx);          (*idx->close)(idx);
   
         free(buf);          free(buf);
           recfree(&r);
         return(1 == ch);          return(1 == ch);
 }  }
   
Line 694  exprexpr(int argc, char *argv[], int *pos, int *lvl, s
Line 717  exprexpr(int argc, char *argv[], int *pos, int *lvl, s
                         ++(*pos);                          ++(*pos);
                         ++(*lvl);                          ++(*lvl);
                         next = mandoc_calloc(1, sizeof(struct expr));                          next = mandoc_calloc(1, sizeof(struct expr));
                         next->cs = 1;  
                         next->subexpr = exprexpr(argc, argv, pos, lvl, tt);                          next->subexpr = exprexpr(argc, argv, pos, lvl, tt);
                         if (NULL == next->subexpr) {                          if (NULL == next->subexpr) {
                                 free(next);                                  free(next);
Line 745  exprterm(char *buf, int cs)
Line 767  exprterm(char *buf, int cs)
   
         memset(&e, 0, sizeof(struct expr));          memset(&e, 0, sizeof(struct expr));
   
         e.cs = cs;  
   
         /* Choose regex or substring match. */          /* Choose regex or substring match. */
   
         if (NULL == (e.v = strpbrk(buf, "=~"))) {          if (NULL == (e.v = strpbrk(buf, "=~"))) {
Line 818  exprmark(const struct expr *p, const char *cp,
Line 838  exprmark(const struct expr *p, const char *cp,
                 if (p->regex) {                  if (p->regex) {
                         if (regexec(&p->re, cp, 0, NULL, 0))                          if (regexec(&p->re, cp, 0, NULL, 0))
                                 continue;                                  continue;
                 } else if (p->cs) {                  } else if (NULL == strcasestr(cp, p->v))
                         if (NULL == strstr(cp, p->v))                          continue;
                                 continue;  
                 } else {  
                         if (NULL == strcasestr(cp, p->v))  
                                 continue;  
                 }  
   
                 if (NULL == ms)                  if (NULL == ms)
                         return(1);                          return(1);
Legend:
Removed from v.1.15  
changed lines
  Added in v.1.29
CVSweb