mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.140 and 1.144

version 1.140, 2014/04/19 02:56:54

version 1.144, 2014/04/23 21:06:41

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

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

{ NULL, 0 }, /* Ta */

};

int

main(int argc, char *argv[])

{

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

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

++progname;

* We accept a few different invocations.

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

* clobber each other.

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

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

"output format\n", optarg);

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

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

}

write_utf8 = 1;

break;

case ('t'):

case 't':

CHECKOP(op, ch);

dup2(STDOUT_FILENO, STDERR_FILENO);

op = OP_TEST;

nodb = warnings = 1;

break;

case ('u'):

case 'u':

CHECKOP(op, ch);

path_arg = optarg;

op = OP_DELETE;

break;

case ('v'):

case 'v':

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

break;

default:

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

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

* manpath_parse() wants to do it.

if (argc > 0) {

dirs.paths = mandoc_calloc

dirs.paths = mandoc_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 538 usage:

Line 539 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 552 usage:

Line 553 usage:

* If use_all has been specified, grok all files.

* If not, sanitise paths to the following:

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

* or

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

Line 592 treescan(void)

Line 593 treescan(void)

* Symbolic links require various sanity checks,

* then get handled just like regular files.

case (FTS_SL):

case FTS_SL:

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

if (warnings)

say(path, "&realpath");

Line 615 treescan(void)

Line 616 treescan(void)

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

* stored directory data and handling the filename.

case (FTS_F):

case FTS_F:

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

continue;

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

Line 662 treescan(void)

Line 663 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 672 treescan(void)

Line 679 treescan(void)

mlink_add(mlink, ff->fts_statp);

continue;

case (FTS_D):

case FTS_D:

/* FALLTHROUGH */

case (FTS_DP):

case FTS_DP:

break;

default:

Line 684 treescan(void)

Line 691 treescan(void)

}

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

Line 715 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 747 treescan(void)

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

Line 825 filescan(const char *file)

say(file, "&stat");

return;

}

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

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

say(file, "Filename too long");

return;

}

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

buf + strlen(basedir) + 1 : buf;

}

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

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

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 972 mlinks_undupe(struct mpage *mpage)

Line 986 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 1113 mpages_merge(struct mchars *mc, struct mparse *mp)

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

goto nextpage;

}

switch (child_pid = fork()) {

case (-1):

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

case 0:

close(fd[0]);

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

say(mpage->mlinks->file,

Line 1286 names_check(void)

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

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

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

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

}

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

Line 1480 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 1487 parse_man(struct mpage *mpage, const struct man_node *

Line 1498 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 1569 parse_mdoc(struct mpage *mpage, const struct mdoc_node

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

assert(NULL != n);

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

switch (n->type) {

case (MDOC_ELEM):

case MDOC_ELEM:

/* FALLTHROUGH */

case (MDOC_BLOCK):

case MDOC_BLOCK:

/* FALLTHROUGH */

case (MDOC_HEAD):

case MDOC_HEAD:

/* FALLTHROUGH */

case (MDOC_BODY):

case MDOC_BODY:

/* FALLTHROUGH */

case (MDOC_TAIL):

case MDOC_TAIL:

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

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

break;

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

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

size_t sz;

if (SEC_SYNOPSIS != n->sec ||

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

MDOC_TEXT != n->type)

return(0);

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

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

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 1773 putkeys(const struct mpage *mpage,

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

}

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

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

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

key->rendered = key->key;

return;

}

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

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

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

}

switch (*val) {

case (ASCII_HYPH):

case ASCII_HYPH:

buf[pos++] = '-';

val++;

continue;

case ('\t'):

case '\t':

/* FALLTHROUGH */

case (ASCII_NBRSP):

case ASCII_NBRSP:

buf[pos++] = ' ';

val++;

/* FALLTHROUGH */

case (ASCII_BREAK):

case ASCII_BREAK:

continue;

default:

break;

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

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

* predefined character or special character.

esc = mandoc_escape

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

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

&seq, &len);

if (ESCAPE_ERROR == esc)

break;

if (ESCAPE_SPECIAL != esc)

Line 2125 dbclose(int real)

Line 2136 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 2151 dbclose(int real)

Line 2162 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 2186 dbopen(int real)

Line 2197 dbopen(int real)

const char *sql;

int rc, ofl;

if (nodb)

return(1);

*tempfilename = '\0';

Line 2206 dbopen(int real)

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

Line 2214 dbopen(int real)

Line 2225 dbopen(int real)

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;

Line 2312 static void *

Line 2314 static void *

hash_halloc(size_t sz, void *arg)

{

return(mandoc_calloc(sz, 1));

return(mandoc_calloc(1, sz));

}

static void *

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

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

use_errno = 1;

if (NULL != format) {

switch (*format) {

case ('&'):

case '&':

format++;

break;

case ('\0'):

case '\0':

format = NULL;

break;

default:

CVSweb