mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.49.2.1 and 1.49.2.2

version 1.49.2.1, 2013/09/17 21:32:07

version 1.49.2.2, 2013/09/17 22:48:53

Line 56

#define MANDOC_SRC 0x1

#define MANDOC_FORM 0x2

#define WARNING(_f, _b, _fmt, _args...) \

do if (warnings) { \

fprintf(stderr, "%s: ", (_b)); \

fprintf(stderr, (_fmt), ##_args); \

if ('\0' != *(_f)) \

fprintf(stderr, ": %s", (_f)); \

fprintf(stderr, "\n"); \

} while (/* CONSTCOND */ 0)

/* Access to the mandoc database on disk. */

struct mdb {

Line 133 static void hash_put(DB *, const struct buf *, uint

Line 124 static void hash_put(DB *, const struct buf *, uint

static void hash_reset(DB **);

static void index_merge(const struct of *, struct mparse *,

struct buf *, struct buf *, DB *,

struct mdb *, struct recs *,

struct mdb *, struct recs *);

const char *);

static void index_prune(const struct of *, struct mdb *,

struct recs *, const char *);

struct recs *);

static void ofile_argbuild(int, char *[],

static void ofile_argbuild(int, char *[], struct of **,

struct of **, const char *);

const char *);

static void ofile_dirbuild(const char *, const char *,

const char *, int, struct of **, char *);

const char *, int, struct of **);

static void ofile_free(struct of *);

static void pformatted(DB *, struct buf *, struct buf *,

static void pformatted(DB *, struct buf *,

const struct of *, const char *);

struct buf *, const struct of *);

static int pman_node(MAN_ARGS);

static void pmdoc_node(MDOC_ARGS);

static int pmdoc_head(MDOC_ARGS);

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

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

struct recs recs;

enum op op; /* current operation */

const char *dir;

char *cp;

char pbuf[PATH_MAX];

int ch, i, flags;

char dirbuf[PATH_MAX];

DB *hash; /* temporary keyword hashtable */

BTREEINFO info; /* btree configuration */

size_t sz1, sz2;

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

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

dbuf.cp = mandoc_malloc(dbuf.size);

if (OP_TEST == op) {

ofile_argbuild(argc, argv, &of, ".");

ofile_argbuild(argc, argv, &of, NULL);

if (NULL == of)

goto out;

index_merge(of, mp, &dbuf, &buf,

index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);

hash, &mdb, &recs, ".");

goto out;

}

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

strlcat(mdb.dbn, dir, PATH_MAX);

if (NULL == realpath(dir, pbuf)) {

strlcat(mdb.dbn, "/", PATH_MAX);

perror(dir);

exit((int)MANDOCLEVEL_BADARG);

}

if (strlcat(pbuf, "/", PATH_MAX) >= PATH_MAX) {

fprintf(stderr, "%s: path too long\n", pbuf);

exit((int)MANDOCLEVEL_BADARG);

}

strlcat(mdb.dbn, pbuf, PATH_MAX);

sz1 = strlcat(mdb.dbn, MANDOC_DB, PATH_MAX);

strlcat(mdb.idxn, dir, PATH_MAX);

strlcat(mdb.idxn, pbuf, PATH_MAX);

strlcat(mdb.idxn, "/", PATH_MAX);

sz2 = strlcat(mdb.idxn, MANDOC_IDX, PATH_MAX);

if (sz1 >= PATH_MAX || sz2 >= PATH_MAX) {

fprintf(stderr, "%s: path too long\n", dir);

fprintf(stderr, "%s: path too long\n", mdb.idxn);

exit((int)MANDOCLEVEL_BADARG);

}

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

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

exit((int)MANDOCLEVEL_SYSERR);

}

ofile_argbuild(argc, argv, &of, dir);

ofile_argbuild(argc, argv, &of, pbuf);

if (NULL == of)

goto out;

index_prune(of, &mdb, &recs, dir);

index_prune(of, &mdb, &recs);

* Go to the root of the respective manual tree.

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

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

exit((int)MANDOCLEVEL_SYSERR);

}

index_merge(of, mp, &dbuf, &buf, hash,

&mdb, &recs, dir);

&mdb, &recs);

}

goto out;

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

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

if (argc > 0) {

dirs.paths = mandoc_calloc(argc, sizeof(char *));

dirs.sz = argc;

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

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

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

if (NULL == (cp = realpath(argv[i], pbuf))) {

perror(argv[i]);

goto out;

}

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

}

} else

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

