Annotation of mandoc/roff.c, Revision 1.60
1.60 ! kristaps 1: /* $Id: roff.c,v 1.59 2008/12/10 12:05:33 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. */
1.60 ! kristaps 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:
533: switch (sec) {
534: case(ROFFSec_SYNOP):
1.60 ! kristaps 535: if (ROFFSec_NAME & tree->asec)
1.52 kristaps 536: return(1);
537: break;
538: case(ROFFSec_DESC):
1.60 ! kristaps 539: if (ROFFSec_SYNOP & tree->asec)
1.52 kristaps 540: return(1);
541: break;
542: case(ROFFSec_RETVAL):
1.60 ! kristaps 543: if (ROFFSec_DESC & tree->asec)
1.52 kristaps 544: return(1);
545: break;
546: case(ROFFSec_ENV):
1.60 ! kristaps 547: if (ROFFSec_RETVAL & tree->asec)
1.52 kristaps 548: return(1);
549: break;
550: case(ROFFSec_FILES):
1.60 ! kristaps 551: if (ROFFSec_ENV & tree->asec)
1.52 kristaps 552: return(1);
553: break;
554: case(ROFFSec_EX):
1.60 ! kristaps 555: if (ROFFSec_FILES & tree->asec)
1.52 kristaps 556: return(1);
557: break;
558: case(ROFFSec_DIAG):
1.60 ! kristaps 559: if (ROFFSec_EX & tree->asec)
1.52 kristaps 560: return(1);
561: break;
562: case(ROFFSec_ERRS):
1.60 ! kristaps 563: if (ROFFSec_DIAG & tree->asec)
1.52 kristaps 564: return(1);
565: break;
566: case(ROFFSec_SEEALSO):
1.60 ! kristaps 567: if (ROFFSec_ERRS & tree->asec)
1.52 kristaps 568: return(1);
569: break;
570: case(ROFFSec_STAND):
1.60 ! kristaps 571: if (ROFFSec_SEEALSO & tree->asec)
1.52 kristaps 572: return(1);
573: break;
574: case(ROFFSec_HIST):
1.60 ! kristaps 575: if (ROFFSec_STAND & tree->asec)
1.52 kristaps 576: return(1);
577: break;
578: case(ROFFSec_AUTH):
1.60 ! kristaps 579: if (ROFFSec_HIST & tree->asec)
1.52 kristaps 580: return(1);
581: break;
582: case(ROFFSec_CAVEATS):
1.60 ! kristaps 583: if (ROFFSec_AUTH & tree->asec)
1.52 kristaps 584: return(1);
585: break;
586: case(ROFFSec_BUGS):
1.60 ! kristaps 587: if (ROFFSec_CAVEATS & tree->asec)
1.52 kristaps 588: return(1);
589: break;
590: default:
591: return(1);
592: }
593:
1.55 kristaps 594: return(roff_warnp(tree, start, ROFF_Sh, WRN_SECORD));
1.53 kristaps 595: }
596:
597:
1.54 kristaps 598: /* FIXME: move this into literals.c (or similar). */
1.53 kristaps 599: static int
1.20 kristaps 600: roffispunct(const char *p)
601: {
602:
603: if (0 == *p)
604: return(0);
605: if (0 != *(p + 1))
606: return(0);
607:
608: switch (*p) {
609: case('{'):
610: /* FALLTHROUGH */
611: case('.'):
612: /* FALLTHROUGH */
613: case(','):
614: /* FALLTHROUGH */
615: case(';'):
616: /* FALLTHROUGH */
617: case(':'):
618: /* FALLTHROUGH */
619: case('?'):
620: /* FALLTHROUGH */
621: case('!'):
622: /* FALLTHROUGH */
623: case('('):
624: /* FALLTHROUGH */
625: case(')'):
626: /* FALLTHROUGH */
627: case('['):
628: /* FALLTHROUGH */
629: case(']'):
630: /* FALLTHROUGH */
631: case('}'):
632: return(1);
633: default:
634: break;
635: }
636:
637: return(0);
638: }
639:
640:
1.2 kristaps 641: static int
642: rofffindcallable(const char *name)
643: {
644: int c;
645:
646: if (ROFF_MAX == (c = rofffindtok(name)))
647: return(ROFF_MAX);
1.8 kristaps 648: assert(c >= 0 && c < ROFF_MAX);
1.2 kristaps 649: return(ROFF_CALLABLE & tokens[c].flags ? c : ROFF_MAX);
650: }
651:
652:
1.1 kristaps 653: static struct roffnode *
1.4 kristaps 654: roffnode_new(int tokid, struct rofftree *tree)
1.1 kristaps 655: {
656: struct roffnode *p;
657:
1.12 kristaps 658: if (NULL == (p = malloc(sizeof(struct roffnode))))
659: err(1, "malloc");
1.1 kristaps 660:
661: p->tok = tokid;
662: p->parent = tree->last;
663: tree->last = p;
1.9 kristaps 664:
1.1 kristaps 665: return(p);
666: }
667:
668:
1.5 kristaps 669: static int
670: roffargok(int tokid, int argid)
671: {
672: const int *c;
673:
674: if (NULL == (c = tokens[tokid].args))
675: return(0);
676:
677: for ( ; ROFF_ARGMAX != *c; c++)
678: if (argid == *c)
679: return(1);
680:
681: return(0);
682: }
683:
684:
1.1 kristaps 685: static void
1.15 kristaps 686: roffnode_free(struct rofftree *tree)
1.1 kristaps 687: {
688: struct roffnode *p;
689:
690: assert(tree->last);
691:
692: p = tree->last;
693: tree->last = tree->last->parent;
694: free(p);
695: }
696:
697:
1.6 kristaps 698: static int
1.47 kristaps 699: roffspecial(struct rofftree *tree, int tok, const char *start,
700: const int *argc, const char **argv,
701: size_t sz, char **ordp)
1.40 kristaps 702: {
703:
1.44 kristaps 704: switch (tok) {
1.46 kristaps 705: case (ROFF_At):
706: if (0 == sz)
707: break;
1.56 kristaps 708: if (ROFF_ATT_MAX != roff_att(*ordp))
1.46 kristaps 709: break;
1.55 kristaps 710: return(roff_errp(tree, *ordp, tok, ERR_BADARG));
1.49 kristaps 711:
1.50 kristaps 712: case (ROFF_Xr):
1.51 kristaps 713: if (2 == sz) {
714: assert(ordp[1]);
1.55 kristaps 715: if (ROFF_MSEC_MAX != roff_msec(ordp[1]))
1.51 kristaps 716: break;
1.55 kristaps 717: if ( ! roff_warn(tree, start, "invalid `%s' manual "
718: "section", toknames[tok]))
719: return(0);
1.51 kristaps 720: }
1.50 kristaps 721: /* FALLTHROUGH */
1.51 kristaps 722:
1.52 kristaps 723: case (ROFF_Sx):
724: /* FALLTHROUGH*/
1.49 kristaps 725: case (ROFF_Fn):
726: if (0 != sz)
727: break;
1.55 kristaps 728: return(roff_errp(tree, start, tok, ERR_ARGGE1));
1.46 kristaps 729:
1.44 kristaps 730: case (ROFF_Nm):
731: if (0 == sz) {
1.55 kristaps 732: if (0 != tree->name[0]) {
733: ordp[0] = tree->name;
734: ordp[1] = NULL;
735: break;
1.44 kristaps 736: }
1.55 kristaps 737: return(roff_err(tree, start, "`Nm' not set"));
1.44 kristaps 738: } else if ( ! roffsetname(tree, ordp))
739: return(0);
740: break;
741:
1.48 kristaps 742: case (ROFF_Rv):
743: /* FALLTHROUGH*/
1.44 kristaps 744: case (ROFF_Ex):
1.48 kristaps 745: if (1 == sz)
746: break;
1.55 kristaps 747: return(roff_errp(tree, start, tok, ERR_ARGEQ1));
1.44 kristaps 748:
749: case (ROFF_Sm):
1.55 kristaps 750: if (1 != sz)
751: return(roff_errp(tree, start, tok, ERR_ARGEQ1));
752: else if (0 == strcmp(ordp[0], "on") ||
753: 0 == strcmp(ordp[0], "off"))
754: break;
755: return(roff_errp(tree, *ordp, tok, ERR_BADARG));
1.45 kristaps 756:
757: case (ROFF_Ud):
758: /* FALLTHROUGH */
1.46 kristaps 759: case (ROFF_Ux):
760: /* FALLTHROUGH */
1.45 kristaps 761: case (ROFF_Bt):
1.55 kristaps 762: if (0 == sz)
763: break;
764: return(roff_errp(tree, start, tok, ERR_ARGEQ0));
1.44 kristaps 765: default:
766: break;
767: }
768:
1.50 kristaps 769: return((*tree->cb.roffspecial)(tree->arg, tok, tree->cur,
770: argc, argv, (const char **)ordp));
1.40 kristaps 771: }
772:
773:
774: static int
1.51 kristaps 775: roffexit(struct rofftree *tree, int tok)
776: {
777:
778: assert(tokens[tok].cb);
779: return((*tokens[tok].cb)(tok, tree, NULL, ROFF_EXIT));
780: }
781:
782:
783: static int
1.33 kristaps 784: roffcall(struct rofftree *tree, int tok, char **argv)
785: {
1.51 kristaps 786: int i;
787: enum roffmsec c;
1.33 kristaps 788:
1.55 kristaps 789: if (NULL == tokens[tok].cb)
790: return(roff_errp(tree, *argv, tok, ERR_NOTSUP));
791:
1.51 kristaps 792: if (tokens[tok].sections && ROFF_MSEC_MAX != tree->section) {
793: i = 0;
794: while (ROFF_MSEC_MAX !=
795: (c = tokens[tok].sections[i++]))
796: if (c == tree->section)
797: break;
798: if (ROFF_MSEC_MAX == c) {
1.55 kristaps 799: if ( ! roff_warn(tree, *argv, "`%s' is not a valid "
1.51 kristaps 800: "macro in this manual section",
1.55 kristaps 801: toknames[tok]))
802: return(0);
1.51 kristaps 803: }
804: }
805:
806: return((*tokens[tok].cb)(tok, tree, argv, ROFF_ENTER));
1.33 kristaps 807: }
808:
809:
810: static int
1.12 kristaps 811: roffnextopt(const struct rofftree *tree, int tok,
1.18 kristaps 812: char ***in, char **val)
1.6 kristaps 813: {
1.18 kristaps 814: char *arg, **argv;
1.6 kristaps 815: int v;
816:
817: *val = NULL;
818: argv = *in;
819: assert(argv);
820:
821: if (NULL == (arg = *argv))
822: return(-1);
823: if ('-' != *arg)
824: return(-1);
825:
1.12 kristaps 826: if (ROFF_ARGMAX == (v = rofffindarg(arg + 1))) {
1.55 kristaps 827: if ( ! roff_warn(tree, arg, "argument-like parameter `%s' to "
828: "`%s'", arg, toknames[tok]))
829: return(ROFF_ARGMAX);
1.6 kristaps 830: return(-1);
1.12 kristaps 831: }
832:
833: if ( ! roffargok(tok, v)) {
1.55 kristaps 834: if ( ! roff_warn(tree, arg, "invalid argument parameter `%s' to "
835: "`%s'", tokargnames[v], toknames[tok]))
836: return(ROFF_ARGMAX);
1.6 kristaps 837: return(-1);
1.12 kristaps 838: }
839:
840: if ( ! (ROFF_VALUE & tokenargs[v]))
1.6 kristaps 841: return(v);
842:
843: *in = ++argv;
844:
1.12 kristaps 845: if (NULL == *argv) {
1.55 kristaps 846: (void)roff_err(tree, arg, "empty value of `%s' for `%s'",
1.12 kristaps 847: tokargnames[v], toknames[tok]);
848: return(ROFF_ARGMAX);
849: }
1.6 kristaps 850:
1.12 kristaps 851: return(v);
1.6 kristaps 852: }
853:
854:
1.27 kristaps 855: static int
1.31 kristaps 856: roffpurgepunct(struct rofftree *tree, char **argv)
857: {
858: int i;
859:
860: i = 0;
861: while (argv[i])
862: i++;
863: assert(i > 0);
864: if ( ! roffispunct(argv[--i]))
865: return(1);
866: while (i >= 0 && roffispunct(argv[i]))
867: i--;
868: i++;
869:
870: /* LINTED */
871: while (argv[i])
1.37 kristaps 872: if ( ! roffdata(tree, 0, argv[i++]))
1.31 kristaps 873: return(0);
874: return(1);
875: }
876:
877:
878: static int
1.27 kristaps 879: roffparseopts(struct rofftree *tree, int tok,
880: char ***args, int *argc, char **argv)
881: {
882: int i, c;
883: char *v;
884:
885: i = 0;
886:
887: while (-1 != (c = roffnextopt(tree, tok, args, &v))) {
888: if (ROFF_ARGMAX == c)
889: return(0);
890:
891: argc[i] = c;
892: argv[i] = v;
893: i++;
894: *args = *args + 1;
895: }
896:
897: argc[i] = ROFF_ARGMAX;
898: argv[i] = NULL;
899: return(1);
900: }
901:
902:
1.37 kristaps 903: static int
904: roffdata(struct rofftree *tree, int space, char *buf)
905: {
906:
1.38 kristaps 907: if (0 == *buf)
908: return(1);
1.37 kristaps 909: return((*tree->cb.roffdata)(tree->arg,
910: space != 0, tree->cur, buf));
911: }
912:
913:
1.1 kristaps 914: /* ARGSUSED */
915: static int
916: roff_Dd(ROFFCALL_ARGS)
917: {
1.30 kristaps 918: time_t t;
919: char *p, buf[32];
1.55 kristaps 920: size_t sz;
1.1 kristaps 921:
1.4 kristaps 922: if (ROFF_BODY & tree->state) {
923: assert( ! (ROFF_PRELUDE & tree->state));
924: assert(ROFF_PRELUDE_Dd & tree->state);
925: return(roff_text(tok, tree, argv, type));
926: }
927:
1.1 kristaps 928: assert(ROFF_PRELUDE & tree->state);
1.4 kristaps 929: assert( ! (ROFF_BODY & tree->state));
930:
1.55 kristaps 931: if (ROFF_PRELUDE_Dd & tree->state)
932: return(roff_errp(tree, *argv, tok, ERR_PR_REP));
933: if (ROFF_PRELUDE_Dt & tree->state)
934: return(roff_errp(tree, *argv, tok, ERR_PR_OOO));
1.1 kristaps 935:
1.30 kristaps 936: assert(NULL == tree->last);
937:
938: argv++;
939:
1.55 kristaps 940: /*
941: * This is a bit complex because there are many forms the date
942: * can be in: it can be simply $Mdocdate$, $Mdocdate <date>$,
943: * or a raw date. Process accordingly.
944: */
945:
1.30 kristaps 946: if (0 == strcmp(*argv, "$Mdocdate$")) {
947: t = time(NULL);
948: if (NULL == localtime_r(&t, &tree->tm))
949: err(1, "localtime_r");
950: tree->state |= ROFF_PRELUDE_Dd;
951: return(1);
952: }
953:
954: buf[0] = 0;
955: p = *argv;
1.55 kristaps 956: sz = sizeof(buf);
1.30 kristaps 957:
958: if (0 != strcmp(*argv, "$Mdocdate:")) {
959: while (*argv) {
1.55 kristaps 960: if (strlcat(buf, *argv++, sz) < sz)
1.30 kristaps 961: continue;
1.55 kristaps 962: return(roff_errp(tree, p, tok, ERR_BADARG));
1.30 kristaps 963: }
964: if (strptime(buf, "%b%d,%Y", &tree->tm)) {
965: tree->state |= ROFF_PRELUDE_Dd;
966: return(1);
967: }
1.55 kristaps 968: return(roff_errp(tree, p, tok, ERR_BADARG));
1.30 kristaps 969: }
970:
971: argv++;
1.55 kristaps 972:
1.30 kristaps 973: while (*argv && **argv != '$') {
1.55 kristaps 974: if (strlcat(buf, *argv++, sz) >= sz)
975: return(roff_errp(tree, p, tok, ERR_BADARG));
976: if (strlcat(buf, " ", sz) >= sz)
977: return(roff_errp(tree, p, tok, ERR_BADARG));
1.30 kristaps 978: }
979:
1.55 kristaps 980: if (NULL == *argv)
981: return(roff_errp(tree, p, tok, ERR_BADARG));
982: if (NULL == strptime(buf, "%b %d %Y", &tree->tm))
983: return(roff_errp(tree, p, tok, ERR_BADARG));
1.4 kristaps 984:
1.1 kristaps 985: tree->state |= ROFF_PRELUDE_Dd;
986: return(1);
987: }
988:
989:
990: /* ARGSUSED */
991: static int
992: roff_Dt(ROFFCALL_ARGS)
993: {
1.55 kristaps 994: size_t sz;
1.1 kristaps 995:
1.4 kristaps 996: if (ROFF_BODY & tree->state) {
997: assert( ! (ROFF_PRELUDE & tree->state));
998: assert(ROFF_PRELUDE_Dt & tree->state);
999: return(roff_text(tok, tree, argv, type));
1000: }
1001:
1.1 kristaps 1002: assert(ROFF_PRELUDE & tree->state);
1.4 kristaps 1003: assert( ! (ROFF_BODY & tree->state));
1004:
1.55 kristaps 1005: if ( ! (ROFF_PRELUDE_Dd & tree->state))
1006: return(roff_errp(tree, *argv, tok, ERR_PR_OOO));
1007: if (ROFF_PRELUDE_Dt & tree->state)
1008: return(roff_errp(tree, *argv, tok, ERR_PR_REP));
1.1 kristaps 1009:
1.30 kristaps 1010: argv++;
1.55 kristaps 1011: sz = sizeof(tree->title);
1012:
1013: if (NULL == *argv)
1014: return(roff_errp(tree, *argv, tok, ERR_ARGGE2));
1015: if (strlcpy(tree->title, *argv, sz) >= sz)
1016: return(roff_errp(tree, *argv, tok, ERR_ARGLEN));
1.30 kristaps 1017:
1018: argv++;
1.55 kristaps 1019: if (NULL == *argv)
1020: return(roff_errp(tree, *argv, tok, ERR_ARGGE2));
1.51 kristaps 1021:
1.55 kristaps 1022: if (ROFF_MSEC_MAX == (tree->section = roff_msec(*argv)))
1023: return(roff_errp(tree, *argv, tok, ERR_BADARG));
1.30 kristaps 1024:
1025: argv++;
1.55 kristaps 1026:
1.30 kristaps 1027: if (NULL == *argv) {
1.58 kristaps 1028: switch (tree->section) {
1029: case(ROFF_MSEC_1):
1030: /* FALLTHROUGH */
1031: case(ROFF_MSEC_6):
1032: /* FALLTHROUGH */
1033: case(ROFF_MSEC_7):
1034: tree->volume = ROFF_VOL_URM;
1035: break;
1036: case(ROFF_MSEC_2):
1037: /* FALLTHROUGH */
1038: case(ROFF_MSEC_3):
1039: /* FALLTHROUGH */
1040: case(ROFF_MSEC_3p):
1041: /* FALLTHROUGH */
1042: case(ROFF_MSEC_4):
1043: /* FALLTHROUGH */
1044: case(ROFF_MSEC_5):
1045: tree->volume = ROFF_VOL_PRM;
1046: break;
1047: case(ROFF_MSEC_8):
1048: tree->volume = ROFF_VOL_PRM;
1049: break;
1050: case(ROFF_MSEC_9):
1051: tree->volume = ROFF_VOL_KM;
1052: break;
1053: case(ROFF_MSEC_UNASS):
1054: /* FALLTHROUGH */
1055: case(ROFF_MSEC_DRAFT):
1056: /* FALLTHROUGH */
1057: case(ROFF_MSEC_PAPER):
1058: tree->volume = ROFF_VOL_NONE;
1059: break;
1060: default:
1061: abort();
1062: /* NOTREACHED */
1063: }
1064: } else if (ROFF_VOL_MAX == (tree->volume = roff_vol(*argv)))
1065: return(roff_errp(tree, *argv, tok, ERR_BADARG));
1.4 kristaps 1066:
1.1 kristaps 1067: assert(NULL == tree->last);
1068: tree->state |= ROFF_PRELUDE_Dt;
1069:
1070: return(1);
1071: }
1072:
1073:
1.42 kristaps 1074: static int
1075: roffsetname(struct rofftree *tree, char **ordp)
1076: {
1.55 kristaps 1077: size_t sz;
1.42 kristaps 1078:
1079: assert(*ordp);
1080:
1081: /* FIXME: not all sections can set this. */
1082:
1.55 kristaps 1083: if (NULL != *(ordp + 1))
1084: return(roff_errp(tree, *ordp, ROFF_Nm, ERR_ARGMNY));
1.42 kristaps 1085:
1.55 kristaps 1086: sz = sizeof(tree->name);
1087: if (strlcpy(tree->name, *ordp, sz) >= sz)
1088: return(roff_errp(tree, *ordp, ROFF_Nm, ERR_ARGLEN));
1.42 kristaps 1089:
1090: return(1);
1091: }
1092:
1093:
1.1 kristaps 1094: /* ARGSUSED */
1.33 kristaps 1095: static int
1096: roff_Ns(ROFFCALL_ARGS)
1097: {
1098: int j, c, first;
1.40 kristaps 1099: char *morep[1];
1.33 kristaps 1100:
1101: first = (*argv++ == tree->cur);
1.40 kristaps 1102: morep[0] = NULL;
1.33 kristaps 1103:
1.47 kristaps 1104: if ( ! roffspecial(tree, tok, *argv, NULL, NULL, 0, morep))
1.33 kristaps 1105: return(0);
1.31 kristaps 1106:
1.33 kristaps 1107: while (*argv) {
1108: if (ROFF_MAX != (c = rofffindcallable(*argv))) {
1109: if ( ! roffcall(tree, c, argv))
1110: return(0);
1.31 kristaps 1111: break;
1112: }
1.33 kristaps 1113:
1114: if ( ! roffispunct(*argv)) {
1.37 kristaps 1115: if ( ! roffdata(tree, 1, *argv++))
1116: return(0);
1117: continue;
1.31 kristaps 1118: }
1.37 kristaps 1119:
1.33 kristaps 1120: for (j = 0; argv[j]; j++)
1121: if ( ! roffispunct(argv[j]))
1122: break;
1123:
1124: if (argv[j]) {
1.37 kristaps 1125: if ( ! roffdata(tree, 0, *argv++))
1126: return(0);
1127: continue;
1.33 kristaps 1128: }
1129:
1.31 kristaps 1130: break;
1131: }
1132:
1133: if ( ! first)
1134: return(1);
1.33 kristaps 1135:
1.31 kristaps 1136: return(roffpurgepunct(tree, argv));
1137: }
1138:
1139:
1140: /* ARGSUSED */
1141: static int
1.1 kristaps 1142: roff_Os(ROFFCALL_ARGS)
1143: {
1.30 kristaps 1144: char *p;
1.55 kristaps 1145: size_t sz;
1.1 kristaps 1146:
1.30 kristaps 1147: if (ROFF_BODY & tree->state) {
1.4 kristaps 1148: assert( ! (ROFF_PRELUDE & tree->state));
1149: assert(ROFF_PRELUDE_Os & tree->state);
1150: return(roff_text(tok, tree, argv, type));
1151: }
1.1 kristaps 1152:
1153: assert(ROFF_PRELUDE & tree->state);
1154: if ( ! (ROFF_PRELUDE_Dt & tree->state) ||
1.55 kristaps 1155: ! (ROFF_PRELUDE_Dd & tree->state))
1156: return(roff_errp(tree, *argv, tok, ERR_PR_OOO));
1.1 kristaps 1157:
1.30 kristaps 1158: tree->os[0] = 0;
1159:
1160: p = *++argv;
1.55 kristaps 1161: sz = sizeof(tree->os);
1.30 kristaps 1162:
1.55 kristaps 1163: while (*argv)
1164: if (strlcat(tree->os, *argv++, sz) >= sz)
1165: return(roff_errp(tree, p, tok, ERR_ARGLEN));
1.30 kristaps 1166:
1167: if (0 == tree->os[0])
1.55 kristaps 1168: if (strlcpy(tree->os, "LOCAL", sz) >= sz)
1169: return(roff_errp(tree, p, tok, ERR_ARGLEN));
1.1 kristaps 1170:
1171: tree->state |= ROFF_PRELUDE_Os;
1172: tree->state &= ~ROFF_PRELUDE;
1173: tree->state |= ROFF_BODY;
1174:
1.51 kristaps 1175: assert(ROFF_MSEC_MAX != tree->section);
1176: assert(0 != tree->title[0]);
1177: assert(0 != tree->os[0]);
1178:
1.4 kristaps 1179: assert(NULL == tree->last);
1180:
1.36 kristaps 1181: return((*tree->cb.roffhead)(tree->arg, &tree->tm,
1.55 kristaps 1182: tree->os, tree->title,
1183: tree->section, tree->volume));
1.1 kristaps 1184: }
1185:
1186:
1187: /* ARGSUSED */
1188: static int
1.2 kristaps 1189: roff_layout(ROFFCALL_ARGS)
1.1 kristaps 1190: {
1.37 kristaps 1191: int i, c, argcp[ROFF_MAXLINEARG];
1.57 kristaps 1192: char *argvp[ROFF_MAXLINEARG];
1.1 kristaps 1193:
1.52 kristaps 1194: /*
1195: * The roff_layout function is for multi-line macros. A layout
1196: * has a start and end point, which is either declared
1197: * explicitly or implicitly. An explicit start and end is
1198: * embodied by `.Bl' and `.El', with the former being the start
1199: * and the latter being an end. The `.Sh' and `.Ss' tags, on
1200: * the other hand, are implicit. The scope of a layout is the
1201: * space between start and end. Explicit layouts may not close
1202: * out implicit ones and vice versa; implicit layouts may close
1203: * out other implicit layouts.
1204: */
1205:
1206: assert( ! (ROFF_CALLABLE & tokens[tok].flags));
1207:
1.55 kristaps 1208: if (ROFF_PRELUDE & tree->state)
1209: return(roff_errp(tree, *argv, tok, ERR_NOT_PR));
1210:
1211: if (ROFF_EXIT == type) {
1.15 kristaps 1212: roffnode_free(tree);
1.35 kristaps 1213: if ( ! (*tree->cb.roffblkbodyout)(tree->arg, tok))
1214: return(0);
1.15 kristaps 1215: return((*tree->cb.roffblkout)(tree->arg, tok));
1.2 kristaps 1216: }
1.1 kristaps 1217:
1.57 kristaps 1218: argv++;
1.27 kristaps 1219: assert( ! (ROFF_CALLABLE & tokens[tok].flags));
1.5 kristaps 1220:
1.27 kristaps 1221: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1222: return(0);
1.4 kristaps 1223: if (NULL == roffnode_new(tok, tree))
1.2 kristaps 1224: return(0);
1225:
1.27 kristaps 1226: /*
1227: * Layouts have two parts: the layout body and header. The
1228: * layout header is the trailing text of the line macro, while
1229: * the layout body is everything following until termination.
1.52 kristaps 1230: * Example:
1231: *
1232: * .It Fl f ) ;
1233: * Bar.
1234: *
1235: * ...Produces...
1236: *
1237: * <block>
1238: * <head>
1239: * <!Fl f!> ;
1240: * </head>
1241: *
1242: * <body>
1243: * Bar.
1244: * </body>
1245: * </block>
1.27 kristaps 1246: */
1247:
1.50 kristaps 1248: if ( ! (*tree->cb.roffblkin)(tree->arg, tok, argcp,
1249: (const char **)argvp))
1.18 kristaps 1250: return(0);
1.52 kristaps 1251:
1252: /* +++ Begin run macro-specific hooks over argv. */
1253:
1254: switch (tok) {
1255: case (ROFF_Sh):
1256: if (NULL == *argv) {
1.55 kristaps 1257: argv--;
1258: return(roff_errp(tree, *argv, tok, ERR_ARGGE1));
1.52 kristaps 1259: }
1.55 kristaps 1260:
1261: tree->csec = roff_sec((const char **)argv);
1262:
1.52 kristaps 1263: if ( ! (ROFFSec_OTHER & tree->csec) &&
1264: tree->asec & tree->csec)
1.55 kristaps 1265: if ( ! roff_warn(tree, *argv, "section repeated"))
1266: return(0);
1267:
1268: if (0 == tree->asec && ! (ROFFSec_NAME & tree->csec))
1269: return(roff_err(tree, *argv, "`NAME' section "
1270: "must be first"));
1271: if ( ! roffchecksec(tree, *argv, tree->csec))
1.52 kristaps 1272: return(0);
1273:
1274: tree->asec |= tree->csec;
1275: break;
1276: default:
1277: break;
1278: }
1279:
1280: /* --- End run macro-specific hooks over argv. */
1281:
1.18 kristaps 1282: if (NULL == *argv)
1.35 kristaps 1283: return((*tree->cb.roffblkbodyin)
1.50 kristaps 1284: (tree->arg, tok, argcp,
1285: (const char **)argvp));
1.35 kristaps 1286:
1.50 kristaps 1287: if ( ! (*tree->cb.roffblkheadin)(tree->arg, tok, argcp,
1288: (const char **)argvp))
1.2 kristaps 1289: return(0);
1290:
1.27 kristaps 1291: /*
1292: * If there are no parsable parts, then write remaining tokens
1293: * into the layout header and exit.
1294: */
1295:
1.2 kristaps 1296: if ( ! (ROFF_PARSED & tokens[tok].flags)) {
1.21 kristaps 1297: i = 0;
1.37 kristaps 1298: while (*argv)
1299: if ( ! roffdata(tree, i++, *argv++))
1.14 kristaps 1300: return(0);
1.37 kristaps 1301:
1.35 kristaps 1302: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1303: return(0);
1.52 kristaps 1304: return((*tree->cb.roffblkbodyin)(tree->arg, tok, argcp,
1.50 kristaps 1305: (const char **)argvp));
1.2 kristaps 1306: }
1307:
1.27 kristaps 1308: /*
1309: * Parsable elements may be in the header (or be the header, for
1310: * that matter). Follow the regular parsing rules for these.
1311: */
1312:
1.21 kristaps 1313: i = 0;
1.1 kristaps 1314: while (*argv) {
1.26 kristaps 1315: if (ROFF_MAX == (c = rofffindcallable(*argv))) {
1316: assert(tree->arg);
1.37 kristaps 1317: if ( ! roffdata(tree, i++, *argv++))
1.8 kristaps 1318: return(0);
1.26 kristaps 1319: continue;
1320: }
1.33 kristaps 1321: if ( ! roffcall(tree, c, argv))
1.14 kristaps 1322: return(0);
1.26 kristaps 1323: break;
1.21 kristaps 1324: }
1325:
1326: /*
1.27 kristaps 1327: * If there's trailing punctuation in the header, then write it
1328: * out now. Here we mimic the behaviour of a line-dominant text
1329: * macro.
1.21 kristaps 1330: */
1331:
1.35 kristaps 1332: if (NULL == *argv) {
1333: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1334: return(0);
1335: return((*tree->cb.roffblkbodyin)
1.50 kristaps 1336: (tree->arg, tok, argcp,
1337: (const char **)argvp));
1.35 kristaps 1338: }
1.21 kristaps 1339:
1.27 kristaps 1340: /*
1341: * Expensive. Scan to the end of line then work backwards until
1342: * a token isn't punctuation.
1343: */
1344:
1.31 kristaps 1345: if ( ! roffpurgepunct(tree, argv))
1346: return(0);
1.35 kristaps 1347: if ( ! (*tree->cb.roffblkheadout)(tree->arg, tok))
1348: return(0);
1.52 kristaps 1349: return((*tree->cb.roffblkbodyin)(tree->arg,
1350: tok, argcp, (const char **)argvp));
1.2 kristaps 1351: }
1352:
1353:
1354: /* ARGSUSED */
1355: static int
1.40 kristaps 1356: roff_ordered(ROFFCALL_ARGS)
1357: {
1.44 kristaps 1358: int i, first, c, argcp[ROFF_MAXLINEARG];
1359: char *ordp[ROFF_MAXLINEARG], *p,
1360: *argvp[ROFF_MAXLINEARG];
1.40 kristaps 1361:
1.52 kristaps 1362: /*
1363: * Ordered macros pass their arguments directly to handlers,
1364: * instead of considering it free-form text. Thus, the
1365: * following macro looks as follows:
1366: *
1367: * .Xr foo 1 ) ,
1368: *
1369: * .Xr arg1 arg2 punctuation
1370: */
1371:
1.55 kristaps 1372: if (ROFF_PRELUDE & tree->state)
1373: return(roff_errp(tree, *argv, tok, ERR_NOT_PR));
1.40 kristaps 1374:
1375: first = (*argv == tree->cur);
1.44 kristaps 1376: p = *argv++;
1.52 kristaps 1377: ordp[0] = NULL;
1.40 kristaps 1378:
1.44 kristaps 1379: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1380: return(0);
1.40 kristaps 1381:
1.52 kristaps 1382: if (NULL == *argv)
1.47 kristaps 1383: return(roffspecial(tree, tok, p, argcp,
1384: (const char **)argvp, 0, ordp));
1.40 kristaps 1385:
1386: i = 0;
1387: while (*argv && i < ROFF_MAXLINEARG) {
1.46 kristaps 1388: c = ROFF_PARSED & tokens[tok].flags ?
1389: rofffindcallable(*argv) : ROFF_MAX;
1.42 kristaps 1390:
1391: if (ROFF_MAX == c && ! roffispunct(*argv)) {
1392: ordp[i++] = *argv++;
1393: continue;
1394: }
1395: ordp[i] = NULL;
1396:
1397: if (ROFF_MAX == c)
1398: break;
1399:
1.47 kristaps 1400: if ( ! roffspecial(tree, tok, p, argcp,
1401: (const char **)argvp,
1402: (size_t)i, ordp))
1.42 kristaps 1403: return(0);
1.40 kristaps 1404:
1.46 kristaps 1405: return(roffcall(tree, c, argv));
1.40 kristaps 1406: }
1407:
1.42 kristaps 1408: assert(i != ROFF_MAXLINEARG);
1.40 kristaps 1409: ordp[i] = NULL;
1410:
1.47 kristaps 1411: if ( ! roffspecial(tree, tok, p, argcp,
1412: (const char**)argvp,
1413: (size_t)i, ordp))
1.40 kristaps 1414: return(0);
1415:
1416: /* FIXME: error if there's stuff after the punctuation. */
1417:
1418: if ( ! first || NULL == *argv)
1419: return(1);
1420:
1421: return(roffpurgepunct(tree, argv));
1422: }
1423:
1424:
1425: /* ARGSUSED */
1426: static int
1.2 kristaps 1427: roff_text(ROFFCALL_ARGS)
1428: {
1.37 kristaps 1429: int i, j, first, c, argcp[ROFF_MAXLINEARG];
1430: char *argvp[ROFF_MAXLINEARG];
1.2 kristaps 1431:
1.52 kristaps 1432: /*
1433: * Text macros are similar to special tokens, except that
1434: * arguments are instead flushed as pure data: we're only
1435: * concerned with the macro and its arguments. Example:
1436: *
1437: * .Fl v W f ;
1438: *
1439: * ...Produces...
1440: *
1441: * <fl> v W f </fl> ;
1442: */
1443:
1.55 kristaps 1444: if (ROFF_PRELUDE & tree->state)
1445: return(roff_errp(tree, *argv, tok, ERR_NOT_PR));
1.4 kristaps 1446:
1.27 kristaps 1447: first = (*argv == tree->cur);
1.12 kristaps 1448: argv++;
1.5 kristaps 1449:
1.27 kristaps 1450: if ( ! roffparseopts(tree, tok, &argv, argcp, argvp))
1451: return(0);
1.50 kristaps 1452: if ( ! (*tree->cb.roffin)(tree->arg, tok, argcp,
1453: (const char **)argvp))
1.2 kristaps 1454: return(0);
1.27 kristaps 1455: if (NULL == *argv)
1456: return((*tree->cb.roffout)(tree->arg, tok));
1.1 kristaps 1457:
1.2 kristaps 1458: if ( ! (ROFF_PARSED & tokens[tok].flags)) {
1.21 kristaps 1459: i = 0;
1.37 kristaps 1460: while (*argv)
1461: if ( ! roffdata(tree, i++, *argv++))
1.14 kristaps 1462: return(0);
1.15 kristaps 1463: return((*tree->cb.roffout)(tree->arg, tok));
1.2 kristaps 1464: }
1.1 kristaps 1465:
1.27 kristaps 1466: /*
1467: * Deal with punctuation. Ugly. Work ahead until we encounter
1468: * terminating punctuation. If we encounter it and all
1469: * subsequent tokens are punctuation, then stop processing (the
1470: * line-dominant macro will print these tokens after closure).
1.49 kristaps 1471: * If the punctuation is followed by non-punctuation, then close
1472: * and re-open our scope, then continue.
1.27 kristaps 1473: */
1474:
1.21 kristaps 1475: i = 0;
1.2 kristaps 1476: while (*argv) {
1.33 kristaps 1477: if (ROFF_MAX != (c = rofffindcallable(*argv))) {
1478: if ( ! (ROFF_LSCOPE & tokens[tok].flags))
1479: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1480: return(0);
1481:
1482: if ( ! roffcall(tree, c, argv))
1483: return(0);
1484: if (ROFF_LSCOPE & tokens[tok].flags)
1485: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1.27 kristaps 1486: return(0);
1.33 kristaps 1487: break;
1488: }
1.21 kristaps 1489:
1.33 kristaps 1490: if ( ! roffispunct(*argv)) {
1.37 kristaps 1491: if ( ! roffdata(tree, i++, *argv++))
1.33 kristaps 1492: return(0);
1493: continue;
1494: }
1.27 kristaps 1495:
1.33 kristaps 1496: i = 1;
1497: for (j = 0; argv[j]; j++)
1498: if ( ! roffispunct(argv[j]))
1499: break;
1.27 kristaps 1500:
1.33 kristaps 1501: if (argv[j]) {
1.49 kristaps 1502: if (ROFF_LSCOPE & tokens[tok].flags) {
1503: if ( ! roffdata(tree, 0, *argv++))
1504: return(0);
1505: continue;
1506: }
1507: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1508: return(0);
1.37 kristaps 1509: if ( ! roffdata(tree, 0, *argv++))
1.27 kristaps 1510: return(0);
1.50 kristaps 1511: if ( ! (*tree->cb.roffin)(tree->arg, tok,
1512: argcp,
1513: (const char **)argvp))
1.49 kristaps 1514: return(0);
1515:
1516: i = 0;
1.33 kristaps 1517: continue;
1.8 kristaps 1518: }
1.20 kristaps 1519:
1.33 kristaps 1520: if ( ! (*tree->cb.roffout)(tree->arg, tok))
1.14 kristaps 1521: return(0);
1.20 kristaps 1522: break;
1.14 kristaps 1523: }
1.12 kristaps 1524:
1.27 kristaps 1525: if (NULL == *argv)
1526: return((*tree->cb.roffout)(tree->arg, tok));
1527: if ( ! first)
1528: return(1);
1.21 kristaps 1529:
1.31 kristaps 1530: return(roffpurgepunct(tree, argv));
1.6 kristaps 1531: }
1532:
1533:
1.9 kristaps 1534: /* ARGSUSED */
1.6 kristaps 1535: static int
1.27 kristaps 1536: roff_noop(ROFFCALL_ARGS)
1.6 kristaps 1537: {
1538:
1539: return(1);
1.1 kristaps 1540: }
1.9 kristaps 1541:
1542:
1543: /* ARGSUSED */
1544: static int
1.27 kristaps 1545: roff_depr(ROFFCALL_ARGS)
1.9 kristaps 1546: {
1547:
1.55 kristaps 1548: return(roff_errp(tree, *argv, tok, ERR_DEPREC));
1549: }
1550:
1551:
1552: static int
1553: roff_warnp(const struct rofftree *tree, const char *pos,
1554: int tok, enum rofferr type)
1555: {
1556: char *p;
1557:
1558: switch (type) {
1559: case (WRN_SECORD):
1560: p = "section at `%s' out of order";
1561: break;
1562: default:
1563: abort();
1564: /* NOTREACHED */
1565: }
1566:
1567: return(roff_warn(tree, pos, p, toknames[tok]));
1.11 kristaps 1568: }
1.12 kristaps 1569:
1570:
1.55 kristaps 1571: static int
1.12 kristaps 1572: roff_warn(const struct rofftree *tree, const char *pos, char *fmt, ...)
1573: {
1574: va_list ap;
1575: char buf[128];
1576:
1577: va_start(ap, fmt);
1578: (void)vsnprintf(buf, sizeof(buf), fmt, ap);
1579: va_end(ap);
1580:
1.55 kristaps 1581: return((*tree->cb.roffmsg)(tree->arg,
1582: ROFF_WARN, tree->cur, pos, buf));
1583: }
1584:
1585:
1586: static int
1587: roff_errp(const struct rofftree *tree, const char *pos,
1588: int tok, enum rofferr type)
1589: {
1590: char *p;
1591:
1592: switch (type) {
1593: case (ERR_ARGEQ1):
1594: p = "`%s' expects exactly one argument";
1595: break;
1596: case (ERR_ARGEQ0):
1597: p = "`%s' expects exactly zero arguments";
1598: break;
1599: case (ERR_ARGGE1):
1600: p = "`%s' expects one or more arguments";
1601: break;
1602: case (ERR_ARGGE2):
1603: p = "`%s' expects two or more arguments";
1604: break;
1605: case (ERR_BADARG):
1606: p = "invalid argument for `%s'";
1607: break;
1608: case (ERR_NOTSUP):
1609: p = "macro `%s' is not supported";
1610: break;
1611: case(ERR_PR_OOO):
1612: p = "prelude macro `%s' is out of order";
1613: break;
1614: case(ERR_PR_REP):
1615: p = "prelude macro `%s' repeated";
1616: break;
1617: case(ERR_ARGLEN):
1618: p = "macro argument for `%s' is too long";
1619: break;
1620: case(ERR_DEPREC):
1621: p = "macro `%s' is deprecated";
1622: break;
1623: case(ERR_NOT_PR):
1624: p = "macro `%s' disallowed in prelude";
1625: break;
1626: case(ERR_ARGMNY):
1627: p = "too many arguments for macro `%s'";
1628: break;
1629: default:
1630: abort();
1631: /* NOTREACHED */
1632: }
1633:
1634: return(roff_err(tree, pos, p, toknames[tok]));
1.12 kristaps 1635: }
1636:
1637:
1.55 kristaps 1638: static int
1.12 kristaps 1639: roff_err(const struct rofftree *tree, const char *pos, char *fmt, ...)
1640: {
1641: va_list ap;
1642: char buf[128];
1643:
1644: va_start(ap, fmt);
1.55 kristaps 1645: if (-1 == vsnprintf(buf, sizeof(buf), fmt, ap))
1646: err(1, "vsnprintf");
1.12 kristaps 1647: va_end(ap);
1648:
1.55 kristaps 1649: return((*tree->cb.roffmsg)
1650: (tree->arg, ROFF_ERROR, tree->cur, pos, buf));
1.12 kristaps 1651: }
1.33 kristaps 1652:
CVSweb