contrib/mdocml/mdoc_html.c

   1 /*      $Id: mdoc_html.c,v 1.216 2014/12/02 10:08:06 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2014 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28
  29 #include "mandoc_aux.h"
  30 #include "mdoc.h"
  31 #include "out.h"
  32 #include "html.h"
  33 #include "main.h"
  34
  35 #define INDENT           5
  36
  37 #define MDOC_ARGS         const struct mdoc_meta *meta, \
  38                           const struct mdoc_node *n, \
  39                           struct html *h
  40
  41 #ifndef MIN
  42 #define MIN(a,b)        ((/*CONSTCOND*/(a)<(b))?(a):(b))
  43 #endif
  44
  45 struct  htmlmdoc {
  46         int             (*pre)(MDOC_ARGS);
  47         void            (*post)(MDOC_ARGS);
  48 };
  49
  50 static  void              print_mdoc(MDOC_ARGS);
  51 static  void              print_mdoc_head(MDOC_ARGS);
  52 static  void              print_mdoc_node(MDOC_ARGS);
  53 static  void              print_mdoc_nodelist(MDOC_ARGS);
  54 static  void              synopsis_pre(struct html *,
  55                                 const struct mdoc_node *);
  56
  57 static  void              a2width(const char *, struct roffsu *);
  58
  59 static  void              mdoc_root_post(MDOC_ARGS);
  60 static  int               mdoc_root_pre(MDOC_ARGS);
  61
  62 static  void              mdoc__x_post(MDOC_ARGS);
  63 static  int               mdoc__x_pre(MDOC_ARGS);
  64 static  int               mdoc_ad_pre(MDOC_ARGS);
  65 static  int               mdoc_an_pre(MDOC_ARGS);
  66 static  int               mdoc_ap_pre(MDOC_ARGS);
  67 static  int               mdoc_ar_pre(MDOC_ARGS);
  68 static  int               mdoc_bd_pre(MDOC_ARGS);
  69 static  int               mdoc_bf_pre(MDOC_ARGS);
  70 static  void              mdoc_bk_post(MDOC_ARGS);
  71 static  int               mdoc_bk_pre(MDOC_ARGS);
  72 static  int               mdoc_bl_pre(MDOC_ARGS);
  73 static  int               mdoc_bt_pre(MDOC_ARGS);
  74 static  int               mdoc_bx_pre(MDOC_ARGS);
  75 static  int               mdoc_cd_pre(MDOC_ARGS);
  76 static  int               mdoc_d1_pre(MDOC_ARGS);
  77 static  int               mdoc_dv_pre(MDOC_ARGS);
  78 static  int               mdoc_fa_pre(MDOC_ARGS);
  79 static  int               mdoc_fd_pre(MDOC_ARGS);
  80 static  int               mdoc_fl_pre(MDOC_ARGS);
  81 static  int               mdoc_fn_pre(MDOC_ARGS);
  82 static  int               mdoc_ft_pre(MDOC_ARGS);
  83 static  int               mdoc_em_pre(MDOC_ARGS);
  84 static  int               mdoc_er_pre(MDOC_ARGS);
  85 static  int               mdoc_ev_pre(MDOC_ARGS);
  86 static  int               mdoc_ex_pre(MDOC_ARGS);
  87 static  void              mdoc_fo_post(MDOC_ARGS);
  88 static  int               mdoc_fo_pre(MDOC_ARGS);
  89 static  int               mdoc_ic_pre(MDOC_ARGS);
  90 static  int               mdoc_igndelim_pre(MDOC_ARGS);
  91 static  int               mdoc_in_pre(MDOC_ARGS);
  92 static  int               mdoc_it_pre(MDOC_ARGS);
  93 static  int               mdoc_lb_pre(MDOC_ARGS);
  94 static  int               mdoc_li_pre(MDOC_ARGS);
  95 static  int               mdoc_lk_pre(MDOC_ARGS);
  96 static  int               mdoc_mt_pre(MDOC_ARGS);
  97 static  int               mdoc_ms_pre(MDOC_ARGS);
  98 static  int               mdoc_nd_pre(MDOC_ARGS);
  99 static  int               mdoc_nm_pre(MDOC_ARGS);
 100 static  int               mdoc_no_pre(MDOC_ARGS);
 101 static  int               mdoc_ns_pre(MDOC_ARGS);
 102 static  int               mdoc_pa_pre(MDOC_ARGS);
 103 static  void              mdoc_pf_post(MDOC_ARGS);
 104 static  int               mdoc_pp_pre(MDOC_ARGS);
 105 static  void              mdoc_quote_post(MDOC_ARGS);
 106 static  int               mdoc_quote_pre(MDOC_ARGS);
 107 static  int               mdoc_rs_pre(MDOC_ARGS);
 108 static  int               mdoc_rv_pre(MDOC_ARGS);
 109 static  int               mdoc_sh_pre(MDOC_ARGS);
 110 static  int               mdoc_skip_pre(MDOC_ARGS);
 111 static  int               mdoc_sm_pre(MDOC_ARGS);
 112 static  int               mdoc_sp_pre(MDOC_ARGS);
 113 static  int               mdoc_ss_pre(MDOC_ARGS);
 114 static  int               mdoc_sx_pre(MDOC_ARGS);
 115 static  int               mdoc_sy_pre(MDOC_ARGS);
 116 static  int               mdoc_ud_pre(MDOC_ARGS);
 117 static  int               mdoc_va_pre(MDOC_ARGS);
 118 static  int               mdoc_vt_pre(MDOC_ARGS);
 119 static  int               mdoc_xr_pre(MDOC_ARGS);
 120 static  int               mdoc_xx_pre(MDOC_ARGS);
 121
 122 static  const struct htmlmdoc mdocs[MDOC_MAX] = {
 123         {mdoc_ap_pre, NULL}, /* Ap */
 124         {NULL, NULL}, /* Dd */
 125         {NULL, NULL}, /* Dt */
 126         {NULL, NULL}, /* Os */
 127         {mdoc_sh_pre, NULL }, /* Sh */
 128         {mdoc_ss_pre, NULL }, /* Ss */
 129         {mdoc_pp_pre, NULL}, /* Pp */
 130         {mdoc_d1_pre, NULL}, /* D1 */
 131         {mdoc_d1_pre, NULL}, /* Dl */
 132         {mdoc_bd_pre, NULL}, /* Bd */
 133         {NULL, NULL}, /* Ed */
 134         {mdoc_bl_pre, NULL}, /* Bl */
 135         {NULL, NULL}, /* El */
 136         {mdoc_it_pre, NULL}, /* It */
 137         {mdoc_ad_pre, NULL}, /* Ad */
 138         {mdoc_an_pre, NULL}, /* An */
 139         {mdoc_ar_pre, NULL}, /* Ar */
 140         {mdoc_cd_pre, NULL}, /* Cd */
 141         {mdoc_fl_pre, NULL}, /* Cm */
 142         {mdoc_dv_pre, NULL}, /* Dv */
 143         {mdoc_er_pre, NULL}, /* Er */
 144         {mdoc_ev_pre, NULL}, /* Ev */
 145         {mdoc_ex_pre, NULL}, /* Ex */
 146         {mdoc_fa_pre, NULL}, /* Fa */
 147         {mdoc_fd_pre, NULL}, /* Fd */
 148         {mdoc_fl_pre, NULL}, /* Fl */
 149         {mdoc_fn_pre, NULL}, /* Fn */
 150         {mdoc_ft_pre, NULL}, /* Ft */
 151         {mdoc_ic_pre, NULL}, /* Ic */
 152         {mdoc_in_pre, NULL}, /* In */
 153         {mdoc_li_pre, NULL}, /* Li */
 154         {mdoc_nd_pre, NULL}, /* Nd */
 155         {mdoc_nm_pre, NULL}, /* Nm */
 156         {mdoc_quote_pre, mdoc_quote_post}, /* Op */
 157         {mdoc_ft_pre, NULL}, /* Ot */
 158         {mdoc_pa_pre, NULL}, /* Pa */
 159         {mdoc_rv_pre, NULL}, /* Rv */
 160         {NULL, NULL}, /* St */
 161         {mdoc_va_pre, NULL}, /* Va */
 162         {mdoc_vt_pre, NULL}, /* Vt */
 163         {mdoc_xr_pre, NULL}, /* Xr */
 164         {mdoc__x_pre, mdoc__x_post}, /* %A */
 165         {mdoc__x_pre, mdoc__x_post}, /* %B */
 166         {mdoc__x_pre, mdoc__x_post}, /* %D */
 167         {mdoc__x_pre, mdoc__x_post}, /* %I */
 168         {mdoc__x_pre, mdoc__x_post}, /* %J */
 169         {mdoc__x_pre, mdoc__x_post}, /* %N */
 170         {mdoc__x_pre, mdoc__x_post}, /* %O */
 171         {mdoc__x_pre, mdoc__x_post}, /* %P */
 172         {mdoc__x_pre, mdoc__x_post}, /* %R */
 173         {mdoc__x_pre, mdoc__x_post}, /* %T */
 174         {mdoc__x_pre, mdoc__x_post}, /* %V */
 175         {NULL, NULL}, /* Ac */
 176         {mdoc_quote_pre, mdoc_quote_post}, /* Ao */
 177         {mdoc_quote_pre, mdoc_quote_post}, /* Aq */
 178         {NULL, NULL}, /* At */
 179         {NULL, NULL}, /* Bc */
 180         {mdoc_bf_pre, NULL}, /* Bf */
 181         {mdoc_quote_pre, mdoc_quote_post}, /* Bo */
 182         {mdoc_quote_pre, mdoc_quote_post}, /* Bq */
 183         {mdoc_xx_pre, NULL}, /* Bsx */
 184         {mdoc_bx_pre, NULL}, /* Bx */
 185         {mdoc_skip_pre, NULL}, /* Db */
 186         {NULL, NULL}, /* Dc */
 187         {mdoc_quote_pre, mdoc_quote_post}, /* Do */
 188         {mdoc_quote_pre, mdoc_quote_post}, /* Dq */
 189         {NULL, NULL}, /* Ec */ /* FIXME: no space */
 190         {NULL, NULL}, /* Ef */
 191         {mdoc_em_pre, NULL}, /* Em */
 192         {mdoc_quote_pre, mdoc_quote_post}, /* Eo */
 193         {mdoc_xx_pre, NULL}, /* Fx */
 194         {mdoc_ms_pre, NULL}, /* Ms */
 195         {mdoc_no_pre, NULL}, /* No */
 196         {mdoc_ns_pre, NULL}, /* Ns */
 197         {mdoc_xx_pre, NULL}, /* Nx */
 198         {mdoc_xx_pre, NULL}, /* Ox */
 199         {NULL, NULL}, /* Pc */
 200         {mdoc_igndelim_pre, mdoc_pf_post}, /* Pf */
 201         {mdoc_quote_pre, mdoc_quote_post}, /* Po */
 202         {mdoc_quote_pre, mdoc_quote_post}, /* Pq */
 203         {NULL, NULL}, /* Qc */
 204         {mdoc_quote_pre, mdoc_quote_post}, /* Ql */
 205         {mdoc_quote_pre, mdoc_quote_post}, /* Qo */
 206         {mdoc_quote_pre, mdoc_quote_post}, /* Qq */
 207         {NULL, NULL}, /* Re */
 208         {mdoc_rs_pre, NULL}, /* Rs */
 209         {NULL, NULL}, /* Sc */
 210         {mdoc_quote_pre, mdoc_quote_post}, /* So */
 211         {mdoc_quote_pre, mdoc_quote_post}, /* Sq */
 212         {mdoc_sm_pre, NULL}, /* Sm */
 213         {mdoc_sx_pre, NULL}, /* Sx */
 214         {mdoc_sy_pre, NULL}, /* Sy */
 215         {NULL, NULL}, /* Tn */
 216         {mdoc_xx_pre, NULL}, /* Ux */
 217         {NULL, NULL}, /* Xc */
 218         {NULL, NULL}, /* Xo */
 219         {mdoc_fo_pre, mdoc_fo_post}, /* Fo */
 220         {NULL, NULL}, /* Fc */
 221         {mdoc_quote_pre, mdoc_quote_post}, /* Oo */
 222         {NULL, NULL}, /* Oc */
 223         {mdoc_bk_pre, mdoc_bk_post}, /* Bk */
 224         {NULL, NULL}, /* Ek */
 225         {mdoc_bt_pre, NULL}, /* Bt */
 226         {NULL, NULL}, /* Hf */
 227         {mdoc_em_pre, NULL}, /* Fr */
 228         {mdoc_ud_pre, NULL}, /* Ud */
 229         {mdoc_lb_pre, NULL}, /* Lb */
 230         {mdoc_pp_pre, NULL}, /* Lp */
 231         {mdoc_lk_pre, NULL}, /* Lk */
 232         {mdoc_mt_pre, NULL}, /* Mt */
 233         {mdoc_quote_pre, mdoc_quote_post}, /* Brq */
 234         {mdoc_quote_pre, mdoc_quote_post}, /* Bro */
 235         {NULL, NULL}, /* Brc */
 236         {mdoc__x_pre, mdoc__x_post}, /* %C */
 237         {mdoc_skip_pre, NULL}, /* Es */
 238         {mdoc_quote_pre, mdoc_quote_post}, /* En */
 239         {mdoc_xx_pre, NULL}, /* Dx */
 240         {mdoc__x_pre, mdoc__x_post}, /* %Q */
 241         {mdoc_sp_pre, NULL}, /* br */
 242         {mdoc_sp_pre, NULL}, /* sp */
 243         {mdoc__x_pre, mdoc__x_post}, /* %U */
 244         {NULL, NULL}, /* Ta */
 245         {mdoc_skip_pre, NULL}, /* ll */
 246 };
 247
 248 static  const char * const lists[LIST_MAX] = {
 249         NULL,
 250         "list-bul",
 251         "list-col",
 252         "list-dash",
 253         "list-diag",
 254         "list-enum",
 255         "list-hang",
 256         "list-hyph",
 257         "list-inset",
 258         "list-item",
 259         "list-ohang",
 260         "list-tag"
 261 };
 262
 263
 264 void
 265 html_mdoc(void *arg, const struct mdoc *mdoc)
 266 {
 267
 268         print_mdoc(mdoc_meta(mdoc), mdoc_node(mdoc),
 269             (struct html *)arg);
 270         putchar('\n');
 271 }
 272
 273 /*
 274  * Calculate the scaling unit passed in a `-width' argument.  This uses
 275  * either a native scaling unit (e.g., 1i, 2m) or the string length of
 276  * the value.
 277  */
 278 static void
 279 a2width(const char *p, struct roffsu *su)
 280 {
 281
 282         if ( ! a2roffsu(p, su, SCALE_MAX)) {
 283                 su->unit = SCALE_EN;
 284                 su->scale = html_strlen(p);
 285         }
 286 }
 287
 288 /*
 289  * See the same function in mdoc_term.c for documentation.
 290  */
 291 static void
 292 synopsis_pre(struct html *h, const struct mdoc_node *n)
 293 {
 294
 295         if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))
 296                 return;
 297
 298         if (n->prev->tok == n->tok &&
 299             MDOC_Fo != n->tok &&
 300             MDOC_Ft != n->tok &&
 301             MDOC_Fn != n->tok) {
 302                 print_otag(h, TAG_BR, 0, NULL);
 303                 return;
 304         }
 305
 306         switch (n->prev->tok) {
 307         case MDOC_Fd:
 308                 /* FALLTHROUGH */
 309         case MDOC_Fn:
 310                 /* FALLTHROUGH */
 311         case MDOC_Fo:
 312                 /* FALLTHROUGH */
 313         case MDOC_In:
 314                 /* FALLTHROUGH */
 315         case MDOC_Vt:
 316                 print_paragraph(h);
 317                 break;
 318         case MDOC_Ft:
 319                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
 320                         print_paragraph(h);
 321                         break;
 322                 }
 323                 /* FALLTHROUGH */
 324         default:
 325                 print_otag(h, TAG_BR, 0, NULL);
 326                 break;
 327         }
 328 }
 329
 330 static void
 331 print_mdoc(MDOC_ARGS)
 332 {
 333         struct tag      *t, *tt;
 334         struct htmlpair  tag;
 335
 336         PAIR_CLASS_INIT(&tag, "mandoc");
 337
 338         if ( ! (HTML_FRAGMENT & h->oflags)) {
 339                 print_gen_decls(h);
 340                 t = print_otag(h, TAG_HTML, 0, NULL);
 341                 tt = print_otag(h, TAG_HEAD, 0, NULL);
 342                 print_mdoc_head(meta, n, h);
 343                 print_tagq(h, tt);
 344                 print_otag(h, TAG_BODY, 0, NULL);
 345                 print_otag(h, TAG_DIV, 1, &tag);
 346         } else
 347                 t = print_otag(h, TAG_DIV, 1, &tag);
 348
 349         print_mdoc_nodelist(meta, n, h);
 350         print_tagq(h, t);
 351 }
 352
 353 static void
 354 print_mdoc_head(MDOC_ARGS)
 355 {
 356
 357         print_gen_head(h);
 358         bufinit(h);
 359         bufcat(h, meta->title);
 360         if (meta->msec)
 361                 bufcat_fmt(h, "(%s)", meta->msec);
 362         if (meta->arch)
 363                 bufcat_fmt(h, " (%s)", meta->arch);
 364
 365         print_otag(h, TAG_TITLE, 0, NULL);
 366         print_text(h, h->buf);
 367 }
 368
 369 static void
 370 print_mdoc_nodelist(MDOC_ARGS)
 371 {
 372
 373         print_mdoc_node(meta, n, h);
 374         if (n->next)
 375                 print_mdoc_nodelist(meta, n->next, h);
 376 }
 377
 378 static void
 379 print_mdoc_node(MDOC_ARGS)
 380 {
 381         int              child;
 382         struct tag      *t;
 383
 384         child = 1;
 385         t = h->tags.head;
 386
 387         switch (n->type) {
 388         case MDOC_ROOT:
 389                 child = mdoc_root_pre(meta, n, h);
 390                 break;
 391         case MDOC_TEXT:
 392                 /* No tables in this mode... */
 393                 assert(NULL == h->tblt);
 394
 395                 /*
 396                  * Make sure that if we're in a literal mode already
 397                  * (i.e., within a <PRE>) don't print the newline.
 398                  */
 399                 if (' ' == *n->string && MDOC_LINE & n->flags)
 400                         if ( ! (HTML_LITERAL & h->flags))
 401                                 print_otag(h, TAG_BR, 0, NULL);
 402                 if (MDOC_DELIMC & n->flags)
 403                         h->flags |= HTML_NOSPACE;
 404                 print_text(h, n->string);
 405                 if (MDOC_DELIMO & n->flags)
 406                         h->flags |= HTML_NOSPACE;
 407                 return;
 408         case MDOC_EQN:
 409                 print_eqn(h, n->eqn);
 410                 break;
 411         case MDOC_TBL:
 412                 /*
 413                  * This will take care of initialising all of the table
 414                  * state data for the first table, then tearing it down
 415                  * for the last one.
 416                  */
 417                 print_tbl(h, n->span);
 418                 return;
 419         default:
 420                 /*
 421                  * Close out the current table, if it's open, and unset
 422                  * the "meta" table state.  This will be reopened on the
 423                  * next table element.
 424                  */
 425                 if (h->tblt != NULL) {
 426                         print_tblclose(h);
 427                         t = h->tags.head;
 428                 }
 429                 assert(h->tblt == NULL);
 430                 if (mdocs[n->tok].pre && (n->end == ENDBODY_NOT || n->child))
 431                         child = (*mdocs[n->tok].pre)(meta, n, h);
 432                 break;
 433         }
 434
 435         if (HTML_KEEP & h->flags) {
 436                 if (n->prev ? (n->prev->lastline != n->line) :
 437                     (n->parent && n->parent->line != n->line)) {
 438                         h->flags &= ~HTML_KEEP;
 439                         h->flags |= HTML_PREKEEP;
 440                 }
 441         }
 442
 443         if (child && n->child)
 444                 print_mdoc_nodelist(meta, n->child, h);
 445
 446         print_stagq(h, t);
 447
 448         switch (n->type) {
 449         case MDOC_ROOT:
 450                 mdoc_root_post(meta, n, h);
 451                 break;
 452         case MDOC_EQN:
 453                 break;
 454         default:
 455                 if ( ! mdocs[n->tok].post || n->flags & MDOC_ENDED)
 456                         break;
 457                 (*mdocs[n->tok].post)(meta, n, h);
 458                 if (n->end != ENDBODY_NOT)
 459                         n->pending->flags |= MDOC_ENDED;
 460                 if (n->end == ENDBODY_NOSPACE)
 461                         h->flags |= HTML_NOSPACE;
 462                 break;
 463         }
 464 }
 465
 466 static void
 467 mdoc_root_post(MDOC_ARGS)
 468 {
 469         struct htmlpair  tag;
 470         struct tag      *t, *tt;
 471
 472         PAIR_CLASS_INIT(&tag, "foot");
 473         t = print_otag(h, TAG_TABLE, 1, &tag);
 474
 475         print_otag(h, TAG_TBODY, 0, NULL);
 476
 477         tt = print_otag(h, TAG_TR, 0, NULL);
 478
 479         PAIR_CLASS_INIT(&tag, "foot-date");
 480         print_otag(h, TAG_TD, 1, &tag);
 481         print_text(h, meta->date);
 482         print_stagq(h, tt);
 483
 484         PAIR_CLASS_INIT(&tag, "foot-os");
 485         print_otag(h, TAG_TD, 1, &tag);
 486         print_text(h, meta->os);
 487         print_tagq(h, t);
 488 }
 489
 490 static int
 491 mdoc_root_pre(MDOC_ARGS)
 492 {
 493         struct htmlpair  tag;
 494         struct tag      *t, *tt;
 495         char            *volume, *title;
 496
 497         if (NULL == meta->arch)
 498                 volume = mandoc_strdup(meta->vol);
 499         else
 500                 mandoc_asprintf(&volume, "%s (%s)",
 501                     meta->vol, meta->arch);
 502
 503         if (NULL == meta->msec)
 504                 title = mandoc_strdup(meta->title);
 505         else
 506                 mandoc_asprintf(&title, "%s(%s)",
 507                     meta->title, meta->msec);
 508
 509         PAIR_CLASS_INIT(&tag, "head");
 510         t = print_otag(h, TAG_TABLE, 1, &tag);
 511
 512         print_otag(h, TAG_TBODY, 0, NULL);
 513
 514         tt = print_otag(h, TAG_TR, 0, NULL);
 515
 516         PAIR_CLASS_INIT(&tag, "head-ltitle");
 517         print_otag(h, TAG_TD, 1, &tag);
 518         print_text(h, title);
 519         print_stagq(h, tt);
 520
 521         PAIR_CLASS_INIT(&tag, "head-vol");
 522         print_otag(h, TAG_TD, 1, &tag);
 523         print_text(h, volume);
 524         print_stagq(h, tt);
 525
 526         PAIR_CLASS_INIT(&tag, "head-rtitle");
 527         print_otag(h, TAG_TD, 1, &tag);
 528         print_text(h, title);
 529         print_tagq(h, t);
 530
 531         free(title);
 532         free(volume);
 533         return(1);
 534 }
 535
 536 static int
 537 mdoc_sh_pre(MDOC_ARGS)
 538 {
 539         struct htmlpair  tag;
 540
 541         switch (n->type) {
 542         case MDOC_BLOCK:
 543                 PAIR_CLASS_INIT(&tag, "section");
 544                 print_otag(h, TAG_DIV, 1, &tag);
 545                 return(1);
 546         case MDOC_BODY:
 547                 if (n->sec == SEC_AUTHORS)
 548                         h->flags &= ~(HTML_SPLIT|HTML_NOSPLIT);
 549                 return(1);
 550         default:
 551                 break;
 552         }
 553
 554         bufinit(h);
 555         bufcat(h, "x");
 556
 557         for (n = n->child; n && MDOC_TEXT == n->type; ) {
 558                 bufcat_id(h, n->string);
 559                 if (NULL != (n = n->next))
 560                         bufcat_id(h, " ");
 561         }
 562
 563         if (NULL == n) {
 564                 PAIR_ID_INIT(&tag, h->buf);
 565                 print_otag(h, TAG_H1, 1, &tag);
 566         } else
 567                 print_otag(h, TAG_H1, 0, NULL);
 568
 569         return(1);
 570 }
 571
 572 static int
 573 mdoc_ss_pre(MDOC_ARGS)
 574 {
 575         struct htmlpair  tag;
 576
 577         if (MDOC_BLOCK == n->type) {
 578                 PAIR_CLASS_INIT(&tag, "subsection");
 579                 print_otag(h, TAG_DIV, 1, &tag);
 580                 return(1);
 581         } else if (MDOC_BODY == n->type)
 582                 return(1);
 583
 584         bufinit(h);
 585         bufcat(h, "x");
 586
 587         for (n = n->child; n && MDOC_TEXT == n->type; ) {
 588                 bufcat_id(h, n->string);
 589                 if (NULL != (n = n->next))
 590                         bufcat_id(h, " ");
 591         }
 592
 593         if (NULL == n) {
 594                 PAIR_ID_INIT(&tag, h->buf);
 595                 print_otag(h, TAG_H2, 1, &tag);
 596         } else
 597                 print_otag(h, TAG_H2, 0, NULL);
 598
 599         return(1);
 600 }
 601
 602 static int
 603 mdoc_fl_pre(MDOC_ARGS)
 604 {
 605         struct htmlpair  tag;
 606
 607         PAIR_CLASS_INIT(&tag, "flag");
 608         print_otag(h, TAG_B, 1, &tag);
 609
 610         /* `Cm' has no leading hyphen. */
 611
 612         if (MDOC_Cm == n->tok)
 613                 return(1);
 614
 615         print_text(h, "\\-");
 616
 617         if ( ! (n->nchild == 0 &&
 618             (n->next == NULL ||
 619              n->next->type == MDOC_TEXT ||
 620              n->next->flags & MDOC_LINE)))
 621                 h->flags |= HTML_NOSPACE;
 622
 623         return(1);
 624 }
 625
 626 static int
 627 mdoc_nd_pre(MDOC_ARGS)
 628 {
 629         struct htmlpair  tag;
 630
 631         if (MDOC_BODY != n->type)
 632                 return(1);
 633
 634         /* XXX: this tag in theory can contain block elements. */
 635
 636         print_text(h, "\\(em");
 637         PAIR_CLASS_INIT(&tag, "desc");
 638         print_otag(h, TAG_SPAN, 1, &tag);
 639         return(1);
 640 }
 641
 642 static int
 643 mdoc_nm_pre(MDOC_ARGS)
 644 {
 645         struct htmlpair  tag;
 646         struct roffsu    su;
 647         int              len;
 648
 649         switch (n->type) {
 650         case MDOC_ELEM:
 651                 synopsis_pre(h, n);
 652                 PAIR_CLASS_INIT(&tag, "name");
 653                 print_otag(h, TAG_B, 1, &tag);
 654                 if (NULL == n->child && meta->name)
 655                         print_text(h, meta->name);
 656                 return(1);
 657         case MDOC_HEAD:
 658                 print_otag(h, TAG_TD, 0, NULL);
 659                 if (NULL == n->child && meta->name)
 660                         print_text(h, meta->name);
 661                 return(1);
 662         case MDOC_BODY:
 663                 print_otag(h, TAG_TD, 0, NULL);
 664                 return(1);
 665         default:
 666                 break;
 667         }
 668
 669         synopsis_pre(h, n);
 670         PAIR_CLASS_INIT(&tag, "synopsis");
 671         print_otag(h, TAG_TABLE, 1, &tag);
 672
 673         for (len = 0, n = n->child; n; n = n->next)
 674                 if (MDOC_TEXT == n->type)
 675                         len += html_strlen(n->string);
 676
 677         if (0 == len && meta->name)
 678                 len = html_strlen(meta->name);
 679
 680         SCALE_HS_INIT(&su, len);
 681         bufinit(h);
 682         bufcat_su(h, "width", &su);
 683         PAIR_STYLE_INIT(&tag, h);
 684         print_otag(h, TAG_COL, 1, &tag);
 685         print_otag(h, TAG_COL, 0, NULL);
 686         print_otag(h, TAG_TBODY, 0, NULL);
 687         print_otag(h, TAG_TR, 0, NULL);
 688         return(1);
 689 }
 690
 691 static int
 692 mdoc_xr_pre(MDOC_ARGS)
 693 {
 694         struct htmlpair  tag[2];
 695
 696         if (NULL == n->child)
 697                 return(0);
 698
 699         PAIR_CLASS_INIT(&tag[0], "link-man");
 700
 701         if (h->base_man) {
 702                 buffmt_man(h, n->child->string,
 703                     n->child->next ?
 704                     n->child->next->string : NULL);
 705                 PAIR_HREF_INIT(&tag[1], h->buf);
 706                 print_otag(h, TAG_A, 2, tag);
 707         } else
 708                 print_otag(h, TAG_A, 1, tag);
 709
 710         n = n->child;
 711         print_text(h, n->string);
 712
 713         if (NULL == (n = n->next))
 714                 return(0);
 715
 716         h->flags |= HTML_NOSPACE;
 717         print_text(h, "(");
 718         h->flags |= HTML_NOSPACE;
 719         print_text(h, n->string);
 720         h->flags |= HTML_NOSPACE;
 721         print_text(h, ")");
 722         return(0);
 723 }
 724
 725 static int
 726 mdoc_ns_pre(MDOC_ARGS)
 727 {
 728
 729         if ( ! (MDOC_LINE & n->flags))
 730                 h->flags |= HTML_NOSPACE;
 731         return(1);
 732 }
 733
 734 static int
 735 mdoc_ar_pre(MDOC_ARGS)
 736 {
 737         struct htmlpair tag;
 738
 739         PAIR_CLASS_INIT(&tag, "arg");
 740         print_otag(h, TAG_I, 1, &tag);
 741         return(1);
 742 }
 743
 744 static int
 745 mdoc_xx_pre(MDOC_ARGS)
 746 {
 747         const char      *pp;
 748         struct htmlpair  tag;
 749         int              flags;
 750
 751         switch (n->tok) {
 752         case MDOC_Bsx:
 753                 pp = "BSD/OS";
 754                 break;
 755         case MDOC_Dx:
 756                 pp = "DragonFly";
 757                 break;
 758         case MDOC_Fx:
 759                 pp = "FreeBSD";
 760                 break;
 761         case MDOC_Nx:
 762                 pp = "NetBSD";
 763                 break;
 764         case MDOC_Ox:
 765                 pp = "OpenBSD";
 766                 break;
 767         case MDOC_Ux:
 768                 pp = "UNIX";
 769                 break;
 770         default:
 771                 return(1);
 772         }
 773
 774         PAIR_CLASS_INIT(&tag, "unix");
 775         print_otag(h, TAG_SPAN, 1, &tag);
 776
 777         print_text(h, pp);
 778         if (n->child) {
 779                 flags = h->flags;
 780                 h->flags |= HTML_KEEP;
 781                 print_text(h, n->child->string);
 782                 h->flags = flags;
 783         }
 784         return(0);
 785 }
 786
 787 static int
 788 mdoc_bx_pre(MDOC_ARGS)
 789 {
 790         struct htmlpair  tag;
 791
 792         PAIR_CLASS_INIT(&tag, "unix");
 793         print_otag(h, TAG_SPAN, 1, &tag);
 794
 795         if (NULL != (n = n->child)) {
 796                 print_text(h, n->string);
 797                 h->flags |= HTML_NOSPACE;
 798                 print_text(h, "BSD");
 799         } else {
 800                 print_text(h, "BSD");
 801                 return(0);
 802         }
 803
 804         if (NULL != (n = n->next)) {
 805                 h->flags |= HTML_NOSPACE;
 806                 print_text(h, "-");
 807                 h->flags |= HTML_NOSPACE;
 808                 print_text(h, n->string);
 809         }
 810
 811         return(0);
 812 }
 813
 814 static int
 815 mdoc_it_pre(MDOC_ARGS)
 816 {
 817         struct roffsu    su;
 818         enum mdoc_list   type;
 819         struct htmlpair  tag[2];
 820         const struct mdoc_node *bl;
 821
 822         bl = n->parent;
 823         while (bl && MDOC_Bl != bl->tok)
 824                 bl = bl->parent;
 825
 826         assert(bl);
 827
 828         type = bl->norm->Bl.type;
 829
 830         assert(lists[type]);
 831         PAIR_CLASS_INIT(&tag[0], lists[type]);
 832
 833         bufinit(h);
 834
 835         if (MDOC_HEAD == n->type) {
 836                 switch (type) {
 837                 case LIST_bullet:
 838                         /* FALLTHROUGH */
 839                 case LIST_dash:
 840                         /* FALLTHROUGH */
 841                 case LIST_item:
 842                         /* FALLTHROUGH */
 843                 case LIST_hyphen:
 844                         /* FALLTHROUGH */
 845                 case LIST_enum:
 846                         return(0);
 847                 case LIST_diag:
 848                         /* FALLTHROUGH */
 849                 case LIST_hang:
 850                         /* FALLTHROUGH */
 851                 case LIST_inset:
 852                         /* FALLTHROUGH */
 853                 case LIST_ohang:
 854                         /* FALLTHROUGH */
 855                 case LIST_tag:
 856                         SCALE_VS_INIT(&su, ! bl->norm->Bl.comp);
 857                         bufcat_su(h, "margin-top", &su);
 858                         PAIR_STYLE_INIT(&tag[1], h);
 859                         print_otag(h, TAG_DT, 2, tag);
 860                         if (LIST_diag != type)
 861                                 break;
 862                         PAIR_CLASS_INIT(&tag[0], "diag");
 863                         print_otag(h, TAG_B, 1, tag);
 864                         break;
 865                 case LIST_column:
 866                         break;
 867                 default:
 868                         break;
 869                 }
 870         } else if (MDOC_BODY == n->type) {
 871                 switch (type) {
 872                 case LIST_bullet:
 873                         /* FALLTHROUGH */
 874                 case LIST_hyphen:
 875                         /* FALLTHROUGH */
 876                 case LIST_dash:
 877                         /* FALLTHROUGH */
 878                 case LIST_enum:
 879                         /* FALLTHROUGH */
 880                 case LIST_item:
 881                         SCALE_VS_INIT(&su, ! bl->norm->Bl.comp);
 882                         bufcat_su(h, "margin-top", &su);
 883                         PAIR_STYLE_INIT(&tag[1], h);
 884                         print_otag(h, TAG_LI, 2, tag);
 885                         break;
 886                 case LIST_diag:
 887                         /* FALLTHROUGH */
 888                 case LIST_hang:
 889                         /* FALLTHROUGH */
 890                 case LIST_inset:
 891                         /* FALLTHROUGH */
 892                 case LIST_ohang:
 893                         /* FALLTHROUGH */
 894                 case LIST_tag:
 895                         if (NULL == bl->norm->Bl.width) {
 896                                 print_otag(h, TAG_DD, 1, tag);
 897                                 break;
 898                         }
 899                         a2width(bl->norm->Bl.width, &su);
 900                         bufcat_su(h, "margin-left", &su);
 901                         PAIR_STYLE_INIT(&tag[1], h);
 902                         print_otag(h, TAG_DD, 2, tag);
 903                         break;
 904                 case LIST_column:
 905                         SCALE_VS_INIT(&su, ! bl->norm->Bl.comp);
 906                         bufcat_su(h, "margin-top", &su);
 907                         PAIR_STYLE_INIT(&tag[1], h);
 908                         print_otag(h, TAG_TD, 2, tag);
 909                         break;
 910                 default:
 911                         break;
 912                 }
 913         } else {
 914                 switch (type) {
 915                 case LIST_column:
 916                         print_otag(h, TAG_TR, 1, tag);
 917                         break;
 918                 default:
 919                         break;
 920                 }
 921         }
 922
 923         return(1);
 924 }
 925
 926 static int
 927 mdoc_bl_pre(MDOC_ARGS)
 928 {
 929         int              i;
 930         struct htmlpair  tag[3];
 931         struct roffsu    su;
 932         char             buf[BUFSIZ];
 933
 934         if (MDOC_BODY == n->type) {
 935                 if (LIST_column == n->norm->Bl.type)
 936                         print_otag(h, TAG_TBODY, 0, NULL);
 937                 return(1);
 938         }
 939
 940         if (MDOC_HEAD == n->type) {
 941                 if (LIST_column != n->norm->Bl.type)
 942                         return(0);
 943
 944                 /*
 945                  * For each column, print out the <COL> tag with our
 946                  * suggested width.  The last column gets min-width, as
 947                  * in terminal mode it auto-sizes to the width of the
 948                  * screen and we want to preserve that behaviour.
 949                  */
 950
 951                 for (i = 0; i < (int)n->norm->Bl.ncols; i++) {
 952                         bufinit(h);
 953                         a2width(n->norm->Bl.cols[i], &su);
 954                         if (i < (int)n->norm->Bl.ncols - 1)
 955                                 bufcat_su(h, "width", &su);
 956                         else
 957                                 bufcat_su(h, "min-width", &su);
 958                         PAIR_STYLE_INIT(&tag[0], h);
 959                         print_otag(h, TAG_COL, 1, tag);
 960                 }
 961
 962                 return(0);
 963         }
 964
 965         SCALE_VS_INIT(&su, 0);
 966         bufinit(h);
 967         bufcat_su(h, "margin-top", &su);
 968         bufcat_su(h, "margin-bottom", &su);
 969         PAIR_STYLE_INIT(&tag[0], h);
 970
 971         assert(lists[n->norm->Bl.type]);
 972         (void)strlcpy(buf, "list ", BUFSIZ);
 973         (void)strlcat(buf, lists[n->norm->Bl.type], BUFSIZ);
 974         PAIR_INIT(&tag[1], ATTR_CLASS, buf);
 975
 976         /* Set the block's left-hand margin. */
 977
 978         if (n->norm->Bl.offs) {
 979                 a2width(n->norm->Bl.offs, &su);
 980                 bufcat_su(h, "margin-left", &su);
 981         }
 982
 983         switch (n->norm->Bl.type) {
 984         case LIST_bullet:
 985                 /* FALLTHROUGH */
 986         case LIST_dash:
 987                 /* FALLTHROUGH */
 988         case LIST_hyphen:
 989                 /* FALLTHROUGH */
 990         case LIST_item:
 991                 print_otag(h, TAG_UL, 2, tag);
 992                 break;
 993         case LIST_enum:
 994                 print_otag(h, TAG_OL, 2, tag);
 995                 break;
 996         case LIST_diag:
 997                 /* FALLTHROUGH */
 998         case LIST_hang:
 999                 /* FALLTHROUGH */
1000         case LIST_inset:
1001                 /* FALLTHROUGH */
1002         case LIST_ohang:
1003                 /* FALLTHROUGH */
1004         case LIST_tag:
1005                 print_otag(h, TAG_DL, 2, tag);
1006                 break;
1007         case LIST_column:
1008                 print_otag(h, TAG_TABLE, 2, tag);
1009                 break;
1010         default:
1011                 abort();
1012                 /* NOTREACHED */
1013         }
1014
1015         return(1);
1016 }
1017
1018 static int
1019 mdoc_ex_pre(MDOC_ARGS)
1020 {
1021         struct tag      *t;
1022         struct htmlpair  tag;
1023         int              nchild;
1024
1025         if (n->prev)
1026                 print_otag(h, TAG_BR, 0, NULL);
1027
1028         PAIR_CLASS_INIT(&tag, "utility");
1029
1030         print_text(h, "The");
1031
1032         nchild = n->nchild;
1033         for (n = n->child; n; n = n->next) {
1034                 assert(MDOC_TEXT == n->type);
1035
1036                 t = print_otag(h, TAG_B, 1, &tag);
1037                 print_text(h, n->string);
1038                 print_tagq(h, t);
1039
1040                 if (nchild > 2 && n->next) {
1041                         h->flags |= HTML_NOSPACE;
1042                         print_text(h, ",");
1043                 }
1044
1045                 if (n->next && NULL == n->next->next)
1046                         print_text(h, "and");
1047         }
1048
1049         if (nchild > 1)
1050                 print_text(h, "utilities exit\\~0");
1051         else
1052                 print_text(h, "utility exits\\~0");
1053
1054         print_text(h, "on success, and\\~>0 if an error occurs.");
1055         return(0);
1056 }
1057
1058 static int
1059 mdoc_em_pre(MDOC_ARGS)
1060 {
1061         struct htmlpair tag;
1062
1063         PAIR_CLASS_INIT(&tag, "emph");
1064         print_otag(h, TAG_SPAN, 1, &tag);
1065         return(1);
1066 }
1067
1068 static int
1069 mdoc_d1_pre(MDOC_ARGS)
1070 {
1071         struct htmlpair  tag[2];
1072         struct roffsu    su;
1073
1074         if (MDOC_BLOCK != n->type)
1075                 return(1);
1076
1077         SCALE_VS_INIT(&su, 0);
1078         bufinit(h);
1079         bufcat_su(h, "margin-top", &su);
1080         bufcat_su(h, "margin-bottom", &su);
1081         PAIR_STYLE_INIT(&tag[0], h);
1082         print_otag(h, TAG_BLOCKQUOTE, 1, tag);
1083
1084         /* BLOCKQUOTE needs a block body. */
1085
1086         PAIR_CLASS_INIT(&tag[0], "display");
1087         print_otag(h, TAG_DIV, 1, tag);
1088
1089         if (MDOC_Dl == n->tok) {
1090                 PAIR_CLASS_INIT(&tag[0], "lit");
1091                 print_otag(h, TAG_CODE, 1, tag);
1092         }
1093
1094         return(1);
1095 }
1096
1097 static int
1098 mdoc_sx_pre(MDOC_ARGS)
1099 {
1100         struct htmlpair  tag[2];
1101
1102         bufinit(h);
1103         bufcat(h, "#x");
1104
1105         for (n = n->child; n; ) {
1106                 bufcat_id(h, n->string);
1107                 if (NULL != (n = n->next))
1108                         bufcat_id(h, " ");
1109         }
1110
1111         PAIR_CLASS_INIT(&tag[0], "link-sec");
1112         PAIR_HREF_INIT(&tag[1], h->buf);
1113
1114         print_otag(h, TAG_I, 1, tag);
1115         print_otag(h, TAG_A, 2, tag);
1116         return(1);
1117 }
1118
1119 static int
1120 mdoc_bd_pre(MDOC_ARGS)
1121 {
1122         struct htmlpair          tag[2];
1123         int                      comp, sv;
1124         const struct mdoc_node  *nn;
1125         struct roffsu            su;
1126
1127         if (MDOC_HEAD == n->type)
1128                 return(0);
1129
1130         if (MDOC_BLOCK == n->type) {
1131                 comp = n->norm->Bd.comp;
1132                 for (nn = n; nn && ! comp; nn = nn->parent) {
1133                         if (MDOC_BLOCK != nn->type)
1134                                 continue;
1135                         if (MDOC_Ss == nn->tok || MDOC_Sh == nn->tok)
1136                                 comp = 1;
1137                         if (nn->prev)
1138                                 break;
1139                 }
1140                 if ( ! comp)
1141                         print_paragraph(h);
1142                 return(1);
1143         }
1144
1145         /* Handle the -offset argument. */
1146
1147         if (n->norm->Bd.offs == NULL ||
1148             ! strcmp(n->norm->Bd.offs, "left"))
1149                 SCALE_HS_INIT(&su, 0);
1150         else if ( ! strcmp(n->norm->Bd.offs, "indent"))
1151                 SCALE_HS_INIT(&su, INDENT);
1152         else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))
1153                 SCALE_HS_INIT(&su, INDENT * 2);
1154         else
1155                 a2width(n->norm->Bd.offs, &su);
1156
1157         bufinit(h);
1158         bufcat_su(h, "margin-left", &su);
1159         PAIR_STYLE_INIT(&tag[0], h);
1160
1161         if (DISP_unfilled != n->norm->Bd.type &&
1162             DISP_literal != n->norm->Bd.type) {
1163                 PAIR_CLASS_INIT(&tag[1], "display");
1164                 print_otag(h, TAG_DIV, 2, tag);
1165                 return(1);
1166         }
1167
1168         PAIR_CLASS_INIT(&tag[1], "lit display");
1169         print_otag(h, TAG_PRE, 2, tag);
1170
1171         /* This can be recursive: save & set our literal state. */
1172
1173         sv = h->flags & HTML_LITERAL;
1174         h->flags |= HTML_LITERAL;
1175
1176         for (nn = n->child; nn; nn = nn->next) {
1177                 print_mdoc_node(meta, nn, h);
1178                 /*
1179                  * If the printed node flushes its own line, then we
1180                  * needn't do it here as well.  This is hacky, but the
1181                  * notion of selective eoln whitespace is pretty dumb
1182                  * anyway, so don't sweat it.
1183                  */
1184                 switch (nn->tok) {
1185                 case MDOC_Sm:
1186                         /* FALLTHROUGH */
1187                 case MDOC_br:
1188                         /* FALLTHROUGH */
1189                 case MDOC_sp:
1190                         /* FALLTHROUGH */
1191                 case MDOC_Bl:
1192                         /* FALLTHROUGH */
1193                 case MDOC_D1:
1194                         /* FALLTHROUGH */
1195                 case MDOC_Dl:
1196                         /* FALLTHROUGH */
1197                 case MDOC_Lp:
1198                         /* FALLTHROUGH */
1199                 case MDOC_Pp:
1200                         continue;
1201                 default:
1202                         break;
1203                 }
1204                 if (h->flags & HTML_NONEWLINE ||
1205                     (nn->next && ! (nn->next->flags & MDOC_LINE)))
1206                         continue;
1207                 else if (nn->next)
1208                         print_text(h, "\n");
1209
1210                 h->flags |= HTML_NOSPACE;
1211         }
1212
1213         if (0 == sv)
1214                 h->flags &= ~HTML_LITERAL;
1215
1216         return(0);
1217 }
1218
1219 static int
1220 mdoc_pa_pre(MDOC_ARGS)
1221 {
1222         struct htmlpair tag;
1223
1224         PAIR_CLASS_INIT(&tag, "file");
1225         print_otag(h, TAG_I, 1, &tag);
1226         return(1);
1227 }
1228
1229 static int
1230 mdoc_ad_pre(MDOC_ARGS)
1231 {
1232         struct htmlpair tag;
1233
1234         PAIR_CLASS_INIT(&tag, "addr");
1235         print_otag(h, TAG_I, 1, &tag);
1236         return(1);
1237 }
1238
1239 static int
1240 mdoc_an_pre(MDOC_ARGS)
1241 {
1242         struct htmlpair tag;
1243
1244         if (n->norm->An.auth == AUTH_split) {
1245                 h->flags &= ~HTML_NOSPLIT;
1246                 h->flags |= HTML_SPLIT;
1247                 return(0);
1248         }
1249         if (n->norm->An.auth == AUTH_nosplit) {
1250                 h->flags &= ~HTML_SPLIT;
1251                 h->flags |= HTML_NOSPLIT;
1252                 return(0);
1253         }
1254
1255         if (n->child == NULL)
1256                 return(0);
1257
1258         if (h->flags & HTML_SPLIT)
1259                 print_otag(h, TAG_BR, 0, NULL);
1260
1261         if (n->sec == SEC_AUTHORS && ! (h->flags & HTML_NOSPLIT))
1262                 h->flags |= HTML_SPLIT;
1263
1264         PAIR_CLASS_INIT(&tag, "author");
1265         print_otag(h, TAG_SPAN, 1, &tag);
1266         return(1);
1267 }
1268
1269 static int
1270 mdoc_cd_pre(MDOC_ARGS)
1271 {
1272         struct htmlpair tag;
1273
1274         synopsis_pre(h, n);
1275         PAIR_CLASS_INIT(&tag, "config");
1276         print_otag(h, TAG_B, 1, &tag);
1277         return(1);
1278 }
1279
1280 static int
1281 mdoc_dv_pre(MDOC_ARGS)
1282 {
1283         struct htmlpair tag;
1284
1285         PAIR_CLASS_INIT(&tag, "define");
1286         print_otag(h, TAG_SPAN, 1, &tag);
1287         return(1);
1288 }
1289
1290 static int
1291 mdoc_ev_pre(MDOC_ARGS)
1292 {
1293         struct htmlpair tag;
1294
1295         PAIR_CLASS_INIT(&tag, "env");
1296         print_otag(h, TAG_SPAN, 1, &tag);
1297         return(1);
1298 }
1299
1300 static int
1301 mdoc_er_pre(MDOC_ARGS)
1302 {
1303         struct htmlpair tag;
1304
1305         PAIR_CLASS_INIT(&tag, "errno");
1306         print_otag(h, TAG_SPAN, 1, &tag);
1307         return(1);
1308 }
1309
1310 static int
1311 mdoc_fa_pre(MDOC_ARGS)
1312 {
1313         const struct mdoc_node  *nn;
1314         struct htmlpair          tag;
1315         struct tag              *t;
1316
1317         PAIR_CLASS_INIT(&tag, "farg");
1318         if (n->parent->tok != MDOC_Fo) {
1319                 print_otag(h, TAG_I, 1, &tag);
1320                 return(1);
1321         }
1322
1323         for (nn = n->child; nn; nn = nn->next) {
1324                 t = print_otag(h, TAG_I, 1, &tag);
1325                 print_text(h, nn->string);
1326                 print_tagq(h, t);
1327                 if (nn->next) {
1328                         h->flags |= HTML_NOSPACE;
1329                         print_text(h, ",");
1330                 }
1331         }
1332
1333         if (n->child && n->next && n->next->tok == MDOC_Fa) {
1334                 h->flags |= HTML_NOSPACE;
1335                 print_text(h, ",");
1336         }
1337
1338         return(0);
1339 }
1340
1341 static int
1342 mdoc_fd_pre(MDOC_ARGS)
1343 {
1344         struct htmlpair  tag[2];
1345         char             buf[BUFSIZ];
1346         size_t           sz;
1347         int              i;
1348         struct tag      *t;
1349
1350         synopsis_pre(h, n);
1351
1352         if (NULL == (n = n->child))
1353                 return(0);
1354
1355         assert(MDOC_TEXT == n->type);
1356
1357         if (strcmp(n->string, "#include")) {
1358                 PAIR_CLASS_INIT(&tag[0], "macro");
1359                 print_otag(h, TAG_B, 1, tag);
1360                 return(1);
1361         }
1362
1363         PAIR_CLASS_INIT(&tag[0], "includes");
1364         print_otag(h, TAG_B, 1, tag);
1365         print_text(h, n->string);
1366
1367         if (NULL != (n = n->next)) {
1368                 assert(MDOC_TEXT == n->type);
1369
1370                 /*
1371                  * XXX This is broken and not easy to fix.
1372                  * When using -Oincludes, truncation may occur.
1373                  * Dynamic allocation wouldn't help because
1374                  * passing long strings to buffmt_includes()
1375                  * does not work either.
1376                  */
1377
1378                 strlcpy(buf, '<' == *n->string || '"' == *n->string ?
1379                     n->string + 1 : n->string, BUFSIZ);
1380
1381                 sz = strlen(buf);
1382                 if (sz && ('>' == buf[sz - 1] || '"' == buf[sz - 1]))
1383                         buf[sz - 1] = '\0';
1384
1385                 PAIR_CLASS_INIT(&tag[0], "link-includes");
1386
1387                 i = 1;
1388                 if (h->base_includes) {
1389                         buffmt_includes(h, buf);
1390                         PAIR_HREF_INIT(&tag[i], h->buf);
1391                         i++;
1392                 }
1393
1394                 t = print_otag(h, TAG_A, i, tag);
1395                 print_text(h, n->string);
1396                 print_tagq(h, t);
1397
1398                 n = n->next;
1399         }
1400
1401         for ( ; n; n = n->next) {
1402                 assert(MDOC_TEXT == n->type);
1403                 print_text(h, n->string);
1404         }
1405
1406         return(0);
1407 }
1408
1409 static int
1410 mdoc_vt_pre(MDOC_ARGS)
1411 {
1412         struct htmlpair  tag;
1413
1414         if (MDOC_BLOCK == n->type) {
1415                 synopsis_pre(h, n);
1416                 return(1);
1417         } else if (MDOC_ELEM == n->type) {
1418                 synopsis_pre(h, n);
1419         } else if (MDOC_HEAD == n->type)
1420                 return(0);
1421
1422         PAIR_CLASS_INIT(&tag, "type");
1423         print_otag(h, TAG_SPAN, 1, &tag);
1424         return(1);
1425 }
1426
1427 static int
1428 mdoc_ft_pre(MDOC_ARGS)
1429 {
1430         struct htmlpair  tag;
1431
1432         synopsis_pre(h, n);
1433         PAIR_CLASS_INIT(&tag, "ftype");
1434         print_otag(h, TAG_I, 1, &tag);
1435         return(1);
1436 }
1437
1438 static int
1439 mdoc_fn_pre(MDOC_ARGS)
1440 {
1441         struct tag      *t;
1442         struct htmlpair  tag[2];
1443         char             nbuf[BUFSIZ];
1444         const char      *sp, *ep;
1445         int              sz, i, pretty;
1446
1447         pretty = MDOC_SYNPRETTY & n->flags;
1448         synopsis_pre(h, n);
1449
1450         /* Split apart into type and name. */
1451         assert(n->child->string);
1452         sp = n->child->string;
1453
1454         ep = strchr(sp, ' ');
1455         if (NULL != ep) {
1456                 PAIR_CLASS_INIT(&tag[0], "ftype");
1457                 t = print_otag(h, TAG_I, 1, tag);
1458
1459                 while (ep) {
1460                         sz = MIN((int)(ep - sp), BUFSIZ - 1);
1461                         (void)memcpy(nbuf, sp, (size_t)sz);
1462                         nbuf[sz] = '\0';
1463                         print_text(h, nbuf);
1464                         sp = ++ep;
1465                         ep = strchr(sp, ' ');
1466                 }
1467                 print_tagq(h, t);
1468         }
1469
1470         PAIR_CLASS_INIT(&tag[0], "fname");
1471
1472         /*
1473          * FIXME: only refer to IDs that we know exist.
1474          */
1475
1476 #if 0
1477         if (MDOC_SYNPRETTY & n->flags) {
1478                 nbuf[0] = '\0';
1479                 html_idcat(nbuf, sp, BUFSIZ);
1480                 PAIR_ID_INIT(&tag[1], nbuf);
1481         } else {
1482                 strlcpy(nbuf, "#", BUFSIZ);
1483                 html_idcat(nbuf, sp, BUFSIZ);
1484                 PAIR_HREF_INIT(&tag[1], nbuf);
1485         }
1486 #endif
1487
1488         t = print_otag(h, TAG_B, 1, tag);
1489
1490         if (sp)
1491                 print_text(h, sp);
1492
1493         print_tagq(h, t);
1494
1495         h->flags |= HTML_NOSPACE;
1496         print_text(h, "(");
1497         h->flags |= HTML_NOSPACE;
1498
1499         PAIR_CLASS_INIT(&tag[0], "farg");
1500         bufinit(h);
1501         bufcat_style(h, "white-space", "nowrap");
1502         PAIR_STYLE_INIT(&tag[1], h);
1503
1504         for (n = n->child->next; n; n = n->next) {
1505                 i = 1;
1506                 if (MDOC_SYNPRETTY & n->flags)
1507                         i = 2;
1508                 t = print_otag(h, TAG_I, i, tag);
1509                 print_text(h, n->string);
1510                 print_tagq(h, t);
1511                 if (n->next) {
1512                         h->flags |= HTML_NOSPACE;
1513                         print_text(h, ",");
1514                 }
1515         }
1516
1517         h->flags |= HTML_NOSPACE;
1518         print_text(h, ")");
1519
1520         if (pretty) {
1521                 h->flags |= HTML_NOSPACE;
1522                 print_text(h, ";");
1523         }
1524
1525         return(0);
1526 }
1527
1528 static int
1529 mdoc_sm_pre(MDOC_ARGS)
1530 {
1531
1532         if (NULL == n->child)
1533                 h->flags ^= HTML_NONOSPACE;
1534         else if (0 == strcmp("on", n->child->string))
1535                 h->flags &= ~HTML_NONOSPACE;
1536         else
1537                 h->flags |= HTML_NONOSPACE;
1538
1539         if ( ! (HTML_NONOSPACE & h->flags))
1540                 h->flags &= ~HTML_NOSPACE;
1541
1542         return(0);
1543 }
1544
1545 static int
1546 mdoc_skip_pre(MDOC_ARGS)
1547 {
1548
1549         return(0);
1550 }
1551
1552 static int
1553 mdoc_pp_pre(MDOC_ARGS)
1554 {
1555
1556         print_paragraph(h);
1557         return(0);
1558 }
1559
1560 static int
1561 mdoc_sp_pre(MDOC_ARGS)
1562 {
1563         struct roffsu    su;
1564         struct htmlpair  tag;
1565
1566         SCALE_VS_INIT(&su, 1);
1567
1568         if (MDOC_sp == n->tok) {
1569                 if (NULL != (n = n->child))
1570                         if ( ! a2roffsu(n->string, &su, SCALE_VS))
1571                                 SCALE_VS_INIT(&su, atoi(n->string));
1572         } else
1573                 su.scale = 0.0;
1574
1575         bufinit(h);
1576         bufcat_su(h, "height", &su);
1577         PAIR_STYLE_INIT(&tag, h);
1578         print_otag(h, TAG_DIV, 1, &tag);
1579
1580         /* So the div isn't empty: */
1581         print_text(h, "\\~");
1582
1583         return(0);
1584
1585 }
1586
1587 static int
1588 mdoc_lk_pre(MDOC_ARGS)
1589 {
1590         struct htmlpair  tag[2];
1591
1592         if (NULL == (n = n->child))
1593                 return(0);
1594
1595         assert(MDOC_TEXT == n->type);
1596
1597         PAIR_CLASS_INIT(&tag[0], "link-ext");
1598         PAIR_HREF_INIT(&tag[1], n->string);
1599
1600         print_otag(h, TAG_A, 2, tag);
1601
1602         if (NULL == n->next)
1603                 print_text(h, n->string);
1604
1605         for (n = n->next; n; n = n->next)
1606                 print_text(h, n->string);
1607
1608         return(0);
1609 }
1610
1611 static int
1612 mdoc_mt_pre(MDOC_ARGS)
1613 {
1614         struct htmlpair  tag[2];
1615         struct tag      *t;
1616
1617         PAIR_CLASS_INIT(&tag[0], "link-mail");
1618
1619         for (n = n->child; n; n = n->next) {
1620                 assert(MDOC_TEXT == n->type);
1621
1622                 bufinit(h);
1623                 bufcat(h, "mailto:");
1624                 bufcat(h, n->string);
1625
1626                 PAIR_HREF_INIT(&tag[1], h->buf);
1627                 t = print_otag(h, TAG_A, 2, tag);
1628                 print_text(h, n->string);
1629                 print_tagq(h, t);
1630         }
1631
1632         return(0);
1633 }
1634
1635 static int
1636 mdoc_fo_pre(MDOC_ARGS)
1637 {
1638         struct htmlpair  tag;
1639         struct tag      *t;
1640
1641         if (MDOC_BODY == n->type) {
1642                 h->flags |= HTML_NOSPACE;
1643                 print_text(h, "(");
1644                 h->flags |= HTML_NOSPACE;
1645                 return(1);
1646         } else if (MDOC_BLOCK == n->type) {
1647                 synopsis_pre(h, n);
1648                 return(1);
1649         }
1650
1651         /* XXX: we drop non-initial arguments as per groff. */
1652
1653         assert(n->child);
1654         assert(n->child->string);
1655
1656         PAIR_CLASS_INIT(&tag, "fname");
1657         t = print_otag(h, TAG_B, 1, &tag);
1658         print_text(h, n->child->string);
1659         print_tagq(h, t);
1660         return(0);
1661 }
1662
1663 static void
1664 mdoc_fo_post(MDOC_ARGS)
1665 {
1666
1667         if (MDOC_BODY != n->type)
1668                 return;
1669         h->flags |= HTML_NOSPACE;
1670         print_text(h, ")");
1671         h->flags |= HTML_NOSPACE;
1672         print_text(h, ";");
1673 }
1674
1675 static int
1676 mdoc_in_pre(MDOC_ARGS)
1677 {
1678         struct tag      *t;
1679         struct htmlpair  tag[2];
1680         int              i;
1681
1682         synopsis_pre(h, n);
1683
1684         PAIR_CLASS_INIT(&tag[0], "includes");
1685         print_otag(h, TAG_B, 1, tag);
1686
1687         /*
1688          * The first argument of the `In' gets special treatment as
1689          * being a linked value.  Subsequent values are printed
1690          * afterward.  groff does similarly.  This also handles the case
1691          * of no children.
1692          */
1693
1694         if (MDOC_SYNPRETTY & n->flags && MDOC_LINE & n->flags)
1695                 print_text(h, "#include");
1696
1697         print_text(h, "<");
1698         h->flags |= HTML_NOSPACE;
1699
1700         if (NULL != (n = n->child)) {
1701                 assert(MDOC_TEXT == n->type);
1702
1703                 PAIR_CLASS_INIT(&tag[0], "link-includes");
1704
1705                 i = 1;
1706                 if (h->base_includes) {
1707                         buffmt_includes(h, n->string);
1708                         PAIR_HREF_INIT(&tag[i], h->buf);
1709                         i++;
1710                 }
1711
1712                 t = print_otag(h, TAG_A, i, tag);
1713                 print_text(h, n->string);
1714                 print_tagq(h, t);
1715
1716                 n = n->next;
1717         }
1718
1719         h->flags |= HTML_NOSPACE;
1720         print_text(h, ">");
1721
1722         for ( ; n; n = n->next) {
1723                 assert(MDOC_TEXT == n->type);
1724                 print_text(h, n->string);
1725         }
1726
1727         return(0);
1728 }
1729
1730 static int
1731 mdoc_ic_pre(MDOC_ARGS)
1732 {
1733         struct htmlpair tag;
1734
1735         PAIR_CLASS_INIT(&tag, "cmd");
1736         print_otag(h, TAG_B, 1, &tag);
1737         return(1);
1738 }
1739
1740 static int
1741 mdoc_rv_pre(MDOC_ARGS)
1742 {
1743         struct htmlpair  tag;
1744         struct tag      *t;
1745         int              nchild;
1746
1747         if (n->prev)
1748                 print_otag(h, TAG_BR, 0, NULL);
1749
1750         PAIR_CLASS_INIT(&tag, "fname");
1751
1752         nchild = n->nchild;
1753         if (nchild > 0) {
1754                 print_text(h, "The");
1755
1756                 for (n = n->child; n; n = n->next) {
1757                         t = print_otag(h, TAG_B, 1, &tag);
1758                         print_text(h, n->string);
1759                         print_tagq(h, t);
1760
1761                         h->flags |= HTML_NOSPACE;
1762                         print_text(h, "()");
1763
1764                         if (n->next == NULL)
1765                                 continue;
1766
1767                         if (nchild > 2) {
1768                                 h->flags |= HTML_NOSPACE;
1769                                 print_text(h, ",");
1770                         }
1771                         if (n->next->next == NULL)
1772                                 print_text(h, "and");
1773                 }
1774
1775                 if (nchild > 1)
1776                         print_text(h, "functions return");
1777                 else
1778                         print_text(h, "function returns");
1779
1780                 print_text(h, "the value\\~0 if successful;");
1781         } else
1782                 print_text(h, "Upon successful completion,"
1783                     " the value\\~0 is returned;");
1784
1785         print_text(h, "otherwise the value\\~\\-1 is returned"
1786            " and the global variable");
1787
1788         PAIR_CLASS_INIT(&tag, "var");
1789         t = print_otag(h, TAG_B, 1, &tag);
1790         print_text(h, "errno");
1791         print_tagq(h, t);
1792         print_text(h, "is set to indicate the error.");
1793         return(0);
1794 }
1795
1796 static int
1797 mdoc_va_pre(MDOC_ARGS)
1798 {
1799         struct htmlpair tag;
1800
1801         PAIR_CLASS_INIT(&tag, "var");
1802         print_otag(h, TAG_B, 1, &tag);
1803         return(1);
1804 }
1805
1806 static int
1807 mdoc_ap_pre(MDOC_ARGS)
1808 {
1809
1810         h->flags |= HTML_NOSPACE;
1811         print_text(h, "\\(aq");
1812         h->flags |= HTML_NOSPACE;
1813         return(1);
1814 }
1815
1816 static int
1817 mdoc_bf_pre(MDOC_ARGS)
1818 {
1819         struct htmlpair  tag[2];
1820         struct roffsu    su;
1821
1822         if (MDOC_HEAD == n->type)
1823                 return(0);
1824         else if (MDOC_BODY != n->type)
1825                 return(1);
1826
1827         if (FONT_Em == n->norm->Bf.font)
1828                 PAIR_CLASS_INIT(&tag[0], "emph");
1829         else if (FONT_Sy == n->norm->Bf.font)
1830                 PAIR_CLASS_INIT(&tag[0], "symb");
1831         else if (FONT_Li == n->norm->Bf.font)
1832                 PAIR_CLASS_INIT(&tag[0], "lit");
1833         else
1834                 PAIR_CLASS_INIT(&tag[0], "none");
1835
1836         /*
1837          * We want this to be inline-formatted, but needs to be div to
1838          * accept block children.
1839          */
1840         bufinit(h);
1841         bufcat_style(h, "display", "inline");
1842         SCALE_HS_INIT(&su, 1);
1843         /* Needs a left-margin for spacing. */
1844         bufcat_su(h, "margin-left", &su);
1845         PAIR_STYLE_INIT(&tag[1], h);
1846         print_otag(h, TAG_DIV, 2, tag);
1847         return(1);
1848 }
1849
1850 static int
1851 mdoc_ms_pre(MDOC_ARGS)
1852 {
1853         struct htmlpair tag;
1854
1855         PAIR_CLASS_INIT(&tag, "symb");
1856         print_otag(h, TAG_SPAN, 1, &tag);
1857         return(1);
1858 }
1859
1860 static int
1861 mdoc_igndelim_pre(MDOC_ARGS)
1862 {
1863
1864         h->flags |= HTML_IGNDELIM;
1865         return(1);
1866 }
1867
1868 static void
1869 mdoc_pf_post(MDOC_ARGS)
1870 {
1871
1872         if ( ! (n->next == NULL || n->next->flags & MDOC_LINE))
1873                 h->flags |= HTML_NOSPACE;
1874 }
1875
1876 static int
1877 mdoc_rs_pre(MDOC_ARGS)
1878 {
1879         struct htmlpair  tag;
1880
1881         if (MDOC_BLOCK != n->type)
1882                 return(1);
1883
1884         if (n->prev && SEC_SEE_ALSO == n->sec)
1885                 print_paragraph(h);
1886
1887         PAIR_CLASS_INIT(&tag, "ref");
1888         print_otag(h, TAG_SPAN, 1, &tag);
1889         return(1);
1890 }
1891
1892 static int
1893 mdoc_no_pre(MDOC_ARGS)
1894 {
1895         struct htmlpair tag;
1896
1897         PAIR_CLASS_INIT(&tag, "none");
1898         print_otag(h, TAG_CODE, 1, &tag);
1899         return(1);
1900 }
1901
1902 static int
1903 mdoc_li_pre(MDOC_ARGS)
1904 {
1905         struct htmlpair tag;
1906
1907         PAIR_CLASS_INIT(&tag, "lit");
1908         print_otag(h, TAG_CODE, 1, &tag);
1909         return(1);
1910 }
1911
1912 static int
1913 mdoc_sy_pre(MDOC_ARGS)
1914 {
1915         struct htmlpair tag;
1916
1917         PAIR_CLASS_INIT(&tag, "symb");
1918         print_otag(h, TAG_SPAN, 1, &tag);
1919         return(1);
1920 }
1921
1922 static int
1923 mdoc_bt_pre(MDOC_ARGS)
1924 {
1925
1926         print_text(h, "is currently in beta test.");
1927         return(0);
1928 }
1929
1930 static int
1931 mdoc_ud_pre(MDOC_ARGS)
1932 {
1933
1934         print_text(h, "currently under development.");
1935         return(0);
1936 }
1937
1938 static int
1939 mdoc_lb_pre(MDOC_ARGS)
1940 {
1941         struct htmlpair tag;
1942
1943         if (SEC_LIBRARY == n->sec && MDOC_LINE & n->flags && n->prev)
1944                 print_otag(h, TAG_BR, 0, NULL);
1945
1946         PAIR_CLASS_INIT(&tag, "lib");
1947         print_otag(h, TAG_SPAN, 1, &tag);
1948         return(1);
1949 }
1950
1951 static int
1952 mdoc__x_pre(MDOC_ARGS)
1953 {
1954         struct htmlpair tag[2];
1955         enum htmltag    t;
1956
1957         t = TAG_SPAN;
1958
1959         switch (n->tok) {
1960         case MDOC__A:
1961                 PAIR_CLASS_INIT(&tag[0], "ref-auth");
1962                 if (n->prev && MDOC__A == n->prev->tok)
1963                         if (NULL == n->next || MDOC__A != n->next->tok)
1964                                 print_text(h, "and");
1965                 break;
1966         case MDOC__B:
1967                 PAIR_CLASS_INIT(&tag[0], "ref-book");
1968                 t = TAG_I;
1969                 break;
1970         case MDOC__C:
1971                 PAIR_CLASS_INIT(&tag[0], "ref-city");
1972                 break;
1973         case MDOC__D:
1974                 PAIR_CLASS_INIT(&tag[0], "ref-date");
1975                 break;
1976         case MDOC__I:
1977                 PAIR_CLASS_INIT(&tag[0], "ref-issue");
1978                 t = TAG_I;
1979                 break;
1980         case MDOC__J:
1981                 PAIR_CLASS_INIT(&tag[0], "ref-jrnl");
1982                 t = TAG_I;
1983                 break;
1984         case MDOC__N:
1985                 PAIR_CLASS_INIT(&tag[0], "ref-num");
1986                 break;
1987         case MDOC__O:
1988                 PAIR_CLASS_INIT(&tag[0], "ref-opt");
1989                 break;
1990         case MDOC__P:
1991                 PAIR_CLASS_INIT(&tag[0], "ref-page");
1992                 break;
1993         case MDOC__Q:
1994                 PAIR_CLASS_INIT(&tag[0], "ref-corp");
1995                 break;
1996         case MDOC__R:
1997                 PAIR_CLASS_INIT(&tag[0], "ref-rep");
1998                 break;
1999         case MDOC__T:
2000                 PAIR_CLASS_INIT(&tag[0], "ref-title");
2001                 break;
2002         case MDOC__U:
2003                 PAIR_CLASS_INIT(&tag[0], "link-ref");
2004                 break;
2005         case MDOC__V:
2006                 PAIR_CLASS_INIT(&tag[0], "ref-vol");
2007                 break;
2008         default:
2009                 abort();
2010                 /* NOTREACHED */
2011         }
2012
2013         if (MDOC__U != n->tok) {
2014                 print_otag(h, t, 1, tag);
2015                 return(1);
2016         }
2017
2018         PAIR_HREF_INIT(&tag[1], n->child->string);
2019         print_otag(h, TAG_A, 2, tag);
2020
2021         return(1);
2022 }
2023
2024 static void
2025 mdoc__x_post(MDOC_ARGS)
2026 {
2027
2028         if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)
2029                 if (NULL == n->next->next || MDOC__A != n->next->next->tok)
2030                         if (NULL == n->prev || MDOC__A != n->prev->tok)
2031                                 return;
2032
2033         /* TODO: %U */
2034
2035         if (NULL == n->parent || MDOC_Rs != n->parent->tok)
2036                 return;
2037
2038         h->flags |= HTML_NOSPACE;
2039         print_text(h, n->next ? "," : ".");
2040 }
2041
2042 static int
2043 mdoc_bk_pre(MDOC_ARGS)
2044 {
2045
2046         switch (n->type) {
2047         case MDOC_BLOCK:
2048                 break;
2049         case MDOC_HEAD:
2050                 return(0);
2051         case MDOC_BODY:
2052                 if (n->parent->args || 0 == n->prev->nchild)
2053                         h->flags |= HTML_PREKEEP;
2054                 break;
2055         default:
2056                 abort();
2057                 /* NOTREACHED */
2058         }
2059
2060         return(1);
2061 }
2062
2063 static void
2064 mdoc_bk_post(MDOC_ARGS)
2065 {
2066
2067         if (MDOC_BODY == n->type)
2068                 h->flags &= ~(HTML_KEEP | HTML_PREKEEP);
2069 }
2070
2071 static int
2072 mdoc_quote_pre(MDOC_ARGS)
2073 {
2074         struct htmlpair tag;
2075
2076         if (MDOC_BODY != n->type)
2077                 return(1);
2078
2079         switch (n->tok) {
2080         case MDOC_Ao:
2081                 /* FALLTHROUGH */
2082         case MDOC_Aq:
2083                 print_text(h, n->parent->prev != NULL &&
2084                     n->parent->prev->tok == MDOC_An ?  "<" : "\\(la");
2085                 break;
2086         case MDOC_Bro:
2087                 /* FALLTHROUGH */
2088         case MDOC_Brq:
2089                 print_text(h, "\\(lC");
2090                 break;
2091         case MDOC_Bo:
2092                 /* FALLTHROUGH */
2093         case MDOC_Bq:
2094                 print_text(h, "\\(lB");
2095                 break;
2096         case MDOC_Oo:
2097                 /* FALLTHROUGH */
2098         case MDOC_Op:
2099                 print_text(h, "\\(lB");
2100                 h->flags |= HTML_NOSPACE;
2101                 PAIR_CLASS_INIT(&tag, "opt");
2102                 print_otag(h, TAG_SPAN, 1, &tag);
2103                 break;
2104         case MDOC_En:
2105                 if (NULL == n->norm->Es ||
2106                     NULL == n->norm->Es->child)
2107                         return(1);
2108                 print_text(h, n->norm->Es->child->string);
2109                 break;
2110         case MDOC_Eo:
2111                 break;
2112         case MDOC_Do:
2113                 /* FALLTHROUGH */
2114         case MDOC_Dq:
2115                 /* FALLTHROUGH */
2116         case MDOC_Qo:
2117                 /* FALLTHROUGH */
2118         case MDOC_Qq:
2119                 print_text(h, "\\(lq");
2120                 break;
2121         case MDOC_Po:
2122                 /* FALLTHROUGH */
2123         case MDOC_Pq:
2124                 print_text(h, "(");
2125                 break;
2126         case MDOC_Ql:
2127                 print_text(h, "\\(oq");
2128                 h->flags |= HTML_NOSPACE;
2129                 PAIR_CLASS_INIT(&tag, "lit");
2130                 print_otag(h, TAG_CODE, 1, &tag);
2131                 break;
2132         case MDOC_So:
2133                 /* FALLTHROUGH */
2134         case MDOC_Sq:
2135                 print_text(h, "\\(oq");
2136                 break;
2137         default:
2138                 abort();
2139                 /* NOTREACHED */
2140         }
2141
2142         h->flags |= HTML_NOSPACE;
2143         return(1);
2144 }
2145
2146 static void
2147 mdoc_quote_post(MDOC_ARGS)
2148 {
2149
2150         if (n->type != MDOC_BODY && n->type != MDOC_ELEM)
2151                 return;
2152
2153         if ( ! (n->tok == MDOC_En ||
2154             (n->tok == MDOC_Eo && n->end == ENDBODY_SPACE)))
2155                 h->flags |= HTML_NOSPACE;
2156
2157         switch (n->tok) {
2158         case MDOC_Ao:
2159                 /* FALLTHROUGH */
2160         case MDOC_Aq:
2161                 print_text(h, n->parent->prev != NULL &&
2162                     n->parent->prev->tok == MDOC_An ?  ">" : "\\(ra");
2163                 break;
2164         case MDOC_Bro:
2165                 /* FALLTHROUGH */
2166         case MDOC_Brq:
2167                 print_text(h, "\\(rC");
2168                 break;
2169         case MDOC_Oo:
2170                 /* FALLTHROUGH */
2171         case MDOC_Op:
2172                 /* FALLTHROUGH */
2173         case MDOC_Bo:
2174                 /* FALLTHROUGH */
2175         case MDOC_Bq:
2176                 print_text(h, "\\(rB");
2177                 break;
2178         case MDOC_En:
2179                 if (NULL != n->norm->Es &&
2180                     NULL != n->norm->Es->child &&
2181                     NULL != n->norm->Es->child->next) {
2182                         h->flags |= HTML_NOSPACE;
2183                         print_text(h, n->norm->Es->child->next->string);
2184                 }
2185                 break;
2186         case MDOC_Eo:
2187                 break;
2188         case MDOC_Qo:
2189                 /* FALLTHROUGH */
2190         case MDOC_Qq:
2191                 /* FALLTHROUGH */
2192         case MDOC_Do:
2193                 /* FALLTHROUGH */
2194         case MDOC_Dq:
2195                 print_text(h, "\\(rq");
2196                 break;
2197         case MDOC_Po:
2198                 /* FALLTHROUGH */
2199         case MDOC_Pq:
2200                 print_text(h, ")");
2201                 break;
2202         case MDOC_Ql:
2203                 /* FALLTHROUGH */
2204         case MDOC_So:
2205                 /* FALLTHROUGH */
2206         case MDOC_Sq:
2207                 print_text(h, "\\(cq");
2208                 break;
2209         default:
2210                 abort();
2211                 /* NOTREACHED */
2212         }
2213 }