mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.133 and 1.176

version 1.133, 2014/04/10 02:46:21

version 1.176, 2014/12/05 14:26:40

Line 15

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

Line 26

Line 25

#include <ctype.h>

#include <errno.h>

#include <fcntl.h>

#if HAVE_FTS

#include <fts.h>

#else

#include "compat_fts.h"

#endif

#include <getopt.h>

#include <limits.h>

#include <stddef.h>

Line 36

Line 39

#include <string.h>

#include <unistd.h>

#ifdef HAVE_OHASH

#if HAVE_OHASH

#include <ohash.h>

#else

#include "compat_ohash.h"

Line 55 extern const char *const mansearch_keynames[];

Line 58 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 80 enum op {

Line 83 enum op {

OP_TEST /* change no databases, report potential problems */

};

enum form {

FORM_NONE, /* format is unknown */

FORM_SRC, /* format is -man or -mdoc */

FORM_CAT /* format is cat */

};

struct str {

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[]; /* may contain escape sequences */

char key[]; /* rendered text */

};

struct inodev {

Line 100 struct inodev {

Line 96 struct inodev {

struct mpage {

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

int64_t recno; /* id in mpages SQL table */

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

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

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

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

int form; /* format from file content */

int name_head_done;

};

struct mlink {

char file[PATH_MAX]; /* filename rel. to manpath */

enum form dform; /* format from directory */

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

char *dsec; /* section from directory */

char *arch; /* architecture from directory */

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 dform; /* format from directory */

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

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

};

Line 127 enum stmt {

Line 124 enum stmt {

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

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

const struct mdoc_node *);

struct mdoc_handler {

mdoc_fp fp; /* optional handler */

Line 139 struct mdoc_handler {

Line 138 struct mdoc_handler {

};

static void dbclose(int);

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

static void dbadd(struct mpage *);

static void dbadd_mlink(const struct mlink *mlink);

static void dbadd_mlink_name(const struct mlink *mlink);

static int dbopen(int);

static void dbprune(void);

static void filescan(const char *);

static void *hash_alloc(size_t, void *);

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

static void hash_free(void *, void *);

static void *hash_halloc(size_t, void *);

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

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

static void mpages_merge(struct mparse *);

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_man(struct mpage *, const struct man_meta *,

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

const struct man_node *);

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

static void parse_mdoc(struct mpage *, const struct mdoc_meta *,

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

const struct mdoc_node *);

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

static int parse_mdoc_body(struct mpage *, const struct mdoc_meta *,

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

const struct mdoc_node *);

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

static int parse_mdoc_head(struct mpage *, const struct mdoc_meta *,

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

const struct mdoc_node *);

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

static int parse_mdoc_Fd(struct mpage *, const struct mdoc_meta *,

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

const struct mdoc_node *);

static int parse_mdoc_Fn(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

static int parse_mdoc_Fo(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

static int parse_mdoc_Nd(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

static int parse_mdoc_Nm(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

static int parse_mdoc_Sh(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

static int parse_mdoc_Xr(struct mpage *, const struct mdoc_meta *,

const struct mdoc_node *);

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

static void putkeys(const struct mpage *,

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

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 int render_string(char **, size_t *);

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

static int set_basedir(const char *);

static int set_basedir(const char *, int);

static int treescan(void);

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

Line 180 static char tempfilename[32];

Line 191 static char tempfilename[32];

static char *progname;

static int nodb; /* no database changes */

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

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 mchars *mchars; /* table of named characters */

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

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

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

{ NULL, 0 }, /* Ux */

{ NULL, 0 }, /* Xc */

{ NULL, 0 }, /* Xo */

{ parse_mdoc_head, 0 }, /* Fo */

{ parse_mdoc_Fo, 0 }, /* Fo */

{ NULL, 0 }, /* Fc */

{ NULL, 0 }, /* Oo */

{ NULL, 0 }, /* Oc */

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

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

{ NULL, 0 }, /* sp */

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

{ NULL, 0 }, /* Ta */

{ NULL, 0 }, /* ll */

};

int

main(int argc, char *argv[])

{

int ch, i;

size_t j, sz;

const char *path_arg;

struct mchars *mc;

struct manpaths dirs;

struct mparse *mp;

struct ohash_info mpages_info, mlinks_info;

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

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

memset(&dirs, 0, sizeof(struct manpaths));

mpages_info.alloc = mlinks_info.alloc = hash_alloc;

mpages_info.halloc = mlinks_info.halloc = hash_halloc;

mpages_info.calloc = mlinks_info.calloc = hash_calloc;

mpages_info.hfree = mlinks_info.hfree = hash_free;

mpages_info.free = mlinks_info.free = hash_free;

mpages_info.key_offset = offsetof(struct mpage, inodev);

mlinks_info.key_offset = offsetof(struct mlink, file);

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

Line 361 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.

#define CHECKOP(_op, _ch) do \

if (OP_DEFAULT != (_op)) { \

fprintf(stderr, "-%c: Conflicting option\n", (_ch)); \

fprintf(stderr, "%s: -%c: Conflicting option\n", \

progname, (_ch)); \

goto usage; \

} while (/*CONSTCOND*/0)

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

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

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'):

case 'd':

CHECKOP(op, ch);

path_arg = optarg;

op = OP_UPDATE;

break;

case ('n'):

case 'n':

nodb = 1;

break;

case ('p'):

case 'p':

warnings = 1;

break;

case ('Q'):

case 'Q':

mparse_options |= MPARSE_QUICK;

break;

case ('T'):

case 'T':

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

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

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

"output format\n", optarg);

"Unsupported output format\n",

progname, optarg);

goto usage;

}

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':

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

break;

default:

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

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

argv += optind;

if (OP_CONFFILE == op && argc > 0) {

fprintf(stderr, "-C: Too many arguments\n");

fprintf(stderr, "%s: -C: Too many arguments\n",

progname);

goto usage;

}

exitcode = (int)MANDOCLEVEL_OK;

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

mchars = mchars_alloc();

mc = mchars_alloc();

mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL,

mchars, NULL);

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.

* Most 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))

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

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

mpages_merge(mp);

dbclose(1);

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

} else {

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

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

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

* manpath_parse() wants to do it.

if (argc > 0) {

dirs.paths = mandoc_calloc

dirs.paths = mandoc_reallocarray(NULL,

(argc, sizeof(char *));

argc, sizeof(char *));

dirs.sz = (size_t)argc;

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

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

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

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

ohash_init(&mlinks, 6, &mlinks_info);

}

if (0 == set_basedir(dirs.paths[j]))

if (0 == set_basedir(dirs.paths[j], argc > 0))

goto out;

continue;

if (0 == treescan())

goto out;

continue;

if (0 == set_basedir(dirs.paths[j]))

goto out;

if (0 == dbopen(0))

goto out;

continue;

mpages_merge(mc, mp);

mpages_merge(mp);

if (warnings &&

if (warnings && !nodb &&

! (MPARSE_QUICK & mparse_options))

names_check();

dbclose(0);

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

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

}

out:

set_basedir(NULL);

manpath_free(&dirs);

mchars_free(mc);

mparse_free(mp);

mchars_free(mchars);

mpages_free();

ohash_delete(&mpages);

ohash_delete(&mlinks);

Line 526 usage:

Line 551 usage:

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

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

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

progname, progname, progname,

progname, progname);

return((int)MANDOCLEVEL_BADARG);

Line 540 usage:

Line 565 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 549 usage:

Line 574 usage:

static int

treescan(void)

{

char buf[PATH_MAX];

FTS *f;

FTSENT *ff;

struct mlink *mlink;

Line 560 treescan(void)

Line 586 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("", "&fts_open");

Line 576 treescan(void)

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

Line 627 treescan(void)

Line 675 treescan(void)

fsec[-1] = '\0';

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

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

if (strlcpy(mlink->file, path,

sizeof(mlink->file)) >=

sizeof(mlink->file)) {

say(path, "Filename too long");

free(mlink);

continue;

}

mlink->dform = dform;

mlink->dsec = dsec;

mlink->arch = arch;

Line 636 treescan(void)

Line 690 treescan(void)

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 668 treescan(void)

Line 727 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 707 treescan(void)

Line 766 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 726 filescan(const char *file)

Line 785 filescan(const char *file)

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

file += 2;

* 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, "&lstat");

return;

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

exitcode = (int)MANDOCLEVEL_BADARG;

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

return;

}

* 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, "&realpath");

return;

}

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

if (OP_TEST == op)

start = buf + strlen(basedir) + 1;

else if (OP_TEST == op)

start = buf;

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

start = buf + strlen(basedir);

else {

exitcode = (int)MANDOCLEVEL_BADARG;

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

return;

}

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

exitcode = (int)MANDOCLEVEL_BADARG;

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

say(file, "&stat");

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

return;

* and use the original name.

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

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

exitcode = (int)MANDOCLEVEL_BADARG;

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

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

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

return;

* doesn't exist.

if (S_IFLNK & st.st_mode) {

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

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "&stat");

return;

}

if (strlcpy(buf, file, sizeof(buf)) >= sizeof(buf)) {

say(file, "Filename too long");

return;

}

start = buf;

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

start += strlen(basedir);

}

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

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

mlink->dform = FORM_NONE;

if (strlcpy(mlink->file, start, sizeof(mlink->file)) >=

sizeof(mlink->file)) {

say(start, "Filename too long");

return;

}

* First try to guess our directory structure.

Line 901 mlinks_undupe(struct mpage *mpage)

Line 1000 mlinks_undupe(struct mpage *mpage)

mpage->form = FORM_NONE;

goto nextlink;

}

