man_term.c

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