=================================================================== RCS file: /cvs/mandoc/mandocdb.c,v retrieving revision 1.7 retrieving revision 1.146 diff -u -p -r1.7 -r1.146 --- mandoc/mandocdb.c 2011/11/13 00:53:13 1.7 +++ mandoc/mandocdb.c 2014/04/27 23:08:56 1.146 @@ -1,6 +1,7 @@ -/* $Id: mandocdb.c,v 1.7 2011/11/13 00:53:13 schwarze Exp $ */ +/* $Id: mandocdb.c,v 1.146 2014/04/27 23:08:56 schwarze Exp $ */ /* - * Copyright (c) 2011 Kristaps Dzonsons + * Copyright (c) 2011, 2012 Kristaps Dzonsons + * Copyright (c) 2011, 2012, 2013, 2014 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,755 +19,1613 @@ #include "config.h" #endif -#include +#include +#include #include -#include +#include +#include #include +#include #include +#include +#include #include #include #include #include +#include -#ifdef __linux__ -# include +#ifdef HAVE_OHASH +#include #else -# include +#include "compat_ohash.h" #endif +#include -#include "man.h" #include "mdoc.h" +#include "man.h" #include "mandoc.h" +#include "mandoc_aux.h" +#include "manpath.h" +#include "mansearch.h" -#define MANDOC_DB "mandoc.db" -#define MANDOC_IDX "mandoc.index" -#define MANDOC_BUFSZ BUFSIZ -#define MANDOC_SLOP 1024 +extern int mansearch_keymax; +extern const char *const mansearch_keynames[]; -/* Bit-fields. See mandocdb.8. */ +#define SQL_EXEC(_v) \ + if (SQLITE_OK != sqlite3_exec(db, (_v), NULL, NULL, NULL)) \ + say("", "%s: %s", (_v), sqlite3_errmsg(db)) +#define SQL_BIND_TEXT(_s, _i, _v) \ + if (SQLITE_OK != sqlite3_bind_text \ + ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \ + say(mlink->file, "%s", sqlite3_errmsg(db)) +#define SQL_BIND_INT(_s, _i, _v) \ + if (SQLITE_OK != sqlite3_bind_int \ + ((_s), (_i)++, (_v))) \ + say(mlink->file, "%s", sqlite3_errmsg(db)) +#define SQL_BIND_INT64(_s, _i, _v) \ + if (SQLITE_OK != sqlite3_bind_int64 \ + ((_s), (_i)++, (_v))) \ + say(mlink->file, "%s", sqlite3_errmsg(db)) +#define SQL_STEP(_s) \ + if (SQLITE_DONE != sqlite3_step((_s))) \ + say(mlink->file, "%s", sqlite3_errmsg(db)) -#define TYPE_NAME 0x01 -#define TYPE_FUNCTION 0x02 -#define TYPE_UTILITY 0x04 -#define TYPE_INCLUDES 0x08 -#define TYPE_VARIABLE 0x10 -#define TYPE_STANDARD 0x20 -#define TYPE_AUTHOR 0x40 -#define TYPE_CONFIG 0x80 -#define TYPE_DESC 0x100 -#define TYPE_XREF 0x200 -#define TYPE_PATH 0x400 -#define TYPE_ENV 0x800 -#define TYPE_ERR 0x1000 +enum op { + OP_DEFAULT = 0, /* new dbs from dir list or default config */ + OP_CONFFILE, /* new databases from custom config file */ + OP_UPDATE, /* delete/add entries in existing database */ + OP_DELETE, /* delete entries from existing database */ + OP_TEST /* change no databases, report potential problems */ +}; -/* Tiny list for files. No need to bring in QUEUE. */ +enum form { + FORM_NONE, /* format is unknown */ + FORM_SRC, /* format is -man or -mdoc */ + FORM_CAT /* format is cat */ +}; -struct of { - char *fname; /* heap-allocated */ - struct of *next; /* NULL for last one */ - struct of *first; /* first in list */ +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 */ }; -/* Buffer for storing growable data. */ +struct inodev { + ino_t st_ino; + dev_t st_dev; +}; -struct buf { - char *cp; - size_t len; /* current length */ - size_t size; /* total buffer size */ +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 */ + char *title; /* title from file content */ + char *desc; /* description from file content */ + struct mlink *mlinks; /* singly linked list */ }; -/* Operation we're going to perform. */ +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 gzip; /* filename has a .gz suffix */ +}; -enum op { - OP_NEW = 0, /* new database */ - OP_UPDATE, /* delete/add entries in existing database */ - OP_DELETE /* delete entries from existing database */ +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 }; -#define MAN_ARGS DB *hash, \ - struct buf *buf, \ - struct buf *dbuf, \ - const struct man_node *n -#define MDOC_ARGS DB *hash, \ - struct buf *buf, \ - struct buf *dbuf, \ - const struct mdoc_node *n, \ - const struct mdoc_meta *m +typedef int (*mdoc_fp)(struct mpage *, const struct mdoc_node *); -static void buf_appendmdoc(struct buf *, - const struct mdoc_node *, int); -static void buf_append(struct buf *, const char *); -static void buf_appendb(struct buf *, - const void *, size_t); -static void dbt_put(DB *, const char *, DBT *, DBT *); -static void hash_put(DB *, const struct buf *, int); -static void hash_reset(DB **); -static void index_merge(const struct of *, struct mparse *, - struct buf *, struct buf *, - DB *, DB *, const char *, - DB *, const char *, int, - recno_t, const recno_t *, size_t); -static void index_prune(const struct of *, DB *, - const char *, DB *, const char *, - int, recno_t *, recno_t **, size_t *); -static void ofile_argbuild(char *[], int, int, struct of **); -static int ofile_dirbuild(const char *, int, struct of **); -static void ofile_free(struct of *); -static int pman_node(MAN_ARGS); -static void pmdoc_node(MDOC_ARGS); -static void pmdoc_An(MDOC_ARGS); -static void pmdoc_Cd(MDOC_ARGS); -static void pmdoc_Er(MDOC_ARGS); -static void pmdoc_Ev(MDOC_ARGS); -static void pmdoc_Fd(MDOC_ARGS); -static void pmdoc_In(MDOC_ARGS); -static void pmdoc_Fn(MDOC_ARGS); -static void pmdoc_Fo(MDOC_ARGS); -static void pmdoc_Nd(MDOC_ARGS); -static void pmdoc_Nm(MDOC_ARGS); -static void pmdoc_Pa(MDOC_ARGS); -static void pmdoc_St(MDOC_ARGS); -static void pmdoc_Vt(MDOC_ARGS); -static void pmdoc_Xr(MDOC_ARGS); -static void usage(void); +struct mdoc_handler { + mdoc_fp fp; /* optional handler */ + uint64_t mask; /* set unless handler returns 0 */ +}; -typedef void (*pmdoc_nf)(MDOC_ARGS); +static void dbclose(int); +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 *); +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 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 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 *); +static int parse_mdoc_head(struct mpage *, const struct mdoc_node *); +static int parse_mdoc_Fd(struct mpage *, const struct mdoc_node *); +static int parse_mdoc_Fn(struct mpage *, const struct mdoc_node *); +static int parse_mdoc_Nd(struct mpage *, const struct mdoc_node *); +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 *, char *, uint64_t); +static void putkeys(const struct mpage *, + const char *, size_t, uint64_t); +static void putmdockey(const struct mpage *, + const struct mdoc_node *, uint64_t); +static void render_key(struct mchars *, struct str *); +static void say(const char *, const char *, ...); +static int set_basedir(const char *); +static int treescan(void); +static size_t utf8(unsigned int, char [7]); -static const pmdoc_nf mdocs[MDOC_MAX] = { - NULL, /* Ap */ - NULL, /* Dd */ - NULL, /* Dt */ - NULL, /* Os */ - NULL, /* Sh */ - NULL, /* Ss */ - NULL, /* Pp */ - NULL, /* D1 */ - NULL, /* Dl */ - NULL, /* Bd */ - NULL, /* Ed */ - NULL, /* Bl */ - NULL, /* El */ - NULL, /* It */ - NULL, /* Ad */ - pmdoc_An, /* An */ - NULL, /* Ar */ - pmdoc_Cd, /* Cd */ - NULL, /* Cm */ - NULL, /* Dv */ - pmdoc_Er, /* Er */ - pmdoc_Ev, /* Ev */ - NULL, /* Ex */ - NULL, /* Fa */ - pmdoc_Fd, /* Fd */ - NULL, /* Fl */ - pmdoc_Fn, /* Fn */ - NULL, /* Ft */ - NULL, /* Ic */ - pmdoc_In, /* In */ - NULL, /* Li */ - pmdoc_Nd, /* Nd */ - pmdoc_Nm, /* Nm */ - NULL, /* Op */ - NULL, /* Ot */ - pmdoc_Pa, /* Pa */ - NULL, /* Rv */ - pmdoc_St, /* St */ - pmdoc_Vt, /* Va */ - pmdoc_Vt, /* Vt */ - pmdoc_Xr, /* Xr */ - NULL, /* %A */ - NULL, /* %B */ - NULL, /* %D */ - NULL, /* %I */ - NULL, /* %J */ - NULL, /* %N */ - NULL, /* %O */ - NULL, /* %P */ - NULL, /* %R */ - NULL, /* %T */ - NULL, /* %V */ - NULL, /* Ac */ - NULL, /* Ao */ - NULL, /* Aq */ - NULL, /* At */ - NULL, /* Bc */ - NULL, /* Bf */ - NULL, /* Bo */ - NULL, /* Bq */ - NULL, /* Bsx */ - NULL, /* Bx */ - NULL, /* Db */ - NULL, /* Dc */ - NULL, /* Do */ - NULL, /* Dq */ - NULL, /* Ec */ - NULL, /* Ef */ - NULL, /* Em */ - NULL, /* Eo */ - NULL, /* Fx */ - NULL, /* Ms */ - NULL, /* No */ - NULL, /* Ns */ - NULL, /* Nx */ - NULL, /* Ox */ - NULL, /* Pc */ - NULL, /* Pf */ - NULL, /* Po */ - NULL, /* Pq */ - NULL, /* Qc */ - NULL, /* Ql */ - NULL, /* Qo */ - NULL, /* Qq */ - NULL, /* Re */ - NULL, /* Rs */ - NULL, /* Sc */ - NULL, /* So */ - NULL, /* Sq */ - NULL, /* Sm */ - NULL, /* Sx */ - NULL, /* Sy */ - NULL, /* Tn */ - NULL, /* Ux */ - NULL, /* Xc */ - NULL, /* Xo */ - pmdoc_Fo, /* Fo */ - NULL, /* Fc */ - NULL, /* Oo */ - NULL, /* Oc */ - NULL, /* Bk */ - NULL, /* Ek */ - NULL, /* Bt */ - NULL, /* Hf */ - NULL, /* Fr */ - NULL, /* Ud */ - NULL, /* Lb */ - NULL, /* Lp */ - NULL, /* Lk */ - NULL, /* Mt */ - NULL, /* Brq */ - NULL, /* Bro */ - NULL, /* Brc */ - NULL, /* %C */ - NULL, /* Es */ - NULL, /* En */ - NULL, /* Dx */ - NULL, /* %Q */ - NULL, /* br */ - NULL, /* sp */ - NULL, /* %U */ - NULL, /* Ta */ +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 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 */ + { NULL, 0 }, /* Dd */ + { NULL, 0 }, /* Dt */ + { NULL, 0 }, /* Os */ + { parse_mdoc_Sh, TYPE_Sh }, /* Sh */ + { parse_mdoc_head, TYPE_Ss }, /* Ss */ + { NULL, 0 }, /* Pp */ + { NULL, 0 }, /* D1 */ + { NULL, 0 }, /* Dl */ + { NULL, 0 }, /* Bd */ + { NULL, 0 }, /* Ed */ + { NULL, 0 }, /* Bl */ + { NULL, 0 }, /* El */ + { NULL, 0 }, /* It */ + { NULL, 0 }, /* Ad */ + { NULL, TYPE_An }, /* An */ + { NULL, TYPE_Ar }, /* Ar */ + { NULL, TYPE_Cd }, /* Cd */ + { NULL, TYPE_Cm }, /* Cm */ + { NULL, TYPE_Dv }, /* Dv */ + { NULL, TYPE_Er }, /* Er */ + { NULL, TYPE_Ev }, /* Ev */ + { NULL, 0 }, /* Ex */ + { NULL, TYPE_Fa }, /* Fa */ + { parse_mdoc_Fd, 0 }, /* Fd */ + { NULL, TYPE_Fl }, /* Fl */ + { parse_mdoc_Fn, 0 }, /* Fn */ + { NULL, TYPE_Ft }, /* Ft */ + { NULL, TYPE_Ic }, /* Ic */ + { NULL, TYPE_In }, /* In */ + { NULL, TYPE_Li }, /* Li */ + { parse_mdoc_Nd, 0 }, /* Nd */ + { parse_mdoc_Nm, 0 }, /* Nm */ + { NULL, 0 }, /* Op */ + { NULL, 0 }, /* Ot */ + { NULL, TYPE_Pa }, /* Pa */ + { NULL, 0 }, /* Rv */ + { NULL, TYPE_St }, /* St */ + { NULL, TYPE_Va }, /* Va */ + { parse_mdoc_body, TYPE_Va }, /* Vt */ + { parse_mdoc_Xr, 0 }, /* Xr */ + { NULL, 0 }, /* %A */ + { NULL, 0 }, /* %B */ + { NULL, 0 }, /* %D */ + { NULL, 0 }, /* %I */ + { NULL, 0 }, /* %J */ + { NULL, 0 }, /* %N */ + { NULL, 0 }, /* %O */ + { NULL, 0 }, /* %P */ + { NULL, 0 }, /* %R */ + { NULL, 0 }, /* %T */ + { NULL, 0 }, /* %V */ + { NULL, 0 }, /* Ac */ + { NULL, 0 }, /* Ao */ + { NULL, 0 }, /* Aq */ + { NULL, TYPE_At }, /* At */ + { NULL, 0 }, /* Bc */ + { NULL, 0 }, /* Bf */ + { NULL, 0 }, /* Bo */ + { NULL, 0 }, /* Bq */ + { NULL, TYPE_Bsx }, /* Bsx */ + { NULL, TYPE_Bx }, /* Bx */ + { NULL, 0 }, /* Db */ + { NULL, 0 }, /* Dc */ + { NULL, 0 }, /* Do */ + { NULL, 0 }, /* Dq */ + { NULL, 0 }, /* Ec */ + { NULL, 0 }, /* Ef */ + { NULL, TYPE_Em }, /* Em */ + { NULL, 0 }, /* Eo */ + { NULL, TYPE_Fx }, /* Fx */ + { NULL, TYPE_Ms }, /* Ms */ + { NULL, 0 }, /* No */ + { NULL, 0 }, /* Ns */ + { NULL, TYPE_Nx }, /* Nx */ + { NULL, TYPE_Ox }, /* Ox */ + { NULL, 0 }, /* Pc */ + { NULL, 0 }, /* Pf */ + { NULL, 0 }, /* Po */ + { NULL, 0 }, /* Pq */ + { NULL, 0 }, /* Qc */ + { NULL, 0 }, /* Ql */ + { NULL, 0 }, /* Qo */ + { NULL, 0 }, /* Qq */ + { NULL, 0 }, /* Re */ + { NULL, 0 }, /* Rs */ + { NULL, 0 }, /* Sc */ + { NULL, 0 }, /* So */ + { NULL, 0 }, /* Sq */ + { NULL, 0 }, /* Sm */ + { NULL, 0 }, /* Sx */ + { NULL, TYPE_Sy }, /* Sy */ + { NULL, TYPE_Tn }, /* Tn */ + { NULL, 0 }, /* Ux */ + { NULL, 0 }, /* Xc */ + { NULL, 0 }, /* Xo */ + { parse_mdoc_head, 0 }, /* Fo */ + { NULL, 0 }, /* Fc */ + { NULL, 0 }, /* Oo */ + { NULL, 0 }, /* Oc */ + { NULL, 0 }, /* Bk */ + { NULL, 0 }, /* Ek */ + { NULL, 0 }, /* Bt */ + { NULL, 0 }, /* Hf */ + { NULL, 0 }, /* Fr */ + { NULL, 0 }, /* Ud */ + { NULL, TYPE_Lb }, /* Lb */ + { NULL, 0 }, /* Lp */ + { NULL, TYPE_Lk }, /* Lk */ + { NULL, TYPE_Mt }, /* Mt */ + { NULL, 0 }, /* Brq */ + { NULL, 0 }, /* Bro */ + { NULL, 0 }, /* Brc */ + { NULL, 0 }, /* %C */ + { NULL, 0 }, /* Es */ + { NULL, 0 }, /* En */ + { NULL, TYPE_Dx }, /* Dx */ + { NULL, 0 }, /* %Q */ + { NULL, 0 }, /* br */ + { NULL, 0 }, /* sp */ + { NULL, 0 }, /* %U */ + { NULL, 0 }, /* Ta */ }; -static const char *progname; int main(int argc, char *argv[]) { - struct mparse *mp; /* parse sequence */ - enum op op; /* current operation */ - const char *dir; - char ibuf[MAXPATHLEN], /* index fname */ - fbuf[MAXPATHLEN]; /* btree fname */ - int verb, /* output verbosity */ - ch, i, flags; - DB *idx, /* index database */ - *db, /* keyword database */ - *hash; /* temporary keyword hashtable */ - BTREEINFO info; /* btree configuration */ - recno_t maxrec; /* supremum of all records */ - recno_t *recs; /* buffer of empty records */ - size_t sz1, sz2, - recsz, /* buffer size of recs */ - reccur; /* valid number of recs */ - struct buf buf, /* keyword buffer */ - dbuf; /* description buffer */ - struct of *of; /* list of files for processing */ - extern int optind; - extern char *optarg; + 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; + memset(stmts, 0, STMT__MAX * sizeof(sqlite3_stmt *)); + memset(&dirs, 0, sizeof(struct manpaths)); + + mpages_info.alloc = mlinks_info.alloc = hash_alloc; + mpages_info.halloc = mlinks_info.halloc = hash_halloc; + mpages_info.hfree = mlinks_info.hfree = hash_free; + + mpages_info.key_offset = offsetof(struct mpage, inodev); + mlinks_info.key_offset = offsetof(struct mlink, file); + progname = strrchr(argv[0], '/'); if (progname == NULL) progname = argv[0]; else ++progname; - verb = 0; - of = NULL; - db = idx = NULL; - mp = NULL; - hash = NULL; - recs = NULL; - recsz = reccur = 0; - maxrec = 0; - op = OP_NEW; - dir = NULL; + /* + * 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)); \ + goto usage; \ + } while (/*CONSTCOND*/0) - while (-1 != (ch = getopt(argc, argv, "d:u:v"))) + path_arg = NULL; + op = OP_DEFAULT; + + while (-1 != (ch = getopt(argc, argv, "aC:Dd:npQT:tu:v"))) switch (ch) { - case ('d'): - dir = optarg; + case 'a': + use_all = 1; + break; + case 'C': + CHECKOP(op, ch); + path_arg = optarg; + op = OP_CONFFILE; + break; + case 'D': + debug++; + break; + case 'd': + CHECKOP(op, ch); + path_arg = optarg; op = OP_UPDATE; break; - case ('u'): - dir = optarg; + case 'n': + nodb = 1; + break; + 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); + goto usage; + } + write_utf8 = 1; + break; + case 't': + CHECKOP(op, ch); + dup2(STDOUT_FILENO, STDERR_FILENO); + op = OP_TEST; + nodb = warnings = 1; + break; + case 'u': + CHECKOP(op, ch); + path_arg = optarg; op = OP_DELETE; break; - case ('v'): - verb++; + case 'v': + /* Compatibility with espie@'s makewhatis. */ break; default: - usage(); - return((int)MANDOCLEVEL_BADARG); + goto usage; } argc -= optind; argv += optind; - memset(&info, 0, sizeof(BTREEINFO)); - info.flags = R_DUP; + if (OP_CONFFILE == op && argc > 0) { + fprintf(stderr, "-C: Too many arguments\n"); + goto usage; + } - mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL); + exitcode = (int)MANDOCLEVEL_OK; + mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL, NULL); + mc = mchars_alloc(); - memset(&buf, 0, sizeof(struct buf)); - memset(&dbuf, 0, sizeof(struct buf)); + ohash_init(&mpages, 6, &mpages_info); + ohash_init(&mlinks, 6, &mlinks_info); - buf.size = dbuf.size = MANDOC_BUFSZ; + if (OP_UPDATE == op || OP_DELETE == op || OP_TEST == op) { - buf.cp = mandoc_malloc(buf.size); - dbuf.cp = mandoc_malloc(dbuf.size); + /* + * All of these deal with a specific directory. + * Jump into that directory first. + */ + if (0 == set_basedir(path_arg)) + goto out; - flags = OP_NEW == op ? O_CREAT|O_TRUNC|O_RDWR : O_CREAT|O_RDWR; + if (dbopen(1)) { + /* + * The existing database is usable. Process + * all files specified on the command-line. + */ + 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); + dbclose(OP_DEFAULT == op ? 0 : 1); + } else { + /* + * If we have arguments, use them as our manpaths. + * If we don't, grok from manpath(1) or however else + * manpath_parse() wants to do it. + */ + if (argc > 0) { + dirs.paths = mandoc_reallocarray(NULL, + argc, 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 (OP_UPDATE == op || OP_DELETE == op) { - ibuf[0] = fbuf[0] = '\0'; + if (0 == dirs.sz) { + exitcode = (int)MANDOCLEVEL_BADARG; + say("", "Empty manpath"); + } - strlcat(fbuf, dir, MAXPATHLEN); - strlcat(fbuf, "/", MAXPATHLEN); - sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN); + /* + * First scan the tree rooted at a base directory, then + * build a new database and finally move it into place. + * Ignore zero-length directories and strip trailing + * slashes. + */ + for (j = 0; j < dirs.sz; j++) { + sz = strlen(dirs.paths[j]); + if (sz && '/' == dirs.paths[j][sz - 1]) + dirs.paths[j][--sz] = '\0'; + if (0 == sz) + continue; - strlcat(ibuf, dir, MAXPATHLEN); - strlcat(ibuf, "/", MAXPATHLEN); - sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN); + if (j) { + ohash_init(&mpages, 6, &mpages_info); + ohash_init(&mlinks, 6, &mlinks_info); + } - if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) { - fprintf(stderr, "%s: Path too long\n", dir); - exit((int)MANDOCLEVEL_BADARG); - } + if (0 == set_basedir(dirs.paths[j])) + goto out; + if (0 == treescan()) + goto out; + if (0 == set_basedir(dirs.paths[j])) + goto out; + if (0 == dbopen(0)) + goto out; - db = dbopen(fbuf, flags, 0644, DB_BTREE, &info); - idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL); + mpages_merge(mc, mp); + if (warnings && + ! (MPARSE_QUICK & mparse_options)) + names_check(); + dbclose(0); - if (NULL == db) { - perror(fbuf); - exit((int)MANDOCLEVEL_SYSERR); - } else if (NULL == db) { - perror(ibuf); - exit((int)MANDOCLEVEL_SYSERR); + if (j + 1 < dirs.sz) { + mpages_free(); + ohash_delete(&mpages); + ohash_delete(&mlinks); + } } + } +out: + set_basedir(NULL); + manpath_free(&dirs); + mchars_free(mc); + mparse_free(mp); + mpages_free(); + ohash_delete(&mpages); + ohash_delete(&mlinks); + return(exitcode); +usage: + fprintf(stderr, "usage: %s [-aDnpQ] [-C file] [-Tutf8]\n" + " %s [-aDnpQ] [-Tutf8] dir ...\n" + " %s [-DnpQ] [-Tutf8] -d dir [file ...]\n" + " %s [-Dnp] -u dir [file ...]\n" + " %s [-Q] -t file ...\n", + progname, progname, progname, + progname, progname); - if (verb > 2) { - printf("%s: Opened\n", fbuf); - printf("%s: Opened\n", ibuf); - } + return((int)MANDOCLEVEL_BADARG); +} - ofile_argbuild(argv, argc, verb, &of); - if (NULL == of) - goto out; +/* + * Scan a directory tree rooted at "basedir" for manpages. + * We use fts(), scanning directory parts along the way for clues to our + * section and architecture. + * + * If use_all has been specified, grok all files. + * If not, sanitise paths to the following: + * + * [./]man*[/]/.
+ * or + * [./]cat
[/]/.0 + * + * TODO: accomodate for multi-language directories. + */ +static int +treescan(void) +{ + char buf[PATH_MAX]; + FTS *f; + FTSENT *ff; + struct mlink *mlink; + int dform, gzip; + char *dsec, *arch, *fsec, *cp; + const char *path; + const char *argv[2]; - of = of->first; + argv[0] = "."; + argv[1] = (char *)NULL; - index_prune(of, db, fbuf, idx, ibuf, verb, - &maxrec, &recs, &recsz); + f = fts_open((char * const *)argv, + FTS_PHYSICAL | FTS_NOCHDIR, NULL); + if (NULL == f) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say("", "&fts_open"); + return(0); + } - if (OP_UPDATE == op) - index_merge(of, mp, &dbuf, &buf, hash, - db, fbuf, idx, ibuf, verb, - maxrec, recs, reccur); + dsec = arch = NULL; + dform = FORM_NONE; - goto out; - } + while (NULL != (ff = fts_read(f))) { + path = ff->fts_path + 2; + switch (ff->fts_info) { - for (i = 0; i < argc; i++) { - ibuf[0] = fbuf[0] = '\0'; + /* + * 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 */ - strlcat(fbuf, argv[i], MAXPATHLEN); - strlcat(fbuf, "/", MAXPATHLEN); - sz1 = strlcat(fbuf, MANDOC_DB, MAXPATHLEN); + /* + * If we're a regular file, add an mlink by using the + * stored directory data and handling the filename. + */ + case FTS_F: + if (0 == strcmp(path, MANDOC_DB)) + continue; + if ( ! use_all && ff->fts_level < 2) { + if (warnings) + say(path, "Extraneous file"); + continue; + } + 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, + "No filename suffix"); + continue; + } + } else if (0 == strcmp(++fsec, "html")) { + if (warnings) + say(path, "Skip html"); + continue; + } else if (0 == strcmp(fsec, "ps")) { + if (warnings) + say(path, "Skip ps"); + continue; + } else if (0 == strcmp(fsec, "pdf")) { + if (warnings) + say(path, "Skip pdf"); + continue; + } else if ( ! use_all && + ((FORM_SRC == dform && strcmp(fsec, dsec)) || + (FORM_CAT == dform && strcmp(fsec, "0")))) { + if (warnings) + say(path, "Wrong filename suffix"); + continue; + } else + fsec[-1] = '\0'; - strlcat(ibuf, argv[i], MAXPATHLEN); - strlcat(ibuf, "/", MAXPATHLEN); - sz2 = strlcat(ibuf, MANDOC_IDX, MAXPATHLEN); + mlink = mandoc_calloc(1, sizeof(struct mlink)); + 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; + mlink->name = ff->fts_name; + mlink->fsec = fsec; + mlink->gzip = gzip; + mlink_add(mlink, ff->fts_statp); + continue; - if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) { - fprintf(stderr, "%s: Path too long\n", argv[i]); - exit((int)MANDOCLEVEL_BADARG); + case FTS_D: + /* FALLTHROUGH */ + case FTS_DP: + break; + + default: + if (warnings) + say(path, "Not a regular file"); + continue; } - db = dbopen(fbuf, flags, 0644, DB_BTREE, &info); - idx = dbopen(ibuf, flags, 0644, DB_RECNO, NULL); + switch (ff->fts_level) { + case 0: + /* Ignore the root directory. */ + break; + case 1: + /* + * This might contain manX/ or catX/. + * Try to infer this from the name. + * If we're not in use_all, enforce it. + */ + cp = ff->fts_name; + if (FTS_DP == ff->fts_info) + break; - if (NULL == db) { - perror(fbuf); - exit((int)MANDOCLEVEL_SYSERR); - } else if (NULL == db) { - perror(ibuf); - exit((int)MANDOCLEVEL_SYSERR); - } + if (0 == strncmp(cp, "man", 3)) { + dform = FORM_SRC; + dsec = cp + 3; + } else if (0 == strncmp(cp, "cat", 3)) { + dform = FORM_CAT; + dsec = cp + 3; + } else { + dform = FORM_NONE; + dsec = NULL; + } - if (verb > 2) { - printf("%s: Truncated\n", fbuf); - printf("%s: Truncated\n", ibuf); + if (NULL != dsec || use_all) + break; + + if (warnings) + say(path, "Unknown directory part"); + fts_set(f, ff, FTS_SKIP); + break; + case 2: + /* + * Possibly our architecture. + * If we're descending, keep tabs on it. + */ + if (FTS_DP != ff->fts_info && NULL != dsec) + arch = ff->fts_name; + else + arch = NULL; + break; + default: + if (FTS_DP == ff->fts_info || use_all) + break; + if (warnings) + say(path, "Extraneous directory part"); + fts_set(f, ff, FTS_SKIP); + break; } + } - ofile_free(of); - of = NULL; + fts_close(f); + return(1); +} - if ( ! ofile_dirbuild(argv[i], verb, &of)) - exit((int)MANDOCLEVEL_SYSERR); +/* + * Add a file to the mlinks table. + * Do not verify that it's a "valid" looking manpage (we'll do that + * later). + * + * Try to infer the manual section, architecture, and page name from the + * path, assuming it looks like + * + * [./]man*[/]/.
+ * or + * [./]cat
[/]/.0 + * + * See treescan() for the fts(3) version of this. + */ +static void +filescan(const char *file) +{ + char buf[PATH_MAX]; + struct stat st; + struct mlink *mlink; + char *p, *start; - if (NULL == of) - continue; + assert(use_all); - of = of->first; + if (0 == strncmp(file, "./", 2)) + file += 2; - index_merge(of, mp, &dbuf, &buf, hash, db, fbuf, - idx, ibuf, verb, maxrec, recs, reccur); + /* + * 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; } -out: - if (db) - (*db->close)(db); - if (idx) - (*idx->close)(idx); - if (hash) - (*hash->close)(hash); - if (mp) - mparse_free(mp); + /* + * 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; + } - ofile_free(of); - free(buf.cp); - free(dbuf.cp); - free(recs); + if (strstr(buf, basedir) == buf) + start = buf + strlen(basedir) + 1; + else if (OP_TEST == op) + start = buf; + else { + exitcode = (int)MANDOCLEVEL_BADARG; + say("", "%s: outside base directory", buf); + return; + } - return(MANDOCLEVEL_OK); -} + /* + * 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; + } + if (strlcpy(buf, file, sizeof(buf)) >= sizeof(buf)) { + say(file, "Filename too long"); + return; + } + start = strstr(buf, basedir) == buf ? + buf + strlen(basedir) + 1 : buf; + } -void -index_merge(const struct of *of, struct mparse *mp, - struct buf *dbuf, struct buf *buf, - DB *hash, DB *db, const char *dbf, - DB *idx, const char *idxf, int verb, - recno_t maxrec, const recno_t *recs, size_t reccur) -{ - recno_t rec; - int ch; - DBT key, val; - struct mdoc *mdoc; - struct man *man; - const char *fn, *msec, *mtitle, *arch; - size_t sv; - unsigned seq; - char vbuf[8]; + mlink = mandoc_calloc(1, sizeof(struct mlink)); + if (strlcpy(mlink->file, start, sizeof(mlink->file)) >= + sizeof(mlink->file)) { + say(start, "Filename too long"); + return; + } - for (rec = 0; of; of = of->next) { - fn = of->fname; - if (reccur > 0) { - --reccur; - rec = recs[(int)reccur]; - } else if (maxrec > 0) { - rec = maxrec; - maxrec = 0; - } else - rec++; + /* + * First try to guess our directory structure. + * If we find a separator, try to look for man* or cat*. + * If we find one of these and what's underneath is a directory, + * assume it's an architecture. + */ + if (NULL != (p = strchr(start, '/'))) { + *p++ = '\0'; + if (0 == strncmp(start, "man", 3)) { + mlink->dform = FORM_SRC; + mlink->dsec = start + 3; + } else if (0 == strncmp(start, "cat", 3)) { + mlink->dform = FORM_CAT; + mlink->dsec = start + 3; + } - mparse_reset(mp); - hash_reset(&hash); - - if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) { - fprintf(stderr, "%s: Parse failure\n", fn); - continue; + start = p; + if (NULL != mlink->dsec && NULL != (p = strchr(start, '/'))) { + *p++ = '\0'; + mlink->arch = start; + start = p; } + } - mparse_result(mp, &mdoc, &man); - if (NULL == mdoc && NULL == man) - continue; + /* + * Now check the file suffix. + * Suffix of `.0' indicates a catpage, `.1-9' is a manpage. + */ + p = strrchr(start, '\0'); + while (p-- > start && '/' != *p && '.' != *p) + /* Loop. */ ; - msec = NULL != mdoc ? - mdoc_meta(mdoc)->msec : man_meta(man)->msec; - mtitle = NULL != mdoc ? - mdoc_meta(mdoc)->title : man_meta(man)->title; - arch = NULL != mdoc ? - mdoc_meta(mdoc)->arch : NULL; + if ('.' == *p) { + *p++ = '\0'; + mlink->fsec = p; + } - if (NULL == arch) - arch = ""; + /* + * Now try to parse the name. + * Use the filename portion of the path. + */ + mlink->name = start; + if (NULL != (p = strrchr(start, '/'))) { + mlink->name = p + 1; + *p = '\0'; + } + mlink_add(mlink, &st); +} - /* - * The index record value consists of a nil-terminated - * filename, a nil-terminated manual section, and a - * nil-terminated description. Since the description - * may not be set, we set a sentinel to see if we're - * going to write a nil byte in its place. - */ +static void +mlink_add(struct mlink *mlink, const struct stat *st) +{ + struct inodev inodev; + struct mpage *mpage; + unsigned int slot; - dbuf->len = 0; - buf_appendb(dbuf, fn, strlen(fn) + 1); - buf_appendb(dbuf, msec, strlen(msec) + 1); - buf_appendb(dbuf, mtitle, strlen(mtitle) + 1); - buf_appendb(dbuf, arch, strlen(arch) + 1); + assert(NULL != mlink->file); - sv = dbuf->len; + mlink->dsec = mandoc_strdup(mlink->dsec ? mlink->dsec : ""); + mlink->arch = mandoc_strdup(mlink->arch ? mlink->arch : ""); + mlink->name = mandoc_strdup(mlink->name ? mlink->name : ""); + mlink->fsec = mandoc_strdup(mlink->fsec ? mlink->fsec : ""); - /* Fix the record number in the btree value. */ + if ('0' == *mlink->fsec) { + free(mlink->fsec); + mlink->fsec = mandoc_strdup(mlink->dsec); + mlink->fform = FORM_CAT; + } else if ('1' <= *mlink->fsec && '9' >= *mlink->fsec) + mlink->fform = FORM_SRC; + else + mlink->fform = FORM_NONE; - if (mdoc) - pmdoc_node(hash, buf, dbuf, - mdoc_node(mdoc), mdoc_meta(mdoc)); - else - pman_node(hash, buf, dbuf, man_node(man)); + slot = ohash_qlookup(&mlinks, mlink->file); + assert(NULL == ohash_find(&mlinks, slot)); + ohash_insert(&mlinks, slot, mlink); - /* - * Copy from the in-memory hashtable of pending keywords - * into the database. - */ - - memset(vbuf, 0, sizeof(uint32_t)); - memcpy(vbuf + 4, &rec, sizeof(uint32_t)); + inodev.st_ino = st->st_ino; + inodev.st_dev = st->st_dev; + slot = ohash_lookup_memory(&mpages, (char *)&inodev, + sizeof(struct inodev), inodev.st_ino); + mpage = ohash_find(&mpages, slot); + if (NULL == mpage) { + mpage = mandoc_calloc(1, sizeof(struct mpage)); + mpage->inodev.st_ino = inodev.st_ino; + mpage->inodev.st_dev = inodev.st_dev; + ohash_insert(&mpages, slot, mpage); + } else + mlink->next = mpage->mlinks; + mpage->mlinks = mlink; + mlink->mpage = mpage; +} - seq = R_FIRST; - while (0 == (ch = (*hash->seq)(hash, &key, &val, seq))) { - seq = R_NEXT; +static void +mlink_free(struct mlink *mlink) +{ - memcpy(vbuf, val.data, sizeof(uint32_t)); - val.size = sizeof(vbuf); - val.data = vbuf; + free(mlink->dsec); + free(mlink->arch); + free(mlink->name); + free(mlink->fsec); + free(mlink); +} - if (verb > 1) - printf("%s: Added keyword: %s\n", - fn, (char *)key.data); - dbt_put(db, dbf, &key, &val); +static void +mpages_free(void) +{ + struct mpage *mpage; + struct mlink *mlink; + unsigned int slot; + + mpage = ohash_first(&mpages, &slot); + while (NULL != mpage) { + while (NULL != (mlink = mpage->mlinks)) { + mpage->mlinks = mlink->next; + mlink_free(mlink); } - if (ch < 0) { - perror("hash"); - exit((int)MANDOCLEVEL_SYSERR); + free(mpage->sec); + free(mpage->arch); + free(mpage->title); + free(mpage->desc); + free(mpage); + mpage = ohash_next(&mpages, &slot); + } +} + +/* + * For each mlink to the mpage, check whether the path looks like + * it is formatted, and if it does, check whether a source manual + * exists by the same name, ignoring the suffix. + * If both conditions hold, drop the mlink. + */ +static void +mlinks_undupe(struct mpage *mpage) +{ + char buf[PATH_MAX]; + struct mlink **prev; + struct mlink *mlink; + char *bufp; + + mpage->form = FORM_CAT; + prev = &mpage->mlinks; + while (NULL != (mlink = *prev)) { + if (FORM_CAT != mlink->dform) { + mpage->form = FORM_NONE; + goto nextlink; } - - /* - * Apply to the index. If we haven't had a description - * set, put an empty one in now. - */ + (void)strlcpy(buf, mlink->file, sizeof(buf)); + bufp = strstr(buf, "cat"); + assert(NULL != bufp); + memcpy(bufp, "man", 3); + if (NULL != (bufp = strrchr(buf, '.'))) + *++bufp = '\0'; + (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); + if (use_all) + goto nextlink; + *prev = mlink->next; + mlink_free(mlink); + continue; +nextlink: + prev = &(*prev)->next; + } +} - if (dbuf->len == sv) - buf_appendb(dbuf, "", 1); +static void +mlink_check(struct mpage *mpage, struct mlink *mlink) +{ + struct str *str; + unsigned int slot; - key.data = &rec; - key.size = sizeof(recno_t); + /* + * Check whether the manual section given in a file + * agrees with the directory where the file is located. + * Some manuals have suffixes like (3p) on their + * section number either inside the file or in the + * directory name, some are linked into more than one + * section, like encrypt(1) = makekey(8). + */ - val.data = dbuf->cp; - val.size = dbuf->len; + if (FORM_SRC == mpage->form && + strcasecmp(mpage->sec, mlink->dsec)) + say(mlink->file, "Section \"%s\" manual in %s directory", + mpage->sec, mlink->dsec); - if (verb) - printf("%s: Added index\n", fn); - dbt_put(idx, idxf, &key, &val); - } + /* + * Manual page directories exist for each kernel + * architecture as returned by machine(1). + * However, many manuals only depend on the + * application architecture as returned by arch(1). + * For example, some (2/ARM) manuals are shared + * across the "armish" and "zaurus" kernel + * architectures. + * A few manuals are even shared across completely + * different architectures, for example fdformat(1) + * on amd64, i386, sparc, and sparc64. + */ + + if (strcasecmp(mpage->arch, mlink->arch)) + say(mlink->file, "Architecture \"%s\" manual in " + "\"%s\" directory", mpage->arch, mlink->arch); + + /* + * XXX + * parse_cat() doesn't set NAME_TITLE yet. + */ + + 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"); } /* - * Scan through all entries in the index file `idx' and prune those - * entries in `ofile'. - * Pruning consists of removing from `db', then invalidating the entry - * in `idx' (zeroing its value size). + * Run through the files in the global vector "mpages" + * and add them to the database specified in "basedir". + * + * This handles the parsing scheme itself, using the cues of directory + * and filename to determine whether the file is parsable or not. */ static void -index_prune(const struct of *ofile, DB *db, const char *dbf, - DB *idx, const char *idxf, int verb, - recno_t *maxrec, recno_t **recs, size_t *recsz) +mpages_merge(struct mchars *mc, struct mparse *mp) { - const struct of *of; - const char *fn; - unsigned seq, sseq; - DBT key, val; - size_t reccur; - int ch; + 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 status; + unsigned int pslot; + enum mandoclevel lvl; - reccur = 0; - seq = R_FIRST; - while (0 == (ch = (*idx->seq)(idx, &key, &val, seq))) { - seq = R_NEXT; - *maxrec = *(recno_t *)key.data; - if (0 == val.size) { - if (reccur >= *recsz) { - *recsz += MANDOC_SLOP; - *recs = mandoc_realloc(*recs, - *recsz * sizeof(recno_t)); - } - (*recs)[(int)reccur] = *maxrec; - reccur++; - continue; - } + str_info.alloc = hash_alloc; + str_info.halloc = hash_halloc; + str_info.hfree = hash_free; + str_info.key_offset = offsetof(struct str, key); - fn = (char *)val.data; - for (of = ofile; of; of = of->next) - if (0 == strcmp(fn, of->fname)) - break; + if (0 == nodb) + SQL_EXEC("BEGIN TRANSACTION"); - if (NULL == of) + mpage = ohash_first(&mpages, &pslot); + while (NULL != mpage) { + mlinks_undupe(mpage); + if (NULL == mpage->mlinks) { + mpage = ohash_next(&mpages, &pslot); continue; + } - sseq = R_FIRST; - while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) { - sseq = R_NEXT; - assert(8 == val.size); - if (*maxrec != *(recno_t *)(val.data + 4)) - continue; - if (verb) - printf("%s: Deleted keyword: %s\n", - fn, (char *)key.data); - ch = (*db->del)(db, &key, R_CURSOR); - if (ch < 0) + 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; + } } - if (ch < 0) { - perror(dbf); - exit((int)MANDOCLEVEL_SYSERR); + + /* + * Try interpreting the file as mdoc(7) or man(7) + * source code, unless it is already known to be + * formatted. Fall back to formatted mode. + */ + if (FORM_CAT != mpage->mlinks->dform || + FORM_CAT != mpage->mlinks->fform) { + lvl = mparse_readfd(mp, fd[0], mpage->mlinks->file); + if (lvl < MANDOCLEVEL_FATAL) + mparse_result(mp, &mdoc, &man, &sodest); } - if (verb) - printf("%s: Deleted index\n", fn); + if (NULL != sodest) { + mlink_dest = ohash_find(&mlinks, + ohash_qlookup(&mlinks, sodest)); + if (NULL != mlink_dest) { - val.size = 0; - ch = (*idx->put)(idx, &key, &val, R_CURSOR); - if (ch < 0) { - perror(idxf); - exit((int)MANDOCLEVEL_SYSERR); + /* 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); + mpage->arch = mdoc_meta(mdoc)->arch; + mpage->arch = mandoc_strdup( + NULL == mpage->arch ? "" : mpage->arch); + mpage->title = + mandoc_strdup(mdoc_meta(mdoc)->title); + } else if (NULL != man) { + mpage->form = FORM_SRC; + mpage->sec = + mandoc_strdup(man_meta(man)->msec); + mpage->arch = + mandoc_strdup(mpage->mlinks->arch); + mpage->title = + mandoc_strdup(man_meta(man)->title); + } else { + mpage->form = FORM_CAT; + mpage->sec = + mandoc_strdup(mpage->mlinks->dsec); + mpage->arch = + mandoc_strdup(mpage->mlinks->arch); + mpage->title = + mandoc_strdup(mpage->mlinks->name); } + putkey(mpage, mpage->sec, TYPE_sec); + putkey(mpage, '\0' == *mpage->arch ? + any : mpage->arch, TYPE_arch); - if (reccur >= *recsz) { - *recsz += MANDOC_SLOP; - *recs = mandoc_realloc - (*recs, *recsz * sizeof(recno_t)); + for (mlink = mpage->mlinks; mlink; mlink = mlink->next) { + if ('\0' != *mlink->dsec) + putkey(mpage, mlink->dsec, TYPE_sec); + if ('\0' != *mlink->fsec) + putkey(mpage, mlink->fsec, TYPE_sec); + putkey(mpage, '\0' == *mlink->arch ? + any : mlink->arch, TYPE_arch); + putkey(mpage, mlink->name, NAME_FILE); } - (*recs)[(int)reccur] = *maxrec; - reccur++; + assert(NULL == mpage->desc); + if (NULL != mdoc) { + if (NULL != (cp = mdoc_meta(mdoc)->name)) + putkey(mpage, cp, NAME_HEAD); + parse_mdoc(mpage, mdoc_node(mdoc)); + } else if (NULL != man) + parse_man(mpage, man_node(man)); + else + parse_cat(mpage, fd[0]); + if (NULL == mpage->desc) + 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); + +nextpage: + if (child_pid) { + 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); + mpage = ohash_next(&mpages, &pslot); } - (*maxrec)++; + + if (0 == nodb) + SQL_EXEC("END TRANSACTION"); } -/* - * Grow the buffer (if necessary) and copy in a binary string. - */ static void -buf_appendb(struct buf *buf, const void *cp, size_t sz) +names_check(void) { + sqlite3_stmt *stmt; + const char *name, *sec, *arch, *key; + int irc; - /* Overshoot by MANDOC_BUFSZ. */ + sqlite3_prepare_v2(db, + "SELECT name, sec, arch, key FROM (" + "SELECT name AS key, pageid FROM names " + "WHERE bits & ? AND NOT EXISTS (" + "SELECT pageid FROM mlinks " + "WHERE mlinks.pageid == names.pageid " + "AND mlinks.name == names.name" + ")" + ") JOIN (" + "SELECT sec, arch, name, pageid FROM mlinks " + "GROUP BY pageid" + ") USING (pageid);", + -1, &stmt, NULL); - while (buf->len + sz >= buf->size) { - buf->size = buf->len + sz + MANDOC_BUFSZ; - buf->cp = mandoc_realloc(buf->cp, buf->size); - } + if (SQLITE_OK != sqlite3_bind_int64(stmt, 1, NAME_TITLE)) + say("", "%s", sqlite3_errmsg(db)); - memcpy(buf->cp + (int)buf->len, cp, sz); - buf->len += sz; + 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); } -/* - * Append a nil-terminated string to the buffer. - * This can be invoked multiple times. - * The buffer string will be nil-terminated. - * If invoked multiple times, a space is put between strings. - */ static void -buf_append(struct buf *buf, const char *cp) +parse_cat(struct mpage *mpage, int fd) { - size_t sz; + FILE *stream; + char *line, *p, *title; + size_t len, plen, titlesz; - if (0 == (sz = strlen(cp))) + stream = (-1 == fd) ? + fopen(mpage->mlinks->file, "r") : + fdopen(fd, "r"); + if (NULL == stream) { + if (warnings) + say(mpage->mlinks->file, "&fopen"); return; + } - if (buf->len) - buf->cp[(int)buf->len - 1] = ' '; + /* Skip to first blank line. */ - buf_appendb(buf, cp, sz + 1); + while (NULL != (line = fgetln(stream, &len))) + if ('\n' == *line) + break; + + /* + * Assume the first line that is not indented + * is the first section header. Skip to it. + */ + + 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, + * appending a trailing space. + * Ignore empty (whitespace-only) lines. + */ + + titlesz = 0; + title = NULL; + + while (NULL != (line = fgetln(stream, &len))) { + if (' ' != *line || '\n' != line[len - 1]) + break; + while (len > 0 && isspace((unsigned char)*line)) { + line++; + len--; + } + if (1 == len) + continue; + title = mandoc_realloc(title, titlesz + len); + memcpy(title + titlesz, line, len); + titlesz += len; + title[titlesz - 1] = ' '; + } + + /* + * If no page content can be found, or the input line + * is already the next section header, or there is no + * trailing newline, reuse the page title as the page + * description. + */ + + if (NULL == title || '\0' == *title) { + if (warnings) + say(mpage->mlinks->file, + "Cannot find NAME section"); + fclose(stream); + free(title); + return; + } + + title = mandoc_realloc(title, titlesz + 1); + title[titlesz] = '\0'; + + /* + * Skip to the first dash. + * Use the remaining line as the description (no more than 70 + * bytes). + */ + + if (NULL != (p = strstr(title, "- "))) { + for (p += 2; ' ' == *p || '\b' == *p; p++) + /* Skip to next word. */ ; + } else { + if (warnings) + say(mpage->mlinks->file, + "No dash in title line"); + p = title; + } + + plen = strlen(p); + + /* Strip backspace-encoding from line. */ + + while (NULL != (line = memchr(p, '\b', plen))) { + len = line - p; + if (0 == len) { + memmove(line, line + 1, plen--); + continue; + } + memmove(line - 1, line + 1, plen - len); + plen -= 2; + } + + mpage->desc = mandoc_strdup(p); + fclose(stream); + free(title); } /* - * Recursively add all text from a given node. - * This is optimised for general mdoc nodes in this context, which do - * not consist of subexpressions and having a recursive call for n->next - * would be wasteful. - * The "f" variable should be 0 unless called from pmdoc_Nd for the - * description buffer, which does not start at the beginning of the - * buffer. + * Put a type/word pair into the word database for this particular file. */ static void -buf_appendmdoc(struct buf *buf, const struct mdoc_node *n, int f) +putkey(const struct mpage *mpage, char *value, uint64_t type) { + char *cp; - for ( ; n; n = n->next) { - if (n->child) - buf_appendmdoc(buf, n->child, f); + 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); +} - if (MDOC_TEXT == n->type && f) { - f = 0; - buf_appendb(buf, n->string, - strlen(n->string) + 1); - } else if (MDOC_TEXT == n->type) - buf_append(buf, n->string); +/* + * Grok all nodes at or below a certain mdoc node into putkey(). + */ +static void +putmdockey(const struct mpage *mpage, + const struct mdoc_node *n, uint64_t m) +{ + for ( ; NULL != n; n = n->next) { + if (NULL != n->child) + putmdockey(mpage, n->child, m); + if (MDOC_TEXT == n->type) + putkey(mpage, n->string, m); } } -/* ARGSUSED */ static void -pmdoc_An(MDOC_ARGS) +parse_man(struct mpage *mpage, const struct man_node *n) { - - if (SEC_AUTHORS != n->sec) + const struct man_node *head, *body; + char *start, *title; + char byte; + size_t sz; + + if (NULL == n) return; - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_AUTHOR); + /* + * We're only searching for one thing: the first text child in + * the BODY of a NAME section. Since we don't keep track of + * sections in -man, run some hoops to find out whether we're in + * the correct section or not. + */ + + if (MAN_BODY == n->type && MAN_SH == n->tok) { + 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. + * Yes, we might run away. + * But too many manuals have big, spread-out + * NAME sections over many lines. + */ + + title = NULL; + man_deroff(&title, body); + 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 + * dash, then a description. Try to puzzle out + * the name parts here. + */ + + start = title; + for ( ;; ) { + sz = strcspn(start, " ,"); + if ('\0' == start[sz]) + break; + + byte = start[sz]; + start[sz] = '\0'; + + /* + * Assume a stray trailing comma in the + * name list if a name begins with a dash. + */ + + if ('-' == start[0] || + ('\\' == start[0] && '-' == start[1])) + break; + + putkey(mpage, start, NAME_TITLE); + + if (' ' == byte) { + start += sz + 1; + break; + } + + assert(',' == byte); + start += sz + 1; + while (' ' == *start) + start++; + } + + if (start == title) { + putkey(mpage, start, NAME_TITLE); + free(title); + return; + } + + while (isspace((unsigned char)*start)) + start++; + + if (0 == strncmp(start, "-", 1)) + start += 1; + else if (0 == strncmp(start, "\\-\\-", 4)) + start += 4; + else if (0 == strncmp(start, "\\-", 2)) + start += 2; + else if (0 == strncmp(start, "\\(en", 4)) + start += 4; + else if (0 == strncmp(start, "\\(em", 4)) + start += 4; + + while (' ' == *start) + start++; + + mpage->desc = mandoc_strdup(start); + free(title); + return; + } + } + + for (n = n->child; n; n = n->next) { + if (NULL != mpage->desc) + break; + parse_man(mpage, n); + } } static void -hash_reset(DB **db) +parse_mdoc(struct mpage *mpage, const struct mdoc_node *n) { - DB *hash; - if (NULL != (hash = *db)) - (*hash->close)(hash); - - *db = dbopen(NULL, O_CREAT|O_RDWR, 0644, DB_HASH, NULL); - if (NULL == *db) { - perror("hash"); - exit((int)MANDOCLEVEL_SYSERR); + assert(NULL != n); + for (n = n->child; NULL != n; n = n->next) { + switch (n->type) { + case MDOC_ELEM: + /* FALLTHROUGH */ + case MDOC_BLOCK: + /* FALLTHROUGH */ + case MDOC_HEAD: + /* FALLTHROUGH */ + case MDOC_BODY: + /* FALLTHROUGH */ + case MDOC_TAIL: + if (NULL != mdocs[n->tok].fp) + if (0 == (*mdocs[n->tok].fp)(mpage, n)) + break; + if (mdocs[n->tok].mask) + putmdockey(mpage, n->child, + mdocs[n->tok].mask); + break; + default: + assert(MDOC_ROOT != n->type); + continue; + } + if (NULL != n->child) + parse_mdoc(mpage, n); } } -/* ARGSUSED */ -static void -pmdoc_Fd(MDOC_ARGS) +static int +parse_mdoc_Fd(struct mpage *mpage, const struct mdoc_node *n) { const char *start, *end; size_t sz; - - if (SEC_SYNOPSIS != n->sec) - return; - if (NULL == (n = n->child) || MDOC_TEXT != n->type) - return; + if (SEC_SYNOPSIS != n->sec || + NULL == (n = n->child) || + MDOC_TEXT != n->type) + return(0); + /* * Only consider those `Fd' macro fields that begin with an * "inclusion" token (versus, e.g., #define). */ + if (strcmp("#include", n->string)) - return; + return(0); if (NULL == (n = n->next) || MDOC_TEXT != n->type) - return; + return(0); /* * Strip away the enclosing angle brackets and make sure we're @@ -778,526 +1637,809 @@ pmdoc_Fd(MDOC_ARGS) start++; if (0 == (sz = strlen(start))) - return; + return(0); end = &start[(int)sz - 1]; if ('>' == *end || '"' == *end) end--; - assert(end >= start); + if (end > start) + putkeys(mpage, start, end - start + 1, TYPE_In); + return(0); +} - buf_appendb(buf, start, (size_t)(end - start + 1)); - buf_appendb(buf, "", 1); +static int +parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_node *n) +{ + char *cp; - hash_put(hash, buf, TYPE_INCLUDES); + 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, ' '))) + cp = n->string; + + while ('*' == *cp) + cp++; + + putkey(mpage, cp, TYPE_Fn); + + if (n->string < cp) + putkeys(mpage, n->string, cp - n->string, TYPE_Ft); + + for (n = n->next; NULL != n; n = n->next) + if (MDOC_TEXT == n->type) + putkey(mpage, n->string, TYPE_Fa); + + return(0); } -/* ARGSUSED */ -static void -pmdoc_Cd(MDOC_ARGS) +static int +parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_node *n) { - - if (SEC_SYNOPSIS != n->sec) - return; + char *cp; - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_CONFIG); + if (NULL == (n = n->child)) + return(0); + + if (NULL == n->next) { + putkey(mpage, n->string, TYPE_Xr); + return(0); + } + + mandoc_asprintf(&cp, "%s(%s)", n->string, n->next->string); + putkey(mpage, cp, TYPE_Xr); + free(cp); + return(0); } -/* ARGSUSED */ -static void -pmdoc_In(MDOC_ARGS) +static int +parse_mdoc_Nd(struct mpage *mpage, const struct mdoc_node *n) { - - if (SEC_SYNOPSIS != n->sec) - return; - if (NULL == n->child || MDOC_TEXT != n->child->type) - return; - buf_append(buf, n->child->string); - hash_put(hash, buf, TYPE_INCLUDES); + if (MDOC_BODY == n->type) + mdoc_deroff(&mpage->desc, n); + return(0); } -/* ARGSUSED */ -static void -pmdoc_Fn(MDOC_ARGS) +static int +parse_mdoc_Nm(struct mpage *mpage, const struct mdoc_node *n) { - const char *cp; - - if (SEC_SYNOPSIS != n->sec) - return; - if (NULL == n->child || MDOC_TEXT != n->child->type) - return; - /* .Fn "struct type *arg" "foo" */ + if (SEC_NAME == n->sec) + putmdockey(mpage, n->child, NAME_TITLE); + else if (SEC_SYNOPSIS == n->sec && MDOC_HEAD == n->type) + putmdockey(mpage, n->child, NAME_SYN); + return(0); +} - cp = strrchr(n->child->string, ' '); - if (NULL == cp) - cp = n->child->string; +static int +parse_mdoc_Sh(struct mpage *mpage, const struct mdoc_node *n) +{ - /* Strip away pointer symbol. */ + return(SEC_CUSTOM == n->sec && MDOC_HEAD == n->type); +} - while ('*' == *cp) - cp++; +static int +parse_mdoc_head(struct mpage *mpage, const struct mdoc_node *n) +{ - buf_append(buf, cp); - hash_put(hash, buf, TYPE_FUNCTION); + return(MDOC_HEAD == n->type); } -/* ARGSUSED */ -static void -pmdoc_St(MDOC_ARGS) +static int +parse_mdoc_body(struct mpage *mpage, const struct mdoc_node *n) { - - if (SEC_STANDARDS != n->sec) - return; - if (NULL == n->child || MDOC_TEXT != n->child->type) - return; - buf_append(buf, n->child->string); - hash_put(hash, buf, TYPE_STANDARD); + return(MDOC_BODY == n->type); } -/* ARGSUSED */ +/* + * Add a string to the hash table for the current manual. + * Each string has a bitmask telling which macros it belongs to. + * When we finish the manual, we'll dump the table. + */ static void -pmdoc_Xr(MDOC_ARGS) +putkeys(const struct mpage *mpage, + const char *cp, size_t sz, uint64_t v) { + struct ohash *htab; + struct str *s; + const char *end; + unsigned int slot; + int i; - if (NULL == (n = n->child)) + if (0 == sz) return; - buf_appendb(buf, n->string, strlen(n->string)); + 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); + } - if (NULL != (n = n->next)) { - buf_appendb(buf, ".", 1); - buf_appendb(buf, n->string, strlen(n->string) + 1); + end = cp + sz; + slot = ohash_qlookupi(htab, cp, &end); + s = ohash_find(htab, slot); + + if (NULL != s && mpage == s->mpage) { + s->mask |= v; + return; + } else if (NULL == s) { + 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; +} + +/* + * Take a Unicode codepoint and produce its UTF-8 encoding. + * This isn't the best way to do this, but it works. + * The magic numbers are from the UTF-8 packaging. + * They're not as scary as they seem: read the UTF-8 spec for details. + */ +static size_t +utf8(unsigned int cp, char out[7]) +{ + size_t rc; + + rc = 0; + if (cp <= 0x0000007F) { + rc = 1; + out[0] = (char)cp; + } else if (cp <= 0x000007FF) { + rc = 2; + out[0] = (cp >> 6 & 31) | 192; + out[1] = (cp & 63) | 128; + } else if (cp <= 0x0000FFFF) { + rc = 3; + out[0] = (cp >> 12 & 15) | 224; + out[1] = (cp >> 6 & 63) | 128; + out[2] = (cp & 63) | 128; + } else if (cp <= 0x001FFFFF) { + rc = 4; + out[0] = (cp >> 18 & 7) | 240; + out[1] = (cp >> 12 & 63) | 128; + out[2] = (cp >> 6 & 63) | 128; + out[3] = (cp & 63) | 128; + } else if (cp <= 0x03FFFFFF) { + rc = 5; + out[0] = (cp >> 24 & 3) | 248; + out[1] = (cp >> 18 & 63) | 128; + out[2] = (cp >> 12 & 63) | 128; + out[3] = (cp >> 6 & 63) | 128; + out[4] = (cp & 63) | 128; + } else if (cp <= 0x7FFFFFFF) { + rc = 6; + out[0] = (cp >> 30 & 1) | 252; + out[1] = (cp >> 24 & 63) | 128; + out[2] = (cp >> 18 & 63) | 128; + out[3] = (cp >> 12 & 63) | 128; + out[4] = (cp >> 6 & 63) | 128; + out[5] = (cp & 63) | 128; } else - buf_appendb(buf, ".", 2); + return(0); - hash_put(hash, buf, TYPE_XREF); + out[rc] = '\0'; + return(rc); } -/* ARGSUSED */ +/* + * Store the rendered version of a key, or alias the pointer + * if the key contains no escape sequences. + */ static void -pmdoc_Vt(MDOC_ARGS) +render_key(struct mchars *mc, struct str *key) { - const char *start; - size_t sz; - - if (SEC_SYNOPSIS != n->sec) - return; - if (MDOC_Vt == n->tok && MDOC_BODY != n->type) - return; - if (NULL == n->last || MDOC_TEXT != n->last->type) - return; + size_t sz, bsz, pos; + char utfbuf[7], res[6]; + char *buf; + const char *seq, *cpp, *val; + int len, u; + enum mandoc_esc esc; - /* - * Strip away leading pointer symbol '*' and trailing ';'. - */ + assert(NULL == key->rendered); - start = n->last->string; + res[0] = '\\'; + res[1] = '\t'; + res[2] = ASCII_NBRSP; + res[3] = ASCII_HYPH; + res[4] = ASCII_BREAK; + res[5] = '\0'; - while ('*' == *start) - start++; + val = key->key; + bsz = strlen(val); - if (0 == (sz = strlen(start))) + /* + * 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; + } - if (';' == start[(int)sz - 1]) - sz--; + /* Pre-allocate by the length of the input */ - if (0 == sz) - return; + buf = mandoc_malloc(++bsz); + pos = 0; - buf_appendb(buf, start, sz); - buf_appendb(buf, "", 1); - hash_put(hash, buf, TYPE_VARIABLE); -} + while ('\0' != *val) { + /* + * Halt on the first escape sequence. + * This also halts on the end of string, in which case + * we just copy, fallthrough, and exit the loop. + */ + if ((sz = strcspn(val, res)) > 0) { + memcpy(&buf[pos], val, sz); + pos += sz; + val += sz; + } -/* ARGSUSED */ -static void -pmdoc_Fo(MDOC_ARGS) -{ - - if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type) - return; - if (NULL == n->child || MDOC_TEXT != n->child->type) - return; + switch (*val) { + case ASCII_HYPH: + buf[pos++] = '-'; + val++; + continue; + case '\t': + /* FALLTHROUGH */ + case ASCII_NBRSP: + buf[pos++] = ' '; + val++; + /* FALLTHROUGH */ + case ASCII_BREAK: + continue; + default: + break; + } + if ('\\' != *val) + break; - buf_append(buf, n->child->string); - hash_put(hash, buf, TYPE_FUNCTION); -} + /* Read past the slash. */ + val++; -/* ARGSUSED */ -static void -pmdoc_Nd(MDOC_ARGS) -{ + /* + * Parse the escape sequence and see if it's a + * predefined character or special character. + */ - if (MDOC_BODY != n->type) - return; + esc = mandoc_escape((const char **)&val, + &seq, &len); + if (ESCAPE_ERROR == esc) + break; + if (ESCAPE_SPECIAL != esc) + continue; - buf_appendmdoc(dbuf, n->child, 1); - buf_appendmdoc(buf, n->child, 0); + /* + * Render the special character + * as either UTF-8 or ASCII. + */ - hash_put(hash, buf, TYPE_DESC); -} + if (write_utf8) { + if (0 == (u = mchars_spec2cp(mc, seq, len))) + continue; + cpp = utfbuf; + if (0 == (sz = utf8(u, utfbuf))) + continue; + sz = strlen(cpp); + } else { + cpp = mchars_spec2str(mc, seq, len, &sz); + if (NULL == cpp) + continue; + if (ASCII_NBRSP == *cpp) { + cpp = " "; + sz = 1; + } + } -/* ARGSUSED */ -static void -pmdoc_Er(MDOC_ARGS) -{ + /* Copy the rendered glyph into the stream. */ - if (SEC_ERRORS != n->sec) - return; - - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_ERR); -} + bsz += sz; + buf = mandoc_realloc(buf, bsz); + memcpy(&buf[pos], cpp, sz); + pos += sz; + } -/* ARGSUSED */ -static void -pmdoc_Ev(MDOC_ARGS) -{ - - if (SEC_ENVIRONMENT != n->sec) - return; - - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_ENV); + buf[pos] = '\0'; + key->rendered = buf; } -/* ARGSUSED */ static void -pmdoc_Pa(MDOC_ARGS) +dbadd_mlink(const struct mlink *mlink) { + size_t i; - if (SEC_FILES != n->sec) - return; - - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_PATH); + 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]); } -/* ARGSUSED */ +/* + * Flush the current page's terms (and their bits) into the database. + * Wrap the entire set of additions in a transaction to make sqlite be a + * little faster. + * Also, handle escape sequences at the last possible moment. + */ static void -pmdoc_Nm(MDOC_ARGS) +dbadd(struct mpage *mpage, struct mchars *mc) { - - if (SEC_NAME == n->sec) { - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_NAME); - return; - } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type) - return; + struct mlink *mlink; + struct str *key; + size_t i; + unsigned int slot; - if (NULL == n->child) - buf_append(buf, m->name); + mlink = mpage->mlinks; - buf_appendmdoc(buf, n->child, 0); - hash_put(hash, buf, TYPE_UTILITY); -} - -static void -hash_put(DB *db, const struct buf *buf, int mask) -{ - DBT key, val; - int rc; - - if (buf->len < 2) + if (nodb) { + if (0 == debug) + return; + 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; + } - key.data = buf->cp; - key.size = buf->len; + if (debug) + say(mlink->file, "Adding to database"); - if ((rc = (*db->get)(db, &key, &val, 0)) < 0) { - perror("hash"); - exit((int)MANDOCLEVEL_SYSERR); - } else if (0 == rc) - mask |= *(int *)val.data; + i = 1; + 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]); + mpage->pageid = sqlite3_last_insert_rowid(db); + sqlite3_reset(stmts[STMT_INSERT_PAGE]); - val.data = &mask; - val.size = sizeof(int); + while (NULL != mlink) { + dbadd_mlink(mlink); + mlink = mlink->next; + } + mlink = mpage->mlinks; - if ((rc = (*db->put)(db, &key, &val, 0)) < 0) { - perror("hash"); - exit((int)MANDOCLEVEL_SYSERR); - } + 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); + 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_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); + } } static void -dbt_put(DB *db, const char *dbn, DBT *key, DBT *val) +dbprune(void) { + struct mpage *mpage; + struct mlink *mlink; + size_t i; + unsigned int slot; - assert(key->size); - assert(val->size); + if (0 == nodb) + SQL_EXEC("BEGIN TRANSACTION"); - if (0 == (*db->put)(db, key, val, 0)) - return; - - perror(dbn); - exit((int)MANDOCLEVEL_SYSERR); - /* NOTREACHED */ + for (mpage = ohash_first(&mpages, &slot); NULL != mpage; + mpage = ohash_next(&mpages, &slot)) { + mlink = mpage->mlinks; + if (debug) + say(mlink->file, "Deleting from database"); + if (nodb) + continue; + for ( ; NULL != mlink; mlink = mlink->next) { + i = 1; + SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE], + i, mlink->dsec); + SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE], + i, mlink->arch); + SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE], + i, mlink->name); + SQL_STEP(stmts[STMT_DELETE_PAGE]); + sqlite3_reset(stmts[STMT_DELETE_PAGE]); + } + } + + if (0 == nodb) + SQL_EXEC("END TRANSACTION"); } /* - * Call out to per-macro handlers after clearing the persistent database - * key. If the macro sets the database key, flush it to the database. + * Close an existing database and its prepared statements. + * If "real" is not set, rename the temporary file into the real one. */ static void -pmdoc_node(MDOC_ARGS) +dbclose(int real) { + size_t i; + int status; + pid_t child; - if (NULL == n) + if (nodb) return; - switch (n->type) { - case (MDOC_HEAD): - /* FALLTHROUGH */ - case (MDOC_BODY): - /* FALLTHROUGH */ - case (MDOC_TAIL): - /* FALLTHROUGH */ - case (MDOC_BLOCK): - /* FALLTHROUGH */ - case (MDOC_ELEM): - if (NULL == mdocs[n->tok]) - break; + for (i = 0; i < STMT__MAX; i++) { + sqlite3_finalize(stmts[i]); + stmts[i] = NULL; + } - buf->len = 0; - (*mdocs[n->tok])(hash, buf, dbuf, n, m); - break; + sqlite3_close(db); + db = NULL; + + if (real) + return; + + 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("", "&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"); + } - pmdoc_node(hash, buf, dbuf, n->child, m); - pmdoc_node(hash, buf, dbuf, n->next, m); + *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); + } } +/* + * This is straightforward stuff. + * Open a database connection to a "temporary" database, then open a set + * of prepared statements we'll use over and over again. + * If "real" is set, we use the existing database; if not, we truncate a + * temporary one. + * Must be matched by dbclose(). + */ static int -pman_node(MAN_ARGS) +dbopen(int real) { - const struct man_node *head, *body; - const char *start, *sv; - size_t sz; + const char *sql; + int rc, ofl; - if (NULL == n) - return(0); + if (nodb) + return(1); - /* - * We're only searching for one thing: the first text child in - * the BODY of a NAME section. Since we don't keep track of - * sections in -man, run some hoops to find out whether we're in - * the correct section or not. - */ + *tempfilename = '\0'; + ofl = SQLITE_OPEN_READWRITE; - if (MAN_BODY == n->type && MAN_SH == n->tok) { - 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) && - MAN_TEXT == body->type) { + if (real) { + rc = sqlite3_open_v2(MANDOC_DB, &db, ofl, NULL); + if (SQLITE_OK != rc) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say(MANDOC_DB, "%s", sqlite3_errstr(rc)); + return(0); + } + goto prepare_statements; + } - assert(body->string); - start = sv = body->string; + ofl |= SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE; - /* - * Go through a special heuristic dance here. - * This is why -man manuals are great! - * (I'm being sarcastic: my eyes are bleeding.) - * Conventionally, one or more manual names are - * comma-specified prior to a whitespace, then a - * dash, then a description. Try to puzzle out - * the name parts here. - */ + remove(MANDOC_DB "~"); + rc = sqlite3_open_v2(MANDOC_DB "~", &db, ofl, NULL); + if (SQLITE_OK == rc) + goto create_tables; + if (MPARSE_QUICK & mparse_options) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say(MANDOC_DB "~", "%s", sqlite3_errstr(rc)); + return(0); + } - for ( ;; ) { - sz = strcspn(start, " ,"); - if ('\0' == start[(int)sz]) - break; + (void)strlcpy(tempfilename, "/tmp/mandocdb.XXXXXX", + sizeof(tempfilename)); + if (NULL == mkdtemp(tempfilename)) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say("", "&%s", tempfilename); + return(0); + } + (void)strlcat(tempfilename, "/" MANDOC_DB, + sizeof(tempfilename)); + rc = sqlite3_open_v2(tempfilename, &db, ofl, NULL); + if (SQLITE_OK != rc) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say("", "%s: %s", tempfilename, sqlite3_errstr(rc)); + return(0); + } - buf->len = 0; - buf_appendb(buf, start, sz); - buf_appendb(buf, "", 1); +create_tables: + sql = "CREATE TABLE \"mpages\" (\n" + " \"desc\" TEXT NOT NULL,\n" + " \"form\" INTEGER NOT NULL,\n" + " \"pageid\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL\n" + ");\n" + "\n" + "CREATE TABLE \"mlinks\" (\n" + " \"sec\" TEXT NOT NULL,\n" + " \"arch\" TEXT NOT NULL,\n" + " \"name\" TEXT NOT NULL,\n" + " \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) " + "ON DELETE CASCADE\n" + ");\n" + "CREATE INDEX mlinks_pageid_idx ON mlinks (pageid);\n" + "\n" + "CREATE TABLE \"names\" (\n" + " \"bits\" INTEGER NOT NULL,\n" + " \"name\" TEXT NOT NULL,\n" + " \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) " + "ON DELETE CASCADE\n" + ");\n" + "\n" + "CREATE TABLE \"keys\" (\n" + " \"bits\" INTEGER NOT NULL,\n" + " \"key\" TEXT NOT NULL,\n" + " \"pageid\" INTEGER NOT NULL REFERENCES mpages(pageid) " + "ON DELETE CASCADE\n" + ");\n" + "CREATE INDEX keys_pageid_idx ON keys (pageid);\n"; - hash_put(hash, buf, TYPE_NAME); + 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); + } - if (' ' == start[(int)sz]) { - start += (int)sz + 1; - break; - } +prepare_statements: + if (SQLITE_OK != sqlite3_exec(db, + "PRAGMA foreign_keys = ON", NULL, NULL, NULL)) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say(MANDOC_DB, "PRAGMA foreign_keys: %s", + sqlite3_errmsg(db)); + sqlite3_close(db); + return(0); + } - assert(',' == start[(int)sz]); - start += (int)sz + 1; - while (' ' == *start) - start++; - } + sql = "DELETE FROM mpages WHERE pageid IN " + "(SELECT pageid FROM mlinks WHERE " + "sec=? AND arch=? AND name=?)"; + sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_DELETE_PAGE], NULL); + sql = "INSERT INTO mpages " + "(desc,form) VALUES (?,?)"; + sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_PAGE], NULL); + sql = "INSERT INTO mlinks " + "(sec,arch,name,pageid) VALUES (?,?,?,?)"; + sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_LINK], NULL); + sql = "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); - buf->len = 0; +#ifndef __APPLE__ + /* + * When opening a new database, we can turn off + * synchronous mode for much better performance. + */ - if (sv == start) { - buf_append(buf, start); - return(1); - } + if (real && SQLITE_OK != sqlite3_exec(db, + "PRAGMA synchronous = OFF", NULL, NULL, NULL)) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say(MANDOC_DB, "PRAGMA synchronous: %s", + sqlite3_errmsg(db)); + sqlite3_close(db); + return(0); + } +#endif - while (' ' == *start) - start++; + return(1); +} - if (0 == strncmp(start, "-", 1)) - start += 1; - else if (0 == strncmp(start, "\\-", 2)) - start += 2; - else if (0 == strncmp(start, "\\(en", 4)) - start += 4; - else if (0 == strncmp(start, "\\(em", 4)) - start += 4; +static void * +hash_halloc(size_t sz, void *arg) +{ - while (' ' == *start) - start++; + return(mandoc_calloc(1, sz)); +} - sz = strlen(start) + 1; - buf_appendb(dbuf, start, sz); - buf_appendb(buf, start, sz); +static void * +hash_alloc(size_t sz, void *arg) +{ - hash_put(hash, buf, TYPE_DESC); - } - } - - for (n = n->child; n; n = n->next) - if (pman_node(hash, buf, dbuf, n)) - return(1); - - return(0); + return(mandoc_malloc(sz)); } static void -ofile_argbuild(char *argv[], int argc, int verb, struct of **of) +hash_free(void *p, size_t sz, void *arg) { - int i; - struct of *nof; - for (i = 0; i < argc; i++) { - nof = mandoc_calloc(1, sizeof(struct of)); - nof->fname = strdup(argv[i]); - if (verb > 2) - printf("%s: Scheduling\n", argv[i]); - if (NULL == *of) { - *of = nof; - (*of)->first = nof; - } else { - nof->first = (*of)->first; - (*of)->next = nof; - *of = nof; - } - } + free(p); } -/* - * Recursively build up a list of files to parse. - * We use this instead of ftw() and so on because I don't want global - * variables hanging around. - * This ignores the mandoc.db and mandoc.index files, but assumes that - * everything else is a manual. - * Pass in a pointer to a NULL structure for the first invocation. - */ static int -ofile_dirbuild(const char *dir, int verb, struct of **of) +set_basedir(const char *targetdir) { - char buf[MAXPATHLEN]; - size_t sz; - DIR *d; - const char *fn; - struct of *nof; - struct dirent *dp; + static char startdir[PATH_MAX]; + static int fd; - if (NULL == (d = opendir(dir))) { - perror(dir); - return(0); - } - - while (NULL != (dp = readdir(d))) { - fn = dp->d_name; - if (DT_DIR == dp->d_type) { - if (0 == strcmp(".", fn)) - continue; - if (0 == strcmp("..", fn)) - continue; - - buf[0] = '\0'; - strlcat(buf, dir, MAXPATHLEN); - strlcat(buf, "/", MAXPATHLEN); - sz = strlcat(buf, fn, MAXPATHLEN); - - if (sz < MAXPATHLEN) { - if ( ! ofile_dirbuild(buf, verb, of)) - return(0); - continue; - } else if (sz < MAXPATHLEN) - continue; - - fprintf(stderr, "%s: Path too long\n", dir); + /* + * Remember where we started by keeping a fd open to the origin + * path component: throughout this utility, we chdir() a lot to + * handle relative paths, and by doing this, we can return to + * the starting point. + */ + if ('\0' == *startdir) { + if (NULL == getcwd(startdir, PATH_MAX)) { + exitcode = (int)MANDOCLEVEL_SYSERR; + if (NULL != targetdir) + say("", "&getcwd"); return(0); } - if (DT_REG != dp->d_type) - continue; - - if (0 == strcmp(MANDOC_DB, fn) || - 0 == strcmp(MANDOC_IDX, fn)) - continue; - - buf[0] = '\0'; - strlcat(buf, dir, MAXPATHLEN); - strlcat(buf, "/", MAXPATHLEN); - sz = strlcat(buf, fn, MAXPATHLEN); - if (sz >= MAXPATHLEN) { - fprintf(stderr, "%s: Path too long\n", dir); + if (-1 == (fd = open(startdir, O_RDONLY, 0))) { + exitcode = (int)MANDOCLEVEL_SYSERR; + say("", "&open %s", startdir); return(0); } - - nof = mandoc_calloc(1, sizeof(struct of)); - nof->fname = mandoc_strdup(buf); - - if (verb > 2) - printf("%s: Scheduling\n", buf); - - if (NULL == *of) { - *of = nof; - (*of)->first = nof; - } else { - nof->first = (*of)->first; - (*of)->next = nof; - *of = nof; + 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); + } } - - closedir(d); + if (NULL == realpath(targetdir, basedir)) { + basedir[0] = '\0'; + exitcode = (int)MANDOCLEVEL_BADARG; + say("", "&%s: realpath", targetdir); + return(0); + } else if (-1 == chdir(basedir)) { + exitcode = (int)MANDOCLEVEL_BADARG; + say("", "&chdir"); + return(0); + } return(1); } static void -ofile_free(struct of *of) +say(const char *file, const char *format, ...) { - struct of *nof; + va_list ap; + int use_errno; - while (of) { - nof = of->next; - free(of->fname); - free(of); - of = nof; - } -} + if ('\0' != *basedir) + fprintf(stderr, "%s", basedir); + if ('\0' != *basedir && '\0' != *file) + fputs("//", stderr); + if ('\0' != *file) + fprintf(stderr, "%s", file); -static void -usage(void) -{ - - fprintf(stderr, "usage: %s [-v] " - "[-d dir [files...] |" - " -u dir [files...] |" - " dir...]\n", progname); + use_errno = 1; + if (NULL != format) { + switch (*format) { + case '&': + format++; + break; + case '\0': + format = NULL; + break; + default: + use_errno = 0; + break; + } + } + if (NULL != format) { + if ('\0' != *basedir || '\0' != *file) + fputs(": ", stderr); + va_start(ap, format); + vfprintf(stderr, format, ap); + va_end(ap); + } + if (use_errno) { + if ('\0' != *basedir || '\0' != *file || NULL != format) + fputs(": ", stderr); + perror(NULL); + } else + fputc('\n', stderr); }