mdoc_action.c

   1 /*      $Id: mdoc_action.c,v 1.10 2009/06/12 09:18:00 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 enum    mwarn {
  28         WBADSEC,
  29         WNOWIDTH,
  30         WBADDATE
  31 };
  32
  33 enum    merr {
  34         ETOOLONG,
  35         EMALLOC,
  36         ENUMFMT
  37 };
  38
  39 #define PRE_ARGS  struct mdoc *m, const struct mdoc_node *n
  40 #define POST_ARGS struct mdoc *m
  41
  42 struct  actions {
  43         int     (*pre)(PRE_ARGS);
  44         int     (*post)(POST_ARGS);
  45 };
  46
  47 static  int       pwarn(struct mdoc *, int, int, enum mwarn);
  48 static  int       perr(struct mdoc *, int, int, enum merr);
  49 static  int       concat(struct mdoc *, const struct mdoc_node *,
  50                         char *, size_t);
  51
  52 static  int       post_ar(POST_ARGS);
  53 static  int       post_bl(POST_ARGS);
  54 static  int       post_bl_width(POST_ARGS);
  55 static  int       post_bl_tagwidth(POST_ARGS);
  56 static  int       post_dd(POST_ARGS);
  57 static  int       post_display(POST_ARGS);
  58 static  int       post_dt(POST_ARGS);
  59 static  int       post_lk(POST_ARGS);
  60 static  int       post_nm(POST_ARGS);
  61 static  int       post_os(POST_ARGS);
  62 static  int       post_prol(POST_ARGS);
  63 static  int       post_sh(POST_ARGS);
  64 static  int       post_std(POST_ARGS);
  65
  66 static  int       pre_bd(PRE_ARGS);
  67 static  int       pre_dl(PRE_ARGS);
  68
  69 #define vwarn(m, t) pwarn((m), (m)->last->line, (m)->last->pos, (t))
  70 #define verr(m, t) perr((m), (m)->last->line, (m)->last->pos, (t))
  71 #define nerr(m, n, t) perr((m), (n)->line, (n)->pos, (t))
  72
  73 const   struct actions mdoc_actions[MDOC_MAX] = {
  74         { NULL, NULL }, /* \" */
  75         { NULL, post_dd }, /* Dd */
  76         { NULL, post_dt }, /* Dt */
  77         { NULL, post_os }, /* Os */
  78         { NULL, post_sh }, /* 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, post_ar }, /* 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, NULL }, /* Pa */
 110         { NULL, post_std }, /* Rv */
 111         { NULL, NULL }, /* 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, NULL }, /* 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, NULL }, /* Lb */
 181         { NULL, NULL }, /* Ap */
 182         { NULL, NULL }, /* Lp */
 183         { NULL, post_lk }, /* Lk */
 184         { NULL, NULL }, /* Mt */
 185         { NULL, NULL }, /* Brq */
 186         { NULL, NULL }, /* Bro */
 187         { NULL, NULL }, /* Brc */
 188         { NULL, NULL }, /* %C */
 189         { NULL, NULL }, /* Es */
 190         { NULL, NULL }, /* En */
 191         { NULL, NULL }, /* Dx */
 192         { NULL, NULL }, /* %Q */
 193 };
 194
 195
 196 #ifdef __linux__
 197 extern  size_t  strlcat(char *, const char *, size_t);
 198 #endif
 199
 200
 201 int
 202 mdoc_action_pre(struct mdoc *m, const struct mdoc_node *n)
 203 {
 204
 205         switch (n->type) {
 206         case (MDOC_ROOT):
 207                 /* FALLTHROUGH */
 208         case (MDOC_TEXT):
 209                 return(1);
 210         default:
 211                 break;
 212         }
 213
 214         if (NULL == mdoc_actions[n->tok].pre)
 215                 return(1);
 216         return((*mdoc_actions[n->tok].pre)(m, n));
 217 }
 218
 219
 220 int
 221 mdoc_action_post(struct mdoc *m)
 222 {
 223
 224         if (MDOC_ACTED & m->last->flags)
 225                 return(1);
 226         m->last->flags |= MDOC_ACTED;
 227
 228         switch (m->last->type) {
 229         case (MDOC_TEXT):
 230                 /* FALLTHROUGH */
 231         case (MDOC_ROOT):
 232                 return(1);
 233         default:
 234                 break;
 235         }
 236
 237         if (NULL == mdoc_actions[m->last->tok].post)
 238                 return(1);
 239         return((*mdoc_actions[m->last->tok].post)(m));
 240 }
 241
 242
 243 static int
 244 concat(struct mdoc *m, const struct mdoc_node *n,
 245                 char *buf, size_t sz)
 246 {
 247
 248         for ( ; n; n = n->next) {
 249                 assert(MDOC_TEXT == n->type);
 250                 if (strlcat(buf, n->string, sz) >= sz)
 251                         return(nerr(m, n, ETOOLONG));
 252                 if (NULL == n->next)
 253                         continue;
 254                 if (strlcat(buf, " ", sz) >= sz)
 255                         return(nerr(m, n, ETOOLONG));
 256         }
 257
 258         return(1);
 259 }
 260
 261
 262 static int
 263 perr(struct mdoc *m, int line, int pos, enum merr type)
 264 {
 265         char            *p;
 266
 267         p = NULL;
 268         switch (type) {
 269         case (ENUMFMT):
 270                 p = "bad number format";
 271                 break;
 272         case (ETOOLONG):
 273                 p = "argument text too long";
 274                 break;
 275         case (EMALLOC):
 276                 p = "memory exhausted";
 277                 break;
 278         }
 279         assert(p);
 280         return(mdoc_perr(m, line, pos, p));
 281 }
 282
 283
 284 static int
 285 pwarn(struct mdoc *m, int line, int pos, enum mwarn type)
 286 {
 287         char            *p;
 288         int              c;
 289
 290         p = NULL;
 291         c = WARN_SYNTAX;
 292         switch (type) {
 293         case (WBADSEC):
 294                 p = "inappropriate document section in manual section";
 295                 c = WARN_COMPAT;
 296                 break;
 297         case (WNOWIDTH):
 298                 p = "cannot determine default width";
 299                 break;
 300         case (WBADDATE):
 301                 p = "malformed date syntax";
 302                 break;
 303         }
 304         assert(p);
 305         return(mdoc_pwarn(m, line, pos, c, p));
 306 }
 307
 308
 309 static int
 310 post_std(POST_ARGS)
 311 {
 312
 313         /*
 314          * If '-std' is invoked without an argument, fill it in with our
 315          * name (if it's been set).
 316          */
 317
 318         if (NULL == m->last->args)
 319                 return(1);
 320         if (m->last->args->argv[0].sz)
 321                 return(1);
 322
 323         assert(m->meta.name);
 324
 325         m->last->args->argv[0].value = calloc(1, sizeof(char *));
 326         if (NULL == m->last->args->argv[0].value)
 327                 return(verr(m, EMALLOC));
 328
 329         m->last->args->argv[0].sz = 1;
 330         m->last->args->argv[0].value[0] = strdup(m->meta.name);
 331         if (NULL == m->last->args->argv[0].value[0])
 332                 return(verr(m, EMALLOC));
 333
 334         return(1);
 335 }
 336
 337
 338 static int
 339 post_nm(POST_ARGS)
 340 {
 341         char             buf[64];
 342
 343         if (m->meta.name)
 344                 return(1);
 345
 346         buf[0] = 0;
 347         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 348                 return(0);
 349
 350         if (NULL == (m->meta.name = strdup(buf)))
 351                 return(verr(m, EMALLOC));
 352
 353         return(1);
 354 }
 355
 356
 357 static int
 358 post_sh(POST_ARGS)
 359 {
 360         enum mdoc_sec    sec;
 361         char             buf[64];
 362
 363         /*
 364          * We keep track of the current section /and/ the "named"
 365          * section, which is one of the conventional ones, in order to
 366          * check ordering.
 367          */
 368
 369         if (MDOC_HEAD != m->last->type)
 370                 return(1);
 371
 372         buf[0] = 0;
 373         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 374                 return(0);
 375         if (SEC_CUSTOM != (sec = mdoc_atosec(buf)))
 376                 m->lastnamed = sec;
 377
 378         switch ((m->lastsec = sec)) {
 379         case (SEC_RETURN_VALUES):
 380                 /* FALLTHROUGH */
 381         case (SEC_ERRORS):
 382                 switch (m->meta.msec) {
 383                 case (2):
 384                         /* FALLTHROUGH */
 385                 case (3):
 386                         /* FALLTHROUGH */
 387                 case (9):
 388                         break;
 389                 default:
 390                         return(vwarn(m, WBADSEC));
 391                 }
 392                 break;
 393         default:
 394                 break;
 395         }
 396         return(1);
 397 }
 398
 399
 400 static int
 401 post_dt(POST_ARGS)
 402 {
 403         struct mdoc_node *n;
 404         const char       *cp;
 405         char             *ep;
 406         long              lval;
 407
 408         if (m->meta.title)
 409                 free(m->meta.title);
 410         if (m->meta.vol)
 411                 free(m->meta.vol);
 412         if (m->meta.arch)
 413                 free(m->meta.arch);
 414
 415         m->meta.title = m->meta.vol = m->meta.arch = NULL;
 416         m->meta.msec = 0;
 417
 418         /* Handles: `.Dt'
 419          *   --> title = unknown, volume = local, msec = 0, arch = NULL
 420          */
 421
 422         if (NULL == (n = m->last->child)) {
 423                 if (NULL == (m->meta.title = strdup("unknown")))
 424                         return(verr(m, EMALLOC));
 425                 if (NULL == (m->meta.vol = strdup("local")))
 426                         return(verr(m, EMALLOC));
 427                 return(post_prol(m));
 428         }
 429
 430         /* Handles: `.Dt TITLE'
 431          *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 432          */
 433
 434         if (NULL == (m->meta.title = strdup(n->string)))
 435                 return(verr(m, EMALLOC));
 436
 437         if (NULL == (n = n->next)) {
 438                 if (NULL == (m->meta.vol = strdup("local")))
 439                         return(verr(m, EMALLOC));
 440                 return(post_prol(m));
 441         }
 442
 443         /* Handles: `.Dt TITLE SEC'
 444          *   --> title = TITLE, volume = SEC is msec ?
 445          *           format(msec) : SEC,
 446          *       msec = SEC is msec ? atoi(msec) : 0,
 447          *       arch = NULL
 448          */
 449
 450         cp = mdoc_a2msec(n->string);
 451         if (cp) {
 452                 if (NULL == (m->meta.vol = strdup(cp)))
 453                         return(verr(m, EMALLOC));
 454                 errno = 0;
 455                 lval = strtol(n->string, &ep, 10);
 456                 if (n->string[0] != '\0' && *ep == '\0')
 457                         m->meta.msec = (int)lval;
 458         } else if (NULL == (m->meta.vol = strdup(n->string)))
 459                 return(verr(m, EMALLOC));
 460
 461         if (NULL == (n = n->next))
 462                 return(post_prol(m));
 463
 464         /* Handles: `.Dt TITLE SEC VOL'
 465          *   --> title = TITLE, volume = VOL is vol ?
 466          *       format(VOL) :
 467          *           VOL is arch ? format(arch) :
 468          *               VOL
 469          */
 470
 471         cp = mdoc_a2vol(n->string);
 472         if (cp) {
 473                 free(m->meta.vol);
 474                 if (NULL == (m->meta.vol = strdup(cp)))
 475                         return(verr(m, EMALLOC));
 476                 n = n->next;
 477         } else {
 478                 cp = mdoc_a2arch(n->string);
 479                 if (NULL == cp) {
 480                         free(m->meta.vol);
 481                         if (NULL == (m->meta.vol = strdup(n->string)))
 482                                 return(verr(m, EMALLOC));
 483                 } else if (NULL == (m->meta.arch = strdup(cp)))
 484                         return(verr(m, EMALLOC));
 485         }
 486
 487         /* Ignore any subsequent parameters... */
 488
 489         return(post_prol(m));
 490 }
 491
 492
 493 static int
 494 post_os(POST_ARGS)
 495 {
 496         char              buf[64];
 497         struct utsname    utsname;
 498
 499         if (m->meta.os)
 500                 free(m->meta.os);
 501
 502         buf[0] = 0;
 503         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 504                 return(0);
 505
 506         if (0 == buf[0]) {
 507                 if (-1 == uname(&utsname))
 508                         return(mdoc_err(m, "utsname"));
 509                 if (strlcat(buf, utsname.sysname, 64) >= 64)
 510                         return(verr(m, ETOOLONG));
 511                 if (strlcat(buf, " ", 64) >= 64)
 512                         return(verr(m, ETOOLONG));
 513                 if (strlcat(buf, utsname.release, 64) >= 64)
 514                         return(verr(m, ETOOLONG));
 515         }
 516
 517         if (NULL == (m->meta.os = strdup(buf)))
 518                 return(verr(m, EMALLOC));
 519         m->lastnamed = m->lastsec = SEC_BODY;
 520
 521         return(post_prol(m));
 522 }
 523
 524
 525 /*
 526  * Calculate the -width for a `Bl -tag' list if it hasn't been provided.
 527  * Uses the first head macro.
 528  */
 529 static int
 530 post_bl_tagwidth(struct mdoc *m)
 531 {
 532         struct mdoc_node  *n;
 533         int                sz;
 534         char               buf[32];
 535
 536         /*
 537          * Use the text width, if a text node, or the default macro
 538          * width if a macro.
 539          */
 540
 541         if ((n = m->last->body->child)) {
 542                 assert(MDOC_BLOCK == n->type);
 543                 assert(MDOC_It == n->tok);
 544                 n = n->head->child;
 545         }
 546
 547         sz = 10; /* Default size. */
 548
 549         if (n) {
 550                 if (MDOC_TEXT != n->type) {
 551                         if (0 == (sz = (int)mdoc_macro2len(n->tok)))
 552                                 if ( ! vwarn(m, WNOWIDTH))
 553                                         return(0);
 554                 } else
 555                         sz = (int)strlen(n->string) + 1;
 556         }
 557
 558         if (-1 == snprintf(buf, sizeof(buf), "%dn", sz))
 559                 return(verr(m, ENUMFMT));
 560
 561         /*
 562          * We have to dynamically add this to the macro's argument list.
 563          * We're guaranteed that a MDOC_Width doesn't already exist.
 564          */
 565
 566         n = m->last;
 567         assert(n->args);
 568         sz = (int)(n->args->argc)++;
 569
 570         n->args->argv = realloc(n->args->argv,
 571                         n->args->argc * sizeof(struct mdoc_argv));
 572
 573         if (NULL == n->args->argv)
 574                 return(verr(m, EMALLOC));
 575
 576         n->args->argv[sz].arg = MDOC_Width;
 577         n->args->argv[sz].line = m->last->line;
 578         n->args->argv[sz].pos = m->last->pos;
 579         n->args->argv[sz].sz = 1;
 580         n->args->argv[sz].value = calloc(1, sizeof(char *));
 581
 582         if (NULL == n->args->argv[sz].value)
 583                 return(verr(m, EMALLOC));
 584         if (NULL == (n->args->argv[sz].value[0] = strdup(buf)))
 585                 return(verr(m, EMALLOC));
 586
 587         return(1);
 588 }
 589
 590
 591 static int
 592 post_bl_width(struct mdoc *m)
 593 {
 594         size_t            width;
 595         int               i, tok;
 596         char              buf[32];
 597         char             *p;
 598
 599         if (NULL == m->last->args)
 600                 return(1);
 601
 602         for (i = 0; i < (int)m->last->args->argc; i++)
 603                 if (MDOC_Width == m->last->args->argv[i].arg)
 604                         break;
 605
 606         if (i == (int)m->last->args->argc)
 607                 return(1);
 608         p = m->last->args->argv[i].value[0];
 609
 610         /*
 611          * If the value to -width is a macro, then we re-write it to be
 612          * the macro's width as set in share/tmac/mdoc/doc-common.
 613          */
 614
 615         if (0 == strcmp(p, "Ds"))
 616                 width = 8;
 617         else if (MDOC_MAX == (tok = mdoc_hash_find(m->htab, p)))
 618                 return(1);
 619         else if (0 == (width = mdoc_macro2len(tok)))
 620                 return(vwarn(m, WNOWIDTH));
 621
 622         /* The value already exists: free and reallocate it. */
 623
 624         if (-1 == snprintf(buf, sizeof(buf), "%zun", width))
 625                 return(verr(m, ENUMFMT));
 626
 627         free(m->last->args->argv[i].value[0]);
 628         m->last->args->argv[i].value[0] = strdup(buf);
 629         if (NULL == m->last->args->argv[i].value[0])
 630                 return(verr(m, EMALLOC));
 631
 632         return(1);
 633 }
 634
 635
 636 static int
 637 post_bl(POST_ARGS)
 638 {
 639         int               i, r, len;
 640
 641         if (MDOC_BLOCK != m->last->type)
 642                 return(1);
 643
 644         /*
 645          * These are fairly complicated, so we've broken them into two
 646          * functions.  post_bl_tagwidth() is called when a -tag is
 647          * specified, but no -width (it must be guessed).  The second
 648          * when a -width is specified (macro indicators must be
 649          * rewritten into real lengths).
 650          */
 651
 652         len = (int)(m->last->args ? m->last->args->argc : 0);
 653
 654         for (r = i = 0; i < len; i++) {
 655                 if (MDOC_Tag == m->last->args->argv[i].arg)
 656                         r |= 1 << 0;
 657                 if (MDOC_Width == m->last->args->argv[i].arg)
 658                         r |= 1 << 1;
 659         }
 660
 661         if (r & (1 << 0) && ! (r & (1 << 1))) {
 662                 if ( ! post_bl_tagwidth(m))
 663                         return(0);
 664         } else if (r & (1 << 1))
 665                 if ( ! post_bl_width(m))
 666                         return(0);
 667
 668         return(1);
 669 }
 670
 671
 672 static int
 673 post_lk(POST_ARGS)
 674 {
 675         struct mdoc_node *n;
 676
 677         if (m->last->child)
 678                 return(1);
 679
 680         n = m->last;
 681         m->next = MDOC_NEXT_CHILD;
 682         /* FIXME: this isn't documented anywhere! */
 683         if ( ! mdoc_word_alloc(m, m->last->line,
 684                                 m->last->pos, "~"))
 685                 return(0);
 686
 687         m->last = n;
 688         m->next = MDOC_NEXT_SIBLING;
 689         return(1);
 690 }
 691
 692
 693 static int
 694 post_ar(POST_ARGS)
 695 {
 696         struct mdoc_node *n;
 697
 698         if (m->last->child)
 699                 return(1);
 700
 701         n = m->last;
 702         m->next = MDOC_NEXT_CHILD;
 703         if ( ! mdoc_word_alloc(m, m->last->line,
 704                                 m->last->pos, "file"))
 705                 return(0);
 706         m->next = MDOC_NEXT_SIBLING;
 707         if ( ! mdoc_word_alloc(m, m->last->line,
 708                                 m->last->pos, "..."))
 709                 return(0);
 710
 711         m->last = n;
 712         m->next = MDOC_NEXT_SIBLING;
 713         return(1);
 714 }
 715
 716
 717 static int
 718 post_dd(POST_ARGS)
 719 {
 720         char              buf[64];
 721
 722         buf[0] = 0;
 723         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 724                 return(0);
 725
 726         if (0 == (m->meta.date = mdoc_atotime(buf))) {
 727                 if ( ! vwarn(m, WBADDATE))
 728                         return(0);
 729                 m->meta.date = time(NULL);
 730         }
 731
 732         return(post_prol(m));
 733 }
 734
 735
 736 static int
 737 post_prol(POST_ARGS)
 738 {
 739         struct mdoc_node *n;
 740
 741         /*
 742          * The end document shouldn't have the prologue macros as part
 743          * of the syntax tree (they encompass only meta-data).
 744          */
 745
 746         if (m->last->parent->child == m->last)
 747                 m->last->parent->child = m->last->prev;
 748         if (m->last->prev)
 749                 m->last->prev->next = NULL;
 750
 751         n = m->last;
 752         assert(NULL == m->last->next);
 753
 754         if (m->last->prev) {
 755                 m->last = m->last->prev;
 756                 m->next = MDOC_NEXT_SIBLING;
 757         } else {
 758                 m->last = m->last->parent;
 759                 m->next = MDOC_NEXT_CHILD;
 760         }
 761
 762         mdoc_node_freelist(n);
 763         return(1);
 764 }
 765
 766
 767 static int
 768 pre_dl(PRE_ARGS)
 769 {
 770
 771         if (MDOC_BODY != n->type)
 772                 return(1);
 773         m->flags |= MDOC_LITERAL;
 774         return(1);
 775 }
 776
 777
 778 static int
 779 pre_bd(PRE_ARGS)
 780 {
 781         int              i;
 782
 783         if (MDOC_BODY != n->type)
 784                 return(1);
 785
 786         /* Enter literal context if `Bd -literal' or * -unfilled'. */
 787
 788         for (n = n->parent, i = 0; i < (int)n->args->argc; i++)
 789                 if (MDOC_Literal == n->args->argv[i].arg)
 790                         break;
 791                 else if (MDOC_Unfilled == n->args->argv[i].arg)
 792                         break;
 793
 794         if (i < (int)n->args->argc)
 795                 m->flags |= MDOC_LITERAL;
 796
 797         return(1);
 798 }
 799
 800
 801 static int
 802 post_display(POST_ARGS)
 803 {
 804
 805         if (MDOC_BODY == m->last->type)
 806                 m->flags &= ~MDOC_LITERAL;
 807         return(1);
 808 }
 809
 810