mandoc/mansearch.c - diff

Return to mansearch.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mansearch.c between version 1.13 and 1.29

version 1.13, 2014/01/04 23:43:53

version 1.29, 2014/04/15 23:48:51

Line 19

#include "config.h"

#endif

#include <sys/mman.h>

#include <assert.h>

#include <fcntl.h>

#include <getopt.h>

Line 39

Line 40

#include <sqlite3.h>

#include "mandoc.h"

#include "mandoc_aux.h"

#include "manpath.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)) \

Line 70 struct expr {

Line 75 struct expr {

struct match {

uint64_t id; /* identifier in database */

char *file; /* relative filepath of manpage */

char *desc; /* manual page description */

char *desc; /* description of manpage */

int form; /* 0 == catpage */

};

struct type {

static void buildnames(struct manpage *, sqlite3 *,

uint64_t bits;

sqlite3_stmt *, uint64_t,

const char *name;

const char *, int form);

};

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" },

{ ~0ULL, "any" },

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

Line 133 static void *hash_halloc(size_t, void *);

Line 90 static void *hash_halloc(size_t, void *);

static struct expr *exprcomp(const struct mansearch *,

int, char *[]);

static void exprfree(struct expr *);

static struct expr *exprspec(struct expr *, uint64_t,

const char *, const char *);

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

static void sql_append(char **sql, size_t *sz,

const char *newstr, int count);

Line 140 static void sql_match(sqlite3_context *context,

Line 99 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 *,

static char *sql_statement(const struct expr *);

const char *, const char *);

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

const char *outkey,

struct manpage **res, size_t *sz)

{

int fd, rc, c, ibit;

int fd, rc, c, indexbit;

int64_t id;

uint64_t outbit;

uint64_t outbit, iterbit;

char buf[PATH_MAX];

char *sql;

struct manpage *mpage;

Line 186 mansearch(const struct mansearch *search,

Line 191 mansearch(const struct mansearch *search,

outbit = 0;

if (NULL != outkey) {

for (ibit = 0; types[ibit].bits; ibit++) {

for (indexbit = 0, iterbit = 1;

if (0 == strcasecmp(types[ibit].name, outkey)) {

indexbit < mansearch_keymax;

outbit = types[ibit].bits;

indexbit++, iterbit <<= 1) {

if (0 == strcasecmp(outkey,

mansearch_keynames[indexbit])) {

outbit = iterbit;

break;

}

Line 209 mansearch(const struct mansearch *search,

Line 217 mansearch(const struct mansearch *search,

goto out;

}

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

sql = sql_statement(e);

printf("%s\n", sql);

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

Line 256 mansearch(const struct mansearch *search,

Line 265 mansearch(const struct mansearch *search,

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

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

Line 281 mansearch(const struct mansearch *search,

Line 286 mansearch(const struct mansearch *search,

* distribution of buckets in the table.

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

id = sqlite3_column_int64(s, 5);

id = sqlite3_column_int64(s, 2);

idx = ohash_lookup_memory

(&htab, (char *)&id,

sizeof(uint64_t), (uint32_t)id);

if (NULL != ohash_find(&htab, idx))

Line 291 mansearch(const struct mansearch *search,

Line 296 mansearch(const struct mansearch *search,

mp = mandoc_calloc(1, sizeof(struct match));

mp->id = id;

mp->file = mandoc_strdup

mp->form = sqlite3_column_int(s, 1);

((char *)sqlite3_column_text(s, 0));

if (TYPE_Nd == outbit)

mp->desc = mandoc_strdup

mp->desc = mandoc_strdup(

((char *)sqlite3_column_text(s, 3));

sqlite3_column_text(s, 0));

mp->form = sqlite3_column_int(s, 4);

ohash_insert(&htab, idx, mp);

}

Line 305 mansearch(const struct mansearch *search,

Line 309 mansearch(const struct mansearch *search,

sqlite3_finalize(s);

c = sqlite3_prepare_v2(db,

"SELECT * FROM mlinks WHERE pageid=?",

"SELECT * FROM mlinks WHERE pageid=?"

" ORDER BY sec, arch, name",

-1, &s, NULL);

if (SQLITE_OK != c)

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

Line 325 mansearch(const struct mansearch *search,

Line 330 mansearch(const struct mansearch *search,

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

}

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->form = mp->form;

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

buildnames(mpage, db, s, mp->id,

mpage->output = outbit ?

paths->paths[i], mp->form);

mpage->output = TYPE_Nd & outbit ?

mp->desc : outbit ?

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

free(mp->file);

free(mp);

cur++;

}

Line 356 out:

return(rc);

}

static char *

static void

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

buildnames(struct manpage *mpage, sqlite3 *db, sqlite3_stmt *s,

uint64_t id, const char *path, int form)

{

char *names, *newnames;

char *newnames, *prevsec, *prevarch;

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

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

size_t i;

int c;

names = NULL;

mpage->file = NULL;

mpage->names = NULL;

prevsec = prevarch = NULL;

i = 1;

SQL_BIND_INT64(db, s, i, id);

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 = names;

oldnames = mpage->names;

sep1 = ", ";

}

sec = sqlite3_column_text(s, 1);

arch = sqlite3_column_text(s, 2);

/* Fetch the next name. */

name = sqlite3_column_text(s, 3);

sep2 = '\0' == *arch ? "" : "/";

sec = sqlite3_column_text(s, 0);

if (-1 == asprintf(&newnames, "%s%s%s(%s%s%s)",

arch = sqlite3_column_text(s, 1);

oldnames, sep1, name, sec, sep2, arch)) {

name = sqlite3_column_text(s, 2);

perror(0);

exit((int)MANDOCLEVEL_SYSERR);

/* 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 (NULL != mpage->file)

continue;

if (form) {

sep1 = "man";

fsec = sec;

} else {

sep1 = "cat";

fsec = "0";

}

sep2 = '\0' == *arch ? "" : "/";

mandoc_asprintf(&mpage->file, "%s/%s%s%s%s/%s.%s",

path, sep1, sec, sep2, arch, name, fsec);

}

if (SQLITE_DONE != c)

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

sqlite3_reset(s);

return(names);

/* Append one final section to the names. */

if (NULL != prevsec) {

sep2 = '\0' == *prevarch ? "" : "/";

mandoc_asprintf(&newnames, "%s(%s%s%s)",

mpage->names, prevsec, sep2, prevarch);

free(mpage->names);

mpage->names = newnames;

free(prevsec);

free(prevarch);

}

static char *

Line 414 buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id,

Line 471 buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id,

sep1 = " # ";

}

data = sqlite3_column_text(s, 1);

if (-1 == asprintf(&newoutput, "%s%s%s",

mandoc_asprintf(&newoutput, "%s%s%s",

oldoutput, sep1, data)) {

oldoutput, sep1, data);

perror(0);

exit((int)MANDOCLEVEL_SYSERR);

}

free(output);

output = newoutput;

}

Line 478 sql_append(char **sql, size_t *sz, const char *newstr,

Line 532 sql_append(char **sql, size_t *sz, const char *newstr,

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

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

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

sql = mandoc_strdup("SELECT * FROM mpages WHERE ");

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

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

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

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

if (e->open)

sql_append(&sql, &sz, "(", e->open);

sql_append(&sql, &sz, NULL == e->substr ?

sql_append(&sql, &sz,

"id IN (SELECT pageid FROM keys "

TYPE_Nd & e->bits

"WHERE key REGEXP ? AND bits & ?)" :

? (NULL == e->substr

"id IN (SELECT pageid FROM keys "

? "desc REGEXP ?"

"WHERE key MATCH ? AND bits & ?)", 1);

: "desc MATCH ?")

: TYPE_Nm == e->bits

? (NULL == e->substr

? "id IN (SELECT pageid FROM names "

"WHERE name REGEXP ?)"

: "id IN (SELECT pageid FROM names "

"WHERE name MATCH ?)")

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

if (e->close)

sql_append(&sql, &sz, ")", e->close);

needop = 1;

}

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

return(sql);

}

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

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

static struct expr *

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

{

uint64_t mask;

int i, toopen, logic, igncase, toclose;

struct expr *first, *next, *cur;

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

first = cur = NULL;

toopen = logic = igncase = toclose = 0;

logic = igncase = toclose = 0;

toopen = 1;

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

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

Line 561 exprcomp(const struct mansearch *search, int argc, cha

Line 621 exprcomp(const struct mansearch *search, int argc, cha

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

if (NULL == next)

goto fail;

next->open = toopen;

if (NULL == first)

next->and = (1 == logic);

first = next;

if (NULL != first) {

else

cur->next = next;

cur = next;

prev = cur = next;

} else

cur = first = 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))

if (toopen || logic || igncase || toclose)

return(first);

goto fail;

cur->close++;

cur = exprspec(cur, TYPE_arch, search->arch, "^(%s|any)$");

exprspec(cur, TYPE_sec, search->sec, "^%s$");

return(first);

fail:

if (NULL != first)

exprfree(first);

Line 579 fail:

Line 668 fail:

}

static struct expr *

exprspec(struct expr *cur, uint64_t key, const char *value,

const char *format)

{

char errbuf[BUFSIZ];

char *cp;

int irc;

if (NULL == value)

return(cur);

mandoc_asprintf(&cp, format, value);

cur->next = mandoc_calloc(1, sizeof(struct expr));

cur = cur->next;

cur->and = 1;

cur->bits = key;

if (0 != (irc = regcomp(&cur->regexp, cp,

REG_EXTENDED | REG_NOSUB | REG_ICASE))) {

regerror(irc, &cur->regexp, errbuf, sizeof(errbuf));

fprintf(stderr, "regcomp: %s\n", errbuf);

cur->substr = value;

}

free(cp);

return(cur);

}

static struct expr *

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

{

char errbuf[BUFSIZ];

struct expr *e;

char *key, *v;

size_t i;

uint64_t iterbit;

int i, irc;

if ('\0' == *buf)

return(NULL);

Line 612 exprterm(const struct mansearch *search, char *buf, in

Line 729 exprterm(const struct mansearch *search, char *buf, in

e->bits = search->deftype;

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

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

if (NULL != strstr(buf, "arch"))

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

cs = 0;

if (0 != (irc = regcomp(&e->regexp, v,

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

regerror(irc, &e->regexp, errbuf, sizeof(errbuf));

fprintf(stderr, "regcomp: %s\n", errbuf);

free(e);

return(NULL);

}

Line 629 exprterm(const struct mansearch *search, char *buf, in

Line 750 exprterm(const struct mansearch *search, char *buf, in

while (NULL != (key = strsep(&buf, ","))) {

if ('\0' == *key)

continue;

i = 0;

for (i = 0, iterbit = 1;

while (types[i].bits &&

i < mansearch_keymax;

strcasecmp(types[i].name, key))

i++, iterbit <<= 1) {

i++;

if (0 == strcasecmp(key,

if (0 == types[i].bits) {

mansearch_keynames[i])) {

free(e);

e->bits |= iterbit;

return(NULL);

break;

}

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

if (i == mansearch_keymax) {

if (strcasecmp(key, "any")) {

free(e);

return(NULL);

}

e->bits |= ~0ULL;

}

return(e);

CVSweb