Annotation of mandoc/roff.c, Revision 1.54
1.54 ! kristaps 1: /* $Id: roff.c,v 1.53 2008/12/08 20:32:49 kristaps Exp $ */
1.1 kristaps 2: /*
3: * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
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
7: * above copyright notice and this permission notice appear in all
8: * copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11: * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12: * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13: * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14: * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15: * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16: * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17: * PERFORMANCE OF THIS SOFTWARE.
18: */
1.30 kristaps 19: #include <sys/param.h>
1.33 kristaps 20: #include <sys/types.h>
1.30 kristaps 21:
1.1 kristaps 22: #include <assert.h>
23: #include <ctype.h>
24: #include <err.h>
1.12 kristaps 25: #include <stdarg.h>
1.1 kristaps 26: #include <stdlib.h>
27: #include <stdio.h>
28: #include <string.h>
29: #include <time.h>
30:
31: #include "libmdocml.h"
32: #include "private.h"
1.43 kristaps 33: #include "roff.h"
1.1 kristaps 34:
1.33 kristaps 35: /* FIXME: First letters of quoted-text interpreted in rofffindtok. */
36: /* FIXME: `No' not implemented. */
1.27 kristaps 37: /* TODO: warn if Pp occurs before/after Sh etc. (see mdoc.samples). */
38: /* TODO: warn about empty lists. */
39: /* TODO: (warn) some sections need specific elements. */
40: /* TODO: (warn) NAME section has particular order. */
41: /* TODO: unify empty-content tags a la <br />. */
42: /* TODO: macros with a set number of arguments? */
1.36 kristaps 43: /* TODO: validate Dt macro arguments. */
1.43 kristaps 44: /* FIXME: Bl -diag supposed to ignore callable children. */
45: /* FIXME: Nm has newline when used in NAME section. */
1.1 kristaps 46:
47: struct roffnode {
1.5 kristaps 48: int tok; /* Token id. */
49: struct roffnode *parent; /* Parent (or NULL). */
1.1 kristaps 50: };
51:
52: struct rofftree {
1.5 kristaps 53: struct roffnode *last; /* Last parsed node. */
1.32 kristaps 54: char *cur; /* Line start. */
1.30 kristaps 55: struct tm tm; /* `Dd' results. */
1.42 kristaps 56: char name[64]; /* `Nm' results. */
1.5 kristaps 57: char os[64]; /* `Os' results. */
58: char title[64]; /* `Dt' results. */
1.51 kristaps 59: enum roffmsec section;
1.5 kristaps 60: char volume[64]; /* `Dt' results. */
1.1 kristaps 61: int state;
1.5 kristaps 62: #define ROFF_PRELUDE (1 << 1) /* In roff prelude. */
63: #define ROFF_PRELUDE_Os (1 << 2) /* `Os' is parsed. */
64: #define ROFF_PRELUDE_Dt (1 << 3) /* `Dt' is parsed. */
65: #define ROFF_PRELUDE_Dd (1 << 4) /* `Dd' is parsed. */
66: #define ROFF_BODY (1 << 5) /* In roff body. */
1.32 kristaps 67: struct roffcb cb; /* Callbacks. */
68: void *arg; /* Callbacks' arg. */
1.52 kristaps 69: int csec; /* Current section. */
70: int asec; /* Thus-far sections. */
1.1 kristaps 71: };
72:
1.4 kristaps 73: static struct roffnode *roffnode_new(int, struct rofftree *);
1.15 kristaps 74: static void roffnode_free(struct rofftree *);
1.12 kristaps 75: static void roff_warn(const struct rofftree *,
76: const char *, char *, ...);
77: static void roff_err(const struct rofftree *,
78: const char *, char *, ...);
1.31 kristaps 79: static int roffpurgepunct(struct rofftree *, char **);
1.7 kristaps 80: static int roffscan(int, const int *);
1.1 kristaps 81: static int rofffindtok(const char *);
82: static int rofffindarg(const char *);
1.2 kristaps 83: static int rofffindcallable(const char *);
1.51 kristaps 84: static int roffismsec(const char *);
1.52 kristaps 85: static int roffissec(const char **);
1.51 kristaps 86: static int roffispunct(const char *);
1.53 kristaps 87: static int roffisatt(const char *);
1.52 kristaps 88: static int roffchecksec(struct rofftree *,
89: const char *, int);
1.10 kristaps 90: static int roffargs(const struct rofftree *,
91: int, char *, char **);
1.5 kristaps 92: static int roffargok(int, int);
1.12 kristaps 93: static int roffnextopt(const struct rofftree *,
1.18 kristaps 94: int, char ***, char **);
1.27 kristaps 95: static int roffparseopts(struct rofftree *, int,
96: char ***, int *, char **);
1.33 kristaps 97: static int roffcall(struct rofftree *, int, char **);
1.51 kristaps 98: static int roffexit(struct rofftree *, int);
1.17 kristaps 99: static int roffparse(struct rofftree *, char *);
1.37 kristaps 100: static int textparse(struct rofftree *, char *);
101: static int roffdata(struct rofftree *, int, char *);
1.44 kristaps 102: static int roffspecial(struct rofftree *, int,
1.47 kristaps 103: const char *, const int *,
104: const char **, size_t, char **);
1.42 kristaps 105: static int roffsetname(struct rofftree *, char **);
1.1 kristaps 106:
1.35 kristaps 107: #ifdef __linux__
108: extern size_t strlcat(char *, const char *, size_t);
109: extern size_t strlcpy(char *, const char *, size_t);
1.33 kristaps 110: extern int vsnprintf(char *, size_t,
111: const char *, va_list);
112: extern char *strptime(const char *, const char *,
113: struct tm *);
114: #endif
115:
1.1 kristaps 116: int
117: roff_free(struct rofftree *tree, int flush)
118: {
1.16 kristaps 119: int error, t;
1.15 kristaps 120: struct roffnode *n;
1.1 kristaps 121:
1.17 kristaps 122: error = 0;
123:
1.16 kristaps 124: if ( ! flush)
125: goto end;
1.1 kristaps 126:
1.16 kristaps 127: error = 1;
1.1 kristaps 128:
1.16 kristaps 129: if (ROFF_PRELUDE & tree->state) {
1.54 ! kristaps 130: (void)roff_err(tree, NULL, "prelude never finished");
1.16 kristaps 131: goto end;
1.52 kristaps 132: } else if ( ! (ROFFSec_NAME & tree->asec)) {
1.54 ! kristaps 133: (void)roff_err(tree, NULL, "missing `NAME' section");
1.52 kristaps 134: goto end;
135: } else if ( ! (ROFFSec_NMASK & tree->asec))
136: roff_warn(tree, NULL, "missing suggested `NAME', "
137: "`SYNOPSIS', `DESCRIPTION' sections");
1.16 kristaps 138:
1.28 kristaps 139: for (n = tree->last; n; n = n->parent) {
1.16 kristaps 140: if (0 != tokens[n->tok].ctx)
1.17 kristaps 141: continue;
1.54 ! kristaps 142: (void)roff_err(tree, NULL, "closing explicit scope "
! 143: "`%s'", toknames[n->tok]);
1.16 kristaps 144: goto end;
145: }
146:
147: while (tree->last) {
148: t = tree->last->tok;
1.51 kristaps 149: if ( ! roffexit(tree, t))
1.16 kristaps 150: goto end;
1.1 kristaps 151: }
152:
1.30 kristaps 153: if ( ! (*tree->cb.rofftail)(tree->arg))
154: goto end;
155:
1.16 kristaps 156: error = 0;
157:
158: end:
159:
1.15 kristaps 160: while (tree->last)
161: roffnode_free(tree);
162:
1.1 kristaps 163: free(tree);
1.17 kristaps 164:
1.1 kristaps 165: return(error ? 0 : 1);
166: }
167:
168:
169: struct rofftree *
1.15 kristaps 170: roff_alloc(const struct roffcb *cb, void *args)
1.1 kristaps 171: {
172: struct rofftree *tree;
173:
1.17 kristaps 174: assert(args);
175: assert(cb);
176:
1.12 kristaps 177: if (NULL == (tree = calloc(1, sizeof(struct rofftree))))
178: err(1, "calloc");
1.1 kristaps 179:
180: tree->state = ROFF_PRELUDE;
1.15 kristaps 181: tree->arg = args;
1.51 kristaps 182: tree->section = ROFF_MSEC_MAX;
1.15 kristaps 183:
184: (void)memcpy(&tree->cb, cb, sizeof(struct roffcb));
1.1 kristaps 185:
186: return(tree);
187: }
188:
189:
190: int
1.17 kristaps 191: roff_engine(struct rofftree *tree, char *buf)
1.1 kristaps 192: {
193:
1.17 kristaps 194: tree->cur = buf;
195: assert(buf);
1.12 kristaps 196:
1.54 ! kristaps 197: if (0 == *buf)
! 198: return(roff_err(tree, buf, "blank line"));
! 199: else if ('.' != *buf)
1.17 kristaps 200: return(textparse(tree, buf));
1.1 kristaps 201:
1.17 kristaps 202: return(roffparse(tree, buf));
1.1 kristaps 203: }
204:
205:
206: static int
1.37 kristaps 207: textparse(struct rofftree *tree, char *buf)
1.1 kristaps 208: {
1.37 kristaps 209: char *bufp;
210:
211: /* TODO: literal parsing. */
1.17 kristaps 212:
1.54 ! kristaps 213: if ( ! (ROFF_BODY & tree->state))
! 214: return(roff_err(tree, buf, "data not in body"));
1.37 kristaps 215:
216: /* LINTED */
217: while (*buf) {
218: while (*buf && isspace(*buf))
219: buf++;
220:
221: if (0 == *buf)
222: break;
223:
224: bufp = buf++;
225:
226: while (*buf && ! isspace(*buf))
227: buf++;
228:
229: if (0 != *buf) {
230: *buf++ = 0;
231: if ( ! roffdata(tree, 1, bufp))
232: return(0);
233: continue;
234: }
235:
236: if ( ! roffdata(tree, 1, bufp))
237: return(0);
238: break;
239: }
240:
241: return(1);
1.1 kristaps 242: }
243:
244:
245: static int
1.10 kristaps 246: roffargs(const struct rofftree *tree,
247: int tok, char *buf, char **argv)
1.1 kristaps 248: {
249: int i;
1.12 kristaps 250: char *p;
1.1 kristaps 251:
252: assert(tok >= 0 && tok < ROFF_MAX);
253: assert('.' == *buf);
254:
1.12 kristaps 255: p = buf;
256:
1.40 kristaps 257: /*
258: * This is an ugly little loop. It parses a line into
259: * space-delimited tokens. If a quote mark is encountered, a
260: * token is alloted the entire quoted text. If whitespace is
261: * escaped, it's included in the prior alloted token.
262: */
263:
1.1 kristaps 264: /* LINTED */
1.37 kristaps 265: for (i = 0; *buf && i < ROFF_MAXLINEARG; i++) {
1.10 kristaps 266: if ('\"' == *buf) {
267: argv[i] = ++buf;
268: while (*buf && '\"' != *buf)
269: buf++;
1.54 ! kristaps 270: if (0 == *buf)
! 271: return(roff_err(tree, argv[i],
! 272: "unclosed quote in arg list"));
1.10 kristaps 273: } else {
274: argv[i] = buf++;
1.40 kristaps 275: while (*buf) {
276: if ( ! isspace(*buf)) {
277: buf++;
278: continue;
279: }
280: if (*(buf - 1) == '\\') {
281: buf++;
282: continue;
283: }
284: break;
285: }
1.10 kristaps 286: if (0 == *buf)
287: continue;
1.1 kristaps 288: }
289: *buf++ = 0;
290: while (*buf && isspace(*buf))
291: buf++;
292: }
1.40 kristaps 293:
1.1 kristaps 294: assert(i > 0);
1.54 ! kristaps 295: if (ROFF_MAXLINEARG == i && *buf)
! 296: return(roff_err(tree, p, "too many args"));
1.10 kristaps 297:
298: argv[i] = NULL;
299: return(1);
1.1 kristaps 300: }
301:
302:
1.6 kristaps 303: static int
304: roffscan(int tok, const int *tokv)
305: {
1.7 kristaps 306:
1.6 kristaps 307: if (NULL == tokv)
308: return(1);
309:
1.7 kristaps 310: for ( ; ROFF_MAX != *tokv; tokv++)
1.6 kristaps 311: if (tok == *tokv)
312: return(1);
313:
314: return(0);
315: }
316:
317:
1.1 kristaps 318: static int
1.17 kristaps 319: roffparse(struct rofftree *tree, char *buf)
1.1 kristaps 320: {
321: int tok, t;
1.6 kristaps 322: struct roffnode *n;
1.37 kristaps 323: char *argv[ROFF_MAXLINEARG];
1.18 kristaps 324: char **argvp;
1.1 kristaps 325:
1.25 kristaps 326: if (0 != *buf && 0 != *(buf + 1) && 0 != *(buf + 2))
327: if (0 == strncmp(buf, ".\\\"", 3))
328: return(1);
329:
1.54 ! kristaps 330: if (ROFF_MAX == (tok = rofffindtok(buf + 1)))
! 331: return(roff_err(tree, buf, "bogus line macro"));
! 332: else if ( ! roffargs(tree, tok, buf, argv))
1.1 kristaps 333: return(0);
1.12 kristaps 334:
1.18 kristaps 335: argvp = (char **)argv;
1.6 kristaps 336:
337: /*
1.12 kristaps 338: * Prelude macros break some assumptions, so branch now.
1.6 kristaps 339: */
1.1 kristaps 340:
1.6 kristaps 341: if (ROFF_PRELUDE & tree->state) {
342: assert(NULL == tree->last);
1.51 kristaps 343: return(roffcall(tree, tok, argvp));
1.28 kristaps 344: }
1.6 kristaps 345:
346: assert(ROFF_BODY & tree->state);
347:
348: /*
349: * First check that our possible parents and parent's possible
350: * children are satisfied.
351: */
352:
1.28 kristaps 353: if (tree->last && ! roffscan
1.54 ! kristaps 354: (tree->last->tok, tokens[tok].parents))
! 355: return(roff_err(tree, *argvp, "`%s' has invalid "
! 356: "parent `%s'", toknames[tok],
! 357: toknames[tree->last->tok]));
1.6 kristaps 358:
1.28 kristaps 359: if (tree->last && ! roffscan
1.54 ! kristaps 360: (tok, tokens[tree->last->tok].children))
! 361: return(roff_err(tree, *argvp, "`%s' has invalid "
! 362: "child `%s'", toknames[tok],
! 363: toknames[tree->last->tok]));
1.1 kristaps 364:
365: /*
1.6 kristaps 366: * Branch if we're not a layout token.
1.1 kristaps 367: */
368:
1.6 kristaps 369: if (ROFF_LAYOUT != tokens[tok].type)
1.51 kristaps 370: return(roffcall(tree, tok, argvp));
1.6 kristaps 371: if (0 == tokens[tok].ctx)
1.51 kristaps 372: return(roffcall(tree, tok, argvp));
1.1 kristaps 373:
1.12 kristaps 374: /*
375: * First consider implicit-end tags, like as follows:
376: * .Sh SECTION 1
377: * .Sh SECTION 2
378: * In this, we want to close the scope of the NAME section. If
379: * there's an intermediary implicit-end tag, such as
380: * .Sh SECTION 1
381: * .Ss Subsection 1
382: * .Sh SECTION 2
383: * then it must be closed as well.
384: */
385:
1.6 kristaps 386: if (tok == tokens[tok].ctx) {
1.12 kristaps 387: /*
388: * First search up to the point where we must close.
389: * If one doesn't exist, then we can open a new scope.
390: */
391:
1.6 kristaps 392: for (n = tree->last; n; n = n->parent) {
393: assert(0 == tokens[n->tok].ctx ||
394: n->tok == tokens[n->tok].ctx);
395: if (n->tok == tok)
396: break;
1.10 kristaps 397: if (ROFF_SHALLOW & tokens[tok].flags) {
398: n = NULL;
399: break;
400: }
1.28 kristaps 401: if (tokens[n->tok].ctx == n->tok)
402: continue;
1.54 ! kristaps 403: return(roff_err(tree, *argv, "`%s' breaks "
! 404: "scope of prior`%s'",
! 405: toknames[tok],
! 406: toknames[n->tok]));
1.6 kristaps 407: }
1.10 kristaps 408:
409: /*
410: * Create a new scope, as no previous one exists to
411: * close out.
412: */
1.12 kristaps 413:
414: if (NULL == n)
1.51 kristaps 415: return(roffcall(tree, tok, argvp));
1.10 kristaps 416:
417: /*
1.12 kristaps 418: * Close out all intermediary scoped blocks, then hang
419: * the current scope from our predecessor's parent.
1.10 kristaps 420: */
421:
1.1 kristaps 422: do {
423: t = tree->last->tok;
1.51 kristaps 424: if ( ! roffexit(tree, t))
1.1 kristaps 425: return(0);
426: } while (t != tok);
1.6 kristaps 427:
1.51 kristaps 428: return(roffcall(tree, tok, argvp));
1.1 kristaps 429: }
430:
1.12 kristaps 431: /*
432: * Now consider explicit-end tags, where we want to close back
433: * to a specific tag. Example:
434: * .Bl
435: * .It Item.
436: * .El
437: * In this, the `El' tag closes out the scope of `Bl'.
438: */
439:
1.6 kristaps 440: assert(tok != tokens[tok].ctx && 0 != tokens[tok].ctx);
441:
1.32 kristaps 442: /* LINTED */
1.28 kristaps 443: for (n = tree->last; n; n = n->parent)
444: if (n->tok != tokens[tok].ctx) {
445: if (n->tok == tokens[n->tok].ctx)
446: continue;
1.54 ! kristaps 447: return(roff_err(tree, *argv, "`%s' breaks "
! 448: "scope of prior `%s'",
! 449: toknames[tok],
! 450: toknames[n->tok]));
1.28 kristaps 451: } else
452: break;
453:
1.54 ! kristaps 454: if (NULL == n)
! 455: return(roff_err(tree, *argv, "`%s' has no starting "
! 456: "tag `%s'", toknames[tok],
! 457: toknames[tokens[tok].ctx]));
1.28 kristaps 458:
1.14 kristaps 459: /* LINTED */
1.6 kristaps 460: do {
461: t = tree->last->tok;
1.51 kristaps 462: if ( ! roffexit(tree, t))
1.6 kristaps 463: return(0);
464: } while (t != tokens[tok].ctx);
1.1 kristaps 465:
1.9 kristaps 466: return(1);
1.1 kristaps 467: }
468:
469:
470: static int
471: rofffindarg(const char *name)
472: {
473: size_t i;
474:
475: /* FIXME: use a table, this is slow but ok for now. */
476:
477: /* LINTED */
478: for (i = 0; i < ROFF_ARGMAX; i++)
479: /* LINTED */
1.4 kristaps 480: if (0 == strcmp(name, tokargnames[i]))
1.1 kristaps 481: return((int)i);
482:
483: return(ROFF_ARGMAX);
484: }
485:
486:
487: static int
1.6 kristaps 488: rofffindtok(const char *buf)
1.1 kristaps 489: {
1.6 kristaps 490: char token[4];
1.23 kristaps 491: int i;
1.1 kristaps 492:
1.6 kristaps 493: for (i = 0; *buf && ! isspace(*buf) && i < 3; i++, buf++)
494: token[i] = *buf;
495:
1.9 kristaps 496: if (i == 3)
1.6 kristaps 497: return(ROFF_MAX);
498:
499: token[i] = 0;
500:
1.1 kristaps 501: /* FIXME: use a table, this is slow but ok for now. */
502:
503: /* LINTED */
504: for (i = 0; i < ROFF_MAX; i++)
505: /* LINTED */
1.12 kristaps 506: if (0 == strcmp(toknames[i], token))
1.1 kristaps 507: return((int)i);
1.7 kristaps 508:
1.1 kristaps 509: return(ROFF_MAX);
510: }
511:
512:
1.20 kristaps 513: static int
1.52 kristaps 514: roffchecksec(struct rofftree *tree, const char *start, int sec)
515: {
516: int prior;
517:
518: switch (sec) {
519: case(ROFFSec_SYNOP):
520: if ((prior = ROFFSec_NAME) & tree->asec)
521: return(1);
522: break;
523: case(ROFFSec_DESC):
524: if ((prior = ROFFSec_SYNOP) & tree->asec)
525: return(1);
526: break;
527: case(ROFFSec_RETVAL):
528: if ((prior = ROFFSec_DESC) & tree->asec)
529: return(1);
530: break;
531: case(ROFFSec_ENV):
532: if ((prior = ROFFSec_RETVAL) & tree->asec)
533: return(1);
534: break;
535: case(ROFFSec_FILES):
536: if ((prior = ROFFSec_ENV) & tree->asec)
537: return(1);
538: break;
539: case(ROFFSec_EX):
540: if ((prior = ROFFSec_FILES) & tree->asec)
541: return(1);
542: break;
543: case(ROFFSec_DIAG):
544: if ((prior = ROFFSec_EX) & tree->asec)
545: return(1);
546: break;
547: case(ROFFSec_ERRS):
548: if ((prior = ROFFSec_DIAG) & tree->asec)
549: return(1);
550: break;
551: case(ROFFSec_SEEALSO):
552: if ((prior = ROFFSec_ERRS) & tree->asec)
553: return(1);
554: break;
555: case(ROFFSec_STAND):
556: if ((prior = ROFFSec_SEEALSO) & tree->asec)
557: return(1);
558: break;
559: case(ROFFSec_HIST):
560: if ((prior = ROFFSec_STAND) & tree->asec)
561: return(1);
562: break;
563: case(ROFFSec_AUTH):
564: if ((prior = ROFFSec_HIST) & tree->asec)
565: return(1);
566: break;
567: case(ROFFSec_CAVEATS):
568: if ((prior = ROFFSec_AUTH) & tree->asec)
569: return(1);
570: break;
571: case(ROFFSec_BUGS):
572: if ((prior = ROFFSec_CAVEATS) & tree->asec)
573: return(1);
574: break;
575: default:
576: return(1);
577: }
578:
579: roff_warn(tree, start, "section violates conventional order");
580: return(1);
581: }
582:
583:
1.54 ! kristaps 584: /* FIXME: move this into literals.c. */
1.52 kristaps 585: static int
586: roffissec(const char **p)
587: {
588:
589: assert(*p);
590: if (NULL != *(p + 1)) {
591: if (NULL != *(p + 2))
592: return(ROFFSec_OTHER);
593: if (0 == strcmp(*p, "RETURN") &&
594: 0 == strcmp(*(p + 1), "VALUES"))
595: return(ROFFSec_RETVAL);
596: if (0 == strcmp(*p, "SEE") &&
597: 0 == strcmp(*(p + 1), "ALSO"))
598: return(ROFFSec_SEEALSO);
599: return(ROFFSec_OTHER);
600: }
601:
602: if (0 == strcmp(*p, "NAME"))
603: return(ROFFSec_NAME);
604: else if (0 == strcmp(*p, "SYNOPSIS"))
605: return(ROFFSec_SYNOP);
606: else if (0 == strcmp(*p, "DESCRIPTION"))
607: return(ROFFSec_DESC);
608: else if (0 == strcmp(*p, "ENVIRONMENT"))
609: return(ROFFSec_ENV);
610: else if (0 == strcmp(*p, "FILES"))
611: return(ROFFSec_FILES);
612: else if (0 == strcmp(*p, "EXAMPLES"))
613: return(ROFFSec_EX);
614: else if (0 == strcmp(*p, "DIAGNOSTICS"))
615: return(ROFFSec_DIAG);
616: else if (0 == strcmp(*p, "ERRORS"))
617: return(ROFFSec_ERRS);
618: else if (0 == strcmp(*p, "STANDARDS"))
619: return(ROFFSec_STAND);
620: else if (0 == strcmp(*p, "HISTORY"))
621: return(ROFFSec_HIST);
622: else if (0 == strcmp(*p, "AUTHORS"))
623: return(ROFFSec_AUTH);
624: else if (0 == strcmp(*p, "CAVEATS"))
625: return(ROFFSec_CAVEATS);
626: else if (0 == strcmp(*p, "BUGS"))
627: return(ROFFSec_BUGS);
628:
629: return(ROFFSec_OTHER);
630: }
631:
632:
1.54 ! kristaps 633: /* FIXME: move this into literals.c. */
1.52 kristaps 634: static int
1.51 kristaps 635: roffismsec(const char *p)
636: {
637:
638: if (0 == strcmp(p, "1"))
639: return(ROFF_MSEC_1);
640: else if (0 == strcmp(p, "2"))
641: return(ROFF_MSEC_2);
642: else if (0 == strcmp(p, "3"))
643: return(ROFF_MSEC_3);
644: else if (0 == strcmp(p, "3p"))
645: return(ROFF_MSEC_3p);
646: else if (0 == strcmp(p, "4"))
647: return(ROFF_MSEC_4);
648: else if (0 == strcmp(p, "5"))
649: return(ROFF_MSEC_5);
650: else if (0 == strcmp(p, "6"))
651: return(ROFF_MSEC_6);
652: else if (0 == strcmp(p, "7"))
653: return(ROFF_MSEC_7);
654: else if (0 == strcmp(p, "8"))
655: return(ROFF_MSEC_8);
656: else if (0 == strcmp(p, "9"))
657: return(ROFF_MSEC_9);
658: else if (0 == strcmp(p, "unass"))
659: return(ROFF_MSEC_UNASS);
660: else if (0 == strcmp(p, "draft"))
661: return(ROFF_MSEC_DRAFT);
662: else if (0 == strcmp(p, "paper"))
663: return(ROFF_MSEC_PAPER);
664:
665: return(ROFF_MSEC_MAX);
666: }
667:
668:
1.54 ! kristaps 669: /* FIXME: move this into literals.c. */
1.51 kristaps 670: static int
1.53 kristaps 671: roffisatt(const char *p)
672: {
673:
674: assert(p);
675: if (0 == strcmp(p, "v1"))
676: return(1);
677: else if (0 == strcmp(p, "v2"))
678: return(1);
679: else if (0 == strcmp(p, "v3"))
680: return(1);
681: else if (0 == strcmp(p, "v6"))
682: return(1);
683: else if (0 == strcmp(p, "v7"))
684: return(1);
685: else if (0 == strcmp(p, "32v"))
686: return(1);
687: else if (0 == strcmp(p, "V.1"))
688: return(1);
689: else if (0 == strcmp(p, "V.4"))
690: return(1);
691:
692: return(0);
693: }
694:
695:
1.54 ! kristaps 696: /* FIXME: move this into literals.c (or similar). */
1.53 kristaps 697: static int
1.20 kristaps 698: roffispunct(const char *p)
699: {
700:
701: if (0 == *p)
702: return(0);
703: if (0 != *(p + 1))
704: return(0);
705:
706: switch (*p) {
707: case('{'):
708: /* FALLTHROUGH */
709: case('.'):
710: /* FALLTHROUGH */
711: case(','):
712: /* FALLTHROUGH */
713: case(';'):
714: /* FALLTHROUGH */
715: case(':'):
716: /* FALLTHROUGH */
717: case('?'):
718: /* FALLTHROUGH */
719: case('!'):
720: /* FALLTHROUGH */
721: case('('):
722: /* FALLTHROUGH */
723: case(')'):
724: /* FALLTHROUGH */
725: case('['):
726: /* FALLTHROUGH */
727: case(']'):
728: /* FALLTHROUGH */
729: case('}'):
730: return(1);
731: default:
732: break;
733: }
734:
735: return(0);
736: }
737:
738:
1.2 kristaps 739: static int
740: rofffindcallable(const char *name)
741: {
742: int c;
743:
744: if (ROFF_MAX == (c = rofffindtok(name)))
745: return(ROFF_MAX);
1.8 kristaps 746: assert(c >= 0 && c < ROFF_MAX);
1.2 kristaps 747: return(ROFF_CALLABLE & tokens[c].flags ? c : ROFF_MAX);
748: }
749:
750:
1.1 kristaps 751: static struct roffnode *
1.4 kristaps 752: roffnode_new(int tokid, struct rofftree *tree)
1.1 kristaps 753: {
754: struct roffnode *p;
755:
1.12 kristaps 756: if (NULL == (p = malloc(sizeof(struct roffnode))))
757: err(1, "malloc");
1.1 kristaps 758:
759: p->tok = tokid;
760: p->parent = tree->last;
761: tree->last = p;
1.9 kristaps 762:
1.1 kristaps 763: return(p);
764: }
765:
766:
1.5 kristaps 767: static int
768: roffargok(int tokid, int argid)
769: {
770: const int *c;
771:
772: if (NULL == (c = tokens[tokid].args))
773: return(0);
774:
775: for ( ; ROFF_ARGMAX != *c; c++)
776: if (argid == *c)
777: return(1);
778:
779: return(0);
780: }
781:
782:
1.1 kristaps 783: static void
1.15 kristaps 784: roffnode_free(struct rofftree *tree)
1.1 kristaps 785: {
786: struct roffnode *p;
787:
788: assert(tree->last);
789:
790: p = tree->last;
791: tree->last = tree->last->parent;
792: free(p);
793: }
794:
795:
1.6 kristaps 796: static int
1.47 kristaps 797: roffspecial(struct rofftree *tree, int tok, const char *start,
798: const int *argc, const char **argv,
799: size_t sz, char **ordp)
1.40 kristaps 800: {
801:
1.44 kristaps 802: switch (tok) {
1.46 kristaps 803: case (ROFF_At):
804: if (0 == sz)
805: break;
1.53 kristaps 806: if (roffisatt(*ordp))
1.46 kristaps 807: break;
1.54 ! kristaps 808: return(roff_err(tree, *ordp, "invalid `At' arg"));
1.49 kristaps 809:
1.50 kristaps 810: case (ROFF_Xr):
1.51 kristaps 811: if (2 == sz) {
812: assert(ordp[1]);
813: if (ROFF_MSEC_MAX != roffismsec(ordp[1]))
814: break;
815: roff_warn(tree, start, "invalid `%s' manual "
816: "section", toknames[tok]);
817: }
1.50 kristaps 818: /* FALLTHROUGH */
1.51 kristaps 819:
1.52 kristaps 820: case (ROFF_Sx):
821: /* FALLTHROUGH*/
1.49 kristaps 822: case (ROFF_Fn):
823: if (0 != sz)
824: break;
1.54 ! kristaps 825: return(roff_err(tree, start, "`%s' expects at least "
! 826: "one arg", toknames[tok]));
1.46 kristaps 827:
1.44 kristaps 828: case (ROFF_Nm):
829: if (0 == sz) {
830: if (0 == tree->name[0]) {
831: roff_err(tree, start, "`Nm' not set");
832: return(0);
833: }
834: ordp[0] = tree->name;
835: ordp[1] = NULL;
836: } else if ( ! roffsetname(tree, ordp))
837: return(0);
838: break;
839:
1.48 kristaps 840: case (ROFF_Rv):
841: /* FALLTHROUGH*/
1.44 kristaps 842: case (ROFF_Ex):
1.48 kristaps 843: if (1 == sz)
844: break;
845: roff_err(tree, start, "`%s' expects one arg",
846: toknames[tok]);
847: return(0);
1.44 kristaps 848:
849: case (ROFF_Sm):
1.46 kristaps 850: if (1 != sz) {
1.44 kristaps 851: roff_err(tree, start, "`Sm' expects one arg");
852: return(0);
853: }
854:
855: if (0 != strcmp(ordp[0], "on") &&
856: 0 != strcmp(ordp[0], "off")) {
857: roff_err(tree, start, "`Sm' has invalid argument");
858: return(0);
859: }
860: break;
1.45 kristaps 861:
862: case (ROFF_Ud):
863: /* FALLTHROUGH */
1.46 kristaps 864: case (ROFF_Ux):
865: /* FALLTHROUGH */
1.45 kristaps 866: case (ROFF_Bt):
867: if (0 != sz) {
868: roff_err(tree, start, "`%s' expects no args",
869: toknames[tok]);
870: return(0);
871: }
872: break;
1.44 kristaps 873: default:
874: break;
875: }
876:
1.50 kristaps 877: return((*tree->cb.roffspecial)(tree->arg, tok, tree->cur,
878: argc, argv, (const char **)ordp));
1.40 kristaps 879: }
880:
881:
882: static int
1.51 kristaps 883: roffexit(struct rofftree *tree, int tok)
884: {
885:
886: assert(tokens[tok].cb);
887: return((*tokens[tok].cb)(tok, tree, NULL, ROFF_EXIT));
888: }
889:
890:
891: static int
1.33 kristaps 892: roffcall(struct rofftree *tree, int tok, char **argv)
893: {
1.51 kristaps 894: int i;
895: enum roffmsec c;
1.33 kristaps 896:
897: if (NULL == tokens[tok].cb) {
1.51 kristaps 898: roff_err(tree, *argv, "`%s' is unsupported",
1.33 kristaps 899: toknames[tok]);
900: return(0);
901: }
1.51 kristaps 902: if (tokens[tok].sections && ROFF_MSEC_MAX != tree->section) {
903: i = 0;
904: while (ROFF_MSEC_MAX !=
905: (c = tokens[tok].sections[i++]))
906: if (c == tree->section)
907: break;
908: if (ROFF_MSEC_MAX == c) {
909: roff_warn(tree, *argv, "`%s' is not a valid "
910: "macro in this manual section",
911: toknames[tok]);
912: }
913: }
914:
915: return((*tokens[tok].cb)(tok, tree, argv, ROFF_ENTER));
1.33 kristaps 916: }
917:
918:
919: static int
1.12 kristaps 920: roffnextopt(const struct rofftree *tree, int tok,
1.18 kristaps 921: char ***in, char **val)
1.6 kristaps 922: {
1.18 kristaps 923: char *arg, **argv;
1.6 kristaps 924: int v;
925:
926: *val = NULL;
927: argv = *in;
928: assert(argv);
929:
930: if (NULL == (arg = *argv))
931: return(-1);
932: if ('-' != *arg)
933: return(-1);
934:
1.12 kristaps 935: if (ROFF_ARGMAX == (v = rofffindarg(arg + 1))) {
936: roff_warn(tree, arg, "argument-like parameter `%s' to "
1.33 kristaps 937: "`%s'", arg, toknames[tok]);
1.6 kristaps 938: return(-1);
1.12 kristaps 939: }
940:
941: if ( ! roffargok(tok, v)) {
942: roff_warn(tree, arg, "invalid argument parameter `%s' to "
943: "`%s'", tokargnames[v], toknames[tok]);
1.6 kristaps 944: return(-1);
1.12 kristaps 945: }
946:
947: if ( ! (ROFF_VALUE & tokenargs[v]))
1.6 kristaps 948: return(v);
949:
950: *in = ++argv;
951:
1.12 kristaps 952: if (NULL == *argv) {
953: roff_err(tree, arg, "empty value of `%s' for `%s'",
954: tokargnames[v], toknames[tok]);
955: return(ROFF_ARGMAX);
956: }
1.6 kristaps 957:
1.12 kristaps 958: return(v);
1.6 kristaps 959: }
960:
961:
1.27 kristaps 962: static int
1.31 kristaps 963: roffpurgepunct(struct rofftree *tree, char **argv)
964: {
965: int i;
966:
967: i = 0;
968: while (argv[i])
969: i++;
970: assert(i > 0);
971: if ( ! roffispunct(argv[--i]))
972: return(1);
973: while (i >= 0 && roffispunct(argv[i]))
974: i--;
975: i++;
976:
977: /* LINTED */
978: while (argv[i])
1.37 kristaps 979: if ( ! roffdata(tree, 0, argv[i++]))
1.31 kristaps 980: return(0);
981: return(1);
982: }
983:
984:
985: static int
1.27 kristaps 986: roffparseopts(struct rofftree *tree, int tok,
987: char ***args, int *argc, char **argv)
988: {
989: int i, c;
990: char *v;
991:
992: i = 0;
993:
994: while (-1 != (c = roffnextopt(tree, tok, args, &v))) {
995: if (ROFF_ARGMAX == c)
996: return(0);
997:
998: argc[i] = c;
999: argv[i] = v;
1000: i++;
1001: *args = *args + 1;
1002: }
1003:
1004: argc[i] = ROFF_ARGMAX;
1005: argv[i] = NULL;
1006: return(1);
1007: }
1008:
1009:
1.37 kristaps 1010: static int
1011: roffdata(struct rofftree *tree, int space, char *buf)
1012: {
1013:
1.38 kristaps 1014: if (0 == *buf)
1015: return(1);
1.37 kristaps 1016: return((*tree->cb.roffdata)(tree->arg,
1017: space != 0, tree->cur, buf));
1018: }
1019:
1020:
1.1 kristaps 1021: /* ARGSUSED */
1022: static int
1023: roff_Dd(ROFFCALL_ARGS)
1024: {
1.30 kristaps 1025: time_t t;
1026: char *p, buf[32];
1.1 kristaps 1027:
1.4 kristaps 1028: if (ROFF_BODY & tree->state) {
1029: assert( ! (ROFF_PRELUDE & tree->state));
1030: assert(ROFF_PRELUDE_Dd & tree->state);
1031: return(roff_text(tok, tree, argv, type));
1032: }
1033:
1.1 kristaps 1034: assert(ROFF_PRELUDE & tree->state);
1.4 kristaps 1035: assert( ! (ROFF_BODY & tree->state));
1036:
1.6 kristaps 1037: if (ROFF_PRELUDE_Dd & tree->state) {
1.12 kristaps 1038: roff_err(tree, *argv, "repeated `Dd' in prelude");
1.6 kristaps 1039: return(0);
1040: } else if (ROFF_PRELUDE_Dt & tree->state) {
1.12 kristaps 1041: roff_err(tree, *argv, "out-of-order `Dd' in prelude");
1.1 kristaps 1042: return(0);
1043: }
1044:
1.30 kristaps 1045: assert(NULL == tree->last);
1046:
1047: argv++;
1048:
1049: if (0 == strcmp(*argv, "$Mdocdate$")) {
1050: t = time(NULL);
1051: if (NULL == localtime_r(&t, &tree->tm))
1052: err(1, "localtime_r");
1053: tree->state |= ROFF_PRELUDE_Dd;
1054: return(1);
1055: }
1056:
1057: /* Build this from Mdocdate or raw date. */
1058:
1059: buf[0] = 0;
1060: p = *argv;
1061:
1062: if (0 != strcmp(*argv, "$Mdocdate:")) {
1063: while (*argv) {
1064: if (strlcat(buf, *argv++, sizeof(buf))
1065: < sizeof(buf))
1066: continue;
1067: roff_err(tree, p, "bad `Dd' date");
1068: return(0);
1069: }
1070: if (strptime(buf, "%b%d,%Y", &tree->tm)) {
1071: tree->state |= ROFF_PRELUDE_Dd;
1072: return(1);
1073: }
1074: roff_err(tree, *argv, "bad `Dd' date");
1075: return(0);
1076: }
1077:
1078: argv++;
1079: while (*argv && **argv != '$') {
1080: if (strlcat(buf, *argv++, sizeof(buf))
1081: >= sizeof(buf)) {
1082: roff_err(tree, p, "bad `Dd' Mdocdate");
1083: return(0);
1084: }
1085: if (strlcat(buf, " ", sizeof(buf))
1086: >= sizeof(buf)) {
1087: roff_err(tree, p, "bad `Dd' Mdocdate");
1088: return(0);
1089: }
1090: }
1091: if (NULL == *argv) {
1092: roff_err(tree, p, "bad `Dd' Mdocdate");
1093: return(0);
1094: }
1095:
1096: if (NULL == strptime(buf, "%b %d %Y", &tree->tm)) {
1097: roff_err(tree, *argv, "bad `Dd' Mdocdate");
1098: return(0);
1099: }
1.4 kristaps 1100:
1.1 kristaps 1101: tree->state |= ROFF_PRELUDE_Dd;
1102: return(1);
1103: }
1104:
1105:
1106: /* ARGSUSED */
1107: static int
1108: roff_Dt(ROFFCALL_ARGS)
1109: {
1110:
1.4 kristaps 1111: if (ROFF_BODY & tree->state) {
1112: assert( ! (ROFF_PRELUDE & tree->state));
1113: assert(ROFF_PRELUDE_Dt & tree->state);
1114: return(roff_text(tok, tree, argv, type));
1115: }
1116:
1.1 kristaps 1117: assert(ROFF_PRELUDE & tree->state);
1.4 kristaps 1118: assert( ! (ROFF_BODY & tree->state));
1119:
1.6 kristaps 1120: if ( ! (ROFF_PRELUDE_Dd & tree->state)) {
1.12 kristaps 1121: roff_err(tree, *argv, "out-of-order `Dt' in prelude");
1.1 kristaps 1122: return(0);
1.6 kristaps 1123: } else if (ROFF_PRELUDE_Dt & tree->state) {
1.12 kristaps 1124: roff_err(tree, *argv, "repeated `Dt' in prelude");
1.6 kristaps 1125: return(0);
1.1 kristaps 1126: }
1127:
1.30 kristaps 1128: argv++;
1129: if (NULL == *argv) {
1130: roff_err(tree, *argv, "`Dt' needs document title");
1131: return(0);
1132: } else if (strlcpy(tree->title, *argv, sizeof(tree->title))
1133: >= sizeof(tree->title)) {
1134: roff_err(tree, *argv, "`Dt' document title too long");
1135: return(0);
1136: }
1137:
1138: argv++;
1139: if (NULL == *argv) {
1140: roff_err(tree, *argv, "`Dt' needs section");
1141: return(0);
1.51 kristaps 1142: }
1143:
1144: if (ROFF_MSEC_MAX == (tree->section = roffismsec(*argv))) {
1145: roff_err(tree, *argv, "bad `Dt' section");
1.30 kristaps 1146: return(0);
1147: }
1148:
1149: argv++;
1150: if (NULL == *argv) {
1151: tree->volume[0] = 0;
1152: } else if (strlcpy(tree->volume, *argv, sizeof(tree->volume))
1153: >= sizeof(tree->volume)) {
1154: roff_err(tree, *argv, "`Dt' volume too long");
1155: return(0);
1156: }
1.4 kristaps 1157:
1.1 kristaps 1158: assert(NULL == tree->last);
1159: tree->state |= ROFF_PRELUDE_Dt;
1160:
1161: return(1);
1162: }
1163:
1164:
1.42 kristaps 1165: static int
1166: roffsetname(struct rofftree *tree, char **ordp)
1167: {
1168:
1169: assert(*ordp);
1170:
1171: /* FIXME: not all sections can set this. */
1172:
1173: if (NULL != *(ordp + 1)) {
1174: roff_err(tree, *ordp, "too many `Nm' args");
1175: return(0);
1176: }
1177:
1178: if (strlcpy(tree->name, *ordp, sizeof(tree->name))
1179: >= sizeof(tree->name)) {
1180: roff_err(tree, *ordp, "`Nm' arg too long");
1181: return(0);
1182: }
1183:
1184: return(1);
1185: }
1186:
1187:
1.1 kristaps 1188: /* ARGSUSED */
1.33 kristaps 1189: static int
1190: roff_Ns(ROFFCALL_ARGS)
1191: {
1192: int j, c, first;
1.40 kristaps 1193: char *morep[1];
1.33 kristaps 1194:
1195: first = (*argv++ == tree->cur);
1.40 kristaps 1196: morep[0] = NULL;
1.33 kristaps 1197:
1.47 kristaps 1198: if ( ! roffspecial(tree, tok, *argv, NULL, NULL, 0, morep))
1.33 kristaps 1199: return(0);
1.31 kristaps 1200:
1.33 kristaps 1201: while (*argv) {
1202: if (ROFF_MAX != (c = rofffindcallable(*argv))) {
1203: if ( ! roffcall(tree, c, argv))
1204: return(0);
1.31 kristaps 1205: break;
1206: }
1.33 kristaps 1207:
1208: if ( ! roffispunct(*argv)) {
1.37 kristaps 1209: if ( ! roffdata(tree, 1, *argv++))
1210: return(0);
1211: continue;
1.31 kristaps 1212: }
1.37 kristaps 1213:
1.33 kristaps 1214: for (j = 0; argv[j]; j++)
1215: if ( ! roffispunct(argv[j]))
1216: break;
1217:
1218: if (argv[j]) {
1.37 kristaps 1219: if ( ! roffdata(tree, 0, *argv++))
1220: return(0);
1221: continue;
1.33 kristaps 1222: }
1223:
1.31 kristaps 1224: break;
1225: }
1226:
1227: if ( ! first)
1228: return(1);
1.33 kristaps 1229:
1.31 kristaps 1230: return(roffpurgepunct(tree, argv));
1231: }
1232:
1233:
1234: /* ARGSUSED */
1235: static int
1.1 kristaps 1236: roff_Os(ROFFCALL_ARGS)
1237: {
1.30 kristaps 1238: char *p;
1.1 kristaps 1239:
1.30 kristaps 1240: if (ROFF_BODY & tree->state) {
1.4 kristaps 1241: assert( ! (ROFF_PRELUDE & tree->state));
1242: assert(ROFF_PRELUDE_Os & tree->state);
1243: return(roff_text(tok, tree, argv, type));
1244: }
1.1 kristaps 1245:
1246: assert(ROFF_PRELUDE & tree->state);
1247: if ( ! (ROFF_PRELUDE_Dt & tree->state) ||
1248: ! (ROFF_PRELUDE_Dd & tree->state)) {
1.12 kristaps 1249: roff_err(tree, *argv, "out-of-order `Os' in prelude");
1.1 kristaps 1250: return(0);
1251: }
1252:
1.30 kristaps 1253: tree->os[0] = 0;
1254:
1255: p = *++argv;
1256:
1257: while (*argv) {
1258: if (strlcat(tree->os, *argv++, sizeof(tree->os))
1259: < sizeof(tree->os))
1260: continue;
1261: roff_err(tree, p, "`Os' value too long");
1262: return(0);
1263: }
1264:
1265: if (0 == tree->os[0])
1266: if (strlcpy(tree->os, "LOCAL", sizeof(tree->os))
1267: >= sizeof(tree->os)) {
1268: roff_err(tree, p, "`Os' value too long");
1269: return(0);
1270: }
1.1 kristaps 1271:
1272: tree->state |= ROFF_PRELUDE_Os;
1273: tree->state &= ~ROFF_PRELUDE;
1274: tree->state |= ROFF_BODY;
1275:
1.51 kristaps 1276: assert(ROFF_MSEC_MAX != tree->section);
1277: assert(0 != tree->title[0]);
1278: assert(0 != tree->os[0]);
1279:
1.4 kristaps 1280: assert(NULL == tree->last);
1281:
1.36 kristaps 1282: return((*tree->cb.roffhead)(tree->arg, &tree->tm,
1283: tree->os, tree->title, tree->section,
1284: tree->volume));
1.1 kristaps 1285: }
1286:
1287:
1288: /* ARGSUSED */
1289: static int
1.2 kristaps 1290: roff_layout(ROFFCALL_ARGS)
1.1 kristaps 1291: {
1.37 kristaps 1292: int i, c, argcp[ROFF_MAXLINEARG];
1.53 kristaps 1293: char *argvp[ROFF_MAXLINEARG], *p;
1.1 kristaps 1294:
1.52 kristaps 1295: /*
1296: * The roff_layout function is for multi-line macros. A layout
1297: * has a start and end point, which is either declared
1298: * explicitly or implicitly. An explicit start and end is
1299: * embodied by `.Bl' and `.El', with the former being the start
1300: * and the latter being an end. The `.Sh' and `.Ss' tags, on
1301: * the other hand, are implicit. The scope of a layout is the
1302: * space between start and end. Explicit layouts may not close
1303: * out implicit ones and vice versa; implicit layouts may close
1304: * out other implicit layouts.
1305: */
1306:
1307: assert( ! (ROFF_CALLABLE & tokens[tok].flags));
1308:
1.4 kristaps 1309: if (ROFF_PRELUDE & tree->state) {
1.27 kristaps 1310: roff_err(tree, *argv, "bad `%s' in prelude",
1.12 kristaps 1311: toknames[tok]);
1.4 kristaps 1312: return(0);
1.27 kristaps 1313: } else if (ROFF_EXIT == type) {
1.15 kristaps 1314: roffnode_free(tree);
1.35 kristaps 1315: if ( ! (*tree->cb.roffblkbodyout)(tree->arg, tok))
1316: return(0);
1.15 kristaps 1317: return((*tree->cb.roffblkout)(tree->arg, tok));
1.2 kristaps 1318: }
1.1 kristaps 1319:
1.27 kristaps 1320: assert( ! (ROFF_CALLABLE & tokens[tok].flags));
1.5 kristaps 1321:
1.53 kristaps 1322: p = *argv++;
1.5 kristaps 1323:
1.27 kristaps 1324: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1325: return(0);
1.4 kristaps 1326: if (NULL == roffnode_new(tok, tree))
1.2 kristaps 1327: return(0);
1328:
1.27 kristaps 1329: /*
1330: * Layouts have two parts: the layout body and header. The
1331: * layout header is the trailing text of the line macro, while
1332: * the layout body is everything following until termination.
1.52 kristaps 1333: * Example:
1334: *
1335: * .It Fl f ) ;
1336: * Bar.
1337: *
1338: * ...Produces...
1339: *
1340: * <block>
1341: * <head>
1342: * <!Fl f!> ;
1343: * </head>
1344: *
1345: * <body>
1346: * Bar.
1347: * </body>
1348: * </block>
1.27 kristaps 1349: */
1350:
1.50 kristaps 1351: if ( ! (*tree->cb.roffblkin)(tree->arg, tok, argcp,
1352: (const char **)argvp))
1.18 kristaps 1353: return(0);
1.52 kristaps 1354:
1355: /* +++ Begin run macro-specific hooks over argv. */
1356:
1357: switch (tok) {
1358: case (ROFF_Sh):
1359: if (NULL == *argv) {
1360: roff_err(tree, *(argv - 1),
1361: "`Sh' expects arguments");
1362: return(0);
1363: }
1364: tree->csec = roffissec((const char **)argv);
1365: if ( ! (ROFFSec_OTHER & tree->csec) &&
1366: tree->asec & tree->csec)
1367: roff_warn(tree, *argv, "section repeated");
1368: if (0 == tree->asec && ! (ROFFSec_NAME & tree->csec)) {
1369: roff_err(tree, *argv, "`NAME' section "
1370: "must be first");
1371: return(0);
1372: } else if ( ! roffchecksec(tree, *argv, tree->csec))
1373: return(0);
1374:
1375: tree->asec |= tree->csec;
1376: break;
1377: default:
1378: break;
1379: }
1380:
1381: /* --- End run macro-specific hooks over argv. */
1382:
1.18 kristaps 1383: if (NULL == *argv)
1.35 kristaps 1384: return((*tree->cb.roffblkbodyin)
1.50 kristaps 1385: (tree->arg, tok, argcp,
1386: (const char **)argvp));
1.35 kristaps 1387:
1.50 kristaps 1388: if ( ! (*tree->cb.roffblkheadin)(tree->arg, tok, argcp,
1389: (const char **)argvp))
1.2 kristaps 1390: return(0);
1391:
1.27 kristaps 1392: /*
1393: * If there are no parsable parts, then write remaining tokens
1394: * into the layout header and exit.
1395: */
1396:
1.2 kristaps 1397: if ( ! (ROFF_PARSED & tokens[tok].flags)) {
1.21 kristaps 1398: i = 0;
1.37 kristaps 1399: while (*argv)
1400: if ( ! roffdata(tree, i++, *argv++))
1.14 kristaps 1401: return(0);
1.37 kristaps 1402:
1.35 kristaps 1403: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1404: return(0);
1.52 kristaps 1405: return((*tree->cb.roffblkbodyin)(tree->arg, tok, argcp,
1.50 kristaps 1406: (const char **)argvp));
1.2 kristaps 1407: }
1408:
1.27 kristaps 1409: /*
1410: * Parsable elements may be in the header (or be the header, for
1411: * that matter). Follow the regular parsing rules for these.
1412: */
1413:
1.21 kristaps 1414: i = 0;
1.1 kristaps 1415: while (*argv) {
1.26 kristaps 1416: if (ROFF_MAX == (c = rofffindcallable(*argv))) {
1417: assert(tree->arg);
1.37 kristaps 1418: if ( ! roffdata(tree, i++, *argv++))
1.8 kristaps 1419: return(0);
1.26 kristaps 1420: continue;
1421: }
1.33 kristaps 1422: if ( ! roffcall(tree, c, argv))
1.14 kristaps 1423: return(0);
1.26 kristaps 1424: break;
1.21 kristaps 1425: }
1426:
1427: /*
1.27 kristaps 1428: * If there's trailing punctuation in the header, then write it
1429: * out now. Here we mimic the behaviour of a line-dominant text
1430: * macro.
1.21 kristaps 1431: */
1432:
1.35 kristaps 1433: if (NULL == *argv) {
1434: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1435: return(0);
1436: return((*tree->cb.roffblkbodyin)
1.50 kristaps 1437: (tree->arg, tok, argcp,
1438: (const char **)argvp));
1.35 kristaps 1439: }
1.21 kristaps 1440:
1.27 kristaps 1441: /*
1442: * Expensive. Scan to the end of line then work backwards until
1443: * a token isn't punctuation.
1444: */
1445:
1.31 kristaps 1446: if ( ! roffpurgepunct(tree, argv))
1447: return(0);
1.35 kristaps 1448: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1449: return(0);
1.52 kristaps 1450: return((*tree->cb.roffblkbodyin)(tree->arg,
1451: tok, argcp, (const char **)argvp));
1.2 kristaps 1452: }
1453:
1454:
1455: /* ARGSUSED */
1456: static int
1.40 kristaps 1457: roff_ordered(ROFFCALL_ARGS)
1458: {
1.44 kristaps 1459: int i, first, c, argcp[ROFF_MAXLINEARG];
1460: char *ordp[ROFF_MAXLINEARG], *p,
1461: *argvp[ROFF_MAXLINEARG];
1.40 kristaps 1462:
1.52 kristaps 1463: /*
1464: * Ordered macros pass their arguments directly to handlers,
1465: * instead of considering it free-form text. Thus, the
1466: * following macro looks as follows:
1467: *
1468: * .Xr foo 1 ) ,
1469: *
1470: * .Xr arg1 arg2 punctuation
1471: */
1472:
1.40 kristaps 1473: if (ROFF_PRELUDE & tree->state) {
1474: roff_err(tree, *argv, "`%s' disallowed in prelude",
1475: toknames[tok]);
1476: return(0);
1477: }
1478:
1479: first = (*argv == tree->cur);
1.44 kristaps 1480: p = *argv++;
1.52 kristaps 1481: ordp[0] = NULL;
1.40 kristaps 1482:
1.44 kristaps 1483: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1484: return(0);
1.40 kristaps 1485:
1.52 kristaps 1486: if (NULL == *argv)
1.47 kristaps 1487: return(roffspecial(tree, tok, p, argcp,
1488: (const char **)argvp, 0, ordp));
1.40 kristaps 1489:
1490: i = 0;
1491: while (*argv && i < ROFF_MAXLINEARG) {
1.46 kristaps 1492: c = ROFF_PARSED & tokens[tok].flags ?
1493: rofffindcallable(*argv) : ROFF_MAX;
1.42 kristaps 1494:
1495: if (ROFF_MAX == c && ! roffispunct(*argv)) {
1496: ordp[i++] = *argv++;
1497: continue;
1498: }
1499: ordp[i] = NULL;
1500:
1501: if (ROFF_MAX == c)
1502: break;
1503:
1.47 kristaps 1504: if ( ! roffspecial(tree, tok, p, argcp,
1505: (const char **)argvp,
1506: (size_t)i, ordp))
1.42 kristaps 1507: return(0);
1.40 kristaps 1508:
1.46 kristaps 1509: return(roffcall(tree, c, argv));
1.40 kristaps 1510: }
1511:
1.42 kristaps 1512: assert(i != ROFF_MAXLINEARG);
1.40 kristaps 1513: ordp[i] = NULL;
1514:
1.47 kristaps 1515: if ( ! roffspecial(tree, tok, p, argcp,
1516: (const char**)argvp,
1517: (size_t)i, ordp))
1.40 kristaps 1518: return(0);
1519:
1520: /* FIXME: error if there's stuff after the punctuation. */
1521:
1522: if ( ! first || NULL == *argv)
1523: return(1);
1524:
1525: return(roffpurgepunct(tree, argv));
1526: }
1527:
1528:
1529: /* ARGSUSED */
1530: static int
1.2 kristaps 1531: roff_text(ROFFCALL_ARGS)
1532: {
1.37 kristaps 1533: int i, j, first, c, argcp[ROFF_MAXLINEARG];
1534: char *argvp[ROFF_MAXLINEARG];
1.2 kristaps 1535:
1.52 kristaps 1536: /*
1537: * Text macros are similar to special tokens, except that
1538: * arguments are instead flushed as pure data: we're only
1539: * concerned with the macro and its arguments. Example:
1540: *
1541: * .Fl v W f ;
1542: *
1543: * ...Produces...
1544: *
1545: * <fl> v W f </fl> ;
1546: */
1547:
1.4 kristaps 1548: if (ROFF_PRELUDE & tree->state) {
1.12 kristaps 1549: roff_err(tree, *argv, "`%s' disallowed in prelude",
1550: toknames[tok]);
1.4 kristaps 1551: return(0);
1552: }
1553:
1.27 kristaps 1554: first = (*argv == tree->cur);
1.12 kristaps 1555: argv++;
1.5 kristaps 1556:
1.27 kristaps 1557: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1558: return(0);
1.50 kristaps 1559: if ( ! (*tree->cb.roffin)(tree->arg, tok, argcp,
1560: (const char **)argvp))
1.2 kristaps 1561: return(0);
1.27 kristaps 1562: if (NULL == *argv)
1563: return((*tree->cb.roffout)(tree->arg, tok));
1.1 kristaps 1564:
1.2 kristaps 1565: if ( ! (ROFF_PARSED & tokens[tok].flags)) {
1.21 kristaps 1566: i = 0;
1.37 kristaps 1567: while (*argv)
1568: if ( ! roffdata(tree, i++, *argv++))
1.14 kristaps 1569: return(0);
1.37 kristaps 1570:
1.15 kristaps 1571: return((*tree->cb.roffout)(tree->arg, tok));
1.2 kristaps 1572: }
1.1 kristaps 1573:
1.27 kristaps 1574: /*
1575: * Deal with punctuation. Ugly. Work ahead until we encounter
1576: * terminating punctuation. If we encounter it and all
1577: * subsequent tokens are punctuation, then stop processing (the
1578: * line-dominant macro will print these tokens after closure).
1.49 kristaps 1579: * If the punctuation is followed by non-punctuation, then close
1580: * and re-open our scope, then continue.
1.27 kristaps 1581: */
1582:
1.21 kristaps 1583: i = 0;
1.2 kristaps 1584: while (*argv) {
1.33 kristaps 1585: if (ROFF_MAX != (c = rofffindcallable(*argv))) {
1586: if ( ! (ROFF_LSCOPE & tokens[tok].flags))
1587: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1588: return(0);
1589:
1590: if ( ! roffcall(tree, c, argv))
1591: return(0);
1592:
1593: if (ROFF_LSCOPE & tokens[tok].flags)
1594: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1.27 kristaps 1595: return(0);
1.33 kristaps 1596:
1597: break;
1598: }
1.21 kristaps 1599:
1.33 kristaps 1600: if ( ! roffispunct(*argv)) {
1.37 kristaps 1601: if ( ! roffdata(tree, i++, *argv++))
1.33 kristaps 1602: return(0);
1603: continue;
1604: }
1.27 kristaps 1605:
1.33 kristaps 1606: i = 1;
1607: for (j = 0; argv[j]; j++)
1608: if ( ! roffispunct(argv[j]))
1609: break;
1.27 kristaps 1610:
1.33 kristaps 1611: if (argv[j]) {
1.49 kristaps 1612: if (ROFF_LSCOPE & tokens[tok].flags) {
1613: if ( ! roffdata(tree, 0, *argv++))
1614: return(0);
1615: continue;
1616: }
1617: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1618: return(0);
1.37 kristaps 1619: if ( ! roffdata(tree, 0, *argv++))
1.27 kristaps 1620: return(0);
1.50 kristaps 1621: if ( ! (*tree->cb.roffin)(tree->arg, tok,
1622: argcp,
1623: (const char **)argvp))
1.49 kristaps 1624: return(0);
1625:
1626: i = 0;
1.33 kristaps 1627: continue;
1.8 kristaps 1628: }
1.20 kristaps 1629:
1.33 kristaps 1630: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1.14 kristaps 1631: return(0);
1.20 kristaps 1632: break;
1.14 kristaps 1633: }
1.12 kristaps 1634:
1.27 kristaps 1635: if (NULL == *argv)
1636: return((*tree->cb.roffout)(tree->arg, tok));
1637: if ( ! first)
1638: return(1);
1.21 kristaps 1639:
1.31 kristaps 1640: return(roffpurgepunct(tree, argv));
1.6 kristaps 1641: }
1642:
1643:
1.9 kristaps 1644: /* ARGSUSED */
1.6 kristaps 1645: static int
1.27 kristaps 1646: roff_noop(ROFFCALL_ARGS)
1.6 kristaps 1647: {
1648:
1649: return(1);
1.1 kristaps 1650: }
1.9 kristaps 1651:
1652:
1653: /* ARGSUSED */
1654: static int
1.27 kristaps 1655: roff_depr(ROFFCALL_ARGS)
1.9 kristaps 1656: {
1657:
1.27 kristaps 1658: roff_err(tree, *argv, "`%s' is deprecated", toknames[tok]);
1659: return(0);
1.11 kristaps 1660: }
1.12 kristaps 1661:
1662:
1663: static void
1664: roff_warn(const struct rofftree *tree, const char *pos, char *fmt, ...)
1665: {
1666: va_list ap;
1667: char buf[128];
1668:
1669: va_start(ap, fmt);
1670: (void)vsnprintf(buf, sizeof(buf), fmt, ap);
1671: va_end(ap);
1672:
1.15 kristaps 1673: (*tree->cb.roffmsg)(tree->arg,
1674: ROFF_WARN, tree->cur, pos, buf);
1.12 kristaps 1675: }
1676:
1677:
1678: static void
1679: roff_err(const struct rofftree *tree, const char *pos, char *fmt, ...)
1680: {
1681: va_list ap;
1682: char buf[128];
1683:
1684: va_start(ap, fmt);
1685: (void)vsnprintf(buf, sizeof(buf), fmt, ap);
1686: va_end(ap);
1687:
1.15 kristaps 1688: (*tree->cb.roffmsg)(tree->arg,
1689: ROFF_ERROR, tree->cur, pos, buf);
1.12 kristaps 1690: }
1.33 kristaps 1691:
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to roff.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc