mdoc_action.c

   1 /* $Id: mdoc_action.c,v 1.5 2009/04/03 11:08:39 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
   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
   7  * above copyright notice and this permission notice appear in all
   8  * copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include <sys/utsname.h>
  20
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "libmdoc.h"
  28
  29 enum    mwarn {
  30         WBADSEC,
  31         WNOWIDTH,
  32         WBADDATE
  33 };
  34
  35 enum    merr {
  36         ETOOLONG,
  37         EMALLOC,
  38         ENUMFMT
  39 };
  40
  41 #define PRE_ARGS  struct mdoc *m, const struct mdoc_node *n
  42 #define POST_ARGS struct mdoc *m
  43
  44 struct  actions {
  45         int     (*pre)(PRE_ARGS);
  46         int     (*post)(POST_ARGS);
  47 };
  48
  49 static  int       pwarn(struct mdoc *, int, int, enum mwarn);
  50 static  int       perr(struct mdoc *, int, int, enum merr);
  51 static  int       concat(struct mdoc *, const struct mdoc_node *,
  52                         char *, size_t);
  53
  54 static  int       post_ar(POST_ARGS);
  55 static  int       post_bl(POST_ARGS);
  56 static  int       post_bl_width(POST_ARGS);
  57 static  int       post_bl_tagwidth(POST_ARGS);
  58 static  int       post_dd(POST_ARGS);
  59 static  int       post_display(POST_ARGS);
  60 static  int       post_dt(POST_ARGS);
  61 static  int       post_nm(POST_ARGS);
  62 static  int       post_os(POST_ARGS);
  63 static  int       post_prol(POST_ARGS);
  64 static  int       post_sh(POST_ARGS);
  65 static  int       post_std(POST_ARGS);
  66
  67 static  int       pre_bd(PRE_ARGS);
  68 static  int       pre_dl(PRE_ARGS);
  69
  70 #define vwarn(m, t) pwarn((m), (m)->last->line, (m)->last->pos, (t))
  71 #define verr(m, t) perr((m), (m)->last->line, (m)->last->pos, (t))
  72 #define nerr(m, n, t) perr((m), (n)->line, (n)->pos, (t))
  73
  74 const   struct actions mdoc_actions[MDOC_MAX] = {
  75         { NULL, NULL }, /* \" */
  76         { NULL, post_dd }, /* Dd */
  77         { NULL, post_dt }, /* Dt */
  78         { NULL, post_os }, /* Os */
  79         { NULL, post_sh }, /* Sh */
  80         { NULL, NULL }, /* Ss */
  81         { NULL, NULL }, /* Pp */
  82         { NULL, NULL }, /* D1 */
  83         { pre_dl, post_display }, /* Dl */
  84         { pre_bd, post_display }, /* Bd */
  85         { NULL, NULL }, /* Ed */
  86         { NULL, post_bl }, /* Bl */
  87         { NULL, NULL }, /* El */
  88         { NULL, NULL }, /* It */
  89         { NULL, NULL }, /* Ad */
  90         { NULL, NULL }, /* An */
  91         { NULL, post_ar }, /* Ar */
  92         { NULL, NULL }, /* Cd */
  93         { NULL, NULL }, /* Cm */
  94         { NULL, NULL }, /* Dv */
  95         { NULL, NULL }, /* Er */
  96         { NULL, NULL }, /* Ev */
  97         { NULL, post_std }, /* Ex */
  98         { NULL, NULL }, /* Fa */
  99         { NULL, NULL }, /* Fd */
 100         { NULL, NULL }, /* Fl */
 101         { NULL, NULL }, /* Fn */
 102         { NULL, NULL }, /* Ft */
 103         { NULL, NULL }, /* Ic */
 104         { NULL, NULL }, /* In */
 105         { NULL, NULL }, /* Li */
 106         { NULL, NULL }, /* Nd */
 107         { NULL, post_nm }, /* Nm */
 108         { NULL, NULL }, /* Op */
 109         { NULL, NULL }, /* Ot */
 110         { NULL, NULL }, /* Pa */
 111         { NULL, post_std }, /* Rv */
 112         { NULL, NULL }, /* St */
 113         { NULL, NULL }, /* Va */
 114         { NULL, NULL }, /* Vt */
 115         { NULL, NULL }, /* Xr */
 116         { NULL, NULL }, /* %A */
 117         { NULL, NULL }, /* %B */
 118         { NULL, NULL }, /* %D */
 119         { NULL, NULL }, /* %I */
 120         { NULL, NULL }, /* %J */
 121         { NULL, NULL }, /* %N */
 122         { NULL, NULL }, /* %O */
 123         { NULL, NULL }, /* %P */
 124         { NULL, NULL }, /* %R */
 125         { NULL, NULL }, /* %T */
 126         { NULL, NULL }, /* %V */
 127         { NULL, NULL }, /* Ac */
 128         { NULL, NULL }, /* Ao */
 129         { NULL, NULL }, /* Aq */
 130         { NULL, NULL }, /* At */
 131         { NULL, NULL }, /* Bc */
 132         { NULL, NULL }, /* Bf */
 133         { NULL, NULL }, /* Bo */
 134         { NULL, NULL }, /* Bq */
 135         { NULL, NULL }, /* Bsx */
 136         { NULL, NULL }, /* Bx */
 137         { NULL, NULL }, /* Db */
 138         { NULL, NULL }, /* Dc */
 139         { NULL, NULL }, /* Do */
 140         { NULL, NULL }, /* Dq */
 141         { NULL, NULL }, /* Ec */
 142         { NULL, NULL }, /* Ef */
 143         { NULL, NULL }, /* Em */
 144         { NULL, NULL }, /* Eo */
 145         { NULL, NULL }, /* Fx */
 146         { NULL, NULL }, /* Ms */
 147         { NULL, NULL }, /* No */
 148         { NULL, NULL }, /* Ns */
 149         { NULL, NULL }, /* Nx */
 150         { NULL, NULL }, /* Ox */
 151         { NULL, NULL }, /* Pc */
 152         { NULL, NULL }, /* Pf */
 153         { NULL, NULL }, /* Po */
 154         { NULL, NULL }, /* Pq */
 155         { NULL, NULL }, /* Qc */
 156         { NULL, NULL }, /* Ql */
 157         { NULL, NULL }, /* Qo */
 158         { NULL, NULL }, /* Qq */
 159         { NULL, NULL }, /* Re */
 160         { NULL, NULL }, /* Rs */
 161         { NULL, NULL }, /* Sc */
 162         { NULL, NULL }, /* So */
 163         { NULL, NULL }, /* Sq */
 164         { NULL, NULL }, /* Sm */
 165         { NULL, NULL }, /* Sx */
 166         { NULL, NULL }, /* Sy */
 167         { NULL, NULL }, /* Tn */
 168         { NULL, NULL }, /* Ux */
 169         { NULL, NULL }, /* Xc */
 170         { NULL, NULL }, /* Xo */
 171         { NULL, NULL }, /* Fo */
 172         { NULL, NULL }, /* Fc */
 173         { NULL, NULL }, /* Oo */
 174         { NULL, NULL }, /* Oc */
 175         { NULL, NULL }, /* Bk */
 176         { NULL, NULL }, /* Ek */
 177         { NULL, NULL }, /* Bt */
 178         { NULL, NULL }, /* Hf */
 179         { NULL, NULL }, /* Fr */
 180         { NULL, NULL }, /* Ud */
 181         { NULL, NULL }, /* Lb */
 182         { NULL, NULL }, /* Ap */
 183         { NULL, NULL }, /* Lp */
 184         { NULL, NULL }, /* Lk */
 185         { NULL, NULL }, /* Mt */
 186         { NULL, NULL }, /* Brq */
 187         { NULL, NULL }, /* Bro */
 188         { NULL, NULL }, /* Brc */
 189         { NULL, NULL }, /* %C */
 190         { NULL, NULL }, /* Es */
 191         { NULL, NULL }, /* En */
 192         { NULL, NULL }, /* Dx */
 193         { NULL, NULL }, /* %Q */
 194 };
 195
 196
 197 #ifdef __linux__
 198 extern  size_t  strlcat(char *, const char *, size_t);
 199 #endif
 200
 201
 202 int
 203 mdoc_action_pre(struct mdoc *m, const struct mdoc_node *n)
 204 {
 205
 206         switch (n->type) {
 207         case (MDOC_ROOT):
 208                 /* FALLTHROUGH */
 209         case (MDOC_TEXT):
 210                 return(1);
 211         default:
 212                 break;
 213         }
 214
 215         if (NULL == mdoc_actions[m->last->tok].pre)
 216                 return(1);
 217         return((*mdoc_actions[m->last->tok].pre)(m, n));
 218 }
 219
 220
 221 int
 222 mdoc_action_post(struct mdoc *m)
 223 {
 224
 225         if (MDOC_ACTED & m->last->flags)
 226                 return(1);
 227         m->last->flags |= MDOC_ACTED;
 228
 229         switch (m->last->type) {
 230         case (MDOC_TEXT):
 231                 /* FALLTHROUGH */
 232         case (MDOC_ROOT):
 233                 return(1);
 234         default:
 235                 break;
 236         }
 237
 238         if (NULL == mdoc_actions[m->last->tok].post)
 239                 return(1);
 240         return((*mdoc_actions[m->last->tok].post)(m));
 241 }
 242
 243
 244 static int
 245 concat(struct mdoc *m, const struct mdoc_node *n,
 246                 char *buf, size_t sz)
 247 {
 248
 249         for ( ; n; n = n->next) {
 250                 assert(MDOC_TEXT == n->type);
 251                 if (strlcat(buf, n->string, sz) >= sz)
 252                         return(nerr(m, n, ETOOLONG));
 253                 if (NULL == n->next)
 254                         continue;
 255                 if (strlcat(buf, " ", sz) >= sz)
 256                         return(nerr(m, n, ETOOLONG));
 257         }
 258
 259         return(1);
 260 }
 261
 262
 263 static int
 264 perr(struct mdoc *m, int line, int pos, enum merr type)
 265 {
 266         char            *p;
 267
 268         p = NULL;
 269         switch (type) {
 270         case (ENUMFMT):
 271                 p = "bad number format";
 272                 break;
 273         case (ETOOLONG):
 274                 p = "argument text too long";
 275                 break;
 276         case (EMALLOC):
 277                 p = "memory exhausted";
 278                 break;
 279         }
 280         assert(p);
 281         return(mdoc_perr(m, line, pos, p));
 282 }
 283
 284
 285 static int
 286 pwarn(struct mdoc *m, int line, int pos, enum mwarn type)
 287 {
 288         char            *p;
 289         int              c;
 290
 291         p = NULL;
 292         c = WARN_SYNTAX;
 293         switch (type) {
 294         case (WBADSEC):
 295                 p = "inappropriate document section in manual section";
 296                 c = WARN_COMPAT;
 297                 break;
 298         case (WNOWIDTH):
 299                 p = "cannot determine default width";
 300                 break;
 301         case (WBADDATE):
 302                 p = "malformed date syntax";
 303                 break;
 304         }
 305         assert(p);
 306         return(mdoc_pwarn(m, line, pos, c, p));
 307 }
 308
 309
 310 static int
 311 post_std(POST_ARGS)
 312 {
 313
 314         /*
 315          * If '-std' is invoked without an argument, fill it in with our
 316          * name (if it's been set).
 317          */
 318
 319         if (NULL == m->last->args)
 320                 return(1);
 321         if (m->last->args->argv[0].sz)
 322                 return(1);
 323
 324         assert(m->meta.name);
 325
 326         m->last->args->argv[0].value = calloc(1, sizeof(char *));
 327         if (NULL == m->last->args->argv[0].value)
 328                 return(verr(m, EMALLOC));
 329
 330         m->last->args->argv[0].sz = 1;
 331         m->last->args->argv[0].value[0] = strdup(m->meta.name);
 332         if (NULL == m->last->args->argv[0].value[0])
 333                 return(verr(m, EMALLOC));
 334
 335         return(1);
 336 }
 337
 338
 339 static int
 340 post_nm(POST_ARGS)
 341 {
 342         char             buf[64];
 343
 344         if (m->meta.name)
 345                 return(1);
 346
 347         buf[0] = 0;
 348         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 349                 return(0);
 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_ar(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         if ( ! mdoc_word_alloc(m, m->last->line,
 683                                 m->last->pos, "file"))
 684                 return(0);
 685         m->next = MDOC_NEXT_SIBLING;
 686         if ( ! mdoc_word_alloc(m, m->last->line,
 687                                 m->last->pos, "..."))
 688                 return(0);
 689
 690         m->last = n;
 691         m->next = MDOC_NEXT_SIBLING;
 692         return(1);
 693 }
 694
 695
 696 static int
 697 post_dd(POST_ARGS)
 698 {
 699         char              buf[64];
 700
 701         buf[0] = 0;
 702         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 703                 return(0);
 704
 705         if (0 == (m->meta.date = mdoc_atotime(buf))) {
 706                 if ( ! vwarn(m, WBADDATE))
 707                         return(0);
 708                 m->meta.date = time(NULL);
 709         }
 710
 711         return(post_prol(m));
 712 }
 713
 714
 715 static int
 716 post_prol(POST_ARGS)
 717 {
 718         struct mdoc_node *n;
 719
 720         /*
 721          * The end document shouldn't have the prologue macros as part
 722          * of the syntax tree (they encompass only meta-data).
 723          */
 724
 725         if (m->last->parent->child == m->last)
 726                 m->last->parent->child = m->last->prev;
 727         if (m->last->prev)
 728                 m->last->prev->next = NULL;
 729
 730         n = m->last;
 731         assert(NULL == m->last->next);
 732
 733         if (m->last->prev) {
 734                 m->last = m->last->prev;
 735                 m->next = MDOC_NEXT_SIBLING;
 736         } else {
 737                 m->last = m->last->parent;
 738                 m->next = MDOC_NEXT_CHILD;
 739         }
 740
 741         mdoc_node_freelist(n);
 742         return(1);
 743 }
 744
 745
 746 static int
 747 pre_dl(PRE_ARGS)
 748 {
 749
 750         if (MDOC_BODY != n->type)
 751                 return(1);
 752         m->flags |= MDOC_LITERAL;
 753         return(1);
 754 }
 755
 756
 757 static int
 758 pre_bd(PRE_ARGS)
 759 {
 760         int              i;
 761
 762         if (MDOC_BODY != n->type)
 763                 return(1);
 764
 765         /* Enter literal context if `Bd -literal' or * -unfilled'. */
 766
 767         for (n = n->parent, i = 0; i < (int)n->args->argc; i++)
 768                 if (MDOC_Literal == n->args->argv[i].arg)
 769                         break;
 770                 else if (MDOC_Unfilled == n->args->argv[i].arg)
 771                         break;
 772
 773         if (i < (int)n->args->argc)
 774                 m->flags |= MDOC_LITERAL;
 775
 776         return(1);
 777 }
 778
 779
 780 static int
 781 post_display(POST_ARGS)
 782 {
 783
 784         if (MDOC_BODY == m->last->type)
 785                 m->flags &= ~MDOC_LITERAL;
 786         return(1);
 787 }
 788
 789