Vastly simplify man(7) block unwinding, similar to mdoc_macro.c 1.171.

[mandoc.git] / mansearch.c

diff --git a/mansearch.c b/mansearch.c
index 886ceef3d0af66e64db73b35cc1bbf5ebd05bb8c..417bd11ded0cb23a4c96b0e0b1d5cb9abc8bee65 100644 (file)
--- a/mansearch.c
+++ b/mansearch.c
@@ -1,27 +1,30 @@
-/*     $Id: mansearch.c,v 1.14 2014/01/05 00:29:54 schwarze Exp $ */
+/*     $Id: mansearch.c,v 1.57 2015/04/01 12:48:33 schwarze Exp $ */

 /*
  * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>
 /*
  * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>

- * Copyright (c) 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * 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
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * 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/types.h>

 
 #include <assert.h>
 
 #include <assert.h>

+#include <errno.h>

 #include <fcntl.h>
 #include <getopt.h>
 #include <fcntl.h>
 #include <getopt.h>

+#include <glob.h>

 #include <limits.h>
 #include <regex.h>
 #include <stdio.h>
 #include <limits.h>
 #include <regex.h>
 #include <stdio.h>


@@ -31,17 +34,24 @@
 #include <string.h>
 #include <unistd.h>
 
 #include <string.h>
 #include <unistd.h>
 

-#ifdef HAVE_OHASH
+#if HAVE_OHASH

 #include <ohash.h>
 #else
 #include "compat_ohash.h"
 #endif
 #include <sqlite3.h>
 #include <ohash.h>
 #else
 #include "compat_ohash.h"
 #endif
 #include <sqlite3.h>

+#ifndef SQLITE_DETERMINISTIC
+#define SQLITE_DETERMINISTIC 0
+#endif

 
 #include "mandoc.h"
 
 #include "mandoc.h"

-#include "manpath.h"
+#include "mandoc_aux.h"
+#include "manconf.h"

 #include "mansearch.h"
 
 #include "mansearch.h"
 

+extern int mansearch_keymax;
+extern const char *const mansearch_keynames[];
+

 #define        SQL_BIND_TEXT(_db, _s, _i, _v) \
        do { if (SQLITE_OK != sqlite3_bind_text \
                ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \
 #define        SQL_BIND_TEXT(_db, _s, _i, _v) \
        do { if (SQLITE_OK != sqlite3_bind_text \
                ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \


@@ -59,102 +69,102 @@
        } while (0)
 
 struct expr {
        } while (0)
 
 struct expr {

-       uint64_t         bits;    /* type-mask */
-       const char      *substr;  /* to search for, if applicable */

        regex_t          regexp;  /* compiled regexp, if applicable */
        regex_t          regexp;  /* compiled regexp, if applicable */

+       const char      *substr;  /* to search for, if applicable */
+       struct expr     *next;    /* next in sequence */
+       uint64_t         bits;    /* type-mask */
+       int              equal;   /* equality, not subsring match */

        int              open;    /* opening parentheses before */
        int              and;     /* logical AND before */
        int              close;   /* closing parentheses after */
        int              open;    /* opening parentheses before */
        int              and;     /* logical AND before */
        int              close;   /* closing parentheses after */

-       struct expr     *next;    /* next in sequence */

 };
 
 struct match {
 };
 
 struct match {

-       uint64_t         id; /* identifier in database */
-       char            *file; /* relative filepath of manpage */
-       char            *desc; /* description of manpage */
-       int              form; /* 0 == catpage */
+       uint64_t         pageid; /* identifier in database */
+       uint64_t         bits; /* name type mask */
+       char            *desc; /* manual page description */
+       int              form; /* bit field: formatted, zipped? */

 };
 
 };
 

