mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.201 and 1.220.2.4

version 1.201, 2015/10/12 21:17:15

version 1.220.2.4, 2016/10/22 10:13:40

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 23

Line 24

#include <assert.h>

#include <ctype.h>

#if HAVE_ERR

#include <err.h>

#endif

#include <errno.h>

#include <fcntl.h>

#if HAVE_FTS

Line 31

Line 34

#else

#include "compat_fts.h"

#endif

#include <getopt.h>

#include <limits.h>

#if HAVE_SANDBOX_INIT

#include <sandbox.h>

#endif

#include <stddef.h>

#include <stdio.h>

#include <stdint.h>

Line 40

Line 45

#include <string.h>

#include <unistd.h>

#if HAVE_OHASH

#include <ohash.h>

#else

#include "compat_ohash.h"

#endif

#include <sqlite3.h>

#include "mandoc_aux.h"

#include "mandoc_ohash.h"

#include "mandoc.h"

#include "roff.h"

#include "mdoc.h"

Line 103 struct mpage {

Line 104 struct mpage {

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

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

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

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

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

int form; /* format from file content */

int name_head_done;

Line 139 struct mdoc_handler {

Line 141 struct mdoc_handler {

uint64_t mask; /* set unless handler returns 0 */

};

int mandocdb(int, char *[]);

static void dbclose(int);

static void dbadd(struct mpage *);

static void dbadd_mlink(const struct mlink *mlink);

Line 146 static void dbadd_mlink_name(const struct mlink *mlin

Line 151 static void dbadd_mlink_name(const struct mlink *mlin

static int dbopen(int);

static void dbprune(void);

static void filescan(const char *);

static void *hash_alloc(size_t, void *);

#if HAVE_FTS_COMPARE_CONST

static void hash_free(void *, void *);

static int fts_compare(const FTSENT *const *, const FTSENT *const *);

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

#else

static int fts_compare(const FTSENT **, const FTSENT **);

#endif

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

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

static void mlink_free(struct mlink *);

Line 161 static void parse_man(struct mpage *, const struct ro

Line 168 static void parse_man(struct mpage *, const struct ro

const struct roff_node *);

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

const struct roff_node *);

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

const struct roff_node *);

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

const struct roff_node *);

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

Line 178 static int parse_mdoc_Nm(struct mpage *, const struct

Line 183 static int parse_mdoc_Nm(struct mpage *, const struct

const struct roff_node *);

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

const struct roff_node *);

static int parse_mdoc_Va(struct mpage *, const struct roff_meta *,

const struct roff_node *);

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

const struct roff_node *);

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

Line 185 static void putkeys(const struct mpage *, char *, siz

Line 192 static void putkeys(const struct mpage *, char *, siz

static void putmdockey(const struct mpage *,

const struct roff_node *, uint64_t);

static int render_string(char **, size_t *);

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

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

__attribute__((__format__ (printf, 2, 3)));

static int set_basedir(const char *, int);

static int treescan(void);

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

extern char *__progname;

static char tempfilename[32];

static int nodb; /* no database changes */

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

Line 202 static int write_utf8; /* write UTF-8 output; else A

Line 208 static int write_utf8; /* write UTF-8 output; else A

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

static enum op op; /* operational mode */

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

static struct mchars *mchars; /* table of named characters */

static struct mpage *mpage_head; /* list of distinct manual pages */

static struct ohash mpages; /* table of distinct manual pages */

static struct ohash mlinks; /* table of directory entries */

static struct ohash names; /* table of all names */

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

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

{ NULL, TYPE_Pa }, /* Pa */

{ NULL, 0 }, /* Rv */

{ NULL, TYPE_St }, /* St */

{ NULL, TYPE_Va }, /* Va */

{ parse_mdoc_Va, TYPE_Va }, /* Va */

{ parse_mdoc_body, TYPE_Va }, /* Vt */

{ parse_mdoc_Va, TYPE_Vt }, /* Vt */

{ parse_mdoc_Xr, 0 }, /* Xr */

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

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

Line 342 int

Line 348 int

mandocdb(int argc, char *argv[])

{

struct manconf conf;

struct ohash_info mpages_info, mlinks_info;

struct mparse *mp;

const char *path_arg;

const char *path_arg, *progname;

size_t j, sz;

int ch, i;

#if HAVE_PLEDGE

if (pledge("stdio rpath wpath cpath fattr flock proc exec", NULL) == -1) {

warn("pledge");

return (int)MANDOCLEVEL_SYSERR;

}

#endif

#if HAVE_SANDBOX_INIT

if (sandbox_init(kSBXProfileNoInternet, SANDBOX_NAMED, NULL) == -1) {

warnx("sandbox_init");

return (int)MANDOCLEVEL_SYSERR;

}

#endif

memset(&conf, 0, sizeof(conf));

memset(stmts, 0, STMT__MAX * sizeof(sqlite3_stmt *));

mpages_info.alloc = mlinks_info.alloc = hash_alloc;

mpages_info.calloc = mlinks_info.calloc = hash_calloc;

mpages_info.free = mlinks_info.free = hash_free;

mpages_info.data = mlinks_info.data = NULL;

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

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

* We accept a few different invocations.

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

Line 429 mandocdb(int argc, char *argv[])

Line 440 mandocdb(int argc, char *argv[])

argc -= optind;

argv += optind;

#if HAVE_PLEDGE

if (nodb) {

if (pledge("stdio rpath", NULL) == -1) {

warn("pledge");

return (int)MANDOCLEVEL_SYSERR;

}

#endif

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

warnx("-C: Too many arguments");

goto usage;

}

exitcode = (int)MANDOCLEVEL_OK;

mchars = mchars_alloc();

mchars_alloc();

mp = mparse_alloc(mparse_options, MANDOCLEVEL_BADARG, NULL,

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

mchars, NULL);

mandoc_ohash_init(&mpages, 6, offsetof(struct mpage, inodev));

ohash_init(&mpages, 6, &mpages_info);

mandoc_ohash_init(&mlinks, 6, offsetof(struct mlink, file));

ohash_init(&mlinks, 6, &mlinks_info);

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

Line 455 mandocdb(int argc, char *argv[])

Line 474 mandocdb(int argc, char *argv[])

* The existing database is usable. Process

* all files specified on the command-line.

#if HAVE_PLEDGE

if (!nodb) {

if (pledge("stdio rpath wpath cpath fattr flock", NULL) == -1) {

warn("pledge");

exitcode = (int)MANDOCLEVEL_SYSERR;

goto out;

}

#endif

use_all = 1;

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

filescan(argv[i]);

Line 509 mandocdb(int argc, char *argv[])

Line 537 mandocdb(int argc, char *argv[])

continue;

if (j) {

ohash_init(&mpages, 6, &mpages_info);

mandoc_ohash_init(&mpages, 6,

ohash_init(&mlinks, 6, &mlinks_info);

offsetof(struct mpage, inodev));

mandoc_ohash_init(&mlinks, 6,

offsetof(struct mlink, file));

}

if ( ! set_basedir(conf.manpath.paths[j], argc > 0))

Line 536 mandocdb(int argc, char *argv[])

Line 566 mandocdb(int argc, char *argv[])

out:

manconf_free(&conf);

mparse_free(mp);

mchars_free(mchars);

mchars_free();

mpages_free();

ohash_delete(&mpages);

ohash_delete(&mlinks);

return exitcode;

usage:

progname = getprogname();

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

__progname, __progname);

return (int)MANDOCLEVEL_BADARG;

}

* To get a singly linked list in alpha order while inserting entries

* at the beginning, process directory entries in reverse alpha order.

static int

#if HAVE_FTS_COMPARE_CONST

fts_compare(const FTSENT *const *a, const FTSENT *const *b)

#else

fts_compare(const FTSENT **a, const FTSENT **b)

#endif

{

return -strcmp((*a)->fts_name, (*b)->fts_name);

}

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

Line 565 usage:

Line 609 usage:

* or

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

* TODO: accomodate for multi-language directories.

* TODO: accommodate for multi-language directories.

static int

treescan(void)

Line 582 treescan(void)

Line 626 treescan(void)

argv[0] = ".";

argv[1] = (char *)NULL;

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

f = fts_open((char * const *)argv, FTS_PHYSICAL | FTS_NOCHDIR,

FTS_PHYSICAL | FTS_NOCHDIR, NULL);

fts_compare);

if (f == NULL) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fts_open");

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

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

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

mpage->inodev.st_ino = inodev.st_ino;

mpage->inodev.st_dev = inodev.st_dev;

mpage->next = mpage_head;

mpage_head = mpage;

ohash_insert(&mpages, slot, mpage);

} else

mlink->next = mpage->mlinks;

Line 971 mpages_free(void)

Line 1017 mpages_free(void)

{

struct mpage *mpage;

struct mlink *mlink;

unsigned int slot;

mpage = ohash_first(&mpages, &slot);

while ((mpage = mpage_head) != NULL) {

while (NULL != mpage) {

while ((mlink = mpage->mlinks) != NULL) {

while (NULL != (mlink = mpage->mlinks)) {

mpage->mlinks = mlink->next;

mlink_free(mlink);

}

mpage_head = mpage->next;

free(mpage->sec);

free(mpage->arch);

free(mpage->title);

free(mpage->desc);

free(mpage);

mpage = ohash_next(&mpages, &slot);

}

Line 1099 static void

Line 1143 static void

mpages_merge(struct mparse *mp)

{

char any[] = "any";

struct ohash_info str_info;

struct mpage *mpage, *mpage_dest;

struct mlink *mlink, *mlink_dest;

struct roff_man *man;

char *sodest;

char *cp;

int fd;

unsigned int pslot;

str_info.alloc = hash_alloc;

str_info.calloc = hash_calloc;

str_info.free = hash_free;

str_info.data = NULL;

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

if ( ! nodb)

SQL_EXEC("BEGIN TRANSACTION");

mpage = ohash_first(&mpages, &pslot);

for (mpage = mpage_head; mpage != NULL; mpage = mpage->next) {

while (mpage != NULL) {

mlinks_undupe(mpage);

if ((mlink = mpage->mlinks) == NULL) {

if ((mlink = mpage->mlinks) == NULL)

mpage = ohash_next(&mpages, &pslot);

continue;

}

name_mask = NAME_MASK;

ohash_init(&names, 4, &str_info);

mandoc_ohash_init(&names, 4, offsetof(struct str, key));

ohash_init(&strings, 6, &str_info);

mandoc_ohash_init(&strings, 6, offsetof(struct str, key));

mparse_reset(mp);

man = NULL;

sodest = NULL;

mparse_open(mp, &fd, mlink->file);

if ((fd = mparse_open(mp, mlink->file)) == -1) {

if (fd == -1) {

say(mlink->file, "&open");

goto nextpage;

}

Line 1144 mpages_merge(struct mparse *mp)

Line 1176 mpages_merge(struct mparse *mp)

if (mlink->dform != FORM_CAT || mlink->fform != FORM_CAT) {

mparse_readfd(mp, fd, mlink->file);

close(fd);

mparse_result(mp, &man, &sodest);

}

Line 1189 mpages_merge(struct mparse *mp)

Line 1222 mpages_merge(struct mparse *mp)

}

goto nextpage;

} else if (man != NULL && man->macroset == MACROSET_MDOC) {

mdoc_validate(man);

mpage->form = FORM_SRC;

mpage->sec = man->meta.msec;

mpage->sec = mandoc_strdup(

Line 1198 mpages_merge(struct mparse *mp)

Line 1232 mpages_merge(struct mparse *mp)

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

mpage->title = mandoc_strdup(man->meta.title);

} else if (man != NULL && man->macroset == MACROSET_MAN) {

man_validate(man);

mpage->form = FORM_SRC;

mpage->sec = mandoc_strdup(man->meta.msec);

mpage->arch = mandoc_strdup(mlink->arch);

Line 1243 mpages_merge(struct mparse *mp)

Line 1278 mpages_merge(struct mparse *mp)

ohash_delete(&strings);

ohash_delete(&names);

mpage = ohash_next(&mpages, &pslot);

}

if (0 == nodb)

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

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

{

FILE *stream;

char *line, *p, *title;

size_t len, plen, titlesz;

size_t linesz, plen, titlesz;

ssize_t len;

int offs;

stream = (-1 == fd) ?

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

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

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

return;

}

line = NULL;

linesz = 0;

/* Skip to first blank line. */

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

while (getline(&line, &linesz, stream) != -1)

if ('\n' == *line)

if (*line == '\n')

break;

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

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

* is the first section header. Skip to it.

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

while (getline(&line, &linesz, stream) != -1)

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

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

break;

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

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

titlesz = 0;

title = NULL;

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

while ((len = getline(&line, &linesz, stream)) != -1) {

if (' ' != *line || '\n' != line[len - 1])

if (*line != ' ')

break;

while (len > 0 && isspace((unsigned char)*line)) {

offs = 0;

line++;

while (isspace((unsigned char)line[offs]))

len--;

offs++;

}

if (line[offs] == '\0')

if (1 == len)

continue;

title = mandoc_realloc(title, titlesz + len);

title = mandoc_realloc(title, titlesz + len - offs);

memcpy(title + titlesz, line, len);

memcpy(title + titlesz, line + offs, len - offs);

titlesz += len;

titlesz += len - offs;

title[titlesz - 1] = ' ';

}

free(line);

* If no page content can be found, or the input line

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

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

return;

}

title = mandoc_realloc(title, titlesz + 1);

title[titlesz - 1] = '\0';

title[titlesz] = '\0';

* Skip to the first dash.

Line 1438 parse_man(struct mpage *mpage, const struct roff_meta

Line 1476 parse_man(struct mpage *mpage, const struct roff_meta

char byte;

size_t sz;

if (NULL == n)

if (n == NULL)

return;

Line 1450 parse_man(struct mpage *mpage, const struct roff_meta

Line 1488 parse_man(struct mpage *mpage, const struct roff_meta

if (n->type == ROFFT_BODY && n->tok == MAN_SH) {

body = n;

assert(body->parent);

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

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

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

1 == head->nchild &&

head->next == NULL &&

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

head->type == ROFFT_TEXT &&

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

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

NULL != body->child) {

body->child != NULL) {

* Suck the entire NAME section into memory.

Line 1681 parse_mdoc_Fo(struct mpage *mpage, const struct roff_m

Line 1718 parse_mdoc_Fo(struct mpage *mpage, const struct roff_m

}

static int

parse_mdoc_Va(struct mpage *mpage, const struct roff_meta *meta,

const struct roff_node *n)

{

char *cp;

if (n->type != ROFFT_ELEM && n->type != ROFFT_BODY)

return 0;

if (n->child != NULL &&

n->child->next == NULL &&

n->child->type == ROFFT_TEXT)

return 1;

cp = NULL;

deroff(&cp, n);

if (cp != NULL) {

putkey(mpage, cp, TYPE_Vt | (n->tok == MDOC_Va ||

n->type == ROFFT_BODY ? TYPE_Va : 0));

free(cp);

}

return 0;

}

static int

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

const struct roff_node *n)

{

Line 1726 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

Line 1788 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

if ( ! (mpage->name_head_done ||

n->child == NULL || n->child->string == NULL ||

strcasecmp(n->child->string, meta->title))) {

putkey(mpage, n->child->string, ROFFT_HEAD);

putkey(mpage, n->child->string, NAME_HEAD);

mpage->name_head_done = 1;

}

return 0;

Line 1748 parse_mdoc_head(struct mpage *mpage, const struct roff

Line 1810 parse_mdoc_head(struct mpage *mpage, const struct roff

return n->type == ROFFT_HEAD;

}

static int

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

const struct roff_node *n)

{

return n->type == ROFFT_BODY;

}

* Add a string to the hash table for the current manual.

* Each string has a bitmask telling which macros it belongs to.

Line 1782 putkeys(const struct mpage *mpage, char *cp, size_t sz

Line 1836 putkeys(const struct mpage *mpage, char *cp, size_t sz

name_mask &= ~NAME_FIRST;

if (debug > 1)

say(mpage->mlinks->file,

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

"Adding name %*s, bits=0x%llx", (int)sz, cp,

(unsigned long long)v);

} else {

htab = &strings;

if (debug > 1)

Line 1790 putkeys(const struct mpage *mpage, char *cp, size_t sz

Line 1845 putkeys(const struct mpage *mpage, char *cp, size_t sz

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

say(mpage->mlinks->file,

"Adding key %s=%*s",

mansearch_keynames[i], sz, cp);

mansearch_keynames[i], (int)sz, cp);

}

end = cp + sz;

Line 1949 render_string(char **public, size_t *psz)

Line 2004 render_string(char **public, size_t *psz)

if (write_utf8) {

unicode = mchars_spec2cp(mchars, seq, seqlen);

unicode = mchars_spec2cp(seq, seqlen);

if (unicode <= 0)

continue;

addsz = utf8(unicode, utfbuf);

Line 1957 render_string(char **public, size_t *psz)

Line 2012 render_string(char **public, size_t *psz)

continue;

addcp = utfbuf;

} else {

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

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

if (addcp == NULL)

continue;

if (*addcp == ASCII_NBRSP) {

Line 2382 prepare_statements:

Line 2437 prepare_statements:

#endif

return 1;

}

static void *

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

{

return mandoc_calloc(n, sz);

}

static void *

hash_alloc(size_t sz, void *arg)

{

return mandoc_malloc(sz);

}

static void

hash_free(void *p, void *arg)

{

free(p);

}

static int

CVSweb