contrib/mdocml/mdoc_man.c

   1 /*      $Id: mdoc_man.c,v 1.132 2019/01/04 03:17:36 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2011-2019 Ingo Schwarze <schwarze@openbsd.org>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 #include "config.h"
  18
  19 #include <sys/types.h>
  20
  21 #include <assert.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "mandoc_aux.h"
  27 #include "mandoc.h"
  28 #include "roff.h"
  29 #include "mdoc.h"
  30 #include "man.h"
  31 #include "out.h"
  32 #include "main.h"
  33
  34 #define DECL_ARGS const struct roff_meta *meta, struct roff_node *n
  35
  36 typedef int     (*int_fp)(DECL_ARGS);
  37 typedef void    (*void_fp)(DECL_ARGS);
  38
  39 struct  mdoc_man_act {
  40         int_fp            cond; /* DON'T run actions */
  41         int_fp            pre; /* pre-node action */
  42         void_fp           post; /* post-node action */
  43         const char       *prefix; /* pre-node string constant */
  44         const char       *suffix; /* post-node string constant */
  45 };
  46
  47 static  int       cond_body(DECL_ARGS);
  48 static  int       cond_head(DECL_ARGS);
  49 static  void      font_push(char);
  50 static  void      font_pop(void);
  51 static  int       man_strlen(const char *);
  52 static  void      mid_it(void);
  53 static  void      post__t(DECL_ARGS);
  54 static  void      post_aq(DECL_ARGS);
  55 static  void      post_bd(DECL_ARGS);
  56 static  void      post_bf(DECL_ARGS);
  57 static  void      post_bk(DECL_ARGS);
  58 static  void      post_bl(DECL_ARGS);
  59 static  void      post_dl(DECL_ARGS);
  60 static  void      post_en(DECL_ARGS);
  61 static  void      post_enc(DECL_ARGS);
  62 static  void      post_eo(DECL_ARGS);
  63 static  void      post_fa(DECL_ARGS);
  64 static  void      post_fd(DECL_ARGS);
  65 static  void      post_fl(DECL_ARGS);
  66 static  void      post_fn(DECL_ARGS);
  67 static  void      post_fo(DECL_ARGS);
  68 static  void      post_font(DECL_ARGS);
  69 static  void      post_in(DECL_ARGS);
  70 static  void      post_it(DECL_ARGS);
  71 static  void      post_lb(DECL_ARGS);
  72 static  void      post_nm(DECL_ARGS);
  73 static  void      post_percent(DECL_ARGS);
  74 static  void      post_pf(DECL_ARGS);
  75 static  void      post_sect(DECL_ARGS);
  76 static  void      post_vt(DECL_ARGS);
  77 static  int       pre__t(DECL_ARGS);
  78 static  int       pre_abort(DECL_ARGS);
  79 static  int       pre_an(DECL_ARGS);
  80 static  int       pre_ap(DECL_ARGS);
  81 static  int       pre_aq(DECL_ARGS);
  82 static  int       pre_bd(DECL_ARGS);
  83 static  int       pre_bf(DECL_ARGS);
  84 static  int       pre_bk(DECL_ARGS);
  85 static  int       pre_bl(DECL_ARGS);
  86 static  void      pre_br(DECL_ARGS);
  87 static  int       pre_dl(DECL_ARGS);
  88 static  int       pre_en(DECL_ARGS);
  89 static  int       pre_enc(DECL_ARGS);
  90 static  int       pre_em(DECL_ARGS);
  91 static  int       pre_skip(DECL_ARGS);
  92 static  int       pre_eo(DECL_ARGS);
  93 static  int       pre_ex(DECL_ARGS);
  94 static  int       pre_fa(DECL_ARGS);
  95 static  int       pre_fd(DECL_ARGS);
  96 static  int       pre_fl(DECL_ARGS);
  97 static  int       pre_fn(DECL_ARGS);
  98 static  int       pre_fo(DECL_ARGS);
  99 static  void      pre_ft(DECL_ARGS);
 100 static  int       pre_Ft(DECL_ARGS);
 101 static  int       pre_in(DECL_ARGS);
 102 static  int       pre_it(DECL_ARGS);
 103 static  int       pre_lk(DECL_ARGS);
 104 static  int       pre_li(DECL_ARGS);
 105 static  int       pre_nm(DECL_ARGS);
 106 static  int       pre_no(DECL_ARGS);
 107 static  void      pre_noarg(DECL_ARGS);
 108 static  int       pre_ns(DECL_ARGS);
 109 static  void      pre_onearg(DECL_ARGS);
 110 static  int       pre_pp(DECL_ARGS);
 111 static  int       pre_rs(DECL_ARGS);
 112 static  int       pre_sm(DECL_ARGS);
 113 static  void      pre_sp(DECL_ARGS);
 114 static  int       pre_sect(DECL_ARGS);
 115 static  int       pre_sy(DECL_ARGS);
 116 static  void      pre_syn(const struct roff_node *);
 117 static  void      pre_ta(DECL_ARGS);
 118 static  int       pre_vt(DECL_ARGS);
 119 static  int       pre_xr(DECL_ARGS);
 120 static  void      print_word(const char *);
 121 static  void      print_line(const char *, int);
 122 static  void      print_block(const char *, int);
 123 static  void      print_offs(const char *, int);
 124 static  void      print_width(const struct mdoc_bl *,
 125                         const struct roff_node *);
 126 static  void      print_count(int *);
 127 static  void      print_node(DECL_ARGS);
 128
 129 static const void_fp roff_man_acts[ROFF_MAX] = {
 130         pre_br,         /* br */
 131         pre_onearg,     /* ce */
 132         pre_noarg,      /* fi */
 133         pre_ft,         /* ft */
 134         pre_onearg,     /* ll */
 135         pre_onearg,     /* mc */
 136         pre_noarg,      /* nf */
 137         pre_onearg,     /* po */
 138         pre_onearg,     /* rj */
 139         pre_sp,         /* sp */
 140         pre_ta,         /* ta */
 141         pre_onearg,     /* ti */
 142 };
 143
 144 static const struct mdoc_man_act mdoc_man_acts[MDOC_MAX - MDOC_Dd] = {
 145         { NULL, NULL, NULL, NULL, NULL }, /* Dd */
 146         { NULL, NULL, NULL, NULL, NULL }, /* Dt */
 147         { NULL, NULL, NULL, NULL, NULL }, /* Os */
 148         { NULL, pre_sect, post_sect, ".SH", NULL }, /* Sh */
 149         { NULL, pre_sect, post_sect, ".SS", NULL }, /* Ss */
 150         { NULL, pre_pp, NULL, NULL, NULL }, /* Pp */
 151         { cond_body, pre_dl, post_dl, NULL, NULL }, /* D1 */
 152         { cond_body, pre_dl, post_dl, NULL, NULL }, /* Dl */
 153         { cond_body, pre_bd, post_bd, NULL, NULL }, /* Bd */
 154         { NULL, NULL, NULL, NULL, NULL }, /* Ed */
 155         { cond_body, pre_bl, post_bl, NULL, NULL }, /* Bl */
 156         { NULL, NULL, NULL, NULL, NULL }, /* El */
 157         { NULL, pre_it, post_it, NULL, NULL }, /* It */
 158         { NULL, pre_em, post_font, NULL, NULL }, /* Ad */
 159         { NULL, pre_an, NULL, NULL, NULL }, /* An */
 160         { NULL, pre_ap, NULL, NULL, NULL }, /* Ap */
 161         { NULL, pre_em, post_font, NULL, NULL }, /* Ar */
 162         { NULL, pre_sy, post_font, NULL, NULL }, /* Cd */
 163         { NULL, pre_sy, post_font, NULL, NULL }, /* Cm */
 164         { NULL, pre_li, post_font, NULL, NULL }, /* Dv */
 165         { NULL, pre_li, post_font, NULL, NULL }, /* Er */
 166         { NULL, pre_li, post_font, NULL, NULL }, /* Ev */
 167         { NULL, pre_ex, NULL, NULL, NULL }, /* Ex */
 168         { NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */
 169         { NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */
 170         { NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */
 171         { NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */
 172         { NULL, pre_Ft, post_font, NULL, NULL }, /* Ft */
 173         { NULL, pre_sy, post_font, NULL, NULL }, /* Ic */
 174         { NULL, pre_in, post_in, NULL, NULL }, /* In */
 175         { NULL, pre_li, post_font, NULL, NULL }, /* Li */
 176         { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
 177         { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
 178         { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
 179         { NULL, pre_abort, NULL, NULL, NULL }, /* Ot */
 180         { NULL, pre_em, post_font, NULL, NULL }, /* Pa */
 181         { NULL, pre_ex, NULL, NULL, NULL }, /* Rv */
 182         { NULL, NULL, NULL, NULL, NULL }, /* St */
 183         { NULL, pre_em, post_font, NULL, NULL }, /* Va */
 184         { NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */
 185         { NULL, pre_xr, NULL, NULL, NULL }, /* Xr */
 186         { NULL, NULL, post_percent, NULL, NULL }, /* %A */
 187         { NULL, pre_em, post_percent, NULL, NULL }, /* %B */
 188         { NULL, NULL, post_percent, NULL, NULL }, /* %D */
 189         { NULL, pre_em, post_percent, NULL, NULL }, /* %I */
 190         { NULL, pre_em, post_percent, NULL, NULL }, /* %J */
 191         { NULL, NULL, post_percent, NULL, NULL }, /* %N */
 192         { NULL, NULL, post_percent, NULL, NULL }, /* %O */
 193         { NULL, NULL, post_percent, NULL, NULL }, /* %P */
 194         { NULL, NULL, post_percent, NULL, NULL }, /* %R */
 195         { NULL, pre__t, post__t, NULL, NULL }, /* %T */
 196         { NULL, NULL, post_percent, NULL, NULL }, /* %V */
 197         { NULL, NULL, NULL, NULL, NULL }, /* Ac */
 198         { cond_body, pre_aq, post_aq, NULL, NULL }, /* Ao */
 199         { cond_body, pre_aq, post_aq, NULL, NULL }, /* Aq */
 200         { NULL, NULL, NULL, NULL, NULL }, /* At */
 201         { NULL, NULL, NULL, NULL, NULL }, /* Bc */
 202         { NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */
 203         { cond_body, pre_enc, post_enc, "[", "]" }, /* Bo */
 204         { cond_body, pre_enc, post_enc, "[", "]" }, /* Bq */
 205         { NULL, pre_bk, post_bk, NULL, NULL }, /* Bsx */
 206         { NULL, pre_bk, post_bk, NULL, NULL }, /* Bx */
 207         { NULL, pre_skip, NULL, NULL, NULL }, /* Db */
 208         { NULL, NULL, NULL, NULL, NULL }, /* Dc */
 209         { cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Do */
 210         { cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Dq */
 211         { NULL, NULL, NULL, NULL, NULL }, /* Ec */
 212         { NULL, NULL, NULL, NULL, NULL }, /* Ef */
 213         { NULL, pre_em, post_font, NULL, NULL }, /* Em */
 214         { cond_body, pre_eo, post_eo, NULL, NULL }, /* Eo */
 215         { NULL, pre_bk, post_bk, NULL, NULL }, /* Fx */
 216         { NULL, pre_sy, post_font, NULL, NULL }, /* Ms */
 217         { NULL, pre_no, NULL, NULL, NULL }, /* No */
 218         { NULL, pre_ns, NULL, NULL, NULL }, /* Ns */
 219         { NULL, pre_bk, post_bk, NULL, NULL }, /* Nx */
 220         { NULL, pre_bk, post_bk, NULL, NULL }, /* Ox */
 221         { NULL, NULL, NULL, NULL, NULL }, /* Pc */
 222         { NULL, NULL, post_pf, NULL, NULL }, /* Pf */
 223         { cond_body, pre_enc, post_enc, "(", ")" }, /* Po */
 224         { cond_body, pre_enc, post_enc, "(", ")" }, /* Pq */
 225         { NULL, NULL, NULL, NULL, NULL }, /* Qc */
 226         { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Ql */
 227         { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qo */
 228         { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qq */
 229         { NULL, NULL, NULL, NULL, NULL }, /* Re */
 230         { cond_body, pre_rs, NULL, NULL, NULL }, /* Rs */
 231         { NULL, NULL, NULL, NULL, NULL }, /* Sc */
 232         { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* So */
 233         { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Sq */
 234         { NULL, pre_sm, NULL, NULL, NULL }, /* Sm */
 235         { NULL, pre_em, post_font, NULL, NULL }, /* Sx */
 236         { NULL, pre_sy, post_font, NULL, NULL }, /* Sy */
 237         { NULL, pre_li, post_font, NULL, NULL }, /* Tn */
 238         { NULL, NULL, NULL, NULL, NULL }, /* Ux */
 239         { NULL, NULL, NULL, NULL, NULL }, /* Xc */
 240         { NULL, NULL, NULL, NULL, NULL }, /* Xo */
 241         { NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */
 242         { NULL, NULL, NULL, NULL, NULL }, /* Fc */
 243         { cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */
 244         { NULL, NULL, NULL, NULL, NULL }, /* Oc */
 245         { NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */
 246         { NULL, NULL, NULL, NULL, NULL }, /* Ek */
 247         { NULL, NULL, NULL, NULL, NULL }, /* Bt */
 248         { NULL, NULL, NULL, NULL, NULL }, /* Hf */
 249         { NULL, pre_em, post_font, NULL, NULL }, /* Fr */
 250         { NULL, NULL, NULL, NULL, NULL }, /* Ud */
 251         { NULL, NULL, post_lb, NULL, NULL }, /* Lb */
 252         { NULL, pre_abort, NULL, NULL, NULL }, /* Lp */
 253         { NULL, pre_lk, NULL, NULL, NULL }, /* Lk */
 254         { NULL, pre_em, post_font, NULL, NULL }, /* Mt */
 255         { cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */
 256         { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
 257         { NULL, NULL, NULL, NULL, NULL }, /* Brc */
 258         { NULL, NULL, post_percent, NULL, NULL }, /* %C */
 259         { NULL, pre_skip, NULL, NULL, NULL }, /* Es */
 260         { cond_body, pre_en, post_en, NULL, NULL }, /* En */
 261         { NULL, pre_bk, post_bk, NULL, NULL }, /* Dx */
 262         { NULL, NULL, post_percent, NULL, NULL }, /* %Q */
 263         { NULL, NULL, post_percent, NULL, NULL }, /* %U */
 264         { NULL, NULL, NULL, NULL, NULL }, /* Ta */
 265 };
 266 static const struct mdoc_man_act *mdoc_man_act(enum roff_tok);
 267
 268 static  int             outflags;
 269 #define MMAN_spc        (1 << 0)  /* blank character before next word */
 270 #define MMAN_spc_force  (1 << 1)  /* even before trailing punctuation */
 271 #define MMAN_nl         (1 << 2)  /* break man(7) code line */
 272 #define MMAN_br         (1 << 3)  /* break output line */
 273 #define MMAN_sp         (1 << 4)  /* insert a blank output line */
 274 #define MMAN_PP         (1 << 5)  /* reset indentation etc. */
 275 #define MMAN_Sm         (1 << 6)  /* horizontal spacing mode */
 276 #define MMAN_Bk         (1 << 7)  /* word keep mode */
 277 #define MMAN_Bk_susp    (1 << 8)  /* suspend this (after a macro) */
 278 #define MMAN_An_split   (1 << 9)  /* author mode is "split" */
 279 #define MMAN_An_nosplit (1 << 10) /* author mode is "nosplit" */
 280 #define MMAN_PD         (1 << 11) /* inter-paragraph spacing disabled */
 281 #define MMAN_nbrword    (1 << 12) /* do not break the next word */
 282
 283 #define BL_STACK_MAX    32
 284
 285 static  int             Bl_stack[BL_STACK_MAX];  /* offsets [chars] */
 286 static  int             Bl_stack_post[BL_STACK_MAX];  /* add final .RE */
 287 static  int             Bl_stack_len;  /* number of nested Bl blocks */
 288 static  int             TPremain;  /* characters before tag is full */
 289
 290 static  struct {
 291         char    *head;
 292         char    *tail;
 293         size_t   size;
 294 }       fontqueue;
 295
 296
 297 static const struct mdoc_man_act *
 298 mdoc_man_act(enum roff_tok tok)
 299 {
 300         assert(tok >= MDOC_Dd && tok <= MDOC_MAX);
 301         return mdoc_man_acts + (tok - MDOC_Dd);
 302 }
 303
 304 static int
 305 man_strlen(const char *cp)
 306 {
 307         size_t   rsz;
 308         int      skip, sz;
 309
 310         sz = 0;
 311         skip = 0;
 312         for (;;) {
 313                 rsz = strcspn(cp, "\\");
 314                 if (rsz) {
 315                         cp += rsz;
 316                         if (skip) {
 317                                 skip = 0;
 318                                 rsz--;
 319                         }
 320                         sz += rsz;
 321                 }
 322                 if ('\0' == *cp)
 323                         break;
 324                 cp++;
 325                 switch (mandoc_escape(&cp, NULL, NULL)) {
 326                 case ESCAPE_ERROR:
 327                         return sz;
 328                 case ESCAPE_UNICODE:
 329                 case ESCAPE_NUMBERED:
 330                 case ESCAPE_SPECIAL:
 331                 case ESCAPE_UNDEF:
 332                 case ESCAPE_OVERSTRIKE:
 333                         if (skip)
 334                                 skip = 0;
 335                         else
 336                                 sz++;
 337                         break;
 338                 case ESCAPE_SKIPCHAR:
 339                         skip = 1;
 340                         break;
 341                 default:
 342                         break;
 343                 }
 344         }
 345         return sz;
 346 }
 347
 348 static void
 349 font_push(char newfont)
 350 {
 351
 352         if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
 353                 fontqueue.size += 8;
 354                 fontqueue.head = mandoc_realloc(fontqueue.head,
 355                     fontqueue.size);
 356         }
 357         *fontqueue.tail = newfont;
 358         print_word("");
 359         printf("\\f");
 360         putchar(newfont);
 361         outflags &= ~MMAN_spc;
 362 }
 363
 364 static void
 365 font_pop(void)
 366 {
 367
 368         if (fontqueue.tail > fontqueue.head)
 369                 fontqueue.tail--;
 370         outflags &= ~MMAN_spc;
 371         print_word("");
 372         printf("\\f");
 373         putchar(*fontqueue.tail);
 374 }
 375
 376 static void
 377 print_word(const char *s)
 378 {
 379
 380         if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
 381                 /*
 382                  * If we need a newline, print it now and start afresh.
 383                  */
 384                 if (MMAN_PP & outflags) {
 385                         if (MMAN_sp & outflags) {
 386                                 if (MMAN_PD & outflags) {
 387                                         printf("\n.PD");
 388                                         outflags &= ~MMAN_PD;
 389                                 }
 390                         } else if ( ! (MMAN_PD & outflags)) {
 391                                 printf("\n.PD 0");
 392                                 outflags |= MMAN_PD;
 393                         }
 394                         printf("\n.PP\n");
 395                 } else if (MMAN_sp & outflags)
 396                         printf("\n.sp\n");
 397                 else if (MMAN_br & outflags)
 398                         printf("\n.br\n");
 399                 else if (MMAN_nl & outflags)
 400                         putchar('\n');
 401                 outflags &= ~(MMAN_PP|MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);
 402                 if (1 == TPremain)
 403                         printf(".br\n");
 404                 TPremain = 0;
 405         } else if (MMAN_spc & outflags) {
 406                 /*
 407                  * If we need a space, only print it if
 408                  * (1) it is forced by `No' or
 409                  * (2) what follows is not terminating punctuation or
 410                  * (3) what follows is longer than one character.
 411                  */
 412                 if (MMAN_spc_force & outflags || '\0' == s[0] ||
 413                     NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {
 414                         if (MMAN_Bk & outflags &&
 415                             ! (MMAN_Bk_susp & outflags))
 416                                 putchar('\\');
 417                         putchar(' ');
 418                         if (TPremain)
 419                                 TPremain--;
 420                 }
 421         }
 422
 423         /*
 424          * Reassign needing space if we're not following opening
 425          * punctuation.
 426          */
 427         if (MMAN_Sm & outflags && ('\0' == s[0] ||
 428             (('(' != s[0] && '[' != s[0]) || '\0' != s[1])))
 429                 outflags |= MMAN_spc;
 430         else
 431                 outflags &= ~MMAN_spc;
 432         outflags &= ~(MMAN_spc_force | MMAN_Bk_susp);
 433
 434         for ( ; *s; s++) {
 435                 switch (*s) {
 436                 case ASCII_NBRSP:
 437                         printf("\\ ");
 438                         break;
 439                 case ASCII_HYPH:
 440                         putchar('-');
 441                         break;
 442                 case ASCII_BREAK:
 443                         printf("\\:");
 444                         break;
 445                 case ' ':
 446                         if (MMAN_nbrword & outflags) {
 447                                 printf("\\ ");
 448                                 break;
 449                         }
 450                         /* FALLTHROUGH */
 451                 default:
 452                         putchar((unsigned char)*s);
 453                         break;
 454                 }
 455                 if (TPremain)
 456                         TPremain--;
 457         }
 458         outflags &= ~MMAN_nbrword;
 459 }
 460
 461 static void
 462 print_line(const char *s, int newflags)
 463 {
 464
 465         outflags |= MMAN_nl;
 466         print_word(s);
 467         outflags |= newflags;
 468 }
 469
 470 static void
 471 print_block(const char *s, int newflags)
 472 {
 473
 474         outflags &= ~MMAN_PP;
 475         if (MMAN_sp & outflags) {
 476                 outflags &= ~(MMAN_sp | MMAN_br);
 477                 if (MMAN_PD & outflags) {
 478                         print_line(".PD", 0);
 479                         outflags &= ~MMAN_PD;
 480                 }
 481         } else if (! (MMAN_PD & outflags))
 482                 print_line(".PD 0", MMAN_PD);
 483         outflags |= MMAN_nl;
 484         print_word(s);
 485         outflags |= MMAN_Bk_susp | newflags;
 486 }
 487
 488 static void
 489 print_offs(const char *v, int keywords)
 490 {
 491         char              buf[24];
 492         struct roffsu     su;
 493         const char       *end;
 494         int               sz;
 495
 496         print_line(".RS", MMAN_Bk_susp);
 497
 498         /* Convert v into a number (of characters). */
 499         if (NULL == v || '\0' == *v || (keywords && !strcmp(v, "left")))
 500                 sz = 0;
 501         else if (keywords && !strcmp(v, "indent"))
 502                 sz = 6;
 503         else if (keywords && !strcmp(v, "indent-two"))
 504                 sz = 12;
 505         else {
 506                 end = a2roffsu(v, &su, SCALE_EN);
 507                 if (end == NULL || *end != '\0')
 508                         sz = man_strlen(v);
 509                 else if (SCALE_EN == su.unit)
 510                         sz = su.scale;
 511                 else {
 512                         /*
 513                          * XXX
 514                          * If we are inside an enclosing list,
 515                          * there is no easy way to add the two
 516                          * indentations because they are provided
 517                          * in terms of different units.
 518                          */
 519                         print_word(v);
 520                         outflags |= MMAN_nl;
 521                         return;
 522                 }
 523         }
 524
 525         /*
 526          * We are inside an enclosing list.
 527          * Add the two indentations.
 528          */
 529         if (Bl_stack_len)
 530                 sz += Bl_stack[Bl_stack_len - 1];
 531
 532         (void)snprintf(buf, sizeof(buf), "%dn", sz);
 533         print_word(buf);
 534         outflags |= MMAN_nl;
 535 }
 536
 537 /*
 538  * Set up the indentation for a list item; used from pre_it().
 539  */
 540 static void
 541 print_width(const struct mdoc_bl *bl, const struct roff_node *child)
 542 {
 543         char              buf[24];
 544         struct roffsu     su;
 545         const char       *end;
 546         int               numeric, remain, sz, chsz;
 547
 548         numeric = 1;
 549         remain = 0;
 550
 551         /* Convert the width into a number (of characters). */
 552         if (bl->width == NULL)
 553                 sz = (bl->type == LIST_hang) ? 6 : 0;
 554         else {
 555                 end = a2roffsu(bl->width, &su, SCALE_MAX);
 556                 if (end == NULL || *end != '\0')
 557                         sz = man_strlen(bl->width);
 558                 else if (SCALE_EN == su.unit)
 559                         sz = su.scale;
 560                 else {
 561                         sz = 0;
 562                         numeric = 0;
 563                 }
 564         }
 565
 566         /* XXX Rough estimation, might have multiple parts. */
 567         if (bl->type == LIST_enum)
 568                 chsz = (bl->count > 8) + 1;
 569         else if (child != NULL && child->type == ROFFT_TEXT)
 570                 chsz = man_strlen(child->string);
 571         else
 572                 chsz = 0;
 573
 574         /* Maybe we are inside an enclosing list? */
 575         mid_it();
 576
 577         /*
 578          * Save our own indentation,
 579          * such that child lists can use it.
 580          */
 581         Bl_stack[Bl_stack_len++] = sz + 2;
 582
 583         /* Set up the current list. */
 584         if (chsz > sz && bl->type != LIST_tag)
 585                 print_block(".HP", 0);
 586         else {
 587                 print_block(".TP", 0);
 588                 remain = sz + 2;
 589         }
 590         if (numeric) {
 591                 (void)snprintf(buf, sizeof(buf), "%dn", sz + 2);
 592                 print_word(buf);
 593         } else
 594                 print_word(bl->width);
 595         TPremain = remain;
 596 }
 597
 598 static void
 599 print_count(int *count)
 600 {
 601         char              buf[24];
 602
 603         (void)snprintf(buf, sizeof(buf), "%d.\\&", ++*count);
 604         print_word(buf);
 605 }
 606
 607 void
 608 man_mdoc(void *arg, const struct roff_meta *mdoc)
 609 {
 610         struct roff_node *n;
 611
 612         printf(".\\\" Automatically generated from an mdoc input file."
 613             "  Do not edit.\n");
 614         for (n = mdoc->first->child; n != NULL; n = n->next) {
 615                 if (n->type != ROFFT_COMMENT)
 616                         break;
 617                 printf(".\\\"%s\n", n->string);
 618         }
 619
 620         printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
 621             mdoc->title, (mdoc->msec == NULL ? "" : mdoc->msec),
 622             mdoc->date, mdoc->os, mdoc->vol);
 623
 624         /* Disable hyphenation and if nroff, disable justification. */
 625         printf(".nh\n.if n .ad l");
 626
 627         outflags = MMAN_nl | MMAN_Sm;
 628         if (0 == fontqueue.size) {
 629                 fontqueue.size = 8;
 630                 fontqueue.head = fontqueue.tail = mandoc_malloc(8);
 631                 *fontqueue.tail = 'R';
 632         }
 633         for (; n != NULL; n = n->next)
 634                 print_node(mdoc, n);
 635         putchar('\n');
 636 }
 637
 638 static void
 639 print_node(DECL_ARGS)
 640 {
 641         const struct mdoc_man_act       *act;
 642         struct roff_node                *sub;
 643         int                              cond, do_sub;
 644
 645         if (n->flags & NODE_NOPRT)
 646                 return;
 647
 648         /*
 649          * Break the line if we were parsed subsequent the current node.
 650          * This makes the page structure be more consistent.
 651          */
 652         if (MMAN_spc & outflags && NODE_LINE & n->flags)
 653                 outflags |= MMAN_nl;
 654
 655         act = NULL;
 656         cond = 0;
 657         do_sub = 1;
 658         n->flags &= ~NODE_ENDED;
 659
 660         if (n->type == ROFFT_TEXT) {
 661                 /*
 662                  * Make sure that we don't happen to start with a
 663                  * control character at the start of a line.
 664                  */
 665                 if (MMAN_nl & outflags &&
 666                     ('.' == *n->string || '\'' == *n->string)) {
 667                         print_word("");
 668                         printf("\\&");
 669                         outflags &= ~MMAN_spc;
 670                 }
 671                 if (n->flags & NODE_DELIMC)
 672                         outflags &= ~(MMAN_spc | MMAN_spc_force);
 673                 else if (outflags & MMAN_Sm)
 674                         outflags |= MMAN_spc_force;
 675                 print_word(n->string);
 676                 if (n->flags & NODE_DELIMO)
 677                         outflags &= ~(MMAN_spc | MMAN_spc_force);
 678                 else if (outflags & MMAN_Sm)
 679                         outflags |= MMAN_spc;
 680         } else if (n->tok < ROFF_MAX) {
 681                 (*roff_man_acts[n->tok])(meta, n);
 682                 return;
 683         } else {
 684                 /*
 685                  * Conditionally run the pre-node action handler for a
 686                  * node.
 687                  */
 688                 act = mdoc_man_act(n->tok);
 689                 cond = act->cond == NULL || (*act->cond)(meta, n);
 690                 if (cond && act->pre != NULL &&
 691                     (n->end == ENDBODY_NOT || n->child != NULL))
 692                         do_sub = (*act->pre)(meta, n);
 693         }
 694
 695         /*
 696          * Conditionally run all child nodes.
 697          * Note that this iterates over children instead of using
 698          * recursion.  This prevents unnecessary depth in the stack.
 699          */
 700         if (do_sub)
 701                 for (sub = n->child; sub; sub = sub->next)
 702                         print_node(meta, sub);
 703
 704         /*
 705          * Lastly, conditionally run the post-node handler.
 706          */
 707         if (NODE_ENDED & n->flags)
 708                 return;
 709
 710         if (cond && act->post)
 711                 (*act->post)(meta, n);
 712
 713         if (ENDBODY_NOT != n->end)
 714                 n->body->flags |= NODE_ENDED;
 715 }
 716
 717 static int
 718 cond_head(DECL_ARGS)
 719 {
 720
 721         return n->type == ROFFT_HEAD;
 722 }
 723
 724 static int
 725 cond_body(DECL_ARGS)
 726 {
 727
 728         return n->type == ROFFT_BODY;
 729 }
 730
 731 static int
 732 pre_abort(DECL_ARGS)
 733 {
 734         abort();
 735 }
 736
 737 static int
 738 pre_enc(DECL_ARGS)
 739 {
 740         const char      *prefix;
 741
 742         prefix = mdoc_man_act(n->tok)->prefix;
 743         if (NULL == prefix)
 744                 return 1;
 745         print_word(prefix);
 746         outflags &= ~MMAN_spc;
 747         return 1;
 748 }
 749
 750 static void
 751 post_enc(DECL_ARGS)
 752 {
 753         const char *suffix;
 754
 755         suffix = mdoc_man_act(n->tok)->suffix;
 756         if (NULL == suffix)
 757                 return;
 758         outflags &= ~(MMAN_spc | MMAN_nl);
 759         print_word(suffix);
 760 }
 761
 762 static int
 763 pre_ex(DECL_ARGS)
 764 {
 765         outflags |= MMAN_br | MMAN_nl;
 766         return 1;
 767 }
 768
 769 static void
 770 post_font(DECL_ARGS)
 771 {
 772
 773         font_pop();
 774 }
 775
 776 static void
 777 post_percent(DECL_ARGS)
 778 {
 779
 780         if (mdoc_man_act(n->tok)->pre == pre_em)
 781                 font_pop();
 782         if (n->next) {
 783                 print_word(",");
 784                 if (n->prev &&  n->prev->tok == n->tok &&
 785                                 n->next->tok == n->tok)
 786                         print_word("and");
 787         } else {
 788                 print_word(".");
 789                 outflags |= MMAN_nl;
 790         }
 791 }
 792
 793 static int
 794 pre__t(DECL_ARGS)
 795 {
 796
 797         if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {
 798                 print_word("\\(lq");
 799                 outflags &= ~MMAN_spc;
 800         } else
 801                 font_push('I');
 802         return 1;
 803 }
 804
 805 static void
 806 post__t(DECL_ARGS)
 807 {
 808
 809         if (n->parent->tok  == MDOC_Rs && n->parent->norm->Rs.quote_T) {
 810                 outflags &= ~MMAN_spc;
 811                 print_word("\\(rq");
 812         } else
 813                 font_pop();
 814         post_percent(meta, n);
 815 }
 816
 817 /*
 818  * Print before a section header.
 819  */
 820 static int
 821 pre_sect(DECL_ARGS)
 822 {
 823
 824         if (n->type == ROFFT_HEAD) {
 825                 outflags |= MMAN_sp;
 826                 print_block(mdoc_man_act(n->tok)->prefix, 0);
 827                 print_word("");
 828                 putchar('\"');
 829                 outflags &= ~MMAN_spc;
 830         }
 831         return 1;
 832 }
 833
 834 /*
 835  * Print subsequent a section header.
 836  */
 837 static void
 838 post_sect(DECL_ARGS)
 839 {
 840
 841         if (n->type != ROFFT_HEAD)
 842                 return;
 843         outflags &= ~MMAN_spc;
 844         print_word("");
 845         putchar('\"');
 846         outflags |= MMAN_nl;
 847         if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)
 848                 outflags &= ~(MMAN_An_split | MMAN_An_nosplit);
 849 }
 850
 851 /* See mdoc_term.c, synopsis_pre() for comments. */
 852 static void
 853 pre_syn(const struct roff_node *n)
 854 {
 855
 856         if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))
 857                 return;
 858
 859         if (n->prev->tok == n->tok &&
 860             MDOC_Ft != n->tok &&
 861             MDOC_Fo != n->tok &&
 862             MDOC_Fn != n->tok) {
 863                 outflags |= MMAN_br;
 864                 return;
 865         }
 866
 867         switch (n->prev->tok) {
 868         case MDOC_Fd:
 869         case MDOC_Fn:
 870         case MDOC_Fo:
 871         case MDOC_In:
 872         case MDOC_Vt:
 873                 outflags |= MMAN_sp;
 874                 break;
 875         case MDOC_Ft:
 876                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
 877                         outflags |= MMAN_sp;
 878                         break;
 879                 }
 880                 /* FALLTHROUGH */
 881         default:
 882                 outflags |= MMAN_br;
 883                 break;
 884         }
 885 }
 886
 887 static int
 888 pre_an(DECL_ARGS)
 889 {
 890
 891         switch (n->norm->An.auth) {
 892         case AUTH_split:
 893                 outflags &= ~MMAN_An_nosplit;
 894                 outflags |= MMAN_An_split;
 895                 return 0;
 896         case AUTH_nosplit:
 897                 outflags &= ~MMAN_An_split;
 898                 outflags |= MMAN_An_nosplit;
 899                 return 0;
 900         default:
 901                 if (MMAN_An_split & outflags)
 902                         outflags |= MMAN_br;
 903                 else if (SEC_AUTHORS == n->sec &&
 904                     ! (MMAN_An_nosplit & outflags))
 905                         outflags |= MMAN_An_split;
 906                 return 1;
 907         }
 908 }
 909
 910 static int
 911 pre_ap(DECL_ARGS)
 912 {
 913
 914         outflags &= ~MMAN_spc;
 915         print_word("'");
 916         outflags &= ~MMAN_spc;
 917         return 0;
 918 }
 919
 920 static int
 921 pre_aq(DECL_ARGS)
 922 {
 923
 924         print_word(n->child != NULL && n->child->next == NULL &&
 925             n->child->tok == MDOC_Mt ?  "<" : "\\(la");
 926         outflags &= ~MMAN_spc;
 927         return 1;
 928 }
 929
 930 static void
 931 post_aq(DECL_ARGS)
 932 {
 933
 934         outflags &= ~(MMAN_spc | MMAN_nl);
 935         print_word(n->child != NULL && n->child->next == NULL &&
 936             n->child->tok == MDOC_Mt ?  ">" : "\\(ra");
 937 }
 938
 939 static int
 940 pre_bd(DECL_ARGS)
 941 {
 942         outflags &= ~(MMAN_PP | MMAN_sp | MMAN_br);
 943
 944         if (DISP_unfilled == n->norm->Bd.type ||
 945             DISP_literal  == n->norm->Bd.type)
 946                 print_line(".nf", 0);
 947         if (0 == n->norm->Bd.comp && NULL != n->parent->prev)
 948                 outflags |= MMAN_sp;
 949         print_offs(n->norm->Bd.offs, 1);
 950         return 1;
 951 }
 952
 953 static void
 954 post_bd(DECL_ARGS)
 955 {
 956         enum roff_tok    bef, now;
 957
 958         /* Close out this display. */
 959         print_line(".RE", MMAN_nl);
 960         bef = n->flags & NODE_NOFILL ? ROFF_nf : ROFF_fi;
 961         if (n->last == NULL)
 962                 now = n->norm->Bd.type == DISP_unfilled ||
 963                     n->norm->Bd.type == DISP_literal ? ROFF_nf : ROFF_fi;
 964         else if (n->last->tok == ROFF_nf)
 965                 now = ROFF_nf;
 966         else if (n->last->tok == ROFF_fi)
 967                 now = ROFF_fi;
 968         else
 969                 now = n->last->flags & NODE_NOFILL ? ROFF_nf : ROFF_fi;
 970         if (bef != now) {
 971                 outflags |= MMAN_nl;
 972                 print_word(".");
 973                 outflags &= ~MMAN_spc;
 974                 print_word(roff_name[bef]);
 975                 outflags |= MMAN_nl;
 976         }
 977
 978         /* Maybe we are inside an enclosing list? */
 979         if (NULL != n->parent->next)
 980                 mid_it();
 981 }
 982
 983 static int
 984 pre_bf(DECL_ARGS)
 985 {
 986
 987         switch (n->type) {
 988         case ROFFT_BLOCK:
 989                 return 1;
 990         case ROFFT_BODY:
 991                 break;
 992         default:
 993                 return 0;
 994         }
 995         switch (n->norm->Bf.font) {
 996         case FONT_Em:
 997                 font_push('I');
 998                 break;
 999         case FONT_Sy:
1000                 font_push('B');
1001                 break;
1002         default:
1003                 font_push('R');
1004                 break;
1005         }
1006         return 1;
1007 }
1008
1009 static void
1010 post_bf(DECL_ARGS)
1011 {
1012
1013         if (n->type == ROFFT_BODY)
1014                 font_pop();
1015 }
1016
1017 static int
1018 pre_bk(DECL_ARGS)
1019 {
1020         switch (n->type) {
1021         case ROFFT_BLOCK:
1022                 return 1;
1023         case ROFFT_BODY:
1024         case ROFFT_ELEM:
1025                 outflags |= MMAN_Bk;
1026                 return 1;
1027         default:
1028                 return 0;
1029         }
1030 }
1031
1032 static void
1033 post_bk(DECL_ARGS)
1034 {
1035         switch (n->type) {
1036         case ROFFT_ELEM:
1037                 while ((n = n->parent) != NULL)
1038                          if (n->tok == MDOC_Bk)
1039                                 return;
1040                 /* FALLTHROUGH */
1041         case ROFFT_BODY:
1042                 outflags &= ~MMAN_Bk;
1043                 break;
1044         default:
1045                 break;
1046         }
1047 }
1048
1049 static int
1050 pre_bl(DECL_ARGS)
1051 {
1052         size_t           icol;
1053
1054         /*
1055          * print_offs() will increase the -offset to account for
1056          * a possible enclosing .It, but any enclosed .It blocks
1057          * just nest and do not add up their indentation.
1058          */
1059         if (n->norm->Bl.offs) {
1060                 print_offs(n->norm->Bl.offs, 0);
1061                 Bl_stack[Bl_stack_len++] = 0;
1062         }
1063
1064         switch (n->norm->Bl.type) {
1065         case LIST_enum:
1066                 n->norm->Bl.count = 0;
1067                 return 1;
1068         case LIST_column:
1069                 break;
1070         default:
1071                 return 1;
1072         }
1073
1074         if (n->child != NULL) {
1075                 print_line(".TS", MMAN_nl);
1076                 for (icol = 0; icol < n->norm->Bl.ncols; icol++)
1077                         print_word("l");
1078                 print_word(".");
1079         }
1080         outflags |= MMAN_nl;
1081         return 1;
1082 }
1083
1084 static void
1085 post_bl(DECL_ARGS)
1086 {
1087
1088         switch (n->norm->Bl.type) {
1089         case LIST_column:
1090                 if (n->child != NULL)
1091                         print_line(".TE", 0);
1092                 break;
1093         case LIST_enum:
1094                 n->norm->Bl.count = 0;
1095                 break;
1096         default:
1097                 break;
1098         }
1099
1100         if (n->norm->Bl.offs) {
1101                 print_line(".RE", MMAN_nl);
1102                 assert(Bl_stack_len);
1103                 Bl_stack_len--;
1104                 assert(0 == Bl_stack[Bl_stack_len]);
1105         } else {
1106                 outflags |= MMAN_PP | MMAN_nl;
1107                 outflags &= ~(MMAN_sp | MMAN_br);
1108         }
1109
1110         /* Maybe we are inside an enclosing list? */
1111         if (NULL != n->parent->next)
1112                 mid_it();
1113
1114 }
1115
1116 static void
1117 pre_br(DECL_ARGS)
1118 {
1119         outflags |= MMAN_br;
1120 }
1121
1122 static int
1123 pre_dl(DECL_ARGS)
1124 {
1125
1126         print_offs("6n", 0);
1127         return 1;
1128 }
1129
1130 static void
1131 post_dl(DECL_ARGS)
1132 {
1133
1134         print_line(".RE", MMAN_nl);
1135
1136         /* Maybe we are inside an enclosing list? */
1137         if (NULL != n->parent->next)
1138                 mid_it();
1139 }
1140
1141 static int
1142 pre_em(DECL_ARGS)
1143 {
1144
1145         font_push('I');
1146         return 1;
1147 }
1148
1149 static int
1150 pre_en(DECL_ARGS)
1151 {
1152
1153         if (NULL == n->norm->Es ||
1154             NULL == n->norm->Es->child)
1155                 return 1;
1156
1157         print_word(n->norm->Es->child->string);
1158         outflags &= ~MMAN_spc;
1159         return 1;
1160 }
1161
1162 static void
1163 post_en(DECL_ARGS)
1164 {
1165
1166         if (NULL == n->norm->Es ||
1167             NULL == n->norm->Es->child ||
1168             NULL == n->norm->Es->child->next)
1169                 return;
1170
1171         outflags &= ~MMAN_spc;
1172         print_word(n->norm->Es->child->next->string);
1173         return;
1174 }
1175
1176 static int
1177 pre_eo(DECL_ARGS)
1178 {
1179
1180         if (n->end == ENDBODY_NOT &&
1181             n->parent->head->child == NULL &&
1182             n->child != NULL &&
1183             n->child->end != ENDBODY_NOT)
1184                 print_word("\\&");
1185         else if (n->end != ENDBODY_NOT ? n->child != NULL :
1186             n->parent->head->child != NULL && (n->child != NULL ||
1187             (n->parent->tail != NULL && n->parent->tail->child != NULL)))
1188                 outflags &= ~(MMAN_spc | MMAN_nl);
1189         return 1;
1190 }
1191
1192 static void
1193 post_eo(DECL_ARGS)
1194 {
1195         int      body, tail;
1196
1197         if (n->end != ENDBODY_NOT) {
1198                 outflags |= MMAN_spc;
1199                 return;
1200         }
1201
1202         body = n->child != NULL || n->parent->head->child != NULL;
1203         tail = n->parent->tail != NULL && n->parent->tail->child != NULL;
1204
1205         if (body && tail)
1206                 outflags &= ~MMAN_spc;
1207         else if ( ! (body || tail))
1208                 print_word("\\&");
1209         else if ( ! tail)
1210                 outflags |= MMAN_spc;
1211 }
1212
1213 static int
1214 pre_fa(DECL_ARGS)
1215 {
1216         int      am_Fa;
1217
1218         am_Fa = MDOC_Fa == n->tok;
1219
1220         if (am_Fa)
1221                 n = n->child;
1222
1223         while (NULL != n) {
1224                 font_push('I');
1225                 if (am_Fa || NODE_SYNPRETTY & n->flags)
1226                         outflags |= MMAN_nbrword;
1227                 print_node(meta, n);
1228                 font_pop();
1229                 if (NULL != (n = n->next))
1230                         print_word(",");
1231         }
1232         return 0;
1233 }
1234
1235 static void
1236 post_fa(DECL_ARGS)
1237 {
1238
1239         if (NULL != n->next && MDOC_Fa == n->next->tok)
1240                 print_word(",");
1241 }
1242
1243 static int
1244 pre_fd(DECL_ARGS)
1245 {
1246
1247         pre_syn(n);
1248         font_push('B');
1249         return 1;
1250 }
1251
1252 static void
1253 post_fd(DECL_ARGS)
1254 {
1255
1256         font_pop();
1257         outflags |= MMAN_br;
1258 }
1259
1260 static int
1261 pre_fl(DECL_ARGS)
1262 {
1263
1264         font_push('B');
1265         print_word("\\-");
1266         if (n->child != NULL)
1267                 outflags &= ~MMAN_spc;
1268         return 1;
1269 }
1270
1271 static void
1272 post_fl(DECL_ARGS)
1273 {
1274
1275         font_pop();
1276         if (!(n->child != NULL ||
1277             n->next == NULL ||
1278             n->next->type == ROFFT_TEXT ||
1279             n->next->flags & NODE_LINE))
1280                 outflags &= ~MMAN_spc;
1281 }
1282
1283 static int
1284 pre_fn(DECL_ARGS)
1285 {
1286
1287         pre_syn(n);
1288
1289         n = n->child;
1290         if (NULL == n)
1291                 return 0;
1292
1293         if (NODE_SYNPRETTY & n->flags)
1294                 print_block(".HP 4n", MMAN_nl);
1295
1296         font_push('B');
1297         print_node(meta, n);
1298         font_pop();
1299         outflags &= ~MMAN_spc;
1300         print_word("(");
1301         outflags &= ~MMAN_spc;
1302
1303         n = n->next;
1304         if (NULL != n)
1305                 pre_fa(meta, n);
1306         return 0;
1307 }
1308
1309 static void
1310 post_fn(DECL_ARGS)
1311 {
1312
1313         print_word(")");
1314         if (NODE_SYNPRETTY & n->flags) {
1315                 print_word(";");
1316                 outflags |= MMAN_PP;
1317         }
1318 }
1319
1320 static int
1321 pre_fo(DECL_ARGS)
1322 {
1323
1324         switch (n->type) {
1325         case ROFFT_BLOCK:
1326                 pre_syn(n);
1327                 break;
1328         case ROFFT_HEAD:
1329                 if (n->child == NULL)
1330                         return 0;
1331                 if (NODE_SYNPRETTY & n->flags)
1332                         print_block(".HP 4n", MMAN_nl);
1333                 font_push('B');
1334                 break;
1335         case ROFFT_BODY:
1336                 outflags &= ~(MMAN_spc | MMAN_nl);
1337                 print_word("(");
1338                 outflags &= ~MMAN_spc;
1339                 break;
1340         default:
1341                 break;
1342         }
1343         return 1;
1344 }
1345
1346 static void
1347 post_fo(DECL_ARGS)
1348 {
1349
1350         switch (n->type) {
1351         case ROFFT_HEAD:
1352                 if (n->child != NULL)
1353                         font_pop();
1354                 break;
1355         case ROFFT_BODY:
1356                 post_fn(meta, n);
1357                 break;
1358         default:
1359                 break;
1360         }
1361 }
1362
1363 static int
1364 pre_Ft(DECL_ARGS)
1365 {
1366
1367         pre_syn(n);
1368         font_push('I');
1369         return 1;
1370 }
1371
1372 static void
1373 pre_ft(DECL_ARGS)
1374 {
1375         print_line(".ft", 0);
1376         print_word(n->child->string);
1377         outflags |= MMAN_nl;
1378 }
1379
1380 static int
1381 pre_in(DECL_ARGS)
1382 {
1383
1384         if (NODE_SYNPRETTY & n->flags) {
1385                 pre_syn(n);
1386                 font_push('B');
1387                 print_word("#include <");
1388                 outflags &= ~MMAN_spc;
1389         } else {
1390                 print_word("<");
1391                 outflags &= ~MMAN_spc;
1392                 font_push('I');
1393         }
1394         return 1;
1395 }
1396
1397 static void
1398 post_in(DECL_ARGS)
1399 {
1400
1401         if (NODE_SYNPRETTY & n->flags) {
1402                 outflags &= ~MMAN_spc;
1403                 print_word(">");
1404                 font_pop();
1405                 outflags |= MMAN_br;
1406         } else {
1407                 font_pop();
1408                 outflags &= ~MMAN_spc;
1409                 print_word(">");
1410         }
1411 }
1412
1413 static int
1414 pre_it(DECL_ARGS)
1415 {
1416         const struct roff_node *bln;
1417
1418         switch (n->type) {
1419         case ROFFT_HEAD:
1420                 outflags |= MMAN_PP | MMAN_nl;
1421                 bln = n->parent->parent;
1422                 if (0 == bln->norm->Bl.comp ||
1423                     (NULL == n->parent->prev &&
1424                      NULL == bln->parent->prev))
1425                         outflags |= MMAN_sp;
1426                 outflags &= ~MMAN_br;
1427                 switch (bln->norm->Bl.type) {
1428                 case LIST_item:
1429                         return 0;
1430                 case LIST_inset:
1431                 case LIST_diag:
1432                 case LIST_ohang:
1433                         if (bln->norm->Bl.type == LIST_diag)
1434                                 print_line(".B \"", 0);
1435                         else
1436                                 print_line(".BR \\& \"", 0);
1437                         outflags &= ~MMAN_spc;
1438                         return 1;
1439                 case LIST_bullet:
1440                 case LIST_dash:
1441                 case LIST_hyphen:
1442                         print_width(&bln->norm->Bl, NULL);
1443                         TPremain = 0;
1444                         outflags |= MMAN_nl;
1445                         font_push('B');
1446                         if (LIST_bullet == bln->norm->Bl.type)
1447                                 print_word("\\(bu");
1448                         else
1449                                 print_word("-");
1450                         font_pop();
1451                         outflags |= MMAN_nl;
1452                         return 0;
1453                 case LIST_enum:
1454                         print_width(&bln->norm->Bl, NULL);
1455                         TPremain = 0;
1456                         outflags |= MMAN_nl;
1457                         print_count(&bln->norm->Bl.count);
1458                         outflags |= MMAN_nl;
1459                         return 0;
1460                 case LIST_hang:
1461                         print_width(&bln->norm->Bl, n->child);
1462                         TPremain = 0;
1463                         outflags |= MMAN_nl;
1464                         return 1;
1465                 case LIST_tag:
1466                         print_width(&bln->norm->Bl, n->child);
1467                         putchar('\n');
1468                         outflags &= ~MMAN_spc;
1469                         return 1;
1470                 default:
1471                         return 1;
1472                 }
1473         default:
1474                 break;
1475         }
1476         return 1;
1477 }
1478
1479 /*
1480  * This function is called after closing out an indented block.
1481  * If we are inside an enclosing list, restore its indentation.
1482  */
1483 static void
1484 mid_it(void)
1485 {
1486         char             buf[24];
1487
1488         /* Nothing to do outside a list. */
1489         if (0 == Bl_stack_len || 0 == Bl_stack[Bl_stack_len - 1])
1490                 return;
1491
1492         /* The indentation has already been set up. */
1493         if (Bl_stack_post[Bl_stack_len - 1])
1494                 return;
1495
1496         /* Restore the indentation of the enclosing list. */
1497         print_line(".RS", MMAN_Bk_susp);
1498         (void)snprintf(buf, sizeof(buf), "%dn",
1499             Bl_stack[Bl_stack_len - 1]);
1500         print_word(buf);
1501
1502         /* Remeber to close out this .RS block later. */
1503         Bl_stack_post[Bl_stack_len - 1] = 1;
1504 }
1505
1506 static void
1507 post_it(DECL_ARGS)
1508 {
1509         const struct roff_node *bln;
1510
1511         bln = n->parent->parent;
1512
1513         switch (n->type) {
1514         case ROFFT_HEAD:
1515                 switch (bln->norm->Bl.type) {
1516                 case LIST_diag:
1517                         outflags &= ~MMAN_spc;
1518                         print_word("\\ ");
1519                         break;
1520                 case LIST_ohang:
1521                         outflags |= MMAN_br;
1522                         break;
1523                 default:
1524                         break;
1525                 }
1526                 break;
1527         case ROFFT_BODY:
1528                 switch (bln->norm->Bl.type) {
1529                 case LIST_bullet:
1530                 case LIST_dash:
1531                 case LIST_hyphen:
1532                 case LIST_enum:
1533                 case LIST_hang:
1534                 case LIST_tag:
1535                         assert(Bl_stack_len);
1536                         Bl_stack[--Bl_stack_len] = 0;
1537
1538                         /*
1539                          * Our indentation had to be restored
1540                          * after a child display or child list.
1541                          * Close out that indentation block now.
1542                          */
1543                         if (Bl_stack_post[Bl_stack_len]) {
1544                                 print_line(".RE", MMAN_nl);
1545                                 Bl_stack_post[Bl_stack_len] = 0;
1546                         }
1547                         break;
1548                 case LIST_column:
1549                         if (NULL != n->next) {
1550                                 putchar('\t');
1551                                 outflags &= ~MMAN_spc;
1552                         }
1553                         break;
1554                 default:
1555                         break;
1556                 }
1557                 break;
1558         default:
1559                 break;
1560         }
1561 }
1562
1563 static void
1564 post_lb(DECL_ARGS)
1565 {
1566
1567         if (SEC_LIBRARY == n->sec)
1568                 outflags |= MMAN_br;
1569 }
1570
1571 static int
1572 pre_lk(DECL_ARGS)
1573 {
1574         const struct roff_node *link, *descr, *punct;
1575
1576         if ((link = n->child) == NULL)
1577                 return 0;
1578
1579         /* Find beginning of trailing punctuation. */
1580         punct = n->last;
1581         while (punct != link && punct->flags & NODE_DELIMC)
1582                 punct = punct->prev;
1583         punct = punct->next;
1584
1585         /* Link text. */
1586         if ((descr = link->next) != NULL && descr != punct) {
1587                 font_push('I');
1588                 while (descr != punct) {
1589                         print_word(descr->string);
1590                         descr = descr->next;
1591                 }
1592                 font_pop();
1593                 print_word(":");
1594         }
1595
1596         /* Link target. */
1597         font_push('B');
1598         print_word(link->string);
1599         font_pop();
1600
1601         /* Trailing punctuation. */
1602         while (punct != NULL) {
1603                 print_word(punct->string);
1604                 punct = punct->next;
1605         }
1606         return 0;
1607 }
1608
1609 static void
1610 pre_onearg(DECL_ARGS)
1611 {
1612         outflags |= MMAN_nl;
1613         print_word(".");
1614         outflags &= ~MMAN_spc;
1615         print_word(roff_name[n->tok]);
1616         if (n->child != NULL)
1617                 print_word(n->child->string);
1618         outflags |= MMAN_nl;
1619         if (n->tok == ROFF_ce)
1620                 for (n = n->child->next; n != NULL; n = n->next)
1621                         print_node(meta, n);
1622 }
1623
1624 static int
1625 pre_li(DECL_ARGS)
1626 {
1627         font_push('R');
1628         return 1;
1629 }
1630
1631 static int
1632 pre_nm(DECL_ARGS)
1633 {
1634         char    *name;
1635
1636         if (n->type == ROFFT_BLOCK) {
1637                 outflags |= MMAN_Bk;
1638                 pre_syn(n);
1639         }
1640         if (n->type != ROFFT_ELEM && n->type != ROFFT_HEAD)
1641                 return 1;
1642         name = n->child == NULL ? NULL : n->child->string;
1643         if (NULL == name)
1644                 return 0;
1645         if (n->type == ROFFT_HEAD) {
1646                 if (NULL == n->parent->prev)
1647                         outflags |= MMAN_sp;
1648                 print_block(".HP", 0);
1649                 printf(" %dn", man_strlen(name) + 1);
1650                 outflags |= MMAN_nl;
1651         }
1652         font_push('B');
1653         return 1;
1654 }
1655
1656 static void
1657 post_nm(DECL_ARGS)
1658 {
1659         switch (n->type) {
1660         case ROFFT_BLOCK:
1661                 outflags &= ~MMAN_Bk;
1662                 break;
1663         case ROFFT_HEAD:
1664         case ROFFT_ELEM:
1665                 if (n->child != NULL && n->child->string != NULL)
1666                         font_pop();
1667                 break;
1668         default:
1669                 break;
1670         }
1671 }
1672
1673 static int
1674 pre_no(DECL_ARGS)
1675 {
1676         outflags |= MMAN_spc_force;
1677         return 1;
1678 }
1679
1680 static void
1681 pre_noarg(DECL_ARGS)
1682 {
1683         outflags |= MMAN_nl;
1684         print_word(".");
1685         outflags &= ~MMAN_spc;
1686         print_word(roff_name[n->tok]);
1687         outflags |= MMAN_nl;
1688 }
1689
1690 static int
1691 pre_ns(DECL_ARGS)
1692 {
1693         outflags &= ~MMAN_spc;
1694         return 0;
1695 }
1696
1697 static void
1698 post_pf(DECL_ARGS)
1699 {
1700
1701         if ( ! (n->next == NULL || n->next->flags & NODE_LINE))
1702                 outflags &= ~MMAN_spc;
1703 }
1704
1705 static int
1706 pre_pp(DECL_ARGS)
1707 {
1708
1709         if (MDOC_It != n->parent->tok)
1710                 outflags |= MMAN_PP;
1711         outflags |= MMAN_sp | MMAN_nl;
1712         outflags &= ~MMAN_br;
1713         return 0;
1714 }
1715
1716 static int
1717 pre_rs(DECL_ARGS)
1718 {
1719
1720         if (SEC_SEE_ALSO == n->sec) {
1721                 outflags |= MMAN_PP | MMAN_sp | MMAN_nl;
1722                 outflags &= ~MMAN_br;
1723         }
1724         return 1;
1725 }
1726
1727 static int
1728 pre_skip(DECL_ARGS)
1729 {
1730
1731         return 0;
1732 }
1733
1734 static int
1735 pre_sm(DECL_ARGS)
1736 {
1737
1738         if (NULL == n->child)
1739                 outflags ^= MMAN_Sm;
1740         else if (0 == strcmp("on", n->child->string))
1741                 outflags |= MMAN_Sm;
1742         else
1743                 outflags &= ~MMAN_Sm;
1744
1745         if (MMAN_Sm & outflags)
1746                 outflags |= MMAN_spc;
1747
1748         return 0;
1749 }
1750
1751 static void
1752 pre_sp(DECL_ARGS)
1753 {
1754         if (outflags & MMAN_PP) {
1755                 outflags &= ~MMAN_PP;
1756                 print_line(".PP", 0);
1757         } else {
1758                 print_line(".sp", 0);
1759                 if (n->child != NULL)
1760                         print_word(n->child->string);
1761         }
1762         outflags |= MMAN_nl;
1763 }
1764
1765 static int
1766 pre_sy(DECL_ARGS)
1767 {
1768
1769         font_push('B');
1770         return 1;
1771 }
1772
1773 static void
1774 pre_ta(DECL_ARGS)
1775 {
1776         print_line(".ta", 0);
1777         for (n = n->child; n != NULL; n = n->next)
1778                 print_word(n->string);
1779         outflags |= MMAN_nl;
1780 }
1781
1782 static int
1783 pre_vt(DECL_ARGS)
1784 {
1785
1786         if (NODE_SYNPRETTY & n->flags) {
1787                 switch (n->type) {
1788                 case ROFFT_BLOCK:
1789                         pre_syn(n);
1790                         return 1;
1791                 case ROFFT_BODY:
1792                         break;
1793                 default:
1794                         return 0;
1795                 }
1796         }
1797         font_push('I');
1798         return 1;
1799 }
1800
1801 static void
1802 post_vt(DECL_ARGS)
1803 {
1804
1805         if (n->flags & NODE_SYNPRETTY && n->type != ROFFT_BODY)
1806                 return;
1807         font_pop();
1808 }
1809
1810 static int
1811 pre_xr(DECL_ARGS)
1812 {
1813
1814         n = n->child;
1815         if (NULL == n)
1816                 return 0;
1817         print_node(meta, n);
1818         n = n->next;
1819         if (NULL == n)
1820                 return 0;
1821         outflags &= ~MMAN_spc;
1822         print_word("(");
1823         print_node(meta, n);
1824         print_word(")");
1825         return 0;
1826 }