mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.93 and 1.116

version 1.93, 2014/01/02 18:52:15

version 1.116, 2014/03/19 21:51:20

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 20

#endif

#include <sys/stat.h>

#include <sys/wait.h>

#include <assert.h>

#include <ctype.h>

Line 48

Line 49

#include "manpath.h"

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

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

Line 82 enum form {

Line 86 enum form {

};

struct str {

char *utf8; /* key in UTF-8 form */

char *rendered; /* key in UTF-8 or ASCII form */

const struct mpage *mpage; /* if set, the owning parse */

uint64_t mask; /* bitmask in sequence */

char key[]; /* the string itself */

char key[]; /* may contain escape sequences */

};

struct inodev {

Line 114 struct mlink {

Line 118 struct mlink {

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

};

struct title {

char *title; /* name(sec/arch) given inside the file */

char *file; /* file name in case of mismatch */

};

enum stmt {

STMT_DELETE_PAGE = 0, /* delete mpage */

STMT_INSERT_PAGE, /* insert mpage */

Line 135 struct mdoc_handler {

Line 134 struct mdoc_handler {

};

static void dbclose(int);

static void dbindex(const struct mpage *, struct mchars *);

static void dbadd(const struct mpage *, struct mchars *);

static int dbopen(int);

static void dbprune(void);

static void filescan(const char *);

Line 147 static int mlink_check(struct mpage *, struct mlink *

Line 146 static int 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 mchars *, struct mparse *, int);

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

static void parse_cat(struct mpage *);

static void parse_man(struct mpage *, const struct man_node *);

static void parse_mdoc(struct mpage *, const struct mdoc_node *);

Line 159 static int parse_mdoc_Nd(struct mpage *, const struct

Line 158 static int parse_mdoc_Nd(struct mpage *, const struct

static int parse_mdoc_Nm(struct mpage *, const struct mdoc_node *);

static int parse_mdoc_Sh(struct mpage *, const struct mdoc_node *);

static int parse_mdoc_Xr(struct mpage *, const struct mdoc_node *);

static void putkey(const struct mpage *,

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

const char *, uint64_t);

static void putkeys(const struct mpage *,

const char *, size_t, uint64_t);

static void putmdockey(const struct mpage *,

const struct mdoc_node *, uint64_t);

static void render_key(struct mchars *, struct str *);

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

static int set_basedir(const char *);

static int treescan(void);

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

static void utf8key(struct mchars *, struct str *);

static char tempfilename[32];

static char *progname;

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

static int nodb; /* no database changes */

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

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

static int verb; /* print what we're doing */

static int warnings; /* warn about crap */

static int write_utf8; /* write UTF-8 output; else ASCII */

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

static enum op op; /* operational mode */

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

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

Line 351 main(int argc, char *argv[])

path_arg = NULL;

op = OP_DEFAULT;

mparse_options = MPARSE_SO;

while (-1 != (ch = getopt(argc, argv, "aC:d:ntu:vW")))

while (-1 != (ch = getopt(argc, argv, "aC:d:nQT:tu:vW")))

switch (ch) {

case ('a'):

use_all = 1;

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

Line 371 main(int argc, char *argv[])

case ('n'):

nodb = 1;

break;

case ('Q'):

mparse_options |= MPARSE_QUICK;

break;

case ('T'):

if (strcmp(optarg, "utf8")) {

fprintf(stderr, "-T%s: Unsupported "

"output format\n", optarg);

goto usage;

}

write_utf8 = 1;

break;

case ('t'):

CHECKOP(op, ch);

dup2(STDOUT_FILENO, STDERR_FILENO);

Line 399 main(int argc, char *argv[])

Line 412 main(int argc, char *argv[])

}

exitcode = (int)MANDOCLEVEL_OK;

mp = mparse_alloc(MPARSE_AUTO,

mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL, NULL);

MANDOCLEVEL_FATAL, NULL, NULL, NULL);

mc = mchars_alloc();

ohash_init(&mpages, 6, &mpages_info);

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

Line 438 main(int argc, char *argv[])

if (OP_TEST != op)

dbprune();

if (OP_DELETE != op)

mpages_merge(mc, mp, 0);

mpages_merge(mc, mp);

dbclose(1);

} else {

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

Line 482 main(int argc, char *argv[])

if (0 == dbopen(0))

goto out;

mpages_merge(mc, mp, warnings && !use_all);

mpages_merge(mc, mp);

dbclose(0);

if (j + 1 < dirs.sz) {

Line 490 out:

Line 502 out:

ohash_delete(&mlinks);

return(exitcode);

usage:

fprintf(stderr, "usage: %s [-anvW] [-C file]\n"

fprintf(stderr, "usage: %s [-anQvW] [-C file] [-Tutf8]\n"

" %s [-anvW] dir ...\n"

" %s [-anQvW] [-Tutf8] dir ...\n"

" %s [-nvW] -d dir [file ...]\n"

" %s [-nQvW] [-Tutf8] -d dir [file ...]\n"

" %s [-nvW] -u dir [file ...]\n"

" %s -t file ...\n",

" %s [-Q] -t file ...\n",

progname, progname, progname,

progname, progname);

Line 522 treescan(void)

Line 534 treescan(void)

FTSENT *ff;

struct mlink *mlink;

int dform;

char *fsec;

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

const char *dsec, *arch, *cp, *path;

const char *path;

const char *argv[2];

argv[0] = ".";

Line 588 treescan(void)

Line 600 treescan(void)

continue;

} else

fsec[-1] = '\0';

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

strlcpy(mlink->file, path, sizeof(mlink->file));

mlink->dform = dform;

if (NULL != dsec)

mlink->dsec = dsec;

mlink->dsec = mandoc_strdup(dsec);

mlink->arch = arch;

if (NULL != arch)

mlink->name = ff->fts_name;

mlink->arch = mandoc_strdup(arch);

mlink->fsec = fsec;

mlink->name = mandoc_strdup(ff->fts_name);

if (NULL != fsec)

mlink->fsec = mandoc_strdup(fsec);

mlink_add(mlink, ff->fts_statp);

continue;

} else if (FTS_D != ff->fts_info &&

Line 617 treescan(void)

Line 627 treescan(void)

* Try to infer this from the name.

* If we're not in use_all, enforce it.

dsec = NULL;

dform = FORM_NONE;

cp = ff->fts_name;

if (FTS_DP == ff->fts_info)

break;

Line 629 treescan(void)

Line 637 treescan(void)

} else if (0 == strncmp(cp, "cat", 3)) {

dform = FORM_CAT;

dsec = cp + 3;

} else {

dform = FORM_NONE;

dsec = NULL;

}

if (NULL != dsec || use_all)

Line 643 treescan(void)

Line 654 treescan(void)

* Possibly our architecture.

* If we're descending, keep tabs on it.

arch = NULL;

if (FTS_DP != ff->fts_info && NULL != dsec)

arch = ff->fts_name;

else

arch = NULL;

break;

default:

if (FTS_DP == ff->fts_info || use_all)

Line 692 filescan(const char *file)

Line 704 filescan(const char *file)

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, NULL);

return;

} else if (OP_TEST != op && strstr(buf, basedir) != buf) {

}

if (strstr(buf, basedir) == buf)

start = buf + strlen(basedir) + 1;

else if (OP_TEST == op)

start = buf;

else {

exitcode = (int)MANDOCLEVEL_BADARG;

say("", "%s: outside base directory", buf);

return;

} else if (-1 == stat(buf, &st)) {

}

if (-1 == stat(buf, &st)) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, NULL);

return;

Line 705 filescan(const char *file)

Line 725 filescan(const char *file)

say(file, "Not a regular file");

return;

}

start = buf + strlen(basedir);

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

strlcpy(mlink->file, start, sizeof(mlink->file));

Line 719 filescan(const char *file)

Line 739 filescan(const char *file)

*p++ = '\0';

if (0 == strncmp(start, "man", 3)) {

mlink->dform = FORM_SRC;

mlink->dsec = mandoc_strdup(start + 3);

mlink->dsec = start + 3;

} else if (0 == strncmp(start, "cat", 3)) {

mlink->dform = FORM_CAT;

mlink->dsec = mandoc_strdup(start + 3);

mlink->dsec = start + 3;

}

start = p;

if (NULL != mlink->dsec && NULL != (p = strchr(start, '/'))) {

*p++ = '\0';

mlink->arch = mandoc_strdup(start);

mlink->arch = start;

start = p;

}

Line 743 filescan(const char *file)

Line 763 filescan(const char *file)

if ('.' == *p) {

*p++ = '\0';

mlink->fsec = mandoc_strdup(p);

mlink->fsec = p;

}

Line 755 filescan(const char *file)

Line 775 filescan(const char *file)

mlink->name = p + 1;

*p = '\0';

}

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

mlink_add(mlink, &st);

}

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

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

