contrib/mandoc/man_term.c

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