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