external/bsd/mdocml/dist/mdoc_validate.c

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