-struct type {
-       uint64_t         bits;
-       const char      *name;
-};
-
-static const struct type types[] = {
-       { TYPE_An,  "An" },
-       { TYPE_Ar,  "Ar" },
-       { TYPE_At,  "At" },
-       { TYPE_Bsx, "Bsx" },
-       { TYPE_Bx,  "Bx" },
-       { TYPE_Cd,  "Cd" },
-       { TYPE_Cm,  "Cm" },
-       { TYPE_Dv,  "Dv" },
-       { TYPE_Dx,  "Dx" },
-       { TYPE_Em,  "Em" },
-       { TYPE_Er,  "Er" },
-       { TYPE_Ev,  "Ev" },
-       { TYPE_Fa,  "Fa" },
-       { TYPE_Fl,  "Fl" },
-       { TYPE_Fn,  "Fn" },
-       { TYPE_Fn,  "Fo" },
-       { TYPE_Ft,  "Ft" },
-       { TYPE_Fx,  "Fx" },
-       { TYPE_Ic,  "Ic" },
-       { TYPE_In,  "In" },
-       { TYPE_Lb,  "Lb" },
-       { TYPE_Li,  "Li" },
-       { TYPE_Lk,  "Lk" },
-       { TYPE_Ms,  "Ms" },
-       { TYPE_Mt,  "Mt" },
-       { TYPE_Nd,  "Nd" },
-       { TYPE_Nm,  "Nm" },
-       { TYPE_Nx,  "Nx" },
-       { TYPE_Ox,  "Ox" },
-       { TYPE_Pa,  "Pa" },
-       { TYPE_Rs,  "Rs" },
-       { TYPE_Sh,  "Sh" },
-       { TYPE_Ss,  "Ss" },
-       { TYPE_St,  "St" },
-       { TYPE_Sy,  "Sy" },
-       { TYPE_Tn,  "Tn" },
-       { TYPE_Va,  "Va" },
-       { TYPE_Va,  "Vt" },
-       { TYPE_Xr,  "Xr" },
-       { TYPE_sec, "sec" },
-       { TYPE_arch,"arch" },
-       { ~0ULL,    "any" },
-       { 0ULL, NULL }
-};
-
-static char            *buildnames(sqlite3 *, sqlite3_stmt *, uint64_t);
+static void             buildnames(const struct mansearch *,
+                               struct manpage *, sqlite3 *,
+                               sqlite3_stmt *, uint64_t,
+                               const char *, int form);

 static char            *buildoutput(sqlite3 *, sqlite3_stmt *,
                                 uint64_t, uint64_t);
 static void            *hash_alloc(size_t, void *);
 static char            *buildoutput(sqlite3 *, sqlite3_stmt *,
                                 uint64_t, uint64_t);
 static void            *hash_alloc(size_t, void *);

-static void             hash_free(void *, size_t, void *);
-static void            *hash_halloc(size_t, void *);
-static struct expr     *exprcomp(const struct mansearch *, 
+static void             hash_free(void *, void *);
+static void            *hash_calloc(size_t, size_t, void *);
+static struct expr     *exprcomp(const struct mansearch *,

                                int, char *[]);
 static void             exprfree(struct expr *);
 static struct expr     *exprterm(const struct mansearch *, char *, int);
                                int, char *[]);
 static void             exprfree(struct expr *);
 static struct expr     *exprterm(const struct mansearch *, char *, int);

+static int              manpage_compare(const void *, const void *);

 static void             sql_append(char **sql, size_t *sz,
                                const char *newstr, int count);
 static void             sql_match(sqlite3_context *context,
                                int argc, sqlite3_value **argv);
 static void             sql_regexp(sqlite3_context *context,
                                int argc, sqlite3_value **argv);
 static void             sql_append(char **sql, size_t *sz,
                                const char *newstr, int count);
 static void             sql_match(sqlite3_context *context,
                                int argc, sqlite3_value **argv);
 static void             sql_regexp(sqlite3_context *context,
                                int argc, sqlite3_value **argv);

