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