mdoc_action.c

   1 /*      $Id: mdoc_action.c,v 1.34 2009/07/26 10:29:39 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
   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 #include <sys/utsname.h>
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "libmdoc.h"
  26
  27 #define PRE_ARGS  struct mdoc *m, const struct mdoc_node *n
  28 #define POST_ARGS struct mdoc *m
  29
  30 struct  actions {
  31         int     (*pre)(PRE_ARGS);
  32         int     (*post)(POST_ARGS);
  33 };
  34
  35 static  int       post_ar(POST_ARGS);
  36 static  int       post_at(POST_ARGS);
  37 static  int       post_bl(POST_ARGS);
  38 static  int       post_bl_head(POST_ARGS);
  39 static  int       post_bl_tagwidth(POST_ARGS);
  40 static  int       post_bl_width(POST_ARGS);
  41 static  int       post_dd(POST_ARGS);
  42 static  int       post_display(POST_ARGS);
  43 static  int       post_dt(POST_ARGS);
  44 static  int       post_lb(POST_ARGS);
  45 static  int       post_nm(POST_ARGS);
  46 static  int       post_os(POST_ARGS);
  47 static  int       post_prol(POST_ARGS);
  48 static  int       post_sh(POST_ARGS);
  49 static  int       post_st(POST_ARGS);
  50 static  int       post_std(POST_ARGS);
  51 static  int       post_tilde(POST_ARGS);
  52
  53 static  int       pre_bd(PRE_ARGS);
  54 static  int       pre_dl(PRE_ARGS);
  55
  56 const   struct actions mdoc_actions[MDOC_MAX] = {
  57         { NULL, NULL }, /* Ap */
  58         { NULL, post_dd }, /* Dd */
  59         { NULL, post_dt }, /* Dt */
  60         { NULL, post_os }, /* Os */
  61         { NULL, post_sh }, /* Sh */
  62         { NULL, NULL }, /* Ss */
  63         { NULL, NULL }, /* Pp */
  64         { NULL, NULL }, /* D1 */
  65         { pre_dl, post_display }, /* Dl */
  66         { pre_bd, post_display }, /* Bd */
  67         { NULL, NULL }, /* Ed */
  68         { NULL, post_bl }, /* Bl */
  69         { NULL, NULL }, /* El */
  70         { NULL, NULL }, /* It */
  71         { NULL, NULL }, /* Ad */
  72         { NULL, NULL }, /* An */
  73         { NULL, post_ar }, /* Ar */
  74         { NULL, NULL }, /* Cd */ /* FIXME: tabs are accepted! */
  75         { NULL, NULL }, /* Cm */
  76         { NULL, NULL }, /* Dv */
  77         { NULL, NULL }, /* Er */
  78         { NULL, NULL }, /* Ev */
  79         { NULL, post_std }, /* Ex */
  80         { NULL, NULL }, /* Fa */
  81         { NULL, NULL }, /* Fd */
  82         { NULL, NULL }, /* Fl */
  83         { NULL, NULL }, /* Fn */
  84         { NULL, NULL }, /* Ft */
  85         { NULL, NULL }, /* Ic */
  86         { NULL, NULL }, /* In */
  87         { NULL, NULL }, /* Li */
  88         { NULL, NULL }, /* Nd */
  89         { NULL, post_nm }, /* Nm */
  90         { NULL, NULL }, /* Op */
  91         { NULL, NULL }, /* Ot */
  92         { NULL, post_tilde }, /* Pa */
  93         { NULL, post_std }, /* Rv */
  94         { NULL, post_st }, /* St */
  95         { NULL, NULL }, /* Va */
  96         { NULL, NULL }, /* Vt */
  97         { NULL, NULL }, /* Xr */
  98         { NULL, NULL }, /* %A */
  99         { NULL, NULL }, /* %B */
 100         { NULL, NULL }, /* %D */
 101         { NULL, NULL }, /* %I */
 102         { NULL, NULL }, /* %J */
 103         { NULL, NULL }, /* %N */
 104         { NULL, NULL }, /* %O */
 105         { NULL, NULL }, /* %P */
 106         { NULL, NULL }, /* %R */
 107         { NULL, NULL }, /* %T */
 108         { NULL, NULL }, /* %V */
 109         { NULL, NULL }, /* Ac */
 110         { NULL, NULL }, /* Ao */
 111         { NULL, NULL }, /* Aq */
 112         { NULL, post_at }, /* At */
 113         { NULL, NULL }, /* Bc */
 114         { NULL, NULL }, /* Bf */
 115         { NULL, NULL }, /* Bo */
 116         { NULL, NULL }, /* Bq */
 117         { NULL, NULL }, /* Bsx */
 118         { NULL, NULL }, /* Bx */
 119         { NULL, NULL }, /* Db */
 120         { NULL, NULL }, /* Dc */
 121         { NULL, NULL }, /* Do */
 122         { NULL, NULL }, /* Dq */
 123         { NULL, NULL }, /* Ec */
 124         { NULL, NULL }, /* Ef */
 125         { NULL, NULL }, /* Em */
 126         { NULL, NULL }, /* Eo */
 127         { NULL, NULL }, /* Fx */
 128         { NULL, NULL }, /* Ms */
 129         { NULL, NULL }, /* No */
 130         { NULL, NULL }, /* Ns */
 131         { NULL, NULL }, /* Nx */
 132         { NULL, NULL }, /* Ox */
 133         { NULL, NULL }, /* Pc */
 134         { NULL, NULL }, /* Pf */
 135         { NULL, NULL }, /* Po */
 136         { NULL, NULL }, /* Pq */
 137         { NULL, NULL }, /* Qc */
 138         { NULL, NULL }, /* Ql */
 139         { NULL, NULL }, /* Qo */
 140         { NULL, NULL }, /* Qq */
 141         { NULL, NULL }, /* Re */
 142         { NULL, NULL }, /* Rs */
 143         { NULL, NULL }, /* Sc */
 144         { NULL, NULL }, /* So */
 145         { NULL, NULL }, /* Sq */
 146         { NULL, NULL }, /* Sm */
 147         { NULL, NULL }, /* Sx */
 148         { NULL, NULL }, /* Sy */
 149         { NULL, NULL }, /* Tn */
 150         { NULL, NULL }, /* Ux */
 151         { NULL, NULL }, /* Xc */
 152         { NULL, NULL }, /* Xo */
 153         { NULL, NULL }, /* Fo */
 154         { NULL, NULL }, /* Fc */
 155         { NULL, NULL }, /* Oo */
 156         { NULL, NULL }, /* Oc */
 157         { NULL, NULL }, /* Bk */
 158         { NULL, NULL }, /* Ek */
 159         { NULL, NULL }, /* Bt */
 160         { NULL, NULL }, /* Hf */
 161         { NULL, NULL }, /* Fr */
 162         { NULL, NULL }, /* Ud */
 163         { NULL, post_lb }, /* Lb */
 164         { NULL, NULL }, /* Lp */
 165         { NULL, post_tilde }, /* Lk */
 166         { NULL, NULL }, /* Mt */
 167         { NULL, NULL }, /* Brq */
 168         { NULL, NULL }, /* Bro */
 169         { NULL, NULL }, /* Brc */
 170         { NULL, NULL }, /* %C */
 171         { NULL, NULL }, /* Es */
 172         { NULL, NULL }, /* En */
 173         { NULL, NULL }, /* Dx */
 174         { NULL, NULL }, /* %Q */
 175         { NULL, NULL }, /* br */
 176         { NULL, NULL }, /* sp */
 177 };
 178
 179 static  int       concat(struct mdoc *, const struct mdoc_node *,
 180                         char *, size_t);
 181
 182 #ifdef __linux__
 183 extern  size_t    strlcat(char *, const char *, size_t);
 184 #endif
 185
 186
 187 int
 188 mdoc_action_pre(struct mdoc *m, const struct mdoc_node *n)
 189 {
 190
 191         switch (n->type) {
 192         case (MDOC_ROOT):
 193                 /* FALLTHROUGH */
 194         case (MDOC_TEXT):
 195                 return(1);
 196         default:
 197                 break;
 198         }
 199
 200         if (NULL == mdoc_actions[n->tok].pre)
 201                 return(1);
 202         return((*mdoc_actions[n->tok].pre)(m, n));
 203 }
 204
 205
 206 int
 207 mdoc_action_post(struct mdoc *m)
 208 {
 209
 210         if (MDOC_ACTED & m->last->flags)
 211                 return(1);
 212         m->last->flags |= MDOC_ACTED;
 213
 214         switch (m->last->type) {
 215         case (MDOC_TEXT):
 216                 /* FALLTHROUGH */
 217         case (MDOC_ROOT):
 218                 return(1);
 219         default:
 220                 break;
 221         }
 222
 223         if (NULL == mdoc_actions[m->last->tok].post)
 224                 return(1);
 225         return((*mdoc_actions[m->last->tok].post)(m));
 226 }
 227
 228
 229 static int
 230 concat(struct mdoc *m, const struct mdoc_node *n,
 231                 char *buf, size_t sz)
 232 {
 233
 234         for ( ; n; n = n->next) {
 235                 assert(MDOC_TEXT == n->type);
 236                 if (strlcat(buf, n->string, sz) >= sz)
 237                         return(mdoc_nerr(m, n, ETOOLONG));
 238                 if (NULL == n->next)
 239                         continue;
 240                 if (strlcat(buf, " ", sz) >= sz)
 241                         return(mdoc_nerr(m, n, ETOOLONG));
 242         }
 243
 244         return(1);
 245 }
 246
 247
 248 static int
 249 post_std(POST_ARGS)
 250 {
 251
 252         /*
 253          * If '-std' is invoked without an argument, fill it in with our
 254          * name (if it's been set).
 255          */
 256
 257         if (NULL == m->last->args)
 258                 return(1);
 259         if (m->last->args->argv[0].sz)
 260                 return(1);
 261
 262         assert(m->meta.name);
 263
 264         m->last->args->argv[0].value = calloc(1, sizeof(char *));
 265         if (NULL == m->last->args->argv[0].value)
 266                 return(mdoc_nerr(m, m->last, EMALLOC));
 267
 268         m->last->args->argv[0].sz = 1;
 269         m->last->args->argv[0].value[0] = strdup(m->meta.name);
 270         if (NULL == m->last->args->argv[0].value[0])
 271                 return(mdoc_nerr(m, m->last, EMALLOC));
 272
 273         return(1);
 274 }
 275
 276
 277 static int
 278 post_nm(POST_ARGS)
 279 {
 280         char             buf[64];
 281
 282         if (m->meta.name)
 283                 return(1);
 284
 285         buf[0] = 0;
 286         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 287                 return(0);
 288
 289         if (NULL == (m->meta.name = strdup(buf)))
 290                 return(mdoc_nerr(m, m->last, EMALLOC));
 291
 292         return(1);
 293 }
 294
 295
 296 static int
 297 post_lb(POST_ARGS)
 298 {
 299         const char      *p;
 300         char            *buf;
 301         size_t           sz;
 302
 303         assert(MDOC_TEXT == m->last->child->type);
 304         p = mdoc_a2lib(m->last->child->string);
 305         if (NULL == p) {
 306                 sz = strlen(m->last->child->string) +
 307                         2 + strlen("\\(lqlibrary\\(rq");
 308                 buf = malloc(sz);
 309                 if (NULL == buf)
 310                         return(mdoc_nerr(m, m->last, EMALLOC));
 311                 (void)snprintf(buf, sz, "library \\(lq%s\\(rq",
 312                                 m->last->child->string);
 313                 free(m->last->child->string);
 314                 m->last->child->string = buf;
 315                 return(1);
 316         }
 317
 318         free(m->last->child->string);
 319         m->last->child->string = strdup(p);
 320         if (NULL == m->last->child->string)
 321                 return(mdoc_nerr(m, m->last, EMALLOC));
 322         return(1);
 323 }
 324
 325
 326 static int
 327 post_st(POST_ARGS)
 328 {
 329         const char      *p;
 330
 331         assert(MDOC_TEXT == m->last->child->type);
 332         p = mdoc_a2st(m->last->child->string);
 333         assert(p);
 334         free(m->last->child->string);
 335         m->last->child->string = strdup(p);
 336         if (NULL == m->last->child->string)
 337                 return(mdoc_nerr(m, m->last, EMALLOC));
 338         return(1);
 339 }
 340
 341
 342 static int
 343 post_at(POST_ARGS)
 344 {
 345         struct mdoc_node *n;
 346         const char       *p;
 347
 348         if (m->last->child) {
 349                 assert(MDOC_TEXT == m->last->child->type);
 350                 p = mdoc_a2att(m->last->child->string);
 351                 assert(p);
 352                 free(m->last->child->string);
 353                 m->last->child->string = strdup(p);
 354                 if (NULL == m->last->child->string)
 355                         return(mdoc_nerr(m, m->last, EMALLOC));
 356                 return(1);
 357         }
 358
 359         n = m->last;
 360         m->next = MDOC_NEXT_CHILD;
 361
 362         if ( ! mdoc_word_alloc(m, n->line, n->pos, "AT&T UNIX"))
 363                 return(0);
 364
 365         m->last = n;
 366         m->next = MDOC_NEXT_SIBLING;
 367         return(1);
 368 }
 369
 370
 371 static int
 372 post_sh(POST_ARGS)
 373 {
 374         enum mdoc_sec    sec;
 375         char             buf[64];
 376
 377         /*
 378          * We keep track of the current section /and/ the "named"
 379          * section, which is one of the conventional ones, in order to
 380          * check ordering.
 381          */
 382
 383         if (MDOC_HEAD != m->last->type)
 384                 return(1);
 385
 386         buf[0] = 0;
 387         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 388                 return(0);
 389         if (SEC_CUSTOM != (sec = mdoc_atosec(buf)))
 390                 m->lastnamed = sec;
 391
 392         switch ((m->lastsec = sec)) {
 393         case (SEC_RETURN_VALUES):
 394                 /* FALLTHROUGH */
 395         case (SEC_ERRORS):
 396                 switch (m->meta.msec) {
 397                 case (2):
 398                         /* FALLTHROUGH */
 399                 case (3):
 400                         /* FALLTHROUGH */
 401                 case (9):
 402                         break;
 403                 default:
 404                         return(mdoc_nwarn(m, m->last, EBADSEC));
 405                 }
 406                 break;
 407         default:
 408                 break;
 409         }
 410         return(1);
 411 }
 412
 413
 414 static int
 415 post_dt(POST_ARGS)
 416 {
 417         struct mdoc_node *n;
 418         const char       *cp;
 419         char             *ep;
 420         long              lval;
 421
 422         if (m->meta.title)
 423                 free(m->meta.title);
 424         if (m->meta.vol)
 425                 free(m->meta.vol);
 426         if (m->meta.arch)
 427                 free(m->meta.arch);
 428
 429         m->meta.title = m->meta.vol = m->meta.arch = NULL;
 430         m->meta.msec = 0;
 431
 432         /* Handles: `.Dt'
 433          *   --> title = unknown, volume = local, msec = 0, arch = NULL
 434          */
 435
 436         if (NULL == (n = m->last->child)) {
 437                 if (NULL == (m->meta.title = strdup("unknown")))
 438                         return(mdoc_nerr(m, m->last, EMALLOC));
 439                 if (NULL == (m->meta.vol = strdup("local")))
 440                         return(mdoc_nerr(m, m->last, EMALLOC));
 441                 return(post_prol(m));
 442         }
 443
 444         /* Handles: `.Dt TITLE'
 445          *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 446          */
 447
 448         if (NULL == (m->meta.title = strdup(n->string)))
 449                 return(mdoc_nerr(m, m->last, EMALLOC));
 450
 451         if (NULL == (n = n->next)) {
 452                 if (NULL == (m->meta.vol = strdup("local")))
 453                         return(mdoc_nerr(m, m->last, EMALLOC));
 454                 return(post_prol(m));
 455         }
 456
 457         /* Handles: `.Dt TITLE SEC'
 458          *   --> title = TITLE, volume = SEC is msec ?
 459          *           format(msec) : SEC,
 460          *       msec = SEC is msec ? atoi(msec) : 0,
 461          *       arch = NULL
 462          */
 463
 464         cp = mdoc_a2msec(n->string);
 465         if (cp) {
 466                 if (NULL == (m->meta.vol = strdup(cp)))
 467                         return(mdoc_nerr(m, m->last, EMALLOC));
 468                 errno = 0;
 469                 lval = strtol(n->string, &ep, 10);
 470                 if (n->string[0] != '\0' && *ep == '\0')
 471                         m->meta.msec = (int)lval;
 472         } else if (NULL == (m->meta.vol = strdup(n->string)))
 473                 return(mdoc_nerr(m, m->last, EMALLOC));
 474
 475         if (NULL == (n = n->next))
 476                 return(post_prol(m));
 477
 478         /* Handles: `.Dt TITLE SEC VOL'
 479          *   --> title = TITLE, volume = VOL is vol ?
 480          *       format(VOL) :
 481          *           VOL is arch ? format(arch) :
 482          *               VOL
 483          */
 484
 485         cp = mdoc_a2vol(n->string);
 486         if (cp) {
 487                 free(m->meta.vol);
 488                 if (NULL == (m->meta.vol = strdup(cp)))
 489                         return(mdoc_nerr(m, m->last, EMALLOC));
 490         } else {
 491                 cp = mdoc_a2arch(n->string);
 492                 if (NULL == cp) {
 493                         free(m->meta.vol);
 494                         if (NULL == (m->meta.vol = strdup(n->string)))
 495                                 return(mdoc_nerr(m, m->last, EMALLOC));
 496                 } else if (NULL == (m->meta.arch = strdup(cp)))
 497                         return(mdoc_nerr(m, m->last, EMALLOC));
 498         }
 499
 500         /* Ignore any subsequent parameters... */
 501
 502         return(post_prol(m));
 503 }
 504
 505
 506 static int
 507 post_os(POST_ARGS)
 508 {
 509         char              buf[64];
 510         struct utsname    utsname;
 511
 512         if (m->meta.os)
 513                 free(m->meta.os);
 514
 515         buf[0] = 0;
 516         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 517                 return(0);
 518
 519         if (0 == buf[0]) {
 520                 if (-1 == uname(&utsname))
 521                         return(mdoc_nerr(m, m->last, EUTSNAME));
 522                 if (strlcat(buf, utsname.sysname, 64) >= 64)
 523                         return(mdoc_nerr(m, m->last, ETOOLONG));
 524                 if (strlcat(buf, " ", 64) >= 64)
 525                         return(mdoc_nerr(m, m->last, ETOOLONG));
 526                 if (strlcat(buf, utsname.release, 64) >= 64)
 527                         return(mdoc_nerr(m, m->last, ETOOLONG));
 528         }
 529
 530         if (NULL == (m->meta.os = strdup(buf)))
 531                 return(mdoc_nerr(m, m->last, EMALLOC));
 532
 533         return(post_prol(m));
 534 }
 535
 536
 537 /*
 538  * Calculate the -width for a `Bl -tag' list if it hasn't been provided.
 539  * Uses the first head macro.
 540  */
 541 static int
 542 post_bl_tagwidth(struct mdoc *m)
 543 {
 544         struct mdoc_node  *n;
 545         int                sz;
 546         char               buf[32];
 547
 548         /*
 549          * Use the text width, if a text node, or the default macro
 550          * width if a macro.
 551          */
 552
 553         n = m->last->body->child;
 554         if (n) {
 555                 assert(MDOC_BLOCK == n->type);
 556                 assert(MDOC_It == n->tok);
 557                 n = n->head->child;
 558         }
 559
 560         sz = 10; /* Default size. */
 561
 562         if (n) {
 563                 if (MDOC_TEXT != n->type) {
 564                         if (0 == (sz = (int)mdoc_macro2len(n->tok)))
 565                                 if ( ! mdoc_nwarn(m, m->last, ENOWIDTH))
 566                                         return(0);
 567                 } else
 568                         sz = (int)strlen(n->string) + 1;
 569         }
 570
 571         if (-1 == snprintf(buf, sizeof(buf), "%dn", sz))
 572                 return(mdoc_nerr(m, m->last, ENUMFMT));
 573
 574         /*
 575          * We have to dynamically add this to the macro's argument list.
 576          * We're guaranteed that a MDOC_Width doesn't already exist.
 577          */
 578
 579         n = m->last;
 580         assert(n->args);
 581         sz = (int)(n->args->argc)++;
 582
 583         n->args->argv = realloc(n->args->argv,
 584                         n->args->argc * sizeof(struct mdoc_argv));
 585
 586         if (NULL == n->args->argv)
 587                 return(mdoc_nerr(m, m->last, EMALLOC));
 588
 589         n->args->argv[sz].arg = MDOC_Width;
 590         n->args->argv[sz].line = m->last->line;
 591         n->args->argv[sz].pos = m->last->pos;
 592         n->args->argv[sz].sz = 1;
 593         n->args->argv[sz].value = calloc(1, sizeof(char *));
 594
 595         if (NULL == n->args->argv[sz].value)
 596                 return(mdoc_nerr(m, m->last, EMALLOC));
 597         if (NULL == (n->args->argv[sz].value[0] = strdup(buf)))
 598                 return(mdoc_nerr(m, m->last, EMALLOC));
 599
 600         return(1);
 601 }
 602
 603
 604 static int
 605 post_bl_width(struct mdoc *m)
 606 {
 607         size_t            width;
 608         int               i, tok;
 609         char              buf[32];
 610         char             *p;
 611
 612         if (NULL == m->last->args)
 613                 return(1);
 614
 615         for (i = 0; i < (int)m->last->args->argc; i++)
 616                 if (MDOC_Width == m->last->args->argv[i].arg)
 617                         break;
 618
 619         if (i == (int)m->last->args->argc)
 620                 return(1);
 621         p = m->last->args->argv[i].value[0];
 622
 623         /*
 624          * If the value to -width is a macro, then we re-write it to be
 625          * the macro's width as set in share/tmac/mdoc/doc-common.
 626          */
 627
 628         if (0 == strcmp(p, "Ds"))
 629                 width = 6;
 630         else if (MDOC_MAX == (tok = mdoc_hash_find(m->htab, p)))
 631                 return(1);
 632         else if (0 == (width = mdoc_macro2len(tok)))
 633                 return(mdoc_nwarn(m, m->last, ENOWIDTH));
 634
 635         /* The value already exists: free and reallocate it. */
 636
 637         if (-1 == snprintf(buf, sizeof(buf), "%zun", width))
 638                 return(mdoc_nerr(m, m->last, ENUMFMT));
 639
 640         free(m->last->args->argv[i].value[0]);
 641         m->last->args->argv[i].value[0] = strdup(buf);
 642         if (NULL == m->last->args->argv[i].value[0])
 643                 return(mdoc_nerr(m, m->last, EMALLOC));
 644
 645         return(1);
 646 }
 647
 648
 649 static int
 650 post_bl_head(POST_ARGS)
 651 {
 652         int                      i, c;
 653         struct mdoc_node        *n, *nn, *nnp;
 654
 655         if (NULL == m->last->child)
 656                 return(1);
 657
 658         n = m->last->parent;
 659         assert(n->args);
 660
 661         for (c = 0; c < (int)n->args->argc; c++)
 662                 if (MDOC_Column == n->args->argv[c].arg)
 663                         break;
 664
 665         /* Only process -column. */
 666
 667         if (c == (int)n->args->argc)
 668                 return(1);
 669
 670         assert(0 == n->args->argv[c].sz);
 671
 672         /*
 673          * Accomodate for new-style groff column syntax.  Shuffle the
 674          * child nodes, all of which must be TEXT, as arguments for the
 675          * column field.  Then, delete the head children.
 676          */
 677
 678         n->args->argv[c].sz = (size_t)m->last->nchild;
 679         n->args->argv[c].value = malloc
 680                 ((size_t)m->last->nchild * sizeof(char *));
 681
 682         for (i = 0, nn = m->last->child; nn; i++) {
 683                 n->args->argv[c].value[i] = nn->string;
 684                 nn->string = NULL;
 685                 nnp = nn;
 686                 nn = nn->next;
 687                 mdoc_node_free(nnp);
 688         }
 689
 690         m->last->nchild = 0;
 691         m->last->child = NULL;
 692
 693         return(1);
 694 }
 695
 696
 697 static int
 698 post_bl(POST_ARGS)
 699 {
 700         int               i, r, len;
 701
 702         if (MDOC_HEAD == m->last->type)
 703                 return(post_bl_head(m));
 704         if (MDOC_BLOCK != m->last->type)
 705                 return(1);
 706
 707         /*
 708          * These are fairly complicated, so we've broken them into two
 709          * functions.  post_bl_tagwidth() is called when a -tag is
 710          * specified, but no -width (it must be guessed).  The second
 711          * when a -width is specified (macro indicators must be
 712          * rewritten into real lengths).
 713          */
 714
 715         len = (int)(m->last->args ? m->last->args->argc : 0);
 716
 717         for (r = i = 0; i < len; i++) {
 718                 if (MDOC_Tag == m->last->args->argv[i].arg)
 719                         r |= 1 << 0;
 720                 if (MDOC_Width == m->last->args->argv[i].arg)
 721                         r |= 1 << 1;
 722         }
 723
 724         if (r & (1 << 0) && ! (r & (1 << 1))) {
 725                 if ( ! post_bl_tagwidth(m))
 726                         return(0);
 727         } else if (r & (1 << 1))
 728                 if ( ! post_bl_width(m))
 729                         return(0);
 730
 731         return(1);
 732 }
 733
 734
 735 static int
 736 post_tilde(POST_ARGS)
 737 {
 738         struct mdoc_node *n;
 739
 740         if (m->last->child)
 741                 return(1);
 742
 743         n = m->last;
 744         m->next = MDOC_NEXT_CHILD;
 745
 746         /* XXX: not documented for `Lk'. */
 747         if ( ! mdoc_word_alloc(m, m->last->line, m->last->pos, "~"))
 748                 return(0);
 749
 750         m->last = n;
 751         m->next = MDOC_NEXT_SIBLING;
 752         return(1);
 753 }
 754
 755
 756 static int
 757 post_ar(POST_ARGS)
 758 {
 759         struct mdoc_node *n;
 760
 761         if (m->last->child)
 762                 return(1);
 763
 764         n = m->last;
 765         m->next = MDOC_NEXT_CHILD;
 766         if ( ! mdoc_word_alloc(m, m->last->line, m->last->pos, "file"))
 767                 return(0);
 768         m->next = MDOC_NEXT_SIBLING;
 769         if ( ! mdoc_word_alloc(m, m->last->line, m->last->pos, "..."))
 770                 return(0);
 771
 772         m->last = n;
 773         m->next = MDOC_NEXT_SIBLING;
 774         return(1);
 775 }
 776
 777
 778 static int
 779 post_dd(POST_ARGS)
 780 {
 781         char              buf[64];
 782
 783         buf[0] = 0;
 784         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 785                 return(0);
 786
 787         if (0 == (m->meta.date = mdoc_atotime(buf))) {
 788                 if ( ! mdoc_nwarn(m, m->last, EBADDATE))
 789                         return(0);
 790                 m->meta.date = time(NULL);
 791         }
 792
 793         return(post_prol(m));
 794 }
 795
 796
 797 static int
 798 post_prol(POST_ARGS)
 799 {
 800         struct mdoc_node *n;
 801
 802         /*
 803          * The end document shouldn't have the prologue macros as part
 804          * of the syntax tree (they encompass only meta-data).
 805          */
 806
 807         if (m->last->parent->child == m->last)
 808                 m->last->parent->child = m->last->prev;
 809         if (m->last->prev)
 810                 m->last->prev->next = NULL;
 811
 812         n = m->last;
 813         assert(NULL == m->last->next);
 814
 815         if (m->last->prev) {
 816                 m->last = m->last->prev;
 817                 m->next = MDOC_NEXT_SIBLING;
 818         } else {
 819                 m->last = m->last->parent;
 820                 m->next = MDOC_NEXT_CHILD;
 821         }
 822
 823         mdoc_node_freelist(n);
 824
 825         if (m->meta.title && m->meta.date && m->meta.os)
 826                 m->flags |= MDOC_PBODY;
 827         return(1);
 828 }
 829
 830
 831 static int
 832 pre_dl(PRE_ARGS)
 833 {
 834
 835         if (MDOC_BODY == n->type)
 836                 m->flags |= MDOC_LITERAL;
 837
 838         return(1);
 839 }
 840
 841
 842 static int
 843 pre_bd(PRE_ARGS)
 844 {
 845         int              i;
 846
 847         if (MDOC_BODY != n->type)
 848                 return(1);
 849
 850         /* Enter literal context if `Bd -literal' or `-unfilled'. */
 851
 852         /*
 853          * TODO: `-offset' without an argument should be the width of
 854          * the literal "<string>".
 855          */
 856
 857         for (n = n->parent, i = 0; i < (int)n->args->argc; i++)
 858                 if (MDOC_Literal == n->args->argv[i].arg)
 859                         break;
 860                 else if (MDOC_Unfilled == n->args->argv[i].arg)
 861                         break;
 862
 863         if (i < (int)n->args->argc)
 864                 m->flags |= MDOC_LITERAL;
 865
 866         return(1);
 867 }
 868
 869
 870 static int
 871 post_display(POST_ARGS)
 872 {
 873
 874         if (MDOC_BODY == m->last->type)
 875                 m->flags &= ~MDOC_LITERAL;
 876         return(1);
 877 }
 878
 879