mdoc_action.c

   1 /*      $Id: mdoc_action.c,v 1.62 2010/05/29 18:58:52 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 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #ifndef OSNAME
  22 #include <sys/utsname.h>
  23 #endif
  24
  25 #include <assert.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include "mandoc.h"
  32 #include "libmdoc.h"
  33 #include "libmandoc.h"
  34
  35 #define POST_ARGS struct mdoc *m, struct mdoc_node *n
  36 #define PRE_ARGS  struct mdoc *m, struct mdoc_node *n
  37
  38 #define NUMSIZ    32
  39 #define DATESIZ   32
  40
  41 struct  actions {
  42         int     (*pre)(PRE_ARGS);
  43         int     (*post)(POST_ARGS);
  44 };
  45
  46 static  int       concat(struct mdoc *, char *,
  47                         const struct mdoc_node *, size_t);
  48 static  inline int order_rs(enum mdoct);
  49
  50 static  int       post_ar(POST_ARGS);
  51 static  int       post_at(POST_ARGS);
  52 static  int       post_bl(POST_ARGS);
  53 static  int       post_bl_head(POST_ARGS);
  54 static  int       post_bl_tagwidth(POST_ARGS);
  55 static  int       post_bl_width(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_lb(POST_ARGS);
  60 static  int       post_li(POST_ARGS);
  61 static  int       post_nm(POST_ARGS);
  62 static  int       post_os(POST_ARGS);
  63 static  int       post_pa(POST_ARGS);
  64 static  int       post_prol(POST_ARGS);
  65 static  int       post_rs(POST_ARGS);
  66 static  int       post_sh(POST_ARGS);
  67 static  int       post_st(POST_ARGS);
  68 static  int       post_std(POST_ARGS);
  69
  70 static  int       pre_bd(PRE_ARGS);
  71 static  int       pre_bl(PRE_ARGS);
  72 static  int       pre_dl(PRE_ARGS);
  73 static  int       pre_offset(PRE_ARGS);
  74
  75 static  const struct actions mdoc_actions[MDOC_MAX] = {
  76         { NULL, NULL }, /* Ap */
  77         { NULL, post_dd }, /* Dd */
  78         { NULL, post_dt }, /* Dt */
  79         { NULL, post_os }, /* Os */
  80         { NULL, post_sh }, /* Sh */
  81         { NULL, NULL }, /* Ss */
  82         { NULL, NULL }, /* Pp */
  83         { NULL, NULL }, /* D1 */
  84         { pre_dl, post_display }, /* Dl */
  85         { pre_bd, post_display }, /* Bd */
  86         { NULL, NULL }, /* Ed */
  87         { pre_bl, post_bl }, /* Bl */
  88         { NULL, NULL }, /* El */
  89         { NULL, NULL }, /* It */
  90         { NULL, NULL }, /* Ad */
  91         { NULL, NULL }, /* An */
  92         { NULL, post_ar }, /* Ar */
  93         { NULL, NULL }, /* Cd */
  94         { NULL, NULL }, /* Cm */
  95         { NULL, NULL }, /* Dv */
  96         { NULL, NULL }, /* Er */
  97         { NULL, NULL }, /* Ev */
  98         { NULL, post_std }, /* Ex */
  99         { NULL, NULL }, /* Fa */
 100         { NULL, NULL }, /* Fd */
 101         { NULL, NULL }, /* Fl */
 102         { NULL, NULL }, /* Fn */
 103         { NULL, NULL }, /* Ft */
 104         { NULL, NULL }, /* Ic */
 105         { NULL, NULL }, /* In */
 106         { NULL, post_li }, /* Li */
 107         { NULL, NULL }, /* Nd */
 108         { NULL, post_nm }, /* Nm */
 109         { NULL, NULL }, /* Op */
 110         { NULL, NULL }, /* Ot */
 111         { NULL, post_pa }, /* Pa */
 112         { NULL, post_std }, /* Rv */
 113         { NULL, post_st }, /* St */
 114         { NULL, NULL }, /* Va */
 115         { NULL, NULL }, /* Vt */
 116         { NULL, NULL }, /* Xr */
 117         { NULL, NULL }, /* %A */
 118         { NULL, NULL }, /* %B */
 119         { NULL, NULL }, /* %D */
 120         { NULL, NULL }, /* %I */
 121         { NULL, NULL }, /* %J */
 122         { NULL, NULL }, /* %N */
 123         { NULL, NULL }, /* %O */
 124         { NULL, NULL }, /* %P */
 125         { NULL, NULL }, /* %R */
 126         { NULL, NULL }, /* %T */
 127         { NULL, NULL }, /* %V */
 128         { NULL, NULL }, /* Ac */
 129         { NULL, NULL }, /* Ao */
 130         { NULL, NULL }, /* Aq */
 131         { NULL, post_at }, /* At */
 132         { NULL, NULL }, /* Bc */
 133         { NULL, NULL }, /* Bf */
 134         { NULL, NULL }, /* Bo */
 135         { NULL, NULL }, /* Bq */
 136         { NULL, NULL }, /* Bsx */
 137         { NULL, NULL }, /* Bx */
 138         { NULL, NULL }, /* Db */
 139         { NULL, NULL }, /* Dc */
 140         { NULL, NULL }, /* Do */
 141         { NULL, NULL }, /* Dq */
 142         { NULL, NULL }, /* Ec */
 143         { NULL, NULL }, /* Ef */
 144         { NULL, NULL }, /* Em */
 145         { NULL, NULL }, /* Eo */
 146         { NULL, NULL }, /* Fx */
 147         { NULL, NULL }, /* Ms */
 148         { NULL, NULL }, /* No */
 149         { NULL, NULL }, /* Ns */
 150         { NULL, NULL }, /* Nx */
 151         { NULL, NULL }, /* Ox */
 152         { NULL, NULL }, /* Pc */
 153         { NULL, NULL }, /* Pf */
 154         { NULL, NULL }, /* Po */
 155         { NULL, NULL }, /* Pq */
 156         { NULL, NULL }, /* Qc */
 157         { NULL, NULL }, /* Ql */
 158         { NULL, NULL }, /* Qo */
 159         { NULL, NULL }, /* Qq */
 160         { NULL, NULL }, /* Re */
 161         { NULL, post_rs }, /* Rs */
 162         { NULL, NULL }, /* Sc */
 163         { NULL, NULL }, /* So */
 164         { NULL, NULL }, /* Sq */
 165         { NULL, NULL }, /* Sm */
 166         { NULL, NULL }, /* Sx */
 167         { NULL, NULL }, /* Sy */
 168         { NULL, NULL }, /* Tn */
 169         { NULL, NULL }, /* Ux */
 170         { NULL, NULL }, /* Xc */
 171         { NULL, NULL }, /* Xo */
 172         { NULL, NULL }, /* Fo */
 173         { NULL, NULL }, /* Fc */
 174         { NULL, NULL }, /* Oo */
 175         { NULL, NULL }, /* Oc */
 176         { NULL, NULL }, /* Bk */
 177         { NULL, NULL }, /* Ek */
 178         { NULL, NULL }, /* Bt */
 179         { NULL, NULL }, /* Hf */
 180         { NULL, NULL }, /* Fr */
 181         { NULL, NULL }, /* Ud */
 182         { NULL, post_lb }, /* Lb */
 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         { NULL, NULL }, /* br */
 195         { NULL, NULL }, /* sp */
 196         { NULL, NULL }, /* %U */
 197 };
 198
 199 #define RSORD_MAX 14
 200
 201 static  const enum mdoct rsord[RSORD_MAX] = {
 202         MDOC__A,
 203         MDOC__T,
 204         MDOC__B,
 205         MDOC__I,
 206         MDOC__J,
 207         MDOC__R,
 208         MDOC__N,
 209         MDOC__V,
 210         MDOC__P,
 211         MDOC__Q,
 212         MDOC__D,
 213         MDOC__O,
 214         MDOC__C,
 215         MDOC__U
 216 };
 217
 218
 219 int
 220 mdoc_action_pre(struct mdoc *m, struct mdoc_node *n)
 221 {
 222
 223         switch (n->type) {
 224         case (MDOC_ROOT):
 225                 /* FALLTHROUGH */
 226         case (MDOC_TEXT):
 227                 return(1);
 228         default:
 229                 break;
 230         }
 231
 232         if (NULL == mdoc_actions[n->tok].pre)
 233                 return(1);
 234         return((*mdoc_actions[n->tok].pre)(m, n));
 235 }
 236
 237
 238 int
 239 mdoc_action_post(struct mdoc *m)
 240 {
 241
 242         if (MDOC_ACTED & m->last->flags)
 243                 return(1);
 244         m->last->flags |= MDOC_ACTED;
 245
 246         switch (m->last->type) {
 247         case (MDOC_TEXT):
 248                 /* FALLTHROUGH */
 249         case (MDOC_ROOT):
 250                 return(1);
 251         default:
 252                 break;
 253         }
 254
 255         if (NULL == mdoc_actions[m->last->tok].post)
 256                 return(1);
 257         return((*mdoc_actions[m->last->tok].post)(m, m->last));
 258 }
 259
 260
 261 /*
 262  * Concatenate sibling nodes together.  All siblings must be of type
 263  * MDOC_TEXT or an assertion is raised.  Concatenation is separated by a
 264  * single whitespace.
 265  */
 266 static int
 267 concat(struct mdoc *m, char *p, const struct mdoc_node *n, size_t sz)
 268 {
 269
 270         assert(sz);
 271         p[0] = '\0';
 272         for ( ; n; n = n->next) {
 273                 assert(MDOC_TEXT == n->type);
 274                 /*
 275                  * XXX: yes, these can technically be resized, but it's
 276                  * highly unlikely that we're going to get here, so let
 277                  * it slip for now.
 278                  */
 279                 if (strlcat(p, n->string, sz) >= sz) {
 280                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 281                         return(0);
 282                 }
 283                 if (NULL == n->next)
 284                         continue;
 285                 if (strlcat(p, " ", sz) >= sz) {
 286                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 287                         return(0);
 288                 }
 289         }
 290
 291         return(1);
 292 }
 293
 294
 295 /*
 296  * Macros accepting `-std' as an argument have the name of the current
 297  * document (`Nm') filled in as the argument if it's not provided.
 298  */
 299 static int
 300 post_std(POST_ARGS)
 301 {
 302         struct mdoc_node *nn;
 303
 304         if (n->child)
 305                 return(1);
 306         if (NULL == m->meta.name)
 307                 return(1);
 308
 309         nn = n;
 310         m->next = MDOC_NEXT_CHILD;
 311
 312         if ( ! mdoc_word_alloc(m, n->line, n->pos, m->meta.name))
 313                 return(0);
 314         m->last = nn;
 315         return(1);
 316 }
 317
 318
 319 /*
 320  * The `Nm' macro's first use sets the name of the document.  See also
 321  * post_std(), etc.
 322  */
 323 static int
 324 post_nm(POST_ARGS)
 325 {
 326         char             buf[BUFSIZ];
 327
 328         if (m->meta.name)
 329                 return(1);
 330         if ( ! concat(m, buf, n->child, BUFSIZ))
 331                 return(0);
 332         m->meta.name = mandoc_strdup(buf);
 333         return(1);
 334 }
 335
 336
 337 /*
 338  * Look up the value of `Lb' for matching predefined strings.  If it has
 339  * one, then substitute the current value for the formatted value.  Note
 340  * that the lookup may fail (we can provide arbitrary strings).
 341  */
 342 /* ARGSUSED */
 343 static int
 344 post_lb(POST_ARGS)
 345 {
 346         const char      *p;
 347         char            *buf;
 348         size_t           sz;
 349
 350         assert(MDOC_TEXT == n->child->type);
 351         p = mdoc_a2lib(n->child->string);
 352
 353         if (p) {
 354                 free(n->child->string);
 355                 n->child->string = mandoc_strdup(p);
 356                 return(1);
 357         }
 358
 359         sz = strlen(n->child->string) +
 360                 2 + strlen("\\(lqlibrary\\(rq");
 361         buf = mandoc_malloc(sz);
 362         snprintf(buf, sz, "library \\(lq%s\\(rq", n->child->string);
 363         free(n->child->string);
 364         n->child->string = buf;
 365         return(1);
 366 }
 367
 368
 369 /*
 370  * Substitute the value of `St' for the corresponding formatted string.
 371  * We're guaranteed that this exists (it's been verified during the
 372  * validation phase).
 373  */
 374 /* ARGSUSED */
 375 static int
 376 post_st(POST_ARGS)
 377 {
 378         const char      *p;
 379
 380         assert(MDOC_TEXT == n->child->type);
 381         p = mdoc_a2st(n->child->string);
 382         if (p != NULL) {
 383                 free(n->child->string);
 384                 n->child->string = mandoc_strdup(p);
 385         }
 386         return(1);
 387 }
 388
 389
 390 /*
 391  * Look up the standard string in a table.  We know that it exists from
 392  * the validation phase, so assert on failure.  If a standard key wasn't
 393  * supplied, supply the default ``AT&T UNIX''.
 394  */
 395 static int
 396 post_at(POST_ARGS)
 397 {
 398         struct mdoc_node *nn;
 399         const char       *p, *q;
 400         char             *buf;
 401         size_t            sz;
 402
 403         if (n->child) {
 404                 assert(MDOC_TEXT == n->child->type);
 405                 p = mdoc_a2att(n->child->string);
 406                 if (p) {
 407                         free(n->child->string);
 408                         n->child->string = mandoc_strdup(p);
 409                 } else {
 410                         p = "AT&T UNIX ";
 411                         q = n->child->string;
 412                         sz = strlen(p) + strlen(q) + 1;
 413                         buf = mandoc_malloc(sz);
 414                         strlcpy(buf, p, sz);
 415                         strlcat(buf, q, sz);
 416                         free(n->child->string);
 417                         n->child->string = buf;
 418                 }
 419                 return(1);
 420         }
 421
 422         nn = n;
 423         m->next = MDOC_NEXT_CHILD;
 424         if ( ! mdoc_word_alloc(m, nn->line, nn->pos, "AT&T UNIX"))
 425                 return(0);
 426         m->last = nn;
 427         return(1);
 428 }
 429
 430
 431 /*
 432  * Mark the current section.  The ``named'' section (lastnamed) is set
 433  * whenever the current section isn't a custom section--we use this to
 434  * keep track of section ordering.  Also check that the section is
 435  * allowed within the document's manual section.
 436  */
 437 static int
 438 post_sh(POST_ARGS)
 439 {
 440         enum mdoc_sec    sec;
 441         char             buf[BUFSIZ];
 442
 443         if (MDOC_HEAD != n->type)
 444                 return(1);
 445
 446         if ( ! concat(m, buf, n->child, BUFSIZ))
 447                 return(0);
 448         sec = mdoc_str2sec(buf);
 449         /*
 450          * The first section should always make us move into a non-new
 451          * state.
 452          */
 453         if (SEC_NONE == m->lastnamed || SEC_CUSTOM != sec)
 454                 m->lastnamed = sec;
 455
 456         /* Some sections only live in certain manual sections. */
 457
 458         switch ((m->lastsec = sec)) {
 459         case (SEC_RETURN_VALUES):
 460                 /* FALLTHROUGH */
 461         case (SEC_ERRORS):
 462                 assert(m->meta.msec);
 463                 if (*m->meta.msec == '2')
 464                         break;
 465                 if (*m->meta.msec == '3')
 466                         break;
 467                 if (*m->meta.msec == '9')
 468                         break;
 469                 return(mdoc_nmsg(m, n, MANDOCERR_SECMSEC));
 470         default:
 471                 break;
 472         }
 473         return(1);
 474 }
 475
 476
 477 /*
 478  * Parse out the contents of `Dt'.  See in-line documentation for how we
 479  * handle the various fields of this macro.
 480  */
 481 static int
 482 post_dt(POST_ARGS)
 483 {
 484         struct mdoc_node *nn;
 485         const char       *cp;
 486
 487         if (m->meta.title)
 488                 free(m->meta.title);
 489         if (m->meta.vol)
 490                 free(m->meta.vol);
 491         if (m->meta.arch)
 492                 free(m->meta.arch);
 493
 494         m->meta.title = m->meta.vol = m->meta.arch = NULL;
 495         /* Handles: `.Dt'
 496          *   --> title = unknown, volume = local, msec = 0, arch = NULL
 497          */
 498
 499         if (NULL == (nn = n->child)) {
 500                 /* XXX: make these macro values. */
 501                 /* FIXME: warn about missing values. */
 502                 m->meta.title = mandoc_strdup("unknown");
 503                 m->meta.vol = mandoc_strdup("local");
 504                 m->meta.msec = mandoc_strdup("1");
 505                 return(post_prol(m, n));
 506         }
 507
 508         /* Handles: `.Dt TITLE'
 509          *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 510          */
 511
 512         m->meta.title = mandoc_strdup(nn->string);
 513
 514         if (NULL == (nn = nn->next)) {
 515                 /* FIXME: warn about missing msec. */
 516                 /* XXX: make this a macro value. */
 517                 m->meta.vol = mandoc_strdup("local");
 518                 m->meta.msec = mandoc_strdup("1");
 519                 return(post_prol(m, n));
 520         }
 521
 522         /* Handles: `.Dt TITLE SEC'
 523          *   --> title = TITLE, volume = SEC is msec ?
 524          *           format(msec) : SEC,
 525          *       msec = SEC is msec ? atoi(msec) : 0,
 526          *       arch = NULL
 527          */
 528
 529         cp = mdoc_a2msec(nn->string);
 530         if (cp) {
 531                 m->meta.vol = mandoc_strdup(cp);
 532                 m->meta.msec = mandoc_strdup(nn->string);
 533         } else if (mdoc_nmsg(m, n, MANDOCERR_BADMSEC)) {
 534                 m->meta.vol = mandoc_strdup(nn->string);
 535                 m->meta.msec = mandoc_strdup(nn->string);
 536         } else
 537                 return(0);
 538
 539         if (NULL == (nn = nn->next))
 540                 return(post_prol(m, n));
 541
 542         /* Handles: `.Dt TITLE SEC VOL'
 543          *   --> title = TITLE, volume = VOL is vol ?
 544          *       format(VOL) :
 545          *           VOL is arch ? format(arch) :
 546          *               VOL
 547          */
 548
 549         cp = mdoc_a2vol(nn->string);
 550         if (cp) {
 551                 free(m->meta.vol);
 552                 m->meta.vol = mandoc_strdup(cp);
 553         } else {
 554                 /* FIXME: warn about bad arch. */
 555                 cp = mdoc_a2arch(nn->string);
 556                 if (NULL == cp) {
 557                         free(m->meta.vol);
 558                         m->meta.vol = mandoc_strdup(nn->string);
 559                 } else
 560                         m->meta.arch = mandoc_strdup(cp);
 561         }
 562
 563         /* Ignore any subsequent parameters... */
 564         /* FIXME: warn about subsequent parameters. */
 565
 566         return(post_prol(m, n));
 567 }
 568
 569
 570 /*
 571  * Set the operating system by way of the `Os' macro.  Note that if an
 572  * argument isn't provided and -DOSNAME="\"foo\"" is provided during
 573  * compilation, this value will be used instead of filling in "sysname
 574  * release" from uname().
 575  */
 576 static int
 577 post_os(POST_ARGS)
 578 {
 579         char              buf[BUFSIZ];
 580 #ifndef OSNAME
 581         struct utsname    utsname;
 582 #endif
 583
 584         if (m->meta.os)
 585                 free(m->meta.os);
 586
 587         if ( ! concat(m, buf, n->child, BUFSIZ))
 588                 return(0);
 589
 590         /* XXX: yes, these can all be dynamically-adjusted buffers, but
 591          * it's really not worth the extra hackery.
 592          */
 593
 594         if ('\0' == buf[0]) {
 595 #ifdef OSNAME
 596                 if (strlcat(buf, OSNAME, BUFSIZ) >= BUFSIZ) {
 597                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 598                         return(0);
 599                 }
 600 #else /*!OSNAME */
 601                 if (-1 == uname(&utsname))
 602                         return(mdoc_nmsg(m, n, MANDOCERR_UTSNAME));
 603
 604                 if (strlcat(buf, utsname.sysname, BUFSIZ) >= BUFSIZ) {
 605                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 606                         return(0);
 607                 }
 608                 if (strlcat(buf, " ", 64) >= BUFSIZ) {
 609                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 610                         return(0);
 611                 }
 612                 if (strlcat(buf, utsname.release, BUFSIZ) >= BUFSIZ) {
 613                         mdoc_nmsg(m, n, MANDOCERR_MEM);
 614                         return(0);
 615                 }
 616 #endif /*!OSNAME*/
 617         }
 618
 619         m->meta.os = mandoc_strdup(buf);
 620         return(post_prol(m, n));
 621 }
 622
 623
 624 /*
 625  * Calculate the -width for a `Bl -tag' list if it hasn't been provided.
 626  * Uses the first head macro.  NOTE AGAIN: this is ONLY if the -width
 627  * argument has NOT been provided.  See post_bl_width() for converting
 628  * the -width string.
 629  */
 630 static int
 631 post_bl_tagwidth(POST_ARGS)
 632 {
 633         struct mdoc_node *nn;
 634         size_t            sz;
 635         int               i;
 636         char              buf[NUMSIZ];
 637
 638         /* Defaults to ten ens. */
 639
 640         sz = 10; /* XXX: make this a macro value. */
 641
 642         for (nn = n->body->child; nn; nn = nn->next) {
 643                 if (MDOC_It == nn->tok)
 644                         break;
 645         }
 646
 647         if (nn) {
 648                 assert(MDOC_BLOCK == nn->type);
 649                 nn = nn->head->child;
 650                 if (MDOC_TEXT != nn->type) {
 651                         sz = mdoc_macro2len(nn->tok);
 652                         if (sz == 0) {
 653                                 if ( ! mdoc_nmsg(m, n, MANDOCERR_NOWIDTHARG))
 654                                         return(0);
 655                                 sz = 10;
 656                         }
 657                 } else
 658                         sz = strlen(nn->string) + 1;
 659         }
 660
 661         snprintf(buf, NUMSIZ, "%zun", sz);
 662
 663         /*
 664          * We have to dynamically add this to the macro's argument list.
 665          * We're guaranteed that a MDOC_Width doesn't already exist.
 666          */
 667
 668         nn = n;
 669         assert(nn->args);
 670         i = (int)(nn->args->argc)++;
 671
 672         nn->args->argv = mandoc_realloc(nn->args->argv,
 673                         nn->args->argc * sizeof(struct mdoc_argv));
 674
 675         nn->args->argv[i].arg = MDOC_Width;
 676         nn->args->argv[i].line = n->line;
 677         nn->args->argv[i].pos = n->pos;
 678         nn->args->argv[i].sz = 1;
 679         nn->args->argv[i].value = mandoc_malloc(sizeof(char *));
 680         nn->args->argv[i].value[0] = mandoc_strdup(buf);
 681         return(1);
 682 }
 683
 684
 685 /*
 686  * Calculate the real width of a list from the -width string, which may
 687  * contain a macro (with a known default width), a literal string, or a
 688  * scaling width.
 689  */
 690 static int
 691 post_bl_width(POST_ARGS)
 692 {
 693         size_t            width;
 694         int               i;
 695         enum mdoct        tok;
 696         char              buf[NUMSIZ];
 697         char             *p;
 698
 699         if (NULL == n->args)
 700                 return(1);
 701
 702         for (i = 0; i < (int)n->args->argc; i++)
 703                 if (MDOC_Width == n->args->argv[i].arg)
 704                         break;
 705
 706         if (i == (int)n->args->argc)
 707                 return(1);
 708         p = n->args->argv[i].value[0];
 709
 710         /*
 711          * If the value to -width is a macro, then we re-write it to be
 712          * the macro's width as set in share/tmac/mdoc/doc-common.
 713          */
 714
 715         if (0 == strcmp(p, "Ds"))
 716                 width = 6;
 717         else if (MDOC_MAX == (tok = mdoc_hash_find(p)))
 718                 return(1);
 719         else if (0 == (width = mdoc_macro2len(tok)))
 720                 return(mdoc_nmsg(m, n, MANDOCERR_BADWIDTH));
 721
 722         /* The value already exists: free and reallocate it. */
 723
 724         snprintf(buf, NUMSIZ, "%zun", width);
 725         free(n->args->argv[i].value[0]);
 726         n->args->argv[i].value[0] = mandoc_strdup(buf);
 727         return(1);
 728 }
 729
 730
 731 /*
 732  * Do processing for -column lists, which can have two distinct styles
 733  * of invocation.  Merge this two styles into a consistent form.
 734  */
 735 /* ARGSUSED */
 736 static int
 737 post_bl_head(POST_ARGS)
 738 {
 739         int                      i, c;
 740         struct mdoc_node        *np, *nn, *nnp;
 741
 742         if (NULL == n->child)
 743                 return(1);
 744
 745         np = n->parent;
 746         assert(np->args);
 747
 748         for (c = 0; c < (int)np->args->argc; c++)
 749                 if (MDOC_Column == np->args->argv[c].arg)
 750                         break;
 751
 752         if (c == (int)np->args->argc)
 753                 return(1);
 754         assert(0 == np->args->argv[c].sz);
 755
 756         /*
 757          * Accomodate for new-style groff column syntax.  Shuffle the
 758          * child nodes, all of which must be TEXT, as arguments for the
 759          * column field.  Then, delete the head children.
 760          */
 761
 762         np->args->argv[c].sz = (size_t)n->nchild;
 763         np->args->argv[c].value = mandoc_malloc
 764                 ((size_t)n->nchild * sizeof(char *));
 765
 766         for (i = 0, nn = n->child; nn; i++) {
 767                 np->args->argv[c].value[i] = nn->string;
 768                 nn->string = NULL;
 769                 nnp = nn;
 770                 nn = nn->next;
 771                 mdoc_node_delete(NULL, nnp);
 772         }
 773
 774         n->nchild = 0;
 775         n->child = NULL;
 776         return(1);
 777 }
 778
 779
 780 static int
 781 post_bl(POST_ARGS)
 782 {
 783         int               i, r, len;
 784
 785         if (MDOC_HEAD == n->type)
 786                 return(post_bl_head(m, n));
 787         if (MDOC_BLOCK != n->type)
 788                 return(1);
 789
 790         /*
 791          * These are fairly complicated, so we've broken them into two
 792          * functions.  post_bl_tagwidth() is called when a -tag is
 793          * specified, but no -width (it must be guessed).  The second
 794          * when a -width is specified (macro indicators must be
 795          * rewritten into real lengths).
 796          */
 797
 798         len = (int)(n->args ? n->args->argc : 0);
 799
 800         for (r = i = 0; i < len; i++) {
 801                 if (MDOC_Tag == n->args->argv[i].arg)
 802                         r |= 1 << 0;
 803                 if (MDOC_Width == n->args->argv[i].arg)
 804                         r |= 1 << 1;
 805         }
 806
 807         if (r & (1 << 0) && ! (r & (1 << 1))) {
 808                 if ( ! post_bl_tagwidth(m, n))
 809                         return(0);
 810         } else if (r & (1 << 1))
 811                 if ( ! post_bl_width(m, n))
 812                         return(0);
 813
 814         return(1);
 815 }
 816
 817
 818 /*
 819  * The `Pa' macro defaults to a tilde if no value is provided as an
 820  * argument.
 821  */
 822 static int
 823 post_pa(POST_ARGS)
 824 {
 825         struct mdoc_node *np;
 826
 827         if (n->child)
 828                 return(1);
 829
 830         np = n;
 831         m->next = MDOC_NEXT_CHILD;
 832         /* XXX: make into macro value. */
 833         if ( ! mdoc_word_alloc(m, n->line, n->pos, "~"))
 834                 return(0);
 835         m->last = np;
 836         return(1);
 837 }
 838
 839
 840 /*
 841  * Empty `Li' macros get an empty string to make front-ends add an extra
 842  * space.
 843  */
 844 static int
 845 post_li(POST_ARGS)
 846 {
 847         struct mdoc_node *np;
 848
 849         if (n->child)
 850                 return(1);
 851
 852         np = n;
 853         m->next = MDOC_NEXT_CHILD;
 854         if ( ! mdoc_word_alloc(m, n->line, n->pos, ""))
 855                 return(0);
 856         m->last = np;
 857         return(1);
 858 }
 859
 860
 861 /*
 862  * The `Ar' macro defaults to two strings "file ..." if no value is
 863  * provided as an argument.
 864  */
 865 static int
 866 post_ar(POST_ARGS)
 867 {
 868         struct mdoc_node *np;
 869
 870         if (n->child)
 871                 return(1);
 872
 873         np = n;
 874         m->next = MDOC_NEXT_CHILD;
 875         /* XXX: make into macro values. */
 876         if ( ! mdoc_word_alloc(m, n->line, n->pos, "file"))
 877                 return(0);
 878         if ( ! mdoc_word_alloc(m, n->line, n->pos, "..."))
 879                 return(0);
 880         m->last = np;
 881         return(1);
 882 }
 883
 884
 885 /*
 886  * Parse the date field in `Dd'.
 887  */
 888 static int
 889 post_dd(POST_ARGS)
 890 {
 891         char            buf[DATESIZ];
 892
 893         if ( ! concat(m, buf, n->child, DATESIZ))
 894                 return(0);
 895
 896         m->meta.date = mandoc_a2time
 897                 (MTIME_MDOCDATE | MTIME_CANONICAL, buf);
 898
 899         if (0 == m->meta.date) {
 900                 if ( ! mdoc_nmsg(m, n, MANDOCERR_BADDATE))
 901                         return(0);
 902                 m->meta.date = time(NULL);
 903         }
 904
 905         return(post_prol(m, n));
 906 }
 907
 908
 909 /*
 910  * Remove prologue macros from the document after they're processed.
 911  * The final document uses mdoc_meta for these values and discards the
 912  * originals.
 913  */
 914 static int
 915 post_prol(POST_ARGS)
 916 {
 917
 918         mdoc_node_delete(m, n);
 919         if (m->meta.title && m->meta.date && m->meta.os)
 920                 m->flags |= MDOC_PBODY;
 921         return(1);
 922 }
 923
 924
 925 /*
 926  * Trigger a literal context.
 927  */
 928 static int
 929 pre_dl(PRE_ARGS)
 930 {
 931
 932         if (MDOC_BODY == n->type)
 933                 m->flags |= MDOC_LITERAL;
 934         return(1);
 935 }
 936
 937
 938 /* ARGSUSED */
 939 static int
 940 pre_offset(PRE_ARGS)
 941 {
 942         int              i;
 943
 944         /*
 945          * Make sure that an empty offset produces an 8n length space as
 946          * stipulated by mdoc.samples.
 947          */
 948
 949         assert(n->args);
 950         for (i = 0; i < (int)n->args->argc; i++) {
 951                 if (MDOC_Offset != n->args->argv[i].arg)
 952                         continue;
 953                 if (n->args->argv[i].sz)
 954                         break;
 955                 assert(1 == n->args->refcnt);
 956                 /* If no value set, length of <string>. */
 957                 n->args->argv[i].sz++;
 958                 n->args->argv[i].value = mandoc_malloc(sizeof(char *));
 959                 n->args->argv[i].value[0] = mandoc_strdup("8n");
 960                 break;
 961         }
 962
 963         return(1);
 964 }
 965
 966
 967 static int
 968 pre_bl(PRE_ARGS)
 969 {
 970         int              pos;
 971
 972         if (MDOC_BLOCK != n->type) {
 973                 assert(n->parent);
 974                 assert(MDOC_BLOCK == n->parent->type);
 975                 assert(MDOC_Bl == n->parent->tok);
 976                 assert(LIST__NONE != n->parent->data.list);
 977                 n->data.list = n->parent->data.list;
 978                 return(1);
 979         }
 980
 981         assert(LIST__NONE == n->data.list);
 982
 983         for (pos = 0; pos < (int)n->args->argc; pos++) {
 984                 switch (n->args->argv[pos].arg) {
 985                 case (MDOC_Bullet):
 986                         n->data.list = LIST_bullet;
 987                         break;
 988                 case (MDOC_Dash):
 989                         n->data.list = LIST_dash;
 990                         break;
 991                 case (MDOC_Enum):
 992                         n->data.list = LIST_enum;
 993                         break;
 994                 case (MDOC_Hyphen):
 995                         n->data.list = LIST_hyphen;
 996                         break;
 997                 case (MDOC_Item):
 998                         n->data.list = LIST_item;
 999                         break;
1000                 case (MDOC_Tag):
1001                         n->data.list = LIST_tag;
1002                         break;
1003                 case (MDOC_Diag):
1004                         n->data.list = LIST_diag;
1005                         break;
1006                 case (MDOC_Hang):
1007                         n->data.list = LIST_hang;
1008                         break;
1009                 case (MDOC_Ohang):
1010                         n->data.list = LIST_ohang;
1011                         break;
1012                 case (MDOC_Inset):
1013                         n->data.list = LIST_inset;
1014                         break;
1015                 case (MDOC_Column):
1016                         n->data.list = LIST_column;
1017                         break;
1018                 default:
1019                         break;
1020                 }
1021                 if (LIST__NONE != n->data.list)
1022                         break;
1023         }
1024
1025         assert(LIST__NONE != n->data.list);
1026         return(pre_offset(m, n));
1027 }
1028
1029
1030 static int
1031 pre_bd(PRE_ARGS)
1032 {
1033         int              i;
1034
1035         if (MDOC_BLOCK == n->type)
1036                 return(pre_offset(m, n));
1037         if (MDOC_BODY != n->type)
1038                 return(1);
1039
1040         /* Enter literal context if `Bd -literal' or `-unfilled'. */
1041
1042         for (n = n->parent, i = 0; i < (int)n->args->argc; i++)
1043                 if (MDOC_Literal == n->args->argv[i].arg)
1044                         m->flags |= MDOC_LITERAL;
1045                 else if (MDOC_Unfilled == n->args->argv[i].arg)
1046                         m->flags |= MDOC_LITERAL;
1047
1048         return(1);
1049 }
1050
1051
1052 static int
1053 post_display(POST_ARGS)
1054 {
1055
1056         if (MDOC_BODY == n->type)
1057                 m->flags &= ~MDOC_LITERAL;
1058         return(1);
1059 }
1060
1061
1062 static inline int
1063 order_rs(enum mdoct t)
1064 {
1065         int             i;
1066
1067         for (i = 0; i < (int)RSORD_MAX; i++)
1068                 if (rsord[i] == t)
1069                         return(i);
1070
1071         abort();
1072         /* NOTREACHED */
1073 }
1074
1075
1076 /* ARGSUSED */
1077 static int
1078 post_rs(POST_ARGS)
1079 {
1080         struct mdoc_node        *nn, *next, *prev;
1081         int                      o;
1082
1083         if (MDOC_BLOCK != n->type)
1084                 return(1);
1085
1086         assert(n->body->child);
1087         for (next = NULL, nn = n->body->child->next; nn; nn = next) {
1088                 o = order_rs(nn->tok);
1089
1090                 /* Remove `nn' from the chain. */
1091                 next = nn->next;
1092                 if (next)
1093                         next->prev = nn->prev;
1094
1095                 prev = nn->prev;
1096                 if (prev)
1097                         prev->next = nn->next;
1098
1099                 nn->prev = nn->next = NULL;
1100
1101                 /*
1102                  * Scan back until we reach a node that's ordered before
1103                  * us, then set ourselves as being the next.
1104                  */
1105                 for ( ; prev; prev = prev->prev)
1106                         if (order_rs(prev->tok) <= o)
1107                                 break;
1108
1109                 nn->prev = prev;
1110                 if (prev) {
1111                         if (prev->next)
1112                                 prev->next->prev = nn;
1113                         nn->next = prev->next;
1114                         prev->next = nn;
1115                         continue;
1116                 }
1117
1118                 n->body->child->prev = nn;
1119                 nn->next = n->body->child;
1120                 n->body->child = nn;
1121         }
1122         return(1);
1123 }