for (i = 0; i < dirs.sz; i++) {

* Go to the root of the respective manual tree.

* This must work or no manuals may be found:

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

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

* Search for manuals and fill the new database.

strlcpy(dirbuf, dirs.paths[i], PATH_MAX);

ofile_dirbuild(".", "", "", 0, &of);

ofile_dirbuild(".", "", "", 0, &of, dirbuf);

if (NULL != of) {

index_merge(of, mp, &dbuf, &buf, hash,

&mdb, &recs, dirs.paths[i]);

&mdb, &recs);

ofile_free(of);

of = NULL;

}

Line 547 out:

Line 549 out:

usage:

fprintf(stderr,

"usage: %s [-av] [-C file] | dir ... | -t file ...\n"

"usage: %s [-avvv] [-C file] | dir ... | -t file ...\n"

" -d dir [file ...] | "

"-u dir [file ...]\n",

progname);

Line 558 usage:

Line 560 usage:

void

index_merge(const struct of *of, struct mparse *mp,

struct buf *dbuf, struct buf *buf, DB *hash,

struct mdb *mdb, struct recs *recs,

struct mdb *mdb, struct recs *recs)

const char *basedir)

{

recno_t rec;

int ch, skip;

DBT key, val;

DB *files; /* temporary file name table */

char emptystring[1] = {'\0'};

struct mdoc *mdoc;

struct man *man;

char *p;

const char *fn, *msec, *march, *mtitle;

char *p;

uint64_t mask;

size_t sv;

unsigned seq;

Line 629 index_merge(const struct of *of, struct mparse *mp,

skip = 0;

assert(of->sec);

assert(msec);

if (strcasecmp(msec, of->sec))

if (warnings)

WARNING(fn, basedir, "Section \"%s\" manual "

if (strcasecmp(msec, of->sec))

"in \"%s\" directory", msec, of->sec);

fprintf(stderr, "%s: "

"section \"%s\" manual "

"in \"%s\" directory\n",

fn, msec, of->sec);

* Manual page directories exist for each kernel

* architecture as returned by machine(1).

Line 649 index_merge(const struct of *of, struct mparse *mp,

Line 653 index_merge(const struct of *of, struct mparse *mp,

assert(of->arch);

assert(march);

if (strcasecmp(march, of->arch))

if (warnings)

WARNING(fn, basedir, "Architecture \"%s\" "

if (strcasecmp(march, of->arch))

"manual in \"%s\" directory",

fprintf(stderr, "%s: "

march, of->arch);

"architecture \"%s\" manual "

"in \"%s\" directory\n",

fn, march, of->arch);

* By default, skip a file if the title given

Line 688 index_merge(const struct of *of, struct mparse *mp,

Line 694 index_merge(const struct of *of, struct mparse *mp,

val.data = NULL;

val.size = 0;

if (0 == skip)

val.data = emptystring;

val.data = "";

else {

ch = (*files->get)(files, &key, &val, 0);

if (ch < 0) {

Line 742 index_merge(const struct of *of, struct mparse *mp,

Line 748 index_merge(const struct of *of, struct mparse *mp,

else if (man)

pman_node(hash, buf, dbuf, man_node(man));

else

pformatted(hash, buf, dbuf, of, basedir);

pformatted(hash, buf, dbuf, of);

/* Test mode, do not access any database. */

Line 789 index_merge(const struct of *of, struct mparse *mp,

Line 795 index_merge(const struct of *of, struct mparse *mp,

}

if (ch < 0) {

perror("hash");

unlink(mdb->dbn);

unlink(mdb->idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

Line 807 index_merge(const struct of *of, struct mparse *mp,

Line 815 index_merge(const struct of *of, struct mparse *mp,

val.size = dbuf->len;

if (verb)

printf("%s: Adding to index: %s\n", basedir, fn);

printf("%s: adding to index\n", fn);

dbt_put(mdb->idx, mdb->idxn, &key, &val);

}

Line 822 index_merge(const struct of *of, struct mparse *mp,

Line 830 index_merge(const struct of *of, struct mparse *mp,

while (0 == (*files->seq)(files, &key, &val, seq)) {

seq = R_NEXT;

if (val.size)

WARNING((char *)val.data, basedir,

fprintf(stderr, "%s: probably "

"Probably unreachable, title "

"unreachable, title is %s\n",

"is %s", (char *)key.data);

(char *)val.data, (char *)key.data);

}

(*files->close)(files);

}

Line 837 index_merge(const struct of *of, struct mparse *mp,

Line 845 index_merge(const struct of *of, struct mparse *mp,

* in `idx' (zeroing its value size).

static void

index_prune(const struct of *ofile, struct mdb *mdb,

index_prune(const struct of *ofile, struct mdb *mdb, struct recs *recs)

struct recs *recs, const char *basedir)

{

const struct of *of;

const char *fn;

Line 913 index_prune(const struct of *ofile, struct mdb *mdb,

Line 920 index_prune(const struct of *ofile, struct mdb *mdb,

}

if (verb)

printf("%s: Deleting from index: %s\n",

printf("%s: deleting from index\n", fn);

basedir, fn);

val.size = 0;

ch = (*mdb->idx->put)(mdb->idx, &key, &val, R_CURSOR);

Line 1474 pman_node(MAN_ARGS)

Line 1480 pman_node(MAN_ARGS)

* By necessity, this involves rather crude guesswork.

static void

pformatted(DB *hash, struct buf *buf, struct buf *dbuf,

pformatted(DB *hash, struct buf *buf,

const struct of *of, const char *basedir)

struct buf *dbuf, const struct of *of)

{

FILE *stream;

char *line, *p, *title;

size_t len, plen, titlesz;

if (NULL == (stream = fopen(of->fname, "r"))) {

WARNING(of->fname, basedir, "%s", strerror(errno));

if (warnings)

perror(of->fname);

return;

}

Line 1537 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1544 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

title[(int)titlesz - 1] = ' ';

}

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

* is already the next section header, or there is no

Line 1545 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1553 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

if (NULL == title || '\0' == *title) {

WARNING(of->fname, basedir,

if (warnings)

"Cannot find NAME section");

fprintf(stderr, "%s: cannot find NAME section\n",

of->fname);

buf_appendb(dbuf, buf->cp, buf->size);

hash_put(hash, buf, TYPE_Nd);

fclose(stream);

Line 1567 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1576 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

for (p += 2; ' ' == *p || '\b' == *p; p++)

/* Skip to next word. */ ;

} else {

WARNING(of->fname, basedir,

if (warnings)

"No dash in title line");

fprintf(stderr, "%s: no dash in title line\n",

of->fname);

p = title;

}

Line 1595 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1605 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

}

static void

ofile_argbuild(int argc, char *argv[],

ofile_argbuild(int argc, char *argv[], struct of **of,

struct of **of, const char *basedir)

const char *basedir)

{

char buf[PATH_MAX];

char pbuf[PATH_MAX];

const char *sec, *arch, *title;

char *p;

char *relpath, *p;

int i, src_form;

struct of *nof;

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

if (NULL == (relpath = realpath(argv[i], pbuf))) {

perror(argv[i]);

continue;

}

if (NULL != basedir) {

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

fprintf(stderr, "%s: file outside "

"base directory %s\n",

pbuf, basedir);

continue;

}

relpath = pbuf + strlen(basedir);

}

* Try to infer the manual section, architecture and

Line 1613 ofile_argbuild(int argc, char *argv[],

Line 1637 ofile_argbuild(int argc, char *argv[],

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

if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {

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

fprintf(stderr, "%s: Path too long\n", argv[i]);

fprintf(stderr, "%s: path too long\n", relpath);

continue;

}

sec = arch = title = "";

Line 1646 ofile_argbuild(int argc, char *argv[],

Line 1670 ofile_argbuild(int argc, char *argv[],

break;

}

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

WARNING(argv[i], basedir,

if (warnings)

"Cannot deduce title from filename");

fprintf(stderr,

"%s: cannot deduce title "

"from filename\n",

relpath);

title = buf;

}

Line 1656 ofile_argbuild(int argc, char *argv[],

Line 1683 ofile_argbuild(int argc, char *argv[],

nof = mandoc_calloc(1, sizeof(struct of));

nof->fname = mandoc_strdup(argv[i]);

nof->fname = mandoc_strdup(relpath);

nof->sec = mandoc_strdup(sec);

nof->arch = mandoc_strdup(arch);

nof->title = mandoc_strdup(title);

Line 1687 ofile_argbuild(int argc, char *argv[],

Line 1714 ofile_argbuild(int argc, char *argv[],

static void

ofile_dirbuild(const char *dir, const char* psec, const char *parch,

int p_src_form, struct of **of, char *basedir)

int p_src_form, struct of **of)

{

char buf[PATH_MAX];

size_t sz;

Line 1699 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1726 ofile_dirbuild(const char *dir, const char* psec, cons

int src_form;

if (NULL == (d = opendir(dir))) {

WARNING("", dir, "%s", strerror(errno));

if (warnings)

perror(dir);

return;

}

Line 1729 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1757 ofile_dirbuild(const char *dir, const char* psec, cons

src_form |= MANDOC_FORM;

sec = fn + 3;

} else {

WARNING(fn, basedir, "Bad section");

if (warnings) fprintf(stderr,

"%s/%s: bad section\n",

dir, fn);

if (use_all)

sec = fn;

else

Line 1737 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1767 ofile_dirbuild(const char *dir, const char* psec, cons

}

} else if ('\0' == *arch) {

if (NULL != strchr(fn, '.')) {

WARNING(fn, basedir, "Bad architecture");

if (warnings) fprintf(stderr,

"%s/%s: bad architecture\n",

dir, fn);

if (0 == use_all)

continue;

}

arch = fn;

} else {

WARNING(fn, basedir, "Excessive subdirectory");

if (warnings) fprintf(stderr, "%s/%s: "

"excessive subdirectory\n", dir, fn);

if (0 == use_all)

continue;

}

Line 1751 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1784 ofile_dirbuild(const char *dir, const char* psec, cons

buf[0] = '\0';

strlcat(buf, dir, PATH_MAX);

strlcat(buf, "/", PATH_MAX);

strlcat(basedir, "/", PATH_MAX);

strlcat(basedir, fn, PATH_MAX);

sz = strlcat(buf, fn, PATH_MAX);

if (PATH_MAX <= sz) {

WARNING(fn, basedir, "Path too long");

if (warnings) fprintf(stderr, "%s/%s: "

"path too long\n", dir, fn);

continue;

}

ofile_dirbuild(buf, sec, arch,

ofile_dirbuild(buf, sec, arch, src_form, of);

src_form, of, basedir);

p = strrchr(basedir, '/');

*p = '\0';

continue;

}

if (DT_REG != dp->d_type) {

WARNING(fn, basedir, "Not a regular file");

if (warnings)

fprintf(stderr,

"%s/%s: not a regular file\n",

dir, fn);

continue;

}

if (!strcmp(MANDOC_DB, fn) || !strcmp(MANDOC_IDX, fn))

continue;

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

WARNING(fn, basedir, "File outside section");

if (warnings)

fprintf(stderr,

"%s/%s: file outside section\n",

dir, fn);

if (0 == use_all)

continue;

}

Line 1788 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1822 ofile_dirbuild(const char *dir, const char* psec, cons

suffix = strrchr(fn, '.');

if (NULL == suffix) {

WARNING(fn, basedir, "No filename suffix");

if (warnings)

fprintf(stderr,

"%s/%s: no filename suffix\n",

dir, fn);

if (0 == use_all)

continue;

} else if ((MANDOC_SRC & src_form &&

strcmp(suffix + 1, psec)) ||

(MANDOC_FORM & src_form &&

strcmp(suffix + 1, "0"))) {

WARNING(fn, basedir, "Wrong filename suffix");

if (warnings)

fprintf(stderr,

"%s/%s: wrong filename suffix\n",

dir, fn);

if (0 == use_all)

continue;

if ('0' == suffix[1])

Line 1829 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1869 ofile_dirbuild(const char *dir, const char* psec, cons

strlcat(buf, "/", PATH_MAX);

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= PATH_MAX) {

WARNING(fn, basedir, "Path too long");

if (warnings) fprintf(stderr,

"%s/%s: path too long\n",

dir, fn);

continue;

}

q = strrchr(buf, '.');

Line 1837 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1879 ofile_dirbuild(const char *dir, const char* psec, cons

*q = '\0';

sz = strlcat(buf, psec, PATH_MAX);

if (sz >= PATH_MAX) {

WARNING(fn, basedir, "Path too long");

if (warnings) fprintf(stderr,

"%s/%s: path too long\n",

dir, fn);

continue;

}

if (0 == access(buf, R_OK))

Line 1853 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1897 ofile_dirbuild(const char *dir, const char* psec, cons

}

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= PATH_MAX) {

WARNING(fn, basedir, "Path too long");

if (warnings) fprintf(stderr,

"%s/%s: path too long\n", dir, fn);

continue;

}

CVSweb