mandoc/makewhatis.c - diff

Return to makewhatis.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/Attic/makewhatis.c between version 1.2 and 1.20

version 1.2, 2011/05/15 02:47:17

version 1.20, 2011/07/12 10:03:02

Line 21

#include <sys/param.h>

#include <assert.h>

#ifdef __linux__

# include <db_185.h>

#else

# include <db.h>

#endif

#include <fcntl.h>

#include <getopt.h>

#include <stdio.h>

Line 33

Line 28

#include <stdlib.h>

#include <string.h>

#ifdef __linux__

# include <db_185.h>

#else

# include <db.h>

#endif

#include "man.h"

#include "mdoc.h"

#include "mandoc.h"

Line 42

Line 43

#define MANDOC_BUFSZ BUFSIZ

#define MANDOC_FLAGS O_CREAT|O_TRUNC|O_RDWR

enum type {

/* Bit-fields. See makewhatis.1. */

MANDOC_NONE = 0,

MANDOC_NAME,

#define TYPE_NAME 0x01

MANDOC_FUNCTION,

#define TYPE_FUNCTION 0x02

MANDOC_UTILITY,

#define TYPE_UTILITY 0x04

MANDOC_INCLUDES,

#define TYPE_INCLUDES 0x08

MANDOC_VARIABLE,

#define TYPE_VARIABLE 0x10

MANDOC_STANDARD,

#define TYPE_STANDARD 0x20

MANDOC_AUTHOR,

#define TYPE_AUTHOR 0x40

MANDOC_CONFIG

#define TYPE_CONFIG 0x80

#define TYPE_DESC 0x100

#define TYPE_XREF 0x200

#define TYPE_PATH 0x400

#define TYPE_ENV 0x800

#define TYPE_ERR 0x1000

/* Buffer for storing growable data. */

struct buf {

char *cp;

size_t len;

size_t size;

};

#define MAN_ARGS DB *db, \

/* Operation we're going to perform. */

const char *dbn, \

DBT *key, size_t *ksz, \

enum op {

DBT *val, \

OP_NEW = 0, /* new database */

DBT *rval, size_t *rsz, \

OP_UPDATE, /* update entries in existing database */

OP_DELETE /* delete entries from existing database */

};

#define MAN_ARGS DB *hash, \

struct buf *buf, \

struct buf *dbuf, \

const struct man_node *n

#define MDOC_ARGS DB *db, \

#define MDOC_ARGS DB *hash, \

const char *dbn, \

struct buf *buf, \

DBT *key, size_t *ksz, \

struct buf *dbuf, \

DBT *val, \

const struct mdoc_node *n, \

DBT *rval, size_t *rsz, \

const struct mdoc_meta *m

const struct mdoc_node *n

static void dbt_append(DBT *, size_t *, const char *);

static void buf_appendmdoc(struct buf *,

static void dbt_appendb(DBT *, size_t *,

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_init(DBT *, size_t *);

static void dbt_put(DB *, const char *, DBT *, DBT *);

static void usage(void);

static void hash_put(DB *, const struct buf *, int);

static void pman(DB *, const char *, DBT *, size_t *,

static void hash_reset(DB **);

DBT *, DBT *, size_t *, struct man *);

static void op_delete(const char *, int, DB *,

const char *, DB *, const char *);

static int pman_node(MAN_ARGS);

static void pmdoc(DB *, const char *, DBT *, size_t *,

DBT *, DBT *, size_t *, struct mdoc *);

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

typedef void (*pmdoc_nf)(MDOC_ARGS);

static const char *progname;

static const pmdoc_nf mdocs[MDOC_MAX] = {

NULL, /* Ap */

NULL, /* Dd */

Line 115 static const pmdoc_nf mdocs[MDOC_MAX] = {

Line 136 static const pmdoc_nf mdocs[MDOC_MAX] = {

pmdoc_Cd, /* Cd */

NULL, /* Cm */

NULL, /* Dv */

NULL, /* Er */

pmdoc_Er, /* Er */

NULL, /* Ev */

pmdoc_Ev, /* Ev */

NULL, /* Ex */

NULL, /* Fa */

pmdoc_Fd, /* Fd */

Line 130 static const pmdoc_nf mdocs[MDOC_MAX] = {

Line 151 static const pmdoc_nf mdocs[MDOC_MAX] = {

pmdoc_Nm, /* Nm */

NULL, /* Op */

NULL, /* Ot */

NULL, /* Pa */

pmdoc_Pa, /* Pa */

NULL, /* Rv */

pmdoc_St, /* St */

pmdoc_Vt, /* Va */

pmdoc_Vt, /* Vt */

NULL, /* Xr */

pmdoc_Xr, /* Xr */

NULL, /* %A */

NULL, /* %B */

NULL, /* %D */

Line 219 static const pmdoc_nf mdocs[MDOC_MAX] = {

Line 240 static const pmdoc_nf mdocs[MDOC_MAX] = {

NULL, /* Ta */

};

static const char *progname;

int

main(int argc, char *argv[])

{

struct mparse *mp; /* parse sequence */

struct mdoc *mdoc; /* resulting mdoc */

struct man *man; /* resulting man */

enum op op;

char *fn; /* current file being parsed */

const char *msec, /* manual section */

*mtitle, /* manual title */

*arch, /* manual architecture */

*dir; /* result dir (default: cwd) */

char ibuf[MAXPATHLEN], /* index fname */

ibbuf[MAXPATHLEN], /* index backup fname */

fbuf[MAXPATHLEN], /* btree fname */

fbbuf[MAXPATHLEN]; /* btree backup fname */

vbuf[8]; /* stringified record number */

int ch;

int ch, seq, verb, i;

DB *idx, /* index database */

*db; /* keyword database */

*db, /* keyword database */

DBT rkey, rval, /* recno entries */

*hash; /* temporary keyword hashtable */

key, val; /* persistent keyword entries */

DBT key, val;

size_t sv,

enum mandoclevel ec;

ksz, rsz; /* entry buffer size */

size_t sv;

char vbuf[8]; /* stringified record number */

BTREEINFO info; /* btree configuration */

recno_t rec; /* current record number */

recno_t rec, /* current record number */

maxrec;

recno_t *recs;

size_t recsz;

struct buf buf, /* keyword buffer */

dbuf; /* description buffer */

extern int optind;

extern char *optarg;

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

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

++progname;

dir = "";

verb = 0;

db = idx = NULL;

mp = NULL;

hash = NULL;

recs = NULL;

recsz = 0;

maxrec = 0;

op = OP_NEW;

ec = MANDOCLEVEL_SYSERR;

while (-1 != (ch = getopt(argc, argv, "d:")))

memset(&buf, 0, sizeof(struct buf));

memset(&dbuf, 0, sizeof(struct buf));

while (-1 != (ch = getopt(argc, argv, "d:ruv")))

switch (ch) {

case ('d'):

dir = optarg;

break;

case ('r'):

op = OP_DELETE;

break;

case ('u'):

op = OP_UPDATE;

break;

case ('v'):

verb++;

break;

default:

usage();

return((int)MANDOCLEVEL_BADARG);

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

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

argc -= optind;

argv += optind;

* Set up temporary file-names into which we're going to write

* all of our data (both for the index and database). These

* will be securely renamed to the real file-names after we've

* written all of our data.

ibuf[0] = ibuf[MAXPATHLEN - 2] =

ibbuf[0] = ibbuf[MAXPATHLEN - 2] =

fbuf[0] = fbuf[MAXPATHLEN - 2] = '\0';

fbuf[0] = fbuf[MAXPATHLEN - 2] =

fbbuf[0] = fbbuf[MAXPATHLEN - 2] = '\0';

strlcat(fbuf, dir, MAXPATHLEN);

strlcat(fbuf, MANDOC_DB, MAXPATHLEN);

strlcat(fbbuf, fbuf, MAXPATHLEN);

strlcat(fbbuf, "~", MAXPATHLEN);

strlcat(ibuf, dir, MAXPATHLEN);

strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);

strlcat(ibbuf, ibuf, MAXPATHLEN);

strlcat(ibbuf, "~", MAXPATHLEN);

if ('\0' != fbuf[MAXPATHLEN - 2] ||

'\0' != fbbuf[MAXPATHLEN - 2] ||

'\0' != ibuf[MAXPATHLEN - 2]) {

'\0' != ibuf[MAXPATHLEN - 2] ||

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

'\0' != ibbuf[MAXPATHLEN - 2]) {

goto out;

fprintf(stderr, "%s: Path too long\n", progname);

exit((int)MANDOCLEVEL_SYSERR);

}

* For the keyword database, open a BTREE database that allows

* duplicates. For the index database, use a standard RECNO

* duplicates.

* database type.

* For the index database, use a standard RECNO database type.

* Truncate the database if we're creating a new one.

memset(&info, 0, sizeof(BTREEINFO));

info.flags = R_DUP;

db = dbopen(fbbuf, MANDOC_FLAGS, 0644, DB_BTREE, &info);

if (OP_NEW == op) {

db = dbopen(fbuf, MANDOC_FLAGS, 0644, DB_BTREE, &info);

idx = dbopen(ibuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);

} else {

db = dbopen(fbuf, O_CREAT|O_RDWR, 0644, DB_BTREE, &info);

idx = dbopen(ibuf, O_CREAT|O_RDWR, 0644, DB_RECNO, NULL);

}

if (NULL == db) {

perror(fbbuf);

perror(fbuf);

exit((int)MANDOCLEVEL_SYSERR);

goto out;

} else if (NULL == db) {

perror(ibuf);

goto out;

}

idx = dbopen(ibbuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);

* If we're going to delete or update a database, remove the

* entries now. This doesn't actually remove them; it only sets

* their record value lengths to zero.

if (NULL == db) {

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

perror(ibbuf);

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

(*db->close)(db);

op_delete(argv[i], verb, idx, ibuf, db, fbuf);

exit((int)MANDOCLEVEL_SYSERR);

if (OP_DELETE == op) {

ec = MANDOCLEVEL_OK;

goto out;

}

* Try parsing the manuals given on the command line. If we

* Compile a list of all available "empty" records to use. This

* totally fail, then just keep on going. Take resulting trees

* keeps the size of the database small.

* and push them down into the database code.

if (OP_UPDATE == op) {

i = 0;

seq = R_FIRST;

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

seq = R_NEXT;

maxrec = *(recno_t *)key.data;

if (val.size > 0)

continue;

if ((size_t)i >= recsz) {

recsz += 1024;

recs = mandoc_realloc

(recs, recsz * sizeof(recno_t));

}

recs[i++] = maxrec;

}

if (ch < 0) {

perror(ibuf);

exit((int)MANDOCLEVEL_SYSERR);

}

recsz = (size_t)i;

maxrec++;

assert(recsz < maxrec);

}

* Add records to the database.

* Try parsing each manual given on the command line.

* If we fail, then emit an error and keep on going.

* Take resulting trees and push them down into the database code.

* Use the auto-parser and don't report any errors.

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

memset(&key, 0, sizeof(DBT));

buf.size = dbuf.size = MANDOC_BUFSZ;

memset(&val, 0, sizeof(DBT));

buf.cp = mandoc_malloc(buf.size);

memset(&rkey, 0, sizeof(DBT));

dbuf.cp = mandoc_malloc(dbuf.size);

memset(&rval, 0, sizeof(DBT));

val.size = sizeof(vbuf);

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

val.data = vbuf;

fn = argv[i];

rkey.size = sizeof(recno_t);

if (OP_UPDATE == op) {

if (recsz > 0) {

--recsz;

rec = recs[(int)recsz];

} else if (maxrec > 0) {

rec = maxrec;

maxrec = 0;

} else

rec++;

} else

rec++;

rec = 1;

ksz = rsz = 0;

while (NULL != (fn = *argv++)) {

mparse_reset(mp);

hash_reset(&hash);

/* Parse and get (non-empty) AST. */

if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {

fprintf(stderr, "%s: Parse failure\n", fn);

continue;

}

mparse_result(mp, &mdoc, &man);

if (NULL == mdoc && NULL == man)

continue;

/* Manual section: can be empty string. */

msec = NULL != mdoc ?

mdoc_meta(mdoc)->msec :

mdoc_meta(mdoc)->msec : man_meta(man)->msec;

man_meta(man)->msec;

mtitle = NULL != mdoc ?

mdoc_meta(mdoc)->title :

mdoc_meta(mdoc)->title : man_meta(man)->title;

man_meta(man)->title;

arch = NULL != mdoc ? mdoc_meta(mdoc)->arch : NULL;

assert(msec);

if (NULL == arch)

assert(mtitle);

arch = "";

* The index record value consists of a nil-terminated

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

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

* going to write a nil byte in its place.

dbt_init(&rval, &rsz);

dbuf.len = 0;

dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);

buf_appendb(&dbuf, fn, strlen(fn) + 1);

dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);

buf_appendb(&dbuf, msec, strlen(msec) + 1);

dbt_appendb(&rval, &rsz, mtitle, strlen(mtitle) + 1);

buf_appendb(&dbuf, mtitle, strlen(mtitle) + 1);

dbt_appendb(&rval, &rsz, arch ? arch : "",

buf_appendb(&dbuf, arch, strlen(arch) + 1);

arch ? strlen(arch) + 1 : 1);

sv = rval.size;

sv = dbuf.len;

/* Fix the record number in the btree value. */

memset(val.data, 0, sizeof(uint32_t));

memcpy(val.data + 4, &rec, sizeof(uint32_t));

if (mdoc)

pmdoc(db, fbbuf, &key, &ksz,

pmdoc_node(hash, &buf, &dbuf,

&val, &rval, &rsz, mdoc);

mdoc_node(mdoc), mdoc_meta(mdoc));

else

pman(db, fbbuf, &key, &ksz,

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

&val, &rval, &rsz, man);

* Apply this to the index. If we haven't had a

* Copy from the in-memory hashtable of pending keywords

* description set, put an empty one in now.

* into the database.

memset(vbuf, 0, sizeof(uint32_t));

memcpy(vbuf + 4, &rec, sizeof(uint32_t));

if (rval.size == sv)

seq = R_FIRST;

dbt_appendb(&rval, &rsz, "", 1);

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

seq = R_NEXT;

rkey.data = &rec;

memcpy(vbuf, val.data, sizeof(uint32_t));

dbt_put(idx, ibbuf, &rkey, &rval);

val.size = sizeof(vbuf);

val.data = vbuf;

printf("Indexed: %s\n", fn);

if (verb > 1)

rec++;

printf("Indexed: %s, %s, 0x%x\n",

}

fn, (char *)key.data,

*(int *)val.data);

dbt_put(db, fbuf, &key, &val);

}

if (ch < 0) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

}

* Apply to the index. If we haven't had a description

* set, put an empty one in now.

(*db->close)(db);

if (dbuf.len == sv)

(*idx->close)(idx);

buf_appendb(&dbuf, "", 1);

mparse_free(mp);

key.data = &rec;

key.size = sizeof(recno_t);

free(key.data);

val.data = dbuf.cp;

free(rval.data);

val.size = dbuf.len;

/* Atomically replace the file with our temporary one. */

if (verb > 0)

printf("Indexed: %s\n", fn);

if (-1 == rename(fbbuf, fbuf))

dbt_put(idx, ibuf, &key, &val);

perror(fbuf);

}

if (-1 == rename(ibbuf, ibuf))

perror(fbuf);

return((int)MANDOCLEVEL_OK);

ec = MANDOCLEVEL_OK;

out:

if (db)

(*db->close)(db);

if (idx)

(*idx->close)(idx);

if (hash)

(*hash->close)(hash);

if (mp)

mparse_free(mp);

free(buf.cp);

free(dbuf.cp);

free(recs);

return((int)ec);

}

* Initialise the stored database key whose data buffer is shared

* between uses (as the key must sometimes be constructed from an array

* of

static void

dbt_init(DBT *key, size_t *ksz)

op_delete(const char *fn, int verb, DB *idx,

const char *ibuf, DB *db, const char *fbuf)

{

int ch;

DBT key, val;

recno_t rec;

unsigned int seq, sseq;

if (0 == *ksz) {

seq = R_FIRST;

assert(0 == key->size);

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

assert(NULL == key->data);

seq = R_NEXT;

key->data = mandoc_malloc(MANDOC_BUFSZ);

if (0 == val.size)

*ksz = MANDOC_BUFSZ;

continue;

}

if (strcmp((char *)val.data, fn))

continue;

key->size = 0;

rec = *(recno_t *)key.data;

sseq = R_FIRST;

while (0 == (ch = (*db->seq)(db, &key, &val, sseq))) {

sseq = R_NEXT;

assert(8 == val.size);

if (rec != *(recno_t *)(val.data + 4))

continue;

if (verb > 1)

printf("Deleted: %s, %s\n",

fn, (char *)key.data);

ch = (*db->del)(db, &key, R_CURSOR);

if (ch < 0)

break;

}

if (ch < 0) {

perror(fbuf);

exit((int)MANDOCLEVEL_SYSERR);

}

val.size = 0;

if (verb)

printf("Deleted: %s\n", fn);

ch = (*idx->put)

(idx, &key, &val, R_CURSOR);

if (ch < 0)

break;

}

if (ch < 0) {

perror(ibuf);

exit((int)MANDOCLEVEL_SYSERR);

}

* Append a binary value to a database entry. This can be invoked

* Grow the buffer (if necessary) and copy in a binary string.

* multiple times; the buffer is automatically resized.

static void

dbt_appendb(DBT *key, size_t *ksz, const void *cp, size_t sz)

buf_appendb(struct buf *buf, const void *cp, size_t sz)

{

assert(key->data);

/* Overshoot by MANDOC_BUFSZ. */

while (key->size + sz >= *ksz) {

while (buf->len + sz >= buf->size) {

*ksz = key->size + sz + MANDOC_BUFSZ;

buf->size = buf->len + sz + MANDOC_BUFSZ;

key->data = mandoc_realloc(key->data, *ksz);

buf->cp = mandoc_realloc(buf->cp, buf->size);

}

memcpy(key->data + (int)key->size, cp, sz);

memcpy(buf->cp + (int)buf->len, cp, sz);

key->size += sz;

buf->len += sz;

}

* Append a nil-terminated string to the database entry. This can be

* Append a nil-terminated string to the buffer.

* invoked multiple times. The database entry will be nil-terminated as

* This can be invoked multiple times.

* well; if invoked multiple times, a space is put between strings.

* The buffer string will be nil-terminated.

* If invoked multiple times, a space is put between strings.

static void

dbt_append(DBT *key, size_t *ksz, const char *cp)

buf_append(struct buf *buf, const char *cp)

{

size_t sz;

if (0 == (sz = strlen(cp)))

return;

assert(key->data);

if (buf->len)

buf->cp[(int)buf->len - 1] = ' ';

if (key->size)

buf_appendb(buf, cp, sz + 1);

((char *)key->data)[(int)key->size - 1] = ' ';

}

dbt_appendb(key, ksz, cp, sz + 1);

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

static void

buf_appendmdoc(struct buf *buf, const struct mdoc_node *n, int f)

{

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

if (n->child)

buf_appendmdoc(buf, n->child, f);

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

}

/* ARGSUSED */

static void

pmdoc_An(MDOC_ARGS)

{

uint32_t fl;

if (SEC_AUTHORS != n->sec)

return;

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

buf_appendmdoc(buf, n->child, 0);

if (MDOC_TEXT == n->type)

hash_put(hash, buf, TYPE_AUTHOR);

dbt_append(key, ksz, n->string);

}

fl = (uint32_t)MANDOC_AUTHOR;

static void

memcpy(val->data, &fl, 4);

hash_reset(DB **db)

{

DB *hash;

if (NULL != (hash = *db))

(*hash->close)(hash);

*db = dbopen(NULL, MANDOC_FLAGS, 0644, DB_HASH, NULL);

if (NULL == *db) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

}

/* ARGSUSED */

static void

pmdoc_Fd(MDOC_ARGS)

{

uint32_t fl;

const char *start, *end;

size_t sz;

Line 550 pmdoc_Fd(MDOC_ARGS)

Line 721 pmdoc_Fd(MDOC_ARGS)

end--;

assert(end >= start);

dbt_appendb(key, ksz, start, (size_t)(end - start + 1));

dbt_appendb(key, ksz, "", 1);

fl = (uint32_t)MANDOC_INCLUDES;

buf_appendb(buf, start, (size_t)(end - start + 1));

memcpy(val->data, &fl, 4);

buf_appendb(buf, "", 1);

hash_put(hash, buf, TYPE_INCLUDES);

}

/* ARGSUSED */

static void

pmdoc_Cd(MDOC_ARGS)

{

uint32_t fl;

if (SEC_SYNOPSIS != n->sec)

return;

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

buf_appendmdoc(buf, n->child, 0);

if (MDOC_TEXT == n->type)

hash_put(hash, buf, TYPE_CONFIG);

dbt_append(key, ksz, n->string);

fl = (uint32_t)MANDOC_CONFIG;

memcpy(val->data, &fl, 4);

}

/* ARGSUSED */

static void

pmdoc_In(MDOC_ARGS)

{

uint32_t fl;

if (SEC_SYNOPSIS != n->sec)

return;

if (NULL == n->child || MDOC_TEXT != n->child->type)

return;

dbt_append(key, ksz, n->child->string);

buf_append(buf, n->child->string);

fl = (uint32_t)MANDOC_INCLUDES;

hash_put(hash, buf, TYPE_INCLUDES);

memcpy(val->data, &fl, 4);

}

/* ARGSUSED */

static void

pmdoc_Fn(MDOC_ARGS)

{

uint32_t fl;

const char *cp;

if (SEC_SYNOPSIS != n->sec)

Line 613 pmdoc_Fn(MDOC_ARGS)

Line 776 pmdoc_Fn(MDOC_ARGS)

while ('*' == *cp)

cp++;

dbt_append(key, ksz, cp);

buf_append(buf, cp);

fl = (uint32_t)MANDOC_FUNCTION;

hash_put(hash, buf, TYPE_FUNCTION);

memcpy(val->data, &fl, 4);

}

/* ARGSUSED */

static void

pmdoc_St(MDOC_ARGS)

{

uint32_t fl;

if (SEC_STANDARDS != n->sec)

return;

if (NULL == n->child || MDOC_TEXT != n->child->type)

return;

dbt_append(key, ksz, n->child->string);

buf_append(buf, n->child->string);

fl = (uint32_t)MANDOC_STANDARD;

hash_put(hash, buf, TYPE_STANDARD);

memcpy(val->data, &fl, 4);

}

/* ARGSUSED */

static void

pmdoc_Xr(MDOC_ARGS)

{

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

return;

buf_appendb(buf, n->string, strlen(n->string));

if (NULL != (n = n->next)) {

buf_appendb(buf, ".", 1);

buf_appendb(buf, n->string, strlen(n->string) + 1);

} else

buf_appendb(buf, ".", 2);

hash_put(hash, buf, TYPE_XREF);

}

/* ARGSUSED */

static void

pmdoc_Vt(MDOC_ARGS)

{

uint32_t fl;

const char *start;

size_t sz;

Line 667 pmdoc_Vt(MDOC_ARGS)

Line 845 pmdoc_Vt(MDOC_ARGS)

if (0 == sz)

return;

dbt_appendb(key, ksz, start, sz);

buf_appendb(buf, start, sz);

dbt_appendb(key, ksz, "", 1);

buf_appendb(buf, "", 1);

hash_put(hash, buf, TYPE_VARIABLE);

fl = (uint32_t)MANDOC_VARIABLE;

memcpy(val->data, &fl, 4);

}

/* ARGSUSED */

static void

pmdoc_Fo(MDOC_ARGS)

{

uint32_t fl;

if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)

return;

if (NULL == n->child || MDOC_TEXT != n->child->type)

return;

dbt_append(key, ksz, n->child->string);

buf_append(buf, n->child->string);

fl = (uint32_t)MANDOC_FUNCTION;

hash_put(hash, buf, TYPE_FUNCTION);

memcpy(val->data, &fl, 4);

}

Line 695 pmdoc_Fo(MDOC_ARGS)

Line 869 pmdoc_Fo(MDOC_ARGS)

static void

pmdoc_Nd(MDOC_ARGS)

{

int first;

if (MDOC_BODY != n->type)

return;

buf_appendmdoc(dbuf, n->child, 1);

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_DESC);

}

/* ARGSUSED */

static void

pmdoc_Er(MDOC_ARGS)

{

if (SEC_ERRORS != n->sec)

return;

for (first = 1, n = n->child; n; n = n->next) {

buf_appendmdoc(buf, n->child, 0);

if (MDOC_TEXT != n->type)

hash_put(hash, buf, TYPE_ERR);

continue;

if (first)

dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);

else

dbt_append(rval, rsz, n->string);

first = 0;

}

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

}

/* ARGSUSED */

static void

pmdoc_Pa(MDOC_ARGS)

{

if (SEC_FILES != n->sec)

return;

buf_appendmdoc(buf, n->child, 0);

hash_put(hash, buf, TYPE_PATH);

}

/* ARGSUSED */

static void

pmdoc_Nm(MDOC_ARGS)

{

uint32_t fl;

if (SEC_NAME == n->sec) {

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

buf_appendmdoc(buf, n->child, 0);

if (MDOC_TEXT != n->type)

hash_put(hash, buf, TYPE_NAME);

continue;

dbt_append(key, ksz, n->string);

}

fl = (uint32_t)MANDOC_NAME;

memcpy(val->data, &fl, 4);

return;

} else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)

return;

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

if (NULL == n->child)

if (MDOC_TEXT != n->type)

buf_append(buf, m->name);

continue;

dbt_append(key, ksz, n->string);

}

fl = (uint32_t)MANDOC_UTILITY;

buf_appendmdoc(buf, n->child, 0);

memcpy(val->data, &fl, 4);

hash_put(hash, buf, TYPE_UTILITY);

}

