man_term.c

   1 /*      $Id: man_term.c,v 1.134 2012/07/29 12:35:42 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011, 2012 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 MAXMARGINS        64 /* maximum number of indented scopes */
  37
  38 struct  mtermp {
  39         int               fl;
  40 #define MANT_LITERAL     (1 << 0)
  41         size_t            lmargin[MAXMARGINS]; /* margins (incl. visible page) */
  42         int               lmargincur; /* index of current margin */
  43         int               lmarginsz; /* actual number of nested margins */
  44         size_t            offset; /* default offset to visible page */
  45         int               pardist; /* vert. space before par., unit: [v] */
  46 };
  47
  48 #define DECL_ARGS         struct termp *p, \
  49                           struct mtermp *mt, \
  50                           const struct man_node *n, \
  51                           const struct man_meta *m
  52
  53 struct  termact {
  54         int             (*pre)(DECL_ARGS);
  55         void            (*post)(DECL_ARGS);
  56         int               flags;
  57 #define MAN_NOTEXT       (1 << 0) /* Never has text children. */
  58 };
  59
  60 static  int               a2width(const struct termp *, const char *);
  61 static  size_t            a2height(const struct termp *, const char *);
  62
  63 static  void              print_man_nodelist(DECL_ARGS);
  64 static  void              print_man_node(DECL_ARGS);
  65 static  void              print_man_head(struct termp *, const void *);
  66 static  void              print_man_foot(struct termp *, const void *);
  67 static  void              print_bvspace(struct termp *,
  68                                 const struct man_node *, int);
  69
  70 static  int               pre_B(DECL_ARGS);
  71 static  int               pre_HP(DECL_ARGS);
  72 static  int               pre_I(DECL_ARGS);
  73 static  int               pre_IP(DECL_ARGS);
  74 static  int               pre_OP(DECL_ARGS);
  75 static  int               pre_PD(DECL_ARGS);
  76 static  int               pre_PP(DECL_ARGS);
  77 static  int               pre_RS(DECL_ARGS);
  78 static  int               pre_SH(DECL_ARGS);
  79 static  int               pre_SS(DECL_ARGS);
  80 static  int               pre_TP(DECL_ARGS);
  81 static  int               pre_alternate(DECL_ARGS);
  82 static  int               pre_ft(DECL_ARGS);
  83 static  int               pre_ign(DECL_ARGS);
  84 static  int               pre_in(DECL_ARGS);
  85 static  int               pre_literal(DECL_ARGS);
  86 static  int               pre_sp(DECL_ARGS);
  87
  88 static  void              post_IP(DECL_ARGS);
  89 static  void              post_HP(DECL_ARGS);
  90 static  void              post_RS(DECL_ARGS);
  91 static  void              post_SH(DECL_ARGS);
  92 static  void              post_SS(DECL_ARGS);
  93 static  void              post_TP(DECL_ARGS);
  94
  95 static  const struct termact termacts[MAN_MAX] = {
  96         { pre_sp, NULL, MAN_NOTEXT }, /* br */
  97         { NULL, NULL, 0 }, /* TH */
  98         { pre_SH, post_SH, 0 }, /* SH */
  99         { pre_SS, post_SS, 0 }, /* SS */
 100         { pre_TP, post_TP, 0 }, /* TP */
 101         { pre_PP, NULL, 0 }, /* LP */
 102         { pre_PP, NULL, 0 }, /* PP */
 103         { pre_PP, NULL, 0 }, /* P */
 104         { pre_IP, post_IP, 0 }, /* IP */
 105         { pre_HP, post_HP, 0 }, /* HP */
 106         { NULL, NULL, 0 }, /* SM */
 107         { pre_B, NULL, 0 }, /* SB */
 108         { pre_alternate, NULL, 0 }, /* BI */
 109         { pre_alternate, NULL, 0 }, /* IB */
 110         { pre_alternate, NULL, 0 }, /* BR */
 111         { pre_alternate, NULL, 0 }, /* RB */
 112         { NULL, NULL, 0 }, /* R */
 113         { pre_B, NULL, 0 }, /* B */
 114         { pre_I, NULL, 0 }, /* I */
 115         { pre_alternate, NULL, 0 }, /* IR */
 116         { pre_alternate, NULL, 0 }, /* RI */
 117         { pre_ign, NULL, MAN_NOTEXT }, /* na */
 118         { pre_sp, NULL, MAN_NOTEXT }, /* sp */
 119         { pre_literal, NULL, 0 }, /* nf */
 120         { pre_literal, NULL, 0 }, /* fi */
 121         { NULL, NULL, 0 }, /* RE */
 122         { pre_RS, post_RS, 0 }, /* RS */
 123         { pre_ign, NULL, 0 }, /* DT */
 124         { pre_ign, NULL, 0 }, /* UC */
 125         { pre_PD, NULL, MAN_NOTEXT }, /* PD */
 126         { pre_ign, NULL, 0 }, /* AT */
 127         { pre_in, NULL, MAN_NOTEXT }, /* in */
 128         { pre_ft, NULL, MAN_NOTEXT }, /* ft */
 129         { pre_OP, NULL, 0 }, /* OP */
 130         { pre_literal, NULL, 0 }, /* EX */
 131         { pre_literal, NULL, 0 }, /* EE */
 132 };
 133
 134
 135
 136 void
 137 terminal_man(void *arg, const struct man *man)
 138 {
 139         struct termp            *p;
 140         const struct man_node   *n;
 141         const struct man_meta   *m;
 142         struct mtermp            mt;
 143
 144         p = (struct termp *)arg;
 145
 146         if (0 == p->defindent)
 147                 p->defindent = 7;
 148
 149         p->overstep = 0;
 150         p->maxrmargin = p->defrmargin;
 151         p->tabwidth = term_len(p, 5);
 152
 153         if (NULL == p->symtab)
 154                 p->symtab = mchars_alloc();
 155
 156         n = man_node(man);
 157         m = man_meta(man);
 158
 159         term_begin(p, print_man_head, print_man_foot, m);
 160         p->flags |= TERMP_NOSPACE;
 161
 162         memset(&mt, 0, sizeof(struct mtermp));
 163
 164         mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
 165         mt.offset = term_len(p, p->defindent);
 166         mt.pardist = 1;
 167
 168         if (n->child)
 169                 print_man_nodelist(p, &mt, n->child, m);
 170
 171         term_end(p);
 172 }
 173
 174
 175 static size_t
 176 a2height(const struct termp *p, const char *cp)
 177 {
 178         struct roffsu    su;
 179
 180         if ( ! a2roffsu(cp, &su, SCALE_VS))
 181                 SCALE_VS_INIT(&su, atoi(cp));
 182
 183         return(term_vspan(p, &su));
 184 }
 185
 186
 187 static int
 188 a2width(const struct termp *p, const char *cp)
 189 {
 190         struct roffsu    su;
 191
 192         if ( ! a2roffsu(cp, &su, SCALE_BU))
 193                 return(-1);
 194
 195         return((int)term_hspan(p, &su));
 196 }
 197
 198 /*
 199  * Printing leading vertical space before a block.
 200  * This is used for the paragraph macros.
 201  * The rules are pretty simple, since there's very little nesting going
 202  * on here.  Basically, if we're the first within another block (SS/SH),
 203  * then don't emit vertical space.  If we are (RS), then do.  If not the
 204  * first, print it.
 205  */
 206 static void
 207 print_bvspace(struct termp *p, const struct man_node *n, int pardist)
 208 {
 209         int      i;
 210
 211         term_newln(p);
 212
 213         if (n->body && n->body->child)
 214                 if (MAN_TBL == n->body->child->type)
 215                         return;
 216
 217         if (MAN_ROOT == n->parent->type || MAN_RS != n->parent->tok)
 218                 if (NULL == n->prev)
 219                         return;
 220
 221         for (i = 0; i < pardist; i++)
 222                 term_vspace(p);
 223 }
 224
 225 /* ARGSUSED */
 226 static int
 227 pre_ign(DECL_ARGS)
 228 {
 229
 230         return(0);
 231 }
 232
 233
 234 /* ARGSUSED */
 235 static int
 236 pre_I(DECL_ARGS)
 237 {
 238
 239         term_fontrepl(p, TERMFONT_UNDER);
 240         return(1);
 241 }
 242
 243
 244 /* ARGSUSED */
 245 static int
 246 pre_literal(DECL_ARGS)
 247 {
 248
 249         term_newln(p);
 250
 251         if (MAN_nf == n->tok || MAN_EX == n->tok)
 252                 mt->fl |= MANT_LITERAL;
 253         else
 254                 mt->fl &= ~MANT_LITERAL;
 255
 256         /*
 257          * Unlike .IP and .TP, .HP does not have a HEAD.
 258          * So in case a second call to term_flushln() is needed,
 259          * indentation has to be set up explicitly.
 260          */
 261         if (MAN_HP == n->parent->tok && p->rmargin < p->maxrmargin) {
 262                 p->offset = p->rmargin;
 263                 p->rmargin = p->maxrmargin;
 264                 p->flags &= ~(TERMP_NOBREAK | TERMP_TWOSPACE);
 265                 p->flags |= TERMP_NOSPACE;
 266         }
 267
 268         return(0);
 269 }
 270
 271 /* ARGSUSED */
 272 static int
 273 pre_PD(DECL_ARGS)
 274 {
 275
 276         n = n->child;
 277         if (0 == n) {
 278                 mt->pardist = 1;
 279                 return(0);
 280         }
 281         assert(MAN_TEXT == n->type);
 282         mt->pardist = atoi(n->string);
 283         return(0);
 284 }
 285
 286 /* ARGSUSED */
 287 static int
 288 pre_alternate(DECL_ARGS)
 289 {
 290         enum termfont            font[2];
 291         const struct man_node   *nn;
 292         int                      savelit, i;
 293
 294         switch (n->tok) {
 295         case (MAN_RB):
 296                 font[0] = TERMFONT_NONE;
 297                 font[1] = TERMFONT_BOLD;
 298                 break;
 299         case (MAN_RI):
 300                 font[0] = TERMFONT_NONE;
 301                 font[1] = TERMFONT_UNDER;
 302                 break;
 303         case (MAN_BR):
 304                 font[0] = TERMFONT_BOLD;
 305                 font[1] = TERMFONT_NONE;
 306                 break;
 307         case (MAN_BI):
 308                 font[0] = TERMFONT_BOLD;
 309                 font[1] = TERMFONT_UNDER;
 310                 break;
 311         case (MAN_IR):
 312                 font[0] = TERMFONT_UNDER;
 313                 font[1] = TERMFONT_NONE;
 314                 break;
 315         case (MAN_IB):
 316                 font[0] = TERMFONT_UNDER;
 317                 font[1] = TERMFONT_BOLD;
 318                 break;
 319         default:
 320                 abort();
 321         }
 322
 323         savelit = MANT_LITERAL & mt->fl;
 324         mt->fl &= ~MANT_LITERAL;
 325
 326         for (i = 0, nn = n->child; nn; nn = nn->next, i = 1 - i) {
 327                 term_fontrepl(p, font[i]);
 328                 if (savelit && NULL == nn->next)
 329                         mt->fl |= MANT_LITERAL;
 330                 print_man_node(p, mt, nn, m);
 331                 if (nn->next)
 332                         p->flags |= TERMP_NOSPACE;
 333         }
 334
 335         return(0);
 336 }
 337
 338 /* ARGSUSED */
 339 static int
 340 pre_B(DECL_ARGS)
 341 {
 342
 343         term_fontrepl(p, TERMFONT_BOLD);
 344         return(1);
 345 }
 346
 347 /* ARGSUSED */
 348 static int
 349 pre_OP(DECL_ARGS)
 350 {
 351
 352         term_word(p, "[");
 353         p->flags |= TERMP_NOSPACE;
 354
 355         if (NULL != (n = n->child)) {
 356                 term_fontrepl(p, TERMFONT_BOLD);
 357                 term_word(p, n->string);
 358         }
 359         if (NULL != n && NULL != n->next) {
 360                 term_fontrepl(p, TERMFONT_UNDER);
 361                 term_word(p, n->next->string);
 362         }
 363
 364         term_fontrepl(p, TERMFONT_NONE);
 365         p->flags |= TERMP_NOSPACE;
 366         term_word(p, "]");
 367         return(0);
 368 }
 369
 370 /* ARGSUSED */
 371 static int
 372 pre_ft(DECL_ARGS)
 373 {
 374         const char      *cp;
 375
 376         if (NULL == n->child) {
 377                 term_fontlast(p);
 378                 return(0);
 379         }
 380
 381         cp = n->child->string;
 382         switch (*cp) {
 383         case ('4'):
 384                 /* FALLTHROUGH */
 385         case ('3'):
 386                 /* FALLTHROUGH */
 387         case ('B'):
 388                 term_fontrepl(p, TERMFONT_BOLD);
 389                 break;
 390         case ('2'):
 391                 /* FALLTHROUGH */
 392         case ('I'):
 393                 term_fontrepl(p, TERMFONT_UNDER);
 394                 break;
 395         case ('P'):
 396                 term_fontlast(p);
 397                 break;
 398         case ('1'):
 399                 /* FALLTHROUGH */
 400         case ('C'):
 401                 /* FALLTHROUGH */
 402         case ('R'):
 403                 term_fontrepl(p, TERMFONT_NONE);
 404                 break;
 405         default:
 406                 break;
 407         }
 408         return(0);
 409 }
 410
 411 /* ARGSUSED */
 412 static int
 413 pre_in(DECL_ARGS)
 414 {
 415         int              len, less;
 416         size_t           v;
 417         const char      *cp;
 418
 419         term_newln(p);
 420
 421         if (NULL == n->child) {
 422                 p->offset = mt->offset;
 423                 return(0);
 424         }
 425
 426         cp = n->child->string;
 427         less = 0;
 428
 429         if ('-' == *cp)
 430                 less = -1;
 431         else if ('+' == *cp)
 432                 less = 1;
 433         else
 434                 cp--;
 435
 436         if ((len = a2width(p, ++cp)) < 0)
 437                 return(0);
 438
 439         v = (size_t)len;
 440
 441         if (less < 0)
 442                 p->offset -= p->offset > v ? v : p->offset;
 443         else if (less > 0)
 444                 p->offset += v;
 445         else
 446                 p->offset = v;
 447
 448         /* Don't let this creep beyond the right margin. */
 449
 450         if (p->offset > p->rmargin)
 451                 p->offset = p->rmargin;
 452
 453         return(0);
 454 }
 455
 456
 457 /* ARGSUSED */
 458 static int
 459 pre_sp(DECL_ARGS)
 460 {
 461         char            *s;
 462         size_t           i, len;
 463         int              neg;
 464
 465         if ((NULL == n->prev && n->parent)) {
 466                 switch (n->parent->tok) {
 467                 case (MAN_SH):
 468                         /* FALLTHROUGH */
 469                 case (MAN_SS):
 470                         /* FALLTHROUGH */
 471                 case (MAN_PP):
 472                         /* FALLTHROUGH */
 473                 case (MAN_LP):
 474                         /* FALLTHROUGH */
 475                 case (MAN_P):
 476                         /* FALLTHROUGH */
 477                         return(0);
 478                 default:
 479                         break;
 480                 }
 481         }
 482
 483         neg = 0;
 484         switch (n->tok) {
 485         case (MAN_br):
 486                 len = 0;
 487                 break;
 488         default:
 489                 if (NULL == n->child) {
 490                         len = 1;
 491                         break;
 492                 }
 493                 s = n->child->string;
 494                 if ('-' == *s) {
 495                         neg = 1;
 496                         s++;
 497                 }
 498                 len = a2height(p, s);
 499                 break;
 500         }
 501
 502         if (0 == len)
 503                 term_newln(p);
 504         else if (neg)
 505                 p->skipvsp += len;
 506         else
 507                 for (i = 0; i < len; i++)
 508                         term_vspace(p);
 509
 510         return(0);
 511 }
 512
 513
 514 /* ARGSUSED */
 515 static int
 516 pre_HP(DECL_ARGS)
 517 {
 518         size_t                   len, one;
 519         int                      ival;
 520         const struct man_node   *nn;
 521
 522         switch (n->type) {
 523         case (MAN_BLOCK):
 524                 print_bvspace(p, n, mt->pardist);
 525                 return(1);
 526         case (MAN_BODY):
 527                 break;
 528         default:
 529                 return(0);
 530         }
 531
 532         if ( ! (MANT_LITERAL & mt->fl)) {
 533                 p->flags |= TERMP_NOBREAK;
 534                 p->flags |= TERMP_TWOSPACE;
 535         }
 536
 537         len = mt->lmargin[mt->lmargincur];
 538         ival = -1;
 539
 540         /* Calculate offset. */
 541
 542         if (NULL != (nn = n->parent->head->child))
 543                 if ((ival = a2width(p, nn->string)) >= 0)
 544                         len = (size_t)ival;
 545
 546         one = term_len(p, 1);
 547         if (len < one)
 548                 len = one;
 549
 550         p->offset = mt->offset;
 551         p->rmargin = mt->offset + len;
 552
 553         if (ival >= 0)
 554                 mt->lmargin[mt->lmargincur] = (size_t)ival;
 555
 556         return(1);
 557 }
 558
 559
 560 /* ARGSUSED */
 561 static void
 562 post_HP(DECL_ARGS)
 563 {
 564
 565         switch (n->type) {
 566         case (MAN_BODY):
 567                 term_flushln(p);
 568                 p->flags &= ~TERMP_NOBREAK;
 569                 p->flags &= ~TERMP_TWOSPACE;
 570                 p->offset = mt->offset;
 571                 p->rmargin = p->maxrmargin;
 572                 break;
 573         default:
 574                 break;
 575         }
 576 }
 577
 578
 579 /* ARGSUSED */
 580 static int
 581 pre_PP(DECL_ARGS)
 582 {
 583
 584         switch (n->type) {
 585         case (MAN_BLOCK):
 586                 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
 587                 print_bvspace(p, n, mt->pardist);
 588                 break;
 589         default:
 590                 p->offset = mt->offset;
 591                 break;
 592         }
 593
 594         return(MAN_HEAD != n->type);
 595 }
 596
 597
 598 /* ARGSUSED */
 599 static int
 600 pre_IP(DECL_ARGS)
 601 {
 602         const struct man_node   *nn;
 603         size_t                   len;
 604         int                      savelit, ival;
 605
 606         switch (n->type) {
 607         case (MAN_BODY):
 608                 p->flags |= TERMP_NOSPACE;
 609                 break;
 610         case (MAN_HEAD):
 611                 p->flags |= TERMP_NOBREAK;
 612                 break;
 613         case (MAN_BLOCK):
 614                 print_bvspace(p, n, mt->pardist);
 615                 /* FALLTHROUGH */
 616         default:
 617                 return(1);
 618         }
 619
 620         len = mt->lmargin[mt->lmargincur];
 621         ival = -1;
 622
 623         /* Calculate the offset from the optional second argument. */
 624         if (NULL != (nn = n->parent->head->child))
 625                 if (NULL != (nn = nn->next))
 626                         if ((ival = a2width(p, nn->string)) >= 0)
 627                                 len = (size_t)ival;
 628
 629         switch (n->type) {
 630         case (MAN_HEAD):
 631                 /* Handle zero-width lengths. */
 632                 if (0 == len)
 633                         len = term_len(p, 1);
 634
 635                 p->offset = mt->offset;
 636                 p->rmargin = mt->offset + len;
 637                 if (ival < 0)
 638                         break;
 639
 640                 /* Set the saved left-margin. */
 641                 mt->lmargin[mt->lmargincur] = (size_t)ival;
 642
 643                 savelit = MANT_LITERAL & mt->fl;
 644                 mt->fl &= ~MANT_LITERAL;
 645
 646                 if (n->child)
 647                         print_man_node(p, mt, n->child, m);
 648
 649                 if (savelit)
 650                         mt->fl |= MANT_LITERAL;
 651
 652                 return(0);
 653         case (MAN_BODY):
 654                 p->offset = mt->offset + len;
 655                 p->rmargin = p->maxrmargin;
 656                 break;
 657         default:
 658                 break;
 659         }
 660
 661         return(1);
 662 }
 663
 664
 665 /* ARGSUSED */
 666 static void
 667 post_IP(DECL_ARGS)
 668 {
 669
 670         switch (n->type) {
 671         case (MAN_HEAD):
 672                 term_flushln(p);
 673                 p->flags &= ~TERMP_NOBREAK;
 674                 p->rmargin = p->maxrmargin;
 675                 break;
 676         case (MAN_BODY):
 677                 term_newln(p);
 678                 break;
 679         default:
 680                 break;
 681         }
 682 }
 683
 684
 685 /* ARGSUSED */
 686 static int
 687 pre_TP(DECL_ARGS)
 688 {
 689         const struct man_node   *nn;
 690         size_t                   len;
 691         int                      savelit, ival;
 692
 693         switch (n->type) {
 694         case (MAN_HEAD):
 695                 p->flags |= TERMP_NOBREAK;
 696                 break;
 697         case (MAN_BODY):
 698                 p->flags |= TERMP_NOSPACE;
 699                 break;
 700         case (MAN_BLOCK):
 701                 print_bvspace(p, n, mt->pardist);
 702                 /* FALLTHROUGH */
 703         default:
 704                 return(1);
 705         }
 706
 707         len = (size_t)mt->lmargin[mt->lmargincur];
 708         ival = -1;
 709
 710         /* Calculate offset. */
 711
 712         if (NULL != (nn = n->parent->head->child))
 713                 if (nn->string && nn->parent->line == nn->line)
 714                         if ((ival = a2width(p, nn->string)) >= 0)
 715                                 len = (size_t)ival;
 716
 717         switch (n->type) {
 718         case (MAN_HEAD):
 719                 /* Handle zero-length properly. */
 720                 if (0 == len)
 721                         len = term_len(p, 1);
 722
 723                 p->offset = mt->offset;
 724                 p->rmargin = mt->offset + len;
 725
 726                 savelit = MANT_LITERAL & mt->fl;
 727                 mt->fl &= ~MANT_LITERAL;
 728
 729                 /* Don't print same-line elements. */
 730                 for (nn = n->child; nn; nn = nn->next)
 731                         if (nn->line > n->line)
 732                                 print_man_node(p, mt, nn, m);
 733
 734                 if (savelit)
 735                         mt->fl |= MANT_LITERAL;
 736                 if (ival >= 0)
 737                         mt->lmargin[mt->lmargincur] = (size_t)ival;
 738
 739                 return(0);
 740         case (MAN_BODY):
 741                 p->offset = mt->offset + len;
 742                 p->rmargin = p->maxrmargin;
 743                 p->flags &= ~TERMP_NOBREAK;
 744                 p->flags &= ~TERMP_TWOSPACE;
 745                 break;
 746         default:
 747                 break;
 748         }
 749
 750         return(1);
 751 }
 752
 753
 754 /* ARGSUSED */
 755 static void
 756 post_TP(DECL_ARGS)
 757 {
 758
 759         switch (n->type) {
 760         case (MAN_HEAD):
 761                 term_flushln(p);
 762                 break;
 763         case (MAN_BODY):
 764                 term_newln(p);
 765                 break;
 766         default:
 767                 break;
 768         }
 769 }
 770
 771
 772 /* ARGSUSED */
 773 static int
 774 pre_SS(DECL_ARGS)
 775 {
 776         int      i;
 777
 778         switch (n->type) {
 779         case (MAN_BLOCK):
 780                 mt->fl &= ~MANT_LITERAL;
 781                 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
 782                 mt->offset = term_len(p, p->defindent);
 783                 /* If following a prior empty `SS', no vspace. */
 784                 if (n->prev && MAN_SS == n->prev->tok)
 785                         if (NULL == n->prev->body->child)
 786                                 break;
 787                 if (NULL == n->prev)
 788                         break;
 789                 for (i = 0; i < mt->pardist; i++)
 790                         term_vspace(p);
 791                 break;
 792         case (MAN_HEAD):
 793                 term_fontrepl(p, TERMFONT_BOLD);
 794                 p->offset = term_len(p, 3);
 795                 break;
 796         case (MAN_BODY):
 797                 p->offset = mt->offset;
 798                 break;
 799         default:
 800                 break;
 801         }
 802
 803         return(1);
 804 }
 805
 806
 807 /* ARGSUSED */
 808 static void
 809 post_SS(DECL_ARGS)
 810 {
 811
 812         switch (n->type) {
 813         case (MAN_HEAD):
 814                 term_newln(p);
 815                 break;
 816         case (MAN_BODY):
 817                 term_newln(p);
 818                 break;
 819         default:
 820                 break;
 821         }
 822 }
 823
 824
 825 /* ARGSUSED */
 826 static int
 827 pre_SH(DECL_ARGS)
 828 {
 829         int      i;
 830
 831         switch (n->type) {
 832         case (MAN_BLOCK):
 833                 mt->fl &= ~MANT_LITERAL;
 834                 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
 835                 mt->offset = term_len(p, p->defindent);
 836                 /* If following a prior empty `SH', no vspace. */
 837                 if (n->prev && MAN_SH == n->prev->tok)
 838                         if (NULL == n->prev->body->child)
 839                                 break;
 840                 /* If the first macro, no vspae. */
 841                 if (NULL == n->prev)
 842                         break;
 843                 for (i = 0; i < mt->pardist; i++)
 844                         term_vspace(p);
 845                 break;
 846         case (MAN_HEAD):
 847                 term_fontrepl(p, TERMFONT_BOLD);
 848                 p->offset = 0;
 849                 break;
 850         case (MAN_BODY):
 851                 p->offset = mt->offset;
 852                 break;
 853         default:
 854                 break;
 855         }
 856
 857         return(1);
 858 }
 859
 860
 861 /* ARGSUSED */
 862 static void
 863 post_SH(DECL_ARGS)
 864 {
 865
 866         switch (n->type) {
 867         case (MAN_HEAD):
 868                 term_newln(p);
 869                 break;
 870         case (MAN_BODY):
 871                 term_newln(p);
 872                 break;
 873         default:
 874                 break;
 875         }
 876 }
 877
 878 /* ARGSUSED */
 879 static int
 880 pre_RS(DECL_ARGS)
 881 {
 882         int              ival;
 883         size_t           sz;
 884
 885         switch (n->type) {
 886         case (MAN_BLOCK):
 887                 term_newln(p);
 888                 return(1);
 889         case (MAN_HEAD):
 890                 return(0);
 891         default:
 892                 break;
 893         }
 894
 895         sz = term_len(p, p->defindent);
 896
 897         if (NULL != (n = n->parent->head->child))
 898                 if ((ival = a2width(p, n->string)) >= 0)
 899                         sz = (size_t)ival;
 900
 901         mt->offset += sz;
 902         p->rmargin = p->maxrmargin;
 903         p->offset = mt->offset < p->rmargin ? mt->offset : p->rmargin;
 904
 905         if (++mt->lmarginsz < MAXMARGINS)
 906                 mt->lmargincur = mt->lmarginsz;
 907
 908         mt->lmargin[mt->lmargincur] = mt->lmargin[mt->lmargincur - 1];
 909         return(1);
 910 }
 911
 912 /* ARGSUSED */
 913 static void
 914 post_RS(DECL_ARGS)
 915 {
 916         int              ival;
 917         size_t           sz;
 918
 919         switch (n->type) {
 920         case (MAN_BLOCK):
 921                 return;
 922         case (MAN_HEAD):
 923                 return;
 924         default:
 925                 term_newln(p);
 926                 break;
 927         }
 928
 929         sz = term_len(p, p->defindent);
 930
 931         if (NULL != (n = n->parent->head->child))
 932                 if ((ival = a2width(p, n->string)) >= 0)
 933                         sz = (size_t)ival;
 934
 935         mt->offset = mt->offset < sz ?  0 : mt->offset - sz;
 936         p->offset = mt->offset;
 937
 938         if (--mt->lmarginsz < MAXMARGINS)
 939                 mt->lmargincur = mt->lmarginsz;
 940 }
 941
 942 static void
 943 print_man_node(DECL_ARGS)
 944 {
 945         size_t           rm, rmax;
 946         int              c;
 947
 948         switch (n->type) {
 949         case(MAN_TEXT):
 950                 /*
 951                  * If we have a blank line, output a vertical space.
 952                  * If we have a space as the first character, break
 953                  * before printing the line's data.
 954                  */
 955                 if ('\0' == *n->string) {
 956                         term_vspace(p);
 957                         return;
 958                 } else if (' ' == *n->string && MAN_LINE & n->flags)
 959                         term_newln(p);
 960
 961                 term_word(p, n->string);
 962                 goto out;
 963
 964         case (MAN_EQN):
 965                 term_eqn(p, n->eqn);
 966                 return;
 967         case (MAN_TBL):
 968                 /*
 969                  * Tables are preceded by a newline.  Then process a
 970                  * table line, which will cause line termination,
 971                  */
 972                 if (TBL_SPAN_FIRST & n->span->flags)
 973                         term_newln(p);
 974                 term_tbl(p, n->span);
 975                 return;
 976         default:
 977                 break;
 978         }
 979
 980         if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
 981                 term_fontrepl(p, TERMFONT_NONE);
 982
 983         c = 1;
 984         if (termacts[n->tok].pre)
 985                 c = (*termacts[n->tok].pre)(p, mt, n, m);
 986
 987         if (c && n->child)
 988                 print_man_nodelist(p, mt, n->child, m);
 989
 990         if (termacts[n->tok].post)
 991                 (*termacts[n->tok].post)(p, mt, n, m);
 992         if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
 993                 term_fontrepl(p, TERMFONT_NONE);
 994
 995 out:
 996         /*
 997          * If we're in a literal context, make sure that words
 998          * together on the same line stay together.  This is a
 999          * POST-printing call, so we check the NEXT word.  Since
1000          * -man doesn't have nested macros, we don't need to be
1001          * more specific than this.
1002          */
1003         if (MANT_LITERAL & mt->fl && ! (TERMP_NOBREAK & p->flags) &&
1004             NULL != n->next && n->next->line > n->line) {
1005                 rm = p->rmargin;
1006                 rmax = p->maxrmargin;
1007                 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
1008                 p->flags |= TERMP_NOSPACE;
1009                 if (NULL != n->string && '\0' != *n->string)
1010                         term_flushln(p);
1011                 else
1012                         term_newln(p);
1013                 if (rm < rmax && n->parent->tok == MAN_HP) {
1014                         p->offset = rm;
1015                         p->rmargin = rmax;
1016                 } else
1017                         p->rmargin = rm;
1018                 p->maxrmargin = rmax;
1019         }
1020         if (MAN_EOS & n->flags)
1021                 p->flags |= TERMP_SENTENCE;
1022 }
1023
1024
1025 static void
1026 print_man_nodelist(DECL_ARGS)
1027 {
1028
1029         print_man_node(p, mt, n, m);
1030         if ( ! n->next)
1031                 return;
1032         print_man_nodelist(p, mt, n->next, m);
1033 }
1034
1035
1036 static void
1037 print_man_foot(struct termp *p, const void *arg)
1038 {
1039         char            title[BUFSIZ];
1040         size_t          datelen;
1041         const struct man_meta *meta;
1042
1043         meta = (const struct man_meta *)arg;
1044         assert(meta->title);
1045         assert(meta->msec);
1046         assert(meta->date);
1047
1048         term_fontrepl(p, TERMFONT_NONE);
1049
1050         term_vspace(p);
1051
1052         /*
1053          * Temporary, undocumented option to imitate mdoc(7) output.
1054          * In the bottom right corner, use the source instead of
1055          * the title.
1056          */
1057
1058         if ( ! p->mdocstyle) {
1059                 term_vspace(p);
1060                 term_vspace(p);
1061                 snprintf(title, BUFSIZ, "%s(%s)", meta->title, meta->msec);
1062         } else if (meta->source) {
1063                 strlcpy(title, meta->source, BUFSIZ);
1064         } else {
1065                 title[0] = '\0';
1066         }
1067         datelen = term_strlen(p, meta->date);
1068
1069         /* Bottom left corner: manual source. */
1070
1071         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1072         p->offset = 0;
1073         p->rmargin = (p->maxrmargin - datelen + term_len(p, 1)) / 2;
1074
1075         if (meta->source)
1076                 term_word(p, meta->source);
1077         term_flushln(p);
1078
1079         /* At the bottom in the middle: manual date. */
1080
1081         p->flags |= TERMP_NOSPACE;
1082         p->offset = p->rmargin;
1083         p->rmargin = p->maxrmargin - term_strlen(p, title);
1084         if (p->offset + datelen >= p->rmargin)
1085                 p->rmargin = p->offset + datelen;
1086
1087         term_word(p, meta->date);
1088         term_flushln(p);
1089
1090         /* Bottom right corner: manual title and section. */
1091
1092         p->flags &= ~TERMP_NOBREAK;
1093         p->flags |= TERMP_NOSPACE;
1094         p->offset = p->rmargin;
1095         p->rmargin = p->maxrmargin;
1096
1097         term_word(p, title);
1098         term_flushln(p);
1099 }
1100
1101
1102 static void
1103 print_man_head(struct termp *p, const void *arg)
1104 {
1105         char            buf[BUFSIZ], title[BUFSIZ];
1106         size_t          buflen, titlen;
1107         const struct man_meta *m;
1108
1109         m = (const struct man_meta *)arg;
1110         assert(m->title);
1111         assert(m->msec);
1112
1113         if (m->vol)
1114                 strlcpy(buf, m->vol, BUFSIZ);
1115         else
1116                 buf[0] = '\0';
1117         buflen = term_strlen(p, buf);
1118
1119         /* Top left corner: manual title and section. */
1120
1121         snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
1122         titlen = term_strlen(p, title);
1123
1124         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1125         p->offset = 0;
1126         p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?
1127             (p->maxrmargin -
1128              term_strlen(p, buf) + term_len(p, 1)) / 2 :
1129             p->maxrmargin - buflen;
1130
1131         term_word(p, title);
1132         term_flushln(p);
1133
1134         /* At the top in the middle: manual volume. */
1135
1136         p->flags |= TERMP_NOSPACE;
1137         p->offset = p->rmargin;
1138         p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?
1139             p->maxrmargin - titlen : p->maxrmargin;
1140
1141         term_word(p, buf);
1142         term_flushln(p);
1143
1144         /* Top right corner: title and section, again. */
1145
1146         p->flags &= ~TERMP_NOBREAK;
1147         if (p->rmargin + titlen <= p->maxrmargin) {
1148                 p->flags |= TERMP_NOSPACE;
1149                 p->offset = p->rmargin;
1150                 p->rmargin = p->maxrmargin;
1151                 term_word(p, title);
1152                 term_flushln(p);
1153         }
1154
1155         p->flags &= ~TERMP_NOSPACE;
1156         p->offset = 0;
1157         p->rmargin = p->maxrmargin;
1158
1159         /*
1160          * Groff prints three blank lines before the content.
1161          * Do the same, except in the temporary, undocumented
1162          * mode imitating mdoc(7) output.
1163          */
1164
1165         term_vspace(p);
1166         if ( ! p->mdocstyle) {
1167                 term_vspace(p);
1168                 term_vspace(p);
1169         }
1170 }