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