static void

dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)

hash_put(DB *db, const struct buf *buf, int mask)

{

DBT key, val;

int rc;

if (0 == key->size)

if (buf->len < 2)

return;

assert(key->data);

key.data = buf->cp;

key.size = buf->len;

if ((rc = (*db->get)(db, &key, &val, 0)) < 0) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

} else if (0 == rc)

mask |= *(int *)val.data;

val.data = &mask;

val.size = sizeof(int);

if ((rc = (*db->put)(db, &key, &val, 0)) < 0) {

perror("hash");

exit((int)MANDOCLEVEL_SYSERR);

}

static void

dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)

{

assert(key->size);

assert(val->size);

assert(val->data);

if (0 == (*db->put)(db, key, val, 0))

return;

Line 779 pmdoc_node(MDOC_ARGS)

Line 1000 pmdoc_node(MDOC_ARGS)

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

break;

dbt_init(key, ksz);

buf->len = 0;

(*mdocs[n->tok])(hash, buf, dbuf, n, m);

(*mdocs[n->tok])(db, dbn, key, ksz, val, rval, rsz, n);

dbt_put(db, dbn, key, val);

break;

default:

break;

}

pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->child);

pmdoc_node(hash, buf, dbuf, n->child, m);

pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->next);

pmdoc_node(hash, buf, dbuf, n->next, m);

}

