mdoc_action.c

   1 /*      $Id: mdoc_action.c,v 1.12 2009/06/16 19:45:51 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 }, /* Ap */
  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 }, /* Lp */
 182         { NULL, post_lk }, /* 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 };
 193
 194
 195 #ifdef __linux__
 196 extern  size_t  strlcat(char *, const char *, size_t);
 197 #endif
 198
 199
 200 int
 201 mdoc_action_pre(struct mdoc *m, const struct mdoc_node *n)
 202 {
 203
 204         switch (n->type) {
 205         case (MDOC_ROOT):
 206                 /* FALLTHROUGH */
 207         case (MDOC_TEXT):
 208                 return(1);
 209         default:
 210                 break;
 211         }
 212
 213         if (NULL == mdoc_actions[n->tok].pre)
 214                 return(1);
 215         return((*mdoc_actions[n->tok].pre)(m, n));
 216 }
 217
 218
 219 int
 220 mdoc_action_post(struct mdoc *m)
 221 {
 222
 223         if (MDOC_ACTED & m->last->flags)
 224                 return(1);
 225         m->last->flags |= MDOC_ACTED;
 226
 227         switch (m->last->type) {
 228         case (MDOC_TEXT):
 229                 /* FALLTHROUGH */
 230         case (MDOC_ROOT):
 231                 return(1);
 232         default:
 233                 break;
 234         }
 235
 236         if (NULL == mdoc_actions[m->last->tok].post)
 237                 return(1);
 238         return((*mdoc_actions[m->last->tok].post)(m));
 239 }
 240
 241
 242 static int
 243 concat(struct mdoc *m, const struct mdoc_node *n,
 244                 char *buf, size_t sz)
 245 {
 246
 247         for ( ; n; n = n->next) {
 248                 assert(MDOC_TEXT == n->type);
 249                 if (strlcat(buf, n->string, sz) >= sz)
 250                         return(nerr(m, n, ETOOLONG));
 251                 if (NULL == n->next)
 252                         continue;
 253                 if (strlcat(buf, " ", sz) >= sz)
 254                         return(nerr(m, n, ETOOLONG));
 255         }
 256
 257         return(1);
 258 }
 259
 260
 261 static int
 262 perr(struct mdoc *m, int line, int pos, enum merr type)
 263 {
 264         char            *p;
 265
 266         p = NULL;
 267         switch (type) {
 268         case (ENUMFMT):
 269                 p = "bad number format";
 270                 break;
 271         case (ETOOLONG):
 272                 p = "argument text too long";
 273                 break;
 274         case (EMALLOC):
 275                 p = "memory exhausted";
 276                 break;
 277         }
 278         assert(p);
 279         return(mdoc_perr(m, line, pos, p));
 280 }
 281
 282
 283 static int
 284 pwarn(struct mdoc *m, int line, int pos, enum mwarn type)
 285 {
 286         char            *p;
 287         int              c;
 288
 289         p = NULL;
 290         c = WARN_SYNTAX;
 291         switch (type) {
 292         case (WBADSEC):
 293                 p = "inappropriate document section in manual section";
 294                 c = WARN_COMPAT;
 295                 break;
 296         case (WNOWIDTH):
 297                 p = "cannot determine default width";
 298                 break;
 299         case (WBADDATE):
 300                 p = "malformed date syntax";
 301                 break;
 302         }
 303         assert(p);
 304         return(mdoc_pwarn(m, line, pos, c, p));
 305 }
 306
 307
 308 static int
 309 post_std(POST_ARGS)
 310 {
 311
 312         /*
 313          * If '-std' is invoked without an argument, fill it in with our
 314          * name (if it's been set).
 315          */
 316
 317         if (NULL == m->last->args)
 318                 return(1);
 319         if (m->last->args->argv[0].sz)
 320                 return(1);
 321
 322         assert(m->meta.name);
 323
 324         m->last->args->argv[0].value = calloc(1, sizeof(char *));
 325         if (NULL == m->last->args->argv[0].value)
 326                 return(verr(m, EMALLOC));
 327
 328         m->last->args->argv[0].sz = 1;
 329         m->last->args->argv[0].value[0] = strdup(m->meta.name);
 330         if (NULL == m->last->args->argv[0].value[0])
 331                 return(verr(m, EMALLOC));
 332
 333         return(1);
 334 }
 335
 336
 337 static int
 338 post_nm(POST_ARGS)
 339 {
 340         char             buf[64];
 341
 342         if (m->meta.name)
 343                 return(1);
 344
 345         buf[0] = 0;
 346         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 347                 return(0);
 348
 349         if (NULL == (m->meta.name = strdup(buf)))
 350                 return(verr(m, EMALLOC));
 351
 352         return(1);
 353 }
 354
 355
 356 static int
 357 post_sh(POST_ARGS)
 358 {
 359         enum mdoc_sec    sec;
 360         char             buf[64];
 361
 362         /*
 363          * We keep track of the current section /and/ the "named"
 364          * section, which is one of the conventional ones, in order to
 365          * check ordering.
 366          */
 367
 368         if (MDOC_HEAD != m->last->type)
 369                 return(1);
 370
 371         buf[0] = 0;
 372         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 373                 return(0);
 374         if (SEC_CUSTOM != (sec = mdoc_atosec(buf)))
 375                 m->lastnamed = sec;
 376
 377         switch ((m->lastsec = sec)) {
 378         case (SEC_RETURN_VALUES):
 379                 /* FALLTHROUGH */
 380         case (SEC_ERRORS):
 381                 switch (m->meta.msec) {
 382                 case (2):
 383                         /* FALLTHROUGH */
 384                 case (3):
 385                         /* FALLTHROUGH */
 386                 case (9):
 387                         break;
 388                 default:
 389                         return(vwarn(m, WBADSEC));
 390                 }
 391                 break;
 392         default:
 393                 break;
 394         }
 395         return(1);
 396 }
 397
 398
 399 static int
 400 post_dt(POST_ARGS)
 401 {
 402         struct mdoc_node *n;
 403         const char       *cp;
 404         char             *ep;
 405         long              lval;
 406
 407         if (m->meta.title)
 408                 free(m->meta.title);
 409         if (m->meta.vol)
 410                 free(m->meta.vol);
 411         if (m->meta.arch)
 412                 free(m->meta.arch);
 413
 414         m->meta.title = m->meta.vol = m->meta.arch = NULL;
 415         m->meta.msec = 0;
 416
 417         /* Handles: `.Dt'
 418          *   --> title = unknown, volume = local, msec = 0, arch = NULL
 419          */
 420
 421         if (NULL == (n = m->last->child)) {
 422                 if (NULL == (m->meta.title = strdup("unknown")))
 423                         return(verr(m, EMALLOC));
 424                 if (NULL == (m->meta.vol = strdup("local")))
 425                         return(verr(m, EMALLOC));
 426                 return(post_prol(m));
 427         }
 428
 429         /* Handles: `.Dt TITLE'
 430          *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 431          */
 432
 433         if (NULL == (m->meta.title = strdup(n->string)))
 434                 return(verr(m, EMALLOC));
 435
 436         if (NULL == (n = n->next)) {
 437                 if (NULL == (m->meta.vol = strdup("local")))
 438                         return(verr(m, EMALLOC));
 439                 return(post_prol(m));
 440         }
 441
 442         /* Handles: `.Dt TITLE SEC'
 443          *   --> title = TITLE, volume = SEC is msec ?
 444          *           format(msec) : SEC,
 445          *       msec = SEC is msec ? atoi(msec) : 0,
 446          *       arch = NULL
 447          */
 448
 449         cp = mdoc_a2msec(n->string);
 450         if (cp) {
 451                 if (NULL == (m->meta.vol = strdup(cp)))
 452                         return(verr(m, EMALLOC));
 453                 errno = 0;
 454                 lval = strtol(n->string, &ep, 10);
 455                 if (n->string[0] != '\0' && *ep == '\0')
 456                         m->meta.msec = (int)lval;
 457         } else if (NULL == (m->meta.vol = strdup(n->string)))
 458                 return(verr(m, EMALLOC));
 459
 460         if (NULL == (n = n->next))
 461                 return(post_prol(m));
 462
 463         /* Handles: `.Dt TITLE SEC VOL'
 464          *   --> title = TITLE, volume = VOL is vol ?
 465          *       format(VOL) :
 466          *           VOL is arch ? format(arch) :
 467          *               VOL
 468          */
 469
 470         cp = mdoc_a2vol(n->string);
 471         if (cp) {
 472                 free(m->meta.vol);
 473                 if (NULL == (m->meta.vol = strdup(cp)))
 474                         return(verr(m, EMALLOC));
 475                 n = n->next;
 476         } else {
 477                 cp = mdoc_a2arch(n->string);
 478                 if (NULL == cp) {
 479                         free(m->meta.vol);
 480                         if (NULL == (m->meta.vol = strdup(n->string)))
 481                                 return(verr(m, EMALLOC));
 482                 } else if (NULL == (m->meta.arch = strdup(cp)))
 483                         return(verr(m, EMALLOC));
 484         }
 485
 486         /* Ignore any subsequent parameters... */
 487
 488         return(post_prol(m));
 489 }
 490
 491
 492 static int
 493 post_os(POST_ARGS)
 494 {
 495         char              buf[64];
 496         struct utsname    utsname;
 497
 498         if (m->meta.os)
 499                 free(m->meta.os);
 500
 501         buf[0] = 0;
 502         if ( ! concat(m, m->last->child, buf, sizeof(buf)))
 503                 return(0);
 504
 505         if (0 == buf[0]) {
 506                 if (-1 == uname(&utsname))
 507                         return(mdoc_err(m, "utsname"));
 508                 if (strlcat(buf, utsname.sysname, 64) >= 64)
 509                         return(verr(m, ETOOLONG));
 510                 if (strlcat(buf, " ", 64) >= 64)
 511                         return(verr(m, ETOOLONG));
 512                 if (strlcat(buf, utsname.release, 64) >= 64)
 513                         return(verr(m, ETOOLONG));
 514         }
 515
 516         if (NULL == (m->meta.os = strdup(buf)))
 517                 return(verr(m, EMALLOC));
 518         m->lastnamed = m->lastsec = SEC_BODY;
 519
 520         return(post_prol(m));
 521 }
 522
 523
 524 /*
 525  * Calculate the -width for a `Bl -tag' list if it hasn't been provided.
 526  * Uses the first head macro.
 527  */
 528 static int
 529 post_bl_tagwidth(struct mdoc *m)
 530 {
 531         struct mdoc_node  *n;
 532         int                sz;
 533         char               buf[32];
 534
 535         /*
 536          * Use the text width, if a text node, or the default macro
 537          * width if a macro.
 538          */
 539
 540         n = m->last->body->child;
 541         if (n) {
 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