mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.220.2.12 and 1.221

version 1.220.2.12, 2017/02/17 14:50:13

version 1.221, 2016/07/19 21:31:55

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 38

Line 37

#if HAVE_SANDBOX_INIT

#include <sandbox.h>

#endif

#include <stdarg.h>

#include <stddef.h>

#include <stdio.h>

#include <stdint.h>

Line 45

#include <string.h>

#include <unistd.h>

#include <sqlite3.h>

#include "mandoc_aux.h"

#include "mandoc_ohash.h"

#include "mandoc.h"

Line 55

Line 53

#include "man.h"

#include "manconf.h"

#include "mansearch.h"

#include "dba_array.h"

#include "dba.h"

extern int mansearch_keymax;

extern const char *const mansearch_keynames[];

#define SQL_EXEC(_v) \

if (SQLITE_OK != sqlite3_exec(db, (_v), NULL, NULL, NULL)) \

say("", "%s: %s", (_v), sqlite3_errmsg(db))

#define SQL_BIND_TEXT(_s, _i, _v) \

if (SQLITE_OK != sqlite3_bind_text \

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

say(mlink->file, "%s", sqlite3_errmsg(db))

#define SQL_BIND_INT(_s, _i, _v) \

if (SQLITE_OK != sqlite3_bind_int \

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

say(mlink->file, "%s", sqlite3_errmsg(db))

#define SQL_BIND_INT64(_s, _i, _v) \

if (SQLITE_OK != sqlite3_bind_int64 \

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

say(mlink->file, "%s", sqlite3_errmsg(db))

#define SQL_STEP(_s) \

if (SQLITE_DONE != sqlite3_step((_s))) \

say(mlink->file, "%s", sqlite3_errmsg(db))

enum op {

OP_DEFAULT = 0, /* new dbs from dir list or default config */

OP_CONFFILE, /* new databases from custom config file */

Line 99 struct inodev {

Line 79 struct inodev {

struct mpage {

struct inodev inodev; /* used for hashing routine */

int64_t pageid; /* pageid in mpages SQL table */

struct dba_array *dba;

char *sec; /* section from file content */

char *arch; /* architecture from file content */

char *title; /* title from file content */

char *desc; /* description from file content */

struct mpage *next; /* singly linked list */

struct mlink *mlinks; /* singly linked list */

int form; /* format from file content */

int name_head_done;

enum form form; /* format from file content */

};

struct mlink {

Line 118 struct mlink {

Line 97 struct mlink {

char *fsec; /* section from file name suffix */

struct mlink *next; /* singly linked list */

struct mpage *mpage; /* parent */

int dform; /* format from directory */

int fform; /* format from file name suffix */

int gzip; /* filename has a .gz suffix */

enum form dform; /* format from directory */

enum form fform; /* format from file name suffix */

};

enum stmt {

STMT_DELETE_PAGE = 0, /* delete mpage */

STMT_INSERT_PAGE, /* insert mpage */

STMT_INSERT_LINK, /* insert mlink */

STMT_INSERT_NAME, /* insert name */

STMT_SELECT_NAME, /* retrieve existing name flags */

STMT_INSERT_KEY, /* insert parsed key */

STMT__MAX

};

typedef int (*mdoc_fp)(struct mpage *, const struct roff_meta *,

const struct roff_node *);

struct mdoc_handler {

mdoc_fp fp; /* optional handler */

uint64_t mask; /* set unless handler returns 0 */

int taboo; /* node flags that must not be set */

};

int mandocdb(int, char *[]);

static void dbclose(int);

static void dbadd(struct dba *, struct mpage *);

static void dbadd(struct mpage *);

static void dbadd_mlink(const struct mlink *mlink);

static void dbadd_mlink_name(const struct mlink *mlink);

static void dbprune(struct dba *);

static int dbopen(int);

static void dbwrite(struct dba *);

static void dbprune(void);

static void filescan(const char *);

#if HAVE_FTS_COMPARE_CONST

static int fts_compare(const FTSENT *const *, const FTSENT *const *);

#else

static int fts_compare(const FTSENT **, const FTSENT **);

#endif

static void mlink_add(struct mlink *, const struct stat *);

static void mlink_check(struct mpage *, struct mlink *);

static void mlink_free(struct mlink *);

static void mlinks_undupe(struct mpage *);

static void mpages_free(void);

static void mpages_merge(struct mparse *);

static void mpages_merge(struct dba *, struct mparse *);

static void names_check(void);

static void parse_cat(struct mpage *, int);

static void parse_man(struct mpage *, const struct roff_meta *,

const struct roff_node *);

Line 191 static int parse_mdoc_Xr(struct mpage *, const struct

Line 151 static int parse_mdoc_Xr(struct mpage *, const struct

static void putkey(const struct mpage *, char *, uint64_t);

static void putkeys(const struct mpage *, char *, size_t, uint64_t);

static void putmdockey(const struct mpage *,

const struct roff_node *, uint64_t, int);

const struct roff_node *, uint64_t);

static int render_string(char **, size_t *);

static void say(const char *, const char *, ...)

__attribute__((__format__ (__printf__, 2, 3)));

__attribute__((__format__ (printf, 2, 3)));

static int set_basedir(const char *, int);

static int treescan(void);

static size_t utf8(unsigned int, char [7]);

static char tempfilename[32];

static int nodb; /* no database changes */

static int mparse_options; /* abort the parse early */

static int use_all; /* use all found files */

Line 209 static int write_utf8; /* write UTF-8 output; else A

Line 168 static int write_utf8; /* write UTF-8 output; else A

static int exitcode; /* to be returned by main */

static enum op op; /* operational mode */

static char basedir[PATH_MAX]; /* current base directory */

static struct mpage *mpage_head; /* list of distinct manual pages */

static struct ohash mpages; /* table of distinct manual pages */

static struct ohash mlinks; /* table of directory entries */

static struct ohash names; /* table of all names */

static struct ohash strings; /* table of all strings */

static sqlite3 *db = NULL; /* current database */

static sqlite3_stmt *stmts[STMT__MAX]; /* current statements */

static uint64_t name_mask;

static const struct mdoc_handler mdocs[MDOC_MAX] = {

{ NULL, 0, 0 }, /* Ap */

{ NULL, 0 }, /* Ap */

{ NULL, 0, NODE_NOPRT }, /* Dd */

{ NULL, 0 }, /* Dd */

{ NULL, 0, NODE_NOPRT }, /* Dt */

{ NULL, 0 }, /* Dt */

{ NULL, 0, NODE_NOPRT }, /* Os */

{ NULL, 0 }, /* Os */

{ parse_mdoc_Sh, TYPE_Sh, 0 }, /* Sh */

{ parse_mdoc_Sh, TYPE_Sh }, /* Sh */

{ parse_mdoc_head, TYPE_Ss, 0 }, /* Ss */

{ parse_mdoc_head, TYPE_Ss }, /* Ss */

{ NULL, 0, 0 }, /* Pp */

{ NULL, 0 }, /* Pp */

{ NULL, 0, 0 }, /* D1 */

{ NULL, 0 }, /* D1 */

{ NULL, 0, 0 }, /* Dl */

{ NULL, 0 }, /* Dl */

{ NULL, 0, 0 }, /* Bd */

{ NULL, 0 }, /* Bd */

{ NULL, 0, 0 }, /* Ed */

{ NULL, 0 }, /* Ed */

{ NULL, 0, 0 }, /* Bl */

{ NULL, 0 }, /* Bl */

{ NULL, 0, 0 }, /* El */

{ NULL, 0 }, /* El */

{ NULL, 0, 0 }, /* It */

{ NULL, 0 }, /* It */

{ NULL, 0, 0 }, /* Ad */

{ NULL, 0 }, /* Ad */

{ NULL, TYPE_An, 0 }, /* An */

{ NULL, TYPE_An }, /* An */

{ NULL, TYPE_Ar, 0 }, /* Ar */

{ NULL, TYPE_Ar }, /* Ar */

{ NULL, TYPE_Cd, 0 }, /* Cd */

{ NULL, TYPE_Cd }, /* Cd */

{ NULL, TYPE_Cm, 0 }, /* Cm */

{ NULL, TYPE_Cm }, /* Cm */

{ NULL, TYPE_Dv, 0 }, /* Dv */

{ NULL, TYPE_Dv }, /* Dv */

{ NULL, TYPE_Er, 0 }, /* Er */

{ NULL, TYPE_Er }, /* Er */

{ NULL, TYPE_Ev, 0 }, /* Ev */

{ NULL, TYPE_Ev }, /* Ev */

{ NULL, 0, 0 }, /* Ex */

{ NULL, 0 }, /* Ex */

{ NULL, TYPE_Fa, 0 }, /* Fa */

{ NULL, TYPE_Fa }, /* Fa */

{ parse_mdoc_Fd, 0, 0 }, /* Fd */

{ parse_mdoc_Fd, 0 }, /* Fd */

{ NULL, TYPE_Fl, 0 }, /* Fl */

{ NULL, TYPE_Fl }, /* Fl */

{ parse_mdoc_Fn, 0, 0 }, /* Fn */

{ parse_mdoc_Fn, 0 }, /* Fn */

{ NULL, TYPE_Ft, 0 }, /* Ft */

{ NULL, TYPE_Ft }, /* Ft */

{ NULL, TYPE_Ic, 0 }, /* Ic */

{ NULL, TYPE_Ic }, /* Ic */

{ NULL, TYPE_In, 0 }, /* In */

{ NULL, TYPE_In }, /* In */

{ NULL, TYPE_Li, 0 }, /* Li */

{ NULL, TYPE_Li }, /* Li */

{ parse_mdoc_Nd, 0, 0 }, /* Nd */

{ parse_mdoc_Nd, 0 }, /* Nd */

{ parse_mdoc_Nm, 0, 0 }, /* Nm */

{ parse_mdoc_Nm, 0 }, /* Nm */

{ NULL, 0, 0 }, /* Op */

{ NULL, 0 }, /* Op */

{ NULL, 0, 0 }, /* Ot */

{ NULL, 0 }, /* Ot */

{ NULL, TYPE_Pa, NODE_NOSRC }, /* Pa */

{ NULL, TYPE_Pa }, /* Pa */

{ NULL, 0, 0 }, /* Rv */

{ NULL, 0 }, /* Rv */

{ NULL, TYPE_St, 0 }, /* St */

{ NULL, TYPE_St }, /* St */

{ parse_mdoc_Va, TYPE_Va, 0 }, /* Va */

{ parse_mdoc_Va, TYPE_Va }, /* Va */

{ parse_mdoc_Va, TYPE_Vt, 0 }, /* Vt */

{ parse_mdoc_Va, TYPE_Vt }, /* Vt */

{ parse_mdoc_Xr, 0, 0 }, /* Xr */

{ parse_mdoc_Xr, 0 }, /* Xr */

{ NULL, 0, 0 }, /* %A */

{ NULL, 0 }, /* %A */

{ NULL, 0, 0 }, /* %B */

{ NULL, 0 }, /* %B */

{ NULL, 0, 0 }, /* %D */

{ NULL, 0 }, /* %D */

{ NULL, 0, 0 }, /* %I */

{ NULL, 0 }, /* %I */

{ NULL, 0, 0 }, /* %J */

{ NULL, 0 }, /* %J */

{ NULL, 0, 0 }, /* %N */

{ NULL, 0 }, /* %N */

{ NULL, 0, 0 }, /* %O */

{ NULL, 0 }, /* %O */

{ NULL, 0, 0 }, /* %P */

{ NULL, 0 }, /* %P */

{ NULL, 0, 0 }, /* %R */

{ NULL, 0 }, /* %R */

{ NULL, 0, 0 }, /* %T */

{ NULL, 0 }, /* %T */

{ NULL, 0, 0 }, /* %V */

{ NULL, 0 }, /* %V */

{ NULL, 0, 0 }, /* Ac */

{ NULL, 0 }, /* Ac */

{ NULL, 0, 0 }, /* Ao */

{ NULL, 0 }, /* Ao */

{ NULL, 0, 0 }, /* Aq */

{ NULL, 0 }, /* Aq */

{ NULL, TYPE_At, 0 }, /* At */

{ NULL, TYPE_At }, /* At */

{ NULL, 0, 0 }, /* Bc */

{ NULL, 0 }, /* Bc */

{ NULL, 0, 0 }, /* Bf */

{ NULL, 0 }, /* Bf */

{ NULL, 0, 0 }, /* Bo */

{ NULL, 0 }, /* Bo */

{ NULL, 0, 0 }, /* Bq */

{ NULL, 0 }, /* Bq */

{ NULL, TYPE_Bsx, NODE_NOSRC }, /* Bsx */

{ NULL, TYPE_Bsx }, /* Bsx */

{ NULL, TYPE_Bx, NODE_NOSRC }, /* Bx */

{ NULL, TYPE_Bx }, /* Bx */

{ NULL, 0, 0 }, /* Db */

{ NULL, 0 }, /* Db */

{ NULL, 0, 0 }, /* Dc */

{ NULL, 0 }, /* Dc */

{ NULL, 0, 0 }, /* Do */

{ NULL, 0 }, /* Do */

{ NULL, 0, 0 }, /* Dq */

{ NULL, 0 }, /* Dq */

{ NULL, 0, 0 }, /* Ec */

{ NULL, 0 }, /* Ec */

{ NULL, 0, 0 }, /* Ef */

{ NULL, 0 }, /* Ef */

{ NULL, TYPE_Em, 0 }, /* Em */

{ NULL, TYPE_Em }, /* Em */

{ NULL, 0, 0 }, /* Eo */

{ NULL, 0 }, /* Eo */

{ NULL, TYPE_Fx, NODE_NOSRC }, /* Fx */

{ NULL, TYPE_Fx }, /* Fx */

{ NULL, TYPE_Ms, 0 }, /* Ms */

{ NULL, TYPE_Ms }, /* Ms */

{ NULL, 0, 0 }, /* No */

{ NULL, 0 }, /* No */

{ NULL, 0, 0 }, /* Ns */

{ NULL, 0 }, /* Ns */

{ NULL, TYPE_Nx, NODE_NOSRC }, /* Nx */

{ NULL, TYPE_Nx }, /* Nx */

{ NULL, TYPE_Ox, NODE_NOSRC }, /* Ox */

{ NULL, TYPE_Ox }, /* Ox */

{ NULL, 0, 0 }, /* Pc */

{ NULL, 0 }, /* Pc */

{ NULL, 0, 0 }, /* Pf */

{ NULL, 0 }, /* Pf */

{ NULL, 0, 0 }, /* Po */

{ NULL, 0 }, /* Po */

{ NULL, 0, 0 }, /* Pq */

{ NULL, 0 }, /* Pq */

{ NULL, 0, 0 }, /* Qc */

{ NULL, 0 }, /* Qc */

{ NULL, 0, 0 }, /* Ql */

{ NULL, 0 }, /* Ql */

{ NULL, 0, 0 }, /* Qo */

{ NULL, 0 }, /* Qo */

{ NULL, 0, 0 }, /* Qq */

{ NULL, 0 }, /* Qq */

{ NULL, 0, 0 }, /* Re */

{ NULL, 0 }, /* Re */

{ NULL, 0, 0 }, /* Rs */

{ NULL, 0 }, /* Rs */

{ NULL, 0, 0 }, /* Sc */

{ NULL, 0 }, /* Sc */

{ NULL, 0, 0 }, /* So */

{ NULL, 0 }, /* So */

{ NULL, 0, 0 }, /* Sq */

{ NULL, 0 }, /* Sq */

{ NULL, 0, 0 }, /* Sm */

{ NULL, 0 }, /* Sm */

{ NULL, 0, 0 }, /* Sx */

{ NULL, 0 }, /* Sx */

{ NULL, TYPE_Sy, 0 }, /* Sy */

{ NULL, TYPE_Sy }, /* Sy */

{ NULL, TYPE_Tn, 0 }, /* Tn */

{ NULL, TYPE_Tn }, /* Tn */

{ NULL, 0, NODE_NOSRC }, /* Ux */

{ NULL, 0 }, /* Ux */

{ NULL, 0, 0 }, /* Xc */

{ NULL, 0 }, /* Xc */

{ NULL, 0, 0 }, /* Xo */

{ NULL, 0 }, /* Xo */

{ parse_mdoc_Fo, 0, 0 }, /* Fo */

{ parse_mdoc_Fo, 0 }, /* Fo */

{ NULL, 0, 0 }, /* Fc */

{ NULL, 0 }, /* Fc */

{ NULL, 0, 0 }, /* Oo */

{ NULL, 0 }, /* Oo */

{ NULL, 0, 0 }, /* Oc */

{ NULL, 0 }, /* Oc */

{ NULL, 0, 0 }, /* Bk */

{ NULL, 0 }, /* Bk */

{ NULL, 0, 0 }, /* Ek */

{ NULL, 0 }, /* Ek */

{ NULL, 0, 0 }, /* Bt */

{ NULL, 0 }, /* Bt */

{ NULL, 0, 0 }, /* Hf */

{ NULL, 0 }, /* Hf */

{ NULL, 0, 0 }, /* Fr */

{ NULL, 0 }, /* Fr */

{ NULL, 0, 0 }, /* Ud */

{ NULL, 0 }, /* Ud */

{ NULL, TYPE_Lb, NODE_NOSRC }, /* Lb */

{ NULL, TYPE_Lb }, /* Lb */

{ NULL, 0, 0 }, /* Lp */

{ NULL, 0 }, /* Lp */

{ NULL, TYPE_Lk, 0 }, /* Lk */

{ NULL, TYPE_Lk }, /* Lk */

{ NULL, TYPE_Mt, NODE_NOSRC }, /* Mt */

{ NULL, TYPE_Mt }, /* Mt */

{ NULL, 0, 0 }, /* Brq */

{ NULL, 0 }, /* Brq */

{ NULL, 0, 0 }, /* Bro */

{ NULL, 0 }, /* Bro */

{ NULL, 0, 0 }, /* Brc */

{ NULL, 0 }, /* Brc */

{ NULL, 0, 0 }, /* %C */

{ NULL, 0 }, /* %C */

{ NULL, 0, 0 }, /* Es */

{ NULL, 0 }, /* Es */

{ NULL, 0, 0 }, /* En */

{ NULL, 0 }, /* En */

{ NULL, TYPE_Dx, NODE_NOSRC }, /* Dx */

{ NULL, TYPE_Dx }, /* Dx */

{ NULL, 0, 0 }, /* %Q */

{ NULL, 0 }, /* %Q */

{ NULL, 0, 0 }, /* br */

{ NULL, 0 }, /* br */

{ NULL, 0, 0 }, /* sp */

{ NULL, 0 }, /* sp */

{ NULL, 0, 0 }, /* %U */

{ NULL, 0 }, /* %U */

{ NULL, 0, 0 }, /* Ta */

{ NULL, 0 }, /* Ta */

{ NULL, 0, 0 }, /* ll */

{ NULL, 0 }, /* ll */

};

Line 350 mandocdb(int argc, char *argv[])

Line 306 mandocdb(int argc, char *argv[])

{

struct manconf conf;

struct mparse *mp;

struct dba *dba;

const char *path_arg, *progname;

size_t j, sz;

int ch, i;

Line 369 mandocdb(int argc, char *argv[])

Line 326 mandocdb(int argc, char *argv[])

#endif

memset(&conf, 0, sizeof(conf));

memset(stmts, 0, STMT__MAX * sizeof(sqlite3_stmt *));

* We accept a few different invocations.

Line 470 mandocdb(int argc, char *argv[])

Line 426 mandocdb(int argc, char *argv[])

if (OP_TEST != op && 0 == set_basedir(path_arg, 1))

goto out;

if (dbopen(1)) {

if ((dba = dba_read(MANDOC_DB)) != NULL) {

* The existing database is usable. Process

* all files specified on the command-line.

Line 488 mandocdb(int argc, char *argv[])

Line 444 mandocdb(int argc, char *argv[])

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

filescan(argv[i]);

if (OP_TEST != op)

dbprune();

dbprune(dba);

} else {

* Database missing or corrupt.

Line 498 mandocdb(int argc, char *argv[])

Line 454 mandocdb(int argc, char *argv[])

op = OP_DEFAULT;

if (0 == treescan())

goto out;

if (0 == dbopen(0))

dba = dba_new(128);

goto out;

}

if (OP_DELETE != op)

mpages_merge(mp);

mpages_merge(dba, mp);

dbclose(OP_DEFAULT == op ? 0 : 1);

if (nodb == 0)

dbwrite(dba);

dba_free(dba);

} else {

* If we have arguments, use them as our manpaths.

Line 548 mandocdb(int argc, char *argv[])

Line 505 mandocdb(int argc, char *argv[])

continue;

if (0 == treescan())

continue;

if (0 == dbopen(0))

dba = dba_new(128);

continue;

mpages_merge(dba, mp);

if (nodb == 0)

dbwrite(dba);

dba_free(dba);

mpages_merge(mp);

if (warnings && !nodb &&

! (MPARSE_QUICK & mparse_options))

names_check();

dbclose(0);

if (j + 1 < conf.manpath.sz) {

mpages_free();

ohash_delete(&mpages);

Line 585 usage:

Line 539 usage:

}

* To get a singly linked list in alpha order while inserting entries

* at the beginning, process directory entries in reverse alpha order.

static int

#if HAVE_FTS_COMPARE_CONST

fts_compare(const FTSENT *const *a, const FTSENT *const *b)

#else

fts_compare(const FTSENT **a, const FTSENT **b)

#endif

{

return -strcmp((*a)->fts_name, (*b)->fts_name);

}

* Scan a directory tree rooted at "basedir" for manpages.

* We use fts(), scanning directory parts along the way for clues to our

* section and architecture.

Line 619 treescan(void)

Line 559 treescan(void)

FTS *f;

FTSENT *ff;

struct mlink *mlink;

int dform, gzip;

int gzip;

enum form dform;

char *dsec, *arch, *fsec, *cp;

const char *path;

const char *argv[2];

argv[0] = ".";

argv[1] = NULL;

argv[1] = (char *)NULL;

f = fts_open((char * const *)argv, FTS_PHYSICAL | FTS_NOCHDIR,

f = fts_open((char * const *)argv,

fts_compare);

FTS_PHYSICAL | FTS_NOCHDIR, NULL);

if (f == NULL) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fts_open");

Line 908 filescan(const char *file)

Line 849 filescan(const char *file)

}

* In test mode or when the original name is absolute

* but outside our tree, guess the base directory.

if (op == OP_TEST || (start == buf && *start == '/')) {

if (strncmp(buf, "man/", 4) == 0)

start = buf + 4;

else if ((start = strstr(buf, "/man/")) != NULL)

start += 5;

else

start = buf;

}

* First try to guess our directory structure.

* If we find a separator, try to look for man* or cat*.

* If we find one of these and what's underneath is a directory,

Line 1007 mlink_add(struct mlink *mlink, const struct stat *st)

Line 934 mlink_add(struct mlink *mlink, const struct stat *st)

mpage = mandoc_calloc(1, sizeof(struct mpage));

mpage->inodev.st_ino = inodev.st_ino;

mpage->inodev.st_dev = inodev.st_dev;

mpage->next = mpage_head;

mpage->form = FORM_NONE;

mpage_head = mpage;

ohash_insert(&mpages, slot, mpage);

} else

mlink->next = mpage->mlinks;

Line 1032 mpages_free(void)

Line 958 mpages_free(void)

{

struct mpage *mpage;

struct mlink *mlink;

unsigned int slot;

while ((mpage = mpage_head) != NULL) {

mpage = ohash_first(&mpages, &slot);

while ((mlink = mpage->mlinks) != NULL) {

while (NULL != mpage) {

while (NULL != (mlink = mpage->mlinks)) {

mpage->mlinks = mlink->next;

mlink_free(mlink);

}

mpage_head = mpage->next;

free(mpage->sec);

free(mpage->arch);

free(mpage->title);

free(mpage->desc);

free(mpage);

mpage = ohash_next(&mpages, &slot);

}

Line 1155 mlink_check(struct mpage *mpage, struct mlink *mlink)

Line 1083 mlink_check(struct mpage *mpage, struct mlink *mlink)

* and filename to determine whether the file is parsable or not.

static void

mpages_merge(struct mparse *mp)

mpages_merge(struct dba *dba, struct mparse *mp)

{

char any[] = "any";

struct mpage *mpage, *mpage_dest;

Line 1164 mpages_merge(struct mparse *mp)

Line 1092 mpages_merge(struct mparse *mp)

char *sodest;

char *cp;

int fd;

unsigned int pslot;

if ( ! nodb)

mpage = ohash_first(&mpages, &pslot);

SQL_EXEC("BEGIN TRANSACTION");

while (mpage != NULL) {

for (mpage = mpage_head; mpage != NULL; mpage = mpage->next) {

mlinks_undupe(mpage);

if ((mlink = mpage->mlinks) == NULL)

if ((mlink = mpage->mlinks) == NULL) {

mpage = ohash_next(&mpages, &pslot);

continue;

}

name_mask = NAME_MASK;

mandoc_ohash_init(&names, 4, offsetof(struct str, key));

Line 1192 mpages_merge(struct mparse *mp)

Line 1121 mpages_merge(struct mparse *mp)

if (mlink->dform != FORM_CAT || mlink->fform != FORM_CAT) {

mparse_readfd(mp, fd, mlink->file);

close(fd);

fd = -1;

mparse_result(mp, &man, &sodest);

}

Line 1222 mpages_merge(struct mparse *mp)

Line 1150 mpages_merge(struct mparse *mp)

* to the target.

if (mpage_dest->pageid)

if (mpage_dest->dba != NULL)

dbadd_mlink_name(mlink);

dbadd_mlink(mlink);

if (mlink->next == NULL)

break;

Line 1249 mpages_merge(struct mparse *mp)

Line 1177 mpages_merge(struct mparse *mp)

mpage->title = mandoc_strdup(man->meta.title);

} else if (man != NULL && man->macroset == MACROSET_MAN) {

man_validate(man);

if (*man->meta.msec != '\0' ||

mpage->form = FORM_SRC;

*man->meta.msec != '\0') {

mpage->sec = mandoc_strdup(man->meta.msec);

mpage->form = FORM_SRC;

mpage->arch = mandoc_strdup(mlink->arch);

mpage->sec = mandoc_strdup(man->meta.msec);

mpage->title = mandoc_strdup(man->meta.title);

mpage->arch = mandoc_strdup(mlink->arch);

} else {

mpage->title = mandoc_strdup(man->meta.title);

} else

man = NULL;

}

assert(mpage->desc == NULL);

if (man == NULL) {

mpage->form = FORM_CAT;

mpage->sec = mandoc_strdup(mlink->dsec);

mpage->arch = mandoc_strdup(mlink->arch);

mpage->title = mandoc_strdup(mlink->name);

parse_cat(mpage, fd);

} else if (man->macroset == MACROSET_MDOC)

parse_mdoc(mpage, &man->meta, man->first);

else

parse_man(mpage, &man->meta, man->first);

if (mpage->desc == NULL) {

mpage->desc = mandoc_strdup(mlink->name);

if (warnings)

say(mlink->file, "No one-line description, "

"using filename \"%s\"", mlink->name);

}

putkey(mpage, mpage->sec, TYPE_sec);

if (*mpage->arch != '\0')

putkey(mpage, mpage->arch, TYPE_arch);

Line 1291 mpages_merge(struct mparse *mp)

Line 1201 mpages_merge(struct mparse *mp)

putkey(mpage, mlink->name, NAME_FILE);

}

assert(mpage->desc == NULL);

if (man != NULL && man->macroset == MACROSET_MDOC)

parse_mdoc(mpage, &man->meta, man->first);

else if (man != NULL)

parse_man(mpage, &man->meta, man->first);

else

parse_cat(mpage, fd);

if (mpage->desc == NULL)

mpage->desc = mandoc_strdup(mpage->mlinks->name);

if (warnings && !use_all)

for (mlink = mpage->mlinks; mlink;

mlink = mlink->next)

mlink_check(mpage, mlink);

dbadd(mpage);

dbadd(dba, mpage);

mlink = mpage->mlinks;

ohash_delete(&strings);

ohash_delete(&names);

mpage = ohash_next(&mpages, &pslot);

}

if (0 == nodb)

SQL_EXEC("END TRANSACTION");

}

static void

names_check(void)

{

sqlite3_stmt *stmt;

const char *name, *sec, *arch, *key;

sqlite3_prepare_v2(db,

"SELECT name, sec, arch, key FROM ("

"SELECT name AS key, pageid FROM names "

"WHERE bits & ? AND NOT EXISTS ("

"SELECT pageid FROM mlinks "

"WHERE mlinks.pageid == names.pageid "

"AND mlinks.name == names.name"

")"

") JOIN ("

"SELECT sec, arch, name, pageid FROM mlinks "

"GROUP BY pageid"

") USING (pageid);",

-1, &stmt, NULL);

if (sqlite3_bind_int64(stmt, 1, NAME_TITLE) != SQLITE_OK)

say("", "%s", sqlite3_errmsg(db));

while (sqlite3_step(stmt) == SQLITE_ROW) {

name = (const char *)sqlite3_column_text(stmt, 0);

sec = (const char *)sqlite3_column_text(stmt, 1);

arch = (const char *)sqlite3_column_text(stmt, 2);

key = (const char *)sqlite3_column_text(stmt, 3);

say("", "%s(%s%s%s) lacks mlink \"%s\"", name, sec,

'\0' == *arch ? "" : "/",

'\0' == *arch ? "" : arch, key);

}

sqlite3_finalize(stmt);

}

static void

parse_cat(struct mpage *mpage, int fd)

{

FILE *stream;

struct mlink *mlink;

char *line, *p, *title;

char *line, *p, *title, *sec;

size_t linesz, plen, titlesz;

ssize_t len;

int offs;

mlink = mpage->mlinks;

stream = (-1 == fd) ?

stream = fd == -1 ? fopen(mlink->file, "r") : fdopen(fd, "r");

fopen(mpage->mlinks->file, "r") :

if (stream == NULL) {

fdopen(fd, "r");

if (fd != -1)

if (NULL == stream) {

if (-1 != fd)

close(fd);

if (warnings)

say(mlink->file, "&fopen");

say(mpage->mlinks->file, "&fopen");

return;

}

line = NULL;

linesz = 0;

/* Parse the section number from the header line. */

/* Skip to first blank line. */

while (getline(&line, &linesz, stream) != -1) {

while (getline(&line, &linesz, stream) != -1)

if (*line == '\n')

continue;

if ((sec = strchr(line, '(')) == NULL)

break;

if ((p = strchr(++sec, ')')) == NULL)

break;

free(mpage->sec);

mpage->sec = mandoc_strndup(sec, p - sec);

if (warnings && *mlink->dsec != '\0' &&

strcasecmp(mpage->sec, mlink->dsec))

say(mlink->file,

"Section \"%s\" manual in %s directory",

mpage->sec, mlink->dsec);

break;

}

/* Skip to first blank line. */

while (line == NULL || *line != '\n')

if (getline(&line, &linesz, stream) == -1)

break;

* Assume the first line that is not indented

* is the first section header. Skip to it.

Line 1433 parse_cat(struct mpage *mpage, int fd)

Line 1298 parse_cat(struct mpage *mpage, int fd)

if (NULL == title || '\0' == *title) {

if (warnings)

say(mlink->file, "Cannot find NAME section");

say(mpage->mlinks->file,

"Cannot find NAME section");

fclose(stream);

free(title);

return;

Line 1452 parse_cat(struct mpage *mpage, int fd)

Line 1318 parse_cat(struct mpage *mpage, int fd)

/* Skip to next word. */ ;

} else {

if (warnings)

say(mlink->file, "No dash in title line, "

say(mpage->mlinks->file,

"reusing \"%s\" as one-line description", title);

"No dash in title line");

p = title;

}

Line 1497 putkey(const struct mpage *mpage, char *value, uint64_

Line 1363 putkey(const struct mpage *mpage, char *value, uint64_

static void

putmdockey(const struct mpage *mpage,

const struct roff_node *n, uint64_t m, int taboo)

const struct roff_node *n, uint64_t m)

{

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

if (n->flags & taboo)

continue;

if (NULL != n->child)

putmdockey(mpage, n->child, m, taboo);

putmdockey(mpage, n->child, m);

if (n->type == ROFFT_TEXT)

putkey(mpage, n->string, m);

}

Line 1642 parse_mdoc(struct mpage *mpage, const struct roff_meta

Line 1506 parse_mdoc(struct mpage *mpage, const struct roff_meta

assert(NULL != n);

for (n = n->child; NULL != n; n = n->next) {

if (n->flags & mdocs[n->tok].taboo)

continue;

switch (n->type) {

case ROFFT_ELEM:

case ROFFT_BLOCK:

Line 1655 parse_mdoc(struct mpage *mpage, const struct roff_meta

Line 1517 parse_mdoc(struct mpage *mpage, const struct roff_meta

break;

if (mdocs[n->tok].mask)

putmdockey(mpage, n->child,

mdocs[n->tok].mask, mdocs[n->tok].taboo);

mdocs[n->tok].mask);

break;

default:

assert(n->type != ROFFT_ROOT);

Line 1823 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

Line 1685 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

{

if (SEC_NAME == n->sec)

putmdockey(mpage, n->child, NAME_TITLE, 0);

putmdockey(mpage, n->child, NAME_TITLE);

else if (n->sec == SEC_SYNOPSIS && n->type == ROFFT_HEAD) {

if (n->child == NULL)

putkey(mpage, meta->name, NAME_SYN);

else

putmdockey(mpage, n->child, NAME_SYN, 0);

putmdockey(mpage, n->child, NAME_SYN);

}

if ( ! (mpage->name_head_done ||

n->child == NULL || n->child->string == NULL ||

strcasecmp(n->child->string, meta->title))) {

putkey(mpage, n->child->string, NAME_HEAD);

putkey(mpage, n->child->string, ROFFT_HEAD);

mpage->name_head_done = 1;

}

return 0;

Line 1881 putkeys(const struct mpage *mpage, char *cp, size_t sz

Line 1743 putkeys(const struct mpage *mpage, char *cp, size_t sz

name_mask &= ~NAME_FIRST;

if (debug > 1)

say(mpage->mlinks->file,

"Adding name %*s, bits=0x%llx", (int)sz, cp,

"Adding name %*s, bits=0x%llu", (int)sz, cp, v);

(unsigned long long)v);

} else {

htab = &strings;

if (debug > 1)

for (i = 0; i < mansearch_keymax; i++)

for (i = 0; i < KEY_MAX; i++)

if ((uint64_t)1 << i & v)

say(mpage->mlinks->file,

"Adding key %s=%*s",

Line 2092 render_string(char **public, size_t *psz)

Line 1953 render_string(char **public, size_t *psz)

static void

dbadd_mlink(const struct mlink *mlink)

{

size_t i;

dba_page_alias(mlink->mpage->dba, mlink->name, NAME_FILE);

dba_page_add(mlink->mpage->dba, DBP_SECT, mlink->dsec);

i = 1;

dba_page_add(mlink->mpage->dba, DBP_ARCH, mlink->arch);

SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->dsec);

dba_page_add(mlink->mpage->dba, DBP_FILE, mlink->file);

SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->arch);

SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->name);

SQL_BIND_INT64(stmts[STMT_INSERT_LINK], i, mlink->mpage->pageid);

SQL_STEP(stmts[STMT_INSERT_LINK]);

sqlite3_reset(stmts[STMT_INSERT_LINK]);

}

static void

dbadd_mlink_name(const struct mlink *mlink)

{

uint64_t bits;

size_t i;

dbadd_mlink(mlink);

i = 1;

SQL_BIND_INT64(stmts[STMT_SELECT_NAME], i, mlink->mpage->pageid);

bits = NAME_FILE & NAME_MASK;

if (sqlite3_step(stmts[STMT_SELECT_NAME]) == SQLITE_ROW) {

bits |= sqlite3_column_int64(stmts[STMT_SELECT_NAME], 0);

sqlite3_reset(stmts[STMT_SELECT_NAME]);

}

i = 1;

SQL_BIND_INT64(stmts[STMT_INSERT_NAME], i, bits);

SQL_BIND_TEXT(stmts[STMT_INSERT_NAME], i, mlink->name);

SQL_BIND_INT64(stmts[STMT_INSERT_NAME], i, mlink->mpage->pageid);

SQL_STEP(stmts[STMT_INSERT_NAME]);

sqlite3_reset(stmts[STMT_INSERT_NAME]);

}

* Flush the current page's terms (and their bits) into the database.

* Wrap the entire set of additions in a transaction to make sqlite be a

* little faster.

* Also, handle escape sequences at the last possible moment.

static void

dbadd(struct mpage *mpage)

dbadd(struct dba *dba, struct mpage *mpage)

{

struct mlink *mlink;

struct str *key;

char *cp;

uint64_t mask;

size_t i;

unsigned int slot;

int mustfree;

Line 2183 dbadd(struct mpage *mpage)

Line 2014 dbadd(struct mpage *mpage)

cp = mpage->desc;

i = strlen(cp);

mustfree = render_string(&cp, &i);

i = 1;

mpage->dba = dba_page_new(dba->pages, mlink->name,

SQL_BIND_TEXT(stmts[STMT_INSERT_PAGE], i, cp);

mlink->dsec, mlink->arch, cp, mlink->file, mpage->form);

SQL_BIND_INT(stmts[STMT_INSERT_PAGE], i, mpage->form);

SQL_STEP(stmts[STMT_INSERT_PAGE]);

mpage->pageid = sqlite3_last_insert_rowid(db);

sqlite3_reset(stmts[STMT_INSERT_PAGE]);

if (mustfree)

free(cp);

while (NULL != mlink) {

while ((mlink = mlink->next) != NULL)

dbadd_mlink(mlink);

mlink = mlink->next;

}

mlink = mpage->mlinks;

for (key = ohash_first(&names, &slot); NULL != key;

key = ohash_next(&names, &slot)) {

assert(key->mpage == mpage);

i = 1;

dba_page_alias(mpage->dba, key->key, key->mask);

SQL_BIND_INT64(stmts[STMT_INSERT_NAME], i, key->mask);

SQL_BIND_TEXT(stmts[STMT_INSERT_NAME], i, key->key);

SQL_BIND_INT64(stmts[STMT_INSERT_NAME], i, mpage->pageid);

SQL_STEP(stmts[STMT_INSERT_NAME]);

sqlite3_reset(stmts[STMT_INSERT_NAME]);

free(key);

}

for (key = ohash_first(&strings, &slot); NULL != key;

key = ohash_next(&strings, &slot)) {

assert(key->mpage == mpage);

i = 1;

i = 0;

SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, key->mask);

for (mask = TYPE_Xr; mask <= TYPE_Lb; mask *= 2) {

SQL_BIND_TEXT(stmts[STMT_INSERT_KEY], i, key->key);

if (key->mask & mask)

SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, mpage->pageid);

dba_macro_add(dba->macros, i,

SQL_STEP(stmts[STMT_INSERT_KEY]);

key->key, mpage->dba);

sqlite3_reset(stmts[STMT_INSERT_KEY]);

i++;

}

free(key);

}

static void

dbprune(void)

dbprune(struct dba *dba)

{

struct mpage *mpage;

struct dba_array *page, *files;

struct mlink *mlink;

char *file;

size_t i;

unsigned int slot;

if (0 == nodb)

dba_array_FOREACH(dba->pages, page) {

SQL_EXEC("BEGIN TRANSACTION");

files = dba_array_get(page, DBP_FILE);

dba_array_FOREACH(files, file) {

for (mpage = ohash_first(&mpages, &slot); NULL != mpage;

if (*file < ' ')

mpage = ohash_next(&mpages, &slot)) {

file++;

mlink = mpage->mlinks;

if (ohash_find(&mlinks, ohash_qlookup(&mlinks,

if (debug)

file)) != NULL) {

say(mlink->file, "Deleting from database");

if (debug)

if (nodb)

say(file, "Deleting from database");

continue;

dba_array_del(dba->pages);

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

break;

i = 1;

}

SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],

i, mlink->dsec);

SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],

i, mlink->arch);

SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],

i, mlink->name);

SQL_STEP(stmts[STMT_DELETE_PAGE]);

sqlite3_reset(stmts[STMT_DELETE_PAGE]);

}

if (0 == nodb)

SQL_EXEC("END TRANSACTION");

}

* Close an existing database and its prepared statements.

* Write the database from memory to disk.

* If "real" is not set, rename the temporary file into the real one.

static void

dbclose(int real)

dbwrite(struct dba *dba)

{

size_t i;

char tfn[32];

int status;

pid_t child;

if (nodb)

if (dba_write(MANDOC_DB "~", dba) != -1) {

if (rename(MANDOC_DB "~", MANDOC_DB) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "&rename");

unlink(MANDOC_DB "~");

}

return;

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

sqlite3_finalize(stmts[i]);

stmts[i] = NULL;

}

sqlite3_close(db);

(void)strlcpy(tfn, "/tmp/mandocdb.XXXXXXXX", sizeof(tfn));

db = NULL;

if (mkdtemp(tfn) == NULL) {

exitcode = (int)MANDOCLEVEL_SYSERR;

if (real)

say("", "&%s", tfn);

return;

}

if ('\0' == *tempfilename) {

(void)strlcat(tfn, "/" MANDOC_DB, sizeof(tfn));

if (-1 == rename(MANDOC_DB "~", MANDOC_DB)) {

if (dba_write(tfn, dba) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "&rename");

say(tfn, "&dba_write");

}

goto out;

return;

}

switch (child = fork()) {

Line 2296 dbclose(int real)

Line 2103 dbclose(int real)

say("", "&fork cmp");

return;

case 0:

execlp("cmp", "cmp", "-s",

execlp("cmp", "cmp", "-s", tfn, MANDOC_DB, (char *)NULL);

tempfilename, MANDOC_DB, (char *)NULL);

say("", "&exec cmp");

exit(0);

default:

break;

}

if (-1 == waitpid(child, &status, 0)) {

if (waitpid(child, &status, 0) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&wait cmp");

} else if (WIFSIGNALED(status)) {

Line 2315 dbclose(int real)

Line 2121 dbclose(int real)

"Data changed, but cannot replace database");

}

*strrchr(tempfilename, '/') = '\0';

out:

*strrchr(tfn, '/') = '\0';

switch (child = fork()) {

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fork rm");

return;

case 0:

execlp("rm", "rm", "-rf", tempfilename, (char *)NULL);

execlp("rm", "rm", "-rf", tfn, (char *)NULL);

say("", "&exec rm");

exit((int)MANDOCLEVEL_SYSERR);

default:

break;

}

if (-1 == waitpid(child, &status, 0)) {

if (waitpid(child, &status, 0) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&wait rm");

} else if (WIFSIGNALED(status) || WEXITSTATUS(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "%s: Cannot remove temporary directory",

say("", "%s: Cannot remove temporary directory", tfn);

tempfilename);

}

* This is straightforward stuff.

* Open a database connection to a "temporary" database, then open a set

* of prepared statements we'll use over and over again.

* If "real" is set, we use the existing database; if not, we truncate a

* temporary one.

* Must be matched by dbclose().

static int

dbopen(int real)

{

const char *sql;

int rc, ofl;

if (nodb)

return 1;

*tempfilename = '\0';

ofl = SQLITE_OPEN_READWRITE;

if (real) {

rc = sqlite3_open_v2(MANDOC_DB, &db, ofl, NULL);

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

if (SQLITE_CANTOPEN != rc)

say(MANDOC_DB, "%s", sqlite3_errstr(rc));

return 0;

}

goto prepare_statements;

}

ofl |= SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE;

remove(MANDOC_DB "~");

rc = sqlite3_open_v2(MANDOC_DB "~", &db, ofl, NULL);

if (SQLITE_OK == rc)

goto create_tables;

if (MPARSE_QUICK & mparse_options) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB "~", "%s", sqlite3_errstr(rc));

return 0;

}

(void)strlcpy(tempfilename, "/tmp/mandocdb.XXXXXX",

sizeof(tempfilename));

if (NULL == mkdtemp(tempfilename)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&%s", tempfilename);

return 0;

}

(void)strlcat(tempfilename, "/" MANDOC_DB,

sizeof(tempfilename));

rc = sqlite3_open_v2(tempfilename, &db, ofl, NULL);

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "%s: %s", tempfilename, sqlite3_errstr(rc));

return 0;

}

create_tables:

sql = "CREATE TABLE \"mpages\" (\n"

" \"desc\" TEXT NOT NULL,\n"

" \"form\" INTEGER NOT NULL,\n"

" \"pageid\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL\n"

");\n"

"\n"

"CREATE TABLE \"mlinks\" (\n"

" \"sec\" TEXT NOT NULL,\n"

" \"arch\" TEXT NOT NULL,\n"

" \"name\" TEXT NOT NULL,\n"

" \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) "

"ON DELETE CASCADE\n"

");\n"

"CREATE INDEX mlinks_pageid_idx ON mlinks (pageid);\n"

"\n"

"CREATE TABLE \"names\" (\n"

" \"bits\" INTEGER NOT NULL,\n"

" \"name\" TEXT NOT NULL,\n"

" \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) "

"ON DELETE CASCADE,\n"

" UNIQUE (\"name\", \"pageid\") ON CONFLICT REPLACE\n"

");\n"

"\n"

"CREATE TABLE \"keys\" (\n"

" \"bits\" INTEGER NOT NULL,\n"

" \"key\" TEXT NOT NULL,\n"

" \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) "

"ON DELETE CASCADE\n"

");\n"

"CREATE INDEX keys_pageid_idx ON keys (pageid);\n";

if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, NULL)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "%s", sqlite3_errmsg(db));

sqlite3_close(db);

return 0;

}

prepare_statements:

if (SQLITE_OK != sqlite3_exec(db,

"PRAGMA foreign_keys = ON", NULL, NULL, NULL)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "PRAGMA foreign_keys: %s",

sqlite3_errmsg(db));

sqlite3_close(db);

return 0;

}

sql = "DELETE FROM mpages WHERE pageid IN "

"(SELECT pageid FROM mlinks WHERE "

"sec=? AND arch=? AND name=?)";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_DELETE_PAGE], NULL);

sql = "INSERT INTO mpages "

"(desc,form) VALUES (?,?)";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_PAGE], NULL);

sql = "INSERT INTO mlinks "

"(sec,arch,name,pageid) VALUES (?,?,?,?)";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_LINK], NULL);

sql = "SELECT bits FROM names where pageid = ?";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_SELECT_NAME], NULL);

sql = "INSERT INTO names "

"(bits,name,pageid) VALUES (?,?,?)";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_NAME], NULL);

sql = "INSERT INTO keys "

"(bits,key,pageid) VALUES (?,?,?)";

sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_KEY], NULL);

#ifndef __APPLE__

* When opening a new database, we can turn off

* synchronous mode for much better performance.

if (real && SQLITE_OK != sqlite3_exec(db,

"PRAGMA synchronous = OFF", NULL, NULL, NULL)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "PRAGMA synchronous: %s",

sqlite3_errmsg(db));

sqlite3_close(db);

return 0;

}

#endif

return 1;

}

static int

CVSweb