mdoc_action.c

   1 /*      $Id: mdoc_action.c,v 1.81 2010/11/29 13:51:03 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #ifndef OSNAME
  22 #include <sys/utsname.h>
  23 #endif
  24
  25 #include <assert.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include "mandoc.h"
  32 #include "libmdoc.h"
  33 #include "libmandoc.h"
  34
  35 /*
  36  * FIXME: this file is deprecated.  All future "actions" should be
  37  * pushed into mdoc_validate.c.
  38  */
  39
  40 #define POST_ARGS struct mdoc *m, struct mdoc_node *n
  41 #define PRE_ARGS  struct mdoc *m, struct mdoc_node *n
  42
  43 #define NUMSIZ    32
  44 #define DATESIZ   32
  45
  46 struct  actions {
  47         int     (*pre)(PRE_ARGS);
  48         int     (*post)(POST_ARGS);
  49 };
  50
  51 static  int       concat(struct mdoc *, char *,
  52                         const struct mdoc_node *, size_t);
  53
  54 static  int       post_at(POST_ARGS);
  55 static  int       post_bl(POST_ARGS);
  56 static  int       post_bl_head(POST_ARGS);
  57 static  int       post_bl_tagwidth(POST_ARGS);
  58 static  int       post_bl_width(POST_ARGS);
  59 static  int       post_dd(POST_ARGS);
  60 static  int       post_display(POST_ARGS);
  61 static  int       post_dt(POST_ARGS);
  62 static  int       post_lb(POST_ARGS);
  63 static  int       post_nm(POST_ARGS);
  64 static  int       post_os(POST_ARGS);
  65 static  int       post_pa(POST_ARGS);
  66 static  int       post_prol(POST_ARGS);
  67 static  int       post_st(POST_ARGS);
  68 static  int       post_std(POST_ARGS);
  69
  70 static  int       pre_bd(PRE_ARGS);
  71 static  int       pre_dl(PRE_ARGS);
  72
  73 static  const struct actions mdoc_actions[MDOC_MAX] = {
  74         { NULL, NULL }, /* Ap */
  75         { NULL, post_dd }, /* Dd */
  76         { NULL, post_dt }, /* Dt */
  77         { NULL, post_os }, /* Os */
  78         { NULL, NULL }, /* Sh */
  79         { NULL, NULL }, /* Ss */
  80         { NULL, NULL }, /* Pp */
  81         { NULL, NULL }, /* D1 */
  82         { pre_dl, post_display }, /* Dl */
  83         { pre_bd, post_display }, /* Bd */
  84         { NULL, NULL }, /* Ed */
  85         { NULL, post_bl }, /* Bl */
  86         { NULL, NULL }, /* El */
  87         { NULL, NULL }, /* It */
  88         { NULL, NULL }, /* Ad */
  89         { NULL, NULL }, /* An */
  90         { NULL, NULL }, /* Ar */
  91         { NULL, NULL }, /* Cd */
  92         { NULL, NULL }, /* Cm */
  93         { NULL, NULL }, /* Dv */
  94         { NULL, NULL }, /* Er */
  95         { NULL, NULL }, /* Ev */
  96         { NULL, post_std }, /* Ex */
  97         { NULL, NULL }, /* Fa */
  98         { NULL, NULL }, /* Fd */
  99         { NULL, NULL }, /* Fl */
 100         { NULL, NULL }, /* Fn */
 101         { NULL, NULL }, /* Ft */
 102         { NULL, NULL }, /* Ic */
 103         { NULL, NULL }, /* In */
 104         { NULL, NULL }, /* Li */
 105         { NULL, NULL }, /* Nd */
 106         { NULL, post_nm }, /* Nm */
 107         { NULL, NULL }, /* Op */
 108         { NULL, NULL }, /* Ot */
 109         { NULL, post_pa }, /* Pa */
 110         { NULL, post_std }, /* Rv */
 111         { NULL, post_st }, /* St */
 112         { NULL, NULL }, /* Va */
 113         { NULL, NULL }, /* Vt */
 114         { NULL, NULL }, /* Xr */
 115         { NULL, NULL }, /* %A */
 116         { NULL, NULL }, /* %B */
 117         { NULL, NULL }, /* %D */
 118         { NULL, NULL }, /* %I */
 119         { NULL, NULL }, /* %J */
 120         { NULL, NULL }, /* %N */
 121         { NULL, NULL }, /* %O */
 122         { NULL, NULL }, /* %P */
 123         { NULL, NULL }, /* %R */
 124         { NULL, NULL }, /* %T */
 125         { NULL, NULL }, /* %V */
 126         { NULL, NULL }, /* Ac */
 127         { NULL, NULL }, /* Ao */
 128         { NULL, NULL }, /* Aq */
 129         { NULL, post_at }, /* At */
 130         { NULL, NULL }, /* Bc */
 131         { NULL, NULL }, /* Bf */
 132         { NULL, NULL }, /* Bo */
 133         { NULL, NULL }, /* Bq */
 134         { NULL, NULL }, /* Bsx */
 135         { NULL, NULL }, /* Bx */
 136         { NULL, NULL }, /* Db */
 137         { NULL, NULL }, /* Dc */
 138         { NULL, NULL }, /* Do */
 139         { NULL, NULL }, /* Dq */
 140         { NULL, NULL }, /* Ec */
 141         { NULL, NULL }, /* Ef */
 142         { NULL, NULL }, /* Em */
 143         { NULL, NULL }, /* Eo */
 144         { NULL, NULL }, /* Fx */
 145         { NULL, NULL }, /* Ms */
 146         { NULL, NULL }, /* No */
 147         { NULL, NULL }, /* Ns */
 148         { NULL, NULL }, /* Nx */
 149         { NULL, NULL }, /* Ox */
 150         { NULL, NULL }, /* Pc */
 151         { NULL, NULL }, /* Pf */
 152         { NULL, NULL }, /* Po */
 153         { NULL, NULL }, /* Pq */
 154         { NULL, NULL }, /* Qc */
 155         { NULL, NULL }, /* Ql */
 156         { NULL, NULL }, /* Qo */
 157         { NULL, NULL }, /* Qq */
 158         { NULL, NULL }, /* Re */
 159         { NULL, NULL }, /* Rs */
 160         { NULL, NULL }, /* Sc */
 161         { NULL, NULL }, /* So */
 162         { NULL, NULL }, /* Sq */
 163         { NULL, NULL }, /* Sm */
 164         { NULL, NULL }, /* Sx */
 165         { NULL, NULL }, /* Sy */
 166         { NULL, NULL }, /* Tn */
 167         { NULL, NULL }, /* Ux */
 168         { NULL, NULL }, /* Xc */
 169         { NULL, NULL }, /* Xo */
 170         { NULL, NULL }, /* Fo */
 171         { NULL, NULL }, /* Fc */
 172         { NULL, NULL }, /* Oo */
 173         { NULL, NULL }, /* Oc */
 174         { NULL, NULL }, /* Bk */
 175         { NULL, NULL }, /* Ek */
 176         { NULL, NULL }, /* Bt */
 177         { NULL, NULL }, /* Hf */
 178         { NULL, NULL }, /* Fr */
 179         { NULL, NULL }, /* Ud */
 180         { NULL, post_lb }, /* Lb */
 181         { NULL, NULL }, /* Lp */
 182         { NULL, NULL }, /* Lk */
 183         { NULL, NULL }, /* Mt */
 184         { NULL, NULL }, /* Brq */
 185         { NULL, NULL }, /* Bro */
 186         { NULL, NULL }, /* Brc */
 187         { NULL, NULL }, /* %C */
 188         { NULL, NULL }, /* Es */
 189         { NULL, NULL }, /* En */
 190         { NULL, NULL }, /* Dx */
 191         { NULL, NULL }, /* %Q */
 192         { NULL, NULL }, /* br */
 193         { NULL, NULL }, /* sp */
 194         { NULL, NULL }, /* %U */
 195         { NULL, NULL }, /* Ta */
 196 };
 197
 198 #define RSORD_MAX 14
 199
 200 static  const enum mdoct rsord[RSORD_MAX] = {
 201         MDOC__A,
 202         MDOC__T,
 203         MDOC__B,
 204         MDOC__I,
 205         MDOC__J,
 206         MDOC__R,
 207         MDOC__N,
 208         MDOC__V,
 209         MDOC__P,
 210         MDOC__Q,
 211         MDOC__D,
 212         MDOC__O,
 213         MDOC__C,
 214         MDOC__U
 215 };
 216
 217
 218 int
 219 mdoc_action_pre(struct mdoc *m, struct mdoc_node *n)
 220 {
 221
 222         switch (n->type) {
 223         case (MDOC_ROOT):
 224                 /* FALLTHROUGH */
 225         case (MDOC_TEXT):
 226                 return(1);
 227         default:
 228                 break;
 229         }
 230
 231         if (NULL == mdoc_actions[n->tok].pre)
 232                 return(1);
 233         return((*mdoc_actions[n->tok].pre)(m, n));
 234 }
 235
 236
 237 int
 238 mdoc_action_post(struct mdoc *m)
 239 {
 240
 241         if (MDOC_ACTED & m->last->flags)
 242                 return(1);
 243         m->last->flags |= MDOC_ACTED;
 244
 245         switch (m->last->type) {
 246         case (MDOC_TEXT):
 247                 /* FALLTHROUGH */
 248         case (MDOC_ROOT):
 249                 return(1);
 250         default:
 251                 break;
 252         }
 253
 254         if (NULL == mdoc_actions[m->last->tok].post)
 255                 return(1);
 256         return((*mdoc_actions[m->last->tok].post)(m, m->last));
 257 }
 258
 259
 260 /*
 261  * Concatenate sibling nodes together.  All siblings must be of type
 262  * MDOC_TEXT or an assertion is raised.  Concatenation is separated by a
 263  * single whitespace.
 264  */
 265 static int
 266 concat(struct mdoc *m, char *p, const struct mdoc_node *n, size_t sz)
 267 {
 268
 269         assert(sz);
 270         p[0] = '\0';
 271         for ( ; n; n = n->next) {
 272                 assert(MDOC_TEXT == n->type);
 273                 /*
 274                  * XXX: yes, these can technically be resized, but it's
 275                  * highly unlikely that we're going to get here, so let
 276                  * it slip for now.
 277                  */
 278                 if (strlcat(p, n->string, sz) >= sz) {
 279                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 280                         return(0);
 281                 }
 282                 if (NULL == n->next)
 283                         continue;
 284                 if (strlcat(p, " ", sz) >= sz) {
 285                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 286                         return(0);
 287                 }
 288         }
 289
 290         return(1);
 291 }
 292
 293
 294 /*
 295  * Macros accepting `-std' as an argument have the name of the current
 296  * document (`Nm') filled in as the argument if it's not provided.
 297  */
 298 static int
 299 post_std(POST_ARGS)
 300 {
 301         struct mdoc_node *nn;
 302
 303         if (n->child)
 304                 return(1);
 305         if (NULL == m->meta.name)
 306                 return(1);
 307
 308         nn = n;
 309         m->next = MDOC_NEXT_CHILD;
 310
 311         if ( ! mdoc_word_alloc(m, n->line, n->pos, m->meta.name))
 312                 return(0);
 313         m->last = nn;
 314         return(1);
 315 }
 316
 317
 318 /*
 319  * The `Nm' macro's first use sets the name of the document.  See also
 320  * post_std(), etc.
 321  */
 322 static int
 323 post_nm(POST_ARGS)
 324 {
 325         char             buf[BUFSIZ];
 326
 327         if (m->meta.name)
 328                 return(1);
 329         if ( ! concat(m, buf, n->child, BUFSIZ))
 330                 return(0);
 331         m->meta.name = mandoc_strdup(buf);
 332         return(1);
 333 }
 334
 335
 336 /*
 337  * Look up the value of `Lb' for matching predefined strings.  If it has
 338  * one, then substitute the current value for the formatted value.  Note
 339  * that the lookup may fail (we can provide arbitrary strings).
 340  */
 341 /* ARGSUSED */
 342 static int
 343 post_lb(POST_ARGS)
 344 {
 345         const char      *p;
 346         char            *buf;
 347         size_t           sz;
 348
 349         assert(MDOC_TEXT == n->child->type);
 350         p = mdoc_a2lib(n->child->string);
 351
 352         if (p) {
 353                 free(n->child->string);
 354                 n->child->string = mandoc_strdup(p);
 355                 return(1);
 356         }
 357
 358         sz = strlen(n->child->string) +
 359                 2 + strlen("\\(lqlibrary\\(rq");
 360         buf = mandoc_malloc(sz);
 361         snprintf(buf, sz, "library \\(lq%s\\(rq", n->child->string);
 362         free(n->child->string);
 363         n->child->string = buf;
 364         return(1);
 365 }
 366
 367
 368 /*
 369  * Substitute the value of `St' for the corresponding formatted string.
 370  * We're guaranteed that this exists (it's been verified during the
 371  * validation phase).
 372  */
 373 /* ARGSUSED */
 374 static int
 375 post_st(POST_ARGS)
 376 {
 377         const char      *p;
 378
 379         assert(MDOC_TEXT == n->child->type);
 380         p = mdoc_a2st(n->child->string);
 381         if (p != NULL) {
 382                 free(n->child->string);
 383                 n->child->string = mandoc_strdup(p);
 384         }
 385         return(1);
 386 }
 387
 388
 389 /*
 390  * Look up the standard string in a table.  We know that it exists from
 391  * the validation phase, so assert on failure.  If a standard key wasn't
 392  * supplied, supply the default ``AT&T UNIX''.
 393  */
 394 static int
 395 post_at(POST_ARGS)
 396 {
 397         struct mdoc_node *nn;
 398         const char       *p, *q;
 399         char             *buf;
 400         size_t            sz;
 401
 402         if (n->child) {
 403                 assert(MDOC_TEXT == n->child->type);
 404                 p = mdoc_a2att(n->child->string);
 405                 if (p) {
 406                         free(n->child->string);
 407                         n->child->string = mandoc_strdup(p);
 408                 } else {
 409                         p = "AT&T UNIX ";
 410                         q = n->child->string;
 411                         sz = strlen(p) + strlen(q) + 1;
 412                         buf = mandoc_malloc(sz);
 413                         strlcpy(buf, p, sz);
 414                         strlcat(buf, q, sz);
 415                         free(n->child->string);
 416                         n->child->string = buf;
 417                 }
 418                 return(1);
 419         }
 420
 421         nn = n;
 422         m->next = MDOC_NEXT_CHILD;
 423         if ( ! mdoc_word_alloc(m, nn->line, nn->pos, "AT&T UNIX"))
 424                 return(0);
 425         m->last = nn;
 426         return(1);
 427 }
 428
 429
 430 /*
 431  * Parse out the contents of `Dt'.  See in-line documentation for how we
 432  * handle the various fields of this macro.
 433  */
 434 static int
 435 post_dt(POST_ARGS)
 436 {
 437         struct mdoc_node *nn;
 438         const char       *cp;
 439
 440         if (m->meta.title)
 441                 free(m->meta.title);
 442         if (m->meta.vol)
 443                 free(m->meta.vol);
 444         if (m->meta.arch)
 445                 free(m->meta.arch);
 446
 447         m->meta.title = m->meta.vol = m->meta.arch = NULL;
 448         /* Handles: `.Dt'
 449          *   --> title = unknown, volume = local, msec = 0, arch = NULL
 450          */
 451
 452         if (NULL == (nn = n->child)) {
 453                 /* XXX: make these macro values. */
 454                 /* FIXME: warn about missing values. */
 455                 m->meta.title = mandoc_strdup("UNKNOWN");
 456                 m->meta.vol = mandoc_strdup("LOCAL");
 457                 m->meta.msec = mandoc_strdup("1");
 458                 return(post_prol(m, n));
 459         }
 460
 461         /* Handles: `.Dt TITLE'
 462          *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 463          */
 464
 465         m->meta.title = mandoc_strdup
 466                 ('\0' == nn->string[0] ? "UNKNOWN" : nn->string);
 467
 468         if (NULL == (nn = nn->next)) {
 469                 /* FIXME: warn about missing msec. */
 470                 /* XXX: make this a macro value. */
 471                 m->meta.vol = mandoc_strdup("LOCAL");
 472                 m->meta.msec = mandoc_strdup("1");
 473                 return(post_prol(m, n));
 474         }
 475
 476         /* Handles: `.Dt TITLE SEC'
 477          *   --> title = TITLE, volume = SEC is msec ?
 478          *           format(msec) : SEC,
 479          *       msec = SEC is msec ? atoi(msec) : 0,
 480          *       arch = NULL
 481          */
 482
 483         cp = mdoc_a2msec(nn->string);
 484         if (cp) {
 485                 m->meta.vol = mandoc_strdup(cp);
 486                 m->meta.msec = mandoc_strdup(nn->string);
 487         } else if (mdoc_nmsg(m, n, MANDOCERR_BADMSEC)) {
 488                 m->meta.vol = mandoc_strdup(nn->string);
 489                 m->meta.msec = mandoc_strdup(nn->string);
 490         } else
 491                 return(0);
 492
 493         if (NULL == (nn = nn->next))
 494                 return(post_prol(m, n));
 495
 496         /* Handles: `.Dt TITLE SEC VOL'
 497          *   --> title = TITLE, volume = VOL is vol ?
 498          *       format(VOL) :
 499          *           VOL is arch ? format(arch) :
 500          *               VOL
 501          */
 502
 503         cp = mdoc_a2vol(nn->string);
 504         if (cp) {
 505                 free(m->meta.vol);
 506                 m->meta.vol = mandoc_strdup(cp);
 507         } else {
 508                 /* FIXME: warn about bad arch. */
 509                 cp = mdoc_a2arch(nn->string);
 510                 if (NULL == cp) {
 511                         free(m->meta.vol);
 512                         m->meta.vol = mandoc_strdup(nn->string);
 513                 } else
 514                         m->meta.arch = mandoc_strdup(cp);
 515         }
 516
 517         /* Ignore any subsequent parameters... */
 518         /* FIXME: warn about subsequent parameters. */
 519
 520         return(post_prol(m, n));
 521 }
 522
 523
 524 /*
 525  * Set the operating system by way of the `Os' macro.  Note that if an
 526  * argument isn't provided and -DOSNAME="\"foo\"" is provided during
 527  * compilation, this value will be used instead of filling in "sysname
 528  * release" from uname().
 529  */
 530 static int
 531 post_os(POST_ARGS)
 532 {
 533         char              buf[BUFSIZ];
 534 #ifndef OSNAME
 535         struct utsname    utsname;
 536 #endif
 537
 538         if (m->meta.os)
 539                 free(m->meta.os);
 540
 541         if ( ! concat(m, buf, n->child, BUFSIZ))
 542                 return(0);
 543
 544         /* XXX: yes, these can all be dynamically-adjusted buffers, but
 545          * it's really not worth the extra hackery.
 546          */
 547
 548         if ('\0' == buf[0]) {
 549 #ifdef OSNAME
 550                 if (strlcat(buf, OSNAME, BUFSIZ) >= BUFSIZ) {
 551                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 552                         return(0);
 553                 }
 554 #else /*!OSNAME */
 555                 if (-1 == uname(&utsname))
 556                         return(mdoc_nmsg(m, n, MANDOCERR_UTSNAME));
 557
 558                 if (strlcat(buf, utsname.sysname, BUFSIZ) >= BUFSIZ) {
 559                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 560                         return(0);
 561                 }
 562                 if (strlcat(buf, " ", 64) >= BUFSIZ) {
 563                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 564                         return(0);
 565                 }
 566                 if (strlcat(buf, utsname.release, BUFSIZ) >= BUFSIZ) {
 567                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 568                         return(0);
 569                 }
 570 #endif /*!OSNAME*/
 571         }
 572
 573         m->meta.os = mandoc_strdup(buf);
 574         return(post_prol(m, n));
 575 }
 576
 577
 578 /*
 579  * Calculate the -width for a `Bl -tag' list if it hasn't been provided.
 580  * Uses the first head macro.  NOTE AGAIN: this is ONLY if the -width
 581  * argument has NOT been provided.  See post_bl_width() for converting
 582  * the -width string.
 583  */
 584 static int
 585 post_bl_tagwidth(POST_ARGS)
 586 {
 587         struct mdoc_node *nn;
 588         size_t            sz, ssz;
 589         int               i;
 590         char              buf[NUMSIZ];
 591
 592         sz = 10;
 593
 594         for (nn = n->body->child; nn; nn = nn->next) {
 595                 if (MDOC_It != nn->tok)
 596                         continue;
 597
 598                 assert(MDOC_BLOCK == nn->type);
 599                 nn = nn->head->child;
 600
 601                 if (nn == NULL) {
 602                         /* No -width for .Bl and first .It is emtpy */
 603                         if ( ! mdoc_nmsg(m, n, MANDOCERR_NOWIDTHARG))
 604                                 return(0);
 605                         break;
 606                 }
 607
 608                 if (MDOC_TEXT == nn->type) {
 609                         sz = strlen(nn->string) + 1;
 610                         break;
 611                 }
 612
 613                 if (0 != (ssz = mdoc_macro2len(nn->tok)))
 614                         sz = ssz;
 615                 else if ( ! mdoc_nmsg(m, n, MANDOCERR_NOWIDTHARG))
 616                         return(0);
 617
 618                 break;
 619         }
 620
 621         /* Defaults to ten ens. */
 622
 623         snprintf(buf, NUMSIZ, "%zun", sz);
 624
 625         /*
 626          * We have to dynamically add this to the macro's argument list.
 627          * We're guaranteed that a MDOC_Width doesn't already exist.
 628          */
 629
 630         assert(n->args);
 631         i = (int)(n->args->argc)++;
 632
 633         n->args->argv = mandoc_realloc(n->args->argv,
 634                         n->args->argc * sizeof(struct mdoc_argv));
 635
 636         n->args->argv[i].arg = MDOC_Width;
 637         n->args->argv[i].line = n->line;
 638         n->args->argv[i].pos = n->pos;
 639         n->args->argv[i].sz = 1;
 640         n->args->argv[i].value = mandoc_malloc(sizeof(char *));
 641         n->args->argv[i].value[0] = mandoc_strdup(buf);
 642
 643         /* Set our width! */
 644         n->data.Bl->width = n->args->argv[i].value[0];
 645         return(1);
 646 }
 647
 648
 649 /*
 650  * Calculate the real width of a list from the -width string, which may
 651  * contain a macro (with a known default width), a literal string, or a
 652  * scaling width.
 653  */
 654 static int
 655 post_bl_width(POST_ARGS)
 656 {
 657         size_t            width;
 658         int               i;
 659         enum mdoct        tok;
 660         char              buf[NUMSIZ];
 661
 662         /*
 663          * If the value to -width is a macro, then we re-write it to be
 664          * the macro's width as set in share/tmac/mdoc/doc-common.
 665          */
 666
 667         if (0 == strcmp(n->data.Bl->width, "Ds"))
 668                 width = 6;
 669         else if (MDOC_MAX == (tok = mdoc_hash_find(n->data.Bl->width)))
 670                 return(1);
 671         else if (0 == (width = mdoc_macro2len(tok)))
 672                 return(mdoc_nmsg(m, n, MANDOCERR_BADWIDTH));
 673
 674         /* The value already exists: free and reallocate it. */
 675
 676         assert(n->args);
 677
 678         for (i = 0; i < (int)n->args->argc; i++)
 679                 if (MDOC_Width == n->args->argv[i].arg)
 680                         break;
 681
 682         assert(i < (int)n->args->argc);
 683
 684         snprintf(buf, NUMSIZ, "%zun", width);
 685         free(n->args->argv[i].value[0]);
 686         n->args->argv[i].value[0] = mandoc_strdup(buf);
 687
 688         /* Set our width! */
 689         n->data.Bl->width = n->args->argv[i].value[0];
 690         return(1);
 691 }
 692
 693
 694 /*
 695  * Do processing for -column lists, which can have two distinct styles
 696  * of invocation.  Merge this two styles into a consistent form.
 697  */
 698 /* ARGSUSED */
 699 static int
 700 post_bl_head(POST_ARGS)
 701 {
 702         int                      i, c;
 703         struct mdoc_node        *np, *nn, *nnp;
 704
 705         if (LIST_column != n->data.Bl->type)
 706                 return(1);
 707         else if (NULL == n->child)
 708                 return(1);
 709
 710         np = n->parent;
 711         assert(np->args);
 712
 713         for (c = 0; c < (int)np->args->argc; c++)
 714                 if (MDOC_Column == np->args->argv[c].arg)
 715                         break;
 716
 717         assert(c < (int)np->args->argc);
 718         assert(0 == np->args->argv[c].sz);
 719
 720         /*
 721          * Accomodate for new-style groff column syntax.  Shuffle the
 722          * child nodes, all of which must be TEXT, as arguments for the
 723          * column field.  Then, delete the head children.
 724          */
 725
 726         np->args->argv[c].sz = (size_t)n->nchild;
 727         np->args->argv[c].value = mandoc_malloc
 728                 ((size_t)n->nchild * sizeof(char *));
 729
 730         n->data.Bl->ncols = np->args->argv[c].sz;
 731         n->data.Bl->cols = (const char **)np->args->argv[c].value;
 732
 733         for (i = 0, nn = n->child; nn; i++) {
 734                 np->args->argv[c].value[i] = nn->string;
 735                 nn->string = NULL;
 736                 nnp = nn;
 737                 nn = nn->next;
 738                 mdoc_node_delete(NULL, nnp);
 739         }
 740
 741         n->nchild = 0;
 742         n->child = NULL;
 743         return(1);
 744 }
 745
 746
 747 static int
 748 post_bl(POST_ARGS)
 749 {
 750
 751         if (MDOC_HEAD == n->type)
 752                 return(post_bl_head(m, n));
 753         if (MDOC_BLOCK != n->type)
 754                 return(1);
 755
 756         /*
 757          * These are fairly complicated, so we've broken them into two
 758          * functions.  post_bl_tagwidth() is called when a -tag is
 759          * specified, but no -width (it must be guessed).  The second
 760          * when a -width is specified (macro indicators must be
 761          * rewritten into real lengths).
 762          */
 763
 764         if (LIST_tag == n->data.Bl->type && NULL == n->data.Bl->width) {
 765                 if ( ! post_bl_tagwidth(m, n))
 766                         return(0);
 767         } else if (NULL != n->data.Bl->width) {
 768                 if ( ! post_bl_width(m, n))
 769                         return(0);
 770         } else
 771                 return(1);
 772
 773         assert(n->data.Bl->width);
 774         return(1);
 775 }
 776
 777
 778 /*
 779  * The `Pa' macro defaults to a tilde if no value is provided as an
 780  * argument.
 781  */
 782 static int
 783 post_pa(POST_ARGS)
 784 {
 785         struct mdoc_node *np;
 786
 787         if (n->child)
 788                 return(1);
 789
 790         np = n;
 791         m->next = MDOC_NEXT_CHILD;
 792         if ( ! mdoc_word_alloc(m, n->line, n->pos, "~"))
 793                 return(0);
 794         m->last = np;
 795         return(1);
 796 }
 797
 798
 799 /*
 800  * Parse the date field in `Dd'.
 801  */
 802 static int
 803 post_dd(POST_ARGS)
 804 {
 805         char            buf[DATESIZ];
 806
 807         if (NULL == n->child) {
 808                 m->meta.date = time(NULL);
 809                 return(post_prol(m, n));
 810         }
 811
 812         if ( ! concat(m, buf, n->child, DATESIZ))
 813                 return(0);
 814
 815         m->meta.date = mandoc_a2time
 816                 (MTIME_MDOCDATE | MTIME_CANONICAL, buf);
 817
 818         if (0 == m->meta.date) {
 819                 if ( ! mdoc_nmsg(m, n, MANDOCERR_BADDATE))
 820                         return(0);
 821                 m->meta.date = time(NULL);
 822         }
 823
 824         return(post_prol(m, n));
 825 }
 826
 827
 828 /*
 829  * Remove prologue macros from the document after they're processed.
 830  * The final document uses mdoc_meta for these values and discards the
 831  * originals.
 832  */
 833 static int
 834 post_prol(POST_ARGS)
 835 {
 836
 837         mdoc_node_delete(m, n);
 838         if (m->meta.title && m->meta.date && m->meta.os)
 839                 m->flags |= MDOC_PBODY;
 840         return(1);
 841 }
 842
 843
 844 /*
 845  * Trigger a literal context.
 846  */
 847 static int
 848 pre_dl(PRE_ARGS)
 849 {
 850
 851         if (MDOC_BODY == n->type)
 852                 m->flags |= MDOC_LITERAL;
 853         return(1);
 854 }
 855
 856
 857 static int
 858 pre_bd(PRE_ARGS)
 859 {
 860
 861         if (MDOC_BODY != n->type)
 862                 return(1);
 863
 864         assert(n->data.Bd);
 865         if (DISP_literal == n->data.Bd->type)
 866                 m->flags |= MDOC_LITERAL;
 867         if (DISP_unfilled == n->data.Bd->type)
 868                 m->flags |= MDOC_LITERAL;
 869
 870         return(1);
 871 }
 872
 873
 874 static int
 875 post_display(POST_ARGS)
 876 {
 877
 878         if (MDOC_BODY == n->type)
 879                 m->flags &= ~MDOC_LITERAL;
 880         return(1);
 881 }