-static char            *sql_statement(const struct expr *,
-                               const char *, const char *);
+static char            *sql_statement(const struct expr *);
+
+
+int
+mansearch_setup(int start)
+{
+       static void     *pagecache;
+       int              c;
+
+#define        PC_PAGESIZE     1280
+#define        PC_NUMPAGES     256
+
+       if (start) {
+               if (NULL != pagecache) {
+                       fprintf(stderr, "pagecache already enabled\n");
+                       return((int)MANDOCLEVEL_BADARG);
+               }
+
+               pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES,
+                   PROT_READ | PROT_WRITE,
+                   MAP_SHARED | MAP_ANON, -1, 0);
+
+               if (MAP_FAILED == pagecache) {
+                       perror("mmap");
+                       pagecache = NULL;
+                       return((int)MANDOCLEVEL_SYSERR);
+               }
+
+               c = sqlite3_config(SQLITE_CONFIG_PAGECACHE,
+                   pagecache, PC_PAGESIZE, PC_NUMPAGES);
+
+               if (SQLITE_OK == c)
+                       return((int)MANDOCLEVEL_OK);
+
+               fprintf(stderr, "pagecache: %s\n", sqlite3_errstr(c));
+
+       } else if (NULL == pagecache) {
+               fprintf(stderr, "pagecache missing\n");
+               return((int)MANDOCLEVEL_BADARG);
+       }
+
+       if (-1 == munmap(pagecache, PC_PAGESIZE * PC_NUMPAGES)) {
+               perror("munmap");
+               pagecache = NULL;
+               return((int)MANDOCLEVEL_SYSERR);
+       }
+
+       pagecache = NULL;
+       return((int)MANDOCLEVEL_OK);
+}

 
 int
 mansearch(const struct mansearch *search,
                const struct manpaths *paths,
                int argc, char *argv[],
 
 int
 mansearch(const struct mansearch *search,
                const struct manpaths *paths,
                int argc, char *argv[],

-               const char *outkey,

                struct manpage **res, size_t *sz)
 {
                struct manpage **res, size_t *sz)
 {

-       int              fd, rc, c, ibit;
-       int64_t          id;
-       uint64_t         outbit;
+       int64_t          pageid;
+       uint64_t         outbit, iterbit;

        char             buf[PATH_MAX];
        char            *sql;
        struct manpage  *mpage;
        char             buf[PATH_MAX];
        char            *sql;
        struct manpage  *mpage;


@@ -166,52 +176,50 @@ mansearch(const struct mansearch *search,
        struct ohash     htab;
        unsigned int     idx;
        size_t           i, j, cur, maxres;
        struct ohash     htab;
        unsigned int     idx;
        size_t           i, j, cur, maxres;

+       int              c, chdir_status, getcwd_status, indexbit;

 
 

-       memset(&info, 0, sizeof(struct ohash_info));
+       if (argc == 0 || (e = exprcomp(search, argc, argv)) == NULL) {
+               *sz = 0;
+               return(0);
+       }

 
 

-       info.halloc = hash_halloc;
+       info.calloc = hash_calloc;

        info.alloc = hash_alloc;
        info.alloc = hash_alloc;

-       info.hfree = hash_free;
-       info.key_offset = offsetof(struct match, id);
+       info.free = hash_free;
+       info.key_offset = offsetof(struct match, pageid);

 
 

-       *sz = cur = maxres = 0;
-       sql = NULL;
+       cur = maxres = 0;

        *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 != outkey) {
-               for (ibit = 0; types[ibit].bits; ibit++) {
-                       if (0 == strcasecmp(types[ibit].name, outkey)) {
-                               outbit = types[ibit].bits;
+
+       if (NULL != search->outkey) {
+               outbit = TYPE_Nd;
+               for (indexbit = 0, iterbit = 1;
+                    indexbit < mansearch_keymax;
+                    indexbit++, iterbit <<= 1) {
+                       if (0 == strcasecmp(search->outkey,
+                           mansearch_keynames[indexbit])) {
+                               outbit = iterbit;

                                break;
                        }
                }
                                break;
                        }
                }

-       }
+       } else
+               outbit = 0;

 
        /*
 
        /*

-        * Save a descriptor to the current working directory.
-        * Since pathnames in the "paths" variable might be relative,
-        * and we'll be chdir()ing into them, we need to keep a handle
-        * on our current directory from which to start the chdir().
+        * Remember the original working directory, if possible.
+        * This will be needed if the second or a later directory
+        * is given as a relative path.
+        * 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)) {
-               perror(NULL);
-               goto out;
-       } else if (-1 == (fd = open(buf, O_RDONLY, 0))) {
-               perror(buf);
-               goto out;
-       }
+       if (getcwd(buf, PATH_MAX) == NULL) {
+               getcwd_status = 0;
+               (void)strlcpy(buf, strerror(errno), sizeof(buf));
+       } else
+               getcwd_status = 1;

 
 

-       sql = sql_statement(e, search->arch, search->sec);
+       sql = sql_statement(e);

 
        /*
         * Loop over the directories (containing databases) for us to
 
        /*
         * Loop over the directories (containing databases) for us to


@@ -221,22 +229,30 @@ 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)) {
-                       perror(buf);
-                       free(*res);
-                       break;
-               } else if (-1 == chdir(paths->paths[i])) {
+               if (chdir_status && paths->paths[i][0] != '/') {
+                       if ( ! getcwd_status) {
+                               fprintf(stderr, "%s: getcwd: %s\n",
+                                   paths->paths[i], buf);
+                               continue;
+                       } else if (chdir(buf) == -1) {
+                               perror(buf);
+                               continue;
+                       }
+               }
+               if (chdir(paths->paths[i]) == -1) {

                        perror(paths->paths[i]);
                        continue;
                        perror(paths->paths[i]);
                        continue;

-               } 
+               }
+               chdir_status = 1;

 
 

-               c =  sqlite3_open_v2
-                       (MANDOC_DB, &db, 
-                        SQLITE_OPEN_READONLY, NULL);
+               c = sqlite3_open_v2(MANDOC_DB, &db,
+                   SQLITE_OPEN_READONLY, NULL);

 
                if (SQLITE_OK != c) {
 
                if (SQLITE_OK != c) {

-                       perror(MANDOC_DB);
+                       fprintf(stderr, "%s/%s: %s\n",
+                           paths->paths[i], MANDOC_DB, strerror(errno));

                        sqlite3_close(db);
                        continue;
                }
                        sqlite3_close(db);
                        continue;
                }


@@ -247,10 +263,12 @@ mansearch(const struct mansearch *search,
                 */
 
                c = sqlite3_create_function(db, "match", 2,
                 */
 
                c = sqlite3_create_function(db, "match", 2,

-                   SQLITE_ANY, NULL, sql_match, NULL, NULL);
+                   SQLITE_UTF8 | SQLITE_DETERMINISTIC,
+                   NULL, sql_match, NULL, NULL);

                assert(SQLITE_OK == c);
                c = sqlite3_create_function(db, "regexp", 2,
                assert(SQLITE_OK == c);
                c = sqlite3_create_function(db, "regexp", 2,

-                   SQLITE_ANY, NULL, sql_regexp, NULL, NULL);
+                   SQLITE_UTF8 | SQLITE_DETERMINISTIC,
+                   NULL, sql_regexp, NULL, NULL);

                assert(SQLITE_OK == c);
 
                j = 1;
                assert(SQLITE_OK == c);
 
                j = 1;


@@ -258,17 +276,13 @@ mansearch(const struct mansearch *search,
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));
 
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));
 

