Annotation of mandoc/mandoc-db.c, Revision 1.11
1.11 ! kristaps 1: /* $Id: mandoc-db.c,v 1.10 2011/04/11 21:36:44 kristaps Exp $ */
1.1 kristaps 2: /*
3: * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
1.2 kristaps 17: #ifdef HAVE_CONFIG_H
18: #include "config.h"
19: #endif
20:
1.1 kristaps 21: #include <sys/param.h>
22:
23: #include <assert.h>
24: #ifdef __linux__
25: # include <db_185.h>
26: #else
27: # include <db.h>
28: #endif
29: #include <fcntl.h>
30: #include <getopt.h>
31: #include <stdio.h>
32: #include <stdint.h>
33: #include <stdlib.h>
34: #include <string.h>
35:
36: #include "man.h"
37: #include "mdoc.h"
38: #include "mandoc.h"
39:
40: #define MANDOC_DB "mandoc.db"
1.3 kristaps 41: #define MANDOC_IDX "mandoc.index"
1.2 kristaps 42: #define MANDOC_BUFSZ BUFSIZ
1.3 kristaps 43: #define MANDOC_FLAGS O_CREAT|O_TRUNC|O_RDWR
1.1 kristaps 44:
45: enum type {
46: MANDOC_NONE = 0,
47: MANDOC_NAME,
48: MANDOC_FUNCTION,
49: MANDOC_UTILITY,
50: MANDOC_INCLUDES,
51: MANDOC_VARIABLE
52: };
53:
1.6 kristaps 54: #define MAN_ARGS DB *db, \
55: const char *dbn, \
56: DBT *key, size_t *ksz, \
57: DBT *val, \
1.11 ! kristaps 58: DBT *rval, size_t *rsz, \
1.6 kristaps 59: const struct man_node *n
1.1 kristaps 60: #define MDOC_ARGS DB *db, \
61: const char *dbn, \
62: DBT *key, size_t *ksz, \
63: DBT *val, \
1.11 ! kristaps 64: DBT *rval, size_t *rsz, \
1.1 kristaps 65: const struct mdoc_node *n
66:
67: static void dbt_append(DBT *, size_t *, const char *);
68: static void dbt_appendb(DBT *, size_t *,
69: const void *, size_t);
70: static void dbt_init(DBT *, size_t *);
1.8 kristaps 71: static void dbt_put(DB *, const char *, DBT *, DBT *);
1.1 kristaps 72: static void usage(void);
1.11 ! kristaps 73: static void pman(DB *, const char *, DBT *, size_t *,
! 74: DBT *, DBT *, size_t *, struct man *);
1.6 kristaps 75: static int pman_node(MAN_ARGS);
1.11 ! kristaps 76: static void pmdoc(DB *, const char *, DBT *, size_t *,
! 77: DBT *, DBT *, size_t *, struct mdoc *);
1.1 kristaps 78: static void pmdoc_node(MDOC_ARGS);
79: static void pmdoc_Fd(MDOC_ARGS);
80: static void pmdoc_In(MDOC_ARGS);
81: static void pmdoc_Fn(MDOC_ARGS);
82: static void pmdoc_Fo(MDOC_ARGS);
1.11 ! kristaps 83: static void pmdoc_Nd(MDOC_ARGS);
1.1 kristaps 84: static void pmdoc_Nm(MDOC_ARGS);
85: static void pmdoc_Vt(MDOC_ARGS);
86:
87: typedef void (*pmdoc_nf)(MDOC_ARGS);
88:
89: static const char *progname;
90:
91: static const pmdoc_nf mdocs[MDOC_MAX] = {
92: NULL, /* Ap */
93: NULL, /* Dd */
94: NULL, /* Dt */
95: NULL, /* Os */
96: NULL, /* Sh */
97: NULL, /* Ss */
98: NULL, /* Pp */
99: NULL, /* D1 */
100: NULL, /* Dl */
101: NULL, /* Bd */
102: NULL, /* Ed */
103: NULL, /* Bl */
104: NULL, /* El */
105: NULL, /* It */
106: NULL, /* Ad */
107: NULL, /* An */
108: NULL, /* Ar */
109: NULL, /* Cd */
110: NULL, /* Cm */
111: NULL, /* Dv */
112: NULL, /* Er */
113: NULL, /* Ev */
114: NULL, /* Ex */
115: NULL, /* Fa */
116: pmdoc_Fd, /* Fd */
117: NULL, /* Fl */
118: pmdoc_Fn, /* Fn */
119: NULL, /* Ft */
120: NULL, /* Ic */
121: pmdoc_In, /* In */
122: NULL, /* Li */
1.11 ! kristaps 123: pmdoc_Nd, /* Nd */
1.1 kristaps 124: pmdoc_Nm, /* Nm */
125: NULL, /* Op */
126: NULL, /* Ot */
127: NULL, /* Pa */
128: NULL, /* Rv */
129: NULL, /* St */
130: pmdoc_Vt, /* Va */
131: pmdoc_Vt, /* Vt */
132: NULL, /* Xr */
133: NULL, /* %A */
134: NULL, /* %B */
135: NULL, /* %D */
136: NULL, /* %I */
137: NULL, /* %J */
138: NULL, /* %N */
139: NULL, /* %O */
140: NULL, /* %P */
141: NULL, /* %R */
142: NULL, /* %T */
143: NULL, /* %V */
144: NULL, /* Ac */
145: NULL, /* Ao */
146: NULL, /* Aq */
147: NULL, /* At */
148: NULL, /* Bc */
149: NULL, /* Bf */
150: NULL, /* Bo */
151: NULL, /* Bq */
152: NULL, /* Bsx */
153: NULL, /* Bx */
154: NULL, /* Db */
155: NULL, /* Dc */
156: NULL, /* Do */
157: NULL, /* Dq */
158: NULL, /* Ec */
159: NULL, /* Ef */
160: NULL, /* Em */
161: NULL, /* Eo */
162: NULL, /* Fx */
163: NULL, /* Ms */
164: NULL, /* No */
165: NULL, /* Ns */
166: NULL, /* Nx */
167: NULL, /* Ox */
168: NULL, /* Pc */
169: NULL, /* Pf */
170: NULL, /* Po */
171: NULL, /* Pq */
172: NULL, /* Qc */
173: NULL, /* Ql */
174: NULL, /* Qo */
175: NULL, /* Qq */
176: NULL, /* Re */
177: NULL, /* Rs */
178: NULL, /* Sc */
179: NULL, /* So */
180: NULL, /* Sq */
181: NULL, /* Sm */
182: NULL, /* Sx */
183: NULL, /* Sy */
184: NULL, /* Tn */
185: NULL, /* Ux */
186: NULL, /* Xc */
187: NULL, /* Xo */
188: pmdoc_Fo, /* Fo */
189: NULL, /* Fc */
190: NULL, /* Oo */
191: NULL, /* Oc */
192: NULL, /* Bk */
193: NULL, /* Ek */
194: NULL, /* Bt */
195: NULL, /* Hf */
196: NULL, /* Fr */
197: NULL, /* Ud */
198: NULL, /* Lb */
199: NULL, /* Lp */
200: NULL, /* Lk */
201: NULL, /* Mt */
202: NULL, /* Brq */
203: NULL, /* Bro */
204: NULL, /* Brc */
205: NULL, /* %C */
206: NULL, /* Es */
207: NULL, /* En */
208: NULL, /* Dx */
209: NULL, /* %Q */
210: NULL, /* br */
211: NULL, /* sp */
212: NULL, /* %U */
213: NULL, /* Ta */
214: };
215:
216: int
217: main(int argc, char *argv[])
218: {
1.2 kristaps 219: struct mparse *mp; /* parse sequence */
220: struct mdoc *mdoc; /* resulting mdoc */
1.6 kristaps 221: struct man *man; /* resulting man */
1.11 ! kristaps 222: char *fn; /* current file being parsed */
! 223: const char *msec, /* manual section */
1.10 kristaps 224: *dir; /* result dir (default: cwd) */
1.3 kristaps 225: char ibuf[MAXPATHLEN], /* index fname */
226: ibbuf[MAXPATHLEN], /* index backup fname */
227: fbuf[MAXPATHLEN], /* btree fname */
1.2 kristaps 228: fbbuf[MAXPATHLEN]; /* btree backup fname */
1.11 ! kristaps 229: int ch;
1.9 kristaps 230: DB *idx, /* index database */
1.3 kristaps 231: *db; /* keyword database */
232: DBT rkey, rval, /* recno entries */
233: key, val; /* persistent keyword entries */
1.11 ! kristaps 234: size_t sv,
! 235: ksz, rsz; /* entry buffer size */
! 236: char vbuf[8]; /* stringified record number */
1.2 kristaps 237: BTREEINFO info; /* btree configuration */
1.11 ! kristaps 238: recno_t rec; /* current record number */
1.1 kristaps 239: extern int optind;
240: extern char *optarg;
241:
242: progname = strrchr(argv[0], '/');
243: if (progname == NULL)
244: progname = argv[0];
245: else
246: ++progname;
247:
1.3 kristaps 248: dir = "";
1.2 kristaps 249:
1.11 ! kristaps 250: while (-1 != (ch = getopt(argc, argv, "d:")))
! 251: switch (ch) {
1.2 kristaps 252: case ('d'):
253: dir = optarg;
1.1 kristaps 254: break;
255: default:
256: usage();
257: return((int)MANDOCLEVEL_BADARG);
258: }
259:
260: argc -= optind;
261: argv += optind;
262:
263: /*
1.3 kristaps 264: * Set up temporary file-names into which we're going to write
265: * all of our data (both for the index and database). These
266: * will be securely renamed to the real file-names after we've
267: * written all of our data.
1.1 kristaps 268: */
269:
1.3 kristaps 270: ibuf[0] = ibuf[MAXPATHLEN - 2] =
271: ibbuf[0] = ibbuf[MAXPATHLEN - 2] =
272: fbuf[0] = fbuf[MAXPATHLEN - 2] =
273: fbbuf[0] = fbbuf[MAXPATHLEN - 2] = '\0';
1.2 kristaps 274:
275: strlcat(fbuf, dir, MAXPATHLEN);
276: strlcat(fbuf, MANDOC_DB, MAXPATHLEN);
1.3 kristaps 277:
1.2 kristaps 278: strlcat(fbbuf, fbuf, MAXPATHLEN);
279: strlcat(fbbuf, "~", MAXPATHLEN);
280:
1.3 kristaps 281: strlcat(ibuf, dir, MAXPATHLEN);
282: strlcat(ibuf, MANDOC_IDX, MAXPATHLEN);
283:
284: strlcat(ibbuf, ibuf, MAXPATHLEN);
285: strlcat(ibbuf, "~", MAXPATHLEN);
286:
1.2 kristaps 287: if ('\0' != fbuf[MAXPATHLEN - 2] ||
1.3 kristaps 288: '\0' != fbbuf[MAXPATHLEN - 2] ||
289: '\0' != ibuf[MAXPATHLEN - 2] ||
290: '\0' != ibbuf[MAXPATHLEN - 2]) {
291: fprintf(stderr, "%s: Path too long\n", progname);
1.1 kristaps 292: exit((int)MANDOCLEVEL_SYSERR);
293: }
294:
295: /*
1.3 kristaps 296: * For the keyword database, open a BTREE database that allows
297: * duplicates. For the index database, use a standard RECNO
298: * database type.
1.1 kristaps 299: */
300:
301: memset(&info, 0, sizeof(BTREEINFO));
302: info.flags = R_DUP;
1.3 kristaps 303: db = dbopen(fbbuf, MANDOC_FLAGS, 0644, DB_BTREE, &info);
1.1 kristaps 304:
305: if (NULL == db) {
1.2 kristaps 306: perror(fbbuf);
1.1 kristaps 307: exit((int)MANDOCLEVEL_SYSERR);
308: }
309:
1.9 kristaps 310: idx = dbopen(ibbuf, MANDOC_FLAGS, 0644, DB_RECNO, NULL);
1.1 kristaps 311:
1.3 kristaps 312: if (NULL == db) {
313: perror(ibbuf);
314: (*db->close)(db);
315: exit((int)MANDOCLEVEL_SYSERR);
316: }
1.1 kristaps 317:
318: /*
319: * Try parsing the manuals given on the command line. If we
320: * totally fail, then just keep on going. Take resulting trees
321: * and push them down into the database code.
1.3 kristaps 322: * Use the auto-parser and don't report any errors.
1.1 kristaps 323: */
324:
1.3 kristaps 325: mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);
326:
1.1 kristaps 327: memset(&key, 0, sizeof(DBT));
328: memset(&val, 0, sizeof(DBT));
1.3 kristaps 329: memset(&rkey, 0, sizeof(DBT));
330: memset(&rval, 0, sizeof(DBT));
331:
332: val.size = sizeof(vbuf);
333: val.data = vbuf;
334: rkey.size = sizeof(recno_t);
335:
336: rec = 1;
1.10 kristaps 337: ksz = rsz = 0;
1.1 kristaps 338:
339: while (NULL != (fn = *argv++)) {
340: mparse_reset(mp);
1.3 kristaps 341:
1.11 ! kristaps 342: /* Parse and get (non-empty) AST. */
! 343:
1.4 kristaps 344: if (mparse_readfd(mp, -1, fn) >= MANDOCLEVEL_FATAL) {
345: fprintf(stderr, "%s: Parse failure\n", fn);
1.1 kristaps 346: continue;
1.4 kristaps 347: }
1.6 kristaps 348: mparse_result(mp, &mdoc, &man);
349: if (NULL == mdoc && NULL == man)
1.3 kristaps 350: continue;
351:
1.11 ! kristaps 352: /* Manual section: can be empty string. */
! 353:
1.10 kristaps 354: msec = NULL != mdoc ?
355: mdoc_meta(mdoc)->msec :
356: man_meta(man)->msec;
357:
1.11 ! kristaps 358: assert(msec);
! 359:
! 360: /*
! 361: * The index record value consists of a nil-terminated
! 362: * filename, a nil-terminated manual section, and a
! 363: * nil-terminated description. Since the description
! 364: * may not be set, we set a sentinel to see if we're
! 365: * going to write a nil byte in its place.
! 366: */
1.3 kristaps 367:
1.10 kristaps 368: dbt_init(&rval, &rsz);
369: dbt_appendb(&rval, &rsz, fn, strlen(fn) + 1);
370: dbt_appendb(&rval, &rsz, msec, strlen(msec) + 1);
1.11 ! kristaps 371: sv = rval.size;
1.10 kristaps 372:
1.11 ! kristaps 373: /* Fix the record number in the btree value. */
1.3 kristaps 374:
375: memset(val.data, 0, sizeof(uint32_t));
376: memcpy(val.data + 4, &rec, sizeof(uint32_t));
377:
1.6 kristaps 378: if (mdoc)
1.11 ! kristaps 379: pmdoc(db, fbbuf, &key, &ksz,
! 380: &val, &rval, &rsz, mdoc);
1.6 kristaps 381: else
1.11 ! kristaps 382: pman(db, fbbuf, &key, &ksz,
! 383: &val, &rval, &rsz, man);
! 384:
! 385: /*
! 386: * Apply this to the index. If we haven't had a
! 387: * description set, put an empty one in now.
! 388: */
! 389:
! 390: if (rval.size == sv)
! 391: dbt_appendb(&rval, &rsz, "", 1);
! 392:
! 393: rkey.data = &rec;
! 394: dbt_put(idx, ibbuf, &rkey, &rval);
! 395:
! 396: printf("Indexed: %s\n", fn);
1.3 kristaps 397: rec++;
1.1 kristaps 398: }
399:
400: (*db->close)(db);
1.9 kristaps 401: (*idx->close)(idx);
1.3 kristaps 402:
1.1 kristaps 403: mparse_free(mp);
404:
405: free(key.data);
1.10 kristaps 406: free(rval.data);
1.1 kristaps 407:
408: /* Atomically replace the file with our temporary one. */
409:
1.2 kristaps 410: if (-1 == rename(fbbuf, fbuf))
411: perror(fbuf);
1.3 kristaps 412: if (-1 == rename(ibbuf, ibuf))
413: perror(fbuf);
1.1 kristaps 414:
415: return((int)MANDOCLEVEL_OK);
416: }
417:
418: /*
419: * Initialise the stored database key whose data buffer is shared
420: * between uses (as the key must sometimes be constructed from an array
421: * of
422: */
423: static void
424: dbt_init(DBT *key, size_t *ksz)
425: {
426:
427: if (0 == *ksz) {
428: assert(0 == key->size);
429: assert(NULL == key->data);
430: key->data = mandoc_malloc(MANDOC_BUFSZ);
431: *ksz = MANDOC_BUFSZ;
432: }
433:
434: key->size = 0;
435: }
436:
437: /*
438: * Append a binary value to a database entry. This can be invoked
439: * multiple times; the buffer is automatically resized.
440: */
441: static void
442: dbt_appendb(DBT *key, size_t *ksz, const void *cp, size_t sz)
443: {
444:
445: assert(key->data);
446:
447: /* Overshoot by MANDOC_BUFSZ. */
448:
449: while (key->size + sz >= *ksz) {
450: *ksz = key->size + sz + MANDOC_BUFSZ;
451: key->data = mandoc_realloc(key->data, *ksz);
452: }
453:
454: memcpy(key->data + (int)key->size, cp, sz);
455: key->size += sz;
456: }
457:
458: /*
459: * Append a nil-terminated string to the database entry. This can be
460: * invoked multiple times. The database entry will be nil-terminated as
461: * well; if invoked multiple times, a space is put between strings.
462: */
463: static void
464: dbt_append(DBT *key, size_t *ksz, const char *cp)
465: {
466: size_t sz;
467:
468: if (0 == (sz = strlen(cp)))
469: return;
470:
1.3 kristaps 471: assert(key->data);
1.1 kristaps 472:
473: if (key->size)
474: ((char *)key->data)[(int)key->size - 1] = ' ';
475:
1.3 kristaps 476: dbt_appendb(key, ksz, cp, sz + 1);
1.1 kristaps 477: }
478:
479: /* ARGSUSED */
480: static void
481: pmdoc_Fd(MDOC_ARGS)
482: {
483: uint32_t fl;
484: const char *start, *end;
485: size_t sz;
1.10 kristaps 486: const char nil = '\0';
1.1 kristaps 487:
488: if (SEC_SYNOPSIS != n->sec)
489: return;
490: if (NULL == (n = n->child) || MDOC_TEXT != n->type)
491: return;
1.4 kristaps 492:
493: /*
494: * Only consider those `Fd' macro fields that begin with an
495: * "inclusion" token (versus, e.g., #define).
496: */
1.1 kristaps 497: if (strcmp("#include", n->string))
498: return;
1.4 kristaps 499:
1.1 kristaps 500: if (NULL == (n = n->next) || MDOC_TEXT != n->type)
501: return;
502:
1.4 kristaps 503: /*
504: * Strip away the enclosing angle brackets and make sure we're
505: * not zero-length.
506: */
507:
1.1 kristaps 508: start = n->string;
1.5 kristaps 509: if ('<' == *start || '"' == *start)
1.1 kristaps 510: start++;
511:
512: if (0 == (sz = strlen(start)))
513: return;
514:
515: end = &start[(int)sz - 1];
1.5 kristaps 516: if ('>' == *end || '"' == *end)
1.1 kristaps 517: end--;
518:
519: dbt_appendb(key, ksz, start, end - start + 1);
520: dbt_appendb(key, ksz, &nil, 1);
521:
522: fl = MANDOC_INCLUDES;
523: memcpy(val->data, &fl, 4);
524: }
525:
526: /* ARGSUSED */
527: static void
528: pmdoc_In(MDOC_ARGS)
529: {
530: uint32_t fl;
531:
532: if (SEC_SYNOPSIS != n->sec)
533: return;
534: if (NULL == n->child || MDOC_TEXT != n->child->type)
535: return;
536:
537: dbt_append(key, ksz, n->child->string);
538: fl = MANDOC_INCLUDES;
539: memcpy(val->data, &fl, 4);
540: }
541:
542: /* ARGSUSED */
543: static void
544: pmdoc_Fn(MDOC_ARGS)
545: {
546: uint32_t fl;
547: const char *cp;
548:
549: if (SEC_SYNOPSIS != n->sec)
550: return;
551: if (NULL == n->child || MDOC_TEXT != n->child->type)
552: return;
553:
554: /* .Fn "struct type *arg" "foo" */
555:
556: cp = strrchr(n->child->string, ' ');
557: if (NULL == cp)
558: cp = n->child->string;
559:
1.4 kristaps 560: /* Strip away pointer symbol. */
1.1 kristaps 561:
562: while ('*' == *cp)
563: cp++;
564:
565: dbt_append(key, ksz, cp);
566: fl = MANDOC_FUNCTION;
567: memcpy(val->data, &fl, 4);
568: }
569:
570: /* ARGSUSED */
571: static void
572: pmdoc_Vt(MDOC_ARGS)
573: {
574: uint32_t fl;
575: const char *start, *end;
576: size_t sz;
1.10 kristaps 577: const char nil = '\0';
1.1 kristaps 578:
579: if (SEC_SYNOPSIS != n->sec)
580: return;
581: if (MDOC_Vt == n->tok && MDOC_BODY != n->type)
582: return;
1.7 kristaps 583: if (NULL == n->last || MDOC_TEXT != n->last->type)
1.1 kristaps 584: return;
585:
586: /*
1.4 kristaps 587: * Strip away leading pointer symbol '*' and trailing ';'.
1.1 kristaps 588: */
589:
590: start = n->last->string;
591:
592: while ('*' == *start)
593: start++;
594:
595: if (0 == (sz = strlen(start)))
596: return;
597:
598: end = &start[sz - 1];
599: while (end > start && ';' == *end)
600: end--;
601:
602: if (end == start)
603: return;
604:
605: dbt_appendb(key, ksz, start, end - start + 1);
606: dbt_appendb(key, ksz, &nil, 1);
607: fl = MANDOC_VARIABLE;
608: memcpy(val->data, &fl, 4);
609: }
610:
611: /* ARGSUSED */
612: static void
613: pmdoc_Fo(MDOC_ARGS)
614: {
615: uint32_t fl;
616:
617: if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)
618: return;
619: if (NULL == n->child || MDOC_TEXT != n->child->type)
620: return;
621:
622: dbt_append(key, ksz, n->child->string);
623: fl = MANDOC_FUNCTION;
624: memcpy(val->data, &fl, 4);
625: }
626:
1.11 ! kristaps 627:
! 628: /* ARGSUSED */
! 629: static void
! 630: pmdoc_Nd(MDOC_ARGS)
! 631: {
! 632: int first;
! 633:
! 634: for (first = 1, n = n->child; n; n = n->next) {
! 635: if (MDOC_TEXT != n->type)
! 636: continue;
! 637: if (first)
! 638: dbt_appendb(rval, rsz, n->string, strlen(n->string) + 1);
! 639: else
! 640: dbt_append(rval, rsz, n->string);
! 641:
! 642: first = 0;
! 643: }
! 644: }
! 645:
1.1 kristaps 646: /* ARGSUSED */
647: static void
648: pmdoc_Nm(MDOC_ARGS)
649: {
650: uint32_t fl;
651:
652: if (SEC_NAME == n->sec) {
653: for (n = n->child; n; n = n->next) {
654: if (MDOC_TEXT != n->type)
655: continue;
656: dbt_append(key, ksz, n->string);
657: }
658: fl = MANDOC_NAME;
659: memcpy(val->data, &fl, 4);
660: return;
661: } else if (SEC_SYNOPSIS != n->sec || MDOC_HEAD != n->type)
662: return;
663:
664: for (n = n->child; n; n = n->next) {
665: if (MDOC_TEXT != n->type)
666: continue;
667: dbt_append(key, ksz, n->string);
668: }
669:
670: fl = MANDOC_UTILITY;
671: memcpy(val->data, &fl, 4);
672: }
673:
1.8 kristaps 674: static void
675: dbt_put(DB *db, const char *dbn, DBT *key, DBT *val)
676: {
677:
678: if (0 == key->size)
679: return;
680:
681: assert(key->data);
1.10 kristaps 682: assert(val->size);
1.8 kristaps 683: assert(val->data);
684:
685: if (0 == (*db->put)(db, key, val, 0))
686: return;
687:
688: perror(dbn);
689: exit((int)MANDOCLEVEL_SYSERR);
690: /* NOTREACHED */
691: }
692:
1.1 kristaps 693: /*
694: * Call out to per-macro handlers after clearing the persistent database
695: * key. If the macro sets the database key, flush it to the database.
696: */
697: static void
698: pmdoc_node(MDOC_ARGS)
699: {
700:
701: if (NULL == n)
702: return;
703:
704: switch (n->type) {
705: case (MDOC_HEAD):
706: /* FALLTHROUGH */
707: case (MDOC_BODY):
708: /* FALLTHROUGH */
709: case (MDOC_TAIL):
710: /* FALLTHROUGH */
711: case (MDOC_BLOCK):
712: /* FALLTHROUGH */
713: case (MDOC_ELEM):
714: if (NULL == mdocs[n->tok])
715: break;
716:
717: dbt_init(key, ksz);
1.11 ! kristaps 718: (*mdocs[n->tok])(db, dbn, key, ksz, val, rval, rsz, n);
1.1 kristaps 719:
1.8 kristaps 720: dbt_put(db, dbn, key, val);
721: break;
1.1 kristaps 722: default:
723: break;
724: }
725:
1.11 ! kristaps 726: pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->child);
! 727: pmdoc_node(db, dbn, key, ksz, val, rval, rsz, n->next);
1.1 kristaps 728: }
1.6 kristaps 729:
730: static int
731: pman_node(MAN_ARGS)
732: {
733: const struct man_node *head, *body;
1.8 kristaps 734: const char *start;
1.10 kristaps 735: const char nil = '\0';
1.8 kristaps 736: size_t sz;
1.6 kristaps 737: uint32_t fl;
738:
739: if (NULL == n)
740: return(0);
741:
742: /*
743: * We're only searching for one thing: the first text child in
744: * the BODY of a NAME section. Since we don't keep track of
745: * sections in -man, run some hoops to find out whether we're in
746: * the correct section or not.
747: */
748:
749: if (MAN_BODY == n->type && MAN_SH == n->tok) {
750: body = n;
751: assert(body->parent);
752: if (NULL != (head = body->parent->head) &&
753: 1 == head->nchild &&
754: NULL != (head = (head->child)) &&
755: MAN_TEXT == head->type &&
756: 0 == strcmp(head->string, "NAME") &&
757: NULL != (body = body->child) &&
758: MAN_TEXT == body->type) {
759:
1.8 kristaps 760: fl = MANDOC_NAME;
761: memcpy(val->data, &fl, 4);
762:
1.6 kristaps 763: start = body->string;
764:
1.8 kristaps 765: /*
766: * Go through a special heuristic dance here.
767: * This is why -man manuals are great!
768: * Conventionally, one or more manual names are
769: * comma-specified prior to a whitespace, then a
770: * dash, then a description. Try to puzzle out
771: * the name parts here.
772: */
773:
774: while (start) {
775: sz = strcspn(start, " ,");
776: if ('\0' == start[(int)sz])
777: break;
778:
779: dbt_init(key, ksz);
780: dbt_appendb(key, ksz, start, sz);
781: dbt_appendb(key, ksz, &nil, 1);
782:
783: dbt_put(db, dbn, key, val);
784:
785: if (' ' == start[(int)sz])
786: break;
787:
788: assert(',' == start[(int)sz]);
789: start += (int)sz + 1;
790: while (' ' == *start)
791: start++;
792: }
793:
1.6 kristaps 794: return(1);
795: }
796: }
797:
1.11 ! kristaps 798: if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->child))
1.6 kristaps 799: return(1);
1.11 ! kristaps 800: if (pman_node(db, dbn, key, ksz, val, rval, rsz, n->next))
1.6 kristaps 801: return(1);
802:
803: return(0);
804: }
805:
806: static void
1.11 ! kristaps 807: pman(DB *db, const char *dbn, DBT *key, size_t *ksz,
! 808: DBT *val, DBT *rval, size_t *rsz, struct man *m)
1.6 kristaps 809: {
810:
1.11 ! kristaps 811: pman_node(db, dbn, key, ksz, val, rval, rsz, man_node(m));
1.6 kristaps 812: }
813:
1.1 kristaps 814:
815: static void
1.11 ! kristaps 816: pmdoc(DB *db, const char *dbn, DBT *key, size_t *ksz,
! 817: DBT *val, DBT *rval, size_t *rsz, struct mdoc *m)
1.1 kristaps 818: {
819:
1.11 ! kristaps 820: pmdoc_node(db, dbn, key, ksz, val, rval, rsz, mdoc_node(m));
1.1 kristaps 821: }
822:
823: static void
824: usage(void)
825: {
826:
827: fprintf(stderr, "usage: %s "
1.2 kristaps 828: "[-d path] "
1.1 kristaps 829: "[file...]\n",
830: progname);
831: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mandoc-db.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc