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