version 1.1, 2012/06/08 10:36:23 |
version 1.77, 2017/08/22 17:50:11 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
* Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv> |
|
* Copyright (c) 2013-2017 Ingo Schwarze <schwarze@openbsd.org> |
* |
* |
* Permission to use, copy, modify, and distribute this software for any |
* Permission to use, copy, modify, and distribute this software for any |
* purpose with or without fee is hereby granted, provided that the above |
* purpose with or without fee is hereby granted, provided that the above |
* copyright notice and this permission notice appear in all copies. |
* 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 |
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
*/ |
*/ |
#ifdef HAVE_CONFIG_H |
|
#include "config.h" |
#include "config.h" |
#endif |
|
|
|
#include <sys/param.h> |
#include <sys/mman.h> |
|
#include <sys/types.h> |
|
|
#include <assert.h> |
#include <assert.h> |
|
#if HAVE_ERR |
|
#include <err.h> |
|
#endif |
|
#include <errno.h> |
#include <fcntl.h> |
#include <fcntl.h> |
#include <getopt.h> |
#include <glob.h> |
|
#include <limits.h> |
|
#include <regex.h> |
#include <stdio.h> |
#include <stdio.h> |
#include <stdint.h> |
#include <stdint.h> |
#include <stddef.h> |
#include <stddef.h> |
|
|
#include <string.h> |
#include <string.h> |
#include <unistd.h> |
#include <unistd.h> |
|
|
#include <ohash.h> |
|
#include <sqlite3.h> |
|
|
|
#include "mandoc.h" |
#include "mandoc.h" |
#include "manpath.h" |
#include "mandoc_aux.h" |
#include "mandocdb.h" |
#include "mandoc_ohash.h" |
|
#include "manconf.h" |
#include "mansearch.h" |
#include "mansearch.h" |
|
#include "dbm.h" |
|
|
struct expr { |
struct expr { |
int glob; /* is glob? */ |
/* Used for terms: */ |
uint64_t bits; /* type-mask */ |
struct dbm_match match; /* Match type and expression. */ |
const char *v; /* search value */ |
uint64_t bits; /* Type mask. */ |
struct expr *next; /* next in sequence */ |
/* Used for OR and AND groups: */ |
|
struct expr *next; /* Next child in the parent group. */ |
|
struct expr *child; /* First child in this group. */ |
|
enum { EXPR_TERM, EXPR_OR, EXPR_AND } type; |
}; |
}; |
|
|
struct match { |
const char *const mansearch_keynames[KEY_MAX] = { |
uint64_t id; /* identifier in database */ |
"arch", "sec", "Xr", "Ar", "Fa", "Fl", "Dv", "Fn", |
char *file; /* relative filepath of manpage */ |
"Ic", "Pa", "Cm", "Li", "Em", "Cd", "Va", "Ft", |
char *desc; /* description of manpage */ |
"Tn", "Er", "Ev", "Sy", "Sh", "In", "Ss", "Ox", |
int form; /* 0 == catpage */ |
"An", "Mt", "St", "Bx", "At", "Nx", "Fx", "Lk", |
|
"Ms", "Bsx", "Dx", "Rs", "Vt", "Lb", "Nm", "Nd" |
}; |
}; |
|
|
struct type { |
|
uint64_t bits; |
|
const char *name; |
|
}; |
|
|
|
static const struct type types[] = { |
static struct ohash *manmerge(struct expr *, struct ohash *); |
{ TYPE_An, "An" }, |
static struct ohash *manmerge_term(struct expr *, struct ohash *); |
{ TYPE_Ar, "Ar" }, |
static struct ohash *manmerge_or(struct expr *, struct ohash *); |
{ TYPE_At, "At" }, |
static struct ohash *manmerge_and(struct expr *, struct ohash *); |
{ TYPE_Bsx, "Bsx" }, |
static char *buildnames(const struct dbm_page *); |
{ TYPE_Bx, "Bx" }, |
static char *buildoutput(size_t, struct dbm_page *); |
{ TYPE_Cd, "Cd" }, |
static size_t lstlen(const char *, size_t); |
{ TYPE_Cm, "Cm" }, |
static void lstcat(char *, size_t *, const char *, const char *); |
{ TYPE_Dv, "Dv" }, |
static int lstmatch(const char *, const char *); |
{ TYPE_Dx, "Dx" }, |
static struct expr *exprcomp(const struct mansearch *, |
{ TYPE_Em, "Em" }, |
int, char *[], int *); |
{ TYPE_Er, "Er" }, |
static struct expr *expr_and(const struct mansearch *, |
{ TYPE_Ev, "Ev" }, |
int, char *[], int *); |
{ TYPE_Fa, "Fa" }, |
static struct expr *exprterm(const struct mansearch *, |
{ TYPE_Fl, "Fl" }, |
int, char *[], int *); |
{ 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" }, |
|
{ ~0ULL, "any" }, |
|
{ 0ULL, NULL } |
|
}; |
|
|
|
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(int, char *[]); |
|
static void exprfree(struct expr *); |
static void exprfree(struct expr *); |
static struct expr *exprterm(char *); |
static int manpage_compare(const void *, const void *); |
static char *sql_statement(const struct expr *, |
|
const char *, const char *); |
|
|
|
|
|
int |
int |
mansearch(const struct manpaths *paths, |
mansearch(const struct mansearch *search, |
const char *arch, const char *sec, |
const struct manpaths *paths, |
int argc, char *argv[], |
int argc, char *argv[], |
struct manpage **res, size_t *sz) |
struct manpage **res, size_t *sz) |
{ |
{ |
int fd, rc; |
char buf[PATH_MAX]; |
int64_t id; |
struct dbm_res *rp; |
char buf[MAXPATHLEN]; |
struct expr *e; |
char *sql; |
struct dbm_page *page; |
struct expr *e, *ep; |
struct manpage *mpage; |
sqlite3 *db; |
struct ohash *htab; |
sqlite3_stmt *s; |
size_t cur, i, maxres, outkey; |
struct match *mp; |
unsigned int slot; |
struct ohash_info info; |
int argi, chdir_status, getcwd_status, im; |
struct ohash htab; |
|
unsigned int idx; |
|
size_t i, j, cur, maxres; |
|
|
|
memset(&info, 0, sizeof(struct ohash_info)); |
argi = 0; |
|
if ((e = exprcomp(search, argc, argv, &argi)) == NULL) { |
|
*sz = 0; |
|
return 0; |
|
} |
|
|
info.halloc = hash_halloc; |
|
info.alloc = hash_alloc; |
|
info.hfree = hash_free; |
|
info.key_offset = offsetof(struct match, id); |
|
|
|
*sz = 0; |
|
sql = NULL; |
|
*res = NULL; |
|
fd = -1; |
|
e = NULL; |
|
cur = maxres = 0; |
cur = maxres = 0; |
|
if (res != NULL) |
|
*res = NULL; |
|
|
if (0 == argc) |
outkey = KEY_Nd; |
goto out; |
if (search->outkey != NULL) |
if (NULL == (e = exprcomp(argc, argv))) |
for (im = 0; im < KEY_MAX; im++) |
goto out; |
if (0 == strcasecmp(search->outkey, |
|
mansearch_keynames[im])) { |
|
outkey = im; |
|
break; |
|
} |
|
|
/* |
/* |
* Save a descriptor to the current working directory. |
* Remember the original working directory, if possible. |
* Since pathnames in the "paths" variable might be relative, |
* This will be needed if the second or a later directory |
* and we'll be chdir()ing into them, we need to keep a handle |
* is given as a relative path. |
* on our current directory from which to start the chdir(). |
* Do not error out if the current directory is not |
|
* searchable: Maybe it won't be needed after all. |
*/ |
*/ |
|
|
if (NULL == getcwd(buf, MAXPATHLEN)) { |
if (getcwd(buf, PATH_MAX) == NULL) { |
perror(NULL); |
getcwd_status = 0; |
goto out; |
(void)strlcpy(buf, strerror(errno), sizeof(buf)); |
} else if (-1 == (fd = open(buf, O_RDONLY, 0))) { |
} else |
perror(buf); |
getcwd_status = 1; |
goto out; |
|
} |
|
|
|
sql = sql_statement(e, arch, sec); |
|
|
|
/* |
/* |
* Loop over the directories (containing databases) for us to |
* Loop over the directories (containing databases) for us to |
* search. |
* search. |
Line 173 mansearch(const struct manpaths *paths, |
|
Line 138 mansearch(const struct manpaths *paths, |
|
* 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)) { |
if (chdir_status && paths->paths[i][0] != '/') { |
/* FIXME: will return success */ |
if ( ! getcwd_status) { |
perror(buf); |
warnx("%s: getcwd: %s", paths->paths[i], buf); |
free(*res); |
continue; |
break; |
} else if (chdir(buf) == -1) { |
} else if (-1 == chdir(paths->paths[i])) { |
warn("%s", buf); |
perror(paths->paths[i]); |
continue; |
|
} |
|
} |
|
if (chdir(paths->paths[i]) == -1) { |
|
warn("%s", paths->paths[i]); |
continue; |
continue; |
} |
} |
|
chdir_status = 1; |
|
|
rc = sqlite3_open_v2 |
if (dbm_open(MANDOC_DB) == -1) { |
(MANDOC_DB, &db, SQLITE_OPEN_READONLY, NULL); |
if (errno != ENOENT) |
|
warn("%s/%s", paths->paths[i], MANDOC_DB); |
|
continue; |
|
} |
|
|
if (SQLITE_OK != rc) { |
if ((htab = manmerge(e, NULL)) == NULL) { |
perror(MANDOC_DB); |
dbm_close(); |
sqlite3_close(db); |
|
continue; |
continue; |
} |
} |
|
|
j = 1; |
for (rp = ohash_first(htab, &slot); rp != NULL; |
sqlite3_prepare_v2(db, sql, -1, &s, NULL); |
rp = ohash_next(htab, &slot)) { |
|
page = dbm_page_get(rp->page); |
|
|
if (NULL != arch) |
if (lstmatch(search->sec, page->sect) == 0 || |
sqlite3_bind_text |
lstmatch(search->arch, page->arch) == 0 || |
(s, j++, arch, -1, SQLITE_STATIC); |
(search->argmode == ARG_NAME && |
if (NULL != sec) |
rp->bits <= (int32_t)(NAME_SYN & NAME_MASK))) |
sqlite3_bind_text |
continue; |
(s, j++, sec, -1, SQLITE_STATIC); |
|
|
|
for (ep = e; NULL != ep; ep = ep->next) { |
if (res == NULL) { |
sqlite3_bind_text |
cur = 1; |
(s, j++, ep->v, -1, SQLITE_STATIC); |
break; |
sqlite3_bind_int64 |
} |
(s, j++, ep->bits); |
if (cur + 1 > maxres) { |
|
maxres += 1024; |
|
*res = mandoc_reallocarray(*res, |
|
maxres, sizeof(**res)); |
|
} |
|
mpage = *res + cur; |
|
mandoc_asprintf(&mpage->file, "%s/%s", |
|
paths->paths[i], page->file + 1); |
|
if (access(chdir_status ? page->file + 1 : |
|
mpage->file, R_OK) == -1) { |
|
warn("%s", mpage->file); |
|
warnx("outdated mandoc.db contains " |
|
"bogus %s entry, run makewhatis %s", |
|
page->file + 1, paths->paths[i]); |
|
free(mpage->file); |
|
free(rp); |
|
continue; |
|
} |
|
mpage->names = buildnames(page); |
|
mpage->output = buildoutput(outkey, page); |
|
mpage->ipath = i; |
|
mpage->bits = rp->bits; |
|
mpage->sec = *page->sect - '0'; |
|
if (mpage->sec < 0 || mpage->sec > 9) |
|
mpage->sec = 10; |
|
mpage->form = *page->file; |
|
free(rp); |
|
cur++; |
} |
} |
|
ohash_delete(htab); |
|
free(htab); |
|
dbm_close(); |
|
|
memset(&htab, 0, sizeof(struct ohash)); |
/* |
ohash_init(&htab, 4, &info); |
* In man(1) mode, prefer matches in earlier trees |
|
* over matches in later trees. |
|
*/ |
|
|
|
if (cur && search->firstmatch) |
|
break; |
|
} |
|
if (res != NULL) |
|
qsort(*res, cur, sizeof(struct manpage), manpage_compare); |
|
if (chdir_status && getcwd_status && chdir(buf) == -1) |
|
warn("%s", buf); |
|
exprfree(e); |
|
*sz = cur; |
|
return res != NULL || cur; |
|
} |
|
|
|
/* |
|
* Merge the results for the expression tree rooted at e |
|
* into the the result list htab. |
|
*/ |
|
static struct ohash * |
|
manmerge(struct expr *e, struct ohash *htab) |
|
{ |
|
switch (e->type) { |
|
case EXPR_TERM: |
|
return manmerge_term(e, htab); |
|
case EXPR_OR: |
|
return manmerge_or(e->child, htab); |
|
case EXPR_AND: |
|
return manmerge_and(e->child, htab); |
|
default: |
|
abort(); |
|
} |
|
} |
|
|
|
static struct ohash * |
|
manmerge_term(struct expr *e, struct ohash *htab) |
|
{ |
|
struct dbm_res res, *rp; |
|
uint64_t ib; |
|
unsigned int slot; |
|
int im; |
|
|
|
if (htab == NULL) { |
|
htab = mandoc_malloc(sizeof(*htab)); |
|
mandoc_ohash_init(htab, 4, offsetof(struct dbm_res, page)); |
|
} |
|
|
|
for (im = 0, ib = 1; im < KEY_MAX; im++, ib <<= 1) { |
|
if ((e->bits & ib) == 0) |
|
continue; |
|
|
|
switch (ib) { |
|
case TYPE_arch: |
|
dbm_page_byarch(&e->match); |
|
break; |
|
case TYPE_sec: |
|
dbm_page_bysect(&e->match); |
|
break; |
|
case TYPE_Nm: |
|
dbm_page_byname(&e->match); |
|
break; |
|
case TYPE_Nd: |
|
dbm_page_bydesc(&e->match); |
|
break; |
|
default: |
|
dbm_page_bymacro(im - 2, &e->match); |
|
break; |
|
} |
|
|
/* |
/* |
* Hash each entry on its [unique] document identifier. |
* When hashing for deduplication, use the unique |
* This is a uint64_t. |
* page ID itself instead of a hash function; |
* Instead of using a hash function, simply convert the |
* that is quite efficient. |
* uint64_t to a uint32_t, the hash value's type. |
|
* This gives good performance and preserves the |
|
* distribution of buckets in the table. |
|
*/ |
*/ |
while (SQLITE_ROW == sqlite3_step(s)) { |
|
id = sqlite3_column_int64(s, 0); |
|
idx = ohash_lookup_memory |
|
(&htab, (char *)&id, |
|
sizeof(uint64_t), (uint32_t)id); |
|
|
|
if (NULL != ohash_find(&htab, idx)) |
for (;;) { |
|
res = dbm_page_next(); |
|
if (res.page == -1) |
|
break; |
|
slot = ohash_lookup_memory(htab, |
|
(char *)&res, sizeof(res.page), res.page); |
|
if ((rp = ohash_find(htab, slot)) != NULL) { |
|
rp->bits |= res.bits; |
continue; |
continue; |
|
} |
|
rp = mandoc_malloc(sizeof(*rp)); |
|
*rp = res; |
|
ohash_insert(htab, slot, rp); |
|
} |
|
} |
|
return htab; |
|
} |
|
|
mp = mandoc_calloc(1, sizeof(struct match)); |
static struct ohash * |
mp->id = id; |
manmerge_or(struct expr *e, struct ohash *htab) |
mp->file = mandoc_strdup |
{ |
((char *)sqlite3_column_text(s, 3)); |
while (e != NULL) { |
mp->desc = mandoc_strdup |
htab = manmerge(e, htab); |
((char *)sqlite3_column_text(s, 4)); |
e = e->next; |
mp->form = sqlite3_column_int(s, 5); |
} |
ohash_insert(&htab, idx, mp); |
return htab; |
|
} |
|
|
|
static struct ohash * |
|
manmerge_and(struct expr *e, struct ohash *htab) |
|
{ |
|
struct ohash *hand, *h1, *h2; |
|
struct dbm_res *res; |
|
unsigned int slot1, slot2; |
|
|
|
/* Evaluate the first term of the AND clause. */ |
|
|
|
hand = manmerge(e, NULL); |
|
|
|
while ((e = e->next) != NULL) { |
|
|
|
/* Evaluate the next term and prepare for ANDing. */ |
|
|
|
h2 = manmerge(e, NULL); |
|
if (ohash_entries(h2) < ohash_entries(hand)) { |
|
h1 = h2; |
|
h2 = hand; |
|
} else |
|
h1 = hand; |
|
hand = mandoc_malloc(sizeof(*hand)); |
|
mandoc_ohash_init(hand, 4, offsetof(struct dbm_res, page)); |
|
|
|
/* Keep all pages that are in both result sets. */ |
|
|
|
for (res = ohash_first(h1, &slot1); res != NULL; |
|
res = ohash_next(h1, &slot1)) { |
|
if (ohash_find(h2, ohash_lookup_memory(h2, |
|
(char *)res, sizeof(res->page), |
|
res->page)) == NULL) |
|
free(res); |
|
else |
|
ohash_insert(hand, ohash_lookup_memory(hand, |
|
(char *)res, sizeof(res->page), |
|
res->page), res); |
} |
} |
|
|
sqlite3_finalize(s); |
/* Discard the merged results. */ |
sqlite3_close(db); |
|
|
|
for (mp = ohash_first(&htab, &idx); |
for (res = ohash_first(h2, &slot2); res != NULL; |
NULL != mp; |
res = ohash_next(h2, &slot2)) |
mp = ohash_next(&htab, &idx)) { |
free(res); |
if (cur + 1 > maxres) { |
ohash_delete(h2); |
maxres += 1024; |
free(h2); |
*res = mandoc_realloc |
ohash_delete(h1); |
(*res, maxres * sizeof(struct manpage)); |
free(h1); |
} |
} |
strlcpy((*res)[cur].file, |
|
paths->paths[i], MAXPATHLEN); |
/* Merge the result of the AND into htab. */ |
strlcat((*res)[cur].file, "/", MAXPATHLEN); |
|
strlcat((*res)[cur].file, mp->file, MAXPATHLEN); |
if (htab == NULL) |
(*res)[cur].desc = mp->desc; |
return hand; |
(*res)[cur].form = mp->form; |
|
free(mp->file); |
for (res = ohash_first(hand, &slot1); res != NULL; |
free(mp); |
res = ohash_next(hand, &slot1)) { |
cur++; |
slot2 = ohash_lookup_memory(htab, |
|
(char *)res, sizeof(res->page), res->page); |
|
if (ohash_find(htab, slot2) == NULL) |
|
ohash_insert(htab, slot2, res); |
|
else |
|
free(res); |
|
} |
|
|
|
/* Discard the merged result. */ |
|
|
|
ohash_delete(hand); |
|
free(hand); |
|
return htab; |
|
} |
|
|
|
void |
|
mansearch_free(struct manpage *res, size_t sz) |
|
{ |
|
size_t i; |
|
|
|
for (i = 0; i < sz; i++) { |
|
free(res[i].file); |
|
free(res[i].names); |
|
free(res[i].output); |
|
} |
|
free(res); |
|
} |
|
|
|
static int |
|
manpage_compare(const void *vp1, const void *vp2) |
|
{ |
|
const struct manpage *mp1, *mp2; |
|
const char *cp1, *cp2; |
|
size_t sz1, sz2; |
|
int diff; |
|
|
|
mp1 = vp1; |
|
mp2 = vp2; |
|
if ((diff = mp2->bits - mp1->bits) || |
|
(diff = mp1->sec - mp2->sec)) |
|
return diff; |
|
|
|
/* Fall back to alphabetic ordering of names. */ |
|
sz1 = strcspn(mp1->names, "("); |
|
sz2 = strcspn(mp2->names, "("); |
|
if (sz1 < sz2) |
|
sz1 = sz2; |
|
if ((diff = strncasecmp(mp1->names, mp2->names, sz1))) |
|
return diff; |
|
|
|
/* For identical names and sections, prefer arch-dependent. */ |
|
cp1 = strchr(mp1->names + sz1, '/'); |
|
cp2 = strchr(mp2->names + sz2, '/'); |
|
return cp1 != NULL && cp2 != NULL ? strcasecmp(cp1, cp2) : |
|
cp1 != NULL ? -1 : cp2 != NULL ? 1 : 0; |
|
} |
|
|
|
static char * |
|
buildnames(const struct dbm_page *page) |
|
{ |
|
char *buf; |
|
size_t i, sz; |
|
|
|
sz = lstlen(page->name, 2) + 1 + lstlen(page->sect, 2) + |
|
(page->arch == NULL ? 0 : 1 + lstlen(page->arch, 2)) + 2; |
|
buf = mandoc_malloc(sz); |
|
i = 0; |
|
lstcat(buf, &i, page->name, ", "); |
|
buf[i++] = '('; |
|
lstcat(buf, &i, page->sect, ", "); |
|
if (page->arch != NULL) { |
|
buf[i++] = '/'; |
|
lstcat(buf, &i, page->arch, ", "); |
|
} |
|
buf[i++] = ')'; |
|
buf[i++] = '\0'; |
|
assert(i == sz); |
|
return buf; |
|
} |
|
|
|
/* |
|
* Count the buffer space needed to print the NUL-terminated |
|
* list of NUL-terminated strings, when printing sep separator |
|
* characters between strings. |
|
*/ |
|
static size_t |
|
lstlen(const char *cp, size_t sep) |
|
{ |
|
size_t sz; |
|
|
|
for (sz = 0; *cp != '\0'; cp++) { |
|
|
|
/* Skip names appearing only in the SYNOPSIS. */ |
|
if (*cp <= (char)(NAME_SYN & NAME_MASK)) { |
|
while (*cp != '\0') |
|
cp++; |
|
continue; |
} |
} |
ohash_delete(&htab); |
|
|
/* Skip name class markers. */ |
|
if (*cp < ' ') |
|
cp++; |
|
|
|
/* Print a separator before each but the first string. */ |
|
if (sz) |
|
sz += sep; |
|
|
|
/* Copy one string. */ |
|
while (*cp != '\0') { |
|
sz++; |
|
cp++; |
|
} |
} |
} |
out: |
return sz; |
exprfree(e); |
|
if (-1 != fd) |
|
close(fd); |
|
free(sql); |
|
*sz = cur; |
|
return(1); |
|
} |
} |
|
|
/* |
/* |
* Prepare the search SQL statement. |
* Print the NUL-terminated list of NUL-terminated strings |
* We search for any of the words specified in our match expression. |
* into the buffer, seperating strings with sep. |
* We filter the per-doc AND expressions when collecting results. |
|
*/ |
*/ |
static char * |
static void |
sql_statement(const struct expr *e, const char *arch, const char *sec) |
lstcat(char *buf, size_t *i, const char *cp, const char *sep) |
{ |
{ |
char *sql; |
const char *s; |
const char *glob = "(key GLOB ? AND bits & ?)"; |
size_t i_start; |
const char *eq = "(key = ? AND bits & ?)"; |
|
const char *andarch = "arch = ? AND "; |
|
const char *andsec = "sec = ? AND "; |
|
const size_t globsz = 27; |
|
const size_t eqsz = 22; |
|
size_t sz; |
|
|
|
sql = mandoc_strdup |
for (i_start = *i; *cp != '\0'; cp++) { |
("SELECT docid,bits,key,file,desc,form,sec,arch " |
|
"FROM keys " |
|
"INNER JOIN docs ON docs.id=keys.docid " |
|
"WHERE "); |
|
sz = strlen(sql); |
|
|
|
if (NULL != arch) { |
/* Skip names appearing only in the SYNOPSIS. */ |
sz += strlen(andarch) + 1; |
if (*cp <= (char)(NAME_SYN & NAME_MASK)) { |
sql = mandoc_realloc(sql, sz); |
while (*cp != '\0') |
strlcat(sql, andarch, sz); |
cp++; |
|
continue; |
|
} |
|
|
|
/* Skip name class markers. */ |
|
if (*cp < ' ') |
|
cp++; |
|
|
|
/* Print a separator before each but the first string. */ |
|
if (*i > i_start) { |
|
s = sep; |
|
while (*s != '\0') |
|
buf[(*i)++] = *s++; |
|
} |
|
|
|
/* Copy one string. */ |
|
while (*cp != '\0') |
|
buf[(*i)++] = *cp++; |
} |
} |
if (NULL != sec) { |
|
sz += strlen(andsec) + 1; |
|
sql = mandoc_realloc(sql, sz); |
|
strlcat(sql, andsec, sz); |
|
} |
|
|
|
sz += 2; |
} |
sql = mandoc_realloc(sql, sz); |
|
strlcat(sql, "(", sz); |
|
|
|
for ( ; NULL != e; e = e->next) { |
/* |
sz += (e->glob ? globsz : eqsz) + |
* Return 1 if the string *want occurs in any of the strings |
(NULL == e->next ? 3 : 5); |
* in the NUL-terminated string list *have, or 0 otherwise. |
sql = mandoc_realloc(sql, sz); |
* If either argument is NULL or empty, assume no filtering |
strlcat(sql, e->glob ? glob : eq, sz); |
* is desired and return 1. |
strlcat(sql, NULL == e->next ? ");" : " OR ", sz); |
*/ |
|
static int |
|
lstmatch(const char *want, const char *have) |
|
{ |
|
if (want == NULL || have == NULL || *have == '\0') |
|
return 1; |
|
while (*have != '\0') { |
|
if (strcasestr(have, want) != NULL) |
|
return 1; |
|
have = strchr(have, '\0') + 1; |
|
} |
|
return 0; |
|
} |
|
|
|
/* |
|
* Build a list of values taken by the macro im in the manual page. |
|
*/ |
|
static char * |
|
buildoutput(size_t im, struct dbm_page *page) |
|
{ |
|
const char *oldoutput, *sep, *input; |
|
char *output, *newoutput, *value; |
|
size_t sz, i; |
|
|
|
switch (im) { |
|
case KEY_Nd: |
|
return mandoc_strdup(page->desc); |
|
case KEY_Nm: |
|
input = page->name; |
|
break; |
|
case KEY_sec: |
|
input = page->sect; |
|
break; |
|
case KEY_arch: |
|
input = page->arch; |
|
if (input == NULL) |
|
input = "all\0"; |
|
break; |
|
default: |
|
input = NULL; |
|
break; |
} |
} |
|
|
return(sql); |
if (input != NULL) { |
|
sz = lstlen(input, 3) + 1; |
|
output = mandoc_malloc(sz); |
|
i = 0; |
|
lstcat(output, &i, input, " # "); |
|
output[i++] = '\0'; |
|
assert(i == sz); |
|
return output; |
|
} |
|
|
|
output = NULL; |
|
dbm_macro_bypage(im - 2, page->addr); |
|
while ((value = dbm_macro_next()) != NULL) { |
|
if (output == NULL) { |
|
oldoutput = ""; |
|
sep = ""; |
|
} else { |
|
oldoutput = output; |
|
sep = " # "; |
|
} |
|
mandoc_asprintf(&newoutput, "%s%s%s", oldoutput, sep, value); |
|
free(output); |
|
output = newoutput; |
|
} |
|
return output; |
} |
} |
|
|
/* |
/* |
Line 328 sql_statement(const struct expr *e, const char *arch, |
|
Line 608 sql_statement(const struct expr *e, const char *arch, |
|
* "(", "foo=bar", etc.). |
* "(", "foo=bar", etc.). |
*/ |
*/ |
static struct expr * |
static struct expr * |
exprcomp(int argc, char *argv[]) |
exprcomp(const struct mansearch *search, int argc, char *argv[], int *argi) |
{ |
{ |
int i; |
struct expr *parent, *child; |
struct expr *first, *next, *cur; |
int needterm, nested; |
|
|
first = cur = NULL; |
if ((nested = *argi) == argc) |
|
return NULL; |
for (i = 0; i < argc; i++) { |
needterm = 1; |
next = exprterm(argv[i]); |
parent = child = NULL; |
if (NULL == next) { |
while (*argi < argc) { |
exprfree(first); |
if (strcmp(")", argv[*argi]) == 0) { |
return(NULL); |
if (needterm) |
|
warnx("missing term " |
|
"before closing parenthesis"); |
|
needterm = 0; |
|
if (nested) |
|
break; |
|
warnx("ignoring unmatched right parenthesis"); |
|
++*argi; |
|
continue; |
} |
} |
if (NULL != first) { |
if (strcmp("-o", argv[*argi]) == 0) { |
cur->next = next; |
if (needterm) { |
cur = next; |
if (*argi > 0) |
} else |
warnx("ignoring -o after %s", |
cur = first = next; |
argv[*argi - 1]); |
|
else |
|
warnx("ignoring initial -o"); |
|
} |
|
needterm = 1; |
|
++*argi; |
|
continue; |
|
} |
|
needterm = 0; |
|
if (child == NULL) { |
|
child = expr_and(search, argc, argv, argi); |
|
continue; |
|
} |
|
if (parent == NULL) { |
|
parent = mandoc_calloc(1, sizeof(*parent)); |
|
parent->type = EXPR_OR; |
|
parent->next = NULL; |
|
parent->child = child; |
|
} |
|
child->next = expr_and(search, argc, argv, argi); |
|
child = child->next; |
} |
} |
|
if (needterm && *argi) |
|
warnx("ignoring trailing %s", argv[*argi - 1]); |
|
return parent == NULL ? child : parent; |
|
} |
|
|
return(first); |
static struct expr * |
|
expr_and(const struct mansearch *search, int argc, char *argv[], int *argi) |
|
{ |
|
struct expr *parent, *child; |
|
int needterm; |
|
|
|
needterm = 1; |
|
parent = child = NULL; |
|
while (*argi < argc) { |
|
if (strcmp(")", argv[*argi]) == 0) { |
|
if (needterm) |
|
warnx("missing term " |
|
"before closing parenthesis"); |
|
needterm = 0; |
|
break; |
|
} |
|
if (strcmp("-o", argv[*argi]) == 0) |
|
break; |
|
if (strcmp("-a", argv[*argi]) == 0) { |
|
if (needterm) { |
|
if (*argi > 0) |
|
warnx("ignoring -a after %s", |
|
argv[*argi - 1]); |
|
else |
|
warnx("ignoring initial -a"); |
|
} |
|
needterm = 1; |
|
++*argi; |
|
continue; |
|
} |
|
if (needterm == 0) |
|
break; |
|
if (child == NULL) { |
|
child = exprterm(search, argc, argv, argi); |
|
if (child != NULL) |
|
needterm = 0; |
|
continue; |
|
} |
|
needterm = 0; |
|
if (parent == NULL) { |
|
parent = mandoc_calloc(1, sizeof(*parent)); |
|
parent->type = EXPR_AND; |
|
parent->next = NULL; |
|
parent->child = child; |
|
} |
|
child->next = exprterm(search, argc, argv, argi); |
|
if (child->next != NULL) { |
|
child = child->next; |
|
needterm = 0; |
|
} |
|
} |
|
if (needterm && *argi) |
|
warnx("ignoring trailing %s", argv[*argi - 1]); |
|
return parent == NULL ? child : parent; |
} |
} |
|
|
static struct expr * |
static struct expr * |
exprterm(char *buf) |
exprterm(const struct mansearch *search, int argc, char *argv[], int *argi) |
{ |
{ |
|
char errbuf[BUFSIZ]; |
struct expr *e; |
struct expr *e; |
char *key, *v; |
char *key, *val; |
size_t i; |
uint64_t iterbit; |
|
int cs, i, irc; |
|
|
if ('\0' == *buf) |
if (strcmp("(", argv[*argi]) == 0) { |
return(NULL); |
++*argi; |
|
e = exprcomp(search, argc, argv, argi); |
|
if (*argi < argc) { |
|
assert(strcmp(")", argv[*argi]) == 0); |
|
++*argi; |
|
} else |
|
warnx("unclosed parenthesis"); |
|
return e; |
|
} |
|
|
e = mandoc_calloc(1, sizeof(struct expr)); |
if (strcmp("-i", argv[*argi]) == 0 && *argi + 1 < argc) { |
|
cs = 0; |
|
++*argi; |
|
} else |
|
cs = 1; |
|
|
|
e = mandoc_calloc(1, sizeof(*e)); |
|
e->type = EXPR_TERM; |
|
e->bits = 0; |
|
e->next = NULL; |
|
e->child = NULL; |
|
|
|
if (search->argmode == ARG_NAME) { |
|
e->bits = TYPE_Nm; |
|
e->match.type = DBM_EXACT; |
|
e->match.str = argv[(*argi)++]; |
|
return e; |
|
} |
|
|
/* |
/* |
* If no =~ is specified, search with equality over names and |
* Separate macro keys from search string. |
* descriptions. |
* If needed, request regular expression handling. |
* If =~ begins the phrase, use name and description fields. |
|
*/ |
*/ |
|
|
if (NULL == (v = strpbrk(buf, "=~"))) { |
if (search->argmode == ARG_WORD) { |
e->v = buf; |
e->bits = TYPE_Nm; |
|
e->match.type = DBM_REGEX; |
|
#if HAVE_REWB_BSD |
|
mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", argv[*argi]); |
|
#elif HAVE_REWB_SYSV |
|
mandoc_asprintf(&val, "\\<%s\\>", argv[*argi]); |
|
#else |
|
mandoc_asprintf(&val, |
|
"(^|[^a-zA-Z01-9_])%s([^a-zA-Z01-9_]|$)", argv[*argi]); |
|
#endif |
|
cs = 0; |
|
} else if ((val = strpbrk(argv[*argi], "=~")) == NULL) { |
e->bits = TYPE_Nm | TYPE_Nd; |
e->bits = TYPE_Nm | TYPE_Nd; |
return(e); |
e->match.type = DBM_SUB; |
} else if (v == buf) |
e->match.str = argv[*argi]; |
e->bits = TYPE_Nm | TYPE_Nd; |
} else { |
|
if (val == argv[*argi]) |
|
e->bits = TYPE_Nm | TYPE_Nd; |
|
if (*val == '=') { |
|
e->match.type = DBM_SUB; |
|
e->match.str = val + 1; |
|
} else |
|
e->match.type = DBM_REGEX; |
|
*val++ = '\0'; |
|
if (strstr(argv[*argi], "arch") != NULL) |
|
cs = 0; |
|
} |
|
|
e->glob = '~' == *v; |
/* Compile regular expressions. */ |
*v++ = '\0'; |
|
e->v = v; |
|
|
|
|
if (e->match.type == DBM_REGEX) { |
|
e->match.re = mandoc_malloc(sizeof(*e->match.re)); |
|
irc = regcomp(e->match.re, val, |
|
REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE)); |
|
if (irc) { |
|
regerror(irc, e->match.re, errbuf, sizeof(errbuf)); |
|
warnx("regcomp /%s/: %s", val, errbuf); |
|
} |
|
if (search->argmode == ARG_WORD) |
|
free(val); |
|
if (irc) { |
|
free(e->match.re); |
|
free(e); |
|
++*argi; |
|
return NULL; |
|
} |
|
} |
|
|
|
if (e->bits) { |
|
++*argi; |
|
return e; |
|
} |
|
|
/* |
/* |
* Parse out all possible fields. |
* Parse out all possible fields. |
* If the field doesn't resolve, bail. |
* If the field doesn't resolve, bail. |
*/ |
*/ |
|
|
while (NULL != (key = strsep(&buf, ","))) { |
while (NULL != (key = strsep(&argv[*argi], ","))) { |
if ('\0' == *key) |
if ('\0' == *key) |
continue; |
continue; |
i = 0; |
for (i = 0, iterbit = 1; i < KEY_MAX; i++, iterbit <<= 1) { |
while (types[i].bits && |
if (0 == strcasecmp(key, mansearch_keynames[i])) { |
strcasecmp(types[i].name, key)) |
e->bits |= iterbit; |
i++; |
break; |
if (0 == types[i].bits) { |
} |
free(e); |
|
return(NULL); |
|
} |
} |
e->bits |= types[i].bits; |
if (i == KEY_MAX) { |
|
if (strcasecmp(key, "any")) |
|
warnx("treating unknown key " |
|
"\"%s\" as \"any\"", key); |
|
e->bits |= ~0ULL; |
|
} |
} |
} |
|
|
return(e); |
++*argi; |
|
return e; |
} |
} |
|
|
static void |
static void |
exprfree(struct expr *p) |
exprfree(struct expr *e) |
{ |
{ |
struct expr *pp; |
if (e->next != NULL) |
|
exprfree(e->next); |
while (NULL != p) { |
if (e->child != NULL) |
pp = p->next; |
exprfree(e->child); |
free(p); |
free(e); |
p = pp; |
|
} |
|
} |
|
|
|
static void * |
|
hash_halloc(size_t sz, void *arg) |
|
{ |
|
|
|
return(mandoc_calloc(sz, 1)); |
|
} |
|
|
|
static void * |
|
hash_alloc(size_t sz, void *arg) |
|
{ |
|
|
|
return(mandoc_malloc(sz)); |
|
} |
|
|
|
static void |
|
hash_free(void *p, size_t sz, void *arg) |
|
{ |
|
|
|
free(p); |
|
} |
} |