assert(NULL != mlink->file);

if (NULL == mlink->dsec)

mlink->dsec = mandoc_strdup(mlink->dsec ? mlink->dsec : "");

mlink->dsec = mandoc_strdup("");

mlink->arch = mandoc_strdup(mlink->arch ? mlink->arch : "");

if (NULL == mlink->arch)

mlink->name = mandoc_strdup(mlink->name ? mlink->name : "");

mlink->arch = mandoc_strdup("");

mlink->fsec = mandoc_strdup(mlink->fsec ? mlink->fsec : "");

if (NULL == mlink->name)

mlink->name = mandoc_strdup("");

if (NULL == mlink->fsec)

mlink->fsec = mandoc_strdup("");

if ('0' == *mlink->fsec) {

free(mlink->fsec);

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

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

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

static void

mpages_merge(struct mchars *mc, struct mparse *mp, int check_reachable)

mpages_merge(struct mchars *mc, struct mparse *mp)

{

struct ohash title_table;

char any[] = "any";

struct ohash_info title_info, str_info;

struct ohash_info str_info;

struct mpage *mpage;

struct mlink *mlink;

struct mdoc *mdoc;

struct man *man;

struct title *title_entry;

char *cp;

char *title_str;

const char *cp;

int match;

unsigned int pslot, tslot;

unsigned int pslot;

enum mandoclevel lvl;

str_info.alloc = hash_alloc;

Line 962 mpages_merge(struct mchars *mc, struct mparse *mp, int

Line 974 mpages_merge(struct mchars *mc, struct mparse *mp, int

str_info.hfree = hash_free;

str_info.key_offset = offsetof(struct str, key);

if (check_reachable) {

if (0 == nodb)

title_info.alloc = hash_alloc;

SQL_EXEC("BEGIN TRANSACTION");

title_info.halloc = hash_halloc;

title_info.hfree = hash_free;

title_info.key_offset = offsetof(struct title, title);

ohash_init(&title_table, 6, &title_info);

}

mpage = ohash_first(&mpages, &pslot);

while (NULL != mpage) {

Line 1021 mpages_merge(struct mchars *mc, struct mparse *mp, int

Line 1028 mpages_merge(struct mchars *mc, struct mparse *mp, int

mpage->title =

mandoc_strdup(mpage->mlinks->name);

}

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

putkey(mpage, '\0' == *mpage->arch ?

any : mpage->arch, TYPE_arch);

for (mlink = mpage->mlinks; mlink; mlink = mlink->next)

for (mlink = mpage->mlinks; mlink; mlink = mlink->next) {

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

putkey(mpage, mlink->dsec, TYPE_sec);

if ('\0' != *mlink->fsec)

putkey(mpage, mlink->fsec, TYPE_sec);

putkey(mpage, '\0' == *mlink->arch ?

any : mlink->arch, TYPE_arch);

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

}

if (warnings && !use_all) {

match = 0;

Line 1046 mpages_merge(struct mchars *mc, struct mparse *mp, int

Line 1063 mpages_merge(struct mchars *mc, struct mparse *mp, int

else

parse_cat(mpage);

dbadd(mpage, mc);

* Build a title string for the file. If it matches

* the location of the file, remember the title as

* found; else, remember it as missing.

if (check_reachable) {

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

mpage->title, mpage->sec,

'\0' == *mpage->arch ? "" : "/",

mpage->arch)) {

perror(NULL);

exit((int)MANDOCLEVEL_SYSERR);

}

tslot = ohash_qlookup(&title_table, title_str);

title_entry = ohash_find(&title_table, tslot);

if (NULL == title_entry) {

title_entry = mandoc_malloc(

sizeof(struct title));

title_entry->title = title_str;

title_entry->file = mandoc_strdup(

match ? "" : mpage->mlinks->file);

ohash_insert(&title_table, tslot,

title_entry);

} else {

if (match)

*title_entry->file = '\0';

free(title_str);

}

dbindex(mpage, mc);

ohash_delete(&strings);

mpage = ohash_next(&mpages, &pslot);

}

if (check_reachable) {

if (0 == nodb)

title_entry = ohash_first(&title_table, &tslot);

SQL_EXEC("END TRANSACTION");

while (NULL != title_entry) {

if ('\0' != *title_entry->file)

say(title_entry->file,

"Probably unreachable, title is %s",

title_entry->title);

free(title_entry->title);

free(title_entry->file);

free(title_entry);

title_entry = ohash_next(&title_table, &tslot);

}

ohash_delete(&title_table);

}

static void

Line 1214 parse_cat(struct mpage *mpage)

Line 1188 parse_cat(struct mpage *mpage)

* Put a type/word pair into the word database for this particular file.

static void

putkey(const struct mpage *mpage, const char *value, uint64_t type)

putkey(const struct mpage *mpage, char *value, uint64_t type)

{

char *cp;

assert(NULL != value);

if (TYPE_arch == type)

for (cp = value; *cp; cp++)

if (isupper((unsigned char)*cp))

*cp = _tolower((unsigned char)*cp);

putkeys(mpage, value, strlen(value), type);

}

Line 1333 parse_man(struct mpage *mpage, const struct man_node *

Line 1312 parse_man(struct mpage *mpage, const struct man_node *

byte = start[sz];

start[sz] = '\0';

* Assume a stray trailing comma in the

* name list if a name begins with a dash.

if ('-' == start[0] ||

('\\' == start[0] && '-' == start[1]))

break;

putkey(mpage, start, TYPE_Nm);

if (' ' == byte) {

Line 1462 parse_mdoc_Fd(struct mpage *mpage, const struct mdoc_n

Line 1450 parse_mdoc_Fd(struct mpage *mpage, const struct mdoc_n

static int

parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_node *n)

{

const char *cp;

char *cp;

if (NULL == (n = n->child) || MDOC_TEXT != n->type)

return(0);

Line 1584 putkeys(const struct mpage *mpage,

Line 1572 putkeys(const struct mpage *mpage,

const char *cp, size_t sz, uint64_t v)

{

struct str *s;

unsigned int slot;

const char *end;

uint64_t mask;

unsigned int slot;

int i;

if (0 == sz)

return;

if (verb > 1) {

for (i = 0, mask = 1;

i < mansearch_keymax;

i++, mask <<= 1)

if (mask & v)

break;

say(mpage->mlinks->file, "Adding key %s=%*s",

mansearch_keynames[i], sz, cp);

}

end = cp + sz;

slot = ohash_qlookupi(&strings, cp, &end);

s = ohash_find(&strings, slot);

Line 1659 utf8(unsigned int cp, char out[7])

}

* Store the UTF-8 version of a key, or alias the pointer if the key has

* Store the rendered version of a key, or alias the pointer

* no UTF-8 transcription marks in it.

* if the key contains no escape sequences.

static void

utf8key(struct mchars *mc, struct str *key)

render_key(struct mchars *mc, struct str *key)

{

size_t sz, bsz, pos;

char utfbuf[7], res[5];

char utfbuf[7], res[6];

char *buf;

const char *seq, *cpp, *val;

int len, u;

enum mandoc_esc esc;

assert(NULL == key->utf8);

assert(NULL == key->rendered);

res[0] = '\\';

res[1] = '\t';

res[2] = ASCII_NBRSP;

res[3] = ASCII_HYPH;

res[4] = '\0';

res[4] = ASCII_BREAK;

res[5] = '\0';

val = key->key;

bsz = strlen(val);

Line 1688 utf8key(struct mchars *mc, struct str *key)

Line 1689 utf8key(struct mchars *mc, struct str *key)

* pointer as ourselvse and get out of here.

if (strcspn(val, res) == bsz) {

key->utf8 = key->key;

key->rendered = key->key;

return;

}

Line 1709 utf8key(struct mchars *mc, struct str *key)

Line 1710 utf8key(struct mchars *mc, struct str *key)

val += sz;

}

if (ASCII_HYPH == *val) {

switch (*val) {

case (ASCII_HYPH):

buf[pos++] = '-';

val++;

continue;

} else if ('\t' == *val || ASCII_NBRSP == *val) {

case ('\t'):

/* FALLTHROUGH */

case (ASCII_NBRSP):

buf[pos++] = ' ';

val++;

/* FALLTHROUGH */

case (ASCII_BREAK):

continue;

} else if ('\\' != *val)

default:

break;

}

if ('\\' != *val)

break;

/* Read past the slash. */

Line 1728 utf8key(struct mchars *mc, struct str *key)

Line 1737 utf8key(struct mchars *mc, struct str *key)

* Parse the escape sequence and see if it's a

* predefined character or special character.

esc = mandoc_escape

((const char **)&val, &seq, &len);

if (ESCAPE_ERROR == esc)

break;

if (ESCAPE_SPECIAL != esc)

continue;

if (0 == (u = mchars_spec2cp(mc, seq, len)))

continue;

* If we have a Unicode codepoint, try to convert that

* Render the special character

* to a UTF-8 byte string.

* as either UTF-8 or ASCII.

cpp = utfbuf;

if (0 == (sz = utf8(u, utfbuf)))

continue;

if (write_utf8) {

if (0 == (u = mchars_spec2cp(mc, seq, len)))

continue;

cpp = utfbuf;

if (0 == (sz = utf8(u, utfbuf)))

continue;

sz = strlen(cpp);

} else {

cpp = mchars_spec2str(mc, seq, len, &sz);

if (NULL == cpp)

continue;

if (ASCII_NBRSP == *cpp) {

cpp = " ";

sz = 1;

}

/* Copy the rendered glyph into the stream. */

sz = strlen(cpp);

bsz += sz;

buf = mandoc_realloc(buf, bsz);

memcpy(&buf[pos], cpp, sz);

pos += sz;

}

buf[pos] = '\0';

key->utf8 = buf;

key->rendered = buf;

}

* 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, UTF-8-encode the description at the last possible moment.

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

static void

dbindex(const struct mpage *mpage, struct mchars *mc)

dbadd(const struct mpage *mpage, struct mchars *mc)

{

struct mlink *mlink;

struct str *key;

const char *desc;

int64_t recno;

size_t i;

unsigned int slot;

if (verb)

say(mpage->mlinks->file, "Adding to index");

say(mpage->mlinks->file, "Adding to database");

if (nodb)

return;

desc = "";

if (NULL != mpage->desc && '\0' != *mpage->desc) {

key = ohash_find(&strings,

ohash_qlookup(&strings, mpage->desc));

assert(NULL != key);

if (NULL == key->utf8)

utf8key(mc, key);

desc = key->utf8;

}

SQL_EXEC("BEGIN TRANSACTION");

i = 1;

* XXX The following three lines are obsolete

* and only kept for backward compatibility

* until apropos(1) and friends have caught up.

SQL_BIND_TEXT(stmts[STMT_INSERT_PAGE], i, mpage->mlinks->file);

SQL_BIND_TEXT(stmts[STMT_INSERT_PAGE], i, mpage->mlinks->dsec);

SQL_BIND_TEXT(stmts[STMT_INSERT_PAGE], i, mpage->mlinks->arch);

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

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

SQL_STEP(stmts[STMT_INSERT_PAGE]);

recno = sqlite3_last_insert_rowid(db);

Line 1812 dbindex(const struct mpage *mpage, struct mchars *mc)

Line 1808 dbindex(const struct mpage *mpage, struct mchars *mc)

for (mlink = mpage->mlinks; mlink; mlink = mlink->next) {

i = 1;

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

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

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

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

Line 1824 dbindex(const struct mpage *mpage, struct mchars *mc)

Line 1819 dbindex(const struct mpage *mpage, struct mchars *mc)

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

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

assert(key->mpage == mpage);

if (NULL == key->utf8)

if (NULL == key->rendered)

utf8key(mc, key);

render_key(mc, key);

i = 1;

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

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

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

SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, recno);

SQL_STEP(stmts[STMT_INSERT_KEY]);

sqlite3_reset(stmts[STMT_INSERT_KEY]);

if (key->utf8 != key->key)

if (key->rendered != key->key)

free(key->utf8);

free(key->rendered);

free(key);

}

SQL_EXEC("END TRANSACTION");

}

static void

Line 1848 dbprune(void)

Line 1841 dbprune(void)

size_t i;

unsigned int slot;

if (nodb)

if (0 == nodb)

return;

SQL_EXEC("BEGIN TRANSACTION");

mpage = ohash_first(&mpages, &slot);

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

while (NULL != mpage) {

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

mlink = mpage->mlinks;

i = 1;

SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE], i, mlink->file);

SQL_STEP(stmts[STMT_DELETE_PAGE]);

sqlite3_reset(stmts[STMT_DELETE_PAGE]);

if (verb)

say(mlink->file, "Deleted from index");

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

mpage = ohash_next(&mpages, &slot);

if (nodb)

continue;

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

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

}

Line 1872 static void

Line 1876 static void

dbclose(int real)

{

size_t i;

int status;

pid_t child;

if (nodb)

return;

Line 1887 dbclose(int real)

Line 1893 dbclose(int real)

if (real)

return;

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

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

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

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "%s", strerror(errno));

}

return;

}

switch (child = fork()) {

case (-1):

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, NULL);

say("fork cmp", "%s", strerror(errno));

return;

case (0):

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

tempfilename, MANDOC_DB, NULL);

say("exec cmp", "%s", strerror(errno));

exit(0);

default:

break;

}

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

exitcode = (int)MANDOCLEVEL_SYSERR;

say("wait cmp", "%s", strerror(errno));

} else if (WIFSIGNALED(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("cmp", "Died from a signal");

} else if (WEXITSTATUS(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB,

"Data changed, but cannot replace database");

}

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

switch (child = fork()) {

case (-1):

exitcode = (int)MANDOCLEVEL_SYSERR;

say("fork rm", "%s", strerror(errno));

return;

case (0):

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

say("exec rm", "%s", strerror(errno));

exit((int)MANDOCLEVEL_SYSERR);

default:

break;

}

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

exitcode = (int)MANDOCLEVEL_SYSERR;

say("wait rm", "%s", strerror(errno));

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

exitcode = (int)MANDOCLEVEL_SYSERR;

say(tempfilename,

"Cannot remove temporary directory");

}

Line 1904 dbclose(int real)

Line 1960 dbclose(int real)

static int

dbopen(int real)

{

const char *file, *sql;

const char *sql;

int rc, ofl;

if (nodb)

return(1);

*tempfilename = '\0';

ofl = SQLITE_OPEN_READWRITE;

if (0 == real) {

file = MANDOC_DB "~";

if (real) {

if (-1 == remove(file) && ENOENT != errno) {

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

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(file, NULL);

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

return(0);

}

ofl |= SQLITE_OPEN_EXCLUSIVE;

goto prepare_statements;

} else

}

file = MANDOC_DB;

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

ofl |= SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE;

remove(MANDOC_DB "~");

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

if (SQLITE_OK == rc)

goto prepare_statements;

goto create_tables;

if (SQLITE_CANTOPEN != rc) {

if (MPARSE_QUICK & mparse_options) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(file, NULL);

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

return(0);

}

sqlite3_close(db);

if (strlcpy(tempfilename, "/tmp/mandocdb.XXXXXX",

db = NULL;

sizeof(tempfilename)) >= sizeof(tempfilename)) {

if (SQLITE_OK != (rc = sqlite3_open(file, &db))) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(file, NULL);

say("/tmp/mandocdb.XXXXXX", "Filename too long");

return(0);

}

if (NULL == mkdtemp(tempfilename)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(tempfilename, "%s", strerror(errno));

return(0);

}

if (strlcat(tempfilename, "/" MANDOC_DB,

sizeof(tempfilename)) >= sizeof(tempfilename)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(tempfilename, "Filename too long");

return(0);

}

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

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return(0);

}

create_tables:

* XXX The first three columns in table mpages are obsolete

* and only kept for backward compatibility

* until apropos(1) and friends have caught up.

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

" \"file\" TEXT NOT NULL,\n"

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

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

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

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

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

");\n"

"\n"

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

" \"file\" TEXT NOT NULL,\n"

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

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

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

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

"ON DELETE CASCADE,\n"

"ON DELETE CASCADE\n"

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

");\n"

"\n"

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

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

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

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

"ON DELETE CASCADE,\n"

"ON DELETE CASCADE\n"

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

");\n";

");\n"

"\n"

"CREATE INDEX \"key_index\" ON keys (key);\n";

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

exitcode = (int)MANDOCLEVEL_SYSERR;

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

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

return(0);

}

prepare_statements:

SQL_EXEC("PRAGMA foreign_keys = ON");

sql = "DELETE FROM mpages where file=?";

sql = "DELETE FROM mpages WHERE id 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 "

"(file,sec,arch,desc,form) VALUES (?,?,?,?,?)";

"(form) VALUES (?)";

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

sql = "INSERT INTO mlinks "

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

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

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

sql = "INSERT INTO keys "

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

CVSweb