In apropos_db.c, move all btree reading (and safety checks) into the

[mandoc.git] / apropos_db.c

diff --git a/apropos_db.c b/apropos_db.c
index 798ada4005757f4c40325e4eabf264fd40b098fa..4d9ae874601f577466a3e6d99652908080debc97 100644 (file)
--- a/apropos_db.c
+++ b/apropos_db.c
@@ -1,4 +1,4 @@
-/*     $Id: apropos_db.c,v 1.7 2011/11/20 12:46:53 kristaps Exp $ */
+/*     $Id: apropos_db.c,v 1.17 2011/12/01 23:46:26 kristaps Exp $ */

 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>


@@ -22,6 +22,9 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>

+#include <unistd.h>
+
+#include <arpa/inet.h>

 
 #ifdef __linux__
 # include <db_185.h>
 
 #ifdef __linux__
 # include <db_185.h>


@@ -51,7 +54,6 @@ struct        expr {
        int              regex; /* is regex? */
        int              index; /* index in match array */
        uint64_t         mask; /* type-mask */
        int              regex; /* is regex? */
        int              index; /* index in match array */
        uint64_t         mask; /* type-mask */

-       int              cs; /* is case-sensitive? */

        int              and; /* is rhs of logical AND? */
        char            *v; /* search value */
        regex_t          re; /* compiled re, if regex */
        int              and; /* is rhs of logical AND? */
        char            *v; /* search value */
        regex_t          re; /* compiled re, if regex */


@@ -64,6 +66,11 @@ struct       type {
        const char      *name;
 };
 
        const char      *name;
 };
 