if (strlcpy(buf, mlink->file, PATH_MAX) >= PATH_MAX) {

(void)strlcpy(buf, mlink->file, sizeof(buf));

if (warnings)

say(mlink->file, "Filename too long");

goto nextlink;

}

bufp = strstr(buf, "cat");

assert(NULL != bufp);

memcpy(bufp, "man", 3);

if (NULL != (bufp = strrchr(buf, '.')))

*++bufp = '\0';

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

(void)strlcat(buf, mlink->dsec, sizeof(buf));

if (NULL == ohash_find(&mlinks,

ohash_qlookup(&mlinks, buf)))

goto nextlink;

if (warnings)

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

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

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

mpages_merge(struct mparse *mp)

{

char any[] = "any";

struct ohash_info str_info;

int fd[2];

struct mpage *mpage, *mpage_dest;

struct mlink *mlink, *mlink_dest;

struct mdoc *mdoc;

struct man *man;

char *sodest;

char *cp;

pid_t child_pid;

int fd;

int status;

unsigned int pslot;

enum mandoclevel lvl;

str_info.alloc = hash_alloc;

str_info.halloc = hash_halloc;

str_info.calloc = hash_calloc;

str_info.hfree = hash_free;

str_info.free = hash_free;

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

if (0 == nodb)

if ( ! nodb)

SQL_EXEC("BEGIN TRANSACTION");

mpage = ohash_first(&mpages, &pslot);

while (NULL != mpage) {

while (mpage != NULL) {

mlinks_undupe(mpage);

if (NULL == mpage->mlinks) {

if (mpage->mlinks == NULL) {

mpage = ohash_next(&mpages, &pslot);

continue;

}

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

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

mdoc = NULL;

man = NULL;

sodest = NULL;

child_pid = 0;

fd[0] = -1;

fd[1] = -1;

if (mpage->mlinks->gzip) {

mparse_open(mp, &fd, mpage->mlinks->file);

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

if (fd == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

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

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;

}

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

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

* source code, unless it is already known to be

* formatted. Fall back to formatted mode.

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

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

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

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

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

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

if (lvl < MANDOCLEVEL_FATAL)

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

}

if (NULL != sodest) {

if (sodest != NULL) {

mlink_dest = ohash_find(&mlinks,

ohash_qlookup(&mlinks, sodest));

if (NULL != mlink_dest) {

if (mlink_dest == NULL) {

mandoc_asprintf(&cp, "%s.gz", sodest);

mlink_dest = ohash_find(&mlinks,

ohash_qlookup(&mlinks, cp));

free(cp);

}

if (mlink_dest != NULL) {

/* The .so target exists. */

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

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

* to the target.

if (mpage_dest->recno)

if (mpage_dest->pageid)

dbadd_mlink(mlink);

dbadd_mlink_name(mlink);

if (NULL == mlink->next)

if (mlink->next == NULL)

break;

mlink = mlink->next;

}

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

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

mpage->mlinks = NULL;

}

goto nextpage;

} else if (NULL != mdoc) {

} else if (mdoc != NULL) {

mpage->form = FORM_SRC;

mpage->sec =

mpage->sec = mdoc_meta(mdoc)->msec;

mandoc_strdup(mdoc_meta(mdoc)->msec);

mpage->sec = mandoc_strdup(

mpage->sec == NULL ? "" : mpage->sec);

mpage->arch = mdoc_meta(mdoc)->arch;

mpage->arch = mandoc_strdup(

NULL == mpage->arch ? "" : mpage->arch);

mpage->arch == NULL ? "" : mpage->arch);

mpage->title =

mandoc_strdup(mdoc_meta(mdoc)->title);

} else if (NULL != man) {

} else if (man != NULL) {

mpage->form = FORM_SRC;

mpage->sec =

mandoc_strdup(man_meta(man)->msec);

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

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

mandoc_strdup(mpage->mlinks->name);

}

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

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

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

any : mpage->arch, TYPE_arch);

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

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

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

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

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

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

}

if (NULL != mdoc) {

assert(mpage->desc == NULL);

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

if (mdoc != NULL)

putkey(mpage, cp, NAME_HEAD);

parse_mdoc(mpage, mdoc_meta(mdoc), mdoc_node(mdoc));

assert(NULL == mpage->desc);

else if (man != NULL)

parse_mdoc(mpage, mdoc_node(mdoc));

parse_man(mpage, man_meta(man), man_node(man));

if (NULL == mpage->desc)

mpage->desc = mandoc_strdup(

mpage->mlinks->name);

} else if (NULL != man)

parse_man(mpage, man_node(man));

else

parse_cat(mpage, fd[0]);

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

dbadd(mpage);

if (child_pid) {

if (mparse_wait(mp) != MANDOCLEVEL_OK) {

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

exitcode = (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));

}

ohash_delete(&strings);

ohash_delete(&names);

Line 1205 names_check(void)

Line 1262 names_check(void)

{

sqlite3_stmt *stmt;

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

size_t i;

int irc;

sqlite3_prepare_v2(db,

Line 1217 names_check(void)

Line 1273 names_check(void)

"AND mlinks.name == names.name"

")"

") JOIN ("

"SELECT * FROM mlinks GROUP BY pageid"

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

"GROUP BY pageid"

") USING (pageid);",

-1, &stmt, NULL);

i = 1;

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

SQL_BIND_INT64(stmt, i, NAME_TITLE);

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

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

name = sqlite3_column_text(stmt, 0);

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

sec = sqlite3_column_text(stmt, 1);

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

arch = sqlite3_column_text(stmt, 2);

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

key = sqlite3_column_text(stmt, 3);

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

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

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

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

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

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

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

fdopen(fd, "r");

if (NULL == stream) {

if (-1 != fd)

close(fd);

if (warnings)

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

return;

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

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

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 1303 parse_cat(struct mpage *mpage, int fd)

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

if (warnings)

say(mpage->mlinks->file,

"Cannot find NAME section");

assert(NULL == mpage->desc);

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

fclose(stream);

free(title);

return;

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

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

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

fclose(stream);

free(title);

Line 1382 putmdockey(const struct mpage *mpage,

Line 1438 putmdockey(const struct mpage *mpage,

}

static void

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

parse_man(struct mpage *mpage, const struct man_meta *meta,

const struct man_node *n)

{

const struct man_node *head, *body;

char *start, *title;

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

Line 1460 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->child) {

* Suck the entire NAME section into memory.

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

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

if (NULL == title)

return;

* Go through a special heuristic dance here.

* Conventionally, one or more manual names are

* comma-specified prior to a whitespace, then a

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

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

break;

putkey(mpage, start, NAME_TITLE);

if ( ! (mpage->name_head_done ||

strcasecmp(start, meta->title))) {

putkey(mpage, start, NAME_HEAD);

mpage->name_head_done = 1;

}

if (' ' == byte) {

start += sz + 1;

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

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

if (start == title) {

putkey(mpage, start, NAME_TITLE);

if ( ! (mpage->name_head_done ||

strcasecmp(start, meta->title))) {

putkey(mpage, start, NAME_HEAD);

mpage->name_head_done = 1;

}

free(title);

return;

}

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

free(title);

return;

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

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

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

if (NULL != mpage->desc)

break;

parse_man(mpage, n);

parse_man(mpage, meta, n);

}

static void

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

parse_mdoc(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

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

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

break;

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

putmdockey(mpage, n->child,

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

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

continue;

}

if (NULL != n->child)

parse_mdoc(mpage, n);

parse_mdoc(mpage, meta, n);

}

static int

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

parse_mdoc_Fd(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

const char *start, *end;

char *start, *end;

size_t sz;

if (SEC_SYNOPSIS != n->sec ||

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

MDOC_TEXT != n->type)

return(0);

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

parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

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 1594 parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_n

Line 1663 parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_n

cp++;

putkey(mpage, cp, TYPE_Fn);

if (n->sec == SEC_SYNOPSIS)

putkey(mpage, cp, NAME_SYN);

if (n->string < cp)

putkeys(mpage, n->string, cp - n->string, TYPE_Ft);

Line 1606 parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_n

Line 1677 parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_n

}

static int

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

parse_mdoc_Fo(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

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

if (n->sec == SEC_SYNOPSIS)

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

return(0);

}

static int

parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

char *cp;

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

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

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

}

static int

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

parse_mdoc_Nd(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

if (MDOC_BODY == n->type)

Line 1634 parse_mdoc_Nd(struct mpage *mpage, const struct mdoc_n

Line 1718 parse_mdoc_Nd(struct mpage *mpage, const struct mdoc_n

}

static int

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

parse_mdoc_Nm(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

if (SEC_NAME == n->sec)

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

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

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

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

if (n->child == NULL)

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

else

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

mpage->name_head_done = 1;

}

return(0);

}

static int

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

parse_mdoc_Sh(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

return(SEC_CUSTOM == n->sec && MDOC_HEAD == n->type);

}

static int

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

parse_mdoc_head(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

return(MDOC_HEAD == n->type);

}

static int

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

parse_mdoc_body(struct mpage *mpage, const struct mdoc_meta *meta,

const struct mdoc_node *n)

{

return(MDOC_BODY == n->type);

Line 1671 parse_mdoc_body(struct mpage *mpage, const struct mdoc

Line 1769 parse_mdoc_body(struct mpage *mpage, const struct mdoc

* When we finish the manual, we'll dump the table.

static void

putkeys(const struct mpage *mpage,

putkeys(const struct mpage *mpage, char *cp, size_t sz, uint64_t v)

const char *cp, size_t sz, uint64_t v)

{

struct ohash *htab;

struct str *s;

const char *end;

unsigned int slot;

int i;

int i, mustfree;

if (0 == sz)

return;

mustfree = render_string(&cp, &sz);

if (TYPE_Nm & v) {

htab = &names;

v &= name_mask;

name_mask &= ~NAME_FIRST;

if (v & NAME_FIRST)

name_mask &= ~NAME_FIRST;

if (debug > 1)

say(mpage->mlinks->file,

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

"Adding name %*s, bits=%d", sz, cp, v);

} else {

htab = &strings;

if (debug > 1)

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

if (1 << i & v)

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

say(mpage->mlinks->file,

"Adding key %s=%*s",

mansearch_keynames[i], sz, cp);

Line 1708 putkeys(const struct mpage *mpage,

Line 1808 putkeys(const struct mpage *mpage,

s->mask |= v;

return;

} else if (NULL == s) {

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

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

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

ohash_insert(htab, slot, s);

}

s->mpage = mpage;

s->mask = v;

if (mustfree)

free(cp);

}

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

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

}

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

* If the string contains escape sequences,

* if the key contains no escape sequences.

* replace it with an allocated rendering and return 1,

* such that the caller can free it after use.

* Otherwise, do nothing and return 0.

static void

static int

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

render_string(char **public, size_t *psz)

{

size_t sz, bsz, pos;

const char *src, *scp, *addcp, *seq;

char *dst;

size_t ssz, dsz, addsz;

char utfbuf[7], res[6];

char *buf;

int seqlen, unicode;

const char *seq, *cpp, *val;

int len, u;

enum mandoc_esc esc;

assert(NULL == key->rendered);

res[0] = '\\';

res[1] = '\t';

res[2] = ASCII_NBRSP;

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

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

res[4] = ASCII_BREAK;

res[5] = '\0';

val = key->key;

src = scp = *public;

bsz = strlen(val);

ssz = *psz;

dst = NULL;

dsz = 0;

while (scp < src + *psz) {

* Pre-check: if we have no stop-characters, then set the

* pointer as ourselvse and get out of here.

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

key->rendered = key->key;

return;

}

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

/* Leave normal characters unchanged. */

buf = mandoc_malloc(++bsz);

if (strchr(res, *scp) == NULL) {

pos = 0;

if (dst != NULL)

dst[dsz++] = *scp;

scp++;

continue;

}

while ('\0' != *val) {

* Halt on the first escape sequence.

* Found something that requires replacing,

* This also halts on the end of string, in which case

* make sure we have a destination buffer.

* we just copy, fallthrough, and exit the loop.

if ((sz = strcspn(val, res)) > 0) {

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

if (dst == NULL) {

pos += sz;

dst = mandoc_malloc(ssz + 1);

val += sz;

dsz = scp - src;

memcpy(dst, src, dsz);

}

switch (*val) {

/* Handle single-char special characters. */

case (ASCII_HYPH):

buf[pos++] = '-';

switch (*scp) {

val++;

case '\\':

break;

case '\t':

/* FALLTHROUGH */

case ASCII_NBRSP:

dst[dsz++] = ' ';

scp++;

continue;

case ('\t'):

case ASCII_HYPH:

dst[dsz++] = '-';

/* FALLTHROUGH */

case (ASCII_NBRSP):

case ASCII_BREAK:

buf[pos++] = ' ';

scp++;

val++;

/* FALLTHROUGH */

case (ASCII_BREAK):

continue;

default:

break;

abort();

}

if ('\\' != *val)

break;

/* Read past the slash. */

val++;

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

* Found an escape sequence.

* predefined character or special character.

* Read past the slash, then parse it.

* Ignore everything except characters.

esc = mandoc_escape

scp++;

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

if (mandoc_escape(&scp, &seq, &seqlen) != ESCAPE_SPECIAL)

if (ESCAPE_ERROR == esc)

break;

if (ESCAPE_SPECIAL != esc)

continue;

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

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

if (write_utf8) {

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

unicode = mchars_spec2cp(mchars, seq, seqlen);

if (unicode <= 0)

continue;

cpp = utfbuf;

addsz = utf8(unicode, utfbuf);

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

if (addsz == 0)

continue;

sz = strlen(cpp);

addcp = utfbuf;

} else {

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

addcp = mchars_spec2str(mchars, seq, seqlen, &addsz);

if (NULL == cpp)

if (addcp == NULL)

continue;

if (ASCII_NBRSP == *cpp) {

if (*addcp == ASCII_NBRSP) {

cpp = " ";

addcp = " ";

sz = 1;

addsz = 1;

}

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

bsz += sz;

ssz += addsz;

buf = mandoc_realloc(buf, bsz);

dst = mandoc_realloc(dst, ssz + 1);

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

memcpy(dst + dsz, addcp, addsz);

pos += sz;

dsz += addsz;

}

if (dst != NULL) {

*public = dst;

*psz = dsz;

}

buf[pos] = '\0';

/* Trim trailing whitespace and NUL-terminate. */

key->rendered = buf;

while (*psz > 0 && (*public)[*psz - 1] == ' ')

--*psz;

if (dst != NULL) {

(*public)[*psz] = '\0';

return(1);

} else

return(0);

}

static void

Line 1898 dbadd_mlink(const struct mlink *mlink)

Line 2006 dbadd_mlink(const struct mlink *mlink)

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

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

Line 1910 dbadd_mlink(const struct mlink *mlink)

Line 2042 dbadd_mlink(const struct mlink *mlink)

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

static void

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

dbadd(struct mpage *mpage)

{

struct mlink *mlink;

struct str *key;

char *cp;

size_t i;

unsigned int slot;

int mustfree;

mlink = mpage->mlinks;

if (nodb) {

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

key = ohash_next(&names, &slot))

free(key);

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

key = ohash_next(&strings, &slot))

free(key);

if (0 == debug)

return;

while (NULL != mlink) {

fputs(mlink->name, stdout);

if (NULL == mlink->next ||

Line 1946 dbadd(struct mpage *mpage, struct mchars *mc)

Line 2088 dbadd(struct mpage *mpage, struct mchars *mc)

if (debug)

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

cp = mpage->desc;

i = strlen(cp);

mustfree = render_string(&cp, &i);

i = 1;

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

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

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

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

SQL_STEP(stmts[STMT_INSERT_PAGE]);

mpage->recno = sqlite3_last_insert_rowid(db);

mpage->pageid = sqlite3_last_insert_rowid(db);

sqlite3_reset(stmts[STMT_INSERT_PAGE]);

if (mustfree)

free(cp);

while (NULL != mlink) {

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

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_TEXT(stmts[STMT_INSERT_NAME], i, key->key);

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

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

if (NULL == key->rendered)

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

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

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

}

Line 2059 dbclose(int real)

Line 2199 dbclose(int real)

}

switch (child = fork()) {

case (-1):

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return;

case (0):

case 0:

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

tempfilename, MANDOC_DB, NULL);

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

Line 2085 dbclose(int real)

Line 2225 dbclose(int real)

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

switch (child = fork()) {

case (-1):

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return;

case (0):

case 0:

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

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

exit((int)MANDOCLEVEL_SYSERR);

Line 2120 dbopen(int real)

Line 2260 dbopen(int real)

const char *sql;

int rc, ofl;

if (nodb)

return(1);

*tempfilename = '\0';

Line 2130 dbopen(int real)

Line 2270 dbopen(int real)

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

if (SQLITE_OK != rc) {

exitcode = (int)MANDOCLEVEL_SYSERR;

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

if (SQLITE_CANTOPEN != rc)

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

return(0);

}

goto prepare_statements;

Line 2140 dbopen(int real)

Line 2281 dbopen(int real)

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_errmsg(db));

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

return(0);

}

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

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

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

sizeof(tempfilename));

exitcode = (int)MANDOCLEVEL_SYSERR;

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,

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

sizeof(tempfilename)) >= 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));

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

return(0);

}

Line 2177 create_tables:

Line 2309 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"

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

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

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

"ON DELETE CASCADE\n"

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

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

"ON DELETE CASCADE\n"

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

SQL_EXEC("PRAGMA foreign_keys = ON");

if (SQLITE_OK != sqlite3_exec(db,

sql = "DELETE FROM mpages WHERE id IN "

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

Line 2220 prepare_statements:

Line 2364 prepare_statements:

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

Line 2233 prepare_statements:

Line 2379 prepare_statements:

* synchronous mode for much better performance.

if (real)

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

SQL_EXEC("PRAGMA synchronous = OFF");

"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 void *

hash_halloc(size_t sz, void *arg)

hash_calloc(size_t n, size_t sz, void *arg)

{

return(mandoc_calloc(sz, 1));

return(mandoc_calloc(n, sz));

}

static void *

Line 2255 hash_alloc(size_t sz, void *arg)

Line 2407 hash_alloc(size_t sz, void *arg)

}

static void

hash_free(void *p, size_t sz, void *arg)

hash_free(void *p, void *arg)

{

free(p);

}

static int

set_basedir(const char *targetdir)

set_basedir(const char *targetdir, int report_baddir)

{

static char startdir[PATH_MAX];

static int fd;

static int getcwd_status; /* 1 = ok, 2 = failure */

static int chdir_status; /* 1 = changed directory */

char *cp;

* Remember where we started by keeping a fd open to the origin

* Remember the original working directory, if possible.

* path component: throughout this utility, we chdir() a lot to

* This will be needed if the second or a later directory

* handle relative paths, and by doing this, we can return to

* on the command line is given as a relative path.

* the starting point.

* Do not error out if the current directory is not

* searchable: Maybe it won't be needed after all.

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

if (0 == getcwd_status) {

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

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

getcwd_status = 2;

(void)strlcpy(startdir, strerror(errno),

sizeof(startdir));

} else

getcwd_status = 1;

}

* We are leaving the old base directory.

* Do not use it any longer, not even for messages.

*basedir = '\0';

* If and only if the directory was changed earlier and

* the next directory to process is given as a relative path,

* first go back, or bail out if that is impossible.

if (chdir_status && '/' != *targetdir) {

if (2 == getcwd_status) {

exitcode = (int)MANDOCLEVEL_SYSERR;

if (NULL != targetdir)

say("", "getcwd: %s", startdir);

say("", "&getcwd");

return(0);

}

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

if (-1 == chdir(startdir)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return(0);

}

if (NULL == targetdir)

targetdir = startdir;

} else {

if (-1 == fd)

return(0);

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

close(fd);

basedir[0] = '\0';

exitcode = (int)MANDOCLEVEL_SYSERR;

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

return(0);

}

if (NULL == targetdir) {

close(fd);

return(1);

}

* Always resolve basedir to the canonicalized absolute

* pathname and append a trailing slash, such that

* we can reliably check whether files are inside.

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

basedir[0] = '\0';

if (report_baddir || errno != ENOENT) {

exitcode = (int)MANDOCLEVEL_BADARG;

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

}

return(0);

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

exitcode = (int)MANDOCLEVEL_BADARG;

if (report_baddir || errno != ENOENT) {

say("", "&chdir");

exitcode = (int)MANDOCLEVEL_BADARG;

say("", "&chdir");

}

return(0);

}

chdir_status = 1;

cp = strchr(basedir, '\0');

if ('/' != cp[-1]) {

if (cp - basedir >= PATH_MAX - 1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "Filename too long");

return(0);

}

*cp++ = '/';

*cp = '\0';

}

return(1);

}

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

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

if ('\0' != *basedir)

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

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

fputs("//", stderr);

fputc('/', stderr);

if ('\0' != *file)

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

use_errno = 1;

if (NULL != format) {

switch (*format) {

case ('&'):

case '&':

format++;

break;

case ('\0'):

case '\0':

format = NULL;

break;

default:

CVSweb