contrib/mdocml/mdoc_man.c

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