+struct rectree {
+       struct rec      *node; /* record array for dir tree */
+       int              len; /* length of record array */
+};
+

 static const struct type types[] = {
        { TYPE_An, "An" },
        { TYPE_Ar, "Ar" },
 static const struct type types[] = {
        { TYPE_An, "An" },
        { TYPE_Ar, "Ar" },


@@ -109,22 +116,26 @@ static    const struct type types[] = {
 };
 
 static DB      *btree_open(void);
 };
 
 static DB      *btree_open(void);

-static int      btree_read(const DBT *, 
-                       const struct mchars *, char **);
+static int      btree_read(const DBT *, const DBT *,
+                       const struct mchars *, 
+                       struct db_val *, 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 *);

-static int      exprmark(const struct expr *, 
+static int      exprmark(const struct expr *,

                        const char *, uint64_t, int *);
 static struct expr *exprexpr(int, char *[], int *, int *, size_t *);
 static struct expr *exprterm(char *, int);
 static DB      *index_open(void);
                        const char *, uint64_t, int *);
 static struct expr *exprexpr(int, char *[], int *, int *, size_t *);
 static struct expr *exprterm(char *, int);
 static DB      *index_open(void);

-static int      index_read(const DBT *, const DBT *, 
+static int      index_read(const DBT *, const DBT *, int,

                        const struct mchars *, struct rec *);
 static void     norm_string(const char *,
                        const struct mchars *, char **);
 static size_t   norm_utf8(unsigned int, char[7]);
 static void     recfree(struct rec *);
                        const struct mchars *, struct rec *);
 static void     norm_string(const char *,
                        const struct mchars *, char **);
 static size_t   norm_utf8(unsigned int, char[7]);
 static void     recfree(struct rec *);

+static int      single_search(struct rectree *, const struct opts *,
+                       const struct expr *, size_t terms,
+                       struct mchars *, int);

 
 /*
  * Open the keyword mandoc-db database.
 
 /*
  * Open the keyword mandoc-db database.


@@ -139,7 +150,7 @@ btree_open(void)
        info.flags = R_DUP;
 
        db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);
        info.flags = R_DUP;
 
        db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);

-       if (NULL != db) 
+       if (NULL != db)

                return(db);
 
        return(NULL);
                return(db);
 
        return(NULL);


@@ -150,24 +161,31 @@ btree_open(void)
  * Return 0 if the database is insane, else 1.
  */
 static int
  * Return 0 if the database is insane, else 1.
  */
 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, 
+               struct db_val *dbv, char **buf)

 {
 {

+       const struct db_val *vp;

 
 

-       /* Sanity: are we nil-terminated? */
-
-       assert(v->size > 0);
+       /* Are our sizes sane? */
+       if (k->size < 2 || sizeof(struct db_val) != v->size)
+               return(0);

 
 

-       if ('\0' != ((char *)v->data)[(int)v->size - 1])
+       /* Is our string nil-terminated? */
+       if ('\0' != ((const char *)k->data)[(int)k->size - 1])

                return(0);
 
                return(0);
 

-       norm_string((char *)v->data, mc, buf);
+       vp = v->data;
+       norm_string((const char *)k->data, mc, buf);
+       dbv->rec = ntohl(vp->rec);
+       dbv->mask = vp->mask;

        return(1);
 }
 
 /*
  * Take a Unicode codepoint and produce its UTF-8 encoding.
  * This isn't the best way to do this, but it works.
        return(1);
 }
 
 /*
  * Take a Unicode codepoint and produce its UTF-8 encoding.
  * This isn't the best way to do this, but it works.

- * The magic numbers are from the UTF-8 packaging.  
+ * The magic numbers are from the UTF-8 packaging.

  * They're not as scary as they seem: read the UTF-8 spec for details.
  */
 static size_t
  * They're not as scary as they seem: read the UTF-8 spec for details.
  */
 static size_t


@@ -232,7 +250,7 @@ norm_string(const char *val, const struct mchars *mc, char **buf)
        const char       *seq, *cpp;
        int               len, u, pos;
        enum mandoc_esc   esc;
        const char       *seq, *cpp;
        int               len, u, pos;
        enum mandoc_esc   esc;

-       static const char res[] = { '\\', '\t', 
+       static const char res[] = { '\\', '\t',

                                ASCII_NBRSP, ASCII_HYPH, '\0' };
 
        /* Pre-allocate by the length of the input */
                                ASCII_NBRSP, ASCII_HYPH, '\0' };
 
        /* Pre-allocate by the length of the input */


@@ -278,7 +296,7 @@ norm_string(const char *val, const struct mchars *mc, char **buf)
                if (ESCAPE_ERROR == esc)
                        break;
 
                if (ESCAPE_ERROR == esc)
                        break;
 

-               /* 
+               /*

                 * XXX - this just does UTF-8, but we need to know
                 * beforehand whether we should do text substitution.
                 */
                 * XXX - this just does UTF-8, but we need to know
                 * beforehand whether we should do text substitution.
                 */


@@ -336,7 +354,7 @@ index_open(void)
  * Returns 1 if an entry was unpacked, 0 if the database is insane.
  */
 static int
  * Returns 1 if an entry was unpacked, 0 if the database is insane.
  */
 static int

-index_read(const DBT *key, const DBT *val, 
+index_read(const DBT *key, const DBT *val, int index,

                const struct mchars *mc, struct rec *rec)
 {
        size_t           left;
                const struct mchars *mc, struct rec *rec)
 {
        size_t           left;


@@ -355,7 +373,9 @@ index_read(const DBT *key, const DBT *val,
        cp = (char *)val->data;
 
        rec->res.rec = *(recno_t *)key->data;
        cp = (char *)val->data;
 
        rec->res.rec = *(recno_t *)key->data;

+       rec->res.volume = index;

 
 

+       INDEX_BREAD(rec->res.type);

        INDEX_BREAD(rec->res.file);
        INDEX_BREAD(rec->res.cat);
        INDEX_BREAD(rec->res.title);
        INDEX_BREAD(rec->res.file);
        INDEX_BREAD(rec->res.cat);
        INDEX_BREAD(rec->res.title);


@@ -365,62 +385,106 @@ index_read(const DBT *key, const DBT *val,
 }
 
 /*
 }
 
 /*

- * Search the mandocdb database for the expression "expr".
+ * Search mandocdb databases in paths for expression "expr".

  * Filter out by "opts".
  * Call "res" with the results, which may be zero.
  * Return 0 if there was a database error, else return 1.
  */
 int
  * Filter out by "opts".
  * Call "res" with the results, which may be zero.
  * Return 0 if there was a database error, else return 1.
  */
 int

-apropos_search(const struct opts *opts, const struct expr *expr,
-               size_t terms, void *arg, 
+apropos_search(int pathsz, char **paths, const struct opts *opts,
+               const struct expr *expr, size_t terms, void *arg,

                void (*res)(struct res *, size_t, void *))
 {
                void (*res)(struct res *, size_t, void *))
 {

-       int              i, rsz, root, leaf, mlen, rc, ch;
-       uint64_t         mask;
+       struct rectree   tree;
+       struct mchars   *mc;
+       struct res      *ress;
+       int              i, mlen, rc;
+
+       memset(&tree, 0, sizeof(struct rectree));
+
+       rc = 0;
+       mc = mchars_alloc();
+
+       /*
+        * Main loop.  Change into the directory containing manpage
+        * databases.  Run our expession over each database in the set.
+        */
+
+       for (i = 0; i < pathsz; i++) {
+               if (chdir(paths[i]))
+                       continue;
+               if ( ! single_search(&tree, opts, expr, terms, mc, i))
+                       goto out;
+       }
+
+       /*
+        * Count matching files, transfer to a "clean" array, then feed
+        * them to the output handler.
+        */
+
+       for (mlen = i = 0; i < tree.len; i++)
+               if (tree.node[i].matched)
+                       mlen++;
+
+       ress = mandoc_malloc(mlen * sizeof(struct res));
+
+       for (mlen = i = 0; i < tree.len; i++)
+               if (tree.node[i].matched)
+                       memcpy(&ress[mlen++], &tree.node[i].res,
+                                       sizeof(struct res));
+
+       (*res)(ress, mlen, arg);
+       free(ress);
+
+       rc = 1;
+out:
+       for (i = 0; i < tree.len; i++)
+               recfree(&tree.node[i]);
+
+       free(tree.node);
+       mchars_free(mc);
+       return(rc);
+}
+
+static int
+single_search(struct rectree *tree, const struct opts *opts,
+               const struct expr *expr, size_t terms,
+               struct mchars *mc, int vol)
+{
+       int              root, leaf, ch;

        DBT              key, val;
        DB              *btree, *idx;
        DBT              key, val;
        DB              *btree, *idx;

-       struct mchars   *mc;

        char            *buf;
        char            *buf;

-       recno_t          rec;

        struct rec      *rs;
        struct rec      *rs;

-       struct res      *ress;

        struct rec       r;
        struct rec       r;

-       struct db_val   *vbuf;
+       struct db_val    vb;

 
 

-       rc      = 0;

        root    = -1;
        leaf    = -1;
        btree   = NULL;
        idx     = NULL;
        root    = -1;
        leaf    = -1;
        btree   = NULL;
        idx     = NULL;

-       mc      = NULL;

        buf     = NULL;
        buf     = NULL;

-       rs      = NULL;
-       rsz     = 0;
+       rs      = tree->node;

 
        memset(&r, 0, sizeof(struct rec));
 
 
        memset(&r, 0, sizeof(struct rec));
 

-       mc = mchars_alloc();
+       if (NULL == (btree = btree_open()))
+               return(1);

 
 

-       if (NULL == (btree = btree_open())) 
-               goto out;
-       if (NULL == (idx = index_open())) 
-               goto out;
+       if (NULL == (idx = index_open())) {
+               (*btree->close)(btree);
+               return(1);
+       }

 
        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) 
-                       break;
-               if ( ! btree_read(&key, mc, &buf))
+               if ( ! btree_read(&key, &val, mc, &vb, &buf))

                        break;
 
                        break;
 

-               vbuf = val.data;
-               rec = vbuf->rec;
-               mask = vbuf->mask;
-

                /*
                 * See if this keyword record matches any of the
                 * expressions we have stored.
                 */
                /*
                 * See if this keyword record matches any of the
                 * expressions we have stored.
                 */

-               if ( ! exprmark(expr, buf, mask, NULL))
+               if ( ! exprmark(expr, buf, vb.mask, NULL))

                        continue;
 
                /*
                        continue;
 
                /*


@@ -430,13 +494,13 @@ apropos_search(const struct opts *opts, const struct expr *expr,
                 */
 
                for (leaf = root; leaf >= 0; )
                 */
 
                for (leaf = root; leaf >= 0; )

-                       if (rec > rs[leaf].res.rec && 
+                       if (vb.rec > rs[leaf].res.rec &&

                                        rs[leaf].rhs >= 0)
                                leaf = rs[leaf].rhs;
                                        rs[leaf].rhs >= 0)
                                leaf = rs[leaf].rhs;

-                       else if (rec < rs[leaf].res.rec && 
+                       else if (vb.rec < rs[leaf].res.rec &&

                                        rs[leaf].lhs >= 0)
                                leaf = rs[leaf].lhs;
                                        rs[leaf].lhs >= 0)
                                leaf = rs[leaf].lhs;

-                       else 
+                       else

                                break;
 
                /*
                                break;
 
                /*


@@ -445,9 +509,9 @@ apropos_search(const struct opts *opts, const struct expr *expr,
                 * try to evaluate it now and continue anyway.
                 */
 
                 * try to evaluate it now and continue anyway.
                 */
 

-               if (leaf >= 0 && rs[leaf].res.rec == rec) {
+               if (leaf >= 0 && rs[leaf].res.rec == vb.rec) {

                        if (0 == rs[leaf].matched)
                        if (0 == rs[leaf].matched)

-                               exprexec(expr, buf, mask, &rs[leaf]);
+                               exprexec(expr, buf, vb.mask, &rs[leaf]);

                        continue;
                }
 
                        continue;
                }
 


@@ -457,14 +521,14 @@ apropos_search(const struct opts *opts, const struct expr *expr,
                 * database, then begin partial evaluation.
                 */
 
                 * database, then begin partial evaluation.
                 */
 

-               key.data = &rec;
+               key.data = &vb.rec;

                key.size = sizeof(recno_t);
 
                if (0 != (*idx->get)(idx, &key, &val, 0))
                        break;
 
                r.lhs = r.rhs = -1;
                key.size = sizeof(recno_t);
 
                if (0 != (*idx->get)(idx, &key, &val, 0))
                        break;
 
                r.lhs = r.rhs = -1;

-               if ( ! index_read(&key, &val, mc, &r))
+               if ( ! index_read(&key, &val, vol, mc, &r))

                        break;
 
                /* XXX: this should be elsewhere, I guess? */
                        break;
 
                /* XXX: this should be elsewhere, I guess? */


@@ -474,68 +538,41 @@ apropos_search(const struct opts *opts, const struct expr *expr,
                if (opts->arch && strcasecmp(opts->arch, r.res.arch))
                        continue;
 
                if (opts->arch && strcasecmp(opts->arch, r.res.arch))
                        continue;
 

-               rs = mandoc_realloc
-                       (rs, (rsz + 1) * sizeof(struct rec));
+               tree->node = rs = mandoc_realloc
+                       (rs, (tree->len + 1) * sizeof(struct rec));

 
 

-               memcpy(&rs[rsz], &r, sizeof(struct rec));
-               rs[rsz].matches = mandoc_calloc(terms, sizeof(int));
+               memcpy(&rs[tree->len], &r, sizeof(struct rec));
+               rs[tree->len].matches =
+                       mandoc_calloc(terms, sizeof(int));
+
+               exprexec(expr, buf, vb.mask, &rs[tree->len]);

 
 

-               exprexec(expr, buf, mask, &rs[rsz]); 

                /* Append to our tree. */
 
                if (leaf >= 0) {
                /* Append to our tree. */
 
                if (leaf >= 0) {

-                       if (rec > rs[leaf].res.rec)
-                               rs[leaf].rhs = rsz;
+                       if (vb.rec > rs[leaf].res.rec)
+                               rs[leaf].rhs = tree->len;

                        else
                        else

-                               rs[leaf].lhs = rsz;
+                               rs[leaf].lhs = tree->len;

                } else
                } else

-                       root = rsz;
-               
-               memset(&r, 0, sizeof(struct rec));
-               rsz++;
-       }
-       
-       /*
-        * If we haven't encountered any database errors, then construct
-        * an array of results and push them to the caller.
-        */
+                       root = tree->len;

 
 

-       if (1 == ch) {
-               for (mlen = i = 0; i < rsz; i++)
-                       if (rs[i].matched)
-                               mlen++;
-               ress = mandoc_malloc(mlen * sizeof(struct res));
-               for (mlen = i = 0; i < rsz; i++)
-                       if (rs[i].matched)
-                               memcpy(&ress[mlen++], &rs[i].res, 
-                                               sizeof(struct res));
-               (*res)(ress, mlen, arg);
-               free(ress);
-               rc = 1;
+               memset(&r, 0, sizeof(struct rec));
+               tree->len++;

        }
 
        }
 

-out:
-       for (i = 0; i < rsz; i++)
-               recfree(&rs[i]);
-
-       recfree(&r);
-
-       if (mc)
-               mchars_free(mc);
-       if (btree)
-               (*btree->close)(btree);
-       if (idx)
-               (*idx->close)(idx);
+       (*btree->close)(btree);
+       (*idx->close)(idx);

 
        free(buf);
 
        free(buf);

-       free(rs);
-       return(rc);
+       return(1 == ch);

 }
 
 static void
 recfree(struct rec *rec)
 {
 
 }
 
 static void
 recfree(struct rec *rec)
 {
 

+       free(rec->res.type);

        free(rec->res.file);
        free(rec->res.cat);
        free(rec->res.title);
        free(rec->res.file);
        free(rec->res.cat);
        free(rec->res.title);


@@ -545,6 +582,49 @@ recfree(struct rec *rec)
        free(rec->matches);
 }
 
        free(rec->matches);
 }
 

+/*
+ * Compile a list of straight-up terms.
+ * The arguments are re-written into ~[[:<:]]term[[:>:]], or "term"
+ * surrounded by word boundaries, then pumped through exprterm().
+ * Terms are case-insensitive.
+ * This emulates whatis(1) behaviour.
+ */
+struct expr *
+termcomp(int argc, char *argv[], size_t *tt)
+{
+       char            *buf;
+       int              pos;
+       struct expr     *e, *next;
+       size_t           sz;
+
+       buf = NULL;
+       e = NULL;
+       *tt = 0;
+
+       for (pos = argc - 1; pos >= 0; pos--) {
+               sz = strlen(argv[pos]) + 18;
+               buf = mandoc_realloc(buf, sz);
+               strlcpy(buf, "Nm~[[:<:]]", sz);
+               strlcat(buf, argv[pos], sz);
+               strlcat(buf, "[[:>:]]", sz);
+               if (NULL == (next = exprterm(buf, 0))) {
+                       free(buf);
+                       exprfree(e);
+                       return(NULL);
+               }
+               next->next = e;
+               e = next;
+               (*tt)++;
+       }
+
+       free(buf);
+       return(e);
+}
+
+/*
+ * Compile a sequence of logical expressions.
+ * See apropos.1 for a grammar of this sequence.
+ */

 struct expr *
 exprcomp(int argc, char *argv[], size_t *tt)
 {
 struct expr *
 exprcomp(int argc, char *argv[], size_t *tt)
 {


@@ -599,7 +679,7 @@ exprexpr(int argc, char *argv[], int *pos, int *lvl, size_t *tt)
                log = 0;
 
                if (NULL != e && 0 == strcmp("-a", argv[*pos]))
                log = 0;
 
                if (NULL != e && 0 == strcmp("-a", argv[*pos]))

-                       log = 1;                        
+                       log = 1;

                else if (NULL != e && 0 == strcmp("-o", argv[*pos]))
                        log = 2;
 
                else if (NULL != e && 0 == strcmp("-o", argv[*pos]))
                        log = 2;
 


@@ -616,7 +696,6 @@ exprexpr(int argc, char *argv[], int *pos, int *lvl, size_t *tt)
                        ++(*pos);
                        ++(*lvl);
                        next = mandoc_calloc(1, sizeof(struct expr));
                        ++(*pos);
                        ++(*lvl);
                        next = mandoc_calloc(1, sizeof(struct expr));

-                       next->cs = 1;

                        next->subexpr = exprexpr(argc, argv, pos, lvl, tt);
                        if (NULL == next->subexpr) {
                                free(next);
                        next->subexpr = exprexpr(argc, argv, pos, lvl, tt);
                        if (NULL == next->subexpr) {
                                free(next);


@@ -667,8 +746,6 @@ 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. */
 
        if (NULL == (e.v = strpbrk(buf, "=~"))) {
        /* Choose regex or substring match. */
 
        if (NULL == (e.v = strpbrk(buf, "=~"))) {


@@ -695,7 +772,7 @@ exprterm(char *buf, int cs)
                e.mask = TYPE_Nm | TYPE_Nd;
 
        if (e.regex) {
                e.mask = TYPE_Nm | TYPE_Nd;
 
        if (e.regex) {

-               i = REG_EXTENDED | REG_NOSUB | cs ? 0 : REG_ICASE;
+               i = REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE);

                if (regcomp(&e.re, e.v, i))
                        return(NULL);
        }
                if (regcomp(&e.re, e.v, i))
                        return(NULL);
        }


@@ -711,7 +788,7 @@ void
 exprfree(struct expr *p)
 {
        struct expr     *pp;
 exprfree(struct expr *p)
 {
        struct expr     *pp;

-       
+

        while (NULL != p) {
                if (p->subexpr)
                        exprfree(p->subexpr);
        while (NULL != p) {
                if (p->subexpr)
                        exprfree(p->subexpr);


@@ -725,7 +802,7 @@ exprfree(struct expr *p)
 }
 
 static int
 }
 
 static int

-exprmark(const struct expr *p, const char *cp, 
+exprmark(const struct expr *p, const char *cp,

                uint64_t mask, int *ms)
 {
 
                uint64_t mask, int *ms)
 {
 


@@ -740,13 +817,8 @@ exprmark(const struct expr *p, const char *cp,
                if (p->regex) {
                        if (regexec(&p->re, cp, 0, NULL, 0))
                                continue;
                if (p->regex) {
                        if (regexec(&p->re, cp, 0, NULL, 0))
                                continue;

-               } else if (p->cs) {
-                       if (NULL == strstr(cp, p->v))
-                               continue;
-               } else {
-                       if (NULL == strcasestr(cp, p->v))
-                               continue;
-               }
+               } else if (NULL == strcasestr(cp, p->v))
+                       continue;

 
                if (NULL == ms)
                        return(1);
 
                if (NULL == ms)
                        return(1);


@@ -780,7 +852,7 @@ expreval(const struct expr *p, int *ms)
                for ( ; p->next && p->next->and; p = p->next) {
                        /* Evaluate a subexpression, if applicable. */
                        if (p->next->subexpr && ! ms[p->next->index])
                for ( ; p->next && p->next->and; p = p->next) {
                        /* Evaluate a subexpression, if applicable. */
                        if (p->next->subexpr && ! ms[p->next->index])

-                               ms[p->next->index] = 
+                               ms[p->next->index] =

                                        expreval(p->next->subexpr, ms);
                        match = match && ms[p->next->index];
                }
                                        expreval(p->next->subexpr, ms);
                        match = match && ms[p->next->index];
                }


@@ -797,11 +869,11 @@ expreval(const struct expr *p, int *ms)
  * If this evaluates to true, mark the expression as satisfied.
  */
 static void
  * If this evaluates to true, mark the expression as satisfied.
  */
 static void

-exprexec(const struct expr *p, const char *cp, 
+exprexec(const struct expr *e, const char *cp,

                uint64_t mask, struct rec *r)
 {
 
        assert(0 == r->matched);
                uint64_t mask, struct rec *r)
 {
 
        assert(0 == r->matched);

-       exprmark(p, cp, mask, r->matches);
-       r->matched = expreval(p, r->matches);
+       exprmark(e, cp, mask, r->matches);
+       r->matched = expreval(e, r->matches);

 }
 }