mandoc/mansearch.c - diff

Return to mansearch.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mansearch.c between version 1.1 and 1.12

version 1.1, 2012/06/08 10:36:23

version 1.12, 2013/12/31 03:41:14

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 18

Line 19

#include "config.h"

#endif

#include <sys/param.h>

#include <assert.h>

#include <fcntl.h>

#include <getopt.h>

#include <limits.h>

#include <regex.h>

#include <stdio.h>

#include <stdint.h>

#include <stddef.h>

Line 30

Line 31

#include <string.h>

#include <unistd.h>

#ifdef HAVE_OHASH

#include <ohash.h>

#else

#include "compat_ohash.h"

#endif

#include <sqlite3.h>

#include "mandoc.h"

#include "manpath.h"

#include "mandocdb.h"

#include "mansearch.h"

#define SQL_BIND_TEXT(_db, _s, _i, _v) \

do { if (SQLITE_OK != sqlite3_bind_text \

((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \

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

} while (0)

#define SQL_BIND_INT64(_db, _s, _i, _v) \

do { if (SQLITE_OK != sqlite3_bind_int64 \

((_s), (_i)++, (_v))) \

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

} while (0)

#define SQL_BIND_BLOB(_db, _s, _i, _v) \

do { if (SQLITE_OK != sqlite3_bind_blob \

((_s), (_i)++, (&_v), sizeof(_v), SQLITE_STATIC)) \

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

} while (0)

struct expr {

int glob; /* is glob? */

uint64_t bits; /* type-mask */

const char *substr; /* to search for, if applicable */

const char *v; /* search value */

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

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

};

struct match {

Line 101 static const struct type types[] = {

Line 121 static const struct type types[] = {

{ 0ULL, NULL }

};

static char *buildnames(sqlite3 *, sqlite3_stmt *, uint64_t);

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(int, char *[]);

static struct expr *exprcomp(const struct mansearch *,

int, char *[]);

static void exprfree(struct expr *);

static struct expr *exprterm(char *);

static struct expr *exprterm(const struct mansearch *, char *, int);

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 *);

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[],

const char *outkey,

struct manpage **res, size_t *sz)

{

int fd, rc;

int fd, rc, c, ibit;

int64_t id;

char buf[MAXPATHLEN];

uint64_t outbit;

char buf[PATH_MAX];

char *sql;

struct manpage *mpage;

struct expr *e, *ep;

sqlite3 *db;

sqlite3_stmt *s;

sqlite3_stmt *s, *s2;

struct match *mp;

struct ohash_info info;

struct ohash htab;

Line 136 mansearch(const struct manpaths *paths,

Line 167 mansearch(const struct manpaths *paths,

info.hfree = hash_free;

info.key_offset = offsetof(struct match, id);

*sz = 0;

*sz = cur = maxres = 0;

sql = NULL;

*res = NULL;

fd = -1;

e = NULL;

cur = maxres = 0;

rc = 0;

if (0 == argc)

goto out;

if (NULL == (e = exprcomp(argc, argv)))

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;

break;

}

* Save a descriptor to the current working directory.

* Since pathnames in the "paths" variable might be relative,

Line 155 mansearch(const struct manpaths *paths,

Line 196 mansearch(const struct manpaths *paths,

* on our current directory from which to start the chdir().

if (NULL == getcwd(buf, MAXPATHLEN)) {

if (NULL == getcwd(buf, PATH_MAX)) {

perror(NULL);

goto out;

} else if (-1 == (fd = open(buf, O_RDONLY, 0))) {

Line 163 mansearch(const struct manpaths *paths,

Line 204 mansearch(const struct manpaths *paths,

goto out;

}

sql = sql_statement(e, arch, sec);

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

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

Line 175 mansearch(const struct manpaths *paths,

Line 216 mansearch(const struct manpaths *paths,

for (i = 0; i < paths->sz; i++) {

if (-1 == fchdir(fd)) {

/* FIXME: will return success */

perror(buf);

free(*res);

break;

Line 184 mansearch(const struct manpaths *paths,

Line 224 mansearch(const struct manpaths *paths,

continue;

}

rc = sqlite3_open_v2

c = sqlite3_open_v2

(MANDOC_DB, &db, SQLITE_OPEN_READONLY, NULL);

(MANDOC_DB, &db,

SQLITE_OPEN_READONLY, NULL);

if (SQLITE_OK != rc) {

if (SQLITE_OK != c) {

perror(MANDOC_DB);

sqlite3_close(db);

continue;

}

* Define the SQL functions for substring

* and regular expression matching.

c = sqlite3_create_function(db, "match", 2,

SQLITE_ANY, NULL, sql_match, NULL, NULL);

assert(SQLITE_OK == c);

c = sqlite3_create_function(db, "regexp", 2,

SQLITE_ANY, NULL, sql_regexp, NULL, NULL);

assert(SQLITE_OK == c);

j = 1;

sqlite3_prepare_v2(db, sql, -1, &s, NULL);

c = sqlite3_prepare_v2(db, sql, -1, &s, NULL);

if (SQLITE_OK != c)

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

if (NULL != arch)

if (NULL != search->arch)

sqlite3_bind_text

SQL_BIND_TEXT(db, s, j, search->arch);

(s, j++, arch, -1, SQLITE_STATIC);

if (NULL != search->sec)

if (NULL != sec)

SQL_BIND_TEXT(db, s, j, search->sec);

sqlite3_bind_text

(s, j++, sec, -1, SQLITE_STATIC);

for (ep = e; NULL != ep; ep = ep->next) {

sqlite3_bind_text

if (NULL == ep->substr) {

(s, j++, ep->v, -1, SQLITE_STATIC);

SQL_BIND_BLOB(db, s, j, ep->regexp);

sqlite3_bind_int64

} else

(s, j++, ep->bits);

SQL_BIND_TEXT(db, s, j, ep->substr);

SQL_BIND_INT64(db, s, j, ep->bits);

}

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

Line 221 mansearch(const struct manpaths *paths,

Line 275 mansearch(const struct manpaths *paths,

* This gives good performance and preserves the

* distribution of buckets in the table.

while (SQLITE_ROW == sqlite3_step(s)) {

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

id = sqlite3_column_int64(s, 0);

idx = ohash_lookup_memory

(&htab, (char *)&id,

Line 240 mansearch(const struct manpaths *paths,

Line 294 mansearch(const struct manpaths *paths,

ohash_insert(&htab, idx, mp);

}

if (SQLITE_DONE != c)

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

sqlite3_finalize(s);

sqlite3_close(db);

c = sqlite3_prepare_v2(db,

"SELECT * FROM mlinks WHERE pageid=?",

-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 & ?",

-1, &s2, NULL);

if (SQLITE_OK != c)

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

for (mp = ohash_first(&htab, &idx);

NULL != mp;

mp = ohash_next(&htab, &idx)) {

Line 251 mansearch(const struct manpaths *paths,

Line 319 mansearch(const struct manpaths *paths,

*res = mandoc_realloc

(*res, maxres * sizeof(struct manpage));

}

strlcpy((*res)[cur].file,

mpage = *res + cur;

paths->paths[i], MAXPATHLEN);

if (-1 == asprintf(&mpage->file, "%s/%s",

strlcat((*res)[cur].file, "/", MAXPATHLEN);

paths->paths[i], mp->file)) {

strlcat((*res)[cur].file, mp->file, MAXPATHLEN);

perror(0);

(*res)[cur].desc = mp->desc;

exit((int)MANDOCLEVEL_SYSERR);

(*res)[cur].form = mp->form;

}

mpage->desc = mp->desc;

mpage->form = mp->form;

mpage->names = buildnames(db, s, mp->id);

mpage->output = outbit ?

buildoutput(db, s2, mp->id, outbit) : NULL;

free(mp->file);

free(mp);

cur++;

}

sqlite3_finalize(s);

sqlite3_finalize(s2);

sqlite3_close(db);

ohash_delete(&htab);

}

rc = 1;

out:

exprfree(e);

if (-1 != fd)

close(fd);

free(sql);

*sz = cur;

return(1);

return(rc);

}

static char *

buildnames(sqlite3 *db, sqlite3_stmt *s, uint64_t id)

{

char *names, *newnames;

const char *oldnames, *sep1, *name, *sec, *sep2, *arch;

size_t i;

int c;

names = NULL;

i = 1;

SQL_BIND_INT64(db, s, i, id);

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

if (NULL == names) {

oldnames = "";

sep1 = "";

} else {

oldnames = names;

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);

}

free(names);

names = newnames;

}

if (SQLITE_DONE != c)

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

sqlite3_reset(s);

return(names);

}

static char *

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

{

char *output, *newoutput;

const char *oldoutput, *sep1, *data;

size_t i;

int c;

output = NULL;

i = 1;

SQL_BIND_INT64(db, s, i, id);

SQL_BIND_INT64(db, s, i, outbit);

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

if (NULL == output) {

oldoutput = "";

sep1 = "";

} else {

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);

}

free(output);

output = newoutput;

}

if (SQLITE_DONE != c)

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

sqlite3_reset(s);

return(output);

}

* Implement substring match as an application-defined SQL function.

* Using the SQL LIKE or GLOB operators instead would be a bad idea

* because that would require escaping metacharacters in the string

* being searched for.

static void

sql_match(sqlite3_context *context, int argc, sqlite3_value **argv)

{

assert(2 == argc);

sqlite3_result_int(context, NULL != strcasestr(

(const char *)sqlite3_value_text(argv[1]),

(const char *)sqlite3_value_text(argv[0])));

}

* Implement regular expression match

* as an application-defined SQL function.

static void

sql_regexp(sqlite3_context *context, int argc, sqlite3_value **argv)

{

assert(2 == argc);

sqlite3_result_int(context, !regexec(

(regex_t *)sqlite3_value_blob(argv[0]),

(const char *)sqlite3_value_text(argv[1]),

0, NULL, 0));

}

* Prepare the search SQL statement.

* We search for any of the words specified in our match expression.

* We filter the per-doc AND expressions when collecting results.

Line 281 static char *

Line 463 static char *

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

{

char *sql;

const char *glob = "(key GLOB ? AND bits & ?)";

const char *substr = "(key MATCH ? AND bits & ?)";

const char *eq = "(key = ? AND bits & ?)";

const char *regexp = "(key REGEXP ? AND bits & ?)";

const char *andarch = "arch = ? AND ";

const char *andsec = "sec = ? AND ";

const size_t globsz = 27;

size_t substrsz;

const size_t eqsz = 22;

size_t regexpsz;

size_t sz;

sql = mandoc_strdup

("SELECT docid,bits,key,file,desc,form,sec,arch "

("SELECT pageid,bits,key,file,desc,form,sec,arch "

"FROM keys "

"INNER JOIN docs ON docs.id=keys.docid "

"INNER JOIN mpages ON mpages.id=keys.pageid "

"WHERE ");

sz = strlen(sql);

substrsz = strlen(substr);

regexpsz = strlen(regexp);

if (NULL != arch) {

sz += strlen(andarch) + 1;

sql = mandoc_realloc(sql, sz);

strlcat(sql, andarch, sz);

}

if (NULL != sec) {

sz += strlen(andsec) + 1;

sql = mandoc_realloc(sql, sz);

Line 312 sql_statement(const struct expr *e, const char *arch,

Line 497 sql_statement(const struct expr *e, const char *arch,

strlcat(sql, "(", sz);

for ( ; NULL != e; e = e->next) {

sz += (e->glob ? globsz : eqsz) +

sz += (NULL == e->substr ? regexpsz : substrsz) +

(NULL == e->next ? 3 : 5);

sql = mandoc_realloc(sql, sz);

strlcat(sql, e->glob ? glob : eq, sz);

strlcat(sql, NULL == e->substr ? regexp : substr, sz);

strlcat(sql, NULL == e->next ? ");" : " OR ", sz);

}

Line 328 sql_statement(const struct expr *e, const char *arch,

Line 513 sql_statement(const struct expr *e, const char *arch,

* "(", "foo=bar", etc.).

static struct expr *

exprcomp(int argc, char *argv[])

exprcomp(const struct mansearch *search, int argc, char *argv[])

{

int i;

int i, cs;

struct expr *first, *next, *cur;

first = cur = NULL;

for (i = 0; i < argc; i++) {

next = exprterm(argv[i]);

if (0 == strcmp("-i", argv[i])) {

if (++i >= argc)

return(NULL);

cs = 0;

} else

cs = 1;

next = exprterm(search, argv[i], cs);

if (NULL == next) {

exprfree(first);

return(NULL);

Line 352 exprcomp(int argc, char *argv[])

Line 543 exprcomp(int argc, char *argv[])

}

static struct expr *

exprterm(char *buf)

exprterm(const struct mansearch *search, char *buf, int cs)

{

struct expr *e;

char *key, *v;

Line 363 exprterm(char *buf)

Line 554 exprterm(char *buf)

e = mandoc_calloc(1, sizeof(struct expr));

/*"whatis" mode uses an opaque string and default fields. */

if (MANSEARCH_WHATIS & search->flags) {

e->substr = buf;

e->bits = search->deftype;

return(e);

}

* If no =~ is specified, search with equality over names and

* descriptions.

Line 370 exprterm(char *buf)

Line 569 exprterm(char *buf)

if (NULL == (v = strpbrk(buf, "=~"))) {

e->v = buf;

e->substr = buf;

e->bits = TYPE_Nm | TYPE_Nd;

e->bits = search->deftype;

return(e);

} else if (v == buf)

e->bits = TYPE_Nm | TYPE_Nd;

e->bits = search->deftype;

e->glob = '~' == *v;

if ('~' == *v++) {

*v++ = '\0';

if (regcomp(&e->regexp, v,

e->v = v;

REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE))) {

free(e);

return(NULL);

}

} else

e->substr = v;

v[-1] = '\0';

* Parse out all possible fields.

CVSweb