static int

Line 798 pman_node(MAN_ARGS)

Line 1017 pman_node(MAN_ARGS)

const struct man_node *head, *body;

const char *start, *sv;

size_t sz;

uint32_t fl;

if (NULL == n)

return(0);

Line 821 pman_node(MAN_ARGS)

Line 1039 pman_node(MAN_ARGS)

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

MAN_TEXT == body->type) {

fl = (uint32_t)MANDOC_NAME;

memcpy(val->data, &fl, 4);

assert(body->string);

start = sv = body->string;

Line 842 pman_node(MAN_ARGS)

Line 1057 pman_node(MAN_ARGS)

if ('\0' == start[(int)sz])

break;

dbt_init(key, ksz);

buf->len = 0;

dbt_appendb(key, ksz, start, sz);

buf_appendb(buf, start, sz);

dbt_appendb(key, ksz, "", 1);

buf_appendb(buf, "", 1);

dbt_put(db, dbn, key, val);

hash_put(hash, buf, TYPE_NAME);

if (' ' == start[(int)sz]) {

start += (int)sz + 1;

Line 859 pman_node(MAN_ARGS)

Line 1074 pman_node(MAN_ARGS)

start++;

}

buf->len = 0;

if (sv == start) {

dbt_init(key, ksz);

buf_append(buf, start);

dbt_append(key, ksz, start);

return(1);

}

Line 880 pman_node(MAN_ARGS)

Line 1096 pman_node(MAN_ARGS)

while (' ' == *start)

start++;

dbt_appendb(rval, rsz, start, strlen(start) + 1);

sz = strlen(start) + 1;

buf_appendb(dbuf, start, sz);

buf_appendb(buf, start, sz);

hash_put(hash, buf, TYPE_DESC);

}

if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->child))

if (pman_node(hash, buf, dbuf, n->child))

return(1);

if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->next))

if (pman_node(hash, buf, dbuf, n->next))

return(1);

return(0);

}

static void

pman(DB *db, const char *dbn, DBT *key, size_t *ksz,

DBT *val, DBT *rval, size_t *rsz, struct man *m)

{

pman_node(db, dbn, key, ksz, val, rval, rsz, man_node(m));

}

static void

pmdoc(DB *db, const char *dbn, DBT *key, size_t *ksz,

DBT *val, DBT *rval, size_t *rsz, struct mdoc *m)

{

pmdoc_node(db, dbn, key, ksz, val, rval, rsz, mdoc_node(m));

}

static void

usage(void)

{

fprintf(stderr, "usage: %s "

fprintf(stderr, "usage: %s [-ruv] [-d path] [file...]\n",

"[-d path] "

"[file...]\n",

progname);

}

CVSweb