contrib/mdocml/mdoc_validate.c

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