mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.100 and 1.141

version 1.100, 2014/01/05 04:13:52

version 1.141, 2014/04/20 16:46:04

Line 20

#endif

#include <sys/stat.h>

#include <sys/wait.h>

#include <assert.h>

#include <ctype.h>

Line 45

Line 46

#include "mdoc.h"

#include "man.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_EXEC(_v) \

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

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

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

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

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

#define SQL_BIND_INT(_s, _i, _v) \

if (SQLITE_OK != sqlite3_bind_int \

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

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

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

#define SQL_BIND_INT64(_s, _i, _v) \

if (SQLITE_OK != sqlite3_bind_int64 \

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

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

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

#define SQL_STEP(_s) \

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

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

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

enum op {

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

Line 95 struct inodev {

Line 100 struct inodev {

struct mpage {

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

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

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

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

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

Line 112 struct mlink {

Line 118 struct mlink {

char *name; /* name from file name (not empty) */

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

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

struct mpage *mpage; /* parent */

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

};

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

STMT_INSERT_LINK, /* insert mlink */

STMT_INSERT_NAME, /* insert name */

STMT_INSERT_KEY, /* insert parsed key */

STMT__MAX

};

Line 135 struct mdoc_handler {

Line 139 struct mdoc_handler {

};

static void dbclose(int);

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

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

static void dbadd_mlink(const struct mlink *mlink);

static int dbopen(int);

static void dbprune(void);

static void filescan(const char *);

Line 143 static void *hash_alloc(size_t, void *);

Line 148 static void *hash_alloc(size_t, void *);

static void hash_free(void *, size_t, void *);

static void *hash_halloc(size_t, void *);

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

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

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

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

static void parse_cat(struct mpage *);

static void names_check(void);

static void parse_cat(struct mpage *, int);

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

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

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

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

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

Line 171 static int set_basedir(const char *);

Line 176 static int set_basedir(const char *);

static int treescan(void);

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

static char tempfilename[32];

static char *progname;

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

static int nodb; /* no database changes */

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

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

static int warnings; /* warn about crap */

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

static int debug; /* 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 */

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 }, /* Ap */

Line 218 static const struct mdoc_handler mdocs[MDOC_MAX] = {

Line 227 static const struct mdoc_handler mdocs[MDOC_MAX] = {

{ NULL, TYPE_Ic }, /* Ic */

{ NULL, TYPE_In }, /* In */

{ NULL, TYPE_Li }, /* Li */

{ parse_mdoc_Nd, TYPE_Nd }, /* Nd */

{ parse_mdoc_Nd, 0 }, /* Nd */

{ parse_mdoc_Nm, TYPE_Nm }, /* Nm */

{ parse_mdoc_Nm, 0 }, /* Nm */

{ NULL, 0 }, /* Op */

{ NULL, 0 }, /* Ot */

{ NULL, TYPE_Pa }, /* Pa */

Line 311 static const struct mdoc_handler mdocs[MDOC_MAX] = {

Line 320 static const struct mdoc_handler mdocs[MDOC_MAX] = {

{ NULL, 0 }, /* Ta */

};

int

main(int argc, char *argv[])

{

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

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

++progname;

* We accept a few different invocations.

* The CHECKOP macro makes sure that invocation styles don't

* clobber each other.

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

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

path_arg = NULL;

op = OP_DEFAULT;

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

while (-1 != (ch = getopt(argc, argv, "aC:Dd:npQT:tu:v")))

switch (ch) {

case ('a'):

case 'a':

use_all = 1;

break;

case ('C'):

case 'C':

CHECKOP(op, ch);

path_arg = optarg;

op = OP_CONFFILE;

break;

case ('d'):

case 'D':

debug++;

break;

case 'd':

CHECKOP(op, ch);

path_arg = optarg;

op = OP_UPDATE;

break;

case ('n'):

case 'n':

nodb = 1;

break;

case ('T'):

case 'p':

warnings = 1;

break;

case 'Q':

mparse_options |= MPARSE_QUICK;

break;

case 'T':

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

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

"output format\n", optarg);

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

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

}

write_utf8 = 1;

break;

case ('t'):

case 't':

CHECKOP(op, ch);

dup2(STDOUT_FILENO, STDERR_FILENO);

op = OP_TEST;

nodb = warnings = 1;

break;

case ('u'):

case 'u':

CHECKOP(op, ch);

path_arg = optarg;

op = OP_DELETE;

break;

case ('v'):

case 'v':

verb++;

/* Compatibility with espie@'s makewhatis. */

break;

case ('W'):

warnings = 1;

break;

default:

goto usage;

}

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

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

ohash_init(&mlinks, 6, &mlinks_info);

if (OP_UPDATE == op || OP_DELETE == op || OP_TEST == op) {

* Force processing all files.

use_all = 1;

* All of these deal with a specific directory.

* Jump into that directory then collect files specified

* Jump into that directory first.

* on the command-line.

if (0 == set_basedir(path_arg))

goto out;

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

filescan(argv[i]);

if (dbopen(1)) {

if (0 == dbopen(1))

goto out;

* The existing database is usable. Process

if (OP_TEST != op)

* all files specified on the command-line.

dbprune();

use_all = 1;

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

filescan(argv[i]);

if (OP_TEST != op)

dbprune();

} else {

* Database missing or corrupt.

* Recreate from scratch.

exitcode = (int)MANDOCLEVEL_OK;

op = OP_DEFAULT;

if (0 == treescan())

goto out;

if (0 == dbopen(0))

goto out;

}

if (OP_DELETE != op)

mpages_merge(mc, mp, 0);

mpages_merge(mc, mp);

dbclose(1);

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

} else {

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

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

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

* manpath_parse() wants to do it.

if (argc > 0) {

dirs.paths = mandoc_calloc

dirs.paths = mandoc_calloc(argc,

(argc, sizeof(char *));

sizeof(char *));

dirs.sz = (size_t)argc;

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

dirs.paths[i] = mandoc_strdup(argv[i]);

} else

manpath_parse(&dirs, path_arg, NULL, NULL);

if (0 == dirs.sz) {

exitcode = (int)MANDOCLEVEL_BADARG;

say("", "Empty manpath");

}

* First scan the tree rooted at a base directory, then

* build a new database and finally move it into place.

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

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

if (0 == dbopen(0))

goto out;

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

mpages_merge(mc, mp);

if (warnings &&

! (MPARSE_QUICK & mparse_options))

names_check();

dbclose(0);

if (j + 1 < dirs.sz) {

Line 499 out:

Line 534 out:

ohash_delete(&mlinks);

return(exitcode);

usage:

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

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

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

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

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

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

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

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

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

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

progname, progname, progname,

progname, progname);

return((int)MANDOCLEVEL_BADARG);

Line 518 usage:

Line 553 usage:

* If use_all has been specified, grok all files.

* If not, sanitise paths to the following:

* [./]man*[/<arch>]/<name>.<section>

* or

* [./]cat<section>[/<arch>]/<name>.0

Line 527 usage:

Line 562 usage:

static int

treescan(void)

{

char buf[PATH_MAX];

FTS *f;

FTSENT *ff;

struct mlink *mlink;

int dform;

int dform, gzip;

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

const char *path;

const char *argv[2];

Line 538 treescan(void)

Line 574 treescan(void)

argv[0] = ".";

argv[1] = (char *)NULL;

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

* Walk through all components under the directory, using the

FTS_PHYSICAL | FTS_NOCHDIR, NULL);

* logical descent of files.

f = fts_open((char * const *)argv, FTS_LOGICAL, NULL);

if (NULL == f) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", NULL);

say("", "&fts_open");

return(0);

}

Line 554 treescan(void)

Line 587 treescan(void)

while (NULL != (ff = fts_read(f))) {

path = ff->fts_path + 2;

switch (ff->fts_info) {

* Symbolic links require various sanity checks,

* then get handled just like regular files.

case FTS_SL:

if (NULL == realpath(path, buf)) {

if (warnings)

say(path, "&realpath");

continue;

}

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

if (warnings) say("",

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

continue;

}

/* Use logical inode to avoid mpages dupe. */

if (-1 == stat(path, ff->fts_statp)) {

if (warnings)

say(path, "&stat");

continue;

}

/* FALLTHROUGH */

* If we're a regular file, add an mlink by using the

* stored directory data and handling the filename.

if (FTS_F == ff->fts_info) {

case FTS_F:

if (0 == strcmp(path, MANDOC_DB))

continue;

if ( ! use_all && ff->fts_level < 2) {

if (warnings)

say(path, "Extraneous file");

continue;

} else if (NULL == (fsec =

}

strrchr(ff->fts_name, '.'))) {

gzip = 0;

fsec = NULL;

while (NULL == fsec) {

fsec = strrchr(ff->fts_name, '.');

if (NULL == fsec || strcmp(fsec+1, "gz"))

break;

gzip = 1;

*fsec = '\0';

fsec = NULL;

}

if (NULL == fsec) {

if ( ! use_all) {

if (warnings)

say(path,

Line 577 treescan(void)

Line 645 treescan(void)

if (warnings)

say(path, "Skip html");

continue;

} else if (0 == strcmp(fsec, "gz")) {

if (warnings)

say(path, "Skip gz");

continue;

} else if (0 == strcmp(fsec, "ps")) {

if (warnings)

say(path, "Skip ps");

Line 605 treescan(void)

Line 669 treescan(void)

mlink->arch = arch;

mlink->name = ff->fts_name;

mlink->fsec = fsec;

mlink->gzip = gzip;

mlink_add(mlink, ff->fts_statp);

continue;

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

FTS_DP != ff->fts_info) {

case FTS_D:

/* FALLTHROUGH */

case FTS_DP:

break;

default:

if (warnings)

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

continue;

}

switch (ff->fts_level) {

case (0):

case 0:

/* Ignore the root directory. */

break;

case (1):

case 1:

* This might contain manX/ or catX/.

* Try to infer this from the name.

Line 639 treescan(void)

Line 709 treescan(void)

dsec = NULL;

}

if (NULL != dsec || use_all)

break;

if (warnings)

say(path, "Unknown directory part");

fts_set(f, ff, FTS_SKIP);

break;

case (2):

case 2:

* Possibly our architecture.

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

Line 678 treescan(void)

Line 748 treescan(void)

* Try to infer the manual section, architecture, and page name from the

* path, assuming it looks like

* [./]man*[/<arch>]/<name>.<section>

* or

* [./]cat<section>[/<arch>]/<name>.0

Line 697 filescan(const char *file)

Line 767 filescan(const char *file)

if (0 == strncmp(file, "./", 2))

file += 2;

if (NULL == realpath(file, buf)) {

* We have to do lstat(2) before realpath(3) loses

* the information whether this is a symbolic link.

* We need to know that because for symbolic links,

* we want to use the orginal file name, while for

* regular files, we want to use the real path.

if (-1 == lstat(file, &st)) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, NULL);

say(file, "&lstat");

return;

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

} else if (0 == ((S_IFREG | S_IFLNK) & st.st_mode)) {

exitcode = (int)MANDOCLEVEL_BADARG;

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

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

return;

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

}

* We have to resolve the file name to the real path

* in any case for the base directory check.

if (NULL == realpath(file, buf)) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, NULL);

say(file, "&realpath");

return;

} else if ( ! (S_IFREG & st.st_mode)) {

}

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

start = buf + strlen(basedir) + 1;

else if (OP_TEST == op)

start = buf;

else {

exitcode = (int)MANDOCLEVEL_BADARG;

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

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

return;

}

start = buf + strlen(basedir);

* Now we are sure the file is inside our tree.

* If it is a symbolic link, ignore the real path

* and use the original name.

* This implies passing stuff like "cat1/../man1/foo.1"

* on the command line won't work. So don't do that.

* Note the stat(2) can still fail if the link target

* doesn't exist.

if (S_IFLNK & st.st_mode) {

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

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "&stat");

return;

}

strlcpy(buf, file, sizeof(buf));

start = strstr(buf, basedir) == buf ?

buf + strlen(basedir) + 1 : buf;

}

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

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

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

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

} else

mlink->next = mpage->mlinks;

mpage->mlinks = mlink;

mlink->mpage = mpage;

}

static void

Line 875 mlinks_undupe(struct mpage *mpage)

Line 985 mlinks_undupe(struct mpage *mpage)

*++bufp = '\0';

strlcat(buf, mlink->dsec, PATH_MAX);

if (NULL == ohash_find(&mlinks,

ohash_qlookup(&mlinks, buf)))

goto nextlink;

if (warnings)

say(mlink->file, "Man source exists: %s", buf);

Line 889 nextlink:

Line 999 nextlink:

}

static int

static void

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

{

int match;

struct str *str;

unsigned int slot;

match = 1;

* Check whether the manual section given in a file

* agrees with the directory where the file is located.

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

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

if (FORM_SRC == mpage->form &&

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

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

match = 0;

say(mlink->file, "Section \"%s\" manual in %s directory",

mpage->sec, mlink->dsec);

}

* Manual page directories exist for each kernel

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

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

* on amd64, i386, sparc, and sparc64.

if (strcasecmp(mpage->arch, mlink->arch)) {

if (strcasecmp(mpage->arch, mlink->arch))

match = 0;

say(mlink->file, "Architecture \"%s\" manual in "

"\"%s\" directory", mpage->arch, mlink->arch);

}

if (strcasecmp(mpage->title, mlink->name))

match = 0;

* XXX

* parse_cat() doesn't set NAME_TITLE yet.

return(match);

if (FORM_CAT == mpage->form)

return;

* Check whether this mlink

* appears as a name in the NAME section.

slot = ohash_qlookup(&names, mlink->name);

str = ohash_find(&names, slot);

assert(NULL != str);

if ( ! (NAME_TITLE & str->mask))

say(mlink->file, "Name missing in NAME section");

}

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

Line 1064 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;

int fd[2];

struct mlink *mlink;

struct mpage *mpage, *mpage_dest;

struct mlink *mlink, *mlink_dest;

struct mdoc *mdoc;

struct man *man;

struct title *title_entry;

char *sodest;

char *title_str;

char *cp;

const char *cp;

pid_t child_pid;

int match;

int status;

unsigned int pslot, tslot;

unsigned int pslot;

enum mandoclevel lvl;

str_info.alloc = hash_alloc;

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

Line 1085 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 981 mpages_merge(struct mchars *mc, struct mparse *mp, int

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

continue;

}

name_mask = NAME_MASK;

ohash_init(&names, 4, &str_info);

ohash_init(&strings, 6, &str_info);

mparse_reset(mp);

mdoc = NULL;

man = NULL;

sodest = NULL;

child_pid = 0;

fd[0] = -1;

fd[1] = -1;

if (mpage->mlinks->gzip) {

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

exitcode = (int)MANDOCLEVEL_SYSERR;

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

goto nextpage;

}

switch (child_pid = fork()) {

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

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

child_pid = 0;

close(fd[1]);

close(fd[0]);

goto nextpage;

case 0:

close(fd[0]);

if (-1 == dup2(fd[1], STDOUT_FILENO)) {

say(mpage->mlinks->file,

"&dup gunzip");

exit(1);

}

execlp("gunzip", "gunzip", "-c",

mpage->mlinks->file, NULL);

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

exit(1);

default:

close(fd[1]);

break;

}

* Try interpreting the file as mdoc(7) or man(7)

* source code, unless it is already known to be

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

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

if (FORM_CAT != mpage->mlinks->dform ||

FORM_CAT != mpage->mlinks->fform) {

lvl = mparse_readfd(mp, -1, mpage->mlinks->file);

lvl = mparse_readfd(mp, fd[0], mpage->mlinks->file);

if (lvl < MANDOCLEVEL_FATAL)

mparse_result(mp, &mdoc, &man);

mparse_result(mp, &mdoc, &man, &sodest);

}

if (NULL != mdoc) {

if (NULL != sodest) {

mlink_dest = ohash_find(&mlinks,

ohash_qlookup(&mlinks, sodest));

if (NULL != mlink_dest) {

/* The .so target exists. */

mpage_dest = mlink_dest->mpage;

mlink = mpage->mlinks;

while (1) {

mlink->mpage = mpage_dest;

* If the target was already

* processed, add the links

* to the database now.

* Otherwise, this will

* happen when we come

* to the target.

if (mpage_dest->pageid)

dbadd_mlink(mlink);

if (NULL == mlink->next)

break;

mlink = mlink->next;

}

/* Move all links to the target. */

mlink->next = mlink_dest->next;

mlink_dest->next = mpage->mlinks;

mpage->mlinks = NULL;

}

goto nextpage;

} else if (NULL != mdoc) {

mpage->form = FORM_SRC;

mpage->sec =

mandoc_strdup(mdoc_meta(mdoc)->msec);

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

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

}

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

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

"any" : mpage->arch, TYPE_arch);

any : mpage->arch, TYPE_arch);

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

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

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

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

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

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

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

"any" : mlink->arch, TYPE_arch);

any : mlink->arch, TYPE_arch);

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

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

}

if (warnings && !use_all) {

assert(NULL == mpage->desc);

match = 0;

for (mlink = mpage->mlinks; mlink;

mlink = mlink->next)

if (mlink_check(mpage, mlink))

match = 1;

} else

match = 1;

if (NULL != mdoc) {

if (NULL != (cp = mdoc_meta(mdoc)->name))

putkey(mpage, cp, TYPE_Nm);

putkey(mpage, cp, NAME_HEAD);

assert(NULL == mpage->desc);

parse_mdoc(mpage, mdoc_node(mdoc));

putkey(mpage, NULL != mpage->desc ?

mpage->desc : mpage->mlinks->name, TYPE_Nd);

} else if (NULL != man)

parse_man(mpage, man_node(man));

else

parse_cat(mpage);

parse_cat(mpage, fd[0]);

if (NULL == mpage->desc)

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

if (warnings && !use_all)

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

for (mlink = mpage->mlinks; mlink;

* the location of the file, remember the title as

mlink = mlink->next)

* found; else, remember it as missing.

mlink_check(mpage, mlink);

if (check_reachable) {

dbadd(mpage, mc);

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

mpage->title, mpage->sec,

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

if (child_pid) {

mpage->arch)) {

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

perror(NULL);

exitcode = (int)MANDOCLEVEL_SYSERR;

exit((int)MANDOCLEVEL_SYSERR);

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

} else if (WIFSIGNALED(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(mpage->mlinks->file,

"gunzip died from signal %d",

WTERMSIG(status));

} else if (WEXITSTATUS(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(mpage->mlinks->file,

"gunzip failed with code %d",

WEXITSTATUS(status));

}

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

ohash_delete(&names);

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,

static void

"Probably unreachable, title is %s",

names_check(void)

title_entry->title);

{

free(title_entry->title);

sqlite3_stmt *stmt;

free(title_entry->file);

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

free(title_entry);

int irc;

title_entry = ohash_next(&title_table, &tslot);

}

sqlite3_prepare_v2(db,

ohash_delete(&title_table);

"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 * FROM mlinks GROUP BY pageid"

") USING (pageid);",

-1, &stmt, NULL);

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

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

while (SQLITE_ROW == (irc = sqlite3_step(stmt))) {

name = sqlite3_column_text(stmt, 0);

sec = sqlite3_column_text(stmt, 1);

arch = sqlite3_column_text(stmt, 2);

key = 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)

parse_cat(struct mpage *mpage, int fd)

{

FILE *stream;

char *line, *p, *title;

size_t len, plen, titlesz;

if (NULL == (stream = fopen(mpage->mlinks->file, "r"))) {

stream = (-1 == fd) ?

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

fdopen(fd, "r");

if (NULL == stream) {

if (warnings)

say(mpage->mlinks->file, NULL);

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

return;

}

Line 1138 parse_cat(struct mpage *mpage)

Line 1336 parse_cat(struct mpage *mpage)

while (NULL != (line = fgetln(stream, &len)))

if ('\n' != *line && ' ' != *line)

break;

* Read up until the next section into a buffer.

* Strip the leading and trailing newline from each read line,

Line 1175 parse_cat(struct mpage *mpage)

Line 1373 parse_cat(struct mpage *mpage)

if (warnings)

say(mpage->mlinks->file,

"Cannot find NAME section");

assert(NULL == mpage->desc);

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

putkey(mpage, mpage->mlinks->name, TYPE_Nd);

fclose(stream);

free(title);

return;

Line 1211 parse_cat(struct mpage *mpage)

Line 1406 parse_cat(struct mpage *mpage)

if (0 == len) {

memmove(line, line + 1, plen--);

continue;

}

memmove(line - 1, line + 1, plen - len);

plen -= 2;

}

assert(NULL == mpage->desc);

mpage->desc = mandoc_strdup(p);

putkey(mpage, mpage->desc, TYPE_Nd);

fclose(stream);

free(title);

}

Line 1227 parse_cat(struct mpage *mpage)

Line 1420 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 1254 static void

Line 1452 static void

parse_man(struct mpage *mpage, const struct man_node *n)

{

const struct man_node *head, *body;

char *start, *sv, *title;

char *start, *title;

char byte;

size_t sz, titlesz;

size_t sz;

if (NULL == n)

return;

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

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

body = n;

assert(body->parent);

if (NULL != (head = body->parent->head) &&

1 == head->nchild &&

NULL != (head = (head->child)) &&

MAN_TEXT == head->type &&

0 == strcmp(head->string, "NAME") &&

NULL != (body = body->child) &&

NULL != body->child) {

MAN_TEXT == body->type) {

title = NULL;

titlesz = 0;

* Suck the entire NAME section into memory.

* Yes, we might run away.

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

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

* NAME sections over many lines.

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

title = NULL;

if (MAN_TEXT != body->type)

man_deroff(&title, body);

break;

if (0 == (sz = strlen(body->string)))

continue;

title = mandoc_realloc

(title, titlesz + sz + 1);

memcpy(title + titlesz, body->string, sz);

titlesz += sz + 1;

title[titlesz - 1] = ' ';

}

if (NULL == title)

return;

title = mandoc_realloc(title, titlesz + 1);

title[titlesz] = '\0';

/* Skip leading space. */

sv = title;

while (isspace((unsigned char)*sv))

sv++;

if (0 == (sz = strlen(sv))) {

free(title);

return;

}

/* Erase trailing space. */

start = &sv[sz - 1];

while (start > sv && isspace((unsigned char)*start))

*start-- = '\0';

if (start == sv) {

free(title);

return;

}

start = sv;

* Go through a special heuristic dance here.

* Conventionally, one or more manual names are

* comma-specified prior to a whitespace, then a

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

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

* the name parts here.

start = title;

for ( ;; ) {

sz = strcspn(start, " ,");

if ('\0' == start[sz])

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

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

byte = start[sz];

start[sz] = '\0';

putkey(mpage, start, TYPE_Nm);

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

if (' ' == byte) {

start += sz + 1;

break;

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

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

start++;

}

if (sv == start) {

if (start == title) {

putkey(mpage, start, TYPE_Nm);

putkey(mpage, start, NAME_TITLE);

free(title);

return;

}

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

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

while (' ' == *start)

start++;

assert(NULL == mpage->desc);

mpage->desc = mandoc_strdup(start);

putkey(mpage, mpage->desc, TYPE_Nd);

free(title);

return;

}

Line 1404 parse_mdoc(struct mpage *mpage, const struct mdoc_node

Line 1570 parse_mdoc(struct mpage *mpage, const struct mdoc_node

assert(NULL != n);

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

switch (n->type) {

case (MDOC_ELEM):

case MDOC_ELEM:

/* FALLTHROUGH */

case (MDOC_BLOCK):

case MDOC_BLOCK:

/* FALLTHROUGH */

case (MDOC_HEAD):

case MDOC_HEAD:

/* FALLTHROUGH */

case (MDOC_BODY):

case MDOC_BODY:

/* FALLTHROUGH */

case (MDOC_TAIL):

case MDOC_TAIL:

if (NULL != mdocs[n->tok].fp)

if (0 == (*mdocs[n->tok].fp)(mpage, n))

break;

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

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

size_t sz;

if (SEC_SYNOPSIS != n->sec ||

NULL == (n = n->child) ||

MDOC_TEXT != n->type)

return(0);

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

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

* Parse: .Fn "struct type *name" "char *arg".

* First strip away pointer symbol.

* Then store the function name, then type.

* Finally, store the arguments.

if (NULL == (cp = strrchr(n->string, ' ')))

Line 1518 parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_n

Line 1684 parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_n

return(0);

}

if (-1 == asprintf(&cp, "%s(%s)", n->string, n->next->string)) {

mandoc_asprintf(&cp, "%s(%s)", n->string, n->next->string);

perror(NULL);

exit((int)MANDOCLEVEL_SYSERR);

}

putkey(mpage, cp, TYPE_Xr);

free(cp);

return(0);

Line 1530 parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_n

Line 1693 parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_n

static int

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

{

size_t sz;

if (MDOC_BODY != n->type)

if (MDOC_BODY == n->type)

return(0);

mdoc_deroff(&mpage->desc, n);

return(0);

* Special-case the `Nd' because we need to put the description

* into the document table.

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

if (MDOC_TEXT == n->type) {

if (NULL != mpage->desc) {

sz = strlen(mpage->desc) +

strlen(n->string) + 2;

mpage->desc = mandoc_realloc(

mpage->desc, sz);

strlcat(mpage->desc, " ", sz);

strlcat(mpage->desc, n->string, sz);

} else

mpage->desc = mandoc_strdup(n->string);

}

if (NULL != n->child)

parse_mdoc_Nd(mpage, n);

}

return(1);

}

static int

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

{

return(SEC_NAME == n->sec ||

if (SEC_NAME == n->sec)

(SEC_SYNOPSIS == n->sec && MDOC_HEAD == n->type));

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

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

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

return(0);

}

static int

Line 1596 static void

Line 1740 static void

putkeys(const struct mpage *mpage,

const char *cp, size_t sz, uint64_t v)

{

struct ohash *htab;

struct str *s;

unsigned int slot;

const char *end;

unsigned int slot;

int i;

if (0 == sz)

return;

if (TYPE_Nm & v) {

htab = &names;

v &= name_mask;

name_mask &= ~NAME_FIRST;

if (debug > 1)

say(mpage->mlinks->file,

"Adding name %*s", sz, cp);

} else {

htab = &strings;

if (debug > 1)

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

if (1 << i & v)

say(mpage->mlinks->file,

"Adding key %s=%*s",

mansearch_keynames[i], sz, cp);

}

end = cp + sz;

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

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

s = ohash_find(&strings, slot);

s = ohash_find(htab, slot);

if (NULL != s && mpage == s->mpage) {

s->mask |= v;

Line 1613 putkeys(const struct mpage *mpage,

Line 1776 putkeys(const struct mpage *mpage,

} else if (NULL == s) {

s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);

memcpy(s->key, cp, sz);

ohash_insert(&strings, slot, s);

ohash_insert(htab, slot, s);

}

s->mpage = mpage;

s->mask = v;

Line 1679 static void

Line 1842 static void

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;

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

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

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 1703 render_key(struct mchars *mc, struct str *key)

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

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

key->rendered = key->key;

return;

}

/* Pre-allocate by the length of the input */

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

Line 1886 render_key(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 1742 render_key(struct mchars *mc, struct str *key)

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

* predefined character or special character.

esc = mandoc_escape

esc = mandoc_escape((const char **)&val,

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

&seq, &len);

if (ESCAPE_ERROR == esc)

break;

if (ESCAPE_SPECIAL != esc)

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

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

key->rendered = buf;

}

static void

dbadd_mlink(const struct mlink *mlink)

{

size_t i;

i = 1;

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

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

SQL_STEP(stmts[STMT_INSERT_LINK]);

sqlite3_reset(stmts[STMT_INSERT_LINK]);

}

* 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

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

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

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

static void

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

dbadd(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)

mlink = mpage->mlinks;

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

if (nodb)

if (nodb) {

while (NULL != mlink) {

fputs(mlink->name, stdout);

if (NULL == mlink->next ||

strcmp(mlink->dsec, mlink->next->dsec) ||

strcmp(mlink->fsec, mlink->next->fsec) ||

strcmp(mlink->arch, mlink->next->arch)) {

putchar('(');

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

fputs(mlink->fsec, stdout);

else

fputs(mlink->dsec, stdout);

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

printf("/%s", mlink->arch);

putchar(')');

}

mlink = mlink->next;

if (NULL != mlink)

fputs(", ", stdout);

}

printf(" - %s\n", mpage->desc);

return;

desc = "";

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

key = ohash_find(&strings,

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

assert(NULL != key);

if (NULL == key->rendered)

render_key(mc, key);

desc = key->rendered;

}

SQL_EXEC("BEGIN TRANSACTION");

if (debug)

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

i = 1;

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

SQL_BIND_TEXT(stmts[STMT_INSERT_PAGE], i, mpage->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);

mpage->pageid = sqlite3_last_insert_rowid(db);

sqlite3_reset(stmts[STMT_INSERT_PAGE]);

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

while (NULL != mlink) {

i = 1;

dbadd_mlink(mlink);

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

mlink = mlink->next;

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

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

SQL_STEP(stmts[STMT_INSERT_LINK]);

sqlite3_reset(stmts[STMT_INSERT_LINK]);

}

mlink = mpage->mlinks;

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

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

assert(key->mpage == mpage);

if (NULL == key->rendered)

render_key(mc, key);

i = 1;

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

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

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

SQL_STEP(stmts[STMT_INSERT_NAME]);

sqlite3_reset(stmts[STMT_INSERT_NAME]);

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

free(key->rendered);

free(key);

}

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

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

assert(key->mpage == mpage);

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

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

i = 1;

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

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

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

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

SQL_STEP(stmts[STMT_INSERT_KEY]);

sqlite3_reset(stmts[STMT_INSERT_KEY]);

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

free(key->rendered);

free(key);

}

SQL_EXEC("END TRANSACTION");

}

static void

Line 1862 dbprune(void)

Line 2065 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;

if (debug)

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

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

SQL_STEP(stmts[STMT_DELETE_PAGE]);

if (nodb)

sqlite3_reset(stmts[STMT_DELETE_PAGE]);

continue;

if (verb)

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

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

i = 1;

mpage = ohash_next(&mpages, &slot);

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 1886 static void

Line 2100 static void

dbclose(int real)

{

size_t i;

int status;

pid_t child;

if (nodb)

return;

Line 1901 dbclose(int real)

Line 2117 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, "&rename");

}

return;

}

switch (child = fork()) {

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, NULL);

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

return;

case 0:

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

tempfilename, MANDOC_DB, NULL);

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

exit(0);

default:

break;

}

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

exitcode = (int)MANDOCLEVEL_SYSERR;

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

} else if (WIFSIGNALED(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "cmp died from signal %d", WTERMSIG(status));

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

return;

case 0:

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

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

exit((int)MANDOCLEVEL_SYSERR);

default:

break;

}

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

exitcode = (int)MANDOCLEVEL_SYSERR;

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

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

exitcode = (int)MANDOCLEVEL_SYSERR;

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

tempfilename);

}

Line 1918 dbclose(int real)

Line 2184 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;

} else

file = MANDOC_DB;

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

if (SQLITE_OK == rc)

goto prepare_statements;

if (SQLITE_CANTOPEN != rc) {

}

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(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("", "&%s", tempfilename);

return(0);

}

if (strlcat(tempfilename, "/" MANDOC_DB,

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

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "%s/" MANDOC_DB ": Filename too long",

tempfilename);

return(0);

}

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

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return(0);

}

create_tables:

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

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

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

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

" \"pageid\" 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) "

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

"ON DELETE CASCADE,\n"

"ON DELETE CASCADE\n"

" \"id\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL\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"

");\n"

"\n"

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

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

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

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

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

"ON DELETE CASCADE,\n"

"ON DELETE CASCADE\n"

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

");\n"

"\n"

"CREATE INDEX keys_pageid_idx ON keys (pageid);\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 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 "

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

Line 2050 set_basedir(const char *targetdir)

Line 2346 set_basedir(const char *targetdir)

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

exitcode = (int)MANDOCLEVEL_SYSERR;

if (NULL != targetdir)

say(".", NULL);

say("", "&getcwd");

return(0);

}

if (-1 == (fd = open(startdir, O_RDONLY, 0))) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(startdir, NULL);

say("", "&open %s", startdir);

return(0);

}

if (NULL == targetdir)

Line 2067 set_basedir(const char *targetdir)

Line 2363 set_basedir(const char *targetdir)

close(fd);

basedir[0] = '\0';

exitcode = (int)MANDOCLEVEL_SYSERR;

say(startdir, NULL);

say("", "&chdir %s", startdir);

return(0);

}

if (NULL == targetdir) {

Line 2078 set_basedir(const char *targetdir)

Line 2374 set_basedir(const char *targetdir)

if (NULL == realpath(targetdir, basedir)) {

basedir[0] = '\0';

exitcode = (int)MANDOCLEVEL_BADARG;

say(targetdir, NULL);

say("", "&%s: realpath", targetdir);

return(0);

} else if (-1 == chdir(basedir)) {

exitcode = (int)MANDOCLEVEL_BADARG;

say("", NULL);

say("", "&chdir");

return(0);

}

return(1);

Line 2092 static void

Line 2388 static void

say(const char *file, const char *format, ...)

{

va_list ap;

int use_errno;

if ('\0' != *basedir)

fprintf(stderr, "%s", basedir);

Line 2099 say(const char *file, const char *format, ...)

Line 2396 say(const char *file, const char *format, ...)

fputs("//", stderr);

if ('\0' != *file)

fprintf(stderr, "%s", file);

fputs(": ", stderr);

if (NULL == format) {

use_errno = 1;

perror(NULL);

if (NULL != format) {

return;

switch (*format) {

case '&':

format++;

break;

case '\0':

format = NULL;

break;

default:

use_errno = 0;

break;

}

if (NULL != format) {

va_start(ap, format);

if ('\0' != *basedir || '\0' != *file)

vfprintf(stderr, format, ap);

fputs(": ", stderr);

va_end(ap);

va_start(ap, format);

vfprintf(stderr, format, ap);

fputc('\n', stderr);

va_end(ap);

}

if (use_errno) {

if ('\0' != *basedir || '\0' != *file || NULL != format)

fputs(": ", stderr);

perror(NULL);

} else

fputc('\n', stderr);

}

CVSweb