1 /* $Id: mdoc.c,v 1.31 2009/10/27 21:40:07 schwarze Exp $ */
3 * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <sys/types.h>
28 const char *const __mdoc_merrnames[MERRMAX] = {
29 "trailing whitespace", /* ETAILWS */
30 "unexpected quoted parameter", /* EQUOTPARM */
31 "unterminated quoted parameter", /* EQUOTTERM */
32 "system: malloc error", /* EMALLOC */
33 "argument parameter suggested", /* EARGVAL */
34 "macro disallowed in prologue", /* EBODYPROL */
35 "macro disallowed in body", /* EPROLBODY */
36 "text disallowed in prologue", /* ETEXTPROL */
37 "blank line disallowed", /* ENOBLANK */
38 "text parameter too long", /* ETOOLONG */
39 "invalid escape sequence", /* EESCAPE */
40 "invalid character", /* EPRINT */
41 "document has no body", /* ENODAT */
42 "document has no prologue", /* ENOPROLOGUE */
43 "expected line arguments", /* ELINE */
44 "invalid AT&T argument", /* EATT */
45 "default name not yet set", /* ENAME */
46 "missing list type", /* ELISTTYPE */
47 "missing display type", /* EDISPTYPE */
48 "too many display types", /* EMULTIDISP */
49 "too many list types", /* EMULTILIST */
50 "NAME section must be first", /* ESECNAME */
51 "badly-formed NAME section", /* ENAMESECINC */
52 "argument repeated", /* EARGREP */
53 "expected boolean parameter", /* EBOOL */
54 "inconsistent column syntax", /* ECOLMIS */
55 "nested display invalid", /* ENESTDISP */
56 "width argument missing", /* EMISSWIDTH */
57 "invalid section for this manual section", /* EWRONGMSEC */
58 "section out of conventional order", /* ESECOOO */
59 "section repeated", /* ESECREP */
60 "invalid standard argument", /* EBADSTAND */
61 "multi-line arguments discouraged", /* ENOMULTILINE */
62 "multi-line arguments suggested", /* EMULTILINE */
63 "line arguments discouraged", /* ENOLINE */
64 "prologue macro out of conventional order", /* EPROLOOO */
65 "prologue macro repeated", /* EPROLREP */
66 "invalid manual section", /* EBADMSEC */
67 "invalid section", /* EBADSEC */
68 "invalid font mode", /* EFONT */
69 "invalid date syntax", /* EBADDATE */
70 "invalid number format", /* ENUMFMT */
71 "superfluous width argument", /* ENOWIDTH */
72 "system: utsname error", /* EUTSNAME */
73 "obsolete macro", /* EOBS */
74 "end-of-line scope violation", /* EIMPBRK */
75 "empty macro ignored", /* EIGNE */
76 "unclosed explicit scope", /* EOPEN */
77 "unterminated quoted phrase", /* EQUOTPHR */
78 "closure macro without prior context", /* ENOCTX */
79 "no description found for library", /* ELIB */
80 "bad child for parent context", /* EBADCHILD */
81 "list arguments preceding type", /* ENOTYPE */
84 const char *const __mdoc_macronames[MDOC_MAX] = {
85 "Ap", "Dd", "Dt", "Os",
86 "Sh", "Ss", "Pp", "D1",
87 "Dl", "Bd", "Ed", "Bl",
88 "El", "It", "Ad", "An",
89 "Ar", "Cd", "Cm", "Dv",
90 "Er", "Ev", "Ex", "Fa",
91 "Fd", "Fl", "Fn", "Ft",
92 "Ic", "In", "Li", "Nd",
93 "Nm", "Op", "Ot", "Pa",
94 "Rv", "St", "Va", "Vt",
96 "Xr", "\%A", "\%B", "\%D",
98 "\%I", "\%J", "\%N", "\%O",
100 "\%P", "\%R", "\%T", "\%V",
101 "Ac", "Ao", "Aq", "At",
102 "Bc", "Bf", "Bo", "Bq",
103 "Bsx", "Bx", "Db", "Dc",
104 "Do", "Dq", "Ec", "Ef",
105 "Em", "Eo", "Fx", "Ms",
106 "No", "Ns", "Nx", "Ox",
107 "Pc", "Pf", "Po", "Pq",
108 "Qc", "Ql", "Qo", "Qq",
109 "Re", "Rs", "Sc", "So",
110 "Sq", "Sm", "Sx", "Sy",
111 "Tn", "Ux", "Xc", "Xo",
112 "Fo", "Fc", "Oo", "Oc",
113 "Bk", "Ek", "Bt", "Hf",
114 "Fr", "Ud", "Lb", "Lp",
115 "Lk", "Mt", "Brq", "Bro",
117 "Brc", "\%C", "Es", "En",
119 "Dx", "\%Q", "br", "sp",
124 const char *const __mdoc_argnames[MDOC_ARG_MAX] = {
125 "split", "nosplit", "ragged",
126 "unfilled", "literal", "file",
127 "offset", "bullet", "dash",
128 "hyphen", "item", "enum",
129 "tag", "diag", "hang",
130 "ohang", "inset", "column",
131 "width", "compact", "std",
132 "filled", "words", "emphasis",
133 "symbolic", "nested", "centered"
136 const char * const *mdoc_macronames = __mdoc_macronames;
137 const char * const *mdoc_argnames = __mdoc_argnames;
139 static void mdoc_free1(struct mdoc *);
140 static int mdoc_alloc1(struct mdoc *);
141 static struct mdoc_node *node_alloc(struct mdoc *, int, int,
142 int, enum mdoc_type);
143 static int node_append(struct mdoc *,
145 static int parsetext(struct mdoc *, int, char *);
146 static int parsemacro(struct mdoc *, int, char *);
147 static int macrowarn(struct mdoc *, int, const char *);
148 static int pstring(struct mdoc *, int, int,
149 const char *, size_t);
152 const struct mdoc_node *
153 mdoc_node(const struct mdoc *m)
156 return(MDOC_HALT & m->flags ? NULL : m->first);
160 const struct mdoc_meta *
161 mdoc_meta(const struct mdoc *m)
164 return(MDOC_HALT & m->flags ? NULL : &m->meta);
169 * Frees volatile resources (parse tree, meta-data, fields).
172 mdoc_free1(struct mdoc *mdoc)
176 mdoc_node_freelist(mdoc->first);
177 if (mdoc->meta.title)
178 free(mdoc->meta.title);
182 free(mdoc->meta.name);
184 free(mdoc->meta.arch);
186 free(mdoc->meta.vol);
191 * Allocate all volatile resources (parse tree, meta-data, fields).
194 mdoc_alloc1(struct mdoc *mdoc)
197 bzero(&mdoc->meta, sizeof(struct mdoc_meta));
199 mdoc->lastnamed = mdoc->lastsec = SEC_NONE;
200 mdoc->last = calloc(1, sizeof(struct mdoc_node));
201 if (NULL == mdoc->last)
204 mdoc->first = mdoc->last;
205 mdoc->last->type = MDOC_ROOT;
206 mdoc->next = MDOC_NEXT_CHILD;
212 * Free up volatile resources (see mdoc_free1()) then re-initialises the
213 * data with mdoc_alloc1(). After invocation, parse data has been reset
214 * and the parser is ready for re-invocation on a new tree; however,
215 * cross-parse non-volatile data is kept intact.
218 mdoc_reset(struct mdoc *mdoc)
222 return(mdoc_alloc1(mdoc));
227 * Completely free up all volatile and non-volatile parse resources.
228 * After invocation, the pointer is no longer usable.
231 mdoc_free(struct mdoc *mdoc)
240 * Allocate volatile and non-volatile parse resources.
243 mdoc_alloc(void *data, int pflags, const struct mdoc_cb *cb)
247 if (NULL == (p = calloc(1, sizeof(struct mdoc))))
250 (void)memcpy(&p->cb, cb, sizeof(struct mdoc_cb));
266 * Climb back up the parse tree, validating open scopes. Mostly calls
267 * through to macro_end() in macro.c.
270 mdoc_endparse(struct mdoc *m)
273 if (MDOC_HALT & m->flags)
275 else if (mdoc_macroend(m))
277 m->flags |= MDOC_HALT;
283 * Main parse routine. Parses a single line -- really just hands off to
284 * the macro (parsemacro()) or text parser (parsetext()).
287 mdoc_parseln(struct mdoc *m, int ln, char *buf)
290 if (MDOC_HALT & m->flags)
293 return('.' == *buf ? parsemacro(m, ln, buf) :
294 parsetext(m, ln, buf));
299 mdoc_verr(struct mdoc *mdoc, int ln, int pos,
300 const char *fmt, ...)
305 if (NULL == mdoc->cb.mdoc_err)
309 (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
312 return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));
317 mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...)
322 if (NULL == mdoc->cb.mdoc_warn)
326 (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
329 return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf));
334 mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type)
338 p = __mdoc_merrnames[(int)type];
342 return(mdoc_verr(m, line, pos, p));
344 return(mdoc_vwarn(m, line, pos, p));
349 mdoc_macro(struct mdoc *m, int tok,
350 int ln, int pp, int *pos, char *buf)
353 * If we're in the prologue, deny "body" macros. Similarly, if
354 * we're in the body, deny prologue calls.
356 if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&
357 MDOC_PBODY & m->flags)
358 return(mdoc_perr(m, ln, pp, EPROLBODY));
359 if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&
360 ! (MDOC_PBODY & m->flags))
361 return(mdoc_perr(m, ln, pp, EBODYPROL));
363 return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
368 node_append(struct mdoc *mdoc, struct mdoc_node *p)
373 assert(MDOC_ROOT != p->type);
375 switch (mdoc->next) {
376 case (MDOC_NEXT_SIBLING):
377 mdoc->last->next = p;
378 p->prev = mdoc->last;
379 p->parent = mdoc->last->parent;
381 case (MDOC_NEXT_CHILD):
382 mdoc->last->child = p;
383 p->parent = mdoc->last;
392 if ( ! mdoc_valid_pre(mdoc, p))
394 if ( ! mdoc_action_pre(mdoc, p))
399 assert(MDOC_BLOCK == p->parent->type);
403 assert(MDOC_BLOCK == p->parent->type);
407 assert(MDOC_BLOCK == p->parent->type);
418 if ( ! mdoc_valid_post(mdoc))
420 if ( ! mdoc_action_post(mdoc))
431 static struct mdoc_node *
432 node_alloc(struct mdoc *m, int line,
433 int pos, int tok, enum mdoc_type type)
437 if (NULL == (p = calloc(1, sizeof(struct mdoc_node)))) {
438 (void)mdoc_nerr(m, m->last, EMALLOC);
446 if (MDOC_TEXT != (p->type = type))
454 mdoc_tail_alloc(struct mdoc *m, int line, int pos, int tok)
458 p = node_alloc(m, line, pos, tok, MDOC_TAIL);
461 if ( ! node_append(m, p))
463 m->next = MDOC_NEXT_CHILD;
469 mdoc_head_alloc(struct mdoc *m, int line, int pos, int tok)
476 p = node_alloc(m, line, pos, tok, MDOC_HEAD);
479 if ( ! node_append(m, p))
481 m->next = MDOC_NEXT_CHILD;
487 mdoc_body_alloc(struct mdoc *m, int line, int pos, int tok)
491 p = node_alloc(m, line, pos, tok, MDOC_BODY);
494 if ( ! node_append(m, p))
496 m->next = MDOC_NEXT_CHILD;
502 mdoc_block_alloc(struct mdoc *m, int line, int pos,
503 int tok, struct mdoc_arg *args)
507 p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
513 if ( ! node_append(m, p))
515 m->next = MDOC_NEXT_CHILD;
521 mdoc_elem_alloc(struct mdoc *m, int line, int pos,
522 int tok, struct mdoc_arg *args)
526 p = node_alloc(m, line, pos, tok, MDOC_ELEM);
532 if ( ! node_append(m, p))
534 m->next = MDOC_NEXT_CHILD;
540 pstring(struct mdoc *m, int line, int pos, const char *p, size_t len)
545 n = node_alloc(m, line, pos, -1, MDOC_TEXT);
547 return(mdoc_nerr(m, m->last, EMALLOC));
549 n->string = malloc(len + 1);
550 if (NULL == n->string) {
552 return(mdoc_nerr(m, m->last, EMALLOC));
555 sv = strlcpy(n->string, p, len + 1);
557 /* Prohibit truncation. */
558 assert(sv < len + 1);
560 if ( ! node_append(m, n))
562 m->next = MDOC_NEXT_SIBLING;
568 mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
571 return(pstring(m, line, pos, p, strlen(p)));
576 mdoc_node_free(struct mdoc_node *p)
584 mdoc_argv_free(p->args);
590 mdoc_node_freelist(struct mdoc_node *p)
594 mdoc_node_freelist(p->child);
596 mdoc_node_freelist(p->next);
598 assert(0 == p->nchild);
604 * Parse free-form text, that is, a line that does not begin with the
608 parsetext(struct mdoc *m, int line, char *buf)
612 if (SEC_NONE == m->lastnamed)
613 return(mdoc_perr(m, line, 0, ETEXTPROL));
616 * If in literal mode, then pass the buffer directly to the
617 * back-end, as it should be preserved as a single term.
620 if (MDOC_LITERAL & m->flags)
621 return(mdoc_word_alloc(m, line, 0, buf));
623 /* Disallow blank/white-space lines in non-literal mode. */
625 for (i = 0; ' ' == buf[i]; i++)
626 /* Skip leading whitespace. */ ;
628 return(mdoc_perr(m, line, 0, ENOBLANK));
631 * Break apart a free-form line into tokens. Spaces are
632 * stripped out of the input.
635 for (j = i; buf[i]; i++) {
639 /* Escaped whitespace. */
640 if (i && ' ' == buf[i] && '\\' == buf[i - 1])
644 if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
647 for ( ; ' ' == buf[i]; i++)
648 /* Skip trailing whitespace. */ ;
655 if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
658 m->next = MDOC_NEXT_SIBLING;
665 macrowarn(struct mdoc *m, int ln, const char *buf)
667 if ( ! (MDOC_IGN_MACRO & m->pflags))
668 return(mdoc_verr(m, ln, 0,
669 "unknown macro: %s%s",
670 buf, strlen(buf) > 3 ? "..." : ""));
671 return(mdoc_vwarn(m, ln, 0, "unknown macro: %s%s",
672 buf, strlen(buf) > 3 ? "..." : ""));
677 * Parse a macro line, that is, a line beginning with the control
681 parsemacro(struct mdoc *m, int ln, char *buf)
686 /* Empty lines are ignored. */
693 /* Accept whitespace after the initial control char. */
697 while (buf[i] && ' ' == buf[i])
703 /* Copy the first word into a nil-terminated buffer. */
705 for (j = 0; j < 4; j++, i++) {
706 if (0 == (mac[j] = buf[i]))
708 else if (' ' == buf[i])
711 /* Check for invalid characters. */
713 if (isgraph((u_char)buf[i]))
715 return(mdoc_perr(m, ln, i, EPRINT));
720 if (j == 4 || j < 2) {
721 if ( ! macrowarn(m, ln, mac))
726 if (MDOC_MAX == (c = mdoc_hash_find(mac))) {
727 if ( ! macrowarn(m, ln, mac))
732 /* The macro is sane. Jump to the next word. */
734 while (buf[i] && ' ' == buf[i])
738 * Begin recursive parse sequence. Since we're at the start of
739 * the line, we don't need to do callable/parseable checks.
741 if ( ! mdoc_macro(m, c, ln, 1, &i, buf))
746 err: /* Error out. */
748 m->flags |= MDOC_HALT;