usr.bin/mandoc/mdoc_html.c

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