man_term.c

   1 /*      $Id: man_term.c,v 1.115 2011/07/22 10:50:46 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <sys/types.h>
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "mandoc.h"
  31 #include "out.h"
  32 #include "man.h"
  33 #include "term.h"
  34 #include "main.h"
  35
  36 #define INDENT            7
  37 #define HALFINDENT        3
  38
  39 /* FIXME: have PD set the default vspace width. */
  40
  41 struct  mtermp {
  42         int               fl;
  43 #define MANT_LITERAL     (1 << 0)
  44         /*
  45          * Default amount to indent the left margin after leading text
  46          * has been printed (e.g., `HP' left-indent, `TP' and `IP' body
  47          * indent).  This needs to be saved because `HP' and so on, if
  48          * not having a specified value, must default.
  49          *
  50          * Note that this is the indentation AFTER the left offset, so
  51          * the total offset is usually offset + lmargin.
  52          */
  53         size_t            lmargin;
  54         /*
  55          * The default offset, i.e., the amount between any text and the
  56          * page boundary.
  57          */
  58         size_t            offset;
  59 };
  60
  61 #define DECL_ARGS         struct termp *p, \
  62                           struct mtermp *mt, \
  63                           const struct man_node *n, \
  64                           const struct man_meta *m
  65
  66 struct  termact {
  67         int             (*pre)(DECL_ARGS);
  68         void            (*post)(DECL_ARGS);
  69         int               flags;
  70 #define MAN_NOTEXT       (1 << 0) /* Never has text children. */
  71 };
  72
  73 static  int               a2width(const struct termp *, const char *);
  74 static  size_t            a2height(const struct termp *, const char *);
  75
  76 static  void              print_man_nodelist(DECL_ARGS);
  77 static  void              print_man_node(DECL_ARGS);
  78 static  void              print_man_head(struct termp *, const void *);
  79 static  void              print_man_foot(struct termp *, const void *);
  80 static  void              print_bvspace(struct termp *,
  81                                 const struct man_node *);
  82
  83 static  int               pre_alternate(DECL_ARGS);
  84 static  int               pre_B(DECL_ARGS);
  85 static  int               pre_HP(DECL_ARGS);
  86 static  int               pre_I(DECL_ARGS);
  87 static  int               pre_IP(DECL_ARGS);
  88 static  int               pre_PP(DECL_ARGS);
  89 static  int               pre_RS(DECL_ARGS);
  90 static  int               pre_SH(DECL_ARGS);
  91 static  int               pre_SS(DECL_ARGS);
  92 static  int               pre_TP(DECL_ARGS);
  93 static  int               pre_ign(DECL_ARGS);
  94 static  int               pre_in(DECL_ARGS);
  95 static  int               pre_literal(DECL_ARGS);
  96 static  int               pre_sp(DECL_ARGS);
  97 static  int               pre_ft(DECL_ARGS);
  98
  99 static  void              post_IP(DECL_ARGS);
 100 static  void              post_HP(DECL_ARGS);
 101 static  void              post_RS(DECL_ARGS);
 102 static  void              post_SH(DECL_ARGS);
 103 static  void              post_SS(DECL_ARGS);
 104 static  void              post_TP(DECL_ARGS);
 105
 106 static  const struct termact termacts[MAN_MAX] = {
 107         { pre_sp, NULL, MAN_NOTEXT }, /* br */
 108         { NULL, NULL, 0 }, /* TH */
 109         { pre_SH, post_SH, 0 }, /* SH */
 110         { pre_SS, post_SS, 0 }, /* SS */
 111         { pre_TP, post_TP, 0 }, /* TP */
 112         { pre_PP, NULL, 0 }, /* LP */
 113         { pre_PP, NULL, 0 }, /* PP */
 114         { pre_PP, NULL, 0 }, /* P */
 115         { pre_IP, post_IP, 0 }, /* IP */
 116         { pre_HP, post_HP, 0 }, /* HP */
 117         { NULL, NULL, 0 }, /* SM */
 118         { pre_B, NULL, 0 }, /* SB */
 119         { pre_alternate, NULL, 0 }, /* BI */
 120         { pre_alternate, NULL, 0 }, /* IB */
 121         { pre_alternate, NULL, 0 }, /* BR */
 122         { pre_alternate, NULL, 0 }, /* RB */
 123         { NULL, NULL, 0 }, /* R */
 124         { pre_B, NULL, 0 }, /* B */
 125         { pre_I, NULL, 0 }, /* I */
 126         { pre_alternate, NULL, 0 }, /* IR */
 127         { pre_alternate, NULL, 0 }, /* RI */
 128         { pre_ign, NULL, MAN_NOTEXT }, /* na */
 129         { pre_sp, NULL, MAN_NOTEXT }, /* sp */
 130         { pre_literal, NULL, 0 }, /* nf */
 131         { pre_literal, NULL, 0 }, /* fi */
 132         { NULL, NULL, 0 }, /* RE */
 133         { pre_RS, post_RS, 0 }, /* RS */
 134         { pre_ign, NULL, 0 }, /* DT */
 135         { pre_ign, NULL, 0 }, /* UC */
 136         { pre_ign, NULL, 0 }, /* PD */
 137         { pre_ign, NULL, 0 }, /* AT */
 138         { pre_in, NULL, MAN_NOTEXT }, /* in */
 139         { pre_ft, NULL, MAN_NOTEXT }, /* ft */
 140 };
 141
 142
 143
 144 void
 145 terminal_man(void *arg, const struct man *man)
 146 {
 147         struct termp            *p;
 148         const struct man_node   *n;
 149         const struct man_meta   *m;
 150         struct mtermp            mt;
 151
 152         p = (struct termp *)arg;
 153
 154         p->overstep = 0;
 155         p->maxrmargin = p->defrmargin;
 156         p->tabwidth = term_len(p, 5);
 157
 158         if (NULL == p->symtab)
 159                 p->symtab = mchars_alloc();
 160
 161         n = man_node(man);
 162         m = man_meta(man);
 163
 164         term_begin(p, print_man_head, print_man_foot, m);
 165         p->flags |= TERMP_NOSPACE;
 166
 167         mt.fl = 0;
 168         mt.lmargin = term_len(p, INDENT);
 169         mt.offset = term_len(p, INDENT);
 170
 171         if (n->child)
 172                 print_man_nodelist(p, &mt, n->child, m);
 173
 174         term_end(p);
 175 }
 176
 177
 178 static size_t
 179 a2height(const struct termp *p, const char *cp)
 180 {
 181         struct roffsu    su;
 182
 183         if ( ! a2roffsu(cp, &su, SCALE_VS))
 184                 SCALE_VS_INIT(&su, atoi(cp));
 185
 186         return(term_vspan(p, &su));
 187 }
 188
 189
 190 static int
 191 a2width(const struct termp *p, const char *cp)
 192 {
 193         struct roffsu    su;
 194
 195         if ( ! a2roffsu(cp, &su, SCALE_BU))
 196                 return(-1);
 197
 198         return((int)term_hspan(p, &su));
 199 }
 200
 201 /*
 202  * Printing leading vertical space before a block.
 203  * This is used for the paragraph macros.
 204  * The rules are pretty simple, since there's very little nesting going
 205  * on here.  Basically, if we're the first within another block (SS/SH),
 206  * then don't emit vertical space.  If we are (RS), then do.  If not the
 207  * first, print it.
 208  */
 209 static void
 210 print_bvspace(struct termp *p, const struct man_node *n)
 211 {
 212
 213         term_newln(p);
 214
 215         if (n->body && n->body->child)
 216                 if (MAN_TBL == n->body->child->type)
 217                         return;
 218
 219         if (MAN_ROOT == n->parent->type || MAN_RS != n->parent->tok)
 220                 if (NULL == n->prev)
 221                         return;
 222
 223         term_vspace(p);
 224 }
 225
 226 /* ARGSUSED */
 227 static int
 228 pre_ign(DECL_ARGS)
 229 {
 230
 231         return(0);
 232 }
 233
 234
 235 /* ARGSUSED */
 236 static int
 237 pre_I(DECL_ARGS)
 238 {
 239
 240         term_fontrepl(p, TERMFONT_UNDER);
 241         return(1);
 242 }
 243
 244
 245 /* ARGSUSED */
 246 static int
 247 pre_literal(DECL_ARGS)
 248 {
 249
 250         term_newln(p);
 251
 252         if (MAN_nf == n->tok)
 253                 mt->fl |= MANT_LITERAL;
 254         else
 255                 mt->fl &= ~MANT_LITERAL;
 256
 257         return(0);
 258 }
 259
 260 /* ARGSUSED */
 261 static int
 262 pre_alternate(DECL_ARGS)
 263 {
 264         enum termfont            font[2];
 265         const struct man_node   *nn;
 266         int                      savelit, i;
 267
 268         switch (n->tok) {
 269         case (MAN_RB):
 270                 font[0] = TERMFONT_NONE;
 271                 font[1] = TERMFONT_BOLD;
 272                 break;
 273         case (MAN_RI):
 274                 font[0] = TERMFONT_NONE;
 275                 font[1] = TERMFONT_UNDER;
 276                 break;
 277         case (MAN_BR):
 278                 font[0] = TERMFONT_BOLD;
 279                 font[1] = TERMFONT_NONE;
 280                 break;
 281         case (MAN_BI):
 282                 font[0] = TERMFONT_BOLD;
 283                 font[1] = TERMFONT_UNDER;
 284                 break;
 285         case (MAN_IR):
 286                 font[0] = TERMFONT_UNDER;
 287                 font[1] = TERMFONT_NONE;
 288                 break;
 289         case (MAN_IB):
 290                 font[0] = TERMFONT_UNDER;
 291                 font[1] = TERMFONT_BOLD;
 292                 break;
 293         default:
 294                 abort();
 295         }
 296
 297         savelit = MANT_LITERAL & mt->fl;
 298         mt->fl &= ~MANT_LITERAL;
 299
 300         for (i = 0, nn = n->child; nn; nn = nn->next, i = 1 - i) {
 301                 term_fontrepl(p, font[i]);
 302                 if (savelit && NULL == nn->next)
 303                         mt->fl |= MANT_LITERAL;
 304                 print_man_node(p, mt, nn, m);
 305                 if (nn->next)
 306                         p->flags |= TERMP_NOSPACE;
 307         }
 308
 309         return(0);
 310 }
 311
 312 /* ARGSUSED */
 313 static int
 314 pre_B(DECL_ARGS)
 315 {
 316
 317         term_fontrepl(p, TERMFONT_BOLD);
 318         return(1);
 319 }
 320
 321 /* ARGSUSED */
 322 static int
 323 pre_ft(DECL_ARGS)
 324 {
 325         const char      *cp;
 326
 327         if (NULL == n->child) {
 328                 term_fontlast(p);
 329                 return(0);
 330         }
 331
 332         cp = n->child->string;
 333         switch (*cp) {
 334         case ('4'):
 335                 /* FALLTHROUGH */
 336         case ('3'):
 337                 /* FALLTHROUGH */
 338         case ('B'):
 339                 term_fontrepl(p, TERMFONT_BOLD);
 340                 break;
 341         case ('2'):
 342                 /* FALLTHROUGH */
 343         case ('I'):
 344                 term_fontrepl(p, TERMFONT_UNDER);
 345                 break;
 346         case ('P'):
 347                 term_fontlast(p);
 348                 break;
 349         case ('1'):
 350                 /* FALLTHROUGH */
 351         case ('C'):
 352                 /* FALLTHROUGH */
 353         case ('R'):
 354                 term_fontrepl(p, TERMFONT_NONE);
 355                 break;
 356         default:
 357                 break;
 358         }
 359         return(0);
 360 }
 361
 362 /* ARGSUSED */
 363 static int
 364 pre_in(DECL_ARGS)
 365 {
 366         int              len, less;
 367         size_t           v;
 368         const char      *cp;
 369
 370         term_newln(p);
 371
 372         if (NULL == n->child) {
 373                 p->offset = mt->offset;
 374                 return(0);
 375         }
 376
 377         cp = n->child->string;
 378         less = 0;
 379
 380         if ('-' == *cp)
 381                 less = -1;
 382         else if ('+' == *cp)
 383                 less = 1;
 384         else
 385                 cp--;
 386
 387         if ((len = a2width(p, ++cp)) < 0)
 388                 return(0);
 389
 390         v = (size_t)len;
 391
 392         if (less < 0)
 393                 p->offset -= p->offset > v ? v : p->offset;
 394         else if (less > 0)
 395                 p->offset += v;
 396         else
 397                 p->offset = v;
 398
 399         /* Don't let this creep beyond the right margin. */
 400
 401         if (p->offset > p->rmargin)
 402                 p->offset = p->rmargin;
 403
 404         return(0);
 405 }
 406
 407
 408 /* ARGSUSED */
 409 static int
 410 pre_sp(DECL_ARGS)
 411 {
 412         size_t           i, len;
 413
 414         if ((NULL == n->prev && n->parent)) {
 415                 if (MAN_SS == n->parent->tok)
 416                         return(0);
 417                 if (MAN_SH == n->parent->tok)
 418                         return(0);
 419         }
 420
 421         switch (n->tok) {
 422         case (MAN_br):
 423                 len = 0;
 424                 break;
 425         default:
 426                 len = n->child ? a2height(p, n->child->string) : 1;
 427                 break;
 428         }
 429
 430         if (0 == len)
 431                 term_newln(p);
 432         for (i = 0; i < len; i++)
 433                 term_vspace(p);
 434
 435         return(0);
 436 }
 437
 438
 439 /* ARGSUSED */
 440 static int
 441 pre_HP(DECL_ARGS)
 442 {
 443         size_t                   len;
 444         int                      ival;
 445         const struct man_node   *nn;
 446
 447         switch (n->type) {
 448         case (MAN_BLOCK):
 449                 print_bvspace(p, n);
 450                 return(1);
 451         case (MAN_BODY):
 452                 p->flags |= TERMP_NOBREAK;
 453                 p->flags |= TERMP_TWOSPACE;
 454                 break;
 455         default:
 456                 return(0);
 457         }
 458
 459         len = mt->lmargin;
 460         ival = -1;
 461
 462         /* Calculate offset. */
 463
 464         if (NULL != (nn = n->parent->head->child))
 465                 if ((ival = a2width(p, nn->string)) >= 0)
 466                         len = (size_t)ival;
 467
 468         if (0 == len)
 469                 len = term_len(p, 1);
 470
 471         p->offset = mt->offset;
 472         p->rmargin = mt->offset + len;
 473
 474         if (ival >= 0)
 475                 mt->lmargin = (size_t)ival;
 476
 477         return(1);
 478 }
 479
 480
 481 /* ARGSUSED */
 482 static void
 483 post_HP(DECL_ARGS)
 484 {
 485
 486         switch (n->type) {
 487         case (MAN_BLOCK):
 488                 term_flushln(p);
 489                 break;
 490         case (MAN_BODY):
 491                 term_flushln(p);
 492                 p->flags &= ~TERMP_NOBREAK;
 493                 p->flags &= ~TERMP_TWOSPACE;
 494                 p->offset = mt->offset;
 495                 p->rmargin = p->maxrmargin;
 496                 break;
 497         default:
 498                 break;
 499         }
 500 }
 501
 502
 503 /* ARGSUSED */
 504 static int
 505 pre_PP(DECL_ARGS)
 506 {
 507
 508         switch (n->type) {
 509         case (MAN_BLOCK):
 510                 mt->lmargin = term_len(p, INDENT);
 511                 print_bvspace(p, n);
 512                 break;
 513         default:
 514                 p->offset = mt->offset;
 515                 break;
 516         }
 517
 518         return(MAN_HEAD != n->type);
 519 }
 520
 521
 522 /* ARGSUSED */
 523 static int
 524 pre_IP(DECL_ARGS)
 525 {
 526         const struct man_node   *nn;
 527         size_t                   len;
 528         int                      savelit, ival;
 529
 530         switch (n->type) {
 531         case (MAN_BODY):
 532                 p->flags |= TERMP_NOLPAD;
 533                 p->flags |= TERMP_NOSPACE;
 534                 break;
 535         case (MAN_HEAD):
 536                 p->flags |= TERMP_NOBREAK;
 537                 break;
 538         case (MAN_BLOCK):
 539                 print_bvspace(p, n);
 540                 /* FALLTHROUGH */
 541         default:
 542                 return(1);
 543         }
 544
 545         len = mt->lmargin;
 546         ival = -1;
 547
 548         /* Calculate the offset from the optional second argument. */
 549         if (NULL != (nn = n->parent->head->child))
 550                 if (NULL != (nn = nn->next))
 551                         if ((ival = a2width(p, nn->string)) >= 0)
 552                                 len = (size_t)ival;
 553
 554         switch (n->type) {
 555         case (MAN_HEAD):
 556                 /* Handle zero-width lengths. */
 557                 if (0 == len)
 558                         len = term_len(p, 1);
 559
 560                 p->offset = mt->offset;
 561                 p->rmargin = mt->offset + len;
 562                 if (ival < 0)
 563                         break;
 564
 565                 /* Set the saved left-margin. */
 566                 mt->lmargin = (size_t)ival;
 567
 568                 savelit = MANT_LITERAL & mt->fl;
 569                 mt->fl &= ~MANT_LITERAL;
 570
 571                 if (n->child)
 572                         print_man_node(p, mt, n->child, m);
 573
 574                 if (savelit)
 575                         mt->fl |= MANT_LITERAL;
 576
 577                 return(0);
 578         case (MAN_BODY):
 579                 p->offset = mt->offset + len;
 580                 p->rmargin = p->maxrmargin;
 581                 break;
 582         default:
 583                 break;
 584         }
 585
 586         return(1);
 587 }
 588
 589
 590 /* ARGSUSED */
 591 static void
 592 post_IP(DECL_ARGS)
 593 {
 594
 595         switch (n->type) {
 596         case (MAN_HEAD):
 597                 term_flushln(p);
 598                 p->flags &= ~TERMP_NOBREAK;
 599                 p->rmargin = p->maxrmargin;
 600                 break;
 601         case (MAN_BODY):
 602                 term_newln(p);
 603                 p->flags &= ~TERMP_NOLPAD;
 604                 break;
 605         default:
 606                 break;
 607         }
 608 }
 609
 610
 611 /* ARGSUSED */
 612 static int
 613 pre_TP(DECL_ARGS)
 614 {
 615         const struct man_node   *nn;
 616         size_t                   len;
 617         int                      savelit, ival;
 618
 619         switch (n->type) {
 620         case (MAN_HEAD):
 621                 p->flags |= TERMP_NOBREAK;
 622                 break;
 623         case (MAN_BODY):
 624                 p->flags |= TERMP_NOLPAD;
 625                 p->flags |= TERMP_NOSPACE;
 626                 break;
 627         case (MAN_BLOCK):
 628                 print_bvspace(p, n);
 629                 /* FALLTHROUGH */
 630         default:
 631                 return(1);
 632         }
 633
 634         len = (size_t)mt->lmargin;
 635         ival = -1;
 636
 637         /* Calculate offset. */
 638
 639         if (NULL != (nn = n->parent->head->child)) {
 640                 while (nn && MAN_TEXT != nn->type)
 641                         nn = nn->next;
 642                 if (nn && nn->next)
 643                         if ((ival = a2width(p, nn->string)) >= 0)
 644                                 len = (size_t)ival;
 645         }
 646
 647         switch (n->type) {
 648         case (MAN_HEAD):
 649                 /* Handle zero-length properly. */
 650                 if (0 == len)
 651                         len = term_len(p, 1);
 652
 653                 p->offset = mt->offset;
 654                 p->rmargin = mt->offset + len;
 655
 656                 savelit = MANT_LITERAL & mt->fl;
 657                 mt->fl &= ~MANT_LITERAL;
 658
 659                 /* Don't print same-line elements. */
 660                 for (nn = n->child; nn; nn = nn->next)
 661                         if (nn->line > n->line)
 662                                 print_man_node(p, mt, nn, m);
 663
 664                 if (savelit)
 665                         mt->fl |= MANT_LITERAL;
 666
 667                 if (ival >= 0)
 668                         mt->lmargin = (size_t)ival;
 669
 670                 return(0);
 671         case (MAN_BODY):
 672                 p->offset = mt->offset + len;
 673                 p->rmargin = p->maxrmargin;
 674                 break;
 675         default:
 676                 break;
 677         }
 678
 679         return(1);
 680 }
 681
 682
 683 /* ARGSUSED */
 684 static void
 685 post_TP(DECL_ARGS)
 686 {
 687
 688         switch (n->type) {
 689         case (MAN_HEAD):
 690                 term_flushln(p);
 691                 p->flags &= ~TERMP_NOBREAK;
 692                 p->flags &= ~TERMP_TWOSPACE;
 693                 p->rmargin = p->maxrmargin;
 694                 break;
 695         case (MAN_BODY):
 696                 term_newln(p);
 697                 p->flags &= ~TERMP_NOLPAD;
 698                 break;
 699         default:
 700                 break;
 701         }
 702 }
 703
 704
 705 /* ARGSUSED */
 706 static int
 707 pre_SS(DECL_ARGS)
 708 {
 709
 710         switch (n->type) {
 711         case (MAN_BLOCK):
 712                 mt->fl &= ~MANT_LITERAL;
 713                 mt->lmargin = term_len(p, INDENT);
 714                 mt->offset = term_len(p, INDENT);
 715                 /* If following a prior empty `SS', no vspace. */
 716                 if (n->prev && MAN_SS == n->prev->tok)
 717                         if (NULL == n->prev->body->child)
 718                                 break;
 719                 if (NULL == n->prev)
 720                         break;
 721                 term_vspace(p);
 722                 break;
 723         case (MAN_HEAD):
 724                 term_fontrepl(p, TERMFONT_BOLD);
 725                 p->offset = term_len(p, HALFINDENT);
 726                 break;
 727         case (MAN_BODY):
 728                 p->offset = mt->offset;
 729                 break;
 730         default:
 731                 break;
 732         }
 733
 734         return(1);
 735 }
 736
 737
 738 /* ARGSUSED */
 739 static void
 740 post_SS(DECL_ARGS)
 741 {
 742
 743         switch (n->type) {
 744         case (MAN_HEAD):
 745                 term_newln(p);
 746                 break;
 747         case (MAN_BODY):
 748                 term_newln(p);
 749                 break;
 750         default:
 751                 break;
 752         }
 753 }
 754
 755
 756 /* ARGSUSED */
 757 static int
 758 pre_SH(DECL_ARGS)
 759 {
 760
 761         switch (n->type) {
 762         case (MAN_BLOCK):
 763                 mt->fl &= ~MANT_LITERAL;
 764                 mt->lmargin = term_len(p, INDENT);
 765                 mt->offset = term_len(p, INDENT);
 766                 /* If following a prior empty `SH', no vspace. */
 767                 if (n->prev && MAN_SH == n->prev->tok)
 768                         if (NULL == n->prev->body->child)
 769                                 break;
 770                 /* If the first macro, no vspae. */
 771                 if (NULL == n->prev)
 772                         break;
 773                 term_vspace(p);
 774                 break;
 775         case (MAN_HEAD):
 776                 term_fontrepl(p, TERMFONT_BOLD);
 777                 p->offset = 0;
 778                 break;
 779         case (MAN_BODY):
 780                 p->offset = mt->offset;
 781                 break;
 782         default:
 783                 break;
 784         }
 785
 786         return(1);
 787 }
 788
 789
 790 /* ARGSUSED */
 791 static void
 792 post_SH(DECL_ARGS)
 793 {
 794
 795         switch (n->type) {
 796         case (MAN_HEAD):
 797                 term_newln(p);
 798                 break;
 799         case (MAN_BODY):
 800                 term_newln(p);
 801                 break;
 802         default:
 803                 break;
 804         }
 805 }
 806
 807 /* ARGSUSED */
 808 static int
 809 pre_RS(DECL_ARGS)
 810 {
 811         int              ival;
 812         size_t           sz;
 813
 814         switch (n->type) {
 815         case (MAN_BLOCK):
 816                 term_newln(p);
 817                 return(1);
 818         case (MAN_HEAD):
 819                 return(0);
 820         default:
 821                 break;
 822         }
 823
 824         sz = term_len(p, INDENT);
 825
 826         if (NULL != (n = n->parent->head->child))
 827                 if ((ival = a2width(p, n->string)) >= 0)
 828                         sz = (size_t)ival;
 829
 830         mt->offset += sz;
 831         p->offset = mt->offset;
 832
 833         return(1);
 834 }
 835
 836 /* ARGSUSED */
 837 static void
 838 post_RS(DECL_ARGS)
 839 {
 840         int              ival;
 841         size_t           sz;
 842
 843         switch (n->type) {
 844         case (MAN_BLOCK):
 845                 return;
 846         case (MAN_HEAD):
 847                 return;
 848         default:
 849                 term_newln(p);
 850                 break;
 851         }
 852
 853         sz = term_len(p, INDENT);
 854
 855         if (NULL != (n = n->parent->head->child))
 856                 if ((ival = a2width(p, n->string)) >= 0)
 857                         sz = (size_t)ival;
 858
 859         mt->offset = mt->offset < sz ?  0 : mt->offset - sz;
 860         p->offset = mt->offset;
 861 }
 862
 863 static void
 864 print_man_node(DECL_ARGS)
 865 {
 866         size_t           rm, rmax;
 867         int              c;
 868
 869         switch (n->type) {
 870         case(MAN_TEXT):
 871                 /*
 872                  * If we have a blank line, output a vertical space.
 873                  * If we have a space as the first character, break
 874                  * before printing the line's data.
 875                  */
 876                 if ('\0' == *n->string) {
 877                         term_vspace(p);
 878                         return;
 879                 } else if (' ' == *n->string && MAN_LINE & n->flags)
 880                         term_newln(p);
 881
 882                 term_word(p, n->string);
 883
 884                 /*
 885                  * If we're in a literal context, make sure that words
 886                  * togehter on the same line stay together.  This is a
 887                  * POST-printing call, so we check the NEXT word.  Since
 888                  * -man doesn't have nested macros, we don't need to be
 889                  * more specific than this.
 890                  */
 891                 if (MANT_LITERAL & mt->fl &&
 892                                 (NULL == n->next ||
 893                                  n->next->line > n->line)) {
 894                         rm = p->rmargin;
 895                         rmax = p->maxrmargin;
 896                         p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
 897                         p->flags |= TERMP_NOSPACE;
 898                         term_flushln(p);
 899                         p->flags &= ~TERMP_NOLPAD;
 900                         p->rmargin = rm;
 901                         p->maxrmargin = rmax;
 902                 }
 903
 904                 if (MAN_EOS & n->flags)
 905                         p->flags |= TERMP_SENTENCE;
 906                 return;
 907         case (MAN_EQN):
 908                 term_eqn(p, n->eqn);
 909                 return;
 910         case (MAN_TBL):
 911                 /*
 912                  * Tables are preceded by a newline.  Then process a
 913                  * table line, which will cause line termination,
 914                  */
 915                 if (TBL_SPAN_FIRST & n->span->flags)
 916                         term_newln(p);
 917                 term_tbl(p, n->span);
 918                 return;
 919         default:
 920                 break;
 921         }
 922
 923         if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
 924                 term_fontrepl(p, TERMFONT_NONE);
 925
 926         c = 1;
 927         if (termacts[n->tok].pre)
 928                 c = (*termacts[n->tok].pre)(p, mt, n, m);
 929
 930         if (c && n->child)
 931                 print_man_nodelist(p, mt, n->child, m);
 932
 933         if (termacts[n->tok].post)
 934                 (*termacts[n->tok].post)(p, mt, n, m);
 935         if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
 936                 term_fontrepl(p, TERMFONT_NONE);
 937
 938         if (MAN_EOS & n->flags)
 939                 p->flags |= TERMP_SENTENCE;
 940 }
 941
 942
 943 static void
 944 print_man_nodelist(DECL_ARGS)
 945 {
 946
 947         print_man_node(p, mt, n, m);
 948         if ( ! n->next)
 949                 return;
 950         print_man_nodelist(p, mt, n->next, m);
 951 }
 952
 953
 954 static void
 955 print_man_foot(struct termp *p, const void *arg)
 956 {
 957         const struct man_meta *meta;
 958
 959         meta = (const struct man_meta *)arg;
 960
 961         term_fontrepl(p, TERMFONT_NONE);
 962
 963         term_vspace(p);
 964         term_vspace(p);
 965         term_vspace(p);
 966
 967         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
 968         p->rmargin = p->maxrmargin - term_strlen(p, meta->date);
 969         p->offset = 0;
 970
 971         /* term_strlen() can return zero. */
 972         if (p->rmargin == p->maxrmargin)
 973                 p->rmargin--;
 974
 975         if (meta->source)
 976                 term_word(p, meta->source);
 977         if (meta->source)
 978                 term_word(p, "");
 979         term_flushln(p);
 980
 981         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
 982         p->offset = p->rmargin;
 983         p->rmargin = p->maxrmargin;
 984         p->flags &= ~TERMP_NOBREAK;
 985
 986         term_word(p, meta->date);
 987         term_flushln(p);
 988 }
 989
 990
 991 static void
 992 print_man_head(struct termp *p, const void *arg)
 993 {
 994         char            buf[BUFSIZ], title[BUFSIZ];
 995         size_t          buflen, titlen;
 996         const struct man_meta *m;
 997
 998         m = (const struct man_meta *)arg;
 999
1000         /*
1001          * Note that old groff would spit out some spaces before the
1002          * header.  We discontinue this strange behaviour, but at one
1003          * point we did so here.
1004          */
1005
1006         p->rmargin = p->maxrmargin;
1007
1008         p->offset = 0;
1009         buf[0] = title[0] = '\0';
1010
1011         if (m->vol)
1012                 strlcpy(buf, m->vol, BUFSIZ);
1013         buflen = term_strlen(p, buf);
1014
1015         snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
1016         titlen = term_strlen(p, title);
1017
1018         p->offset = 0;
1019         p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?
1020             (p->maxrmargin -
1021              term_strlen(p, buf) + term_len(p, 1)) / 2 :
1022             p->maxrmargin - buflen;
1023         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1024
1025         term_word(p, title);
1026         term_flushln(p);
1027
1028         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1029         p->offset = p->rmargin;
1030         p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?
1031             p->maxrmargin - titlen : p->maxrmargin;
1032
1033         term_word(p, buf);
1034         term_flushln(p);
1035
1036         p->flags &= ~TERMP_NOBREAK;
1037         if (p->rmargin + titlen <= p->maxrmargin) {
1038                 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1039                 p->offset = p->rmargin;
1040                 p->rmargin = p->maxrmargin;
1041                 term_word(p, title);
1042                 term_flushln(p);
1043         }
1044
1045         p->rmargin = p->maxrmargin;
1046         p->offset = 0;
1047         p->flags &= ~TERMP_NOSPACE;
1048
1049         /*
1050          * Groff likes to have some leading spaces before content.  Well
1051          * that's fine by me.
1052          */
1053
1054         term_vspace(p);
1055         term_vspace(p);
1056         term_vspace(p);
1057 }