-               if (NULL != search->arch)
-                       SQL_BIND_TEXT(db, s, j, search->arch);
-               if (NULL != search->sec)
-                       SQL_BIND_TEXT(db, s, j, search->sec);
-

                for (ep = e; NULL != ep; ep = ep->next) {
                        if (NULL == ep->substr) {
                                SQL_BIND_BLOB(db, s, j, ep->regexp);
                        } else
                                SQL_BIND_TEXT(db, s, j, ep->substr);
                for (ep = e; NULL != ep; ep = ep->next) {
                        if (NULL == ep->substr) {
                                SQL_BIND_BLOB(db, s, j, ep->regexp);
                        } else
                                SQL_BIND_TEXT(db, s, j, ep->substr);

-                       SQL_BIND_INT64(db, s, j, ep->bits);
+                       if (0 == ((TYPE_Nd | TYPE_Nm) & ep->bits))
+                               SQL_BIND_INT64(db, s, j, ep->bits);

                }
 
                memset(&htab, 0, sizeof(struct ohash));
                }
 
                memset(&htab, 0, sizeof(struct ohash));


@@ -283,21 +297,21 @@ mansearch(const struct mansearch *search,
                 * distribution of buckets in the table.
                 */
                while (SQLITE_ROW == (c = sqlite3_step(s))) {
                 * distribution of buckets in the table.
                 */
                while (SQLITE_ROW == (c = sqlite3_step(s))) {

-                       id = sqlite3_column_int64(s, 5);
-                       idx = ohash_lookup_memory
-                               (&htab, (char *)&id, 
-                                sizeof(uint64_t), (uint32_t)id);
+                       pageid = sqlite3_column_int64(s, 2);
+                       idx = ohash_lookup_memory(&htab,
+                           (char *)&pageid, sizeof(uint64_t),
+                           (uint32_t)pageid);

 
                        if (NULL != ohash_find(&htab, idx))
                                continue;
 
                        mp = mandoc_calloc(1, sizeof(struct match));
 
                        if (NULL != ohash_find(&htab, idx))
                                continue;
 
                        mp = mandoc_calloc(1, sizeof(struct match));

-                       mp->id = id;
-                       mp->file = mandoc_strdup
-                               ((char *)sqlite3_column_text(s, 0));
-                       mp->desc = mandoc_strdup
-                               ((char *)sqlite3_column_text(s, 3));
-                       mp->form = sqlite3_column_int(s, 4);
+                       mp->pageid = pageid;
+                       mp->form = sqlite3_column_int(s, 1);
+                       mp->bits = sqlite3_column_int64(s, 3);
+                       if (TYPE_Nd == outbit)
+                               mp->desc = mandoc_strdup((const char *)
+                                   sqlite3_column_text(s, 0));

                        ohash_insert(&htab, idx, mp);
                }
 
                        ohash_insert(&htab, idx, mp);
                }
 


@@ -306,14 +320,16 @@ mansearch(const struct mansearch *search,
 
                sqlite3_finalize(s);
 
 
                sqlite3_finalize(s);
 

-               c = sqlite3_prepare_v2(db, 
-                   "SELECT * FROM mlinks WHERE pageid=?",
+               c = sqlite3_prepare_v2(db,
+                   "SELECT sec, arch, name, pageid FROM mlinks "
+                   "WHERE pageid=? ORDER BY sec, arch, name",

                    -1, &s, NULL);
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));
 
                c = sqlite3_prepare_v2(db,
                    -1, &s, NULL);
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));
 
                c = sqlite3_prepare_v2(db,

-                   "SELECT * FROM keys WHERE pageid=? AND bits & ?",
+                   "SELECT bits, key, pageid FROM keys "
+                   "WHERE pageid=? AND bits & ?",

                    -1, &s2, NULL);
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));
                    -1, &s2, NULL);
                if (SQLITE_OK != c)
                        fprintf(stderr, "%s\n", sqlite3_errmsg(db));


