man_term.c

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