1 /* $Id: man.c,v 1.49 2010/01/07 10:24:43 kristaps 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>
27 #include "libmandoc.h"
29 const char *const __man_merrnames
[WERRMAX
] = {
30 "invalid character", /* WNPRINT */
31 "invalid manual section", /* WMSEC */
32 "invalid date format", /* WDATE */
33 "scope of prior line violated", /* WLNSCOPE */
34 "trailing whitespace", /* WTSPACE */
35 "unterminated quoted parameter", /* WTQUOTE */
36 "document has no body", /* WNODATA */
37 "document has no title/section", /* WNOTITLE */
38 "invalid escape sequence", /* WESCAPE */
39 "invalid number format", /* WNUMFMT */
40 "expected block head arguments", /* WHEADARGS */
41 "expected block body arguments", /* WBODYARGS */
42 "expected empty block head", /* WNHEADARGS */
43 "ill-formed macro", /* WMACROFORM */
44 "scope open on exit", /* WEXITSCOPE */
45 "no scope context", /* WNOSCOPE */
46 "literal context already open", /* WOLITERAL */
47 "no literal context open" /* WNLITERAL */
50 const char *const __man_macronames
[MAN_MAX
] = {
51 "br", "TH", "SH", "SS",
52 "TP", "LP", "PP", "P",
53 "IP", "HP", "SM", "SB",
54 "BI", "IB", "BR", "RB",
56 "RI", "na", "i", "sp",
57 "nf", "fi", "r", "RE",
58 "RS", "DT", "UC", "PD"
61 const char * const *man_macronames
= __man_macronames
;
63 static struct man_node
*man_node_alloc(int, int,
65 static int man_node_append(struct man
*,
67 static int man_ptext(struct man
*, int, char *);
68 static int man_pmacro(struct man
*, int, char *);
69 static void man_free1(struct man
*);
70 static void man_alloc1(struct man
*);
71 static int pstring(struct man
*, int, int,
72 const char *, size_t);
73 static int macrowarn(struct man
*, int, const char *);
76 const struct man_node
*
77 man_node(const struct man
*m
)
80 return(MAN_HALT
& m
->flags
? NULL
: m
->first
);
84 const struct man_meta
*
85 man_meta(const struct man
*m
)
88 return(MAN_HALT
& m
->flags
? NULL
: &m
->meta
);
93 man_reset(struct man
*man
)
102 man_free(struct man
*man
)
111 man_alloc(void *data
, int pflags
, const struct man_cb
*cb
)
115 p
= mandoc_calloc(1, sizeof(struct man
));
118 memcpy(&p
->cb
, cb
, sizeof(struct man_cb
));
130 man_endparse(struct man
*m
)
133 if (MAN_HALT
& m
->flags
)
135 else if (man_macroend(m
))
137 m
->flags
|= MAN_HALT
;
143 man_parseln(struct man
*m
, int ln
, char *buf
)
147 man_pmacro(m
, ln
, buf
) :
148 man_ptext(m
, ln
, buf
));
153 man_free1(struct man
*man
)
157 man_node_freelist(man
->first
);
159 free(man
->meta
.title
);
160 if (man
->meta
.source
)
161 free(man
->meta
.source
);
168 man_alloc1(struct man
*m
)
171 memset(&m
->meta
, 0, sizeof(struct man_meta
));
173 m
->last
= mandoc_calloc(1, sizeof(struct man_node
));
175 m
->last
->type
= MAN_ROOT
;
176 m
->next
= MAN_NEXT_CHILD
;
181 man_node_append(struct man
*man
, struct man_node
*p
)
186 assert(MAN_ROOT
!= p
->type
);
189 case (MAN_NEXT_SIBLING
):
192 p
->parent
= man
->last
->parent
;
194 case (MAN_NEXT_CHILD
):
195 man
->last
->child
= p
;
196 p
->parent
= man
->last
;
205 if ( ! man_valid_pre(man
, p
))
210 assert(MAN_BLOCK
== p
->parent
->type
);
214 assert(MAN_BLOCK
== p
->parent
->type
);
225 if ( ! man_valid_post(man
))
227 if ( ! man_action_post(man
))
238 static struct man_node
*
239 man_node_alloc(int line
, int pos
, enum man_type type
, int tok
)
243 p
= mandoc_calloc(1, sizeof(struct man_node
));
253 man_elem_alloc(struct man
*m
, int line
, int pos
, int tok
)
257 p
= man_node_alloc(line
, pos
, MAN_ELEM
, tok
);
258 if ( ! man_node_append(m
, p
))
260 m
->next
= MAN_NEXT_CHILD
;
266 man_head_alloc(struct man
*m
, int line
, int pos
, int tok
)
270 p
= man_node_alloc(line
, pos
, MAN_HEAD
, tok
);
271 if ( ! man_node_append(m
, p
))
273 m
->next
= MAN_NEXT_CHILD
;
279 man_body_alloc(struct man
*m
, int line
, int pos
, int tok
)
283 p
= man_node_alloc(line
, pos
, MAN_BODY
, tok
);
284 if ( ! man_node_append(m
, p
))
286 m
->next
= MAN_NEXT_CHILD
;
292 man_block_alloc(struct man
*m
, int line
, int pos
, int tok
)
296 p
= man_node_alloc(line
, pos
, MAN_BLOCK
, tok
);
297 if ( ! man_node_append(m
, p
))
299 m
->next
= MAN_NEXT_CHILD
;
305 pstring(struct man
*m
, int line
, int pos
,
306 const char *p
, size_t len
)
311 n
= man_node_alloc(line
, pos
, MAN_TEXT
, -1);
312 n
->string
= mandoc_malloc(len
+ 1);
313 sv
= strlcpy(n
->string
, p
, len
+ 1);
315 /* Prohibit truncation. */
316 assert(sv
< len
+ 1);
318 if ( ! man_node_append(m
, n
))
320 m
->next
= MAN_NEXT_SIBLING
;
326 man_word_alloc(struct man
*m
, int line
, int pos
, const char *word
)
329 return(pstring(m
, line
, pos
, word
, strlen(word
)));
334 man_node_free(struct man_node
*p
)
346 man_node_freelist(struct man_node
*p
)
351 man_node_freelist(p
->child
);
352 assert(0 == p
->nchild
);
356 man_node_freelist(n
);
361 man_ptext(struct man
*m
, int line
, char *buf
)
366 /* Literal free-form text whitespace is preserved. */
368 if (MAN_LITERAL
& m
->flags
) {
369 if ( ! man_word_alloc(m
, line
, 0, buf
))
374 /* First de-chunk and allocate words. */
376 for (i
= 0; ' ' == buf
[i
]; i
++)
377 /* Skip leading whitespace. */ ;
379 if ('\0' == buf
[i
]) {
380 /* Trailing whitespace? */
381 if (i
&& ' ' == buf
[i
- 1])
382 if ( ! man_pwarn(m
, line
, i
- 1, WTSPACE
))
384 if ( ! pstring(m
, line
, 0, &buf
[i
], 0))
389 for (j
= i
; buf
[i
]; i
++) {
393 /* Escaped whitespace. */
394 if (i
&& ' ' == buf
[i
] && '\\' == buf
[i
- 1])
400 if ( ! pstring(m
, line
, j
, &buf
[j
], (size_t)(i
- j
)))
403 /* Trailing whitespace? Check at overwritten byte. */
405 if (' ' == sv
&& '\0' == buf
[i
])
406 if ( ! man_pwarn(m
, line
, i
- 1, WTSPACE
))
409 for ( ; ' ' == buf
[i
]; i
++)
410 /* Skip trailing whitespace. */ ;
414 /* Trailing whitespace? */
416 if (' ' == buf
[i
- 1] && '\0' == buf
[i
])
417 if ( ! man_pwarn(m
, line
, i
- 1, WTSPACE
))
424 if (j
!= i
&& ! pstring(m
, line
, j
, &buf
[j
], (size_t)(i
- j
)))
430 * Co-ordinate what happens with having a next-line scope open:
431 * first close out the element scope (if applicable), then close
432 * out the block scope (also if applicable).
435 if (MAN_ELINE
& m
->flags
) {
436 m
->flags
&= ~MAN_ELINE
;
437 if ( ! man_unscope(m
, m
->last
->parent
))
441 if ( ! (MAN_BLINE
& m
->flags
))
443 m
->flags
&= ~MAN_BLINE
;
445 if ( ! man_unscope(m
, m
->last
->parent
))
447 return(man_body_alloc(m
, line
, 0, m
->last
->tok
));
452 macrowarn(struct man
*m
, int ln
, const char *buf
)
454 if ( ! (MAN_IGN_MACRO
& m
->pflags
))
455 return(man_verr(m
, ln
, 0,
456 "unknown macro: %s%s",
457 buf
, strlen(buf
) > 3 ? "..." : ""));
458 return(man_vwarn(m
, ln
, 0, "unknown macro: %s%s",
459 buf
, strlen(buf
) > 3 ? "..." : ""));
464 man_pmacro(struct man
*m
, int ln
, char *buf
)
466 int i
, j
, c
, ppos
, fl
;
470 /* Comments and empties are quickly ignored. */
481 while (buf
[i
] && ' ' == buf
[i
])
489 /* Copy the first word into a nil-terminated buffer. */
491 for (j
= 0; j
< 4; j
++, i
++) {
492 if ('\0' == (mac
[j
] = buf
[i
]))
494 else if (' ' == buf
[i
])
497 /* Check for invalid characters. */
499 if (isgraph((u_char
)buf
[i
]))
501 return(man_perr(m
, ln
, i
, WNPRINT
));
506 if (j
== 4 || j
< 1) {
507 if ( ! (MAN_IGN_MACRO
& m
->pflags
)) {
508 (void)man_perr(m
, ln
, ppos
, WMACROFORM
);
511 if ( ! man_pwarn(m
, ln
, ppos
, WMACROFORM
))
516 if (MAN_MAX
== (c
= man_hash_find(mac
))) {
517 if ( ! macrowarn(m
, ln
, mac
))
522 /* The macro is sane. Jump to the next word. */
524 while (buf
[i
] && ' ' == buf
[i
])
527 /* Trailing whitespace? */
529 if ('\0' == buf
[i
] && ' ' == buf
[i
- 1])
530 if ( ! man_pwarn(m
, ln
, i
- 1, WTSPACE
))
533 /* Remove prior ELINE macro, if applicable. */
535 if (m
->flags
& MAN_ELINE
) {
537 assert(NULL
== n
->child
);
538 assert(0 == n
->nchild
);
539 if ( ! man_nwarn(m
, n
, WLNSCOPE
))
543 assert(n
!= n
->parent
->child
);
544 assert(n
== n
->prev
->next
);
545 n
->prev
->next
= NULL
;
547 m
->next
= MAN_NEXT_SIBLING
;
549 assert(n
== n
->parent
->child
);
550 n
->parent
->child
= NULL
;
552 m
->next
= MAN_NEXT_CHILD
;
556 m
->flags
&= ~MAN_ELINE
;
559 /* Begin recursive parse sequence. */
561 assert(man_macros
[c
].fp
);
563 if ( ! (*man_macros
[c
].fp
)(m
, c
, ln
, ppos
, &i
, buf
))
567 if ( ! (MAN_BLINE
& fl
))
571 * If we've opened a new next-line element scope, then return
572 * now, as the next line will close out the block scope.
575 if (MAN_ELINE
& m
->flags
)
578 /* Close out the block scope opened in the prior line. */
580 assert(MAN_BLINE
& m
->flags
);
581 m
->flags
&= ~MAN_BLINE
;
583 if ( ! man_unscope(m
, m
->last
->parent
))
585 return(man_body_alloc(m
, ln
, 0, m
->last
->tok
));
587 err
: /* Error out. */
589 m
->flags
|= MAN_HALT
;
595 man_verr(struct man
*man
, int ln
, int pos
, const char *fmt
, ...)
600 if (NULL
== man
->cb
.man_err
)
604 (void)vsnprintf(buf
, sizeof(buf
) - 1, fmt
, ap
);
606 return((*man
->cb
.man_err
)(man
->data
, ln
, pos
, buf
));
611 man_vwarn(struct man
*man
, int ln
, int pos
, const char *fmt
, ...)
616 if (NULL
== man
->cb
.man_warn
)
620 (void)vsnprintf(buf
, sizeof(buf
) - 1, fmt
, ap
);
622 return((*man
->cb
.man_warn
)(man
->data
, ln
, pos
, buf
));
627 man_err(struct man
*m
, int line
, int pos
, int iserr
, enum merr type
)
631 p
= __man_merrnames
[(int)type
];
635 return(man_verr(m
, line
, pos
, p
));
637 return(man_vwarn(m
, line
, pos
, p
));