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