contrib/mandoc/mdoc_man.c

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