contrib/mdocml/mdoc_validate.c

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