mandoc/mandoc-db.c - diff

Return to mandoc-db.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/Attic/mandoc-db.c between version 1.7 and 1.17

version 1.7, 2011/04/05 13:12:34

version 1.17, 2011/05/03 14:39:27

Line 48 enum type {

MANDOC_FUNCTION,

MANDOC_UTILITY,

MANDOC_INCLUDES,

MANDOC_VARIABLE

MANDOC_VARIABLE,

MANDOC_STANDARD,

MANDOC_AUTHOR

};

#define MAN_ARGS DB *db, \

const char *dbn, \

DBT *key, size_t *ksz, \

DBT *val, \

DBT *rval, size_t *rsz, \

const struct man_node *n

#define MDOC_ARGS DB *db, \

const char *dbn, \

DBT *key, size_t *ksz, \

DBT *val, \

DBT *rval, size_t *rsz, \

const struct mdoc_node *n

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

static void dbt_appendb(DBT *, size_t *,

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 pman(DB *, const char *,

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

DBT *, size_t *, DBT *,

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

const char *, struct man *);

static int pman_node(MAN_ARGS);

static void pmdoc(DB *, const char *,

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

DBT *, size_t *, DBT *,

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

const char *, struct mdoc *);

static void pmdoc_node(MDOC_ARGS);

static void pmdoc_An(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_St(MDOC_ARGS);

static void pmdoc_Vt(MDOC_ARGS);

typedef void (*pmdoc_nf)(MDOC_ARGS);

Line 102 static const pmdoc_nf mdocs[MDOC_MAX] = {

Line 108 static const pmdoc_nf mdocs[MDOC_MAX] = {

NULL, /* El */

NULL, /* It */

NULL, /* Ad */

NULL, /* An */

pmdoc_An, /* An */

NULL, /* Ar */

NULL, /* Cd */

NULL, /* Cm */

Line 118 static const pmdoc_nf mdocs[MDOC_MAX] = {

Line 124 static const pmdoc_nf mdocs[MDOC_MAX] = {

NULL, /* Ic */

pmdoc_In, /* In */

NULL, /* Li */

NULL, /* Nd */

pmdoc_Nd, /* Nd */

pmdoc_Nm, /* Nm */

NULL, /* Op */

NULL, /* Ot */

NULL, /* Pa */

NULL, /* Rv */

NULL, /* St */

pmdoc_St, /* St */

pmdoc_Vt, /* Va */

pmdoc_Vt, /* Vt */

NULL, /* Xr */

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

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

struct mparse *mp; /* parse sequence */

struct mdoc *mdoc; /* resulting mdoc */

struct man *man; /* resulting man */

char *fn;

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

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

const char *msec, /* manual section */

*mtitle, /* manual title */

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

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

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

fbuf[MAXPATHLEN], /* btree fname */

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

int c;

int ch;

DB *index, /* index database */

DB *idx, /* index database */

*db; /* keyword database */

DBT rkey, rval, /* recno entries */

key, val; /* persistent keyword entries */

size_t ksz; /* entry buffer size */

size_t sv,

char vbuf[8];

ksz, rsz; /* entry buffer size */

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

BTREEINFO info; /* btree configuration */

recno_t rec;

recno_t rec; /* current record number */

extern int optind;

extern char *optarg;

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

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

dir = "";

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

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

switch (c) {

switch (ch) {

case ('d'):

dir = optarg;

break;

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

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

exit((int)MANDOCLEVEL_SYSERR);

}

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

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

if (NULL == db) {

perror(ibbuf);

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

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

rkey.size = sizeof(recno_t);

rec = 1;

ksz = 0;

ksz = rsz = 0;

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

mparse_reset(mp);

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

rkey.data = &rec;

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

rval.data = fn;

rval.size = strlen(fn) + 1;

if (-1 == (*index->put)(index, &rkey, &rval, 0)) {

msec = NULL != mdoc ?

perror(ibbuf);

mdoc_meta(mdoc)->msec :

break;

man_meta(man)->msec;

}

mtitle = NULL != mdoc ?

mdoc_meta(mdoc)->title :

man_meta(man)->title;

assert(msec);

assert(mtitle);

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

dbt_init(&rval, &rsz);

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

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

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

sv = rval.size;

/* 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, &val, fn, mdoc);

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

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

else

pman(db, fbbuf, &key, &ksz, &val, fn, man);

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

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

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

* description set, put an empty one in now.

if (rval.size == sv)

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

rkey.data = &rec;

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

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

rec++;

}

(*db->close)(db);

(*index->close)(index);

(*idx->close)(idx);

mparse_free(mp);

free(key.data);

free(rval.data);

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

Line 416 dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz

Line 461 dbt_appendb(DBT *key, size_t *ksz, const void *cp, siz

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

}

#if 0

dstp = key->data + (int)key->size;

while (NULL != (endp = memchr(cp, '\\', sz))) {

ssz = endp - cp;

memcpy(dstp, cp, ssz);

dstp += ssz;

key->size += ssz;

sz -= ssz;

cp = endp++;

/* FIXME: expects nil-terminated string! */

esc = mandoc_escape((const char **)&endp, NULL, NULL);

switch (esc) {

case (ESCAPE_ERROR):

/* Nil-terminate this point. */

memcpy(dstp, "", 1);

key->size++;

return;

case (ESCAPE_PREDEF):

/* FALLTHROUGH */

case (ESCAPE_SPECIAL):

break;

default:

sz -= endp - cp;

cp = endp;

continue;

}

ssz = endp - cp;

memcpy(dstp, cp, ssz);

dstp += ssz;

key->size += ssz;

sz -= ssz;

cp = endp;

}

#endif

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

key->size += sz;

}

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

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

/* ARGSUSED */

static void

pmdoc_An(MDOC_ARGS)

{

uint32_t fl;

if (SEC_AUTHORS != n->sec)

return;

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

if (MDOC_TEXT == n->type)

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

fl = MANDOC_AUTHOR;

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

}

/* ARGSUSED */

static void

pmdoc_Fd(MDOC_ARGS)

{

uint32_t fl;

const char *start, *end;

size_t sz;

char nil;

if (SEC_SYNOPSIS != n->sec)

return;

Line 481 pmdoc_Fd(MDOC_ARGS)

Line 584 pmdoc_Fd(MDOC_ARGS)

if ('>' == *end || '"' == *end)

end--;

nil = '\0';

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

dbt_appendb(key, ksz, &nil, 1);

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

fl = MANDOC_INCLUDES;

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

Line 535 pmdoc_Fn(MDOC_ARGS)

Line 637 pmdoc_Fn(MDOC_ARGS)

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

fl = MANDOC_STANDARD;

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

}

/* ARGSUSED */

static void

pmdoc_Vt(MDOC_ARGS)

{

uint32_t fl;

const char *start, *end;

const char *start;

size_t sz;

char nil;

if (SEC_SYNOPSIS != n->sec)

return;

Line 561 pmdoc_Vt(MDOC_ARGS)

Line 678 pmdoc_Vt(MDOC_ARGS)

if (0 == (sz = strlen(start)))

return;

end = &start[sz - 1];

if (';' == start[sz - 1])

while (end > start && ';' == *end)

sz--;

end--;

if (end == start)

if (0 == sz)

return;

nil = '\0';

dbt_appendb(key, ksz, start, sz);

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

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

dbt_appendb(key, ksz, &nil, 1);

fl = MANDOC_VARIABLE;

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

}

Line 591 pmdoc_Fo(MDOC_ARGS)

Line 707 pmdoc_Fo(MDOC_ARGS)

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

}

/* ARGSUSED */

static void

pmdoc_Nd(MDOC_ARGS)

{

int first;

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

if (MDOC_TEXT != n->type)

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_Nm(MDOC_ARGS)

{

uint32_t fl;

Line 619 pmdoc_Nm(MDOC_ARGS)

Line 753 pmdoc_Nm(MDOC_ARGS)

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

}

static void

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

{

if (0 == key->size)

return;

assert(key->data);

assert(val->size);

assert(val->data);

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

return;

perror(dbn);

exit((int)MANDOCLEVEL_SYSERR);

/* NOTREACHED */

}

* Call out to per-macro handlers after clearing the persistent database

* key. If the macro sets the database key, flush it to the database.

Line 644 pmdoc_node(MDOC_ARGS)

Line 797 pmdoc_node(MDOC_ARGS)

break;

dbt_init(key, ksz);

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

if (0 == key->size)

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

break;

dbt_put(db, dbn, key, val);

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

break;

perror(dbn);

exit((int)MANDOCLEVEL_SYSERR);

/* NOTREACHED */

default:

break;

}

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

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

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

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

}

static int

pman_node(MAN_ARGS)

{

const struct man_node *head, *body;

const char *end, *start;

const char *start, *sv;

char nil;

size_t sz;

uint32_t fl;

if (NULL == n)

Line 690 pman_node(MAN_ARGS)

Line 837 pman_node(MAN_ARGS)

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

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

MAN_TEXT == body->type) {

nil = '\0';

start = body->string;

if (NULL == (end = strchr(start, ' ')))

end = start + strlen(start);

dbt_init(key, ksz);

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

dbt_appendb(key, ksz, &nil, 1);

fl = MANDOC_NAME;

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

return(1);

assert(body->string);

start = sv = body->string;

* Go through a special heuristic dance here.

* This is why -man manuals are great!

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

for ( ;; ) {

sz = strcspn(start, " ,");

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

break;

dbt_init(key, ksz);

dbt_appendb(key, ksz, start, sz);

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

dbt_put(db, dbn, key, val);

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

start += (int)sz + 1;

break;

}

assert(',' == start[(int)sz]);

start += (int)sz + 1;

while (' ' == *start)

start++;

}

if (sv == start) {

dbt_init(key, ksz);

dbt_append(key, ksz, start);

return(1);

}

while (' ' == *start)

start++;

if ('\\' == *start && '-' == *(start + 1))

start += 2;

else if ('-' == *start)

start++;

while (' ' == *start)

start++;

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

}

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

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

return(1);

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

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

return(1);

return(0);

}

static void

pman(DB *db, const char *dbn,

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

DBT *key, size_t *ksz, DBT *val,

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

const char *path, struct man *m)

{

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

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

}

static void

pmdoc(DB *db, const char *dbn,

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

DBT *key, size_t *ksz, DBT *val,

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

const char *path, struct mdoc *m)

{

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

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

}

static void

CVSweb