@@ -323,80 +339,205 @@ mansearch(const struct mansearch *search,
                                mp = ohash_next(&htab, &idx)) {
                        if (cur + 1 > maxres) {
                                maxres += 1024;
                                mp = ohash_next(&htab, &idx)) {
                        if (cur + 1 > maxres) {
                                maxres += 1024;

-                               *res = mandoc_realloc
-                                       (*res, maxres * sizeof(struct manpage));
+                               *res = mandoc_reallocarray(*res,
+                                   maxres, sizeof(struct manpage));

                        }
                        mpage = *res + cur;
                        }
                        mpage = *res + cur;

-                       if (-1 == asprintf(&mpage->file, "%s/%s",
-                           paths->paths[i], mp->file)) {
-                               perror(0);
-                               exit((int)MANDOCLEVEL_SYSERR);
-                       }
-                       mpage->desc = mp->desc;
+                       mpage->ipath = i;
+                       mpage->bits = mp->bits;
+                       mpage->sec = 10;

                        mpage->form = mp->form;
                        mpage->form = mp->form;

-                       mpage->names = buildnames(db, s, mp->id);
-                       mpage->output = outbit ?
-                           buildoutput(db, s2, mp->id, outbit) : NULL;
-
-                       free(mp->file);
+                       buildnames(search, mpage, db, s, mp->pageid,
+                           paths->paths[i], mp->form);
+                       if (mpage->names != NULL) {
+                               mpage->output = TYPE_Nd & outbit ?
+                                   mp->desc : outbit ?
+                                   buildoutput(db, s2, mp->pageid, outbit) :
+                                   NULL;
+                               cur++;
+                       }

                        free(mp);
                        free(mp);

-                       cur++;

                }
 
                sqlite3_finalize(s);
                sqlite3_finalize(s2);
                sqlite3_close(db);
                ohash_delete(&htab);
                }
 
                sqlite3_finalize(s);
                sqlite3_finalize(s2);
                sqlite3_close(db);
                ohash_delete(&htab);

+
+               /*
+                * In man(1) mode, prefer matches in earlier trees
+                * over matches in later trees.
+                */
+
+               if (cur && search->firstmatch)
+                       break;

        }
        }

-       rc = 1;
-out:
+       qsort(*res, cur, sizeof(struct manpage), manpage_compare);
+       if (chdir_status && getcwd_status && chdir(buf) == -1)
+               perror(buf);

        exprfree(e);
        exprfree(e);

-       if (-1 != fd)
-               close(fd);

        free(sql);
        *sz = cur;
        free(sql);
        *sz = cur;

-       return(rc);
+       return(1);

 }
 
 }
 

