contrib/mandoc/mdoc_term.c

   1 /*      $Id: mdoc_term.c,v 1.367 2018/04/11 17:11:13 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2012-2018 Ingo Schwarze <schwarze@openbsd.org>
   5  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include "config.h"
  20
  21 #include <sys/types.h>
  22
  23 #include <assert.h>
  24 #include <ctype.h>
  25 #include <limits.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "mandoc_aux.h"
  32 #include "mandoc.h"
  33 #include "roff.h"
  34 #include "mdoc.h"
  35 #include "out.h"
  36 #include "term.h"
  37 #include "tag.h"
  38 #include "main.h"
  39
  40 struct  termpair {
  41         struct termpair  *ppair;
  42         int               count;
  43 };
  44
  45 #define DECL_ARGS struct termp *p, \
  46                   struct termpair *pair, \
  47                   const struct roff_meta *meta, \
  48                   struct roff_node *n
  49
  50 struct  termact {
  51         int     (*pre)(DECL_ARGS);
  52         void    (*post)(DECL_ARGS);
  53 };
  54
  55 static  int       a2width(const struct termp *, const char *);
  56
  57 static  void      print_bvspace(struct termp *,
  58                         const struct roff_node *,
  59                         const struct roff_node *);
  60 static  void      print_mdoc_node(DECL_ARGS);
  61 static  void      print_mdoc_nodelist(DECL_ARGS);
  62 static  void      print_mdoc_head(struct termp *, const struct roff_meta *);
  63 static  void      print_mdoc_foot(struct termp *, const struct roff_meta *);
  64 static  void      synopsis_pre(struct termp *,
  65                         const struct roff_node *);
  66
  67 static  void      termp____post(DECL_ARGS);
  68 static  void      termp__t_post(DECL_ARGS);
  69 static  void      termp_bd_post(DECL_ARGS);
  70 static  void      termp_bk_post(DECL_ARGS);
  71 static  void      termp_bl_post(DECL_ARGS);
  72 static  void      termp_eo_post(DECL_ARGS);
  73 static  void      termp_fd_post(DECL_ARGS);
  74 static  void      termp_fo_post(DECL_ARGS);
  75 static  void      termp_in_post(DECL_ARGS);
  76 static  void      termp_it_post(DECL_ARGS);
  77 static  void      termp_lb_post(DECL_ARGS);
  78 static  void      termp_nm_post(DECL_ARGS);
  79 static  void      termp_pf_post(DECL_ARGS);
  80 static  void      termp_quote_post(DECL_ARGS);
  81 static  void      termp_sh_post(DECL_ARGS);
  82 static  void      termp_ss_post(DECL_ARGS);
  83 static  void      termp_xx_post(DECL_ARGS);
  84
  85 static  int       termp__a_pre(DECL_ARGS);
  86 static  int       termp__t_pre(DECL_ARGS);
  87 static  int       termp_an_pre(DECL_ARGS);
  88 static  int       termp_ap_pre(DECL_ARGS);
  89 static  int       termp_bd_pre(DECL_ARGS);
  90 static  int       termp_bf_pre(DECL_ARGS);
  91 static  int       termp_bk_pre(DECL_ARGS);
  92 static  int       termp_bl_pre(DECL_ARGS);
  93 static  int       termp_bold_pre(DECL_ARGS);
  94 static  int       termp_cd_pre(DECL_ARGS);
  95 static  int       termp_d1_pre(DECL_ARGS);
  96 static  int       termp_eo_pre(DECL_ARGS);
  97 static  int       termp_em_pre(DECL_ARGS);
  98 static  int       termp_er_pre(DECL_ARGS);
  99 static  int       termp_ex_pre(DECL_ARGS);
 100 static  int       termp_fa_pre(DECL_ARGS);
 101 static  int       termp_fd_pre(DECL_ARGS);
 102 static  int       termp_fl_pre(DECL_ARGS);
 103 static  int       termp_fn_pre(DECL_ARGS);
 104 static  int       termp_fo_pre(DECL_ARGS);
 105 static  int       termp_ft_pre(DECL_ARGS);
 106 static  int       termp_in_pre(DECL_ARGS);
 107 static  int       termp_it_pre(DECL_ARGS);
 108 static  int       termp_li_pre(DECL_ARGS);
 109 static  int       termp_lk_pre(DECL_ARGS);
 110 static  int       termp_nd_pre(DECL_ARGS);
 111 static  int       termp_nm_pre(DECL_ARGS);
 112 static  int       termp_ns_pre(DECL_ARGS);
 113 static  int       termp_quote_pre(DECL_ARGS);
 114 static  int       termp_rs_pre(DECL_ARGS);
 115 static  int       termp_sh_pre(DECL_ARGS);
 116 static  int       termp_skip_pre(DECL_ARGS);
 117 static  int       termp_sm_pre(DECL_ARGS);
 118 static  int       termp_pp_pre(DECL_ARGS);
 119 static  int       termp_ss_pre(DECL_ARGS);
 120 static  int       termp_sy_pre(DECL_ARGS);
 121 static  int       termp_tag_pre(DECL_ARGS);
 122 static  int       termp_under_pre(DECL_ARGS);
 123 static  int       termp_vt_pre(DECL_ARGS);
 124 static  int       termp_xr_pre(DECL_ARGS);
 125 static  int       termp_xx_pre(DECL_ARGS);
 126
 127 static  const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {
 128         { NULL, NULL }, /* Dd */
 129         { NULL, NULL }, /* Dt */
 130         { NULL, NULL }, /* Os */
 131         { termp_sh_pre, termp_sh_post }, /* Sh */
 132         { termp_ss_pre, termp_ss_post }, /* Ss */
 133         { termp_pp_pre, NULL }, /* Pp */
 134         { termp_d1_pre, termp_bl_post }, /* D1 */
 135         { termp_d1_pre, termp_bl_post }, /* Dl */
 136         { termp_bd_pre, termp_bd_post }, /* Bd */
 137         { NULL, NULL }, /* Ed */
 138         { termp_bl_pre, termp_bl_post }, /* Bl */
 139         { NULL, NULL }, /* El */
 140         { termp_it_pre, termp_it_post }, /* It */
 141         { termp_under_pre, NULL }, /* Ad */
 142         { termp_an_pre, NULL }, /* An */
 143         { termp_ap_pre, NULL }, /* Ap */
 144         { termp_under_pre, NULL }, /* Ar */
 145         { termp_cd_pre, NULL }, /* Cd */
 146         { termp_bold_pre, NULL }, /* Cm */
 147         { termp_li_pre, NULL }, /* Dv */
 148         { termp_er_pre, NULL }, /* Er */
 149         { termp_tag_pre, NULL }, /* Ev */
 150         { termp_ex_pre, NULL }, /* Ex */
 151         { termp_fa_pre, NULL }, /* Fa */
 152         { termp_fd_pre, termp_fd_post }, /* Fd */
 153         { termp_fl_pre, NULL }, /* Fl */
 154         { termp_fn_pre, NULL }, /* Fn */
 155         { termp_ft_pre, NULL }, /* Ft */
 156         { termp_bold_pre, NULL }, /* Ic */
 157         { termp_in_pre, termp_in_post }, /* In */
 158         { termp_li_pre, NULL }, /* Li */
 159         { termp_nd_pre, NULL }, /* Nd */
 160         { termp_nm_pre, termp_nm_post }, /* Nm */
 161         { termp_quote_pre, termp_quote_post }, /* Op */
 162         { termp_ft_pre, NULL }, /* Ot */
 163         { termp_under_pre, NULL }, /* Pa */
 164         { termp_ex_pre, NULL }, /* Rv */
 165         { NULL, NULL }, /* St */
 166         { termp_under_pre, NULL }, /* Va */
 167         { termp_vt_pre, NULL }, /* Vt */
 168         { termp_xr_pre, NULL }, /* Xr */
 169         { termp__a_pre, termp____post }, /* %A */
 170         { termp_under_pre, termp____post }, /* %B */
 171         { NULL, termp____post }, /* %D */
 172         { termp_under_pre, termp____post }, /* %I */
 173         { termp_under_pre, termp____post }, /* %J */
 174         { NULL, termp____post }, /* %N */
 175         { NULL, termp____post }, /* %O */
 176         { NULL, termp____post }, /* %P */
 177         { NULL, termp____post }, /* %R */
 178         { termp__t_pre, termp__t_post }, /* %T */
 179         { NULL, termp____post }, /* %V */
 180         { NULL, NULL }, /* Ac */
 181         { termp_quote_pre, termp_quote_post }, /* Ao */
 182         { termp_quote_pre, termp_quote_post }, /* Aq */
 183         { NULL, NULL }, /* At */
 184         { NULL, NULL }, /* Bc */
 185         { termp_bf_pre, NULL }, /* Bf */
 186         { termp_quote_pre, termp_quote_post }, /* Bo */
 187         { termp_quote_pre, termp_quote_post }, /* Bq */
 188         { termp_xx_pre, termp_xx_post }, /* Bsx */
 189         { NULL, NULL }, /* Bx */
 190         { termp_skip_pre, NULL }, /* Db */
 191         { NULL, NULL }, /* Dc */
 192         { termp_quote_pre, termp_quote_post }, /* Do */
 193         { termp_quote_pre, termp_quote_post }, /* Dq */
 194         { NULL, NULL }, /* Ec */ /* FIXME: no space */
 195         { NULL, NULL }, /* Ef */
 196         { termp_em_pre, NULL }, /* Em */
 197         { termp_eo_pre, termp_eo_post }, /* Eo */
 198         { termp_xx_pre, termp_xx_post }, /* Fx */
 199         { termp_bold_pre, NULL }, /* Ms */
 200         { termp_li_pre, NULL }, /* No */
 201         { termp_ns_pre, NULL }, /* Ns */
 202         { termp_xx_pre, termp_xx_post }, /* Nx */
 203         { termp_xx_pre, termp_xx_post }, /* Ox */
 204         { NULL, NULL }, /* Pc */
 205         { NULL, termp_pf_post }, /* Pf */
 206         { termp_quote_pre, termp_quote_post }, /* Po */
 207         { termp_quote_pre, termp_quote_post }, /* Pq */
 208         { NULL, NULL }, /* Qc */
 209         { termp_quote_pre, termp_quote_post }, /* Ql */
 210         { termp_quote_pre, termp_quote_post }, /* Qo */
 211         { termp_quote_pre, termp_quote_post }, /* Qq */
 212         { NULL, NULL }, /* Re */
 213         { termp_rs_pre, NULL }, /* Rs */
 214         { NULL, NULL }, /* Sc */
 215         { termp_quote_pre, termp_quote_post }, /* So */
 216         { termp_quote_pre, termp_quote_post }, /* Sq */
 217         { termp_sm_pre, NULL }, /* Sm */
 218         { termp_under_pre, NULL }, /* Sx */
 219         { termp_sy_pre, NULL }, /* Sy */
 220         { NULL, NULL }, /* Tn */
 221         { termp_xx_pre, termp_xx_post }, /* Ux */
 222         { NULL, NULL }, /* Xc */
 223         { NULL, NULL }, /* Xo */
 224         { termp_fo_pre, termp_fo_post }, /* Fo */
 225         { NULL, NULL }, /* Fc */
 226         { termp_quote_pre, termp_quote_post }, /* Oo */
 227         { NULL, NULL }, /* Oc */
 228         { termp_bk_pre, termp_bk_post }, /* Bk */
 229         { NULL, NULL }, /* Ek */
 230         { NULL, NULL }, /* Bt */
 231         { NULL, NULL }, /* Hf */
 232         { termp_under_pre, NULL }, /* Fr */
 233         { NULL, NULL }, /* Ud */
 234         { NULL, termp_lb_post }, /* Lb */
 235         { termp_pp_pre, NULL }, /* Lp */
 236         { termp_lk_pre, NULL }, /* Lk */
 237         { termp_under_pre, NULL }, /* Mt */
 238         { termp_quote_pre, termp_quote_post }, /* Brq */
 239         { termp_quote_pre, termp_quote_post }, /* Bro */
 240         { NULL, NULL }, /* Brc */
 241         { NULL, termp____post }, /* %C */
 242         { termp_skip_pre, NULL }, /* Es */
 243         { termp_quote_pre, termp_quote_post }, /* En */
 244         { termp_xx_pre, termp_xx_post }, /* Dx */
 245         { NULL, termp____post }, /* %Q */
 246         { NULL, termp____post }, /* %U */
 247         { NULL, NULL }, /* Ta */
 248 };
 249 static  const struct termact *const termacts = __termacts - MDOC_Dd;
 250
 251 static  int      fn_prio;
 252
 253
 254 void
 255 terminal_mdoc(void *arg, const struct roff_man *mdoc)
 256 {
 257         struct roff_node        *n;
 258         struct termp            *p;
 259         size_t                   save_defindent;
 260
 261         p = (struct termp *)arg;
 262         p->tcol->rmargin = p->maxrmargin = p->defrmargin;
 263         term_tab_set(p, NULL);
 264         term_tab_set(p, "T");
 265         term_tab_set(p, ".5i");
 266
 267         n = mdoc->first->child;
 268         if (p->synopsisonly) {
 269                 while (n != NULL) {
 270                         if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {
 271                                 if (n->child->next->child != NULL)
 272                                         print_mdoc_nodelist(p, NULL,
 273                                             &mdoc->meta,
 274                                             n->child->next->child);
 275                                 term_newln(p);
 276                                 break;
 277                         }
 278                         n = n->next;
 279                 }
 280         } else {
 281                 save_defindent = p->defindent;
 282                 if (p->defindent == 0)
 283                         p->defindent = 5;
 284                 term_begin(p, print_mdoc_head, print_mdoc_foot,
 285                     &mdoc->meta);
 286                 while (n != NULL &&
 287                     (n->type == ROFFT_COMMENT ||
 288                      n->flags & NODE_NOPRT))
 289                         n = n->next;
 290                 if (n != NULL) {
 291                         if (n->tok != MDOC_Sh)
 292                                 term_vspace(p);
 293                         print_mdoc_nodelist(p, NULL, &mdoc->meta, n);
 294                 }
 295                 term_end(p);
 296                 p->defindent = save_defindent;
 297         }
 298 }
 299
 300 static void
 301 print_mdoc_nodelist(DECL_ARGS)
 302 {
 303
 304         while (n != NULL) {
 305                 print_mdoc_node(p, pair, meta, n);
 306                 n = n->next;
 307         }
 308 }
 309
 310 static void
 311 print_mdoc_node(DECL_ARGS)
 312 {
 313         int              chld;
 314         struct termpair  npair;
 315         size_t           offset, rmargin;
 316
 317         if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
 318                 return;
 319
 320         chld = 1;
 321         offset = p->tcol->offset;
 322         rmargin = p->tcol->rmargin;
 323         n->flags &= ~NODE_ENDED;
 324         n->prev_font = p->fonti;
 325
 326         memset(&npair, 0, sizeof(struct termpair));
 327         npair.ppair = pair;
 328
 329         /*
 330          * Keeps only work until the end of a line.  If a keep was
 331          * invoked in a prior line, revert it to PREKEEP.
 332          */
 333
 334         if (p->flags & TERMP_KEEP && n->flags & NODE_LINE) {
 335                 p->flags &= ~TERMP_KEEP;
 336                 p->flags |= TERMP_PREKEEP;
 337         }
 338
 339         /*
 340          * After the keep flags have been set up, we may now
 341          * produce output.  Note that some pre-handlers do so.
 342          */
 343
 344         switch (n->type) {
 345         case ROFFT_TEXT:
 346                 if (*n->string == ' ' && n->flags & NODE_LINE &&
 347                     (p->flags & TERMP_NONEWLINE) == 0)
 348                         term_newln(p);
 349                 if (NODE_DELIMC & n->flags)
 350                         p->flags |= TERMP_NOSPACE;
 351                 term_word(p, n->string);
 352                 if (NODE_DELIMO & n->flags)
 353                         p->flags |= TERMP_NOSPACE;
 354                 break;
 355         case ROFFT_EQN:
 356                 if ( ! (n->flags & NODE_LINE))
 357                         p->flags |= TERMP_NOSPACE;
 358                 term_eqn(p, n->eqn);
 359                 if (n->next != NULL && ! (n->next->flags & NODE_LINE))
 360                         p->flags |= TERMP_NOSPACE;
 361                 break;
 362         case ROFFT_TBL:
 363                 if (p->tbl.cols == NULL)
 364                         term_newln(p);
 365                 term_tbl(p, n->span);
 366                 break;
 367         default:
 368                 if (n->tok < ROFF_MAX) {
 369                         roff_term_pre(p, n);
 370                         return;
 371                 }
 372                 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
 373                 if (termacts[n->tok].pre != NULL &&
 374                     (n->end == ENDBODY_NOT || n->child != NULL))
 375                         chld = (*termacts[n->tok].pre)
 376                                 (p, &npair, meta, n);
 377                 break;
 378         }
 379
 380         if (chld && n->child)
 381                 print_mdoc_nodelist(p, &npair, meta, n->child);
 382
 383         term_fontpopq(p,
 384             (ENDBODY_NOT == n->end ? n : n->body)->prev_font);
 385
 386         switch (n->type) {
 387         case ROFFT_TEXT:
 388                 break;
 389         case ROFFT_TBL:
 390                 break;
 391         case ROFFT_EQN:
 392                 break;
 393         default:
 394                 if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED)
 395                         break;
 396                 (void)(*termacts[n->tok].post)(p, &npair, meta, n);
 397
 398                 /*
 399                  * Explicit end tokens not only call the post
 400                  * handler, but also tell the respective block
 401                  * that it must not call the post handler again.
 402                  */
 403                 if (ENDBODY_NOT != n->end)
 404                         n->body->flags |= NODE_ENDED;
 405                 break;
 406         }
 407
 408         if (NODE_EOS & n->flags)
 409                 p->flags |= TERMP_SENTENCE;
 410
 411         if (n->type != ROFFT_TEXT)
 412                 p->tcol->offset = offset;
 413         p->tcol->rmargin = rmargin;
 414 }
 415
 416 static void
 417 print_mdoc_foot(struct termp *p, const struct roff_meta *meta)
 418 {
 419         size_t sz;
 420
 421         term_fontrepl(p, TERMFONT_NONE);
 422
 423         /*
 424          * Output the footer in new-groff style, that is, three columns
 425          * with the middle being the manual date and flanking columns
 426          * being the operating system:
 427          *
 428          * SYSTEM                  DATE                    SYSTEM
 429          */
 430
 431         term_vspace(p);
 432
 433         p->tcol->offset = 0;
 434         sz = term_strlen(p, meta->date);
 435         p->tcol->rmargin = p->maxrmargin > sz ?
 436             (p->maxrmargin + term_len(p, 1) - sz) / 2 : 0;
 437         p->trailspace = 1;
 438         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
 439
 440         term_word(p, meta->os);
 441         term_flushln(p);
 442
 443         p->tcol->offset = p->tcol->rmargin;
 444         sz = term_strlen(p, meta->os);
 445         p->tcol->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;
 446         p->flags |= TERMP_NOSPACE;
 447
 448         term_word(p, meta->date);
 449         term_flushln(p);
 450
 451         p->tcol->offset = p->tcol->rmargin;
 452         p->tcol->rmargin = p->maxrmargin;
 453         p->trailspace = 0;
 454         p->flags &= ~TERMP_NOBREAK;
 455         p->flags |= TERMP_NOSPACE;
 456
 457         term_word(p, meta->os);
 458         term_flushln(p);
 459
 460         p->tcol->offset = 0;
 461         p->tcol->rmargin = p->maxrmargin;
 462         p->flags = 0;
 463 }
 464
 465 static void
 466 print_mdoc_head(struct termp *p, const struct roff_meta *meta)
 467 {
 468         char                    *volume, *title;
 469         size_t                   vollen, titlen;
 470
 471         /*
 472          * The header is strange.  It has three components, which are
 473          * really two with the first duplicated.  It goes like this:
 474          *
 475          * IDENTIFIER              TITLE                   IDENTIFIER
 476          *
 477          * The IDENTIFIER is NAME(SECTION), which is the command-name
 478          * (if given, or "unknown" if not) followed by the manual page
 479          * section.  These are given in `Dt'.  The TITLE is a free-form
 480          * string depending on the manual volume.  If not specified, it
 481          * switches on the manual section.
 482          */
 483
 484         assert(meta->vol);
 485         if (NULL == meta->arch)
 486                 volume = mandoc_strdup(meta->vol);
 487         else
 488                 mandoc_asprintf(&volume, "%s (%s)",
 489                     meta->vol, meta->arch);
 490         vollen = term_strlen(p, volume);
 491
 492         if (NULL == meta->msec)
 493                 title = mandoc_strdup(meta->title);
 494         else
 495                 mandoc_asprintf(&title, "%s(%s)",
 496                     meta->title, meta->msec);
 497         titlen = term_strlen(p, title);
 498
 499         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
 500         p->trailspace = 1;
 501         p->tcol->offset = 0;
 502         p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
 503             (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
 504             vollen < p->maxrmargin ?  p->maxrmargin - vollen : 0;
 505
 506         term_word(p, title);
 507         term_flushln(p);
 508
 509         p->flags |= TERMP_NOSPACE;
 510         p->tcol->offset = p->tcol->rmargin;
 511         p->tcol->rmargin = p->tcol->offset + vollen + titlen <
 512             p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;
 513
 514         term_word(p, volume);
 515         term_flushln(p);
 516
 517         p->flags &= ~TERMP_NOBREAK;
 518         p->trailspace = 0;
 519         if (p->tcol->rmargin + titlen <= p->maxrmargin) {
 520                 p->flags |= TERMP_NOSPACE;
 521                 p->tcol->offset = p->tcol->rmargin;
 522                 p->tcol->rmargin = p->maxrmargin;
 523                 term_word(p, title);
 524                 term_flushln(p);
 525         }
 526
 527         p->flags &= ~TERMP_NOSPACE;
 528         p->tcol->offset = 0;
 529         p->tcol->rmargin = p->maxrmargin;
 530         free(title);
 531         free(volume);
 532 }
 533
 534 static int
 535 a2width(const struct termp *p, const char *v)
 536 {
 537         struct roffsu    su;
 538         const char      *end;
 539
 540         end = a2roffsu(v, &su, SCALE_MAX);
 541         if (end == NULL || *end != '\0') {
 542                 SCALE_HS_INIT(&su, term_strlen(p, v));
 543                 su.scale /= term_strlen(p, "0");
 544         }
 545         return term_hen(p, &su);
 546 }
 547
 548 /*
 549  * Determine how much space to print out before block elements of `It'
 550  * (and thus `Bl') and `Bd'.  And then go ahead and print that space,
 551  * too.
 552  */
 553 static void
 554 print_bvspace(struct termp *p,
 555         const struct roff_node *bl,
 556         const struct roff_node *n)
 557 {
 558         const struct roff_node  *nn;
 559
 560         assert(n);
 561
 562         term_newln(p);
 563
 564         if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)
 565                 return;
 566         if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)
 567                 return;
 568
 569         /* Do not vspace directly after Ss/Sh. */
 570
 571         nn = n;
 572         while (nn->prev != NULL &&
 573             (nn->prev->type == ROFFT_COMMENT ||
 574              nn->prev->flags & NODE_NOPRT))
 575                 nn = nn->prev;
 576         while (nn->prev == NULL) {
 577                 do {
 578                         nn = nn->parent;
 579                         if (nn->type == ROFFT_ROOT)
 580                                 return;
 581                 } while (nn->type != ROFFT_BLOCK);
 582                 if (nn->tok == MDOC_Sh || nn->tok == MDOC_Ss)
 583                         return;
 584                 if (nn->tok == MDOC_It &&
 585                     nn->parent->parent->norm->Bl.type != LIST_item)
 586                         break;
 587         }
 588
 589         /* A `-column' does not assert vspace within the list. */
 590
 591         if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)
 592                 if (n->prev && MDOC_It == n->prev->tok)
 593                         return;
 594
 595         /* A `-diag' without body does not vspace. */
 596
 597         if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)
 598                 if (n->prev && MDOC_It == n->prev->tok) {
 599                         assert(n->prev->body);
 600                         if (NULL == n->prev->body->child)
 601                                 return;
 602                 }
 603
 604         term_vspace(p);
 605 }
 606
 607
 608 static int
 609 termp_it_pre(DECL_ARGS)
 610 {
 611         struct roffsu           su;
 612         char                    buf[24];
 613         const struct roff_node *bl, *nn;
 614         size_t                  ncols, dcol;
 615         int                     i, offset, width;
 616         enum mdoc_list          type;
 617
 618         if (n->type == ROFFT_BLOCK) {
 619                 print_bvspace(p, n->parent->parent, n);
 620                 return 1;
 621         }
 622
 623         bl = n->parent->parent->parent;
 624         type = bl->norm->Bl.type;
 625
 626         /*
 627          * Defaults for specific list types.
 628          */
 629
 630         switch (type) {
 631         case LIST_bullet:
 632         case LIST_dash:
 633         case LIST_hyphen:
 634         case LIST_enum:
 635                 width = term_len(p, 2);
 636                 break;
 637         case LIST_hang:
 638         case LIST_tag:
 639                 width = term_len(p, 8);
 640                 break;
 641         case LIST_column:
 642                 width = term_len(p, 10);
 643                 break;
 644         default:
 645                 width = 0;
 646                 break;
 647         }
 648         offset = 0;
 649
 650         /*
 651          * First calculate width and offset.  This is pretty easy unless
 652          * we're a -column list, in which case all prior columns must
 653          * be accounted for.
 654          */
 655
 656         if (bl->norm->Bl.offs != NULL) {
 657                 offset = a2width(p, bl->norm->Bl.offs);
 658                 if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
 659                         offset = -p->tcol->offset;
 660                 else if (offset > SHRT_MAX)
 661                         offset = 0;
 662         }
 663
 664         switch (type) {
 665         case LIST_column:
 666                 if (n->type == ROFFT_HEAD)
 667                         break;
 668
 669                 /*
 670                  * Imitate groff's column handling:
 671                  * - For each earlier column, add its width.
 672                  * - For less than 5 columns, add four more blanks per
 673                  *   column.
 674                  * - For exactly 5 columns, add three more blank per
 675                  *   column.
 676                  * - For more than 5 columns, add only one column.
 677                  */
 678                 ncols = bl->norm->Bl.ncols;
 679                 dcol = ncols < 5 ? term_len(p, 4) :
 680                     ncols == 5 ? term_len(p, 3) : term_len(p, 1);
 681
 682                 /*
 683                  * Calculate the offset by applying all prior ROFFT_BODY,
 684                  * so we stop at the ROFFT_HEAD (nn->prev == NULL).
 685                  */
 686
 687                 for (i = 0, nn = n->prev;
 688                     nn->prev && i < (int)ncols;
 689                     nn = nn->prev, i++) {
 690                         SCALE_HS_INIT(&su,
 691                             term_strlen(p, bl->norm->Bl.cols[i]));
 692                         su.scale /= term_strlen(p, "0");
 693                         offset += term_hen(p, &su) + dcol;
 694                 }
 695
 696                 /*
 697                  * When exceeding the declared number of columns, leave
 698                  * the remaining widths at 0.  This will later be
 699                  * adjusted to the default width of 10, or, for the last
 700                  * column, stretched to the right margin.
 701                  */
 702                 if (i >= (int)ncols)
 703                         break;
 704
 705                 /*
 706                  * Use the declared column widths, extended as explained
 707                  * in the preceding paragraph.
 708                  */
 709                 SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i]));
 710                 su.scale /= term_strlen(p, "0");
 711                 width = term_hen(p, &su) + dcol;
 712                 break;
 713         default:
 714                 if (NULL == bl->norm->Bl.width)
 715                         break;
 716
 717                 /*
 718                  * Note: buffer the width by 2, which is groff's magic
 719                  * number for buffering single arguments.  See the above
 720                  * handling for column for how this changes.
 721                  */
 722                 width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);
 723                 if (width < 0 && (size_t)(-width) > p->tcol->offset)
 724                         width = -p->tcol->offset;
 725                 else if (width > SHRT_MAX)
 726                         width = 0;
 727                 break;
 728         }
 729
 730         /*
 731          * Whitespace control.  Inset bodies need an initial space,
 732          * while diagonal bodies need two.
 733          */
 734
 735         p->flags |= TERMP_NOSPACE;
 736
 737         switch (type) {
 738         case LIST_diag:
 739                 if (n->type == ROFFT_BODY)
 740                         term_word(p, "\\ \\ ");
 741                 break;
 742         case LIST_inset:
 743                 if (n->type == ROFFT_BODY && n->parent->head->child != NULL)
 744                         term_word(p, "\\ ");
 745                 break;
 746         default:
 747                 break;
 748         }
 749
 750         p->flags |= TERMP_NOSPACE;
 751
 752         switch (type) {
 753         case LIST_diag:
 754                 if (n->type == ROFFT_HEAD)
 755                         term_fontpush(p, TERMFONT_BOLD);
 756                 break;
 757         default:
 758                 break;
 759         }
 760
 761         /*
 762          * Pad and break control.  This is the tricky part.  These flags
 763          * are documented in term_flushln() in term.c.  Note that we're
 764          * going to unset all of these flags in termp_it_post() when we
 765          * exit.
 766          */
 767
 768         switch (type) {
 769         case LIST_enum:
 770         case LIST_bullet:
 771         case LIST_dash:
 772         case LIST_hyphen:
 773                 if (n->type == ROFFT_HEAD) {
 774                         p->flags |= TERMP_NOBREAK | TERMP_HANG;
 775                         p->trailspace = 1;
 776                 } else if (width <= (int)term_len(p, 2))
 777                         p->flags |= TERMP_NOPAD;
 778                 break;
 779         case LIST_hang:
 780                 if (n->type != ROFFT_HEAD)
 781                         break;
 782                 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;
 783                 p->trailspace = 1;
 784                 break;
 785         case LIST_tag:
 786                 if (n->type != ROFFT_HEAD)
 787                         break;
 788
 789                 p->flags |= TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND;
 790                 p->trailspace = 2;
 791
 792                 if (NULL == n->next || NULL == n->next->child)
 793                         p->flags |= TERMP_HANG;
 794                 break;
 795         case LIST_column:
 796                 if (n->type == ROFFT_HEAD)
 797                         break;
 798
 799                 if (NULL == n->next) {
 800                         p->flags &= ~TERMP_NOBREAK;
 801                         p->trailspace = 0;
 802                 } else {
 803                         p->flags |= TERMP_NOBREAK;
 804                         p->trailspace = 1;
 805                 }
 806
 807                 break;
 808         case LIST_diag:
 809                 if (n->type != ROFFT_HEAD)
 810                         break;
 811                 p->flags |= TERMP_NOBREAK | TERMP_BRIND;
 812                 p->trailspace = 1;
 813                 break;
 814         default:
 815                 break;
 816         }
 817
 818         /*
 819          * Margin control.  Set-head-width lists have their right
 820          * margins shortened.  The body for these lists has the offset
 821          * necessarily lengthened.  Everybody gets the offset.
 822          */
 823
 824         p->tcol->offset += offset;
 825
 826         switch (type) {
 827         case LIST_bullet:
 828         case LIST_dash:
 829         case LIST_enum:
 830         case LIST_hyphen:
 831         case LIST_hang:
 832         case LIST_tag:
 833                 if (n->type == ROFFT_HEAD)
 834                         p->tcol->rmargin = p->tcol->offset + width;
 835                 else
 836                         p->tcol->offset += width;
 837                 break;
 838         case LIST_column:
 839                 assert(width);
 840                 p->tcol->rmargin = p->tcol->offset + width;
 841                 /*
 842                  * XXX - this behaviour is not documented: the
 843                  * right-most column is filled to the right margin.
 844                  */
 845                 if (n->type == ROFFT_HEAD)
 846                         break;
 847                 if (n->next == NULL && p->tcol->rmargin < p->maxrmargin)
 848                         p->tcol->rmargin = p->maxrmargin;
 849                 break;
 850         default:
 851                 break;
 852         }
 853
 854         /*
 855          * The dash, hyphen, bullet and enum lists all have a special
 856          * HEAD character (temporarily bold, in some cases).
 857          */
 858
 859         if (n->type == ROFFT_HEAD)
 860                 switch (type) {
 861                 case LIST_bullet:
 862                         term_fontpush(p, TERMFONT_BOLD);
 863                         term_word(p, "\\[bu]");
 864                         term_fontpop(p);
 865                         break;
 866                 case LIST_dash:
 867                 case LIST_hyphen:
 868                         term_fontpush(p, TERMFONT_BOLD);
 869                         term_word(p, "-");
 870                         term_fontpop(p);
 871                         break;
 872                 case LIST_enum:
 873                         (pair->ppair->ppair->count)++;
 874                         (void)snprintf(buf, sizeof(buf), "%d.",
 875                             pair->ppair->ppair->count);
 876                         term_word(p, buf);
 877                         break;
 878                 default:
 879                         break;
 880                 }
 881
 882         /*
 883          * If we're not going to process our children, indicate so here.
 884          */
 885
 886         switch (type) {
 887         case LIST_bullet:
 888         case LIST_item:
 889         case LIST_dash:
 890         case LIST_hyphen:
 891         case LIST_enum:
 892                 if (n->type == ROFFT_HEAD)
 893                         return 0;
 894                 break;
 895         case LIST_column:
 896                 if (n->type == ROFFT_HEAD)
 897                         return 0;
 898                 p->minbl = 0;
 899                 break;
 900         default:
 901                 break;
 902         }
 903
 904         return 1;
 905 }
 906
 907 static void
 908 termp_it_post(DECL_ARGS)
 909 {
 910         enum mdoc_list     type;
 911
 912         if (n->type == ROFFT_BLOCK)
 913                 return;
 914
 915         type = n->parent->parent->parent->norm->Bl.type;
 916
 917         switch (type) {
 918         case LIST_item:
 919         case LIST_diag:
 920         case LIST_inset:
 921                 if (n->type == ROFFT_BODY)
 922                         term_newln(p);
 923                 break;
 924         case LIST_column:
 925                 if (n->type == ROFFT_BODY)
 926                         term_flushln(p);
 927                 break;
 928         default:
 929                 term_newln(p);
 930                 break;
 931         }
 932
 933         /*
 934          * Now that our output is flushed, we can reset our tags.  Since
 935          * only `It' sets these flags, we're free to assume that nobody
 936          * has munged them in the meanwhile.
 937          */
 938
 939         p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND | TERMP_HANG);
 940         p->trailspace = 0;
 941 }
 942
 943 static int
 944 termp_nm_pre(DECL_ARGS)
 945 {
 946         const char      *cp;
 947
 948         if (n->type == ROFFT_BLOCK) {
 949                 p->flags |= TERMP_PREKEEP;
 950                 return 1;
 951         }
 952
 953         if (n->type == ROFFT_BODY) {
 954                 if (n->child == NULL)
 955                         return 0;
 956                 p->flags |= TERMP_NOSPACE;
 957                 cp = NULL;
 958                 if (n->prev->child != NULL)
 959                     cp = n->prev->child->string;
 960                 if (cp == NULL)
 961                         cp = meta->name;
 962                 if (cp == NULL)
 963                         p->tcol->offset += term_len(p, 6);
 964                 else
 965                         p->tcol->offset += term_len(p, 1) +
 966                             term_strlen(p, cp);
 967                 return 1;
 968         }
 969
 970         if (n->child == NULL)
 971                 return 0;
 972
 973         if (n->type == ROFFT_HEAD)
 974                 synopsis_pre(p, n->parent);
 975
 976         if (n->type == ROFFT_HEAD &&
 977             n->next != NULL && n->next->child != NULL) {
 978                 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND;
 979                 p->trailspace = 1;
 980                 p->tcol->rmargin = p->tcol->offset + term_len(p, 1);
 981                 if (n->child == NULL)
 982                         p->tcol->rmargin += term_strlen(p, meta->name);
 983                 else if (n->child->type == ROFFT_TEXT) {
 984                         p->tcol->rmargin += term_strlen(p, n->child->string);
 985                         if (n->child->next != NULL)
 986                                 p->flags |= TERMP_HANG;
 987                 } else {
 988                         p->tcol->rmargin += term_len(p, 5);
 989                         p->flags |= TERMP_HANG;
 990                 }
 991         }
 992
 993         term_fontpush(p, TERMFONT_BOLD);
 994         return 1;
 995 }
 996
 997 static void
 998 termp_nm_post(DECL_ARGS)
 999 {
1000
1001         if (n->type == ROFFT_BLOCK) {
1002                 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
1003         } else if (n->type == ROFFT_HEAD &&
1004             NULL != n->next && NULL != n->next->child) {
1005                 term_flushln(p);
1006                 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);
1007                 p->trailspace = 0;
1008         } else if (n->type == ROFFT_BODY && n->child != NULL)
1009                 term_flushln(p);
1010 }
1011
1012 static int
1013 termp_fl_pre(DECL_ARGS)
1014 {
1015
1016         termp_tag_pre(p, pair, meta, n);
1017         term_fontpush(p, TERMFONT_BOLD);
1018         term_word(p, "\\-");
1019
1020         if (!(n->child == NULL &&
1021             (n->next == NULL ||
1022              n->next->type == ROFFT_TEXT ||
1023              n->next->flags & NODE_LINE)))
1024                 p->flags |= TERMP_NOSPACE;
1025
1026         return 1;
1027 }
1028
1029 static int
1030 termp__a_pre(DECL_ARGS)
1031 {
1032
1033         if (n->prev && MDOC__A == n->prev->tok)
1034                 if (NULL == n->next || MDOC__A != n->next->tok)
1035                         term_word(p, "and");
1036
1037         return 1;
1038 }
1039
1040 static int
1041 termp_an_pre(DECL_ARGS)
1042 {
1043
1044         if (n->norm->An.auth == AUTH_split) {
1045                 p->flags &= ~TERMP_NOSPLIT;
1046                 p->flags |= TERMP_SPLIT;
1047                 return 0;
1048         }
1049         if (n->norm->An.auth == AUTH_nosplit) {
1050                 p->flags &= ~TERMP_SPLIT;
1051                 p->flags |= TERMP_NOSPLIT;
1052                 return 0;
1053         }
1054
1055         if (p->flags & TERMP_SPLIT)
1056                 term_newln(p);
1057
1058         if (n->sec == SEC_AUTHORS && ! (p->flags & TERMP_NOSPLIT))
1059                 p->flags |= TERMP_SPLIT;
1060
1061         return 1;
1062 }
1063
1064 static int
1065 termp_ns_pre(DECL_ARGS)
1066 {
1067
1068         if ( ! (NODE_LINE & n->flags))
1069                 p->flags |= TERMP_NOSPACE;
1070         return 1;
1071 }
1072
1073 static int
1074 termp_rs_pre(DECL_ARGS)
1075 {
1076
1077         if (SEC_SEE_ALSO != n->sec)
1078                 return 1;
1079         if (n->type == ROFFT_BLOCK && n->prev != NULL)
1080                 term_vspace(p);
1081         return 1;
1082 }
1083
1084 static int
1085 termp_ex_pre(DECL_ARGS)
1086 {
1087         term_newln(p);
1088         return 1;
1089 }
1090
1091 static int
1092 termp_nd_pre(DECL_ARGS)
1093 {
1094
1095         if (n->type == ROFFT_BODY)
1096                 term_word(p, "\\(en");
1097         return 1;
1098 }
1099
1100 static int
1101 termp_bl_pre(DECL_ARGS)
1102 {
1103
1104         return n->type != ROFFT_HEAD;
1105 }
1106
1107 static void
1108 termp_bl_post(DECL_ARGS)
1109 {
1110
1111         if (n->type != ROFFT_BLOCK)
1112                 return;
1113         term_newln(p);
1114         if (n->tok != MDOC_Bl || n->norm->Bl.type != LIST_column)
1115                 return;
1116         term_tab_set(p, NULL);
1117         term_tab_set(p, "T");
1118         term_tab_set(p, ".5i");
1119 }
1120
1121 static int
1122 termp_xr_pre(DECL_ARGS)
1123 {
1124
1125         if (NULL == (n = n->child))
1126                 return 0;
1127
1128         assert(n->type == ROFFT_TEXT);
1129         term_word(p, n->string);
1130
1131         if (NULL == (n = n->next))
1132                 return 0;
1133
1134         p->flags |= TERMP_NOSPACE;
1135         term_word(p, "(");
1136         p->flags |= TERMP_NOSPACE;
1137
1138         assert(n->type == ROFFT_TEXT);
1139         term_word(p, n->string);
1140
1141         p->flags |= TERMP_NOSPACE;
1142         term_word(p, ")");
1143
1144         return 0;
1145 }
1146
1147 /*
1148  * This decides how to assert whitespace before any of the SYNOPSIS set
1149  * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain
1150  * macro combos).
1151  */
1152 static void
1153 synopsis_pre(struct termp *p, const struct roff_node *n)
1154 {
1155         /*
1156          * Obviously, if we're not in a SYNOPSIS or no prior macros
1157          * exist, do nothing.
1158          */
1159         if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))
1160                 return;
1161
1162         /*
1163          * If we're the second in a pair of like elements, emit our
1164          * newline and return.  UNLESS we're `Fo', `Fn', `Fn', in which
1165          * case we soldier on.
1166          */
1167         if (n->prev->tok == n->tok &&
1168             MDOC_Ft != n->tok &&
1169             MDOC_Fo != n->tok &&
1170             MDOC_Fn != n->tok) {
1171                 term_newln(p);
1172                 return;
1173         }
1174
1175         /*
1176          * If we're one of the SYNOPSIS set and non-like pair-wise after
1177          * another (or Fn/Fo, which we've let slip through) then assert
1178          * vertical space, else only newline and move on.
1179          */
1180         switch (n->prev->tok) {
1181         case MDOC_Fd:
1182         case MDOC_Fn:
1183         case MDOC_Fo:
1184         case MDOC_In:
1185         case MDOC_Vt:
1186                 term_vspace(p);
1187                 break;
1188         case MDOC_Ft:
1189                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
1190                         term_vspace(p);
1191                         break;
1192                 }
1193                 /* FALLTHROUGH */
1194         default:
1195                 term_newln(p);
1196                 break;
1197         }
1198 }
1199
1200 static int
1201 termp_vt_pre(DECL_ARGS)
1202 {
1203
1204         if (n->type == ROFFT_ELEM) {
1205                 synopsis_pre(p, n);
1206                 return termp_under_pre(p, pair, meta, n);
1207         } else if (n->type == ROFFT_BLOCK) {
1208                 synopsis_pre(p, n);
1209                 return 1;
1210         } else if (n->type == ROFFT_HEAD)
1211                 return 0;
1212
1213         return termp_under_pre(p, pair, meta, n);
1214 }
1215
1216 static int
1217 termp_bold_pre(DECL_ARGS)
1218 {
1219
1220         termp_tag_pre(p, pair, meta, n);
1221         term_fontpush(p, TERMFONT_BOLD);
1222         return 1;
1223 }
1224
1225 static int
1226 termp_fd_pre(DECL_ARGS)
1227 {
1228
1229         synopsis_pre(p, n);
1230         return termp_bold_pre(p, pair, meta, n);
1231 }
1232
1233 static void
1234 termp_fd_post(DECL_ARGS)
1235 {
1236
1237         term_newln(p);
1238 }
1239
1240 static int
1241 termp_sh_pre(DECL_ARGS)
1242 {
1243
1244         switch (n->type) {
1245         case ROFFT_BLOCK:
1246                 /*
1247                  * Vertical space before sections, except
1248                  * when the previous section was empty.
1249                  */
1250                 if (n->prev == NULL ||
1251                     n->prev->tok != MDOC_Sh ||
1252                     (n->prev->body != NULL &&
1253                      n->prev->body->child != NULL))
1254                         term_vspace(p);
1255                 break;
1256         case ROFFT_HEAD:
1257                 term_fontpush(p, TERMFONT_BOLD);
1258                 break;
1259         case ROFFT_BODY:
1260                 p->tcol->offset = term_len(p, p->defindent);
1261                 term_tab_set(p, NULL);
1262                 term_tab_set(p, "T");
1263                 term_tab_set(p, ".5i");
1264                 switch (n->sec) {
1265                 case SEC_DESCRIPTION:
1266                         fn_prio = 0;
1267                         break;
1268                 case SEC_AUTHORS:
1269                         p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);
1270                         break;
1271                 default:
1272                         break;
1273                 }
1274                 break;
1275         default:
1276                 break;
1277         }
1278         return 1;
1279 }
1280
1281 static void
1282 termp_sh_post(DECL_ARGS)
1283 {
1284
1285         switch (n->type) {
1286         case ROFFT_HEAD:
1287                 term_newln(p);
1288                 break;
1289         case ROFFT_BODY:
1290                 term_newln(p);
1291                 p->tcol->offset = 0;
1292                 break;
1293         default:
1294                 break;
1295         }
1296 }
1297
1298 static void
1299 termp_lb_post(DECL_ARGS)
1300 {
1301
1302         if (SEC_LIBRARY == n->sec && NODE_LINE & n->flags)
1303                 term_newln(p);
1304 }
1305
1306 static int
1307 termp_d1_pre(DECL_ARGS)
1308 {
1309
1310         if (n->type != ROFFT_BLOCK)
1311                 return 1;
1312         term_newln(p);
1313         p->tcol->offset += term_len(p, p->defindent + 1);
1314         term_tab_set(p, NULL);
1315         term_tab_set(p, "T");
1316         term_tab_set(p, ".5i");
1317         return 1;
1318 }
1319
1320 static int
1321 termp_ft_pre(DECL_ARGS)
1322 {
1323
1324         /* NB: NODE_LINE does not effect this! */
1325         synopsis_pre(p, n);
1326         term_fontpush(p, TERMFONT_UNDER);
1327         return 1;
1328 }
1329
1330 static int
1331 termp_fn_pre(DECL_ARGS)
1332 {
1333         size_t           rmargin = 0;
1334         int              pretty;
1335
1336         pretty = NODE_SYNPRETTY & n->flags;
1337
1338         synopsis_pre(p, n);
1339
1340         if (NULL == (n = n->child))
1341                 return 0;
1342
1343         if (pretty) {
1344                 rmargin = p->tcol->rmargin;
1345                 p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
1346                 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;
1347         }
1348
1349         assert(n->type == ROFFT_TEXT);
1350         term_fontpush(p, TERMFONT_BOLD);
1351         term_word(p, n->string);
1352         term_fontpop(p);
1353
1354         if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)
1355                 tag_put(n->string, ++fn_prio, p->line);
1356
1357         if (pretty) {
1358                 term_flushln(p);
1359                 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);
1360                 p->flags |= TERMP_NOPAD;
1361                 p->tcol->offset = p->tcol->rmargin;
1362                 p->tcol->rmargin = rmargin;
1363         }
1364
1365         p->flags |= TERMP_NOSPACE;
1366         term_word(p, "(");
1367         p->flags |= TERMP_NOSPACE;
1368
1369         for (n = n->next; n; n = n->next) {
1370                 assert(n->type == ROFFT_TEXT);
1371                 term_fontpush(p, TERMFONT_UNDER);
1372                 if (pretty)
1373                         p->flags |= TERMP_NBRWORD;
1374                 term_word(p, n->string);
1375                 term_fontpop(p);
1376
1377                 if (n->next) {
1378                         p->flags |= TERMP_NOSPACE;
1379                         term_word(p, ",");
1380                 }
1381         }
1382
1383         p->flags |= TERMP_NOSPACE;
1384         term_word(p, ")");
1385
1386         if (pretty) {
1387                 p->flags |= TERMP_NOSPACE;
1388                 term_word(p, ";");
1389                 term_flushln(p);
1390         }
1391
1392         return 0;
1393 }
1394
1395 static int
1396 termp_fa_pre(DECL_ARGS)
1397 {
1398         const struct roff_node  *nn;
1399
1400         if (n->parent->tok != MDOC_Fo) {
1401                 term_fontpush(p, TERMFONT_UNDER);
1402                 return 1;
1403         }
1404
1405         for (nn = n->child; nn; nn = nn->next) {
1406                 term_fontpush(p, TERMFONT_UNDER);
1407                 p->flags |= TERMP_NBRWORD;
1408                 term_word(p, nn->string);
1409                 term_fontpop(p);
1410
1411                 if (nn->next || (n->next && n->next->tok == MDOC_Fa)) {
1412                         p->flags |= TERMP_NOSPACE;
1413                         term_word(p, ",");
1414                 }
1415         }
1416
1417         return 0;
1418 }
1419
1420 static int
1421 termp_bd_pre(DECL_ARGS)
1422 {
1423         size_t                   lm, len;
1424         struct roff_node        *nn;
1425         int                      offset;
1426
1427         if (n->type == ROFFT_BLOCK) {
1428                 print_bvspace(p, n, n);
1429                 return 1;
1430         } else if (n->type == ROFFT_HEAD)
1431                 return 0;
1432
1433         /* Handle the -offset argument. */
1434
1435         if (n->norm->Bd.offs == NULL ||
1436             ! strcmp(n->norm->Bd.offs, "left"))
1437                 /* nothing */;
1438         else if ( ! strcmp(n->norm->Bd.offs, "indent"))
1439                 p->tcol->offset += term_len(p, p->defindent + 1);
1440         else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))
1441                 p->tcol->offset += term_len(p, (p->defindent + 1) * 2);
1442         else {
1443                 offset = a2width(p, n->norm->Bd.offs);
1444                 if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
1445                         p->tcol->offset = 0;
1446                 else if (offset < SHRT_MAX)
1447                         p->tcol->offset += offset;
1448         }
1449
1450         /*
1451          * If -ragged or -filled are specified, the block does nothing
1452          * but change the indentation.  If -unfilled or -literal are
1453          * specified, text is printed exactly as entered in the display:
1454          * for macro lines, a newline is appended to the line.  Blank
1455          * lines are allowed.
1456          */
1457
1458         if (n->norm->Bd.type != DISP_literal &&
1459             n->norm->Bd.type != DISP_unfilled &&
1460             n->norm->Bd.type != DISP_centered)
1461                 return 1;
1462
1463         if (n->norm->Bd.type == DISP_literal) {
1464                 term_tab_set(p, NULL);
1465                 term_tab_set(p, "T");
1466                 term_tab_set(p, "8n");
1467         }
1468
1469         lm = p->tcol->offset;
1470         p->flags |= TERMP_BRNEVER;
1471         for (nn = n->child; nn != NULL; nn = nn->next) {
1472                 if (n->norm->Bd.type == DISP_centered) {
1473                         if (nn->type == ROFFT_TEXT) {
1474                                 len = term_strlen(p, nn->string);
1475                                 p->tcol->offset = len >= p->tcol->rmargin ?
1476                                     0 : lm + len >= p->tcol->rmargin ?
1477                                     p->tcol->rmargin - len :
1478                                     (lm + p->tcol->rmargin - len) / 2;
1479                         } else
1480                                 p->tcol->offset = lm;
1481                 }
1482                 print_mdoc_node(p, pair, meta, nn);
1483                 /*
1484                  * If the printed node flushes its own line, then we
1485                  * needn't do it here as well.  This is hacky, but the
1486                  * notion of selective eoln whitespace is pretty dumb
1487                  * anyway, so don't sweat it.
1488                  */
1489                 if (nn->tok < ROFF_MAX)
1490                         continue;
1491                 switch (nn->tok) {
1492                 case MDOC_Sm:
1493                 case MDOC_Bl:
1494                 case MDOC_D1:
1495                 case MDOC_Dl:
1496                 case MDOC_Lp:
1497                 case MDOC_Pp:
1498                         continue;
1499                 default:
1500                         break;
1501                 }
1502                 if (p->flags & TERMP_NONEWLINE ||
1503                     (nn->next && ! (nn->next->flags & NODE_LINE)))
1504                         continue;
1505                 term_flushln(p);
1506                 p->flags |= TERMP_NOSPACE;
1507         }
1508         p->flags &= ~TERMP_BRNEVER;
1509         return 0;
1510 }
1511
1512 static void
1513 termp_bd_post(DECL_ARGS)
1514 {
1515         if (n->type != ROFFT_BODY)
1516                 return;
1517         if (DISP_literal == n->norm->Bd.type ||
1518             DISP_unfilled == n->norm->Bd.type)
1519                 p->flags |= TERMP_BRNEVER;
1520         p->flags |= TERMP_NOSPACE;
1521         term_newln(p);
1522         p->flags &= ~TERMP_BRNEVER;
1523 }
1524
1525 static int
1526 termp_xx_pre(DECL_ARGS)
1527 {
1528         if ((n->aux = p->flags & TERMP_PREKEEP) == 0)
1529                 p->flags |= TERMP_PREKEEP;
1530         return 1;
1531 }
1532
1533 static void
1534 termp_xx_post(DECL_ARGS)
1535 {
1536         if (n->aux == 0)
1537                 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
1538 }
1539
1540 static void
1541 termp_pf_post(DECL_ARGS)
1542 {
1543
1544         if ( ! (n->next == NULL || n->next->flags & NODE_LINE))
1545                 p->flags |= TERMP_NOSPACE;
1546 }
1547
1548 static int
1549 termp_ss_pre(DECL_ARGS)
1550 {
1551         struct roff_node *nn;
1552
1553         switch (n->type) {
1554         case ROFFT_BLOCK:
1555                 term_newln(p);
1556                 for (nn = n->prev; nn != NULL; nn = nn->prev)
1557                         if (nn->type != ROFFT_COMMENT &&
1558                             (nn->flags & NODE_NOPRT) == 0)
1559                                 break;
1560                 if (nn != NULL)
1561                         term_vspace(p);
1562                 break;
1563         case ROFFT_HEAD:
1564                 term_fontpush(p, TERMFONT_BOLD);
1565                 p->tcol->offset = term_len(p, (p->defindent+1)/2);
1566                 break;
1567         case ROFFT_BODY:
1568                 p->tcol->offset = term_len(p, p->defindent);
1569                 term_tab_set(p, NULL);
1570                 term_tab_set(p, "T");
1571                 term_tab_set(p, ".5i");
1572                 break;
1573         default:
1574                 break;
1575         }
1576
1577         return 1;
1578 }
1579
1580 static void
1581 termp_ss_post(DECL_ARGS)
1582 {
1583
1584         if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY)
1585                 term_newln(p);
1586 }
1587
1588 static int
1589 termp_cd_pre(DECL_ARGS)
1590 {
1591
1592         synopsis_pre(p, n);
1593         term_fontpush(p, TERMFONT_BOLD);
1594         return 1;
1595 }
1596
1597 static int
1598 termp_in_pre(DECL_ARGS)
1599 {
1600
1601         synopsis_pre(p, n);
1602
1603         if (NODE_SYNPRETTY & n->flags && NODE_LINE & n->flags) {
1604                 term_fontpush(p, TERMFONT_BOLD);
1605                 term_word(p, "#include");
1606                 term_word(p, "<");
1607         } else {
1608                 term_word(p, "<");
1609                 term_fontpush(p, TERMFONT_UNDER);
1610         }
1611
1612         p->flags |= TERMP_NOSPACE;
1613         return 1;
1614 }
1615
1616 static void
1617 termp_in_post(DECL_ARGS)
1618 {
1619
1620         if (NODE_SYNPRETTY & n->flags)
1621                 term_fontpush(p, TERMFONT_BOLD);
1622
1623         p->flags |= TERMP_NOSPACE;
1624         term_word(p, ">");
1625
1626         if (NODE_SYNPRETTY & n->flags)
1627                 term_fontpop(p);
1628 }
1629
1630 static int
1631 termp_pp_pre(DECL_ARGS)
1632 {
1633         fn_prio = 0;
1634         term_vspace(p);
1635         return 0;
1636 }
1637
1638 static int
1639 termp_skip_pre(DECL_ARGS)
1640 {
1641
1642         return 0;
1643 }
1644
1645 static int
1646 termp_quote_pre(DECL_ARGS)
1647 {
1648
1649         if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM)
1650                 return 1;
1651
1652         switch (n->tok) {
1653         case MDOC_Ao:
1654         case MDOC_Aq:
1655                 term_word(p, n->child != NULL && n->child->next == NULL &&
1656                     n->child->tok == MDOC_Mt ? "<" : "\\(la");
1657                 break;
1658         case MDOC_Bro:
1659         case MDOC_Brq:
1660                 term_word(p, "{");
1661                 break;
1662         case MDOC_Oo:
1663         case MDOC_Op:
1664         case MDOC_Bo:
1665         case MDOC_Bq:
1666                 term_word(p, "[");
1667                 break;
1668         case MDOC__T:
1669                 /* FALLTHROUGH */
1670         case MDOC_Do:
1671         case MDOC_Dq:
1672                 term_word(p, "\\(lq");
1673                 break;
1674         case MDOC_En:
1675                 if (NULL == n->norm->Es ||
1676                     NULL == n->norm->Es->child)
1677                         return 1;
1678                 term_word(p, n->norm->Es->child->string);
1679                 break;
1680         case MDOC_Po:
1681         case MDOC_Pq:
1682                 term_word(p, "(");
1683                 break;
1684         case MDOC_Qo:
1685         case MDOC_Qq:
1686                 term_word(p, "\"");
1687                 break;
1688         case MDOC_Ql:
1689         case MDOC_So:
1690         case MDOC_Sq:
1691                 term_word(p, "\\(oq");
1692                 break;
1693         default:
1694                 abort();
1695         }
1696
1697         p->flags |= TERMP_NOSPACE;
1698         return 1;
1699 }
1700
1701 static void
1702 termp_quote_post(DECL_ARGS)
1703 {
1704
1705         if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM)
1706                 return;
1707
1708         p->flags |= TERMP_NOSPACE;
1709
1710         switch (n->tok) {
1711         case MDOC_Ao:
1712         case MDOC_Aq:
1713                 term_word(p, n->child != NULL && n->child->next == NULL &&
1714                     n->child->tok == MDOC_Mt ? ">" : "\\(ra");
1715                 break;
1716         case MDOC_Bro:
1717         case MDOC_Brq:
1718                 term_word(p, "}");
1719                 break;
1720         case MDOC_Oo:
1721         case MDOC_Op:
1722         case MDOC_Bo:
1723         case MDOC_Bq:
1724                 term_word(p, "]");
1725                 break;
1726         case MDOC__T:
1727                 /* FALLTHROUGH */
1728         case MDOC_Do:
1729         case MDOC_Dq:
1730                 term_word(p, "\\(rq");
1731                 break;
1732         case MDOC_En:
1733                 if (n->norm->Es == NULL ||
1734                     n->norm->Es->child == NULL ||
1735                     n->norm->Es->child->next == NULL)
1736                         p->flags &= ~TERMP_NOSPACE;
1737                 else
1738                         term_word(p, n->norm->Es->child->next->string);
1739                 break;
1740         case MDOC_Po:
1741         case MDOC_Pq:
1742                 term_word(p, ")");
1743                 break;
1744         case MDOC_Qo:
1745         case MDOC_Qq:
1746                 term_word(p, "\"");
1747                 break;
1748         case MDOC_Ql:
1749         case MDOC_So:
1750         case MDOC_Sq:
1751                 term_word(p, "\\(cq");
1752                 break;
1753         default:
1754                 abort();
1755         }
1756 }
1757
1758 static int
1759 termp_eo_pre(DECL_ARGS)
1760 {
1761
1762         if (n->type != ROFFT_BODY)
1763                 return 1;
1764
1765         if (n->end == ENDBODY_NOT &&
1766             n->parent->head->child == NULL &&
1767             n->child != NULL &&
1768             n->child->end != ENDBODY_NOT)
1769                 term_word(p, "\\&");
1770         else if (n->end != ENDBODY_NOT ? n->child != NULL :
1771              n->parent->head->child != NULL && (n->child != NULL ||
1772              (n->parent->tail != NULL && n->parent->tail->child != NULL)))
1773                 p->flags |= TERMP_NOSPACE;
1774
1775         return 1;
1776 }
1777
1778 static void
1779 termp_eo_post(DECL_ARGS)
1780 {
1781         int      body, tail;
1782
1783         if (n->type != ROFFT_BODY)
1784                 return;
1785
1786         if (n->end != ENDBODY_NOT) {
1787                 p->flags &= ~TERMP_NOSPACE;
1788                 return;
1789         }
1790
1791         body = n->child != NULL || n->parent->head->child != NULL;
1792         tail = n->parent->tail != NULL && n->parent->tail->child != NULL;
1793
1794         if (body && tail)
1795                 p->flags |= TERMP_NOSPACE;
1796         else if ( ! (body || tail))
1797                 term_word(p, "\\&");
1798         else if ( ! tail)
1799                 p->flags &= ~TERMP_NOSPACE;
1800 }
1801
1802 static int
1803 termp_fo_pre(DECL_ARGS)
1804 {
1805         size_t           rmargin = 0;
1806         int              pretty;
1807
1808         pretty = NODE_SYNPRETTY & n->flags;
1809
1810         if (n->type == ROFFT_BLOCK) {
1811                 synopsis_pre(p, n);
1812                 return 1;
1813         } else if (n->type == ROFFT_BODY) {
1814                 if (pretty) {
1815                         rmargin = p->tcol->rmargin;
1816                         p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
1817                         p->flags |= TERMP_NOBREAK | TERMP_BRIND |
1818                                         TERMP_HANG;
1819                 }
1820                 p->flags |= TERMP_NOSPACE;
1821                 term_word(p, "(");
1822                 p->flags |= TERMP_NOSPACE;
1823                 if (pretty) {
1824                         term_flushln(p);
1825                         p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND |
1826                                         TERMP_HANG);
1827                         p->flags |= TERMP_NOPAD;
1828                         p->tcol->offset = p->tcol->rmargin;
1829                         p->tcol->rmargin = rmargin;
1830                 }
1831                 return 1;
1832         }
1833
1834         if (NULL == n->child)
1835                 return 0;
1836
1837         /* XXX: we drop non-initial arguments as per groff. */
1838
1839         assert(n->child->string);
1840         term_fontpush(p, TERMFONT_BOLD);
1841         term_word(p, n->child->string);
1842         return 0;
1843 }
1844
1845 static void
1846 termp_fo_post(DECL_ARGS)
1847 {
1848
1849         if (n->type != ROFFT_BODY)
1850                 return;
1851
1852         p->flags |= TERMP_NOSPACE;
1853         term_word(p, ")");
1854
1855         if (NODE_SYNPRETTY & n->flags) {
1856                 p->flags |= TERMP_NOSPACE;
1857                 term_word(p, ";");
1858                 term_flushln(p);
1859         }
1860 }
1861
1862 static int
1863 termp_bf_pre(DECL_ARGS)
1864 {
1865
1866         if (n->type == ROFFT_HEAD)
1867                 return 0;
1868         else if (n->type != ROFFT_BODY)
1869                 return 1;
1870
1871         if (FONT_Em == n->norm->Bf.font)
1872                 term_fontpush(p, TERMFONT_UNDER);
1873         else if (FONT_Sy == n->norm->Bf.font)
1874                 term_fontpush(p, TERMFONT_BOLD);
1875         else
1876                 term_fontpush(p, TERMFONT_NONE);
1877
1878         return 1;
1879 }
1880
1881 static int
1882 termp_sm_pre(DECL_ARGS)
1883 {
1884
1885         if (NULL == n->child)
1886                 p->flags ^= TERMP_NONOSPACE;
1887         else if (0 == strcmp("on", n->child->string))
1888                 p->flags &= ~TERMP_NONOSPACE;
1889         else
1890                 p->flags |= TERMP_NONOSPACE;
1891
1892         if (p->col && ! (TERMP_NONOSPACE & p->flags))
1893                 p->flags &= ~TERMP_NOSPACE;
1894
1895         return 0;
1896 }
1897
1898 static int
1899 termp_ap_pre(DECL_ARGS)
1900 {
1901
1902         p->flags |= TERMP_NOSPACE;
1903         term_word(p, "'");
1904         p->flags |= TERMP_NOSPACE;
1905         return 1;
1906 }
1907
1908 static void
1909 termp____post(DECL_ARGS)
1910 {
1911
1912         /*
1913          * Handle lists of authors.  In general, print each followed by
1914          * a comma.  Don't print the comma if there are only two
1915          * authors.
1916          */
1917         if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)
1918                 if (NULL == n->next->next || MDOC__A != n->next->next->tok)
1919                         if (NULL == n->prev || MDOC__A != n->prev->tok)
1920                                 return;
1921
1922         /* TODO: %U. */
1923
1924         if (NULL == n->parent || MDOC_Rs != n->parent->tok)
1925                 return;
1926
1927         p->flags |= TERMP_NOSPACE;
1928         if (NULL == n->next) {
1929                 term_word(p, ".");
1930                 p->flags |= TERMP_SENTENCE;
1931         } else
1932                 term_word(p, ",");
1933 }
1934
1935 static int
1936 termp_li_pre(DECL_ARGS)
1937 {
1938
1939         termp_tag_pre(p, pair, meta, n);
1940         term_fontpush(p, TERMFONT_NONE);
1941         return 1;
1942 }
1943
1944 static int
1945 termp_lk_pre(DECL_ARGS)
1946 {
1947         const struct roff_node *link, *descr, *punct;
1948
1949         if ((link = n->child) == NULL)
1950                 return 0;
1951
1952         /* Find beginning of trailing punctuation. */
1953         punct = n->last;
1954         while (punct != link && punct->flags & NODE_DELIMC)
1955                 punct = punct->prev;
1956         punct = punct->next;
1957
1958         /* Link text. */
1959         if ((descr = link->next) != NULL && descr != punct) {
1960                 term_fontpush(p, TERMFONT_UNDER);
1961                 while (descr != punct) {
1962                         if (descr->flags & (NODE_DELIMC | NODE_DELIMO))
1963                                 p->flags |= TERMP_NOSPACE;
1964                         term_word(p, descr->string);
1965                         descr = descr->next;
1966                 }
1967                 term_fontpop(p);
1968                 p->flags |= TERMP_NOSPACE;
1969                 term_word(p, ":");
1970         }
1971
1972         /* Link target. */
1973         term_fontpush(p, TERMFONT_BOLD);
1974         term_word(p, link->string);
1975         term_fontpop(p);
1976
1977         /* Trailing punctuation. */
1978         while (punct != NULL) {
1979                 p->flags |= TERMP_NOSPACE;
1980                 term_word(p, punct->string);
1981                 punct = punct->next;
1982         }
1983         return 0;
1984 }
1985
1986 static int
1987 termp_bk_pre(DECL_ARGS)
1988 {
1989
1990         switch (n->type) {
1991         case ROFFT_BLOCK:
1992                 break;
1993         case ROFFT_HEAD:
1994                 return 0;
1995         case ROFFT_BODY:
1996                 if (n->parent->args != NULL || n->prev->child == NULL)
1997                         p->flags |= TERMP_PREKEEP;
1998                 break;
1999         default:
2000                 abort();
2001         }
2002
2003         return 1;
2004 }
2005
2006 static void
2007 termp_bk_post(DECL_ARGS)
2008 {
2009
2010         if (n->type == ROFFT_BODY)
2011                 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
2012 }
2013
2014 static void
2015 termp__t_post(DECL_ARGS)
2016 {
2017
2018         /*
2019          * If we're in an `Rs' and there's a journal present, then quote
2020          * us instead of underlining us (for disambiguation).
2021          */
2022         if (n->parent && MDOC_Rs == n->parent->tok &&
2023             n->parent->norm->Rs.quote_T)
2024                 termp_quote_post(p, pair, meta, n);
2025
2026         termp____post(p, pair, meta, n);
2027 }
2028
2029 static int
2030 termp__t_pre(DECL_ARGS)
2031 {
2032
2033         /*
2034          * If we're in an `Rs' and there's a journal present, then quote
2035          * us instead of underlining us (for disambiguation).
2036          */
2037         if (n->parent && MDOC_Rs == n->parent->tok &&
2038             n->parent->norm->Rs.quote_T)
2039                 return termp_quote_pre(p, pair, meta, n);
2040
2041         term_fontpush(p, TERMFONT_UNDER);
2042         return 1;
2043 }
2044
2045 static int
2046 termp_under_pre(DECL_ARGS)
2047 {
2048
2049         term_fontpush(p, TERMFONT_UNDER);
2050         return 1;
2051 }
2052
2053 static int
2054 termp_em_pre(DECL_ARGS)
2055 {
2056         if (n->child != NULL &&
2057             n->child->type == ROFFT_TEXT)
2058                 tag_put(n->child->string, 0, p->line);
2059         term_fontpush(p, TERMFONT_UNDER);
2060         return 1;
2061 }
2062
2063 static int
2064 termp_sy_pre(DECL_ARGS)
2065 {
2066         if (n->child != NULL &&
2067             n->child->type == ROFFT_TEXT)
2068                 tag_put(n->child->string, 0, p->line);
2069         term_fontpush(p, TERMFONT_BOLD);
2070         return 1;
2071 }
2072
2073 static int
2074 termp_er_pre(DECL_ARGS)
2075 {
2076
2077         if (n->sec == SEC_ERRORS &&
2078             (n->parent->tok == MDOC_It ||
2079              (n->parent->tok == MDOC_Bq &&
2080               n->parent->parent->parent->tok == MDOC_It)))
2081                 tag_put(n->child->string, 1, p->line);
2082         return 1;
2083 }
2084
2085 static int
2086 termp_tag_pre(DECL_ARGS)
2087 {
2088
2089         if (n->child != NULL &&
2090             n->child->type == ROFFT_TEXT &&
2091             (n->prev == NULL ||
2092              (n->prev->type == ROFFT_TEXT &&
2093               strcmp(n->prev->string, "|") == 0)) &&
2094             (n->parent->tok == MDOC_It ||
2095              (n->parent->tok == MDOC_Xo &&
2096               n->parent->parent->prev == NULL &&
2097               n->parent->parent->parent->tok == MDOC_It)))
2098                 tag_put(n->child->string, 1, p->line);
2099         return 1;
2100 }