contrib/mandoc/mdoc_validate.c

   1 /*      $Id: mdoc_validate.c,v 1.360 2018/08/01 16:00:58 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010-2018 Ingo Schwarze <schwarze@openbsd.org>
   5  * Copyright (c) 2010 Joerg Sonnenberger <joerg@netbsd.org>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include "config.h"
  20
  21 #include <sys/types.h>
  22 #ifndef OSNAME
  23 #include <sys/utsname.h>
  24 #endif
  25
  26 #include <assert.h>
  27 #include <ctype.h>
  28 #include <limits.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <time.h>
  33
  34 #include "mandoc_aux.h"
  35 #include "mandoc.h"
  36 #include "mandoc_xr.h"
  37 #include "roff.h"
  38 #include "mdoc.h"
  39 #include "libmandoc.h"
  40 #include "roff_int.h"
  41 #include "libmdoc.h"
  42
  43 /* FIXME: .Bl -diag can't have non-text children in HEAD. */
  44
  45 #define POST_ARGS struct roff_man *mdoc
  46
  47 enum    check_ineq {
  48         CHECK_LT,
  49         CHECK_GT,
  50         CHECK_EQ
  51 };
  52
  53 typedef void    (*v_post)(POST_ARGS);
  54
  55 static  int      build_list(struct roff_man *, int);
  56 static  void     check_argv(struct roff_man *,
  57                         struct roff_node *, struct mdoc_argv *);
  58 static  void     check_args(struct roff_man *, struct roff_node *);
  59 static  void     check_text(struct roff_man *, int, int, char *);
  60 static  void     check_text_em(struct roff_man *, int, int, char *);
  61 static  void     check_toptext(struct roff_man *, int, int, const char *);
  62 static  int      child_an(const struct roff_node *);
  63 static  size_t          macro2len(enum roff_tok);
  64 static  void     rewrite_macro2len(struct roff_man *, char **);
  65 static  int      similar(const char *, const char *);
  66
  67 static  void     post_an(POST_ARGS);
  68 static  void     post_an_norm(POST_ARGS);
  69 static  void     post_at(POST_ARGS);
  70 static  void     post_bd(POST_ARGS);
  71 static  void     post_bf(POST_ARGS);
  72 static  void     post_bk(POST_ARGS);
  73 static  void     post_bl(POST_ARGS);
  74 static  void     post_bl_block(POST_ARGS);
  75 static  void     post_bl_head(POST_ARGS);
  76 static  void     post_bl_norm(POST_ARGS);
  77 static  void     post_bx(POST_ARGS);
  78 static  void     post_defaults(POST_ARGS);
  79 static  void     post_display(POST_ARGS);
  80 static  void     post_dd(POST_ARGS);
  81 static  void     post_delim(POST_ARGS);
  82 static  void     post_delim_nb(POST_ARGS);
  83 static  void     post_dt(POST_ARGS);
  84 static  void     post_en(POST_ARGS);
  85 static  void     post_es(POST_ARGS);
  86 static  void     post_eoln(POST_ARGS);
  87 static  void     post_ex(POST_ARGS);
  88 static  void     post_fa(POST_ARGS);
  89 static  void     post_fn(POST_ARGS);
  90 static  void     post_fname(POST_ARGS);
  91 static  void     post_fo(POST_ARGS);
  92 static  void     post_hyph(POST_ARGS);
  93 static  void     post_ignpar(POST_ARGS);
  94 static  void     post_it(POST_ARGS);
  95 static  void     post_lb(POST_ARGS);
  96 static  void     post_nd(POST_ARGS);
  97 static  void     post_nm(POST_ARGS);
  98 static  void     post_ns(POST_ARGS);
  99 static  void     post_obsolete(POST_ARGS);
 100 static  void     post_os(POST_ARGS);
 101 static  void     post_par(POST_ARGS);
 102 static  void     post_prevpar(POST_ARGS);
 103 static  void     post_root(POST_ARGS);
 104 static  void     post_rs(POST_ARGS);
 105 static  void     post_rv(POST_ARGS);
 106 static  void     post_sh(POST_ARGS);
 107 static  void     post_sh_head(POST_ARGS);
 108 static  void     post_sh_name(POST_ARGS);
 109 static  void     post_sh_see_also(POST_ARGS);
 110 static  void     post_sh_authors(POST_ARGS);
 111 static  void     post_sm(POST_ARGS);
 112 static  void     post_st(POST_ARGS);
 113 static  void     post_std(POST_ARGS);
 114 static  void     post_sx(POST_ARGS);
 115 static  void     post_useless(POST_ARGS);
 116 static  void     post_xr(POST_ARGS);
 117 static  void     post_xx(POST_ARGS);
 118
 119 static  const v_post __mdoc_valids[MDOC_MAX - MDOC_Dd] = {
 120         post_dd,        /* Dd */
 121         post_dt,        /* Dt */
 122         post_os,        /* Os */
 123         post_sh,        /* Sh */
 124         post_ignpar,    /* Ss */
 125         post_par,       /* Pp */
 126         post_display,   /* D1 */
 127         post_display,   /* Dl */
 128         post_display,   /* Bd */
 129         NULL,           /* Ed */
 130         post_bl,        /* Bl */
 131         NULL,           /* El */
 132         post_it,        /* It */
 133         post_delim_nb,  /* Ad */
 134         post_an,        /* An */
 135         NULL,           /* Ap */
 136         post_defaults,  /* Ar */
 137         NULL,           /* Cd */
 138         post_delim_nb,  /* Cm */
 139         post_delim_nb,  /* Dv */
 140         post_delim_nb,  /* Er */
 141         post_delim_nb,  /* Ev */
 142         post_ex,        /* Ex */
 143         post_fa,        /* Fa */
 144         NULL,           /* Fd */
 145         post_delim_nb,  /* Fl */
 146         post_fn,        /* Fn */
 147         post_delim_nb,  /* Ft */
 148         post_delim_nb,  /* Ic */
 149         post_delim_nb,  /* In */
 150         post_defaults,  /* Li */
 151         post_nd,        /* Nd */
 152         post_nm,        /* Nm */
 153         post_delim_nb,  /* Op */
 154         post_obsolete,  /* Ot */
 155         post_defaults,  /* Pa */
 156         post_rv,        /* Rv */
 157         post_st,        /* St */
 158         post_delim_nb,  /* Va */
 159         post_delim_nb,  /* Vt */
 160         post_xr,        /* Xr */
 161         NULL,           /* %A */
 162         post_hyph,      /* %B */ /* FIXME: can be used outside Rs/Re. */
 163         NULL,           /* %D */
 164         NULL,           /* %I */
 165         NULL,           /* %J */
 166         post_hyph,      /* %N */
 167         post_hyph,      /* %O */
 168         NULL,           /* %P */
 169         post_hyph,      /* %R */
 170         post_hyph,      /* %T */ /* FIXME: can be used outside Rs/Re. */
 171         NULL,           /* %V */
 172         NULL,           /* Ac */
 173         NULL,           /* Ao */
 174         post_delim_nb,  /* Aq */
 175         post_at,        /* At */
 176         NULL,           /* Bc */
 177         post_bf,        /* Bf */
 178         NULL,           /* Bo */
 179         NULL,           /* Bq */
 180         post_xx,        /* Bsx */
 181         post_bx,        /* Bx */
 182         post_obsolete,  /* Db */
 183         NULL,           /* Dc */
 184         NULL,           /* Do */
 185         NULL,           /* Dq */
 186         NULL,           /* Ec */
 187         NULL,           /* Ef */
 188         post_delim_nb,  /* Em */
 189         NULL,           /* Eo */
 190         post_xx,        /* Fx */
 191         post_delim_nb,  /* Ms */
 192         NULL,           /* No */
 193         post_ns,        /* Ns */
 194         post_xx,        /* Nx */
 195         post_xx,        /* Ox */
 196         NULL,           /* Pc */
 197         NULL,           /* Pf */
 198         NULL,           /* Po */
 199         post_delim_nb,  /* Pq */
 200         NULL,           /* Qc */
 201         post_delim_nb,  /* Ql */
 202         NULL,           /* Qo */
 203         post_delim_nb,  /* Qq */
 204         NULL,           /* Re */
 205         post_rs,        /* Rs */
 206         NULL,           /* Sc */
 207         NULL,           /* So */
 208         post_delim_nb,  /* Sq */
 209         post_sm,        /* Sm */
 210         post_sx,        /* Sx */
 211         post_delim_nb,  /* Sy */
 212         post_useless,   /* Tn */
 213         post_xx,        /* Ux */
 214         NULL,           /* Xc */
 215         NULL,           /* Xo */
 216         post_fo,        /* Fo */
 217         NULL,           /* Fc */
 218         NULL,           /* Oo */
 219         NULL,           /* Oc */
 220         post_bk,        /* Bk */
 221         NULL,           /* Ek */
 222         post_eoln,      /* Bt */
 223         post_obsolete,  /* Hf */
 224         post_obsolete,  /* Fr */
 225         post_eoln,      /* Ud */
 226         post_lb,        /* Lb */
 227         post_par,       /* Lp */
 228         post_delim_nb,  /* Lk */
 229         post_defaults,  /* Mt */
 230         post_delim_nb,  /* Brq */
 231         NULL,           /* Bro */
 232         NULL,           /* Brc */
 233         NULL,           /* %C */
 234         post_es,        /* Es */
 235         post_en,        /* En */
 236         post_xx,        /* Dx */
 237         NULL,           /* %Q */
 238         NULL,           /* %U */
 239         NULL,           /* Ta */
 240 };
 241 static  const v_post *const mdoc_valids = __mdoc_valids - MDOC_Dd;
 242
 243 #define RSORD_MAX 14 /* Number of `Rs' blocks. */
 244
 245 static  const enum roff_tok rsord[RSORD_MAX] = {
 246         MDOC__A,
 247         MDOC__T,
 248         MDOC__B,
 249         MDOC__I,
 250         MDOC__J,
 251         MDOC__R,
 252         MDOC__N,
 253         MDOC__V,
 254         MDOC__U,
 255         MDOC__P,
 256         MDOC__Q,
 257         MDOC__C,
 258         MDOC__D,
 259         MDOC__O
 260 };
 261
 262 static  const char * const secnames[SEC__MAX] = {
 263         NULL,
 264         "NAME",
 265         "LIBRARY",
 266         "SYNOPSIS",
 267         "DESCRIPTION",
 268         "CONTEXT",
 269         "IMPLEMENTATION NOTES",
 270         "RETURN VALUES",
 271         "ENVIRONMENT",
 272         "FILES",
 273         "EXIT STATUS",
 274         "EXAMPLES",
 275         "DIAGNOSTICS",
 276         "COMPATIBILITY",
 277         "ERRORS",
 278         "SEE ALSO",
 279         "STANDARDS",
 280         "HISTORY",
 281         "AUTHORS",
 282         "CAVEATS",
 283         "BUGS",
 284         "SECURITY CONSIDERATIONS",
 285         NULL
 286 };
 287
 288
 289 void
 290 mdoc_node_validate(struct roff_man *mdoc)
 291 {
 292         struct roff_node *n, *np;
 293         const v_post *p;
 294
 295         n = mdoc->last;
 296         mdoc->last = mdoc->last->child;
 297         while (mdoc->last != NULL) {
 298                 mdoc_node_validate(mdoc);
 299                 if (mdoc->last == n)
 300                         mdoc->last = mdoc->last->child;
 301                 else
 302                         mdoc->last = mdoc->last->next;
 303         }
 304
 305         mdoc->last = n;
 306         mdoc->next = ROFF_NEXT_SIBLING;
 307         switch (n->type) {
 308         case ROFFT_TEXT:
 309                 np = n->parent;
 310                 if (n->sec != SEC_SYNOPSIS ||
 311                     (np->tok != MDOC_Cd && np->tok != MDOC_Fd))
 312                         check_text(mdoc, n->line, n->pos, n->string);
 313                 if (np->tok != MDOC_Ql && np->tok != MDOC_Dl &&
 314                     (np->tok != MDOC_Bd ||
 315                      (mdoc->flags & MDOC_LITERAL) == 0) &&
 316                     (np->tok != MDOC_It || np->type != ROFFT_HEAD ||
 317                      np->parent->parent->norm->Bl.type != LIST_diag))
 318                         check_text_em(mdoc, n->line, n->pos, n->string);
 319                 if (np->tok == MDOC_It || (np->type == ROFFT_BODY &&
 320                     (np->tok == MDOC_Sh || np->tok == MDOC_Ss)))
 321                         check_toptext(mdoc, n->line, n->pos, n->string);
 322                 break;
 323         case ROFFT_COMMENT:
 324         case ROFFT_EQN:
 325         case ROFFT_TBL:
 326                 break;
 327         case ROFFT_ROOT:
 328                 post_root(mdoc);
 329                 break;
 330         default:
 331                 check_args(mdoc, mdoc->last);
 332
 333                 /*
 334                  * Closing delimiters are not special at the
 335                  * beginning of a block, opening delimiters
 336                  * are not special at the end.
 337                  */
 338
 339                 if (n->child != NULL)
 340                         n->child->flags &= ~NODE_DELIMC;
 341                 if (n->last != NULL)
 342                         n->last->flags &= ~NODE_DELIMO;
 343
 344                 /* Call the macro's postprocessor. */
 345
 346                 if (n->tok < ROFF_MAX) {
 347                         switch(n->tok) {
 348                         case ROFF_br:
 349                         case ROFF_sp:
 350                                 post_par(mdoc);
 351                                 break;
 352                         default:
 353                                 roff_validate(mdoc);
 354                                 break;
 355                         }
 356                         break;
 357                 }
 358
 359                 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
 360                 p = mdoc_valids + n->tok;
 361                 if (*p)
 362                         (*p)(mdoc);
 363                 if (mdoc->last == n)
 364                         mdoc_state(mdoc, n);
 365                 break;
 366         }
 367 }
 368
 369 static void
 370 check_args(struct roff_man *mdoc, struct roff_node *n)
 371 {
 372         int              i;
 373
 374         if (NULL == n->args)
 375                 return;
 376
 377         assert(n->args->argc);
 378         for (i = 0; i < (int)n->args->argc; i++)
 379                 check_argv(mdoc, n, &n->args->argv[i]);
 380 }
 381
 382 static void
 383 check_argv(struct roff_man *mdoc, struct roff_node *n, struct mdoc_argv *v)
 384 {
 385         int              i;
 386
 387         for (i = 0; i < (int)v->sz; i++)
 388                 check_text(mdoc, v->line, v->pos, v->value[i]);
 389 }
 390
 391 static void
 392 check_text(struct roff_man *mdoc, int ln, int pos, char *p)
 393 {
 394         char            *cp;
 395
 396         if (MDOC_LITERAL & mdoc->flags)
 397                 return;
 398
 399         for (cp = p; NULL != (p = strchr(p, '\t')); p++)
 400                 mandoc_msg(MANDOCERR_FI_TAB, mdoc->parse,
 401                     ln, pos + (int)(p - cp), NULL);
 402 }
 403
 404 static void
 405 check_text_em(struct roff_man *mdoc, int ln, int pos, char *p)
 406 {
 407         const struct roff_node  *np, *nn;
 408         char                    *cp;
 409
 410         np = mdoc->last->prev;
 411         nn = mdoc->last->next;
 412
 413         /* Look for em-dashes wrongly encoded as "--". */
 414
 415         for (cp = p; *cp != '\0'; cp++) {
 416                 if (cp[0] != '-' || cp[1] != '-')
 417                         continue;
 418                 cp++;
 419
 420                 /* Skip input sequences of more than two '-'. */
 421
 422                 if (cp[1] == '-') {
 423                         while (cp[1] == '-')
 424                                 cp++;
 425                         continue;
 426                 }
 427
 428                 /* Skip "--" directly attached to something else. */
 429
 430                 if ((cp - p > 1 && cp[-2] != ' ') ||
 431                     (cp[1] != '\0' && cp[1] != ' '))
 432                         continue;
 433
 434                 /* Require a letter right before or right afterwards. */
 435
 436                 if ((cp - p > 2 ?
 437                      isalpha((unsigned char)cp[-3]) :
 438                      np != NULL &&
 439                      np->type == ROFFT_TEXT &&
 440                      *np->string != '\0' &&
 441                      isalpha((unsigned char)np->string[
 442                        strlen(np->string) - 1])) ||
 443                     (cp[1] != '\0' && cp[2] != '\0' ?
 444                      isalpha((unsigned char)cp[2]) :
 445                      nn != NULL &&
 446                      nn->type == ROFFT_TEXT &&
 447                      isalpha((unsigned char)*nn->string))) {
 448                         mandoc_msg(MANDOCERR_DASHDASH, mdoc->parse,
 449                             ln, pos + (int)(cp - p) - 1, NULL);
 450                         break;
 451                 }
 452         }
 453 }
 454
 455 static void
 456 check_toptext(struct roff_man *mdoc, int ln, int pos, const char *p)
 457 {
 458         const char      *cp, *cpr;
 459
 460         if (*p == '\0')
 461                 return;
 462
 463         if ((cp = strstr(p, "OpenBSD")) != NULL)
 464                 mandoc_msg(MANDOCERR_BX, mdoc->parse,
 465                     ln, pos + (cp - p), "Ox");
 466         if ((cp = strstr(p, "NetBSD")) != NULL)
 467                 mandoc_msg(MANDOCERR_BX, mdoc->parse,
 468                     ln, pos + (cp - p), "Nx");
 469         if ((cp = strstr(p, "FreeBSD")) != NULL)
 470                 mandoc_msg(MANDOCERR_BX, mdoc->parse,
 471                     ln, pos + (cp - p), "Fx");
 472         if ((cp = strstr(p, "DragonFly")) != NULL)
 473                 mandoc_msg(MANDOCERR_BX, mdoc->parse,
 474                     ln, pos + (cp - p), "Dx");
 475
 476         cp = p;
 477         while ((cp = strstr(cp + 1, "()")) != NULL) {
 478                 for (cpr = cp - 1; cpr >= p; cpr--)
 479                         if (*cpr != '_' && !isalnum((unsigned char)*cpr))
 480                                 break;
 481                 if ((cpr < p || *cpr == ' ') && cpr + 1 < cp) {
 482                         cpr++;
 483                         mandoc_vmsg(MANDOCERR_FUNC, mdoc->parse,
 484                             ln, pos + (cpr - p),
 485                             "%.*s()", (int)(cp - cpr), cpr);
 486                 }
 487         }
 488 }
 489
 490 static void
 491 post_delim(POST_ARGS)
 492 {
 493         const struct roff_node  *nch;
 494         const char              *lc;
 495         enum mdelim              delim;
 496         enum roff_tok            tok;
 497
 498         tok = mdoc->last->tok;
 499         nch = mdoc->last->last;
 500         if (nch == NULL || nch->type != ROFFT_TEXT)
 501                 return;
 502         lc = strchr(nch->string, '\0') - 1;
 503         if (lc < nch->string)
 504                 return;
 505         delim = mdoc_isdelim(lc);
 506         if (delim == DELIM_NONE || delim == DELIM_OPEN)
 507                 return;
 508         if (*lc == ')' && (tok == MDOC_Nd || tok == MDOC_Sh ||
 509             tok == MDOC_Ss || tok == MDOC_Fo))
 510                 return;
 511
 512         mandoc_vmsg(MANDOCERR_DELIM, mdoc->parse,
 513             nch->line, nch->pos + (lc - nch->string),
 514             "%s%s %s", roff_name[tok],
 515             nch == mdoc->last->child ? "" : " ...", nch->string);
 516 }
 517
 518 static void
 519 post_delim_nb(POST_ARGS)
 520 {
 521         const struct roff_node  *nch;
 522         const char              *lc, *cp;
 523         int                      nw;
 524         enum mdelim              delim;
 525         enum roff_tok            tok;
 526
 527         /*
 528          * Find candidates: at least two bytes,
 529          * the last one a closing or middle delimiter.
 530          */
 531
 532         tok = mdoc->last->tok;
 533         nch = mdoc->last->last;
 534         if (nch == NULL || nch->type != ROFFT_TEXT)
 535                 return;
 536         lc = strchr(nch->string, '\0') - 1;
 537         if (lc <= nch->string)
 538                 return;
 539         delim = mdoc_isdelim(lc);
 540         if (delim == DELIM_NONE || delim == DELIM_OPEN)
 541                 return;
 542
 543         /*
 544          * Reduce false positives by allowing various cases.
 545          */
 546
 547         /* Escaped delimiters. */
 548         if (lc > nch->string + 1 && lc[-2] == '\\' &&
 549             (lc[-1] == '&' || lc[-1] == 'e'))
 550                 return;
 551
 552         /* Specific byte sequences. */
 553         switch (*lc) {
 554         case ')':
 555                 for (cp = lc; cp >= nch->string; cp--)
 556                         if (*cp == '(')
 557                                 return;
 558                 break;
 559         case '.':
 560                 if (lc > nch->string + 1 && lc[-2] == '.' && lc[-1] == '.')
 561                         return;
 562                 if (lc[-1] == '.')
 563                         return;
 564                 break;
 565         case ';':
 566                 if (tok == MDOC_Vt)
 567                         return;
 568                 break;
 569         case '?':
 570                 if (lc[-1] == '?')
 571                         return;
 572                 break;
 573         case ']':
 574                 for (cp = lc; cp >= nch->string; cp--)
 575                         if (*cp == '[')
 576                                 return;
 577                 break;
 578         case '|':
 579                 if (lc == nch->string + 1 && lc[-1] == '|')
 580                         return;
 581         default:
 582                 break;
 583         }
 584
 585         /* Exactly two non-alphanumeric bytes. */
 586         if (lc == nch->string + 1 && !isalnum((unsigned char)lc[-1]))
 587                 return;
 588
 589         /* At least three alphabetic words with a sentence ending. */
 590         if (strchr("!.:?", *lc) != NULL && (tok == MDOC_Em ||
 591             tok == MDOC_Li || tok == MDOC_Pq || tok == MDOC_Sy)) {
 592                 nw = 0;
 593                 for (cp = lc - 1; cp >= nch->string; cp--) {
 594                         if (*cp == ' ') {
 595                                 nw++;
 596                                 if (cp > nch->string && cp[-1] == ',')
 597                                         cp--;
 598                         } else if (isalpha((unsigned int)*cp)) {
 599                                 if (nw > 1)
 600                                         return;
 601                         } else
 602                                 break;
 603                 }
 604         }
 605
 606         mandoc_vmsg(MANDOCERR_DELIM_NB, mdoc->parse,
 607             nch->line, nch->pos + (lc - nch->string),
 608             "%s%s %s", roff_name[tok],
 609             nch == mdoc->last->child ? "" : " ...", nch->string);
 610 }
 611
 612 static void
 613 post_bl_norm(POST_ARGS)
 614 {
 615         struct roff_node *n;
 616         struct mdoc_argv *argv, *wa;
 617         int               i;
 618         enum mdocargt     mdoclt;
 619         enum mdoc_list    lt;
 620
 621         n = mdoc->last->parent;
 622         n->norm->Bl.type = LIST__NONE;
 623
 624         /*
 625          * First figure out which kind of list to use: bind ourselves to
 626          * the first mentioned list type and warn about any remaining
 627          * ones.  If we find no list type, we default to LIST_item.
 628          */
 629
 630         wa = (n->args == NULL) ? NULL : n->args->argv;
 631         mdoclt = MDOC_ARG_MAX;
 632         for (i = 0; n->args && i < (int)n->args->argc; i++) {
 633                 argv = n->args->argv + i;
 634                 lt = LIST__NONE;
 635                 switch (argv->arg) {
 636                 /* Set list types. */
 637                 case MDOC_Bullet:
 638                         lt = LIST_bullet;
 639                         break;
 640                 case MDOC_Dash:
 641                         lt = LIST_dash;
 642                         break;
 643                 case MDOC_Enum:
 644                         lt = LIST_enum;
 645                         break;
 646                 case MDOC_Hyphen:
 647                         lt = LIST_hyphen;
 648                         break;
 649                 case MDOC_Item:
 650                         lt = LIST_item;
 651                         break;
 652                 case MDOC_Tag:
 653                         lt = LIST_tag;
 654                         break;
 655                 case MDOC_Diag:
 656                         lt = LIST_diag;
 657                         break;
 658                 case MDOC_Hang:
 659                         lt = LIST_hang;
 660                         break;
 661                 case MDOC_Ohang:
 662                         lt = LIST_ohang;
 663                         break;
 664                 case MDOC_Inset:
 665                         lt = LIST_inset;
 666                         break;
 667                 case MDOC_Column:
 668                         lt = LIST_column;
 669                         break;
 670                 /* Set list arguments. */
 671                 case MDOC_Compact:
 672                         if (n->norm->Bl.comp)
 673                                 mandoc_msg(MANDOCERR_ARG_REP,
 674                                     mdoc->parse, argv->line,
 675                                     argv->pos, "Bl -compact");
 676                         n->norm->Bl.comp = 1;
 677                         break;
 678                 case MDOC_Width:
 679                         wa = argv;
 680                         if (0 == argv->sz) {
 681                                 mandoc_msg(MANDOCERR_ARG_EMPTY,
 682                                     mdoc->parse, argv->line,
 683                                     argv->pos, "Bl -width");
 684                                 n->norm->Bl.width = "0n";
 685                                 break;
 686                         }
 687                         if (NULL != n->norm->Bl.width)
 688                                 mandoc_vmsg(MANDOCERR_ARG_REP,
 689                                     mdoc->parse, argv->line,
 690                                     argv->pos, "Bl -width %s",
 691                                     argv->value[0]);
 692                         rewrite_macro2len(mdoc, argv->value);
 693                         n->norm->Bl.width = argv->value[0];
 694                         break;
 695                 case MDOC_Offset:
 696                         if (0 == argv->sz) {
 697                                 mandoc_msg(MANDOCERR_ARG_EMPTY,
 698                                     mdoc->parse, argv->line,
 699                                     argv->pos, "Bl -offset");
 700                                 break;
 701                         }
 702                         if (NULL != n->norm->Bl.offs)
 703                                 mandoc_vmsg(MANDOCERR_ARG_REP,
 704                                     mdoc->parse, argv->line,
 705                                     argv->pos, "Bl -offset %s",
 706                                     argv->value[0]);
 707                         rewrite_macro2len(mdoc, argv->value);
 708                         n->norm->Bl.offs = argv->value[0];
 709                         break;
 710                 default:
 711                         continue;
 712                 }
 713                 if (LIST__NONE == lt)
 714                         continue;
 715                 mdoclt = argv->arg;
 716
 717                 /* Check: multiple list types. */
 718
 719                 if (LIST__NONE != n->norm->Bl.type) {
 720                         mandoc_vmsg(MANDOCERR_BL_REP,
 721                             mdoc->parse, n->line, n->pos,
 722                             "Bl -%s", mdoc_argnames[argv->arg]);
 723                         continue;
 724                 }
 725
 726                 /* The list type should come first. */
 727
 728                 if (n->norm->Bl.width ||
 729                     n->norm->Bl.offs ||
 730                     n->norm->Bl.comp)
 731                         mandoc_vmsg(MANDOCERR_BL_LATETYPE,
 732                             mdoc->parse, n->line, n->pos, "Bl -%s",
 733                             mdoc_argnames[n->args->argv[0].arg]);
 734
 735                 n->norm->Bl.type = lt;
 736                 if (LIST_column == lt) {
 737                         n->norm->Bl.ncols = argv->sz;
 738                         n->norm->Bl.cols = (void *)argv->value;
 739                 }
 740         }
 741
 742         /* Allow lists to default to LIST_item. */
 743
 744         if (LIST__NONE == n->norm->Bl.type) {
 745                 mandoc_msg(MANDOCERR_BL_NOTYPE, mdoc->parse,
 746                     n->line, n->pos, "Bl");
 747                 n->norm->Bl.type = LIST_item;
 748                 mdoclt = MDOC_Item;
 749         }
 750
 751         /*
 752          * Validate the width field.  Some list types don't need width
 753          * types and should be warned about them.  Others should have it
 754          * and must also be warned.  Yet others have a default and need
 755          * no warning.
 756          */
 757
 758         switch (n->norm->Bl.type) {
 759         case LIST_tag:
 760                 if (n->norm->Bl.width == NULL)
 761                         mandoc_msg(MANDOCERR_BL_NOWIDTH, mdoc->parse,
 762                             n->line, n->pos, "Bl -tag");
 763                 break;
 764         case LIST_column:
 765         case LIST_diag:
 766         case LIST_ohang:
 767         case LIST_inset:
 768         case LIST_item:
 769                 if (n->norm->Bl.width != NULL)
 770                         mandoc_vmsg(MANDOCERR_BL_SKIPW, mdoc->parse,
 771                             wa->line, wa->pos, "Bl -%s",
 772                             mdoc_argnames[mdoclt]);
 773                 n->norm->Bl.width = NULL;
 774                 break;
 775         case LIST_bullet:
 776         case LIST_dash:
 777         case LIST_hyphen:
 778                 if (n->norm->Bl.width == NULL)
 779                         n->norm->Bl.width = "2n";
 780                 break;
 781         case LIST_enum:
 782                 if (n->norm->Bl.width == NULL)
 783                         n->norm->Bl.width = "3n";
 784                 break;
 785         default:
 786                 break;
 787         }
 788 }
 789
 790 static void
 791 post_bd(POST_ARGS)
 792 {
 793         struct roff_node *n;
 794         struct mdoc_argv *argv;
 795         int               i;
 796         enum mdoc_disp    dt;
 797
 798         n = mdoc->last;
 799         for (i = 0; n->args && i < (int)n->args->argc; i++) {
 800                 argv = n->args->argv + i;
 801                 dt = DISP__NONE;
 802
 803                 switch (argv->arg) {
 804                 case MDOC_Centred:
 805                         dt = DISP_centered;
 806                         break;
 807                 case MDOC_Ragged:
 808                         dt = DISP_ragged;
 809                         break;
 810                 case MDOC_Unfilled:
 811                         dt = DISP_unfilled;
 812                         break;
 813                 case MDOC_Filled:
 814                         dt = DISP_filled;
 815                         break;
 816                 case MDOC_Literal:
 817                         dt = DISP_literal;
 818                         break;
 819                 case MDOC_File:
 820                         mandoc_msg(MANDOCERR_BD_FILE, mdoc->parse,
 821                             n->line, n->pos, NULL);
 822                         break;
 823                 case MDOC_Offset:
 824                         if (0 == argv->sz) {
 825                                 mandoc_msg(MANDOCERR_ARG_EMPTY,
 826                                     mdoc->parse, argv->line,
 827                                     argv->pos, "Bd -offset");
 828                                 break;
 829                         }
 830                         if (NULL != n->norm->Bd.offs)
 831                                 mandoc_vmsg(MANDOCERR_ARG_REP,
 832                                     mdoc->parse, argv->line,
 833                                     argv->pos, "Bd -offset %s",
 834                                     argv->value[0]);
 835                         rewrite_macro2len(mdoc, argv->value);
 836                         n->norm->Bd.offs = argv->value[0];
 837                         break;
 838                 case MDOC_Compact:
 839                         if (n->norm->Bd.comp)
 840                                 mandoc_msg(MANDOCERR_ARG_REP,
 841                                     mdoc->parse, argv->line,
 842                                     argv->pos, "Bd -compact");
 843                         n->norm->Bd.comp = 1;
 844                         break;
 845                 default:
 846                         abort();
 847                 }
 848                 if (DISP__NONE == dt)
 849                         continue;
 850
 851                 if (DISP__NONE == n->norm->Bd.type)
 852                         n->norm->Bd.type = dt;
 853                 else
 854                         mandoc_vmsg(MANDOCERR_BD_REP,
 855                             mdoc->parse, n->line, n->pos,
 856                             "Bd -%s", mdoc_argnames[argv->arg]);
 857         }
 858
 859         if (DISP__NONE == n->norm->Bd.type) {
 860                 mandoc_msg(MANDOCERR_BD_NOTYPE, mdoc->parse,
 861                     n->line, n->pos, "Bd");
 862                 n->norm->Bd.type = DISP_ragged;
 863         }
 864 }
 865
 866 /*
 867  * Stand-alone line macros.
 868  */
 869
 870 static void
 871 post_an_norm(POST_ARGS)
 872 {
 873         struct roff_node *n;
 874         struct mdoc_argv *argv;
 875         size_t   i;
 876
 877         n = mdoc->last;
 878         if (n->args == NULL)
 879                 return;
 880
 881         for (i = 1; i < n->args->argc; i++) {
 882                 argv = n->args->argv + i;
 883                 mandoc_vmsg(MANDOCERR_AN_REP,
 884                     mdoc->parse, argv->line, argv->pos,
 885                     "An -%s", mdoc_argnames[argv->arg]);
 886         }
 887
 888         argv = n->args->argv;
 889         if (argv->arg == MDOC_Split)
 890                 n->norm->An.auth = AUTH_split;
 891         else if (argv->arg == MDOC_Nosplit)
 892                 n->norm->An.auth = AUTH_nosplit;
 893         else
 894                 abort();
 895 }
 896
 897 static void
 898 post_eoln(POST_ARGS)
 899 {
 900         struct roff_node        *n;
 901
 902         post_useless(mdoc);
 903         n = mdoc->last;
 904         if (n->child != NULL)
 905                 mandoc_vmsg(MANDOCERR_ARG_SKIP, mdoc->parse, n->line,
 906                     n->pos, "%s %s", roff_name[n->tok], n->child->string);
 907
 908         while (n->child != NULL)
 909                 roff_node_delete(mdoc, n->child);
 910
 911         roff_word_alloc(mdoc, n->line, n->pos, n->tok == MDOC_Bt ?
 912             "is currently in beta test." : "currently under development.");
 913         mdoc->last->flags |= NODE_EOS | NODE_NOSRC;
 914         mdoc->last = n;
 915 }
 916
 917 static int
 918 build_list(struct roff_man *mdoc, int tok)
 919 {
 920         struct roff_node        *n;
 921         int                      ic;
 922
 923         n = mdoc->last->next;
 924         for (ic = 1;; ic++) {
 925                 roff_elem_alloc(mdoc, n->line, n->pos, tok);
 926                 mdoc->last->flags |= NODE_NOSRC;
 927                 mdoc_node_relink(mdoc, n);
 928                 n = mdoc->last = mdoc->last->parent;
 929                 mdoc->next = ROFF_NEXT_SIBLING;
 930                 if (n->next == NULL)
 931                         return ic;
 932                 if (ic > 1 || n->next->next != NULL) {
 933                         roff_word_alloc(mdoc, n->line, n->pos, ",");
 934                         mdoc->last->flags |= NODE_DELIMC | NODE_NOSRC;
 935                 }
 936                 n = mdoc->last->next;
 937                 if (n->next == NULL) {
 938                         roff_word_alloc(mdoc, n->line, n->pos, "and");
 939                         mdoc->last->flags |= NODE_NOSRC;
 940                 }
 941         }
 942 }
 943
 944 static void
 945 post_ex(POST_ARGS)
 946 {
 947         struct roff_node        *n;
 948         int                      ic;
 949
 950         post_std(mdoc);
 951
 952         n = mdoc->last;
 953         mdoc->next = ROFF_NEXT_CHILD;
 954         roff_word_alloc(mdoc, n->line, n->pos, "The");
 955         mdoc->last->flags |= NODE_NOSRC;
 956
 957         if (mdoc->last->next != NULL)
 958                 ic = build_list(mdoc, MDOC_Nm);
 959         else if (mdoc->meta.name != NULL) {
 960                 roff_elem_alloc(mdoc, n->line, n->pos, MDOC_Nm);
 961                 mdoc->last->flags |= NODE_NOSRC;
 962                 roff_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);
 963                 mdoc->last->flags |= NODE_NOSRC;
 964                 mdoc->last = mdoc->last->parent;
 965                 mdoc->next = ROFF_NEXT_SIBLING;
 966                 ic = 1;
 967         } else {
 968                 mandoc_msg(MANDOCERR_EX_NONAME, mdoc->parse,
 969                     n->line, n->pos, "Ex");
 970                 ic = 0;
 971         }
 972
 973         roff_word_alloc(mdoc, n->line, n->pos,
 974             ic > 1 ? "utilities exit\\~0" : "utility exits\\~0");
 975         mdoc->last->flags |= NODE_NOSRC;
 976         roff_word_alloc(mdoc, n->line, n->pos,
 977             "on success, and\\~>0 if an error occurs.");
 978         mdoc->last->flags |= NODE_EOS | NODE_NOSRC;
 979         mdoc->last = n;
 980 }
 981
 982 static void
 983 post_lb(POST_ARGS)
 984 {
 985         struct roff_node        *n;
 986         const char              *p;
 987
 988         post_delim_nb(mdoc);
 989
 990         n = mdoc->last;
 991         assert(n->child->type == ROFFT_TEXT);
 992         mdoc->next = ROFF_NEXT_CHILD;
 993
 994         if ((p = mdoc_a2lib(n->child->string)) != NULL) {
 995                 n->child->flags |= NODE_NOPRT;
 996                 roff_word_alloc(mdoc, n->line, n->pos, p);
 997                 mdoc->last->flags = NODE_NOSRC;
 998                 mdoc->last = n;
 999                 return;
1000         }
1001
1002         mandoc_vmsg(MANDOCERR_LB_BAD, mdoc->parse, n->child->line,
1003             n->child->pos, "Lb %s", n->child->string);
1004
1005         roff_word_alloc(mdoc, n->line, n->pos, "library");
1006         mdoc->last->flags = NODE_NOSRC;
1007         roff_word_alloc(mdoc, n->line, n->pos, "\\(lq");
1008         mdoc->last->flags = NODE_DELIMO | NODE_NOSRC;
1009         mdoc->last = mdoc->last->next;
1010         roff_word_alloc(mdoc, n->line, n->pos, "\\(rq");
1011         mdoc->last->flags = NODE_DELIMC | NODE_NOSRC;
1012         mdoc->last = n;
1013 }
1014
1015 static void
1016 post_rv(POST_ARGS)
1017 {
1018         struct roff_node        *n;
1019         int                      ic;
1020
1021         post_std(mdoc);
1022
1023         n = mdoc->last;
1024         mdoc->next = ROFF_NEXT_CHILD;
1025         if (n->child != NULL) {
1026                 roff_word_alloc(mdoc, n->line, n->pos, "The");
1027                 mdoc->last->flags |= NODE_NOSRC;
1028                 ic = build_list(mdoc, MDOC_Fn);
1029                 roff_word_alloc(mdoc, n->line, n->pos,
1030                     ic > 1 ? "functions return" : "function returns");
1031                 mdoc->last->flags |= NODE_NOSRC;
1032                 roff_word_alloc(mdoc, n->line, n->pos,
1033                     "the value\\~0 if successful;");
1034         } else
1035                 roff_word_alloc(mdoc, n->line, n->pos, "Upon successful "
1036                     "completion, the value\\~0 is returned;");
1037         mdoc->last->flags |= NODE_NOSRC;
1038
1039         roff_word_alloc(mdoc, n->line, n->pos, "otherwise "
1040             "the value\\~\\-1 is returned and the global variable");
1041         mdoc->last->flags |= NODE_NOSRC;
1042         roff_elem_alloc(mdoc, n->line, n->pos, MDOC_Va);
1043         mdoc->last->flags |= NODE_NOSRC;
1044         roff_word_alloc(mdoc, n->line, n->pos, "errno");
1045         mdoc->last->flags |= NODE_NOSRC;
1046         mdoc->last = mdoc->last->parent;
1047         mdoc->next = ROFF_NEXT_SIBLING;
1048         roff_word_alloc(mdoc, n->line, n->pos,
1049             "is set to indicate the error.");
1050         mdoc->last->flags |= NODE_EOS | NODE_NOSRC;
1051         mdoc->last = n;
1052 }
1053
1054 static void
1055 post_std(POST_ARGS)
1056 {
1057         struct roff_node *n;
1058
1059         post_delim(mdoc);
1060
1061         n = mdoc->last;
1062         if (n->args && n->args->argc == 1)
1063                 if (n->args->argv[0].arg == MDOC_Std)
1064                         return;
1065
1066         mandoc_msg(MANDOCERR_ARG_STD, mdoc->parse,
1067             n->line, n->pos, roff_name[n->tok]);
1068 }
1069
1070 static void
1071 post_st(POST_ARGS)
1072 {
1073         struct roff_node         *n, *nch;
1074         const char               *p;
1075
1076         n = mdoc->last;
1077         nch = n->child;
1078         assert(nch->type == ROFFT_TEXT);
1079
1080         if ((p = mdoc_a2st(nch->string)) == NULL) {
1081                 mandoc_vmsg(MANDOCERR_ST_BAD, mdoc->parse,
1082                     nch->line, nch->pos, "St %s", nch->string);
1083                 roff_node_delete(mdoc, n);
1084                 return;
1085         }
1086
1087         nch->flags |= NODE_NOPRT;
1088         mdoc->next = ROFF_NEXT_CHILD;
1089         roff_word_alloc(mdoc, nch->line, nch->pos, p);
1090         mdoc->last->flags |= NODE_NOSRC;
1091         mdoc->last= n;
1092 }
1093
1094 static void
1095 post_obsolete(POST_ARGS)
1096 {
1097         struct roff_node *n;
1098
1099         n = mdoc->last;
1100         if (n->type == ROFFT_ELEM || n->type == ROFFT_BLOCK)
1101                 mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,
1102                     n->line, n->pos, roff_name[n->tok]);
1103 }
1104
1105 static void
1106 post_useless(POST_ARGS)
1107 {
1108         struct roff_node *n;
1109
1110         n = mdoc->last;
1111         mandoc_msg(MANDOCERR_MACRO_USELESS, mdoc->parse,
1112             n->line, n->pos, roff_name[n->tok]);
1113 }
1114
1115 /*
1116  * Block macros.
1117  */
1118
1119 static void
1120 post_bf(POST_ARGS)
1121 {
1122         struct roff_node *np, *nch;
1123
1124         /*
1125          * Unlike other data pointers, these are "housed" by the HEAD
1126          * element, which contains the goods.
1127          */
1128
1129         np = mdoc->last;
1130         if (np->type != ROFFT_HEAD)
1131                 return;
1132
1133         assert(np->parent->type == ROFFT_BLOCK);
1134         assert(np->parent->tok == MDOC_Bf);
1135
1136         /* Check the number of arguments. */
1137
1138         nch = np->child;
1139         if (np->parent->args == NULL) {
1140                 if (nch == NULL) {
1141                         mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,
1142                             np->line, np->pos, "Bf");
1143                         return;
1144                 }
1145                 nch = nch->next;
1146         }
1147         if (nch != NULL)
1148                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1149                     nch->line, nch->pos, "Bf ... %s", nch->string);
1150
1151         /* Extract argument into data. */
1152
1153         if (np->parent->args != NULL) {
1154                 switch (np->parent->args->argv[0].arg) {
1155                 case MDOC_Emphasis:
1156                         np->norm->Bf.font = FONT_Em;
1157                         break;
1158                 case MDOC_Literal:
1159                         np->norm->Bf.font = FONT_Li;
1160                         break;
1161                 case MDOC_Symbolic:
1162                         np->norm->Bf.font = FONT_Sy;
1163                         break;
1164                 default:
1165                         abort();
1166                 }
1167                 return;
1168         }
1169
1170         /* Extract parameter into data. */
1171
1172         if ( ! strcmp(np->child->string, "Em"))
1173                 np->norm->Bf.font = FONT_Em;
1174         else if ( ! strcmp(np->child->string, "Li"))
1175                 np->norm->Bf.font = FONT_Li;
1176         else if ( ! strcmp(np->child->string, "Sy"))
1177                 np->norm->Bf.font = FONT_Sy;
1178         else
1179                 mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,
1180                     np->child->line, np->child->pos,
1181                     "Bf %s", np->child->string);
1182 }
1183
1184 static void
1185 post_fname(POST_ARGS)
1186 {
1187         const struct roff_node  *n;
1188         const char              *cp;
1189         size_t                   pos;
1190
1191         n = mdoc->last->child;
1192         pos = strcspn(n->string, "()");
1193         cp = n->string + pos;
1194         if ( ! (cp[0] == '\0' || (cp[0] == '(' && cp[1] == '*')))
1195                 mandoc_msg(MANDOCERR_FN_PAREN, mdoc->parse,
1196                     n->line, n->pos + pos, n->string);
1197 }
1198
1199 static void
1200 post_fn(POST_ARGS)
1201 {
1202
1203         post_fname(mdoc);
1204         post_fa(mdoc);
1205 }
1206
1207 static void
1208 post_fo(POST_ARGS)
1209 {
1210         const struct roff_node  *n;
1211
1212         n = mdoc->last;
1213
1214         if (n->type != ROFFT_HEAD)
1215                 return;
1216
1217         if (n->child == NULL) {
1218                 mandoc_msg(MANDOCERR_FO_NOHEAD, mdoc->parse,
1219                     n->line, n->pos, "Fo");
1220                 return;
1221         }
1222         if (n->child != n->last) {
1223                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1224                     n->child->next->line, n->child->next->pos,
1225                     "Fo ... %s", n->child->next->string);
1226                 while (n->child != n->last)
1227                         roff_node_delete(mdoc, n->last);
1228         } else
1229                 post_delim(mdoc);
1230
1231         post_fname(mdoc);
1232 }
1233
1234 static void
1235 post_fa(POST_ARGS)
1236 {
1237         const struct roff_node *n;
1238         const char *cp;
1239
1240         for (n = mdoc->last->child; n != NULL; n = n->next) {
1241                 for (cp = n->string; *cp != '\0'; cp++) {
1242                         /* Ignore callbacks and alterations. */
1243                         if (*cp == '(' || *cp == '{')
1244                                 break;
1245                         if (*cp != ',')
1246                                 continue;
1247                         mandoc_msg(MANDOCERR_FA_COMMA, mdoc->parse,
1248                             n->line, n->pos + (cp - n->string),
1249                             n->string);
1250                         break;
1251                 }
1252         }
1253         post_delim_nb(mdoc);
1254 }
1255
1256 static void
1257 post_nm(POST_ARGS)
1258 {
1259         struct roff_node        *n;
1260
1261         n = mdoc->last;
1262
1263         if (n->sec == SEC_NAME && n->child != NULL &&
1264             n->child->type == ROFFT_TEXT && mdoc->meta.msec != NULL)
1265                 mandoc_xr_add(mdoc->meta.msec, n->child->string, -1, -1);
1266
1267         if (n->last != NULL &&
1268             (n->last->tok == MDOC_Pp ||
1269              n->last->tok == MDOC_Lp))
1270                 mdoc_node_relink(mdoc, n->last);
1271
1272         if (mdoc->meta.name == NULL)
1273                 deroff(&mdoc->meta.name, n);
1274
1275         if (mdoc->meta.name == NULL ||
1276             (mdoc->lastsec == SEC_NAME && n->child == NULL))
1277                 mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
1278                     n->line, n->pos, "Nm");
1279
1280         switch (n->type) {
1281         case ROFFT_ELEM:
1282                 post_delim_nb(mdoc);
1283                 break;
1284         case ROFFT_HEAD:
1285                 post_delim(mdoc);
1286                 break;
1287         default:
1288                 return;
1289         }
1290
1291         if ((n->child != NULL && n->child->type == ROFFT_TEXT) ||
1292             mdoc->meta.name == NULL)
1293                 return;
1294
1295         mdoc->next = ROFF_NEXT_CHILD;
1296         roff_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);
1297         mdoc->last->flags |= NODE_NOSRC;
1298         mdoc->last = n;
1299 }
1300
1301 static void
1302 post_nd(POST_ARGS)
1303 {
1304         struct roff_node        *n;
1305
1306         n = mdoc->last;
1307
1308         if (n->type != ROFFT_BODY)
1309                 return;
1310
1311         if (n->sec != SEC_NAME)
1312                 mandoc_msg(MANDOCERR_ND_LATE, mdoc->parse,
1313                     n->line, n->pos, "Nd");
1314
1315         if (n->child == NULL)
1316                 mandoc_msg(MANDOCERR_ND_EMPTY, mdoc->parse,
1317                     n->line, n->pos, "Nd");
1318         else
1319                 post_delim(mdoc);
1320
1321         post_hyph(mdoc);
1322 }
1323
1324 static void
1325 post_display(POST_ARGS)
1326 {
1327         struct roff_node *n, *np;
1328
1329         n = mdoc->last;
1330         switch (n->type) {
1331         case ROFFT_BODY:
1332                 if (n->end != ENDBODY_NOT) {
1333                         if (n->tok == MDOC_Bd &&
1334                             n->body->parent->args == NULL)
1335                                 roff_node_delete(mdoc, n);
1336                 } else if (n->child == NULL)
1337                         mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
1338                             n->line, n->pos, roff_name[n->tok]);
1339                 else if (n->tok == MDOC_D1)
1340                         post_hyph(mdoc);
1341                 break;
1342         case ROFFT_BLOCK:
1343                 if (n->tok == MDOC_Bd) {
1344                         if (n->args == NULL) {
1345                                 mandoc_msg(MANDOCERR_BD_NOARG,
1346                                     mdoc->parse, n->line, n->pos, "Bd");
1347                                 mdoc->next = ROFF_NEXT_SIBLING;
1348                                 while (n->body->child != NULL)
1349                                         mdoc_node_relink(mdoc,
1350                                             n->body->child);
1351                                 roff_node_delete(mdoc, n);
1352                                 break;
1353                         }
1354                         post_bd(mdoc);
1355                         post_prevpar(mdoc);
1356                 }
1357                 for (np = n->parent; np != NULL; np = np->parent) {
1358                         if (np->type == ROFFT_BLOCK && np->tok == MDOC_Bd) {
1359                                 mandoc_vmsg(MANDOCERR_BD_NEST,
1360                                     mdoc->parse, n->line, n->pos,
1361                                     "%s in Bd", roff_name[n->tok]);
1362                                 break;
1363                         }
1364                 }
1365                 break;
1366         default:
1367                 break;
1368         }
1369 }
1370
1371 static void
1372 post_defaults(POST_ARGS)
1373 {
1374         struct roff_node *nn;
1375
1376         if (mdoc->last->child != NULL) {
1377                 post_delim_nb(mdoc);
1378                 return;
1379         }
1380
1381         /*
1382          * The `Ar' defaults to "file ..." if no value is provided as an
1383          * argument; the `Mt' and `Pa' macros use "~"; the `Li' just
1384          * gets an empty string.
1385          */
1386
1387         nn = mdoc->last;
1388         switch (nn->tok) {
1389         case MDOC_Ar:
1390                 mdoc->next = ROFF_NEXT_CHILD;
1391                 roff_word_alloc(mdoc, nn->line, nn->pos, "file");
1392                 mdoc->last->flags |= NODE_NOSRC;
1393                 roff_word_alloc(mdoc, nn->line, nn->pos, "...");
1394                 mdoc->last->flags |= NODE_NOSRC;
1395                 break;
1396         case MDOC_Pa:
1397         case MDOC_Mt:
1398                 mdoc->next = ROFF_NEXT_CHILD;
1399                 roff_word_alloc(mdoc, nn->line, nn->pos, "~");
1400                 mdoc->last->flags |= NODE_NOSRC;
1401                 break;
1402         default:
1403                 abort();
1404         }
1405         mdoc->last = nn;
1406 }
1407
1408 static void
1409 post_at(POST_ARGS)
1410 {
1411         struct roff_node        *n, *nch;
1412         const char              *att;
1413
1414         n = mdoc->last;
1415         nch = n->child;
1416
1417         /*
1418          * If we have a child, look it up in the standard keys.  If a
1419          * key exist, use that instead of the child; if it doesn't,
1420          * prefix "AT&T UNIX " to the existing data.
1421          */
1422
1423         att = NULL;
1424         if (nch != NULL && ((att = mdoc_a2att(nch->string)) == NULL))
1425                 mandoc_vmsg(MANDOCERR_AT_BAD, mdoc->parse,
1426                     nch->line, nch->pos, "At %s", nch->string);
1427
1428         mdoc->next = ROFF_NEXT_CHILD;
1429         if (att != NULL) {
1430                 roff_word_alloc(mdoc, nch->line, nch->pos, att);
1431                 nch->flags |= NODE_NOPRT;
1432         } else
1433                 roff_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX");
1434         mdoc->last->flags |= NODE_NOSRC;
1435         mdoc->last = n;
1436 }
1437
1438 static void
1439 post_an(POST_ARGS)
1440 {
1441         struct roff_node *np, *nch;
1442
1443         post_an_norm(mdoc);
1444
1445         np = mdoc->last;
1446         nch = np->child;
1447         if (np->norm->An.auth == AUTH__NONE) {
1448                 if (nch == NULL)
1449                         mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
1450                             np->line, np->pos, "An");
1451                 else
1452                         post_delim_nb(mdoc);
1453         } else if (nch != NULL)
1454                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1455                     nch->line, nch->pos, "An ... %s", nch->string);
1456 }
1457
1458 static void
1459 post_en(POST_ARGS)
1460 {
1461
1462         post_obsolete(mdoc);
1463         if (mdoc->last->type == ROFFT_BLOCK)
1464                 mdoc->last->norm->Es = mdoc->last_es;
1465 }
1466
1467 static void
1468 post_es(POST_ARGS)
1469 {
1470
1471         post_obsolete(mdoc);
1472         mdoc->last_es = mdoc->last;
1473 }
1474
1475 static void
1476 post_xx(POST_ARGS)
1477 {
1478         struct roff_node        *n;
1479         const char              *os;
1480         char                    *v;
1481
1482         post_delim_nb(mdoc);
1483
1484         n = mdoc->last;
1485         switch (n->tok) {
1486         case MDOC_Bsx:
1487                 os = "BSD/OS";
1488                 break;
1489         case MDOC_Dx:
1490                 os = "DragonFly";
1491                 break;
1492         case MDOC_Fx:
1493                 os = "FreeBSD";
1494                 break;
1495         case MDOC_Nx:
1496                 os = "NetBSD";
1497                 if (n->child == NULL)
1498                         break;
1499                 v = n->child->string;
1500                 if ((v[0] != '0' && v[0] != '1') || v[1] != '.' ||
1501                     v[2] < '0' || v[2] > '9' ||
1502                     v[3] < 'a' || v[3] > 'z' || v[4] != '\0')
1503                         break;
1504                 n->child->flags |= NODE_NOPRT;
1505                 mdoc->next = ROFF_NEXT_CHILD;
1506                 roff_word_alloc(mdoc, n->child->line, n->child->pos, v);
1507                 v = mdoc->last->string;
1508                 v[3] = toupper((unsigned char)v[3]);
1509                 mdoc->last->flags |= NODE_NOSRC;
1510                 mdoc->last = n;
1511                 break;
1512         case MDOC_Ox:
1513                 os = "OpenBSD";
1514                 break;
1515         case MDOC_Ux:
1516                 os = "UNIX";
1517                 break;
1518         default:
1519                 abort();
1520         }
1521         mdoc->next = ROFF_NEXT_CHILD;
1522         roff_word_alloc(mdoc, n->line, n->pos, os);
1523         mdoc->last->flags |= NODE_NOSRC;
1524         mdoc->last = n;
1525 }
1526
1527 static void
1528 post_it(POST_ARGS)
1529 {
1530         struct roff_node *nbl, *nit, *nch;
1531         int               i, cols;
1532         enum mdoc_list    lt;
1533
1534         post_prevpar(mdoc);
1535
1536         nit = mdoc->last;
1537         if (nit->type != ROFFT_BLOCK)
1538                 return;
1539
1540         nbl = nit->parent->parent;
1541         lt = nbl->norm->Bl.type;
1542
1543         switch (lt) {
1544         case LIST_tag:
1545         case LIST_hang:
1546         case LIST_ohang:
1547         case LIST_inset:
1548         case LIST_diag:
1549                 if (nit->head->child == NULL)
1550                         mandoc_vmsg(MANDOCERR_IT_NOHEAD,
1551                             mdoc->parse, nit->line, nit->pos,
1552                             "Bl -%s It",
1553                             mdoc_argnames[nbl->args->argv[0].arg]);
1554                 break;
1555         case LIST_bullet:
1556         case LIST_dash:
1557         case LIST_enum:
1558         case LIST_hyphen:
1559                 if (nit->body == NULL || nit->body->child == NULL)
1560                         mandoc_vmsg(MANDOCERR_IT_NOBODY,
1561                             mdoc->parse, nit->line, nit->pos,
1562                             "Bl -%s It",
1563                             mdoc_argnames[nbl->args->argv[0].arg]);
1564                 /* FALLTHROUGH */
1565         case LIST_item:
1566                 if ((nch = nit->head->child) != NULL)
1567                         mandoc_vmsg(MANDOCERR_ARG_SKIP, mdoc->parse,
1568                             nit->line, nit->pos, "It %s",
1569                             nch->string == NULL ? roff_name[nch->tok] :
1570                             nch->string);
1571                 break;
1572         case LIST_column:
1573                 cols = (int)nbl->norm->Bl.ncols;
1574
1575                 assert(nit->head->child == NULL);
1576
1577                 if (nit->head->next->child == NULL &&
1578                     nit->head->next->next == NULL) {
1579                         mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
1580                             nit->line, nit->pos, "It");
1581                         roff_node_delete(mdoc, nit);
1582                         break;
1583                 }
1584
1585                 i = 0;
1586                 for (nch = nit->child; nch != NULL; nch = nch->next) {
1587                         if (nch->type != ROFFT_BODY)
1588                                 continue;
1589                         if (i++ && nch->flags & NODE_LINE)
1590                                 mandoc_msg(MANDOCERR_TA_LINE, mdoc->parse,
1591                                     nch->line, nch->pos, "Ta");
1592                 }
1593                 if (i < cols || i > cols + 1)
1594                         mandoc_vmsg(MANDOCERR_BL_COL,
1595                             mdoc->parse, nit->line, nit->pos,
1596                             "%d columns, %d cells", cols, i);
1597                 else if (nit->head->next->child != NULL &&
1598                     nit->head->next->child->line > nit->line)
1599                         mandoc_msg(MANDOCERR_IT_NOARG, mdoc->parse,
1600                             nit->line, nit->pos, "Bl -column It");
1601                 break;
1602         default:
1603                 abort();
1604         }
1605 }
1606
1607 static void
1608 post_bl_block(POST_ARGS)
1609 {
1610         struct roff_node *n, *ni, *nc;
1611
1612         post_prevpar(mdoc);
1613
1614         n = mdoc->last;
1615         for (ni = n->body->child; ni != NULL; ni = ni->next) {
1616                 if (ni->body == NULL)
1617                         continue;
1618                 nc = ni->body->last;
1619                 while (nc != NULL) {
1620                         switch (nc->tok) {
1621                         case MDOC_Pp:
1622                         case MDOC_Lp:
1623                         case ROFF_br:
1624                                 break;
1625                         default:
1626                                 nc = NULL;
1627                                 continue;
1628                         }
1629                         if (ni->next == NULL) {
1630                                 mandoc_msg(MANDOCERR_PAR_MOVE,
1631                                     mdoc->parse, nc->line, nc->pos,
1632                                     roff_name[nc->tok]);
1633                                 mdoc_node_relink(mdoc, nc);
1634                         } else if (n->norm->Bl.comp == 0 &&
1635                             n->norm->Bl.type != LIST_column) {
1636                                 mandoc_vmsg(MANDOCERR_PAR_SKIP,
1637                                     mdoc->parse, nc->line, nc->pos,
1638                                     "%s before It", roff_name[nc->tok]);
1639                                 roff_node_delete(mdoc, nc);
1640                         } else
1641                                 break;
1642                         nc = ni->body->last;
1643                 }
1644         }
1645 }
1646
1647 /*
1648  * If the argument of -offset or -width is a macro,
1649  * replace it with the associated default width.
1650  */
1651 static void
1652 rewrite_macro2len(struct roff_man *mdoc, char **arg)
1653 {
1654         size_t            width;
1655         enum roff_tok     tok;
1656
1657         if (*arg == NULL)
1658                 return;
1659         else if ( ! strcmp(*arg, "Ds"))
1660                 width = 6;
1661         else if ((tok = roffhash_find(mdoc->mdocmac, *arg, 0)) == TOKEN_NONE)
1662                 return;
1663         else
1664                 width = macro2len(tok);
1665
1666         free(*arg);
1667         mandoc_asprintf(arg, "%zun", width);
1668 }
1669
1670 static void
1671 post_bl_head(POST_ARGS)
1672 {
1673         struct roff_node *nbl, *nh, *nch, *nnext;
1674         struct mdoc_argv *argv;
1675         int               i, j;
1676
1677         post_bl_norm(mdoc);
1678
1679         nh = mdoc->last;
1680         if (nh->norm->Bl.type != LIST_column) {
1681                 if ((nch = nh->child) == NULL)
1682                         return;
1683                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
1684                     nch->line, nch->pos, "Bl ... %s", nch->string);
1685                 while (nch != NULL) {
1686                         roff_node_delete(mdoc, nch);
1687                         nch = nh->child;
1688                 }
1689                 return;
1690         }
1691
1692         /*
1693          * Append old-style lists, where the column width specifiers
1694          * trail as macro parameters, to the new-style ("normal-form")
1695          * lists where they're argument values following -column.
1696          */
1697
1698         if (nh->child == NULL)
1699                 return;
1700
1701         nbl = nh->parent;
1702         for (j = 0; j < (int)nbl->args->argc; j++)
1703                 if (nbl->args->argv[j].arg == MDOC_Column)
1704                         break;
1705
1706         assert(j < (int)nbl->args->argc);
1707
1708         /*
1709          * Accommodate for new-style groff column syntax.  Shuffle the
1710          * child nodes, all of which must be TEXT, as arguments for the
1711          * column field.  Then, delete the head children.
1712          */
1713
1714         argv = nbl->args->argv + j;
1715         i = argv->sz;
1716         for (nch = nh->child; nch != NULL; nch = nch->next)
1717                 argv->sz++;
1718         argv->value = mandoc_reallocarray(argv->value,
1719             argv->sz, sizeof(char *));
1720
1721         nh->norm->Bl.ncols = argv->sz;
1722         nh->norm->Bl.cols = (void *)argv->value;
1723
1724         for (nch = nh->child; nch != NULL; nch = nnext) {
1725                 argv->value[i++] = nch->string;
1726                 nch->string = NULL;
1727                 nnext = nch->next;
1728                 roff_node_delete(NULL, nch);
1729         }
1730         nh->child = NULL;
1731 }
1732
1733 static void
1734 post_bl(POST_ARGS)
1735 {
1736         struct roff_node        *nparent, *nprev; /* of the Bl block */
1737         struct roff_node        *nblock, *nbody;  /* of the Bl */
1738         struct roff_node        *nchild, *nnext;  /* of the Bl body */
1739         const char              *prev_Er;
1740         int                      order;
1741
1742         nbody = mdoc->last;
1743         switch (nbody->type) {
1744         case ROFFT_BLOCK:
1745                 post_bl_block(mdoc);
1746                 return;
1747         case ROFFT_HEAD:
1748                 post_bl_head(mdoc);
1749                 return;
1750         case ROFFT_BODY:
1751                 break;
1752         default:
1753                 return;
1754         }
1755         if (nbody->end != ENDBODY_NOT)
1756                 return;
1757
1758         nchild = nbody->child;
1759         if (nchild == NULL) {
1760                 mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
1761                     nbody->line, nbody->pos, "Bl");
1762                 return;
1763         }
1764         while (nchild != NULL) {
1765                 nnext = nchild->next;
1766                 if (nchild->tok == MDOC_It ||
1767                     (nchild->tok == MDOC_Sm &&
1768                      nnext != NULL && nnext->tok == MDOC_It)) {
1769                         nchild = nnext;
1770                         continue;
1771                 }
1772
1773                 /*
1774                  * In .Bl -column, the first rows may be implicit,
1775                  * that is, they may not start with .It macros.
1776                  * Such rows may be followed by nodes generated on the
1777                  * roff level, for example .TS, which cannot be moved
1778                  * out of the list.  In that case, wrap such roff nodes
1779                  * into an implicit row.
1780                  */
1781
1782                 if (nchild->prev != NULL) {
1783                         mdoc->last = nchild;
1784                         mdoc->next = ROFF_NEXT_SIBLING;
1785                         roff_block_alloc(mdoc, nchild->line,
1786                             nchild->pos, MDOC_It);
1787                         roff_head_alloc(mdoc, nchild->line,
1788                             nchild->pos, MDOC_It);
1789                         mdoc->next = ROFF_NEXT_SIBLING;
1790                         roff_body_alloc(mdoc, nchild->line,
1791                             nchild->pos, MDOC_It);
1792                         while (nchild->tok != MDOC_It) {
1793                                 mdoc_node_relink(mdoc, nchild);
1794                                 if ((nchild = nnext) == NULL)
1795                                         break;
1796                                 nnext = nchild->next;
1797                                 mdoc->next = ROFF_NEXT_SIBLING;
1798                         }
1799                         mdoc->last = nbody;
1800                         continue;
1801                 }
1802
1803                 mandoc_msg(MANDOCERR_BL_MOVE, mdoc->parse,
1804                     nchild->line, nchild->pos, roff_name[nchild->tok]);
1805
1806                 /*
1807                  * Move the node out of the Bl block.
1808                  * First, collect all required node pointers.
1809                  */
1810
1811                 nblock  = nbody->parent;
1812                 nprev   = nblock->prev;
1813                 nparent = nblock->parent;
1814
1815                 /*
1816                  * Unlink this child.
1817                  */
1818
1819                 nbody->child = nnext;
1820                 if (nnext == NULL)
1821                         nbody->last  = NULL;
1822                 else
1823                         nnext->prev = NULL;
1824
1825                 /*
1826                  * Relink this child.
1827                  */
1828
1829                 nchild->parent = nparent;
1830                 nchild->prev   = nprev;
1831                 nchild->next   = nblock;
1832
1833                 nblock->prev = nchild;
1834                 if (nprev == NULL)
1835                         nparent->child = nchild;
1836                 else
1837                         nprev->next = nchild;
1838
1839                 nchild = nnext;
1840         }
1841
1842         if (mdoc->meta.os_e != MANDOC_OS_NETBSD)
1843                 return;
1844
1845         prev_Er = NULL;
1846         for (nchild = nbody->child; nchild != NULL; nchild = nchild->next) {
1847                 if (nchild->tok != MDOC_It)
1848                         continue;
1849                 if ((nnext = nchild->head->child) == NULL)
1850                         continue;
1851                 if (nnext->type == ROFFT_BLOCK)
1852                         nnext = nnext->body->child;
1853                 if (nnext == NULL || nnext->tok != MDOC_Er)
1854                         continue;
1855                 nnext = nnext->child;
1856                 if (prev_Er != NULL) {
1857                         order = strcmp(prev_Er, nnext->string);
1858                         if (order > 0)
1859                                 mandoc_vmsg(MANDOCERR_ER_ORDER,
1860                                     mdoc->parse, nnext->line, nnext->pos,
1861                                     "Er %s %s (NetBSD)",
1862                                     prev_Er, nnext->string);
1863                         else if (order == 0)
1864                                 mandoc_vmsg(MANDOCERR_ER_REP,
1865                                     mdoc->parse, nnext->line, nnext->pos,
1866                                     "Er %s (NetBSD)", prev_Er);
1867                 }
1868                 prev_Er = nnext->string;
1869         }
1870 }
1871
1872 static void
1873 post_bk(POST_ARGS)
1874 {
1875         struct roff_node        *n;
1876
1877         n = mdoc->last;
1878
1879         if (n->type == ROFFT_BLOCK && n->body->child == NULL) {
1880                 mandoc_msg(MANDOCERR_BLK_EMPTY,
1881                     mdoc->parse, n->line, n->pos, "Bk");
1882                 roff_node_delete(mdoc, n);
1883         }
1884 }
1885
1886 static void
1887 post_sm(POST_ARGS)
1888 {
1889         struct roff_node        *nch;
1890
1891         nch = mdoc->last->child;
1892
1893         if (nch == NULL) {
1894                 mdoc->flags ^= MDOC_SMOFF;
1895                 return;
1896         }
1897
1898         assert(nch->type == ROFFT_TEXT);
1899
1900         if ( ! strcmp(nch->string, "on")) {
1901                 mdoc->flags &= ~MDOC_SMOFF;
1902                 return;
1903         }
1904         if ( ! strcmp(nch->string, "off")) {
1905                 mdoc->flags |= MDOC_SMOFF;
1906                 return;
1907         }
1908
1909         mandoc_vmsg(MANDOCERR_SM_BAD,
1910             mdoc->parse, nch->line, nch->pos,
1911             "%s %s", roff_name[mdoc->last->tok], nch->string);
1912         mdoc_node_relink(mdoc, nch);
1913         return;
1914 }
1915
1916 static void
1917 post_root(POST_ARGS)
1918 {
1919         const char *openbsd_arch[] = {
1920                 "alpha", "amd64", "arm64", "armv7", "hppa", "i386",
1921                 "landisk", "loongson", "luna88k", "macppc", "mips64",
1922                 "octeon", "sgi", "socppc", "sparc64", NULL
1923         };
1924         const char *netbsd_arch[] = {
1925                 "acorn26", "acorn32", "algor", "alpha", "amiga",
1926                 "arc", "atari",
1927                 "bebox", "cats", "cesfic", "cobalt", "dreamcast",
1928                 "emips", "evbarm", "evbmips", "evbppc", "evbsh3", "evbsh5",
1929                 "hp300", "hpcarm", "hpcmips", "hpcsh", "hppa",
1930                 "i386", "ibmnws", "luna68k",
1931                 "mac68k", "macppc", "mipsco", "mmeye", "mvme68k", "mvmeppc",
1932                 "netwinder", "news68k", "newsmips", "next68k",
1933                 "pc532", "playstation2", "pmax", "pmppc", "prep",
1934                 "sandpoint", "sbmips", "sgimips", "shark",
1935                 "sparc", "sparc64", "sun2", "sun3",
1936                 "vax", "walnut", "x68k", "x86", "x86_64", "xen", NULL
1937         };
1938         const char **arches[] = { NULL, netbsd_arch, openbsd_arch };
1939
1940         struct roff_node *n;
1941         const char **arch;
1942
1943         /* Add missing prologue data. */
1944
1945         if (mdoc->meta.date == NULL)
1946                 mdoc->meta.date = mdoc->quick ? mandoc_strdup("") :
1947                     mandoc_normdate(mdoc, NULL, 0, 0);
1948
1949         if (mdoc->meta.title == NULL) {
1950                 mandoc_msg(MANDOCERR_DT_NOTITLE,
1951                     mdoc->parse, 0, 0, "EOF");
1952                 mdoc->meta.title = mandoc_strdup("UNTITLED");
1953         }
1954
1955         if (mdoc->meta.vol == NULL)
1956                 mdoc->meta.vol = mandoc_strdup("LOCAL");
1957
1958         if (mdoc->meta.os == NULL) {
1959                 mandoc_msg(MANDOCERR_OS_MISSING,
1960                     mdoc->parse, 0, 0, NULL);
1961                 mdoc->meta.os = mandoc_strdup("");
1962         } else if (mdoc->meta.os_e &&
1963             (mdoc->meta.rcsids & (1 << mdoc->meta.os_e)) == 0)
1964                 mandoc_msg(MANDOCERR_RCS_MISSING, mdoc->parse, 0, 0,
1965                     mdoc->meta.os_e == MANDOC_OS_OPENBSD ?
1966                     "(OpenBSD)" : "(NetBSD)");
1967
1968         if (mdoc->meta.arch != NULL &&
1969             (arch = arches[mdoc->meta.os_e]) != NULL) {
1970                 while (*arch != NULL && strcmp(*arch, mdoc->meta.arch))
1971                         arch++;
1972                 if (*arch == NULL) {
1973                         n = mdoc->first->child;
1974                         while (n->tok != MDOC_Dt ||
1975                             n->child == NULL ||
1976                             n->child->next == NULL ||
1977                             n->child->next->next == NULL)
1978                                 n = n->next;
1979                         n = n->child->next->next;
1980                         mandoc_vmsg(MANDOCERR_ARCH_BAD,
1981                             mdoc->parse, n->line, n->pos,
1982                             "Dt ... %s %s", mdoc->meta.arch,
1983                             mdoc->meta.os_e == MANDOC_OS_OPENBSD ?
1984                             "(OpenBSD)" : "(NetBSD)");
1985                 }
1986         }
1987
1988         /* Check that we begin with a proper `Sh'. */
1989
1990         n = mdoc->first->child;
1991         while (n != NULL &&
1992             (n->type == ROFFT_COMMENT ||
1993              (n->tok >= MDOC_Dd &&
1994               mdoc_macros[n->tok].flags & MDOC_PROLOGUE)))
1995                 n = n->next;
1996
1997         if (n == NULL)
1998                 mandoc_msg(MANDOCERR_DOC_EMPTY, mdoc->parse, 0, 0, NULL);
1999         else if (n->tok != MDOC_Sh)
2000                 mandoc_msg(MANDOCERR_SEC_BEFORE, mdoc->parse,
2001                     n->line, n->pos, roff_name[n->tok]);
2002 }
2003
2004 static void
2005 post_rs(POST_ARGS)
2006 {
2007         struct roff_node *np, *nch, *next, *prev;
2008         int               i, j;
2009
2010         np = mdoc->last;
2011
2012         if (np->type != ROFFT_BODY)
2013                 return;
2014
2015         if (np->child == NULL) {
2016                 mandoc_msg(MANDOCERR_RS_EMPTY, mdoc->parse,
2017                     np->line, np->pos, "Rs");
2018                 return;
2019         }
2020
2021         /*
2022          * The full `Rs' block needs special handling to order the
2023          * sub-elements according to `rsord'.  Pick through each element
2024          * and correctly order it.  This is an insertion sort.
2025          */
2026
2027         next = NULL;
2028         for (nch = np->child->next; nch != NULL; nch = next) {
2029                 /* Determine order number of this child. */
2030                 for (i = 0; i < RSORD_MAX; i++)
2031                         if (rsord[i] == nch->tok)
2032                                 break;
2033
2034                 if (i == RSORD_MAX) {
2035                         mandoc_msg(MANDOCERR_RS_BAD, mdoc->parse,
2036                             nch->line, nch->pos, roff_name[nch->tok]);
2037                         i = -1;
2038                 } else if (nch->tok == MDOC__J || nch->tok == MDOC__B)
2039                         np->norm->Rs.quote_T++;
2040
2041                 /*
2042                  * Remove this child from the chain.  This somewhat
2043                  * repeats roff_node_unlink(), but since we're
2044                  * just re-ordering, there's no need for the
2045                  * full unlink process.
2046                  */
2047
2048                 if ((next = nch->next) != NULL)
2049                         next->prev = nch->prev;
2050
2051                 if ((prev = nch->prev) != NULL)
2052                         prev->next = nch->next;
2053
2054                 nch->prev = nch->next = NULL;
2055
2056                 /*
2057                  * Scan back until we reach a node that's
2058                  * to be ordered before this child.
2059                  */
2060
2061                 for ( ; prev ; prev = prev->prev) {
2062                         /* Determine order of `prev'. */
2063                         for (j = 0; j < RSORD_MAX; j++)
2064                                 if (rsord[j] == prev->tok)
2065                                         break;
2066                         if (j == RSORD_MAX)
2067                                 j = -1;
2068
2069                         if (j <= i)
2070                                 break;
2071                 }
2072
2073                 /*
2074                  * Set this child back into its correct place
2075                  * in front of the `prev' node.
2076                  */
2077
2078                 nch->prev = prev;
2079
2080                 if (prev == NULL) {
2081                         np->child->prev = nch;
2082                         nch->next = np->child;
2083                         np->child = nch;
2084                 } else {
2085                         if (prev->next)
2086                                 prev->next->prev = nch;
2087                         nch->next = prev->next;
2088                         prev->next = nch;
2089                 }
2090         }
2091 }
2092
2093 /*
2094  * For some arguments of some macros,
2095  * convert all breakable hyphens into ASCII_HYPH.
2096  */
2097 static void
2098 post_hyph(POST_ARGS)
2099 {
2100         struct roff_node        *nch;
2101         char                    *cp;
2102
2103         for (nch = mdoc->last->child; nch != NULL; nch = nch->next) {
2104                 if (nch->type != ROFFT_TEXT)
2105                         continue;
2106                 cp = nch->string;
2107                 if (*cp == '\0')
2108                         continue;
2109                 while (*(++cp) != '\0')
2110                         if (*cp == '-' &&
2111                             isalpha((unsigned char)cp[-1]) &&
2112                             isalpha((unsigned char)cp[1]))
2113                                 *cp = ASCII_HYPH;
2114         }
2115 }
2116
2117 static void
2118 post_ns(POST_ARGS)
2119 {
2120         struct roff_node        *n;
2121
2122         n = mdoc->last;
2123         if (n->flags & NODE_LINE ||
2124             (n->next != NULL && n->next->flags & NODE_DELIMC))
2125                 mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,
2126                     n->line, n->pos, NULL);
2127 }
2128
2129 static void
2130 post_sx(POST_ARGS)
2131 {
2132         post_delim(mdoc);
2133         post_hyph(mdoc);
2134 }
2135
2136 static void
2137 post_sh(POST_ARGS)
2138 {
2139
2140         post_ignpar(mdoc);
2141
2142         switch (mdoc->last->type) {
2143         case ROFFT_HEAD:
2144                 post_sh_head(mdoc);
2145                 break;
2146         case ROFFT_BODY:
2147                 switch (mdoc->lastsec)  {
2148                 case SEC_NAME:
2149                         post_sh_name(mdoc);
2150                         break;
2151                 case SEC_SEE_ALSO:
2152                         post_sh_see_also(mdoc);
2153                         break;
2154                 case SEC_AUTHORS:
2155                         post_sh_authors(mdoc);
2156                         break;
2157                 default:
2158                         break;
2159                 }
2160                 break;
2161         default:
2162                 break;
2163         }
2164 }
2165
2166 static void
2167 post_sh_name(POST_ARGS)
2168 {
2169         struct roff_node *n;
2170         int hasnm, hasnd;
2171
2172         hasnm = hasnd = 0;
2173
2174         for (n = mdoc->last->child; n != NULL; n = n->next) {
2175                 switch (n->tok) {
2176                 case MDOC_Nm:
2177                         if (hasnm && n->child != NULL)
2178                                 mandoc_vmsg(MANDOCERR_NAMESEC_PUNCT,
2179                                     mdoc->parse, n->line, n->pos,
2180                                     "Nm %s", n->child->string);
2181                         hasnm = 1;
2182                         continue;
2183                 case MDOC_Nd:
2184                         hasnd = 1;
2185                         if (n->next != NULL)
2186                                 mandoc_msg(MANDOCERR_NAMESEC_ND,
2187                                     mdoc->parse, n->line, n->pos, NULL);
2188                         break;
2189                 case TOKEN_NONE:
2190                         if (n->type == ROFFT_TEXT &&
2191                             n->string[0] == ',' && n->string[1] == '\0' &&
2192                             n->next != NULL && n->next->tok == MDOC_Nm) {
2193                                 n = n->next;
2194                                 continue;
2195                         }
2196                         /* FALLTHROUGH */
2197                 default:
2198                         mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
2199                             n->line, n->pos, roff_name[n->tok]);
2200                         continue;
2201                 }
2202                 break;
2203         }
2204
2205         if ( ! hasnm)
2206                 mandoc_msg(MANDOCERR_NAMESEC_NONM, mdoc->parse,
2207                     mdoc->last->line, mdoc->last->pos, NULL);
2208         if ( ! hasnd)
2209                 mandoc_msg(MANDOCERR_NAMESEC_NOND, mdoc->parse,
2210                     mdoc->last->line, mdoc->last->pos, NULL);
2211 }
2212
2213 static void
2214 post_sh_see_also(POST_ARGS)
2215 {
2216         const struct roff_node  *n;
2217         const char              *name, *sec;
2218         const char              *lastname, *lastsec, *lastpunct;
2219         int                      cmp;
2220
2221         n = mdoc->last->child;
2222         lastname = lastsec = lastpunct = NULL;
2223         while (n != NULL) {
2224                 if (n->tok != MDOC_Xr ||
2225                     n->child == NULL ||
2226                     n->child->next == NULL)
2227                         break;
2228
2229                 /* Process one .Xr node. */
2230
2231                 name = n->child->string;
2232                 sec = n->child->next->string;
2233                 if (lastsec != NULL) {
2234                         if (lastpunct[0] != ',' || lastpunct[1] != '\0')
2235                                 mandoc_vmsg(MANDOCERR_XR_PUNCT,
2236                                     mdoc->parse, n->line, n->pos,
2237                                     "%s before %s(%s)", lastpunct,
2238                                     name, sec);
2239                         cmp = strcmp(lastsec, sec);
2240                         if (cmp > 0)
2241                                 mandoc_vmsg(MANDOCERR_XR_ORDER,
2242                                     mdoc->parse, n->line, n->pos,
2243                                     "%s(%s) after %s(%s)", name,
2244                                     sec, lastname, lastsec);
2245                         else if (cmp == 0 &&
2246                             strcasecmp(lastname, name) > 0)
2247                                 mandoc_vmsg(MANDOCERR_XR_ORDER,
2248                                     mdoc->parse, n->line, n->pos,
2249                                     "%s after %s", name, lastname);
2250                 }
2251                 lastname = name;
2252                 lastsec = sec;
2253
2254                 /* Process the following node. */
2255
2256                 n = n->next;
2257                 if (n == NULL)
2258                         break;
2259                 if (n->tok == MDOC_Xr) {
2260                         lastpunct = "none";
2261                         continue;
2262                 }
2263                 if (n->type != ROFFT_TEXT)
2264                         break;
2265                 for (name = n->string; *name != '\0'; name++)
2266                         if (isalpha((const unsigned char)*name))
2267                                 return;
2268                 lastpunct = n->string;
2269                 if (n->next == NULL || n->next->tok == MDOC_Rs)
2270                         mandoc_vmsg(MANDOCERR_XR_PUNCT, mdoc->parse,
2271                             n->line, n->pos, "%s after %s(%s)",
2272                             lastpunct, lastname, lastsec);
2273                 n = n->next;
2274         }
2275 }
2276
2277 static int
2278 child_an(const struct roff_node *n)
2279 {
2280
2281         for (n = n->child; n != NULL; n = n->next)
2282                 if ((n->tok == MDOC_An && n->child != NULL) || child_an(n))
2283                         return 1;
2284         return 0;
2285 }
2286
2287 static void
2288 post_sh_authors(POST_ARGS)
2289 {
2290
2291         if ( ! child_an(mdoc->last))
2292                 mandoc_msg(MANDOCERR_AN_MISSING, mdoc->parse,
2293                     mdoc->last->line, mdoc->last->pos, NULL);
2294 }
2295
2296 /*
2297  * Return an upper bound for the string distance (allowing
2298  * transpositions).  Not a full Levenshtein implementation
2299  * because Levenshtein is quadratic in the string length
2300  * and this function is called for every standard name,
2301  * so the check for each custom name would be cubic.
2302  * The following crude heuristics is linear, resulting
2303  * in quadratic behaviour for checking one custom name,
2304  * which does not cause measurable slowdown.
2305  */
2306 static int
2307 similar(const char *s1, const char *s2)
2308 {
2309         const int       maxdist = 3;
2310         int             dist = 0;
2311
2312         while (s1[0] != '\0' && s2[0] != '\0') {
2313                 if (s1[0] == s2[0]) {
2314                         s1++;
2315                         s2++;
2316                         continue;
2317                 }
2318                 if (++dist > maxdist)
2319                         return INT_MAX;
2320                 if (s1[1] == s2[1]) {  /* replacement */
2321                         s1++;
2322                         s2++;
2323                 } else if (s1[0] == s2[1] && s1[1] == s2[0]) {
2324                         s1 += 2;        /* transposition */
2325                         s2 += 2;
2326                 } else if (s1[0] == s2[1])  /* insertion */
2327                         s2++;
2328                 else if (s1[1] == s2[0])  /* deletion */
2329                         s1++;
2330                 else
2331                         return INT_MAX;
2332         }
2333         dist += strlen(s1) + strlen(s2);
2334         return dist > maxdist ? INT_MAX : dist;
2335 }
2336
2337 static void
2338 post_sh_head(POST_ARGS)
2339 {
2340         struct roff_node        *nch;
2341         const char              *goodsec;
2342         const char *const       *testsec;
2343         int                      dist, mindist;
2344         enum roff_sec            sec;
2345
2346         /*
2347          * Process a new section.  Sections are either "named" or
2348          * "custom".  Custom sections are user-defined, while named ones
2349          * follow a conventional order and may only appear in certain
2350          * manual sections.
2351          */
2352
2353         sec = mdoc->last->sec;
2354
2355         /* The NAME should be first. */
2356
2357         if (sec != SEC_NAME && mdoc->lastnamed == SEC_NONE)
2358                 mandoc_vmsg(MANDOCERR_NAMESEC_FIRST, mdoc->parse,
2359                     mdoc->last->line, mdoc->last->pos, "Sh %s",
2360                     sec != SEC_CUSTOM ? secnames[sec] :
2361                     (nch = mdoc->last->child) == NULL ? "" :
2362                     nch->type == ROFFT_TEXT ? nch->string :
2363                     roff_name[nch->tok]);
2364
2365         /* The SYNOPSIS gets special attention in other areas. */
2366
2367         if (sec == SEC_SYNOPSIS) {
2368                 roff_setreg(mdoc->roff, "nS", 1, '=');
2369                 mdoc->flags |= MDOC_SYNOPSIS;
2370         } else {
2371                 roff_setreg(mdoc->roff, "nS", 0, '=');
2372                 mdoc->flags &= ~MDOC_SYNOPSIS;
2373         }
2374
2375         /* Mark our last section. */
2376
2377         mdoc->lastsec = sec;
2378
2379         /* We don't care about custom sections after this. */
2380
2381         if (sec == SEC_CUSTOM) {
2382                 if ((nch = mdoc->last->child) == NULL ||
2383                     nch->type != ROFFT_TEXT || nch->next != NULL)
2384                         return;
2385                 goodsec = NULL;
2386                 mindist = INT_MAX;
2387                 for (testsec = secnames + 1; *testsec != NULL; testsec++) {
2388                         dist = similar(nch->string, *testsec);
2389                         if (dist < mindist) {
2390                                 goodsec = *testsec;
2391                                 mindist = dist;
2392                         }
2393                 }
2394                 if (goodsec != NULL)
2395                         mandoc_vmsg(MANDOCERR_SEC_TYPO, mdoc->parse,
2396                             nch->line, nch->pos, "Sh %s instead of %s",
2397                             nch->string, goodsec);
2398                 return;
2399         }
2400
2401         /*
2402          * Check whether our non-custom section is being repeated or is
2403          * out of order.
2404          */
2405
2406         if (sec == mdoc->lastnamed)
2407                 mandoc_vmsg(MANDOCERR_SEC_REP, mdoc->parse,
2408                     mdoc->last->line, mdoc->last->pos,
2409                     "Sh %s", secnames[sec]);
2410
2411         if (sec < mdoc->lastnamed)
2412                 mandoc_vmsg(MANDOCERR_SEC_ORDER, mdoc->parse,
2413                     mdoc->last->line, mdoc->last->pos,
2414                     "Sh %s", secnames[sec]);
2415
2416         /* Mark the last named section. */
2417
2418         mdoc->lastnamed = sec;
2419
2420         /* Check particular section/manual conventions. */
2421
2422         if (mdoc->meta.msec == NULL)
2423                 return;
2424
2425         goodsec = NULL;
2426         switch (sec) {
2427         case SEC_ERRORS:
2428                 if (*mdoc->meta.msec == '4')
2429                         break;
2430                 goodsec = "2, 3, 4, 9";
2431                 /* FALLTHROUGH */
2432         case SEC_RETURN_VALUES:
2433         case SEC_LIBRARY:
2434                 if (*mdoc->meta.msec == '2')
2435                         break;
2436                 if (*mdoc->meta.msec == '3')
2437                         break;
2438                 if (NULL == goodsec)
2439                         goodsec = "2, 3, 9";
2440                 /* FALLTHROUGH */
2441         case SEC_CONTEXT:
2442                 if (*mdoc->meta.msec == '9')
2443                         break;
2444                 if (NULL == goodsec)
2445                         goodsec = "9";
2446                 mandoc_vmsg(MANDOCERR_SEC_MSEC, mdoc->parse,
2447                     mdoc->last->line, mdoc->last->pos,
2448                     "Sh %s for %s only", secnames[sec], goodsec);
2449                 break;
2450         default:
2451                 break;
2452         }
2453 }
2454
2455 static void
2456 post_xr(POST_ARGS)
2457 {
2458         struct roff_node *n, *nch;
2459
2460         n = mdoc->last;
2461         nch = n->child;
2462         if (nch->next == NULL) {
2463                 mandoc_vmsg(MANDOCERR_XR_NOSEC, mdoc->parse,
2464                     n->line, n->pos, "Xr %s", nch->string);
2465         } else {
2466                 assert(nch->next == n->last);
2467                 if(mandoc_xr_add(nch->next->string, nch->string,
2468                     nch->line, nch->pos))
2469                         mandoc_vmsg(MANDOCERR_XR_SELF, mdoc->parse,
2470                             nch->line, nch->pos, "Xr %s %s",
2471                             nch->string, nch->next->string);
2472         }
2473         post_delim_nb(mdoc);
2474 }
2475
2476 static void
2477 post_ignpar(POST_ARGS)
2478 {
2479         struct roff_node *np;
2480
2481         switch (mdoc->last->type) {
2482         case ROFFT_BLOCK:
2483                 post_prevpar(mdoc);
2484                 return;
2485         case ROFFT_HEAD:
2486                 post_delim(mdoc);
2487                 post_hyph(mdoc);
2488                 return;
2489         case ROFFT_BODY:
2490                 break;
2491         default:
2492                 return;
2493         }
2494
2495         if ((np = mdoc->last->child) != NULL)
2496                 if (np->tok == MDOC_Pp || np->tok == MDOC_Lp) {
2497                         mandoc_vmsg(MANDOCERR_PAR_SKIP,
2498                             mdoc->parse, np->line, np->pos,
2499                             "%s after %s", roff_name[np->tok],
2500                             roff_name[mdoc->last->tok]);
2501                         roff_node_delete(mdoc, np);
2502                 }
2503
2504         if ((np = mdoc->last->last) != NULL)
2505                 if (np->tok == MDOC_Pp || np->tok == MDOC_Lp) {
2506                         mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2507                             np->line, np->pos, "%s at the end of %s",
2508                             roff_name[np->tok],
2509                             roff_name[mdoc->last->tok]);
2510                         roff_node_delete(mdoc, np);
2511                 }
2512 }
2513
2514 static void
2515 post_prevpar(POST_ARGS)
2516 {
2517         struct roff_node *n;
2518
2519         n = mdoc->last;
2520         if (NULL == n->prev)
2521                 return;
2522         if (n->type != ROFFT_ELEM && n->type != ROFFT_BLOCK)
2523                 return;
2524
2525         /*
2526          * Don't allow prior `Lp' or `Pp' prior to a paragraph-type
2527          * block:  `Lp', `Pp', or non-compact `Bd' or `Bl'.
2528          */
2529
2530         if (n->prev->tok != MDOC_Pp &&
2531             n->prev->tok != MDOC_Lp &&
2532             n->prev->tok != ROFF_br)
2533                 return;
2534         if (n->tok == MDOC_Bl && n->norm->Bl.comp)
2535                 return;
2536         if (n->tok == MDOC_Bd && n->norm->Bd.comp)
2537                 return;
2538         if (n->tok == MDOC_It && n->parent->norm->Bl.comp)
2539                 return;
2540
2541         mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2542             n->prev->line, n->prev->pos, "%s before %s",
2543             roff_name[n->prev->tok], roff_name[n->tok]);
2544         roff_node_delete(mdoc, n->prev);
2545 }
2546
2547 static void
2548 post_par(POST_ARGS)
2549 {
2550         struct roff_node *np;
2551
2552         np = mdoc->last;
2553         if (np->tok != ROFF_br && np->tok != ROFF_sp)
2554                 post_prevpar(mdoc);
2555
2556         if (np->tok == ROFF_sp) {
2557                 if (np->child != NULL && np->child->next != NULL)
2558                         mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
2559                             np->child->next->line, np->child->next->pos,
2560                             "sp ... %s", np->child->next->string);
2561         } else if (np->child != NULL)
2562                 mandoc_vmsg(MANDOCERR_ARG_SKIP,
2563                     mdoc->parse, np->line, np->pos, "%s %s",
2564                     roff_name[np->tok], np->child->string);
2565
2566         if ((np = mdoc->last->prev) == NULL) {
2567                 np = mdoc->last->parent;
2568                 if (np->tok != MDOC_Sh && np->tok != MDOC_Ss)
2569                         return;
2570         } else if (np->tok != MDOC_Pp && np->tok != MDOC_Lp &&
2571             (mdoc->last->tok != ROFF_br ||
2572              (np->tok != ROFF_sp && np->tok != ROFF_br)))
2573                 return;
2574
2575         mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
2576             mdoc->last->line, mdoc->last->pos, "%s after %s",
2577             roff_name[mdoc->last->tok], roff_name[np->tok]);
2578         roff_node_delete(mdoc, mdoc->last);
2579 }
2580
2581 static void
2582 post_dd(POST_ARGS)
2583 {
2584         struct roff_node *n;
2585         char             *datestr;
2586
2587         n = mdoc->last;
2588         n->flags |= NODE_NOPRT;
2589
2590         if (mdoc->meta.date != NULL) {
2591                 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
2592                     n->line, n->pos, "Dd");
2593                 free(mdoc->meta.date);
2594         } else if (mdoc->flags & MDOC_PBODY)
2595                 mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
2596                     n->line, n->pos, "Dd");
2597         else if (mdoc->meta.title != NULL)
2598                 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
2599                     n->line, n->pos, "Dd after Dt");
2600         else if (mdoc->meta.os != NULL)
2601                 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
2602                     n->line, n->pos, "Dd after Os");
2603
2604         if (n->child == NULL || n->child->string[0] == '\0') {
2605                 mdoc->meta.date = mdoc->quick ? mandoc_strdup("") :
2606                     mandoc_normdate(mdoc, NULL, n->line, n->pos);
2607                 return;
2608         }
2609
2610         datestr = NULL;
2611         deroff(&datestr, n);
2612         if (mdoc->quick)
2613                 mdoc->meta.date = datestr;
2614         else {
2615                 mdoc->meta.date = mandoc_normdate(mdoc,
2616                     datestr, n->line, n->pos);
2617                 free(datestr);
2618         }
2619 }
2620
2621 static void
2622 post_dt(POST_ARGS)
2623 {
2624         struct roff_node *nn, *n;
2625         const char       *cp;
2626         char             *p;
2627
2628         n = mdoc->last;
2629         n->flags |= NODE_NOPRT;
2630
2631         if (mdoc->flags & MDOC_PBODY) {
2632                 mandoc_msg(MANDOCERR_DT_LATE, mdoc->parse,
2633                     n->line, n->pos, "Dt");
2634                 return;
2635         }
2636
2637         if (mdoc->meta.title != NULL)
2638                 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
2639                     n->line, n->pos, "Dt");
2640         else if (mdoc->meta.os != NULL)
2641                 mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
2642                     n->line, n->pos, "Dt after Os");
2643
2644         free(mdoc->meta.title);
2645         free(mdoc->meta.msec);
2646         free(mdoc->meta.vol);
2647         free(mdoc->meta.arch);
2648
2649         mdoc->meta.title = NULL;
2650         mdoc->meta.msec = NULL;
2651         mdoc->meta.vol = NULL;
2652         mdoc->meta.arch = NULL;
2653
2654         /* Mandatory first argument: title. */
2655
2656         nn = n->child;
2657         if (nn == NULL || *nn->string == '\0') {
2658                 mandoc_msg(MANDOCERR_DT_NOTITLE,
2659                     mdoc->parse, n->line, n->pos, "Dt");
2660                 mdoc->meta.title = mandoc_strdup("UNTITLED");
2661         } else {
2662                 mdoc->meta.title = mandoc_strdup(nn->string);
2663
2664                 /* Check that all characters are uppercase. */
2665
2666                 for (p = nn->string; *p != '\0'; p++)
2667                         if (islower((unsigned char)*p)) {
2668                                 mandoc_vmsg(MANDOCERR_TITLE_CASE,
2669                                     mdoc->parse, nn->line,
2670                                     nn->pos + (p - nn->string),
2671                                     "Dt %s", nn->string);
2672                                 break;
2673                         }
2674         }
2675
2676         /* Mandatory second argument: section. */
2677
2678         if (nn != NULL)
2679                 nn = nn->next;
2680
2681         if (nn == NULL) {
2682                 mandoc_vmsg(MANDOCERR_MSEC_MISSING,
2683                     mdoc->parse, n->line, n->pos,
2684                     "Dt %s", mdoc->meta.title);
2685                 mdoc->meta.vol = mandoc_strdup("LOCAL");
2686                 return;  /* msec and arch remain NULL. */
2687         }
2688
2689         mdoc->meta.msec = mandoc_strdup(nn->string);
2690
2691         /* Infer volume title from section number. */
2692
2693         cp = mandoc_a2msec(nn->string);
2694         if (cp == NULL) {
2695                 mandoc_vmsg(MANDOCERR_MSEC_BAD, mdoc->parse,
2696                     nn->line, nn->pos, "Dt ... %s", nn->string);
2697                 mdoc->meta.vol = mandoc_strdup(nn->string);
2698         } else
2699                 mdoc->meta.vol = mandoc_strdup(cp);
2700
2701         /* Optional third argument: architecture. */
2702
2703         if ((nn = nn->next) == NULL)
2704                 return;
2705
2706         for (p = nn->string; *p != '\0'; p++)
2707                 *p = tolower((unsigned char)*p);
2708         mdoc->meta.arch = mandoc_strdup(nn->string);
2709
2710         /* Ignore fourth and later arguments. */
2711
2712         if ((nn = nn->next) != NULL)
2713                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
2714                     nn->line, nn->pos, "Dt ... %s", nn->string);
2715 }
2716
2717 static void
2718 post_bx(POST_ARGS)
2719 {
2720         struct roff_node        *n, *nch;
2721         const char              *macro;
2722
2723         post_delim_nb(mdoc);
2724
2725         n = mdoc->last;
2726         nch = n->child;
2727
2728         if (nch != NULL) {
2729                 macro = !strcmp(nch->string, "Open") ? "Ox" :
2730                     !strcmp(nch->string, "Net") ? "Nx" :
2731                     !strcmp(nch->string, "Free") ? "Fx" :
2732                     !strcmp(nch->string, "DragonFly") ? "Dx" : NULL;
2733                 if (macro != NULL)
2734                         mandoc_msg(MANDOCERR_BX, mdoc->parse,
2735                             n->line, n->pos, macro);
2736                 mdoc->last = nch;
2737                 nch = nch->next;
2738                 mdoc->next = ROFF_NEXT_SIBLING;
2739                 roff_elem_alloc(mdoc, n->line, n->pos, MDOC_Ns);
2740                 mdoc->last->flags |= NODE_NOSRC;
2741                 mdoc->next = ROFF_NEXT_SIBLING;
2742         } else
2743                 mdoc->next = ROFF_NEXT_CHILD;
2744         roff_word_alloc(mdoc, n->line, n->pos, "BSD");
2745         mdoc->last->flags |= NODE_NOSRC;
2746
2747         if (nch == NULL) {
2748                 mdoc->last = n;
2749                 return;
2750         }
2751
2752         roff_elem_alloc(mdoc, n->line, n->pos, MDOC_Ns);
2753         mdoc->last->flags |= NODE_NOSRC;
2754         mdoc->next = ROFF_NEXT_SIBLING;
2755         roff_word_alloc(mdoc, n->line, n->pos, "-");
2756         mdoc->last->flags |= NODE_NOSRC;
2757         roff_elem_alloc(mdoc, n->line, n->pos, MDOC_Ns);
2758         mdoc->last->flags |= NODE_NOSRC;
2759         mdoc->last = n;
2760
2761         /*
2762          * Make `Bx's second argument always start with an uppercase
2763          * letter.  Groff checks if it's an "accepted" term, but we just
2764          * uppercase blindly.
2765          */
2766
2767         *nch->string = (char)toupper((unsigned char)*nch->string);
2768 }
2769
2770 static void
2771 post_os(POST_ARGS)
2772 {
2773 #ifndef OSNAME
2774         struct utsname    utsname;
2775         static char      *defbuf;
2776 #endif
2777         struct roff_node *n;
2778
2779         n = mdoc->last;
2780         n->flags |= NODE_NOPRT;
2781
2782         if (mdoc->meta.os != NULL)
2783                 mandoc_msg(MANDOCERR_PROLOG_REP, mdoc->parse,
2784                     n->line, n->pos, "Os");
2785         else if (mdoc->flags & MDOC_PBODY)
2786                 mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
2787                     n->line, n->pos, "Os");
2788
2789         post_delim(mdoc);
2790
2791         /*
2792          * Set the operating system by way of the `Os' macro.
2793          * The order of precedence is:
2794          * 1. the argument of the `Os' macro, unless empty
2795          * 2. the -Ios=foo command line argument, if provided
2796          * 3. -DOSNAME="\"foo\"", if provided during compilation
2797          * 4. "sysname release" from uname(3)
2798          */
2799
2800         free(mdoc->meta.os);
2801         mdoc->meta.os = NULL;
2802         deroff(&mdoc->meta.os, n);
2803         if (mdoc->meta.os)
2804                 goto out;
2805
2806         if (mdoc->os_s != NULL) {
2807                 mdoc->meta.os = mandoc_strdup(mdoc->os_s);
2808                 goto out;
2809         }
2810
2811 #ifdef OSNAME
2812         mdoc->meta.os = mandoc_strdup(OSNAME);
2813 #else /*!OSNAME */
2814         if (defbuf == NULL) {
2815                 if (uname(&utsname) == -1) {
2816                         mandoc_msg(MANDOCERR_OS_UNAME, mdoc->parse,
2817                             n->line, n->pos, "Os");
2818                         defbuf = mandoc_strdup("UNKNOWN");
2819                 } else
2820                         mandoc_asprintf(&defbuf, "%s %s",
2821                             utsname.sysname, utsname.release);
2822         }
2823         mdoc->meta.os = mandoc_strdup(defbuf);
2824 #endif /*!OSNAME*/
2825
2826 out:
2827         if (mdoc->meta.os_e == MANDOC_OS_OTHER) {
2828                 if (strstr(mdoc->meta.os, "OpenBSD") != NULL)
2829                         mdoc->meta.os_e = MANDOC_OS_OPENBSD;
2830                 else if (strstr(mdoc->meta.os, "NetBSD") != NULL)
2831                         mdoc->meta.os_e = MANDOC_OS_NETBSD;
2832         }
2833
2834         /*
2835          * This is the earliest point where we can check
2836          * Mdocdate conventions because we don't know
2837          * the operating system earlier.
2838          */
2839
2840         if (n->child != NULL)
2841                 mandoc_vmsg(MANDOCERR_OS_ARG, mdoc->parse,
2842                     n->child->line, n->child->pos,
2843                     "Os %s (%s)", n->child->string,
2844                     mdoc->meta.os_e == MANDOC_OS_OPENBSD ?
2845                     "OpenBSD" : "NetBSD");
2846
2847         while (n->tok != MDOC_Dd)
2848                 if ((n = n->prev) == NULL)
2849                         return;
2850         if ((n = n->child) == NULL)
2851                 return;
2852         if (strncmp(n->string, "$" "Mdocdate", 9)) {
2853                 if (mdoc->meta.os_e == MANDOC_OS_OPENBSD)
2854                         mandoc_vmsg(MANDOCERR_MDOCDATE_MISSING,
2855                             mdoc->parse, n->line, n->pos,
2856                             "Dd %s (OpenBSD)", n->string);
2857         } else {
2858                 if (mdoc->meta.os_e == MANDOC_OS_NETBSD)
2859                         mandoc_vmsg(MANDOCERR_MDOCDATE,
2860                             mdoc->parse, n->line, n->pos,
2861                             "Dd %s (NetBSD)", n->string);
2862         }
2863 }
2864
2865 enum roff_sec
2866 mdoc_a2sec(const char *p)
2867 {
2868         int              i;
2869
2870         for (i = 0; i < (int)SEC__MAX; i++)
2871                 if (secnames[i] && 0 == strcmp(p, secnames[i]))
2872                         return (enum roff_sec)i;
2873
2874         return SEC_CUSTOM;
2875 }
2876
2877 static size_t
2878 macro2len(enum roff_tok macro)
2879 {
2880
2881         switch (macro) {
2882         case MDOC_Ad:
2883                 return 12;
2884         case MDOC_Ao:
2885                 return 12;
2886         case MDOC_An:
2887                 return 12;
2888         case MDOC_Aq:
2889                 return 12;
2890         case MDOC_Ar:
2891                 return 12;
2892         case MDOC_Bo:
2893                 return 12;
2894         case MDOC_Bq:
2895                 return 12;
2896         case MDOC_Cd:
2897                 return 12;
2898         case MDOC_Cm:
2899                 return 10;
2900         case MDOC_Do:
2901                 return 10;
2902         case MDOC_Dq:
2903                 return 12;
2904         case MDOC_Dv:
2905                 return 12;
2906         case MDOC_Eo:
2907                 return 12;
2908         case MDOC_Em:
2909                 return 10;
2910         case MDOC_Er:
2911                 return 17;
2912         case MDOC_Ev:
2913                 return 15;
2914         case MDOC_Fa:
2915                 return 12;
2916         case MDOC_Fl:
2917                 return 10;
2918         case MDOC_Fo:
2919                 return 16;
2920         case MDOC_Fn:
2921                 return 16;
2922         case MDOC_Ic:
2923                 return 10;
2924         case MDOC_Li:
2925                 return 16;
2926         case MDOC_Ms:
2927                 return 6;
2928         case MDOC_Nm:
2929                 return 10;
2930         case MDOC_No:
2931                 return 12;
2932         case MDOC_Oo:
2933                 return 10;
2934         case MDOC_Op:
2935                 return 14;
2936         case MDOC_Pa:
2937                 return 32;
2938         case MDOC_Pf:
2939                 return 12;
2940         case MDOC_Po:
2941                 return 12;
2942         case MDOC_Pq:
2943                 return 12;
2944         case MDOC_Ql:
2945                 return 16;
2946         case MDOC_Qo:
2947                 return 12;
2948         case MDOC_So:
2949                 return 12;
2950         case MDOC_Sq:
2951                 return 12;
2952         case MDOC_Sy:
2953                 return 6;
2954         case MDOC_Sx:
2955                 return 16;
2956         case MDOC_Tn:
2957                 return 10;
2958         case MDOC_Va:
2959                 return 12;
2960         case MDOC_Vt:
2961                 return 12;
2962         case MDOC_Xr:
2963                 return 10;
2964         default:
2965                 break;
2966         };
2967         return 0;
2968 }