mandoc/mansearch.c - diff

Return to mansearch.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mansearch.c between version 1.15 and 1.33

version 1.15, 2014/01/05 03:06:43

version 1.33, 2014/04/17 19:20:01

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 69 struct expr {

Line 74 struct expr {

};

struct match {

uint64_t id; /* identifier in database */

uint64_t pageid; /* 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" },

{ TYPE_sec, "sec" },

{ TYPE_arch,"arch" },

{ ~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 147 static void sql_regexp(sqlite3_context *context,

Line 102 static void sql_regexp(sqlite3_context *context,

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

int64_t pageid;

uint64_t outbit;

uint64_t outbit, iterbit;

char buf[PATH_MAX];

char *sql;

struct manpage *mpage;

Line 173 mansearch(const struct mansearch *search,

Line 175 mansearch(const struct mansearch *search,

info.halloc = hash_halloc;

info.alloc = hash_alloc;

info.hfree = hash_free;

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

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

*sz = cur = maxres = 0;

sql = NULL;

Line 189 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 205 mansearch(const struct mansearch *search,

Line 210 mansearch(const struct mansearch *search,

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

perror(NULL);

perror("getcwd");

goto out;

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

perror(buf);

Line 248 mansearch(const struct mansearch *search,

Line 253 mansearch(const struct mansearch *search,

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,

SQLITE_ANY, NULL, sql_regexp, NULL, NULL);

SQLITE_UTF8 | SQLITE_DETERMINISTIC,

NULL, sql_regexp, NULL, NULL);

assert(SQLITE_OK == c);

j = 1;

Line 264 mansearch(const struct mansearch *search,

Line 271 mansearch(const struct mansearch *search,

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 279 mansearch(const struct mansearch *search,

Line 287 mansearch(const struct mansearch *search,

* distribution of buckets in the table.

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

id = sqlite3_column_int64(s, 5);

pageid = sqlite3_column_int64(s, 2);

idx = ohash_lookup_memory

(&htab, (char *)&id,

(&htab, (char *)&pageid,

sizeof(uint64_t), (uint32_t)id);

sizeof(uint64_t), (uint32_t)pageid);

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

continue;

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

mp->id = id;

mp->pageid = pageid;

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 303 mansearch(const struct mansearch *search,

Line 310 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 323 mansearch(const struct mansearch *search,

Line 331 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->pageid,

mpage->output = outbit ?

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

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

mpage->output = TYPE_Nd & outbit ?

mp->desc : outbit ?

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

free(mp->file);

free(mp);

cur++;

}

Line 346 mansearch(const struct mansearch *search,

Line 349 mansearch(const struct mansearch *search,

}

rc = 1;

out:

exprfree(e);

if (-1 != fd) {

if (-1 != fd)

if (-1 == fchdir(fd))

perror(buf);

close(fd);

}

exprfree(e);

free(sql);

*sz = cur;

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

SQL_BIND_INT64(db, s, i, pageid);

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 *

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;

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

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

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

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

Line 475 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 492 sql_statement(const struct expr *e)

Line 552 sql_statement(const struct expr *e)

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

? "pageid IN (SELECT pageid FROM names "

"WHERE name REGEXP ?)"

: "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;

Line 513 sql_statement(const struct expr *e)

Line 584 sql_statement(const struct expr *e)

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;

logic = igncase = toclose = 0;

toopen = 1;

toopen = NULL != search->sec || NULL != search->arch;

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

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

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

Line 625 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)

goto fail;

cur->close++;

if (NULL != search->sec || NULL != search->arch)

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

cur->close++;

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

if (NULL != search->arch)

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

if (NULL != search->sec)

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

return(first);

Line 585 exprspec(struct expr *cur, uint64_t key, const char *v

Line 682 exprspec(struct expr *cur, uint64_t key, const char *v

char *cp;

int irc;

if (NULL == value)

mandoc_asprintf(&cp, format, value);

return(cur);

if (-1 == asprintf(&cp, format, value)) {

perror(0);

exit((int)MANDOCLEVEL_SYSERR);

}

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

cur = cur->next;

cur->and = 1;

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

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

char errbuf[BUFSIZ];

struct expr *e;

char *key, *v;

size_t i;

uint64_t iterbit;

int irc;

int i, irc;

if ('\0' == *buf)

return(NULL);

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

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

e->bits = search->deftype;

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

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

cs = 0;

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

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

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

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

Line 754 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