-static char *
-buildnames(sqlite3 *db, sqlite3_stmt *s, uint64_t id)
+void
+mansearch_free(struct manpage *res, size_t sz)

 {
 {

-       char            *names, *newnames;
-       const char      *oldnames, *sep1, *name, *sec, *sep2, *arch;
+       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
+manpage_compare(const void *vp1, const void *vp2)
+{
+       const struct manpage    *mp1, *mp2;
+       int                      diff;
+
+       mp1 = vp1;
+       mp2 = vp2;
+       return( (diff = mp2->bits - mp1->bits) ? diff :
+               (diff = mp1->sec - mp2->sec) ? diff :
+               strcasecmp(mp1->names, mp2->names));
+}
+
+static void
+buildnames(const struct mansearch *search, struct manpage *mpage,
+               sqlite3 *db, sqlite3_stmt *s,
+               uint64_t pageid, const char *path, int form)
+{
+       glob_t           globinfo;
+       char            *firstname, *newnames, *prevsec, *prevarch;
+       const char      *oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;

        size_t           i;
        size_t           i;

-       int              c;
+       int              c, globres;

 
 

-       names = NULL;
+       mpage->file = NULL;
+       mpage->names = NULL;
+       firstname = prevsec = prevarch = NULL;

        i = 1;
        i = 1;

-       SQL_BIND_INT64(db, s, i, id);
+       SQL_BIND_INT64(db, s, i, pageid);

        while (SQLITE_ROW == (c = sqlite3_step(s))) {
        while (SQLITE_ROW == (c = sqlite3_step(s))) {

-               if (NULL == names) {
+
+               /* Decide whether we already have some names. */
+
+               if (NULL == mpage->names) {

                        oldnames = "";
                        sep1 = "";
                } else {
                        oldnames = "";
                        sep1 = "";
                } else {

-                       oldnames = names;
+                       oldnames = mpage->names;

                        sep1 = ", ";
                }
                        sep1 = ", ";
                }

-               sec = sqlite3_column_text(s, 1);
-               arch = sqlite3_column_text(s, 2);
-               name = sqlite3_column_text(s, 3);
-               sep2 = '\0' == *arch ? "" : "/";
-               if (-1 == asprintf(&newnames, "%s%s%s(%s%s%s)",
-                   oldnames, sep1, name, sec, sep2, arch)) {
-                       perror(0);
-                       exit((int)MANDOCLEVEL_SYSERR);
+
+               /* Fetch the next name, rejecting sec/arch mismatches. */
+
+               sec = (const char *)sqlite3_column_text(s, 0);
+               if (search->sec != NULL && strcasecmp(sec, search->sec))
+                       continue;
+               arch = (const char *)sqlite3_column_text(s, 1);
+               if (search->arch != NULL && *arch != '\0' &&
+                   strcasecmp(arch, search->arch))
+                       continue;
+               name = (const char *)sqlite3_column_text(s, 2);
+
+               /* Remember the first section found. */
+
+               if (9 < mpage->sec && '1' <= *sec && '9' >= *sec)
+                       mpage->sec = (*sec - '1') + 1;
+
+               /* If the section changed, append the old one. */
+
+               if (NULL != prevsec &&
+                   (strcmp(sec, prevsec) ||
+                    strcmp(arch, prevarch))) {
+                       sep2 = '\0' == *prevarch ? "" : "/";
+                       mandoc_asprintf(&newnames, "%s(%s%s%s)",
+                           oldnames, prevsec, sep2, prevarch);
+                       free(mpage->names);
+                       oldnames = mpage->names = newnames;
+                       free(prevsec);
+                       free(prevarch);
+                       prevsec = prevarch = NULL;

                }
                }

-               free(names);
-               names = newnames;
+
+               /* Save the new section, to append it later. */
+
+               if (NULL == prevsec) {
+                       prevsec = mandoc_strdup(sec);
+                       prevarch = mandoc_strdup(arch);
+               }
+
+               /* Append the new name. */
+
+               mandoc_asprintf(&newnames, "%s%s%s",
+                   oldnames, sep1, name);
+               free(mpage->names);
+               mpage->names = newnames;
+
+               /* Also save the first file name encountered. */
+
+               if (mpage->file != NULL)
+                       continue;
+
+               if (form & FORM_SRC) {
+                       sep1 = "man";
+                       fsec = sec;
+               } else {
+                       sep1 = "cat";
+                       fsec = "0";
+               }
+               sep2 = *arch == '\0' ? "" : "/";
+               mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",
+                   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 (SQLITE_DONE != c)
+       if (c != SQLITE_DONE)

                fprintf(stderr, "%s\n", sqlite3_errmsg(db));
        sqlite3_reset(s);
                fprintf(stderr, "%s\n", sqlite3_errmsg(db));
        sqlite3_reset(s);

-       return(names);
+
+       /* 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. */
+
+       if (prevsec != NULL) {
+               sep2 = *prevarch == '\0' ? "" : "/";
+               mandoc_asprintf(&newnames, "%s(%s%s%s)",
+                   mpage->names, prevsec, sep2, prevarch);
+               free(mpage->names);
+               mpage->names = newnames;
+               free(prevsec);
+               free(prevarch);
+       }

 }
 
 static char *
 }
 
 static char *

-buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id, uint64_t outbit)
+buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pageid, uint64_t outbit)

 {
        char            *output, *newoutput;
        const char      *oldoutput, *sep1, *data;
 {
        char            *output, *newoutput;
        const char      *oldoutput, *sep1, *data;


@@ -405,7 +546,7 @@ buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id, uint64_t outbit)
 
        output = NULL;
        i = 1;
 
        output = NULL;
        i = 1;

-       SQL_BIND_INT64(db, s, i, id);
+       SQL_BIND_INT64(db, s, i, pageid);

        SQL_BIND_INT64(db, s, i, outbit);
        while (SQLITE_ROW == (c = sqlite3_step(s))) {
                if (NULL == output) {
        SQL_BIND_INT64(db, s, i, outbit);
        while (SQLITE_ROW == (c = sqlite3_step(s))) {
                if (NULL == output) {


@@ -415,12 +556,9 @@ buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id, uint64_t outbit)
                        oldoutput = output;
                        sep1 = " # ";
                }
                        oldoutput = output;
                        sep1 = " # ";
                }

-               data = sqlite3_column_text(s, 1);
-               if (-1 == asprintf(&newoutput, "%s%s%s",
-                   oldoutput, sep1, data)) {
-                       perror(0);
-                       exit((int)MANDOCLEVEL_SYSERR);
-               }
+               data = (const char *)sqlite3_column_text(s, 1);
+               mandoc_asprintf(&newoutput, "%s%s%s",
+                   oldoutput, sep1, data);

                free(output);
                output = newoutput;
        }
                free(output);
                output = newoutput;
        }


@@ -480,21 +618,18 @@ sql_append(char **sql, size_t *sz, const char *newstr, int count)
  * Prepare the search SQL statement.
  */
 static char *
  * Prepare the search SQL statement.
  */
 static char *

-sql_statement(const struct expr *e, const char *arch, const char *sec)
+sql_statement(const struct expr *e)

 {
        char            *sql;
        size_t           sz;
        int              needop;
 
 {
        char            *sql;
        size_t           sz;
        int              needop;
 

-       sql = mandoc_strdup("SELECT * FROM mpages WHERE ");
+       sql = mandoc_strdup(e->equal ?
+           "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);
 

-       if (NULL != arch)
-               sql_append(&sql, &sz, "arch = ? AND ", 1);
-       if (NULL != sec)
-               sql_append(&sql, &sz, "sec = ? AND ", 1);
-       sql_append(&sql, &sz, "(", 1);
-

        for (needop = 0; NULL != e; e = e->next) {
                if (e->and)
                        sql_append(&sql, &sz, " AND ", 1);
        for (needop = 0; NULL != e; e = e->next) {
                if (e->and)
                        sql_append(&sql, &sz, " AND ", 1);


@@ -502,16 +637,28 @@ sql_statement(const struct expr *e, const char *arch, const char *sec)
                        sql_append(&sql, &sz, " OR ", 1);
                if (e->open)
                        sql_append(&sql, &sz, "(", e->open);
                        sql_append(&sql, &sz, " OR ", 1);
                if (e->open)
                        sql_append(&sql, &sz, "(", e->open);

-               sql_append(&sql, &sz, NULL == e->substr ?
-                   "id IN (SELECT pageid FROM keys "
-                   "WHERE key REGEXP ? AND bits & ?)" :
-                   "id IN (SELECT pageid FROM keys "
-                   "WHERE key MATCH ? AND bits & ?)", 1);
+               sql_append(&sql, &sz,
+                   TYPE_Nd & e->bits
+                   ? (NULL == e->substr
+                       ? "desc REGEXP ?"
+                       : "desc MATCH ?")
+                   : TYPE_Nm == e->bits
+                   ? (NULL == e->substr
+                       ? "pageid IN (SELECT pageid FROM names "
+                         "WHERE name REGEXP ?)"
+                       : e->equal
+                       ? "name = ? "
+                       : "pageid IN (SELECT pageid FROM names "
+                         "WHERE name MATCH ?)")
+                   : (NULL == e->substr
+                       ? "pageid IN (SELECT pageid FROM keys "
+                         "WHERE key REGEXP ? AND bits & ?)"
+                       : "pageid IN (SELECT pageid FROM keys "
+                         "WHERE key MATCH ? AND bits & ?)"), 1);

                if (e->close)
                        sql_append(&sql, &sz, ")", e->close);
                needop = 1;
        }
                if (e->close)
                        sql_append(&sql, &sz, ")", e->close);
                needop = 1;
        }

-       sql_append(&sql, &sz, ")", 1);

 
        return(sql);
 }
 
        return(sql);
 }


@@ -524,11 +671,12 @@ sql_statement(const struct expr *e, const char *arch, const char *sec)
 static struct expr *
 exprcomp(const struct mansearch *search, int argc, char *argv[])
 {
 static struct expr *
 exprcomp(const struct mansearch *search, int argc, char *argv[])
 {

+       uint64_t         mask;

        int              i, toopen, logic, igncase, toclose;
        int              i, toopen, logic, igncase, toclose;

-       struct expr     *first, *next, *cur;
+       struct expr     *first, *prev, *cur, *next;

 
        first = cur = NULL;
 
        first = cur = NULL;

-       toopen = logic = igncase = toclose = 0;
+       logic = igncase = toopen = toclose = 0;

 
        for (i = 0; i < argc; i++) {
                if (0 == strcmp("(", argv[i])) {
 
        for (i = 0; i < argc; i++) {
                if (0 == strcmp("(", argv[i])) {


@@ -563,17 +711,40 @@ exprcomp(const struct mansearch *search, int argc, char *argv[])
                next = exprterm(search, argv[i], !igncase);
                if (NULL == next)
                        goto fail;
                next = exprterm(search, argv[i], !igncase);
                if (NULL == next)
                        goto fail;

-               next->open = toopen;
-               next->and = (1 == logic);
-               if (NULL != first) {
+               if (NULL == first)
+                       first = next;
+               else

                        cur->next = next;
                        cur->next = next;

-                       cur = next;
-               } else
-                       cur = first = next;
+               prev = cur = next;
+
+               /*
+                * Searching for descriptions must be split out
+                * because they are stored in the mpages table,
+                * not in the keys table.
+                */
+
+               for (mask = TYPE_Nm; mask <= TYPE_Nd; mask <<= 1) {
+                       if (mask & cur->bits && ~mask & cur->bits) {
+                               next = mandoc_calloc(1,
+                                   sizeof(struct expr));
+                               memcpy(next, cur, sizeof(struct expr));
+                               prev->open = 1;
+                               cur->bits = mask;
+                               cur->next = next;
+                               cur = next;
+                               cur->bits &= ~mask;
+                       }
+               }
+               prev->and = (1 == logic);
+               prev->open += toopen;
+               if (cur != prev)
+                       cur->close = 1;
+

                toopen = logic = igncase = 0;
        }
        if ( ! (toopen || logic || igncase || toclose))
                return(first);
                toopen = logic = igncase = 0;
        }
        if ( ! (toopen || logic || igncase || toclose))
                return(first);

+

 fail:
        if (NULL != first)
                exprfree(first);
 fail:
        if (NULL != first)
                exprfree(first);


@@ -583,45 +754,65 @@ fail:
 static struct expr *
 exprterm(const struct mansearch *search, char *buf, int cs)
 {
 static struct expr *
 exprterm(const struct mansearch *search, char *buf, int cs)
 {

+       char             errbuf[BUFSIZ];

        struct expr     *e;
        struct expr     *e;

-       char            *key, *v;
-       size_t           i;
+       char            *key, *val;
+       uint64_t         iterbit;
+       int              i, irc;

 
        if ('\0' == *buf)
                return(NULL);
 
        e = mandoc_calloc(1, sizeof(struct expr));
 
 
        if ('\0' == *buf)
                return(NULL);
 
        e = mandoc_calloc(1, sizeof(struct expr));
 

-       /*"whatis" mode uses an opaque string and default fields. */
-
-       if (MANSEARCH_WHATIS & search->flags) {
+       if (search->argmode == ARG_NAME) {
+               e->bits = TYPE_Nm;

                e->substr = buf;
                e->substr = buf;

-               e->bits = search->deftype;
+               e->equal = 1;

                return(e);
        }
 
        /*
                return(e);
        }
 
        /*

-        * If no =~ is specified, search with equality over names and
-        * descriptions.
-        * If =~ begins the phrase, use name and description fields.
+        * Separate macro keys from search string.
+        * If needed, request regular expression handling
+        * by setting e->substr to NULL.

         */
 
         */
 

-       if (NULL == (v = strpbrk(buf, "=~"))) {
+       if (search->argmode == ARG_WORD) {
+               e->bits = TYPE_Nm;
+               e->substr = NULL;
+               mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", buf);
+               cs = 0;
+       } else if ((val = strpbrk(buf, "=~")) == NULL) {
+               e->bits = TYPE_Nm | TYPE_Nd;

                e->substr = buf;
                e->substr = buf;

-               e->bits = search->deftype;
-               return(e);
-       } else if (v == buf)
-               e->bits = search->deftype;
+       } else {
+               if (val == buf)
+                       e->bits = TYPE_Nm | TYPE_Nd;
+               if ('=' == *val)
+                       e->substr = val + 1;
+               *val++ = '\0';
+               if (NULL != strstr(buf, "arch"))
+                       cs = 0;
+       }
+
+       /* Compile regular expressions. */

 
 

-       if ('~' == *v++) {
-               if (regcomp(&e->regexp, v,
-                   REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE))) {
+       if (NULL == e->substr) {
+               irc = regcomp(&e->regexp, val,
+                   REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE));
+               if (search->argmode == ARG_WORD)
+                       free(val);
+               if (irc) {
+                       regerror(irc, &e->regexp, errbuf, sizeof(errbuf));
+                       fprintf(stderr, "regcomp: %s\n", errbuf);

                        free(e);
                        return(NULL);
                }
                        free(e);
                        return(NULL);
                }

-       } else
-               e->substr = v;
-       v[-1] = '\0';
+       }
+
+       if (e->bits)
+               return(e);

 
        /*
         * Parse out all possible fields.
 
        /*
         * Parse out all possible fields.


@@ -631,15 +822,22 @@ exprterm(const struct mansearch *search, char *buf, int cs)
        while (NULL != (key = strsep(&buf, ","))) {
                if ('\0' == *key)
                        continue;
        while (NULL != (key = strsep(&buf, ","))) {
                if ('\0' == *key)
                        continue;

-               i = 0;
-               while (types[i].bits && 
-                       strcasecmp(types[i].name, key))
-                       i++;
-               if (0 == types[i].bits) {
-                       free(e);
-                       return(NULL);
+               for (i = 0, iterbit = 1;
+                    i < mansearch_keymax;
+                    i++, iterbit <<= 1) {
+                       if (0 == strcasecmp(key,
+                           mansearch_keynames[i])) {
+                               e->bits |= iterbit;
+                               break;
+                       }
+               }
+               if (i == mansearch_keymax) {
+                       if (strcasecmp(key, "any")) {
+                               free(e);
+                               return(NULL);
+                       }
+                       e->bits |= ~0ULL;

                }
                }

-               e->bits |= types[i].bits;

        }
 
        return(e);
        }
 
        return(e);


@@ -658,10 +856,10 @@ exprfree(struct expr *p)
 }
 
 static void *
 }
 
 static void *

-hash_halloc(size_t sz, void *arg)
+hash_calloc(size_t nmemb, size_t sz, void *arg)

 {
 
 {
 

-       return(mandoc_calloc(sz, 1));
+       return(mandoc_calloc(nmemb, sz));

 }
 
 static void *
 }
 
 static void *


@@ -672,7 +870,7 @@ hash_alloc(size_t sz, void *arg)
 }
 
 static void
 }
 
 static void

-hash_free(void *p, size_t sz, void *arg)
+hash_free(void *p, void *arg)

 {
 
        free(p);
 {
 
        free(p);