1 /* $Id: read.c,v 1.192 2017/07/20 14:36:36 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010-2017 Ingo Schwarze <schwarze@openbsd.org>
5 * Copyright (c) 2010, 2012 Joerg Sonnenberger <joerg@netbsd.org>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19 #include "config.h"
20
21 #include <sys/types.h>
22 #include <sys/mman.h>
23 #include <sys/stat.h>
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <zlib.h>
35
36 #include "mandoc_aux.h"
37 #include "mandoc.h"
38 #include "roff.h"
39 #include "mdoc.h"
40 #include "man.h"
41 #include "libmandoc.h"
42
43 #define REPARSE_LIMIT 1000
44
45 struct mparse {
46 struct roff *roff; /* roff parser (!NULL) */
47 struct roff_man *man; /* man parser */
48 char *sodest; /* filename pointed to by .so */
49 const char *file; /* filename of current input file */
50 struct buf *primary; /* buffer currently being parsed */
51 struct buf *secondary; /* preprocessed copy of input */
52 const char *os_s; /* default operating system */
53 mandocmsg mmsg; /* warning/error message handler */
54 enum mandoclevel file_status; /* status of current parse */
55 enum mandocerr mmin; /* ignore messages below this */
56 int options; /* parser options */
57 int gzip; /* current input file is gzipped */
58 int filenc; /* encoding of the current file */
59 int reparse_count; /* finite interp. stack */
60 int line; /* line number in the file */
61 };
62
63 static void choose_parser(struct mparse *);
64 static void resize_buf(struct buf *, size_t);
65 static int mparse_buf_r(struct mparse *, struct buf, size_t, int);
66 static int read_whole_file(struct mparse *, const char *, int,
67 struct buf *, int *);
68 static void mparse_end(struct mparse *);
69 static void mparse_parse_buffer(struct mparse *, struct buf,
70 const char *);
71
72 static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = {
73 MANDOCERR_OK,
74 MANDOCERR_OK,
75 MANDOCERR_WARNING,
76 MANDOCERR_ERROR,
77 MANDOCERR_UNSUPP,
78 MANDOCERR_MAX,
79 MANDOCERR_MAX
80 };
81
82 static const char * const mandocerrs[MANDOCERR_MAX] = {
83 "ok",
84
85 "base system convention",
86
87 "Mdocdate found",
88 "Mdocdate missing",
89 "unknown architecture",
90 "operating system explicitly specified",
91 "RCS id missing",
92 "referenced manual not found",
93
94 "generic style suggestion",
95
96 "legacy man(7) date format",
97 "lower case character in document title",
98 "duplicate RCS id",
99 "typo in section name",
100 "unterminated quoted argument",
101 "useless macro",
102 "consider using OS macro",
103 "errnos out of order",
104 "duplicate errno",
105 "trailing delimiter",
106 "no blank before trailing delimiter",
107 "fill mode already enabled, skipping",
108 "fill mode already disabled, skipping",
109 "function name without markup",
110 "whitespace at end of input line",
111 "bad comment style",
112
113 "generic warning",
114
115 /* related to the prologue */
116 "missing manual title, using UNTITLED",
117 "missing manual title, using \"\"",
118 "missing manual section, using \"\"",
119 "unknown manual section",
120 "missing date, using today's date",
121 "cannot parse date, using it verbatim",
122 "date in the future, using it anyway",
123 "missing Os macro, using \"\"",
124 "late prologue macro",
125 "prologue macros out of order",
126
127 /* related to document structure */
128 ".so is fragile, better use ln(1)",
129 "no document body",
130 "content before first section header",
131 "first section is not \"NAME\"",
132 "NAME section without Nm before Nd",
133 "NAME section without description",
134 "description not at the end of NAME",
135 "bad NAME section content",
136 "missing comma before name",
137 "missing description line, using \"\"",
138 "description line outside NAME section",
139 "sections out of conventional order",
140 "duplicate section title",
141 "unexpected section",
142 "cross reference to self",
143 "unusual Xr order",
144 "unusual Xr punctuation",
145 "AUTHORS section without An macro",
146
147 /* related to macros and nesting */
148 "obsolete macro",
149 "macro neither callable nor escaped",
150 "skipping paragraph macro",
151 "moving paragraph macro out of list",
152 "skipping no-space macro",
153 "blocks badly nested",
154 "nested displays are not portable",
155 "moving content out of list",
156 "first macro on line",
157 "line scope broken",
158 "skipping blank line in line scope",
159
160 /* related to missing macro arguments */
161 "skipping empty request",
162 "conditional request controls empty scope",
163 "skipping empty macro",
164 "empty block",
165 "empty argument, using 0n",
166 "missing display type, using -ragged",
167 "list type is not the first argument",
168 "missing -width in -tag list, using 6n",
169 "missing utility name, using \"\"",
170 "missing function name, using \"\"",
171 "empty head in list item",
172 "empty list item",
173 "missing argument, using next line",
174 "missing font type, using \\fR",
175 "unknown font type, using \\fR",
176 "nothing follows prefix",
177 "empty reference block",
178 "missing section argument",
179 "missing -std argument, adding it",
180 "missing option string, using \"\"",
181 "missing resource identifier, using \"\"",
182 "missing eqn box, using \"\"",
183
184 /* related to bad macro arguments */
185 "duplicate argument",
186 "skipping duplicate argument",
187 "skipping duplicate display type",
188 "skipping duplicate list type",
189 "skipping -width argument",
190 "wrong number of cells",
191 "unknown AT&T UNIX version",
192 "comma in function argument",
193 "parenthesis in function name",
194 "unknown library name",
195 "invalid content in Rs block",
196 "invalid Boolean argument",
197 "unknown font, skipping request",
198 "odd number of characters in request",
199
200 /* related to plain text */
201 "blank line in fill mode, using .sp",
202 "tab in filled text",
203 "new sentence, new line",
204 "invalid escape sequence",
205 "undefined string, using \"\"",
206
207 /* related to tables */
208 "tbl line starts with span",
209 "tbl column starts with span",
210 "skipping vertical bar in tbl layout",
211
212 "generic error",
213
214 /* related to tables */
215 "non-alphabetic character in tbl options",
216 "skipping unknown tbl option",
217 "missing tbl option argument",
218 "wrong tbl option argument size",
219 "empty tbl layout",
220 "invalid character in tbl layout",
221 "unmatched parenthesis in tbl layout",
222 "tbl without any data cells",
223 "ignoring data in spanned tbl cell",
224 "ignoring extra tbl data cells",
225 "data block open at end of tbl",
226
227 /* related to document structure and macros */
228 NULL,
229 "duplicate prologue macro",
230 "skipping late title macro",
231 "input stack limit exceeded, infinite loop?",
232 "skipping bad character",
233 "skipping unknown macro",
234 "skipping insecure request",
235 "skipping item outside list",
236 "skipping column outside column list",
237 "skipping end of block that is not open",
238 "fewer RS blocks open, skipping",
239 "inserting missing end of block",
240 "appending missing end of block",
241
242 /* related to request and macro arguments */
243 "escaped character not allowed in a name",
244 "NOT IMPLEMENTED: Bd -file",
245 "skipping display without arguments",
246 "missing list type, using -item",
247 "argument is not numeric, using 1",
248 "missing manual name, using \"\"",
249 "uname(3) system call failed, using UNKNOWN",
250 "unknown standard specifier",
251 "skipping request without numeric argument",
252 "NOT IMPLEMENTED: .so with absolute path or \"..\"",
253 ".so request failed",
254 "skipping all arguments",
255 "skipping excess arguments",
256 "divide by zero",
257
258 "unsupported feature",
259 "input too large",
260 "unsupported control character",
261 "unsupported roff request",
262 "eqn delim option in tbl",
263 "unsupported tbl layout modifier",
264 "ignoring macro in table",
265 };
266
267 static const char * const mandoclevels[MANDOCLEVEL_MAX] = {
268 "SUCCESS",
269 "STYLE",
270 "WARNING",
271 "ERROR",
272 "UNSUPP",
273 "BADARG",
274 "SYSERR"
275 };
276
277
278 static void
279 resize_buf(struct buf *buf, size_t initial)
280 {
281
282 buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial;
283 buf->buf = mandoc_realloc(buf->buf, buf->sz);
284 }
285
286 static void
287 choose_parser(struct mparse *curp)
288 {
289 char *cp, *ep;
290 int format;
291
292 /*
293 * If neither command line arguments -mdoc or -man select
294 * a parser nor the roff parser found a .Dd or .TH macro
295 * yet, look ahead in the main input buffer.
296 */
297
298 if ((format = roff_getformat(curp->roff)) == 0) {
299 cp = curp->primary->buf;
300 ep = cp + curp->primary->sz;
301 while (cp < ep) {
302 if (*cp == '.' || *cp == '\'') {
303 cp++;
304 if (cp[0] == 'D' && cp[1] == 'd') {
305 format = MPARSE_MDOC;
306 break;
307 }
308 if (cp[0] == 'T' && cp[1] == 'H') {
309 format = MPARSE_MAN;
310 break;
311 }
312 }
313 cp = memchr(cp, '\n', ep - cp);
314 if (cp == NULL)
315 break;
316 cp++;
317 }
318 }
319
320 if (format == MPARSE_MDOC) {
321 curp->man->macroset = MACROSET_MDOC;
322 if (curp->man->mdocmac == NULL)
323 curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
324 } else {
325 curp->man->macroset = MACROSET_MAN;
326 if (curp->man->manmac == NULL)
327 curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);
328 }
329 curp->man->first->tok = TOKEN_NONE;
330 }
331
332 /*
333 * Main parse routine for a buffer.
334 * It assumes encoding and line numbering are already set up.
335 * It can recurse directly (for invocations of user-defined
336 * macros, inline equations, and input line traps)
337 * and indirectly (for .so file inclusion).
338 */
339 static int
340 mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
341 {
342 struct buf ln;
343 const char *save_file;
344 char *cp;
345 size_t pos; /* byte number in the ln buffer */
346 enum rofferr rr;
347 int of;
348 int lnn; /* line number in the real file */
349 int fd;
350 unsigned char c;
351
352 memset(&ln, 0, sizeof(ln));
353
354 lnn = curp->line;
355 pos = 0;
356
357 while (i < blk.sz) {
358 if (0 == pos && '\0' == blk.buf[i])
359 break;
360
361 if (start) {
362 curp->line = lnn;
363 curp->reparse_count = 0;
364
365 if (lnn < 3 &&
366 curp->filenc & MPARSE_UTF8 &&
367 curp->filenc & MPARSE_LATIN1)
368 curp->filenc = preconv_cue(&blk, i);
369 }
370
371 while (i < blk.sz && (start || blk.buf[i] != '\0')) {
372
373 /*
374 * When finding an unescaped newline character,
375 * leave the character loop to process the line.
376 * Skip a preceding carriage return, if any.
377 */
378
379 if ('\r' == blk.buf[i] && i + 1 < blk.sz &&
380 '\n' == blk.buf[i + 1])
381 ++i;
382 if ('\n' == blk.buf[i]) {
383 ++i;
384 ++lnn;
385 break;
386 }
387
388 /*
389 * Make sure we have space for the worst
390 * case of 11 bytes: "\\[u10ffff]\0"
391 */
392
393 if (pos + 11 > ln.sz)
394 resize_buf(&ln, 256);
395
396 /*
397 * Encode 8-bit input.
398 */
399
400 c = blk.buf[i];
401 if (c & 0x80) {
402 if ( ! (curp->filenc && preconv_encode(
403 &blk, &i, &ln, &pos, &curp->filenc))) {
404 mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
405 curp->line, pos, "0x%x", c);
406 ln.buf[pos++] = '?';
407 i++;
408 }
409 continue;
410 }
411
412 /*
413 * Exclude control characters.
414 */
415
416 if (c == 0x7f || (c < 0x20 && c != 0x09)) {
417 mandoc_vmsg(c == 0x00 || c == 0x04 ||
418 c > 0x0a ? MANDOCERR_CHAR_BAD :
419 MANDOCERR_CHAR_UNSUPP,
420 curp, curp->line, pos, "0x%x", c);
421 i++;
422 if (c != '\r')
423 ln.buf[pos++] = '?';
424 continue;
425 }
426
427 ln.buf[pos++] = blk.buf[i++];
428 }
429
430 if (pos + 1 >= ln.sz)
431 resize_buf(&ln, 256);
432
433 if (i == blk.sz || blk.buf[i] == '\0')
434 ln.buf[pos++] = '\n';
435 ln.buf[pos] = '\0';
436
437 /*
438 * A significant amount of complexity is contained by
439 * the roff preprocessor. It's line-oriented but can be
440 * expressed on one line, so we need at times to
441 * readjust our starting point and re-run it. The roff
442 * preprocessor can also readjust the buffers with new
443 * data, so we pass them in wholesale.
444 */
445
446 of = 0;
447
448 /*
449 * Maintain a lookaside buffer of all parsed lines. We
450 * only do this if mparse_keep() has been invoked (the
451 * buffer may be accessed with mparse_getkeep()).
452 */
453
454 if (curp->secondary) {
455 curp->secondary->buf = mandoc_realloc(
456 curp->secondary->buf,
457 curp->secondary->sz + pos + 2);
458 memcpy(curp->secondary->buf +
459 curp->secondary->sz,
460 ln.buf, pos);
461 curp->secondary->sz += pos;
462 curp->secondary->buf
463 [curp->secondary->sz] = '\n';
464 curp->secondary->sz++;
465 curp->secondary->buf
466 [curp->secondary->sz] = '\0';
467 }
468 rerun:
469 rr = roff_parseln(curp->roff, curp->line, &ln, &of);
470
471 switch (rr) {
472 case ROFF_REPARSE:
473 if (++curp->reparse_count > REPARSE_LIMIT)
474 mandoc_msg(MANDOCERR_ROFFLOOP, curp,
475 curp->line, pos, NULL);
476 else if (mparse_buf_r(curp, ln, of, 0) == 1 ||
477 start == 1) {
478 pos = 0;
479 continue;
480 }
481 free(ln.buf);
482 return 0;
483 case ROFF_APPEND:
484 pos = strlen(ln.buf);
485 continue;
486 case ROFF_RERUN:
487 goto rerun;
488 case ROFF_IGN:
489 pos = 0;
490 continue;
491 case ROFF_SO:
492 if ( ! (curp->options & MPARSE_SO) &&
493 (i >= blk.sz || blk.buf[i] == '\0')) {
494 curp->sodest = mandoc_strdup(ln.buf + of);
495 free(ln.buf);
496 return 1;
497 }
498 /*
499 * We remove `so' clauses from our lookaside
500 * buffer because we're going to descend into
501 * the file recursively.
502 */
503 if (curp->secondary)
504 curp->secondary->sz -= pos + 1;
505 save_file = curp->file;
506 if ((fd = mparse_open(curp, ln.buf + of)) != -1) {
507 mparse_readfd(curp, fd, ln.buf + of);
508 close(fd);
509 curp->file = save_file;
510 } else {
511 curp->file = save_file;
512 mandoc_vmsg(MANDOCERR_SO_FAIL,
513 curp, curp->line, pos,
514 ".so %s", ln.buf + of);
515 ln.sz = mandoc_asprintf(&cp,
516 ".sp\nSee the file %s.\n.sp",
517 ln.buf + of);
518 free(ln.buf);
519 ln.buf = cp;
520 of = 0;
521 mparse_buf_r(curp, ln, of, 0);
522 }
523 pos = 0;
524 continue;
525 default:
526 break;
527 }
528
529 if (curp->man->macroset == MACROSET_NONE)
530 choose_parser(curp);
531
532 if ((curp->man->macroset == MACROSET_MDOC ?
533 mdoc_parseln(curp->man, curp->line, ln.buf, of) :
534 man_parseln(curp->man, curp->line, ln.buf, of)) == 2)
535 break;
536
537 /* Temporary buffers typically are not full. */
538
539 if (0 == start && '\0' == blk.buf[i])
540 break;
541
542 /* Start the next input line. */
543
544 pos = 0;
545 }
546
547 free(ln.buf);
548 return 1;
549 }
550
551 static int
552 read_whole_file(struct mparse *curp, const char *file, int fd,
553 struct buf *fb, int *with_mmap)
554 {
555 struct stat st;
556 gzFile gz;
557 size_t off;
558 ssize_t ssz;
559
560 if (fstat(fd, &st) == -1) {
561 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
562 "fstat: %s", strerror(errno));
563 return 0;
564 }
565
566 /*
567 * If we're a regular file, try just reading in the whole entry
568 * via mmap(). This is faster than reading it into blocks, and
569 * since each file is only a few bytes to begin with, I'm not
570 * concerned that this is going to tank any machines.
571 */
572
573 if (curp->gzip == 0 && S_ISREG(st.st_mode)) {
574 if (st.st_size > 0x7fffffff) {
575 mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL);
576 return 0;
577 }
578 *with_mmap = 1;
579 fb->sz = (size_t)st.st_size;
580 fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);
581 if (fb->buf != MAP_FAILED)
582 return 1;
583 }
584
585 if (curp->gzip) {
586 if ((gz = gzdopen(fd, "rb")) == NULL) {
587 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
588 "gzdopen: %s", strerror(errno));
589 return 0;
590 }
591 } else
592 gz = NULL;
593
594 /*
595 * If this isn't a regular file (like, say, stdin), then we must
596 * go the old way and just read things in bit by bit.
597 */
598
599 *with_mmap = 0;
600 off = 0;
601 fb->sz = 0;
602 fb->buf = NULL;
603 for (;;) {
604 if (off == fb->sz) {
605 if (fb->sz == (1U << 31)) {
606 mandoc_msg(MANDOCERR_TOOLARGE, curp,
607 0, 0, NULL);
608 break;
609 }
610 resize_buf(fb, 65536);
611 }
612 ssz = curp->gzip ?
613 gzread(gz, fb->buf + (int)off, fb->sz - off) :
614 read(fd, fb->buf + (int)off, fb->sz - off);
615 if (ssz == 0) {
616 fb->sz = off;
617 return 1;
618 }
619 if (ssz == -1) {
620 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
621 "read: %s", strerror(errno));
622 break;
623 }
624 off += (size_t)ssz;
625 }
626
627 free(fb->buf);
628 fb->buf = NULL;
629 return 0;
630 }
631
632 static void
633 mparse_end(struct mparse *curp)
634 {
635 if (curp->man->macroset == MACROSET_NONE)
636 curp->man->macroset = MACROSET_MAN;
637 if (curp->man->macroset == MACROSET_MDOC)
638 mdoc_endparse(curp->man);
639 else
640 man_endparse(curp->man);
641 roff_endparse(curp->roff);
642 }
643
644 static void
645 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file)
646 {
647 struct buf *svprimary;
648 const char *svfile;
649 size_t offset;
650 static int recursion_depth;
651
652 if (64 < recursion_depth) {
653 mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL);
654 return;
655 }
656
657 /* Line number is per-file. */
658 svfile = curp->file;
659 curp->file = file;
660 svprimary = curp->primary;
661 curp->primary = &blk;
662 curp->line = 1;
663 recursion_depth++;
664
665 /* Skip an UTF-8 byte order mark. */
666 if (curp->filenc & MPARSE_UTF8 && blk.sz > 2 &&
667 (unsigned char)blk.buf[0] == 0xef &&
668 (unsigned char)blk.buf[1] == 0xbb &&
669 (unsigned char)blk.buf[2] == 0xbf) {
670 offset = 3;
671 curp->filenc &= ~MPARSE_LATIN1;
672 } else
673 offset = 0;
674
675 mparse_buf_r(curp, blk, offset, 1);
676
677 if (--recursion_depth == 0)
678 mparse_end(curp);
679
680 curp->primary = svprimary;
681 curp->file = svfile;
682 }
683
684 enum mandoclevel
685 mparse_readmem(struct mparse *curp, void *buf, size_t len,
686 const char *file)
687 {
688 struct buf blk;
689
690 blk.buf = buf;
691 blk.sz = len;
692
693 mparse_parse_buffer(curp, blk, file);
694 return curp->file_status;
695 }
696
697 /*
698 * Read the whole file into memory and call the parsers.
699 * Called recursively when an .so request is encountered.
700 */
701 enum mandoclevel
702 mparse_readfd(struct mparse *curp, int fd, const char *file)
703 {
704 struct buf blk;
705 int with_mmap;
706 int save_filenc;
707
708 if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {
709 save_filenc = curp->filenc;
710 curp->filenc = curp->options &
711 (MPARSE_UTF8 | MPARSE_LATIN1);
712 mparse_parse_buffer(curp, blk, file);
713 curp->filenc = save_filenc;
714 if (with_mmap)
715 munmap(blk.buf, blk.sz);
716 else
717 free(blk.buf);
718 }
719 return curp->file_status;
720 }
721
722 int
723 mparse_open(struct mparse *curp, const char *file)
724 {
725 char *cp;
726 int fd;
727
728 curp->file = file;
729 cp = strrchr(file, '.');
730 curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz"));
731
732 /* First try to use the filename as it is. */
733
734 if ((fd = open(file, O_RDONLY)) != -1)
735 return fd;
736
737 /*
738 * If that doesn't work and the filename doesn't
739 * already end in .gz, try appending .gz.
740 */
741
742 if ( ! curp->gzip) {
743 mandoc_asprintf(&cp, "%s.gz", file);
744 fd = open(cp, O_RDONLY);
745 free(cp);
746 if (fd != -1) {
747 curp->gzip = 1;
748 return fd;
749 }
750 }
751
752 /* Neither worked, give up. */
753
754 mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno));
755 return -1;
756 }
757
758 struct mparse *
759 mparse_alloc(int options, enum mandocerr mmin, mandocmsg mmsg,
760 enum mandoc_os os_e, const char *os_s)
761 {
762 struct mparse *curp;
763
764 curp = mandoc_calloc(1, sizeof(struct mparse));
765
766 curp->options = options;
767 curp->mmin = mmin;
768 curp->mmsg = mmsg;
769 curp->os_s = os_s;
770
771 curp->roff = roff_alloc(curp, options);
772 curp->man = roff_man_alloc(curp->roff, curp, curp->os_s,
773 curp->options & MPARSE_QUICK ? 1 : 0);
774 if (curp->options & MPARSE_MDOC) {
775 curp->man->macroset = MACROSET_MDOC;
776 if (curp->man->mdocmac == NULL)
777 curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
778 } else if (curp->options & MPARSE_MAN) {
779 curp->man->macroset = MACROSET_MAN;
780 if (curp->man->manmac == NULL)
781 curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);
782 }
783 curp->man->first->tok = TOKEN_NONE;
784 curp->man->meta.os_e = os_e;
785 return curp;
786 }
787
788 void
789 mparse_reset(struct mparse *curp)
790 {
791 roff_reset(curp->roff);
792 roff_man_reset(curp->man);
793
794 free(curp->sodest);
795 curp->sodest = NULL;
796
797 if (curp->secondary)
798 curp->secondary->sz = 0;
799
800 curp->file_status = MANDOCLEVEL_OK;
801 curp->gzip = 0;
802 }
803
804 void
805 mparse_free(struct mparse *curp)
806 {
807
808 roffhash_free(curp->man->mdocmac);
809 roffhash_free(curp->man->manmac);
810 roff_man_free(curp->man);
811 roff_free(curp->roff);
812 if (curp->secondary)
813 free(curp->secondary->buf);
814
815 free(curp->secondary);
816 free(curp->sodest);
817 free(curp);
818 }
819
820 void
821 mparse_result(struct mparse *curp, struct roff_man **man,
822 char **sodest)
823 {
824
825 if (sodest && NULL != (*sodest = curp->sodest)) {
826 *man = NULL;
827 return;
828 }
829 if (man)
830 *man = curp->man;
831 }
832
833 void
834 mparse_updaterc(struct mparse *curp, enum mandoclevel *rc)
835 {
836 if (curp->file_status > *rc)
837 *rc = curp->file_status;
838 }
839
840 void
841 mandoc_vmsg(enum mandocerr t, struct mparse *m,
842 int ln, int pos, const char *fmt, ...)
843 {
844 char buf[256];
845 va_list ap;
846
847 va_start(ap, fmt);
848 (void)vsnprintf(buf, sizeof(buf), fmt, ap);
849 va_end(ap);
850
851 mandoc_msg(t, m, ln, pos, buf);
852 }
853
854 void
855 mandoc_msg(enum mandocerr er, struct mparse *m,
856 int ln, int col, const char *msg)
857 {
858 enum mandoclevel level;
859
860 if (er < m->mmin && er != MANDOCERR_FILE)
861 return;
862
863 level = MANDOCLEVEL_UNSUPP;
864 while (er < mandoclimits[level])
865 level--;
866
867 if (m->mmsg)
868 (*m->mmsg)(er, level, m->file, ln, col, msg);
869
870 if (m->file_status < level)
871 m->file_status = level;
872 }
873
874 const char *
875 mparse_strerror(enum mandocerr er)
876 {
877
878 return mandocerrs[er];
879 }
880
881 const char *
882 mparse_strlevel(enum mandoclevel lvl)
883 {
884 return mandoclevels[lvl];
885 }
886
887 void
888 mparse_keep(struct mparse *p)
889 {
890
891 assert(NULL == p->secondary);
892 p->secondary = mandoc_calloc(1, sizeof(struct buf));
893 }
894
895 const char *
896 mparse_getkeep(const struct mparse *p)
897 {
898
899 assert(p->secondary);
900 return p->secondary->sz ? p->secondary->buf : NULL;
901 }