]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_validate.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
shut up about tabs in SYNOPSIS .Fd lines, there is no good way to avoid them
[mandoc.git] / mdoc_validate.c
1 /* $Id: mdoc_validate.c,v 1.279 2015/02/14 13:23:57 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>
5 * Copyright (c) 2010 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 AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 #ifndef OSNAME
23 #include <sys/utsname.h>
24 #endif
25
26 #include <assert.h>
27 #include <ctype.h>
28 #include <limits.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <time.h>
33
34 #include "mdoc.h"
35 #include "mandoc.h"
36 #include "mandoc_aux.h"
37 #include "libmdoc.h"
38 #include "libmandoc.h"
39
40 /* FIXME: .Bl -diag can't have non-text children in HEAD. */
41
42 #define PRE_ARGS struct mdoc *mdoc, struct mdoc_node *n
43 #define POST_ARGS struct mdoc *mdoc
44
45 enum check_ineq {
46 CHECK_LT,
47 CHECK_GT,
48 CHECK_EQ
49 };
50
51 typedef void (*v_pre)(PRE_ARGS);
52 typedef void (*v_post)(POST_ARGS);
53
54 struct valids {
55 v_pre pre;
56 v_post post;
57 };
58
59 static void check_text(struct mdoc *, int, int, char *);
60 static void check_argv(struct mdoc *,
61 struct mdoc_node *, struct mdoc_argv *);
62 static void check_args(struct mdoc *, struct mdoc_node *);
63 static int child_an(const struct mdoc_node *);
64 static enum mdoc_sec a2sec(const char *);
65 static size_t macro2len(enum mdoct);
66 static void rewrite_macro2len(char **);
67
68 static void post_an(POST_ARGS);
69 static void post_at(POST_ARGS);
70 static void post_bf(POST_ARGS);
71 static void post_bk(POST_ARGS);
72 static void post_bl(POST_ARGS);
73 static void post_bl_block(POST_ARGS);
74 static void post_bl_block_tag(POST_ARGS);
75 static void post_bl_head(POST_ARGS);
76 static void post_bx(POST_ARGS);
77 static void post_d1(POST_ARGS);
78 static void post_defaults(POST_ARGS);
79 static void post_dd(POST_ARGS);
80 static void post_dt(POST_ARGS);
81 static void post_en(POST_ARGS);
82 static void post_es(POST_ARGS);
83 static void post_eoln(POST_ARGS);
84 static void post_ex(POST_ARGS);
85 static void post_fa(POST_ARGS);
86 static void post_fn(POST_ARGS);
87 static void post_fname(POST_ARGS);
88 static void post_fo(POST_ARGS);
89 static void post_hyph(POST_ARGS);
90 static void post_ignpar(POST_ARGS);
91 static void post_it(POST_ARGS);
92 static void post_lb(POST_ARGS);
93 static void post_literal(POST_ARGS);
94 static void post_nd(POST_ARGS);
95 static void post_nm(POST_ARGS);
96 static void post_ns(POST_ARGS);
97 static void post_os(POST_ARGS);
98 static void post_par(POST_ARGS);
99 static void post_root(POST_ARGS);
100 static void post_rs(POST_ARGS);
101 static void post_sh(POST_ARGS);
102 static void post_sh_head(POST_ARGS);
103 static void post_sh_name(POST_ARGS);
104 static void post_sh_see_also(POST_ARGS);
105 static void post_sh_authors(POST_ARGS);
106 static void post_sm(POST_ARGS);
107 static void post_st(POST_ARGS);
108 static void post_vt(POST_ARGS);
109
110 static void pre_an(PRE_ARGS);
111 static void pre_bd(PRE_ARGS);
112 static void pre_bl(PRE_ARGS);
113 static void pre_dd(PRE_ARGS);
114 static void pre_display(PRE_ARGS);
115 static void pre_dt(PRE_ARGS);
116 static void pre_literal(PRE_ARGS);
117 static void pre_obsolete(PRE_ARGS);
118 static void pre_os(PRE_ARGS);
119 static void pre_par(PRE_ARGS);
120 static void pre_std(PRE_ARGS);
121
122 static const struct valids mdoc_valids[MDOC_MAX] = {
123 { NULL, NULL }, /* Ap */
124 { pre_dd, post_dd }, /* Dd */
125 { pre_dt, post_dt }, /* Dt */
126 { pre_os, post_os }, /* Os */
127 { NULL, post_sh }, /* Sh */
128 { NULL, post_ignpar }, /* Ss */
129 { pre_par, post_par }, /* Pp */
130 { pre_display, post_d1 }, /* D1 */
131 { pre_literal, post_literal }, /* Dl */
132 { pre_bd, post_literal }, /* Bd */
133 { NULL, NULL }, /* Ed */
134 { pre_bl, post_bl }, /* Bl */
135 { NULL, NULL }, /* El */
136 { pre_par, post_it }, /* It */
137 { NULL, NULL }, /* Ad */
138 { pre_an, post_an }, /* An */
139 { NULL, post_defaults }, /* Ar */
140 { NULL, NULL }, /* Cd */
141 { NULL, NULL }, /* Cm */
142 { NULL, NULL }, /* Dv */
143 { NULL, NULL }, /* Er */
144 { NULL, NULL }, /* Ev */
145 { pre_std, post_ex }, /* Ex */
146 { NULL, post_fa }, /* Fa */
147 { NULL, NULL }, /* Fd */
148 { NULL, NULL }, /* Fl */
149 { NULL, post_fn }, /* Fn */
150 { NULL, NULL }, /* Ft */
151 { NULL, NULL }, /* Ic */
152 { NULL, NULL }, /* In */
153 { NULL, post_defaults }, /* Li */
154 { NULL, post_nd }, /* Nd */
155 { NULL, post_nm }, /* Nm */
156 { NULL, NULL }, /* Op */
157 { pre_obsolete, NULL }, /* Ot */
158 { NULL, post_defaults }, /* Pa */
159 { pre_std, NULL }, /* Rv */
160 { NULL, post_st }, /* St */
161 { NULL, NULL }, /* Va */
162 { NULL, post_vt }, /* Vt */
163 { NULL, NULL }, /* Xr */
164 { NULL, NULL }, /* %A */
165 { NULL, post_hyph }, /* %B */ /* FIXME: can be used outside Rs/Re. */
166 { NULL, NULL }, /* %D */
167 { NULL, NULL }, /* %I */
168 { NULL, NULL }, /* %J */
169 { NULL, post_hyph }, /* %N */
170 { NULL, post_hyph }, /* %O */
171 { NULL, NULL }, /* %P */
172 { NULL, post_hyph }, /* %R */
173 { NULL, post_hyph }, /* %T */ /* FIXME: can be used outside Rs/Re. */
174 { NULL, NULL }, /* %V */
175 { NULL, NULL }, /* Ac */
176 { NULL, NULL }, /* Ao */
177 { NULL, NULL }, /* Aq */
178 { NULL, post_at }, /* At */
179 { NULL, NULL }, /* Bc */
180 { NULL, post_bf }, /* Bf */
181 { NULL, NULL }, /* Bo */
182 { NULL, NULL }, /* Bq */
183 { NULL, NULL }, /* Bsx */
184 { NULL, post_bx }, /* Bx */
185 { pre_obsolete, NULL }, /* Db */
186 { NULL, NULL }, /* Dc */
187 { NULL, NULL }, /* Do */
188 { NULL, NULL }, /* Dq */
189 { NULL, NULL }, /* Ec */
190 { NULL, NULL }, /* Ef */
191 { NULL, NULL }, /* Em */
192 { NULL, NULL }, /* Eo */
193 { NULL, NULL }, /* Fx */
194 { NULL, NULL }, /* Ms */
195 { NULL, NULL }, /* No */
196 { NULL, post_ns }, /* Ns */
197 { NULL, NULL }, /* Nx */
198 { NULL, NULL }, /* Ox */
199 { NULL, NULL }, /* Pc */
200 { NULL, NULL }, /* Pf */
201 { NULL, NULL }, /* Po */
202 { NULL, NULL }, /* Pq */
203 { NULL, NULL }, /* Qc */
204 { NULL, NULL }, /* Ql */
205 { NULL, NULL }, /* Qo */
206 { NULL, NULL }, /* Qq */
207 { NULL, NULL }, /* Re */
208 { NULL, post_rs }, /* Rs */
209 { NULL, NULL }, /* Sc */
210 { NULL, NULL }, /* So */
211 { NULL, NULL }, /* Sq */
212 { NULL, post_sm }, /* Sm */
213 { NULL, post_hyph }, /* Sx */
214 { NULL, NULL }, /* Sy */
215 { NULL, NULL }, /* Tn */
216 { NULL, NULL }, /* Ux */
217 { NULL, NULL }, /* Xc */
218 { NULL, NULL }, /* Xo */
219 { NULL, post_fo }, /* Fo */
220 { NULL, NULL }, /* Fc */
221 { NULL, NULL }, /* Oo */
222 { NULL, NULL }, /* Oc */
223 { NULL, post_bk }, /* Bk */
224 { NULL, NULL }, /* Ek */
225 { NULL, post_eoln }, /* Bt */
226 { NULL, NULL }, /* Hf */
227 { pre_obsolete, NULL }, /* Fr */
228 { NULL, post_eoln }, /* Ud */
229 { NULL, post_lb }, /* Lb */
230 { pre_par, post_par }, /* Lp */
231 { NULL, NULL }, /* Lk */
232 { NULL, post_defaults }, /* Mt */
233 { NULL, NULL }, /* Brq */
234 { NULL, NULL }, /* Bro */
235 { NULL, NULL }, /* Brc */
236 { NULL, NULL }, /* %C */
237 { pre_obsolete, post_es }, /* Es */
238 { pre_obsolete, post_en }, /* En */
239 { NULL, NULL }, /* Dx */
240 { NULL, NULL }, /* %Q */
241 { NULL, post_par }, /* br */
242 { NULL, post_par }, /* sp */
243 { NULL, NULL }, /* %U */
244 { NULL, NULL }, /* Ta */
245 { NULL, NULL }, /* ll */
246 };
247
248 #define RSORD_MAX 14 /* Number of `Rs' blocks. */
249
250 static const enum mdoct rsord[RSORD_MAX] = {
251 MDOC__A,
252 MDOC__T,
253 MDOC__B,
254 MDOC__I,
255 MDOC__J,
256 MDOC__R,
257 MDOC__N,
258 MDOC__V,
259 MDOC__U,
260 MDOC__P,
261 MDOC__Q,
262 MDOC__C,
263 MDOC__D,
264 MDOC__O
265 };
266
267 static const char * const secnames[SEC__MAX] = {
268 NULL,
269 "NAME",
270 "LIBRARY",
271 "SYNOPSIS",
272 "DESCRIPTION",
273 "CONTEXT",
274 "IMPLEMENTATION NOTES",
275 "RETURN VALUES",
276 "ENVIRONMENT",
277 "FILES",
278 "EXIT STATUS",
279 "EXAMPLES",
280 "DIAGNOSTICS",
281 "COMPATIBILITY",
282 "ERRORS",
283 "SEE ALSO",
284 "STANDARDS",
285 "HISTORY",
286 "AUTHORS",
287 "CAVEATS",
288 "BUGS",
289 "SECURITY CONSIDERATIONS",
290 NULL
291 };
292
293
294 void
295 mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
296 {
297 v_pre p;
298
299 switch (n->type) {
300 case MDOC_TEXT:
301 if (n->sec != SEC_SYNOPSIS || n->parent->tok != MDOC_Fd)
302 check_text(mdoc, n->line, n->pos, n->string);
303 /* FALLTHROUGH */
304 case MDOC_TBL:
305 /* FALLTHROUGH */
306 case MDOC_EQN:
307 /* FALLTHROUGH */
308 case MDOC_ROOT:
309 return;
310 default:
311 break;
312 }
313
314 check_args(mdoc, n);
315 p = mdoc_valids[n->tok].pre;
316 if (*p)
317 (*p)(mdoc, n);
318 }
319
320 void
321 mdoc_valid_post(struct mdoc *mdoc)
322 {
323 struct mdoc_node *n;
324 v_post p;
325
326 n = mdoc->last;
327 if (n->flags & MDOC_VALID)
328 return;
329 n->flags |= MDOC_VALID | MDOC_ENDED;
330
331 switch (n->type) {
332 case MDOC_TEXT:
333 /* FALLTHROUGH */
334 case MDOC_EQN:
335 /* FALLTHROUGH */
336 case MDOC_TBL:
337 break;
338 case MDOC_ROOT:
339 post_root(mdoc);
340 break;
341 default:
342
343 /*
344 * Closing delimiters are not special at the
345 * beginning of a block, opening delimiters
346 * are not special at the end.
347 */
348
349 if (n->child != NULL)
350 n->child->flags &= ~MDOC_DELIMC;
351 if (n->last != NULL)
352 n->last->flags &= ~MDOC_DELIMO;
353
354 /* Call the macro's postprocessor. */
355
356 p = mdoc_valids[n->tok].post;
357 if (*p)
358 (*p)(mdoc);
359 break;
360 }
361 }
362
363 static void
364 check_args(struct mdoc *mdoc, struct mdoc_node *n)
365 {
366 int i;
367
368 if (NULL == n->args)
369 return;
370
371 assert(n->args->argc);
372 for (i = 0; i < (int)n->args->argc; i++)
373 check_argv(mdoc, n, &n->args->argv[i]);
374 }
375
376 static void
377 check_argv(struct mdoc *mdoc, struct mdoc_node *n, struct mdoc_argv *v)
378 {
379 int i;
380
381 for (i = 0; i < (int)v->sz; i++)
382 check_text(mdoc, v->line, v->pos, v->value[i]);
383 }
384
385 static void
386 check_text(struct mdoc *mdoc, int ln, int pos, char *p)
387 {
388 char *cp;
389
390 if (MDOC_LITERAL & mdoc->flags)
391 return;
392
393 for (cp = p; NULL != (p = strchr(p, '\t')); p++)
394 mandoc_msg(MANDOCERR_FI_TAB, mdoc->parse,
395 ln, pos + (int)(p - cp), NULL);
396 }
397
398 static void
399 pre_display(PRE_ARGS)
400 {
401 struct mdoc_node *node;
402
403 if (MDOC_BLOCK != n->type)
404 return;
405
406 for (node = mdoc->last->parent; node; node = node->parent)
407 if (MDOC_BLOCK == node->type)
408 if (MDOC_Bd == node->tok)
409 break;
410
411 if (node)
412 mandoc_vmsg(MANDOCERR_BD_NEST,
413 mdoc->parse, n->line, n->pos,
414 "%s in Bd", mdoc_macronames[n->tok]);
415 }
416
417 static void
418 pre_bl(PRE_ARGS)
419 {
420 struct mdoc_argv *argv, *wa;
421 int i;
422 enum mdocargt mdoclt;
423 enum mdoc_list lt;
424
425 if (n->type != MDOC_BLOCK)
426 return;
427
428 /*
429 * First figure out which kind of list to use: bind ourselves to
430 * the first mentioned list type and warn about any remaining
431 * ones. If we find no list type, we default to LIST_item.
432 */
433
434 wa = (n->args == NULL) ? NULL : n->args->argv;
435 mdoclt = MDOC_ARG_MAX;
436 for (i = 0; n->args && i < (int)n->args->argc; i++) {
437 argv = n->args->argv + i;
438 lt = LIST__NONE;
439 switch (argv->arg) {
440 /* Set list types. */
441 case MDOC_Bullet:
442 lt = LIST_bullet;
443 break;
444 case MDOC_Dash:
445 lt = LIST_dash;
446 break;
447 case MDOC_Enum:
448 lt = LIST_enum;
449 break;
450 case MDOC_Hyphen:
451 lt = LIST_hyphen;
452 break;
453 case MDOC_Item:
454 lt = LIST_item;
455 break;
456 case MDOC_Tag:
457 lt = LIST_tag;
458 break;
459 case MDOC_Diag:
460 lt = LIST_diag;
461 break;
462 case MDOC_Hang:
463 lt = LIST_hang;
464 break;
465 case MDOC_Ohang:
466 lt = LIST_ohang;
467 break;
468 case MDOC_Inset:
469 lt = LIST_inset;
470 break;
471 case MDOC_Column:
472 lt = LIST_column;
473 break;
474 /* Set list arguments. */
475 case MDOC_Compact:
476 if (n->norm->Bl.comp)
477 mandoc_msg(MANDOCERR_ARG_REP,
478 mdoc->parse, argv->line,
479 argv->pos, "Bl -compact");
480 n->norm->Bl.comp = 1;
481 break;
482 case MDOC_Width:
483 wa = argv;
484 if (0 == argv->sz) {
485 mandoc_msg(MANDOCERR_ARG_EMPTY,
486 mdoc->parse, argv->line,
487 argv->pos, "Bl -width");
488 n->norm->Bl.width = "0n";
489 break;
490 }
491 if (NULL != n->norm->Bl.width)
492 mandoc_vmsg(MANDOCERR_ARG_REP,
493 mdoc->parse, argv->line,
494 argv->pos, "Bl -width %s",
495 argv->value[0]);
496 rewrite_macro2len(argv->value);
497 n->norm->Bl.width = argv->value[0];
498 break;
499 case MDOC_Offset:
500 if (0 == argv->sz) {
501 mandoc_msg(MANDOCERR_ARG_EMPTY,
502 mdoc->parse, argv->line,
503 argv->pos, "Bl -offset");
504 break;
505 }
506 if (NULL != n->norm->Bl.offs)
507 mandoc_vmsg(MANDOCERR_ARG_REP,
508 mdoc->parse, argv->line,
509 argv->pos, "Bl -offset %s",
510 argv->value[0]);
511 rewrite_macro2len(argv->value);
512 n->norm->Bl.offs = argv->value[0];
513 break;
514 default:
515 continue;
516 }
517 if (LIST__NONE == lt)
518 continue;
519 mdoclt = argv->arg;
520
521 /* Check: multiple list types. */
522
523 if (LIST__NONE != n->norm->Bl.type) {
524 mandoc_vmsg(MANDOCERR_BL_REP,
525 mdoc->parse, n->line, n->pos,
526 "Bl -%s", mdoc_argnames[argv->arg]);
527 continue;
528 }
529
530 /* The list type should come first. */
531
532 if (n->norm->Bl.width ||
533 n->norm->Bl.offs ||
534 n->norm->Bl.comp)
535 mandoc_vmsg(MANDOCERR_BL_LATETYPE,
536 mdoc->parse, n->line, n->pos, "Bl -%s",
537 mdoc_argnames[n->args->argv[0].arg]);
538
539 n->norm->Bl.type = lt;
540 if (LIST_column == lt) {
541 n->norm->Bl.ncols = argv->sz;
542 n->norm->Bl.cols = (void *)argv->value;
543 }
544 }
545
546 /* Allow lists to default to LIST_item. */
547
548 if (LIST__NONE == n->norm->Bl.type) {
549 mandoc_msg(MANDOCERR_BL_NOTYPE, mdoc->parse,
550 n->line, n->pos, "Bl");
551 n->norm->Bl.type = LIST_item;
552 }
553
554 /*
555 * Validate the width field. Some list types don't need width
556 * types and should be warned about them. Others should have it
557 * and must also be warned. Yet others have a default and need
558 * no warning.
559 */
560
561 switch (n->norm->Bl.type) {
562 case LIST_tag:
563 if (NULL == n->norm->Bl.width)
564 mandoc_msg(MANDOCERR_BL_NOWIDTH, mdoc->parse,
565 n->line, n->pos, "Bl -tag");
566 break;
567 case LIST_column:
568 /* FALLTHROUGH */
569 case LIST_diag:
570 /* FALLTHROUGH */
571 case LIST_ohang:
572 /* FALLTHROUGH */
573 case LIST_inset:
574 /* FALLTHROUGH */
575 case LIST_item:
576 if (n->norm->Bl.width)
577 mandoc_vmsg(MANDOCERR_BL_SKIPW, mdoc->parse,
578 wa->line, wa->pos, "Bl -%s",
579 mdoc_argnames[mdoclt]);
580 break;
581 case LIST_bullet:
582 /* FALLTHROUGH */
583 case LIST_dash:
584 /* FALLTHROUGH */
585 case LIST_hyphen:
586 if (NULL == n->norm->Bl.width)
587 n->norm->Bl.width = "2n";
588 break;
589 case LIST_enum:
590 if (NULL == n->norm->Bl.width)
591 n->norm->Bl.width = "3n";
592 break;
593 default:
594 break;
595 }
596 pre_par(mdoc, n);
597 }
598
599 static void
600 pre_bd(PRE_ARGS)
601 {
602 struct mdoc_argv *argv;
603 int i;
604 enum mdoc_disp dt;
605
606 pre_literal(mdoc, n);
607
608 if (n->type != MDOC_BLOCK)
609 return;
610
611 for (i = 0; n->args && i < (int)n->args->argc; i++) {
612 argv = n->args->argv + i;
613 dt = DISP__NONE;
614
615 switch (argv->arg) {
616 case MDOC_Centred:
617 dt = DISP_centered;
618 break;
619 case MDOC_Ragged:
620 dt = DISP_ragged;
621 break;
622 case MDOC_Unfilled:
623 dt = DISP_unfilled;
624 break;
625 case MDOC_Filled:
626 dt = DISP_filled;
627 break;
628 case MDOC_Literal:
629 dt = DISP_literal;
630 break;
631 case MDOC_File:
632 mandoc_msg(MANDOCERR_BD_FILE, mdoc->parse,
633 n->line, n->pos, NULL);
634 break;
635 case MDOC_Offset:
636 if (0 == argv->sz) {
637 mandoc_msg(MANDOCERR_ARG_EMPTY,
638 mdoc->parse, argv->line,
639 argv->pos, "Bd -offset");
640 break;
641 }
642 if (NULL != n->norm->Bd.offs)
643 mandoc_vmsg(MANDOCERR_ARG_REP,
644 mdoc->parse, argv->line,
645 argv->pos, "Bd -offset %s",
646 argv->value[0]);
647 rewrite_macro2len(argv->value);
648 n->norm->Bd.offs = argv->value[0];
649 break;
650 case MDOC_Compact:
651 if (n->norm->Bd.comp)
652 mandoc_msg(MANDOCERR_ARG_REP,
653 mdoc->parse, argv->line,
654 argv->pos, "Bd -compact");
655 n->norm->Bd.comp = 1;
656 break;
657 default:
658 abort();
659 /* NOTREACHED */
660 }
661 if (DISP__NONE == dt)
662 continue;
663
664 if (DISP__NONE == n->norm->Bd.type)
665 n->norm->Bd.type = dt;
666 else
667 mandoc_vmsg(MANDOCERR_BD_REP,
668 mdoc->parse, n->line, n->pos,
669 "Bd -%s", mdoc_argnames[argv->arg]);
670 }
671
672 if (DISP__NONE == n->norm->Bd.type) {
673 mandoc_msg(MANDOCERR_BD_NOTYPE, mdoc->parse,
674 n->line, n->pos, "Bd");
675 n->norm->Bd.type = DISP_ragged;
676 }
677 pre_par(mdoc, n);
678 }
679
680 static void
681 pre_an(PRE_ARGS)
682 {
683 struct mdoc_argv *argv;
684 size_t i;
685
686 if (n->args == NULL)
687 return;
688
689 for (i = 1; i < n->args->argc; i++) {
690 argv = n->args->argv + i;
691 mandoc_vmsg(MANDOCERR_AN_REP,
692 mdoc->parse, argv->line, argv->pos,
693 "An -%s", mdoc_argnames[argv->arg]);
694 }
695
696 argv = n->args->argv;
697 if (argv->arg == MDOC_Split)
698 n->norm->An.auth = AUTH_split;
699 else if (argv->arg == MDOC_Nosplit)
700 n->norm->An.auth = AUTH_nosplit;
701 else
702 abort();
703 }
704
705 static void
706 pre_std(PRE_ARGS)
707 {
708
709 if (n->args && 1 == n->args->argc)
710 if (MDOC_Std == n->args->argv[0].arg)
711 return;
712
713 mandoc_msg(MANDOCERR_ARG_STD, mdoc->parse,
714 n->line, n->pos, mdoc_macronames[n->tok]);
715 }
716
717 static void
718 pre_obsolete(PRE_ARGS)
719 {
720
721 if (MDOC_ELEM == n->type || MDOC_BLOCK == n->type)
722 mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,
723 n->line, n->pos, mdoc_macronames[n->tok]);
724 }
725
726 static void
727 pre_dt(PRE_ARGS)
728 {
729
730 if (mdoc->meta.title != NULL)
731 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
732 n->line, n->pos, "Dt");
733 else if (mdoc->meta.os != NULL)
734 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
735 n->line, n->pos, "Dt after Os");
736 }
737
738 static void
739 pre_os(PRE_ARGS)
740 {
741
742 if (mdoc->meta.os != NULL)
743 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
744 n->line, n->pos, "Os");
745 else if (mdoc->flags & MDOC_PBODY)
746 mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
747 n->line, n->pos, "Os");
748 }
749
750 static void
751 pre_dd(PRE_ARGS)
752 {
753
754 if (mdoc->meta.date != NULL)
755 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
756 n->line, n->pos, "Dd");
757 else if (mdoc->flags & MDOC_PBODY)
758 mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
759 n->line, n->pos, "Dd");
760 else if (mdoc->meta.title != NULL)
761 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
762 n->line, n->pos, "Dd after Dt");
763 else if (mdoc->meta.os != NULL)
764 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
765 n->line, n->pos, "Dd after Os");
766 }
767
768 static void
769 post_bf(POST_ARGS)
770 {
771 struct mdoc_node *np, *nch;
772 enum mdocargt arg;
773
774 /*
775 * Unlike other data pointers, these are "housed" by the HEAD
776 * element, which contains the goods.
777 */
778
779 np = mdoc->last;
780 if (MDOC_HEAD != np->type)
781 return;
782
783 assert(MDOC_BLOCK == np->parent->type);
784 assert(MDOC_Bf == np->parent->tok);
785
786 /* Check the number of arguments. */
787
788 nch = np->child;
789 if (NULL == np->parent->args) {
790 if (NULL == nch) {
791 mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,
792 np->line, np->pos, "Bf");
793 return;
794 }
795 nch = nch->next;
796 }
797 if (NULL != nch)
798 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
799 nch->line, nch->pos, "Bf ... %s", nch->string);
800
801 /* Extract argument into data. */
802
803 if (np->parent->args) {
804 arg = np->parent->args->argv[0].arg;
805 if (MDOC_Emphasis == arg)
806 np->norm->Bf.font = FONT_Em;
807 else if (MDOC_Literal == arg)
808 np->norm->Bf.font = FONT_Li;
809 else if (MDOC_Symbolic == arg)
810 np->norm->Bf.font = FONT_Sy;
811 else
812 abort();
813 return;
814 }
815
816 /* Extract parameter into data. */
817
818 if (0 == strcmp(np->child->string, "Em"))
819 np->norm->Bf.font = FONT_Em;
820 else if (0 == strcmp(np->child->string, "Li"))
821 np->norm->Bf.font = FONT_Li;
822 else if (0 == strcmp(np->child->string, "Sy"))
823 np->norm->Bf.font = FONT_Sy;
824 else
825 mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,
826 np->child->line, np->child->pos,
827 "Bf %s", np->child->string);
828 }
829
830 static void
831 post_lb(POST_ARGS)
832 {
833 struct mdoc_node *n;
834 const char *stdlibname;
835 char *libname;
836
837 n = mdoc->last->child;
838 assert(MDOC_TEXT == n->type);
839
840 if (NULL == (stdlibname = mdoc_a2lib(n->string)))
841 mandoc_asprintf(&libname,
842 "library \\(lq%s\\(rq", n->string);
843 else
844 libname = mandoc_strdup(stdlibname);
845
846 free(n->string);
847 n->string = libname;
848 }
849
850 static void
851 post_eoln(POST_ARGS)
852 {
853 const struct mdoc_node *n;
854
855 n = mdoc->last;
856 if (n->child)
857 mandoc_vmsg(MANDOCERR_ARG_SKIP,
858 mdoc->parse, n->line, n->pos,
859 "%s %s", mdoc_macronames[n->tok],
860 n->child->string);
861 }
862
863 static void
864 post_fname(POST_ARGS)
865 {
866 const struct mdoc_node *n;
867 const char *cp;
868 size_t pos;
869
870 n = mdoc->last->child;
871 pos = strcspn(n->string, "()");
872 cp = n->string + pos;
873 if ( ! (cp[0] == '\0' || (cp[0] == '(' && cp[1] == '*')))
874 mandoc_msg(MANDOCERR_FN_PAREN, mdoc->parse,
875 n->line, n->pos + pos, n->string);
876 }
877
878 static void
879 post_fn(POST_ARGS)
880 {
881
882 post_fname(mdoc);
883 post_fa(mdoc);
884 }
885
886 static void
887 post_fo(POST_ARGS)
888 {
889 const struct mdoc_node *n;
890
891 n = mdoc->last;
892
893 if (n->type != MDOC_HEAD)
894 return;
895
896 if (n->child == NULL) {
897 mandoc_msg(MANDOCERR_FO_NOHEAD, mdoc->parse,
898 n->line, n->pos, "Fo");
899 return;
900 }
901 if (n->child != n->last) {
902 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
903 n->child->next->line, n->child->next->pos,
904 "Fo ... %s", n->child->next->string);
905 while (n->child != n->last)
906 mdoc_node_delete(mdoc, n->last);
907 }
908
909 post_fname(mdoc);
910 }
911
912 static void
913 post_fa(POST_ARGS)
914 {
915 const struct mdoc_node *n;
916 const char *cp;
917
918 for (n = mdoc->last->child; n != NULL; n = n->next) {
919 for (cp = n->string; *cp != '\0'; cp++) {
920 /* Ignore callbacks and alterations. */
921 if (*cp == '(' || *cp == '{')
922 break;
923 if (*cp != ',')
924 continue;
925 mandoc_msg(MANDOCERR_FA_COMMA, mdoc->parse,
926 n->line, n->pos + (cp - n->string),
927 n->string);
928 break;
929 }
930 }
931 }
932
933 static void
934 post_vt(POST_ARGS)
935 {
936 const struct mdoc_node *n;
937
938 /*
939 * The Vt macro comes in both ELEM and BLOCK form, both of which
940 * have different syntaxes (yet more context-sensitive
941 * behaviour). ELEM types must have a child, which is already
942 * guaranteed by the in_line parsing routine; BLOCK types,
943 * specifically the BODY, should only have TEXT children.
944 */
945
946 if (MDOC_BODY != mdoc->last->type)
947 return;
948
949 for (n = mdoc->last->child; n; n = n->next)
950 if (MDOC_TEXT != n->type)
951 mandoc_msg(MANDOCERR_VT_CHILD, mdoc->parse,
952 n->line, n->pos, mdoc_macronames[n->tok]);
953 }
954
955 static void
956 post_nm(POST_ARGS)
957 {
958 struct mdoc_node *n;
959
960 n = mdoc->last;
961
962 if (n->last != NULL &&
963 (n->last->tok == MDOC_Pp ||
964 n->last->tok == MDOC_Lp))
965 mdoc_node_relink(mdoc, n->last);
966
967 if (NULL != mdoc->meta.name)
968 return;
969
970 mdoc_deroff(&mdoc->meta.name, n);
971
972 if (NULL == mdoc->meta.name)
973 mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
974 n->line, n->pos, "Nm");
975 }
976
977 static void
978 post_nd(POST_ARGS)
979 {
980 struct mdoc_node *n;
981
982 n = mdoc->last;
983
984 if (n->type != MDOC_BODY)
985 return;
986
987 if (n->child == NULL)
988 mandoc_msg(MANDOCERR_ND_EMPTY, mdoc->parse,
989 n->line, n->pos, "Nd");
990
991 post_hyph(mdoc);
992 }
993
994 static void
995 post_d1(POST_ARGS)
996 {
997 struct mdoc_node *n;
998
999 n = mdoc->last;
1000
1001 if (n->type != MDOC_BODY)
1002 return;
1003
1004 if (n->child == NULL)
1005 mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
1006 n->line, n->pos, "D1");
1007
1008 post_hyph(mdoc);
1009 }
1010
1011 static void
1012 post_literal(POST_ARGS)
1013 {
1014 struct mdoc_node *n;
1015
1016 n = mdoc->last;
1017
1018 if (n->type != MDOC_BODY)
1019 return;
1020
1021 if (n->child == NULL)
1022 mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
1023 n->line, n->pos, mdoc_macronames[n->tok]);
1024
1025 if (n->tok == MDOC_Bd &&
1026 n->norm->Bd.type != DISP_literal &&
1027 n->norm->Bd.type != DISP_unfilled)
1028 return;
1029
1030 mdoc->flags &= ~MDOC_LITERAL;
1031 }
1032
1033 static void
1034 post_defaults(POST_ARGS)
1035 {
1036 struct mdoc_node *nn;
1037
1038 /*
1039 * The `Ar' defaults to "file ..." if no value is provided as an
1040 * argument; the `Mt' and `Pa' macros use "~"; the `Li' just
1041 * gets an empty string.
1042 */
1043
1044 if (mdoc->last->child)
1045 return;
1046
1047 nn = mdoc->last;
1048 mdoc->next = MDOC_NEXT_CHILD;
1049
1050 switch (nn->tok) {
1051 case MDOC_Ar:
1052 mdoc_word_alloc(mdoc, nn->line, nn->pos, "file");
1053 mdoc_word_alloc(mdoc, nn->line, nn->pos, "...");
1054 break;
1055 case MDOC_Pa:
1056 /* FALLTHROUGH */
1057 case MDOC_Mt:
1058 mdoc_word_alloc(mdoc, nn->line, nn->pos, "~");
1059 break;
1060 default:
1061 abort();
1062 /* NOTREACHED */
1063 }
1064 mdoc->last = nn;
1065 }
1066
1067 static void
1068 post_at(POST_ARGS)
1069 {
1070 struct mdoc_node *n;
1071 const char *std_att;
1072 char *att;
1073
1074 n = mdoc->last;
1075 if (n->child == NULL) {
1076 mdoc->next = MDOC_NEXT_CHILD;
1077 mdoc_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX");
1078 mdoc->last = n;
1079 return;
1080 }
1081
1082 /*
1083 * If we have a child, look it up in the standard keys. If a
1084 * key exist, use that instead of the child; if it doesn't,
1085 * prefix "AT&T UNIX " to the existing data.
1086 */
1087
1088 n = n->child;
1089 assert(MDOC_TEXT == n->type);
1090 if (NULL == (std_att = mdoc_a2att(n->string))) {
1091 mandoc_vmsg(MANDOCERR_AT_BAD, mdoc->parse,
1092 n->line, n->pos, "At %s", n->string);
1093 mandoc_asprintf(&att, "AT&T UNIX %s", n->string);
1094 } else
1095 att = mandoc_strdup(std_att);
1096
1097 free(n->string);
1098 n->string = att;
1099 }
1100
1101 static void
1102 post_an(POST_ARGS)
1103 {
1104 struct mdoc_node *np, *nch;
1105
1106 np = mdoc->last;
1107 nch = np->child;
1108 if (np->norm->An.auth == AUTH__NONE) {
1109 if (nch == NULL)
1110 mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
1111 np->line, np->pos, "An");
1112 } else if (nch != NULL)
1113 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1114 nch->line, nch->pos, "An ... %s", nch->string);
1115 }
1116
1117 static void
1118 post_en(POST_ARGS)
1119 {
1120
1121 if (MDOC_BLOCK == mdoc->last->type)
1122 mdoc->last->norm->Es = mdoc->last_es;
1123 }
1124
1125 static void
1126 post_es(POST_ARGS)
1127 {
1128
1129 mdoc->last_es = mdoc->last;
1130 }
1131
1132 static void
1133 post_it(POST_ARGS)
1134 {
1135 int i, cols;
1136 enum mdoc_list lt;
1137 struct mdoc_node *nbl, *nit, *nch;
1138
1139 nit = mdoc->last;
1140 if (nit->type != MDOC_BLOCK)
1141 return;
1142
1143 nbl = nit->parent->parent;
1144 lt = nbl->norm->Bl.type;
1145
1146 switch (lt) {
1147 case LIST_tag:
1148 /* FALLTHROUGH */
1149 case LIST_hang:
1150 /* FALLTHROUGH */
1151 case LIST_ohang:
1152 /* FALLTHROUGH */
1153 case LIST_inset:
1154 /* FALLTHROUGH */
1155 case LIST_diag:
1156 if (nit->head->child == NULL)
1157 mandoc_vmsg(MANDOCERR_IT_NOHEAD,
1158 mdoc->parse, nit->line, nit->pos,
1159 "Bl -%s It",
1160 mdoc_argnames[nbl->args->argv[0].arg]);
1161 break;
1162 case LIST_bullet:
1163 /* FALLTHROUGH */
1164 case LIST_dash:
1165 /* FALLTHROUGH */
1166 case LIST_enum:
1167 /* FALLTHROUGH */
1168 case LIST_hyphen:
1169 if (nit->body == NULL || nit->body->child == NULL)
1170 mandoc_vmsg(MANDOCERR_IT_NOBODY,
1171 mdoc->parse, nit->line, nit->pos,
1172 "Bl -%s It",
1173 mdoc_argnames[nbl->args->argv[0].arg]);
1174 /* FALLTHROUGH */
1175 case LIST_item:
1176 if (nit->head->child != NULL)
1177 mandoc_vmsg(MANDOCERR_ARG_SKIP,
1178 mdoc->parse, nit->line, nit->pos,
1179 "It %s", nit->head->child->string);
1180 break;
1181 case LIST_column:
1182 cols = (int)nbl->norm->Bl.ncols;
1183
1184 assert(nit->head->child == NULL);
1185
1186 for (i = 0, nch = nit->child; nch; nch = nch->next)
1187 if (nch->type == MDOC_BODY)
1188 i++;
1189
1190 if (i < cols || i > cols + 1)
1191 mandoc_vmsg(MANDOCERR_BL_COL,
1192 mdoc->parse, nit->line, nit->pos,
1193 "%d columns, %d cells", cols, i);
1194 break;
1195 default:
1196 abort();
1197 }
1198 }
1199
1200 static void
1201 post_bl_block(POST_ARGS)
1202 {
1203 struct mdoc_node *n, *ni, *nc;
1204
1205 /*
1206 * These are fairly complicated, so we've broken them into two
1207 * functions. post_bl_block_tag() is called when a -tag is
1208 * specified, but no -width (it must be guessed). The second
1209 * when a -width is specified (macro indicators must be
1210 * rewritten into real lengths).
1211 */
1212
1213 n = mdoc->last;
1214
1215 if (LIST_tag == n->norm->Bl.type &&
1216 NULL == n->norm->Bl.width) {
1217 post_bl_block_tag(mdoc);
1218 assert(n->norm->Bl.width);
1219 }
1220
1221 for (ni = n->body->child; ni; ni = ni->next) {
1222 if (NULL == ni->body)
1223 continue;
1224 nc = ni->body->last;
1225 while (NULL != nc) {
1226 switch (nc->tok) {
1227 case MDOC_Pp:
1228 /* FALLTHROUGH */
1229 case MDOC_Lp:
1230 /* FALLTHROUGH */
1231 case MDOC_br:
1232 break;
1233 default:
1234 nc = NULL;
1235 continue;
1236 }
1237 if (NULL == ni->next) {
1238 mandoc_msg(MANDOCERR_PAR_MOVE,
1239 mdoc->parse, nc->line, nc->pos,
1240 mdoc_macronames[nc->tok]);
1241 mdoc_node_relink(mdoc, nc);
1242 } else if (0 == n->norm->Bl.comp &&
1243 LIST_column != n->norm->Bl.type) {
1244 mandoc_vmsg(MANDOCERR_PAR_SKIP,
1245 mdoc->parse, nc->line, nc->pos,
1246 "%s before It",
1247 mdoc_macronames[nc->tok]);
1248 mdoc_node_delete(mdoc, nc);
1249 } else
1250 break;
1251 nc = ni->body->last;
1252 }
1253 }
1254 }
1255
1256 /*
1257 * If the argument of -offset or -width is a macro,
1258 * replace it with the associated default width.
1259 */
1260 void
1261 rewrite_macro2len(char **arg)
1262 {
1263 size_t width;
1264 enum mdoct tok;
1265
1266 if (*arg == NULL)
1267 return;
1268 else if ( ! strcmp(*arg, "Ds"))
1269 width = 6;
1270 else if ((tok = mdoc_hash_find(*arg)) == MDOC_MAX)
1271 return;
1272 else
1273 width = macro2len(tok);
1274
1275 free(*arg);
1276 mandoc_asprintf(arg, "%zun", width);
1277 }
1278
1279 static void
1280 post_bl_block_tag(POST_ARGS)
1281 {
1282 struct mdoc_node *n, *nn;
1283 size_t sz, ssz;
1284 int i;
1285 char buf[24];
1286
1287 /*
1288 * Calculate the -width for a `Bl -tag' list if it hasn't been
1289 * provided. Uses the first head macro. NOTE AGAIN: this is
1290 * ONLY if the -width argument has NOT been provided. See
1291 * rewrite_macro2len() for converting the -width string.
1292 */
1293
1294 sz = 10;
1295 n = mdoc->last;
1296
1297 for (nn = n->body->child; nn; nn = nn->next) {
1298 if (MDOC_It != nn->tok)
1299 continue;
1300
1301 assert(MDOC_BLOCK == nn->type);
1302 nn = nn->head->child;
1303
1304 if (nn == NULL)
1305 break;
1306
1307 if (MDOC_TEXT == nn->type) {
1308 sz = strlen(nn->string) + 1;
1309 break;
1310 }
1311
1312 if (0 != (ssz = macro2len(nn->tok)))
1313 sz = ssz;
1314
1315 break;
1316 }
1317
1318 /* Defaults to ten ens. */
1319
1320 (void)snprintf(buf, sizeof(buf), "%un", (unsigned int)sz);
1321
1322 /*
1323 * We have to dynamically add this to the macro's argument list.
1324 * We're guaranteed that a MDOC_Width doesn't already exist.
1325 */
1326
1327 assert(n->args);
1328 i = (int)(n->args->argc)++;
1329
1330 n->args->argv = mandoc_reallocarray(n->args->argv,
1331 n->args->argc, sizeof(struct mdoc_argv));
1332
1333 n->args->argv[i].arg = MDOC_Width;
1334 n->args->argv[i].line = n->line;
1335 n->args->argv[i].pos = n->pos;
1336 n->args->argv[i].sz = 1;
1337 n->args->argv[i].value = mandoc_malloc(sizeof(char *));
1338 n->args->argv[i].value[0] = mandoc_strdup(buf);
1339
1340 /* Set our width! */
1341 n->norm->Bl.width = n->args->argv[i].value[0];
1342 }
1343
1344 static void
1345 post_bl_head(POST_ARGS)
1346 {
1347 struct mdoc_node *nbl, *nh, *nch, *nnext;
1348 struct mdoc_argv *argv;
1349 int i, j;
1350
1351 nh = mdoc->last;
1352
1353 if (nh->norm->Bl.type != LIST_column) {
1354 if ((nch = nh->child) == NULL)
1355 return;
1356 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1357 nch->line, nch->pos, "Bl ... %s", nch->string);
1358 while (nch != NULL) {
1359 mdoc_node_delete(mdoc, nch);
1360 nch = nh->child;
1361 }
1362 return;
1363 }
1364
1365 /*
1366 * Append old-style lists, where the column width specifiers
1367 * trail as macro parameters, to the new-style ("normal-form")
1368 * lists where they're argument values following -column.
1369 */
1370
1371 if (nh->child == NULL)
1372 return;
1373
1374 nbl = nh->parent;
1375 for (j = 0; j < (int)nbl->args->argc; j++)
1376 if (nbl->args->argv[j].arg == MDOC_Column)
1377 break;
1378
1379 assert(j < (int)nbl->args->argc);
1380
1381 /*
1382 * Accommodate for new-style groff column syntax. Shuffle the
1383 * child nodes, all of which must be TEXT, as arguments for the
1384 * column field. Then, delete the head children.
1385 */
1386
1387 argv = nbl->args->argv + j;
1388 i = argv->sz;
1389 argv->sz += nh->nchild;
1390 argv->value = mandoc_reallocarray(argv->value,
1391 argv->sz, sizeof(char *));
1392
1393 nh->norm->Bl.ncols = argv->sz;
1394 nh->norm->Bl.cols = (void *)argv->value;
1395
1396 for (nch = nh->child; nch != NULL; nch = nnext) {
1397 argv->value[i++] = nch->string;
1398 nch->string = NULL;
1399 nnext = nch->next;
1400 mdoc_node_delete(NULL, nch);
1401 }
1402 nh->nchild = 0;
1403 nh->child = NULL;
1404 }
1405
1406 static void
1407 post_bl(POST_ARGS)
1408 {
1409 struct mdoc_node *nparent, *nprev; /* of the Bl block */
1410 struct mdoc_node *nblock, *nbody; /* of the Bl */
1411 struct mdoc_node *nchild, *nnext; /* of the Bl body */
1412
1413 nbody = mdoc->last;
1414 switch (nbody->type) {
1415 case MDOC_BLOCK:
1416 post_bl_block(mdoc);
1417 return;
1418 case MDOC_HEAD:
1419 post_bl_head(mdoc);
1420 return;
1421 case MDOC_BODY:
1422 break;
1423 default:
1424 return;
1425 }
1426
1427 nchild = nbody->child;
1428 if (nchild == NULL) {
1429 mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
1430 nbody->line, nbody->pos, "Bl");
1431 return;
1432 }
1433 while (nchild != NULL) {
1434 if (nchild->tok == MDOC_It ||
1435 (nchild->tok == MDOC_Sm &&
1436 nchild->next != NULL &&
1437 nchild->next->tok == MDOC_It)) {
1438 nchild = nchild->next;
1439 continue;
1440 }
1441
1442 mandoc_msg(MANDOCERR_BL_MOVE, mdoc->parse,
1443 nchild->line, nchild->pos,
1444 mdoc_macronames[nchild->tok]);
1445
1446 /*
1447 * Move the node out of the Bl block.
1448 * First, collect all required node pointers.
1449 */
1450
1451 nblock = nbody->parent;
1452 nprev = nblock->prev;
1453 nparent = nblock->parent;
1454 nnext = nchild->next;
1455
1456 /*
1457 * Unlink this child.
1458 */
1459
1460 assert(NULL == nchild->prev);
1461 if (0 == --nbody->nchild) {
1462 nbody->child = NULL;
1463 nbody->last = NULL;
1464 assert(NULL == nnext);
1465 } else {
1466 nbody->child = nnext;
1467 nnext->prev = NULL;
1468 }
1469
1470 /*
1471 * Relink this child.
1472 */
1473
1474 nchild->parent = nparent;
1475 nchild->prev = nprev;
1476 nchild->next = nblock;
1477
1478 nblock->prev = nchild;
1479 nparent->nchild++;
1480 if (NULL == nprev)
1481 nparent->child = nchild;
1482 else
1483 nprev->next = nchild;
1484
1485 nchild = nnext;
1486 }
1487 }
1488
1489 static void
1490 post_bk(POST_ARGS)
1491 {
1492 struct mdoc_node *n;
1493
1494 n = mdoc->last;
1495
1496 if (n->type == MDOC_BLOCK && n->body->child == NULL) {
1497 mandoc_msg(MANDOCERR_BLK_EMPTY,
1498 mdoc->parse, n->line, n->pos, "Bk");
1499 mdoc_node_delete(mdoc, n);
1500 }
1501 }
1502
1503 static void
1504 post_sm(struct mdoc *mdoc)
1505 {
1506 struct mdoc_node *nch;
1507
1508 nch = mdoc->last->child;
1509
1510 if (nch == NULL) {
1511 mdoc->flags ^= MDOC_SMOFF;
1512 return;
1513 }
1514
1515 assert(nch->type == MDOC_TEXT);
1516
1517 if ( ! strcmp(nch->string, "on")) {
1518 mdoc->flags &= ~MDOC_SMOFF;
1519 return;
1520 }
1521 if ( ! strcmp(nch->string, "off")) {
1522 mdoc->flags |= MDOC_SMOFF;
1523 return;
1524 }
1525
1526 mandoc_vmsg(MANDOCERR_SM_BAD,
1527 mdoc->parse, nch->line, nch->pos,
1528 "%s %s", mdoc_macronames[mdoc->last->tok], nch->string);
1529 mdoc_node_relink(mdoc, nch);
1530 return;
1531 }
1532
1533 static void
1534 post_root(POST_ARGS)
1535 {
1536 struct mdoc_node *n;
1537
1538 /* Add missing prologue data. */
1539
1540 if (mdoc->meta.date == NULL)
1541 mdoc->meta.date = mdoc->quick ?
1542 mandoc_strdup("") :
1543 mandoc_normdate(mdoc->parse, NULL, 0, 0);
1544
1545 if (mdoc->meta.title == NULL) {
1546 mandoc_msg(MANDOCERR_DT_NOTITLE,
1547 mdoc->parse, 0, 0, "EOF");
1548 mdoc->meta.title = mandoc_strdup("UNTITLED");
1549 }
1550
1551 if (mdoc->meta.vol == NULL)
1552 mdoc->meta.vol = mandoc_strdup("LOCAL");
1553
1554 if (mdoc->meta.os == NULL) {
1555 mandoc_msg(MANDOCERR_OS_MISSING,
1556 mdoc->parse, 0, 0, NULL);
1557 mdoc->meta.os = mandoc_strdup("");
1558 }
1559
1560 /* Check that we begin with a proper `Sh'. */
1561
1562 n = mdoc->first->child;
1563 while (n != NULL && mdoc_macros[n->tok].flags & MDOC_PROLOGUE)
1564 n = n->next;
1565
1566 if (n == NULL)
1567 mandoc_msg(MANDOCERR_DOC_EMPTY, mdoc->parse, 0, 0, NULL);
1568 else if (n->tok != MDOC_Sh)
1569 mandoc_msg(MANDOCERR_SEC_BEFORE, mdoc->parse,
1570 n->line, n->pos, mdoc_macronames[n->tok]);
1571 }
1572
1573 static void
1574 post_st(POST_ARGS)
1575 {
1576 struct mdoc_node *n, *nch;
1577 const char *p;
1578
1579 n = mdoc->last;
1580 nch = n->child;
1581
1582 assert(MDOC_TEXT == nch->type);
1583
1584 if (NULL == (p = mdoc_a2st(nch->string))) {
1585 mandoc_vmsg(MANDOCERR_ST_BAD, mdoc->parse,
1586 nch->line, nch->pos, "St %s", nch->string);
1587 mdoc_node_delete(mdoc, n);
1588 } else {
1589 free(nch->string);
1590 nch->string = mandoc_strdup(p);
1591 }
1592 }
1593
1594 static void
1595 post_rs(POST_ARGS)
1596 {
1597 struct mdoc_node *np, *nch, *next, *prev;
1598 int i, j;
1599
1600 np = mdoc->last;
1601
1602 if (np->type != MDOC_BODY)
1603 return;
1604
1605 if (np->child == NULL) {
1606 mandoc_msg(MANDOCERR_RS_EMPTY, mdoc->parse,
1607 np->line, np->pos, "Rs");
1608 return;
1609 }
1610
1611 /*
1612 * The full `Rs' block needs special handling to order the
1613 * sub-elements according to `rsord'. Pick through each element
1614 * and correctly order it. This is an insertion sort.
1615 */
1616
1617 next = NULL;
1618 for (nch = np->child->next; nch != NULL; nch = next) {
1619 /* Determine order number of this child. */
1620 for (i = 0; i < RSORD_MAX; i++)
1621 if (rsord[i] == nch->tok)
1622 break;
1623
1624 if (i == RSORD_MAX) {
1625 mandoc_msg(MANDOCERR_RS_BAD,
1626 mdoc->parse, nch->line, nch->pos,
1627 mdoc_macronames[nch->tok]);
1628 i = -1;
1629 } else if (nch->tok == MDOC__J || nch->tok == MDOC__B)
1630 np->norm->Rs.quote_T++;
1631
1632 /*
1633 * Remove this child from the chain. This somewhat
1634 * repeats mdoc_node_unlink(), but since we're
1635 * just re-ordering, there's no need for the
1636 * full unlink process.
1637 */
1638
1639 if ((next = nch->next) != NULL)
1640 next->prev = nch->prev;
1641
1642 if ((prev = nch->prev) != NULL)
1643 prev->next = nch->next;
1644
1645 nch->prev = nch->next = NULL;
1646
1647 /*
1648 * Scan back until we reach a node that's
1649 * to be ordered before this child.
1650 */
1651
1652 for ( ; prev ; prev = prev->prev) {
1653 /* Determine order of `prev'. */
1654 for (j = 0; j < RSORD_MAX; j++)
1655 if (rsord[j] == prev->tok)
1656 break;
1657 if (j == RSORD_MAX)
1658 j = -1;
1659
1660 if (j <= i)
1661 break;
1662 }
1663
1664 /*
1665 * Set this child back into its correct place
1666 * in front of the `prev' node.
1667 */
1668
1669 nch->prev = prev;
1670
1671 if (prev == NULL) {
1672 np->child->prev = nch;
1673 nch->next = np->child;
1674 np->child = nch;
1675 } else {
1676 if (prev->next)
1677 prev->next->prev = nch;
1678 nch->next = prev->next;
1679 prev->next = nch;
1680 }
1681 }
1682 }
1683
1684 /*
1685 * For some arguments of some macros,
1686 * convert all breakable hyphens into ASCII_HYPH.
1687 */
1688 static void
1689 post_hyph(POST_ARGS)
1690 {
1691 struct mdoc_node *nch;
1692 char *cp;
1693
1694 for (nch = mdoc->last->child; nch != NULL; nch = nch->next) {
1695 if (nch->type != MDOC_TEXT)
1696 continue;
1697 cp = nch->string;
1698 if (*cp == '\0')
1699 continue;
1700 while (*(++cp) != '\0')
1701 if (*cp == '-' &&
1702 isalpha((unsigned char)cp[-1]) &&
1703 isalpha((unsigned char)cp[1]))
1704 *cp = ASCII_HYPH;
1705 }
1706 }
1707
1708 static void
1709 post_ns(POST_ARGS)
1710 {
1711
1712 if (MDOC_LINE & mdoc->last->flags)
1713 mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,
1714 mdoc->last->line, mdoc->last->pos, NULL);
1715 }
1716
1717 static void
1718 post_sh(POST_ARGS)
1719 {
1720
1721 post_ignpar(mdoc);
1722
1723 switch (mdoc->last->type) {
1724 case MDOC_HEAD:
1725 post_sh_head(mdoc);
1726 break;
1727 case MDOC_BODY:
1728 switch (mdoc->lastsec) {
1729 case SEC_NAME:
1730 post_sh_name(mdoc);
1731 break;
1732 case SEC_SEE_ALSO:
1733 post_sh_see_also(mdoc);
1734 break;
1735 case SEC_AUTHORS:
1736 post_sh_authors(mdoc);
1737 break;
1738 default:
1739 break;
1740 }
1741 break;
1742 default:
1743 break;
1744 }
1745 }
1746
1747 static void
1748 post_sh_name(POST_ARGS)
1749 {
1750 struct mdoc_node *n;
1751
1752 /*
1753 * Warn if the NAME section doesn't contain the `Nm' and `Nd'
1754 * macros (can have multiple `Nm' and one `Nd'). Note that the
1755 * children of the BODY declaration can also be "text".
1756 */
1757
1758 if (NULL == (n = mdoc->last->child)) {
1759 mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
1760 mdoc->last->line, mdoc->last->pos, "empty");
1761 return;
1762 }
1763
1764 for ( ; n && n->next; n = n->next) {
1765 if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)
1766 continue;
1767 if (MDOC_TEXT == n->type)
1768 continue;
1769 mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
1770 n->line, n->pos, mdoc_macronames[n->tok]);
1771 }
1772
1773 assert(n);
1774 if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)
1775 return;
1776
1777 mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
1778 n->line, n->pos, mdoc_macronames[n->tok]);
1779 }
1780
1781 static void
1782 post_sh_see_also(POST_ARGS)
1783 {
1784 const struct mdoc_node *n;
1785 const char *name, *sec;
1786 const char *lastname, *lastsec, *lastpunct;
1787 int cmp;
1788
1789 n = mdoc->last->child;
1790 lastname = lastsec = lastpunct = NULL;
1791 while (n != NULL) {
1792 if (n->tok != MDOC_Xr || n->nchild < 2)
1793 break;
1794
1795 /* Process one .Xr node. */
1796
1797 name = n->child->string;
1798 sec = n->child->next->string;
1799 if (lastsec != NULL) {
1800 if (lastpunct[0] != ',' || lastpunct[1] != '\0')
1801 mandoc_vmsg(MANDOCERR_XR_PUNCT,
1802 mdoc->parse, n->line, n->pos,
1803 "%s before %s(%s)", lastpunct,
1804 name, sec);
1805 cmp = strcmp(lastsec, sec);
1806 if (cmp > 0)
1807 mandoc_vmsg(MANDOCERR_XR_ORDER,
1808 mdoc->parse, n->line, n->pos,
1809 "%s(%s) after %s(%s)", name,
1810 sec, lastname, lastsec);
1811 else if (cmp == 0 &&
1812 strcasecmp(lastname, name) > 0)
1813 mandoc_vmsg(MANDOCERR_XR_ORDER,
1814 mdoc->parse, n->line, n->pos,
1815 "%s after %s", name, lastname);
1816 }
1817 lastname = name;
1818 lastsec = sec;
1819
1820 /* Process the following node. */
1821
1822 n = n->next;
1823 if (n == NULL)
1824 break;
1825 if (n->tok == MDOC_Xr) {
1826 lastpunct = "none";
1827 continue;
1828 }
1829 if (n->type != MDOC_TEXT)
1830 break;
1831 for (name = n->string; *name != '\0'; name++)
1832 if (isalpha((const unsigned char)*name))
1833 return;
1834 lastpunct = n->string;
1835 if (n->next == NULL)
1836 mandoc_vmsg(MANDOCERR_XR_PUNCT, mdoc->parse,
1837 n->line, n->pos, "%s after %s(%s)",
1838 lastpunct, lastname, lastsec);
1839 n = n->next;
1840 }
1841 }
1842
1843 static int
1844 child_an(const struct mdoc_node *n)
1845 {
1846
1847 for (n = n->child; n != NULL; n = n->next)
1848 if ((n->tok == MDOC_An && n->nchild) || child_an(n))
1849 return(1);
1850 return(0);
1851 }
1852
1853 static void
1854 post_sh_authors(POST_ARGS)
1855 {
1856
1857 if ( ! child_an(mdoc->last))
1858 mandoc_msg(MANDOCERR_AN_MISSING, mdoc->parse,
1859 mdoc->last->line, mdoc->last->pos, NULL);
1860 }
1861
1862 static void
1863 post_sh_head(POST_ARGS)
1864 {
1865 struct mdoc_node *n;
1866 const char *goodsec;
1867 char *secname;
1868 enum mdoc_sec sec;
1869
1870 /*
1871 * Process a new section. Sections are either "named" or
1872 * "custom". Custom sections are user-defined, while named ones
1873 * follow a conventional order and may only appear in certain
1874 * manual sections.
1875 */
1876
1877 secname = NULL;
1878 sec = SEC_CUSTOM;
1879 mdoc_deroff(&secname, mdoc->last);
1880 sec = NULL == secname ? SEC_CUSTOM : a2sec(secname);
1881
1882 /* The NAME should be first. */
1883
1884 if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed)
1885 mandoc_vmsg(MANDOCERR_NAMESEC_FIRST, mdoc->parse,
1886 mdoc->last->line, mdoc->last->pos,
1887 "Sh %s", secname);
1888
1889 /* The SYNOPSIS gets special attention in other areas. */
1890
1891 if (SEC_SYNOPSIS == sec) {
1892 roff_setreg(mdoc->roff, "nS", 1, '=');
1893 mdoc->flags |= MDOC_SYNOPSIS;
1894 } else {
1895 roff_setreg(mdoc->roff, "nS", 0, '=');
1896 mdoc->flags &= ~MDOC_SYNOPSIS;
1897 }
1898
1899 /* Mark our last section. */
1900
1901 mdoc->lastsec = sec;
1902
1903 /*
1904 * Set the section attribute for the current HEAD, for its
1905 * parent BLOCK, and for the HEAD children; the latter can
1906 * only be TEXT nodes, so no recursion is needed.
1907 * For other blocks and elements, including .Sh BODY, this is
1908 * done when allocating the node data structures, but for .Sh
1909 * BLOCK and HEAD, the section is still unknown at that time.
1910 */
1911
1912 mdoc->last->parent->sec = sec;
1913 mdoc->last->sec = sec;
1914 for (n = mdoc->last->child; n; n = n->next)
1915 n->sec = sec;
1916
1917 /* We don't care about custom sections after this. */
1918
1919 if (SEC_CUSTOM == sec) {
1920 free(secname);
1921 return;
1922 }
1923
1924 /*
1925 * Check whether our non-custom section is being repeated or is
1926 * out of order.
1927 */
1928
1929 if (sec == mdoc->lastnamed)
1930 mandoc_vmsg(MANDOCERR_SEC_REP, mdoc->parse,
1931 mdoc->last->line, mdoc->last->pos,
1932 "Sh %s", secname);
1933
1934 if (sec < mdoc->lastnamed)
1935 mandoc_vmsg(MANDOCERR_SEC_ORDER, mdoc->parse,
1936 mdoc->last->line, mdoc->last->pos,
1937 "Sh %s", secname);
1938
1939 /* Mark the last named section. */
1940
1941 mdoc->lastnamed = sec;
1942
1943 /* Check particular section/manual conventions. */
1944
1945 if (mdoc->meta.msec == NULL) {
1946 free(secname);
1947 return;
1948 }
1949
1950 goodsec = NULL;
1951 switch (sec) {
1952 case SEC_ERRORS:
1953 if (*mdoc->meta.msec == '4')
1954 break;
1955 goodsec = "2, 3, 4, 9";
1956 /* FALLTHROUGH */
1957 case SEC_RETURN_VALUES:
1958 /* FALLTHROUGH */
1959 case SEC_LIBRARY:
1960 if (*mdoc->meta.msec == '2')
1961 break;
1962 if (*mdoc->meta.msec == '3')
1963 break;
1964 if (NULL == goodsec)
1965 goodsec = "2, 3, 9";
1966 /* FALLTHROUGH */
1967 case SEC_CONTEXT:
1968 if (*mdoc->meta.msec == '9')
1969 break;
1970 if (NULL == goodsec)
1971 goodsec = "9";
1972 mandoc_vmsg(MANDOCERR_SEC_MSEC, mdoc->parse,
1973 mdoc->last->line, mdoc->last->pos,
1974 "Sh %s for %s only", secname, goodsec);
1975 break;
1976 default:
1977 break;
1978 }
1979 free(secname);
1980 }
1981
1982 static void
1983 post_ignpar(POST_ARGS)
1984 {
1985 struct mdoc_node *np;
1986
1987 switch (mdoc->last->type) {
1988 case MDOC_HEAD:
1989 post_hyph(mdoc);
1990 return;
1991 case MDOC_BODY:
1992 break;
1993 default:
1994 return;
1995 }
1996
1997 if (NULL != (np = mdoc->last->child))
1998 if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
1999 mandoc_vmsg(MANDOCERR_PAR_SKIP,
2000 mdoc->parse, np->line, np->pos,
2001 "%s after %s", mdoc_macronames[np->tok],
2002 mdoc_macronames[mdoc->last->tok]);
2003 mdoc_node_delete(mdoc, np);
2004 }
2005
2006 if (NULL != (np = mdoc->last->last))
2007 if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
2008 mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2009 np->line, np->pos, "%s at the end of %s",
2010 mdoc_macronames[np->tok],
2011 mdoc_macronames[mdoc->last->tok]);
2012 mdoc_node_delete(mdoc, np);
2013 }
2014 }
2015
2016 static void
2017 pre_par(PRE_ARGS)
2018 {
2019
2020 if (NULL == mdoc->last)
2021 return;
2022 if (MDOC_ELEM != n->type && MDOC_BLOCK != n->type)
2023 return;
2024
2025 /*
2026 * Don't allow prior `Lp' or `Pp' prior to a paragraph-type
2027 * block: `Lp', `Pp', or non-compact `Bd' or `Bl'.
2028 */
2029
2030 if (MDOC_Pp != mdoc->last->tok &&
2031 MDOC_Lp != mdoc->last->tok &&
2032 MDOC_br != mdoc->last->tok)
2033 return;
2034 if (MDOC_Bl == n->tok && n->norm->Bl.comp)
2035 return;
2036 if (MDOC_Bd == n->tok && n->norm->Bd.comp)
2037 return;
2038 if (MDOC_It == n->tok && n->parent->norm->Bl.comp)
2039 return;
2040
2041 mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2042 mdoc->last->line, mdoc->last->pos,
2043 "%s before %s", mdoc_macronames[mdoc->last->tok],
2044 mdoc_macronames[n->tok]);
2045 mdoc_node_delete(mdoc, mdoc->last);
2046 }
2047
2048 static void
2049 post_par(POST_ARGS)
2050 {
2051 struct mdoc_node *np;
2052
2053 np = mdoc->last;
2054
2055 if (np->tok == MDOC_sp) {
2056 if (np->nchild > 1)
2057 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
2058 np->child->next->line, np->child->next->pos,
2059 "sp ... %s", np->child->next->string);
2060 } else if (np->child != NULL)
2061 mandoc_vmsg(MANDOCERR_ARG_SKIP,
2062 mdoc->parse, np->line, np->pos, "%s %s",
2063 mdoc_macronames[np->tok], np->child->string);
2064
2065 if (NULL == (np = mdoc->last->prev)) {
2066 np = mdoc->last->parent;
2067 if (MDOC_Sh != np->tok && MDOC_Ss != np->tok)
2068 return;
2069 } else if (MDOC_Pp != np->tok && MDOC_Lp != np->tok &&
2070 (MDOC_br != mdoc->last->tok ||
2071 (MDOC_sp != np->tok && MDOC_br != np->tok)))
2072 return;
2073
2074 mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2075 mdoc->last->line, mdoc->last->pos,
2076 "%s after %s", mdoc_macronames[mdoc->last->tok],
2077 mdoc_macronames[np->tok]);
2078 mdoc_node_delete(mdoc, mdoc->last);
2079 }
2080
2081 static void
2082 pre_literal(PRE_ARGS)
2083 {
2084
2085 pre_display(mdoc, n);
2086
2087 if (MDOC_BODY != n->type)
2088 return;
2089
2090 /*
2091 * The `Dl' (note "el" not "one") and `Bd -literal' and `Bd
2092 * -unfilled' macros set MDOC_LITERAL on entrance to the body.
2093 */
2094
2095 switch (n->tok) {
2096 case MDOC_Dl:
2097 mdoc->flags |= MDOC_LITERAL;
2098 break;
2099 case MDOC_Bd:
2100 if (DISP_literal == n->norm->Bd.type)
2101 mdoc->flags |= MDOC_LITERAL;
2102 if (DISP_unfilled == n->norm->Bd.type)
2103 mdoc->flags |= MDOC_LITERAL;
2104 break;
2105 default:
2106 abort();
2107 /* NOTREACHED */
2108 }
2109 }
2110
2111 static void
2112 post_dd(POST_ARGS)
2113 {
2114 struct mdoc_node *n;
2115 char *datestr;
2116
2117 if (mdoc->meta.date)
2118 free(mdoc->meta.date);
2119
2120 n = mdoc->last;
2121 if (NULL == n->child || '\0' == n->child->string[0]) {
2122 mdoc->meta.date = mdoc->quick ? mandoc_strdup("") :
2123 mandoc_normdate(mdoc->parse, NULL, n->line, n->pos);
2124 goto out;
2125 }
2126
2127 datestr = NULL;
2128 mdoc_deroff(&datestr, n);
2129 if (mdoc->quick)
2130 mdoc->meta.date = datestr;
2131 else {
2132 mdoc->meta.date = mandoc_normdate(mdoc->parse,
2133 datestr, n->line, n->pos);
2134 free(datestr);
2135 }
2136 out:
2137 mdoc_node_delete(mdoc, n);
2138 }
2139
2140 static void
2141 post_dt(POST_ARGS)
2142 {
2143 struct mdoc_node *nn, *n;
2144 const char *cp;
2145 char *p;
2146
2147 n = mdoc->last;
2148
2149 free(mdoc->meta.title);
2150 free(mdoc->meta.msec);
2151 free(mdoc->meta.vol);
2152 free(mdoc->meta.arch);
2153
2154 mdoc->meta.title = NULL;
2155 mdoc->meta.msec = NULL;
2156 mdoc->meta.vol = NULL;
2157 mdoc->meta.arch = NULL;
2158
2159 /* First check that all characters are uppercase. */
2160
2161 if (NULL != (nn = n->child))
2162 for (p = nn->string; *p; p++) {
2163 if (toupper((unsigned char)*p) == *p)
2164 continue;
2165 mandoc_vmsg(MANDOCERR_TITLE_CASE,
2166 mdoc->parse, nn->line,
2167 nn->pos + (p - nn->string),
2168 "Dt %s", nn->string);
2169 break;
2170 }
2171
2172 /* No argument: msec and arch remain NULL. */
2173
2174 if (NULL == (nn = n->child)) {
2175 mandoc_msg(MANDOCERR_DT_NOTITLE,
2176 mdoc->parse, n->line, n->pos, "Dt");
2177 mdoc->meta.title = mandoc_strdup("UNTITLED");
2178 mdoc->meta.vol = mandoc_strdup("LOCAL");
2179 goto out;
2180 }
2181
2182 /* One argument: msec and arch remain NULL. */
2183
2184 mdoc->meta.title = mandoc_strdup(
2185 '\0' == nn->string[0] ? "UNTITLED" : nn->string);
2186
2187 if (NULL == (nn = nn->next)) {
2188 mandoc_vmsg(MANDOCERR_MSEC_MISSING,
2189 mdoc->parse, n->line, n->pos,
2190 "Dt %s", mdoc->meta.title);
2191 mdoc->meta.vol = mandoc_strdup("LOCAL");
2192 goto out;
2193 }
2194
2195 /* Handles: `.Dt TITLE SEC'
2196 * title = TITLE,
2197 * volume = SEC is msec ? format(msec) : SEC,
2198 * msec = SEC is msec ? atoi(msec) : 0,
2199 * arch = NULL
2200 */
2201
2202 cp = mandoc_a2msec(nn->string);
2203 if (cp) {
2204 mdoc->meta.vol = mandoc_strdup(cp);
2205 mdoc->meta.msec = mandoc_strdup(nn->string);
2206 } else {
2207 mandoc_vmsg(MANDOCERR_MSEC_BAD, mdoc->parse,
2208 nn->line, nn->pos, "Dt ... %s", nn->string);
2209 mdoc->meta.vol = mandoc_strdup(nn->string);
2210 mdoc->meta.msec = mandoc_strdup(nn->string);
2211 }
2212
2213 /* Handle an optional architecture */
2214
2215 if ((nn = nn->next) != NULL) {
2216 for (p = nn->string; *p; p++)
2217 *p = tolower((unsigned char)*p);
2218 mdoc->meta.arch = mandoc_strdup(nn->string);
2219 }
2220
2221 /* Ignore any subsequent parameters... */
2222 /* FIXME: warn about subsequent parameters. */
2223 out:
2224 mdoc_node_delete(mdoc, n);
2225 }
2226
2227 static void
2228 post_bx(POST_ARGS)
2229 {
2230 struct mdoc_node *n;
2231
2232 /*
2233 * Make `Bx's second argument always start with an uppercase
2234 * letter. Groff checks if it's an "accepted" term, but we just
2235 * uppercase blindly.
2236 */
2237
2238 n = mdoc->last->child;
2239 if (n && NULL != (n = n->next))
2240 *n->string = (char)toupper((unsigned char)*n->string);
2241 }
2242
2243 static void
2244 post_os(POST_ARGS)
2245 {
2246 #ifndef OSNAME
2247 struct utsname utsname;
2248 static char *defbuf;
2249 #endif
2250 struct mdoc_node *n;
2251
2252 n = mdoc->last;
2253
2254 /*
2255 * Set the operating system by way of the `Os' macro.
2256 * The order of precedence is:
2257 * 1. the argument of the `Os' macro, unless empty
2258 * 2. the -Ios=foo command line argument, if provided
2259 * 3. -DOSNAME="\"foo\"", if provided during compilation
2260 * 4. "sysname release" from uname(3)
2261 */
2262
2263 free(mdoc->meta.os);
2264 mdoc->meta.os = NULL;
2265 mdoc_deroff(&mdoc->meta.os, n);
2266 if (mdoc->meta.os)
2267 goto out;
2268
2269 if (mdoc->defos) {
2270 mdoc->meta.os = mandoc_strdup(mdoc->defos);
2271 goto out;
2272 }
2273
2274 #ifdef OSNAME
2275 mdoc->meta.os = mandoc_strdup(OSNAME);
2276 #else /*!OSNAME */
2277 if (NULL == defbuf) {
2278 if (-1 == uname(&utsname)) {
2279 mandoc_msg(MANDOCERR_OS_UNAME, mdoc->parse,
2280 n->line, n->pos, "Os");
2281 defbuf = mandoc_strdup("UNKNOWN");
2282 } else
2283 mandoc_asprintf(&defbuf, "%s %s",
2284 utsname.sysname, utsname.release);
2285 }
2286 mdoc->meta.os = mandoc_strdup(defbuf);
2287 #endif /*!OSNAME*/
2288
2289 out:
2290 mdoc_node_delete(mdoc, n);
2291 }
2292
2293 /*
2294 * If no argument is provided,
2295 * fill in the name of the current manual page.
2296 */
2297 static void
2298 post_ex(POST_ARGS)
2299 {
2300 struct mdoc_node *n;
2301
2302 n = mdoc->last;
2303
2304 if (n->child)
2305 return;
2306
2307 if (mdoc->meta.name == NULL) {
2308 mandoc_msg(MANDOCERR_EX_NONAME, mdoc->parse,
2309 n->line, n->pos, "Ex");
2310 return;
2311 }
2312
2313 mdoc->next = MDOC_NEXT_CHILD;
2314 mdoc_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);
2315 mdoc->last = n;
2316 }
2317
2318 static enum mdoc_sec
2319 a2sec(const char *p)
2320 {
2321 int i;
2322
2323 for (i = 0; i < (int)SEC__MAX; i++)
2324 if (secnames[i] && 0 == strcmp(p, secnames[i]))
2325 return((enum mdoc_sec)i);
2326
2327 return(SEC_CUSTOM);
2328 }
2329
2330 static size_t
2331 macro2len(enum mdoct macro)
2332 {
2333
2334 switch (macro) {
2335 case MDOC_Ad:
2336 return(12);
2337 case MDOC_Ao:
2338 return(12);
2339 case MDOC_An:
2340 return(12);
2341 case MDOC_Aq:
2342 return(12);
2343 case MDOC_Ar:
2344 return(12);
2345 case MDOC_Bo:
2346 return(12);
2347 case MDOC_Bq:
2348 return(12);
2349 case MDOC_Cd:
2350 return(12);
2351 case MDOC_Cm:
2352 return(10);
2353 case MDOC_Do:
2354 return(10);
2355 case MDOC_Dq:
2356 return(12);
2357 case MDOC_Dv:
2358 return(12);
2359 case MDOC_Eo:
2360 return(12);
2361 case MDOC_Em:
2362 return(10);
2363 case MDOC_Er:
2364 return(17);
2365 case MDOC_Ev:
2366 return(15);
2367 case MDOC_Fa:
2368 return(12);
2369 case MDOC_Fl:
2370 return(10);
2371 case MDOC_Fo:
2372 return(16);
2373 case MDOC_Fn:
2374 return(16);
2375 case MDOC_Ic:
2376 return(10);
2377 case MDOC_Li:
2378 return(16);
2379 case MDOC_Ms:
2380 return(6);
2381 case MDOC_Nm:
2382 return(10);
2383 case MDOC_No:
2384 return(12);
2385 case MDOC_Oo:
2386 return(10);
2387 case MDOC_Op:
2388 return(14);
2389 case MDOC_Pa:
2390 return(32);
2391 case MDOC_Pf:
2392 return(12);
2393 case MDOC_Po:
2394 return(12);
2395 case MDOC_Pq:
2396 return(12);
2397 case MDOC_Ql:
2398 return(16);
2399 case MDOC_Qo:
2400 return(12);
2401 case MDOC_So:
2402 return(12);
2403 case MDOC_Sq:
2404 return(12);
2405 case MDOC_Sy:
2406 return(6);
2407 case MDOC_Sx:
2408 return(16);
2409 case MDOC_Tn:
2410 return(10);
2411 case MDOC_Va:
2412 return(12);
2413 case MDOC_Vt:
2414 return(12);
2415 case MDOC_Xr:
2416 return(10);
2417 default:
2418 break;
2419 };
2420 return(0);
2421 }
A git conversion mirror of mandoc.bsd.lv