[BACK]Return to mdoc_html.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_html.c between version 1.108 and 1.119

version 1.108, 2010/09/27 11:21:39 version 1.119, 2010/12/15 16:35:21
Line 72  static int    mdoc_bd_pre(MDOC_ARGS);
Line 72  static int    mdoc_bd_pre(MDOC_ARGS);
 static  int               mdoc_bf_pre(MDOC_ARGS);  static  int               mdoc_bf_pre(MDOC_ARGS);
 static  void              mdoc_bk_post(MDOC_ARGS);  static  void              mdoc_bk_post(MDOC_ARGS);
 static  int               mdoc_bk_pre(MDOC_ARGS);  static  int               mdoc_bk_pre(MDOC_ARGS);
 static  void              mdoc_bl_post(MDOC_ARGS);  
 static  int               mdoc_bl_pre(MDOC_ARGS);  static  int               mdoc_bl_pre(MDOC_ARGS);
 static  int               mdoc_bt_pre(MDOC_ARGS);  static  int               mdoc_bt_pre(MDOC_ARGS);
 static  int               mdoc_bx_pre(MDOC_ARGS);  static  int               mdoc_bx_pre(MDOC_ARGS);
Line 91  static int    mdoc_ex_pre(MDOC_ARGS);
Line 90  static int    mdoc_ex_pre(MDOC_ARGS);
 static  void              mdoc_fo_post(MDOC_ARGS);  static  void              mdoc_fo_post(MDOC_ARGS);
 static  int               mdoc_fo_pre(MDOC_ARGS);  static  int               mdoc_fo_pre(MDOC_ARGS);
 static  int               mdoc_ic_pre(MDOC_ARGS);  static  int               mdoc_ic_pre(MDOC_ARGS);
   static  int               mdoc_igndelim_pre(MDOC_ARGS);
 static  int               mdoc_in_pre(MDOC_ARGS);  static  int               mdoc_in_pre(MDOC_ARGS);
 static  int               mdoc_it_block_pre(MDOC_ARGS, enum mdoc_list,  
                                 int, struct roffsu *, struct roffsu *);  
 static  int               mdoc_it_head_pre(MDOC_ARGS, enum mdoc_list,  
                                 struct roffsu *);  
 static  int               mdoc_it_body_pre(MDOC_ARGS, enum mdoc_list,  
                                 struct roffsu *);  
 static  int               mdoc_it_pre(MDOC_ARGS);  static  int               mdoc_it_pre(MDOC_ARGS);
 static  int               mdoc_lb_pre(MDOC_ARGS);  static  int               mdoc_lb_pre(MDOC_ARGS);
 static  int               mdoc_li_pre(MDOC_ARGS);  static  int               mdoc_li_pre(MDOC_ARGS);
Line 109  static int    mdoc_nm_pre(MDOC_ARGS);
Line 103  static int    mdoc_nm_pre(MDOC_ARGS);
 static  int               mdoc_ns_pre(MDOC_ARGS);  static  int               mdoc_ns_pre(MDOC_ARGS);
 static  int               mdoc_pa_pre(MDOC_ARGS);  static  int               mdoc_pa_pre(MDOC_ARGS);
 static  void              mdoc_pf_post(MDOC_ARGS);  static  void              mdoc_pf_post(MDOC_ARGS);
 static  int               mdoc_pf_pre(MDOC_ARGS);  
 static  void              mdoc_quote_post(MDOC_ARGS);  static  void              mdoc_quote_post(MDOC_ARGS);
 static  int               mdoc_quote_pre(MDOC_ARGS);  static  int               mdoc_quote_pre(MDOC_ARGS);
 static  int               mdoc_rs_pre(MDOC_ARGS);  static  int               mdoc_rs_pre(MDOC_ARGS);
Line 138  static const struct htmlmdoc mdocs[MDOC_MAX] = {
Line 131  static const struct htmlmdoc mdocs[MDOC_MAX] = {
         {mdoc_d1_pre, NULL}, /* Dl */          {mdoc_d1_pre, NULL}, /* Dl */
         {mdoc_bd_pre, NULL}, /* Bd */          {mdoc_bd_pre, NULL}, /* Bd */
         {NULL, NULL}, /* Ed */          {NULL, NULL}, /* Ed */
         {mdoc_bl_pre, mdoc_bl_post}, /* Bl */          {mdoc_bl_pre, NULL}, /* Bl */
         {NULL, NULL}, /* El */          {NULL, NULL}, /* El */
         {mdoc_it_pre, NULL}, /* It */          {mdoc_it_pre, NULL}, /* It */
         {mdoc_ad_pre, NULL}, /* Ad */          {mdoc_ad_pre, NULL}, /* Ad */
Line 199  static const struct htmlmdoc mdocs[MDOC_MAX] = {
Line 192  static const struct htmlmdoc mdocs[MDOC_MAX] = {
         {NULL, NULL}, /* Eo */          {NULL, NULL}, /* Eo */
         {mdoc_xx_pre, NULL}, /* Fx */          {mdoc_xx_pre, NULL}, /* Fx */
         {mdoc_ms_pre, NULL}, /* Ms */          {mdoc_ms_pre, NULL}, /* Ms */
         {NULL, NULL}, /* No */          {mdoc_igndelim_pre, NULL}, /* No */
         {mdoc_ns_pre, NULL}, /* Ns */          {mdoc_ns_pre, NULL}, /* Ns */
         {mdoc_xx_pre, NULL}, /* Nx */          {mdoc_xx_pre, NULL}, /* Nx */
         {mdoc_xx_pre, NULL}, /* Ox */          {mdoc_xx_pre, NULL}, /* Ox */
         {NULL, NULL}, /* Pc */          {NULL, NULL}, /* Pc */
         {mdoc_pf_pre, mdoc_pf_post}, /* Pf */          {mdoc_igndelim_pre, mdoc_pf_post}, /* Pf */
         {mdoc_quote_pre, mdoc_quote_post}, /* Po */          {mdoc_quote_pre, mdoc_quote_post}, /* Po */
         {mdoc_quote_pre, mdoc_quote_post}, /* Pq */          {mdoc_quote_pre, mdoc_quote_post}, /* Pq */
         {NULL, NULL}, /* Qc */          {NULL, NULL}, /* Qc */
Line 251  static const struct htmlmdoc mdocs[MDOC_MAX] = {
Line 244  static const struct htmlmdoc mdocs[MDOC_MAX] = {
         {NULL, NULL}, /* Ta */          {NULL, NULL}, /* Ta */
 };  };
   
   static  const char * const lists[LIST_MAX] = {
           NULL,
           "list-bul",
           "list-col",
           "list-dash",
           "list-diag",
           "list-enum",
           "list-hang",
           "list-hyph",
           "list-inset",
           "list-item",
           "list-ohang",
           "list-tag"
   };
   
 void  void
 html_mdoc(void *arg, const struct mdoc *m)  html_mdoc(void *arg, const struct mdoc *m)
Line 362  static void
Line 369  static void
 print_mdoc(MDOC_ARGS)  print_mdoc(MDOC_ARGS)
 {  {
         struct tag      *t;          struct tag      *t;
         struct htmlpair  tag;  
   
         t = print_otag(h, TAG_HEAD, 0, NULL);          t = print_otag(h, TAG_HEAD, 0, NULL);
         print_mdoc_head(m, n, h);          print_mdoc_head(m, n, h);
         print_tagq(h, t);          print_tagq(h, t);
   
         t = print_otag(h, TAG_BODY, 0, NULL);          t = print_otag(h, TAG_BODY, 0, NULL);
   
         tag.key = ATTR_CLASS;  
         tag.val = "body";  
         print_otag(h, TAG_DIV, 1, &tag);  
   
         print_mdoc_nodelist(m, n, h);          print_mdoc_nodelist(m, n, h);
         print_tagq(h, t);          print_tagq(h, t);
 }  }
Line 472  mdoc_root_post(MDOC_ARGS)
Line 473  mdoc_root_post(MDOC_ARGS)
   
         time2a(m->date, b, DATESIZ);          time2a(m->date, b, DATESIZ);
   
         /*  
          * XXX: this should use divs, but in Firefox, divs with nested  
          * divs for some reason puke when trying to put a border line  
          * below.  So I use tables, instead.  
          */  
   
         PAIR_CLASS_INIT(&tag[0], "footer");          PAIR_CLASS_INIT(&tag[0], "footer");
         bufcat_style(h, "width", "100%");          bufcat_style(h, "width", "100%");
         PAIR_STYLE_INIT(&tag[1], h);          PAIR_STYLE_INIT(&tag[1], h);
Line 511  mdoc_root_pre(MDOC_ARGS)
Line 506  mdoc_root_pre(MDOC_ARGS)
         struct tag      *t, *tt;          struct tag      *t, *tt;
         char             b[BUFSIZ], title[BUFSIZ];          char             b[BUFSIZ], title[BUFSIZ];
   
         (void)strlcpy(b, m->vol, BUFSIZ);          strlcpy(b, m->vol, BUFSIZ);
   
         if (m->arch) {          if (m->arch) {
                 (void)strlcat(b, " (", BUFSIZ);                  strlcat(b, " (", BUFSIZ);
                 (void)strlcat(b, m->arch, BUFSIZ);                  strlcat(b, m->arch, BUFSIZ);
                 (void)strlcat(b, ")", BUFSIZ);                  strlcat(b, ")", BUFSIZ);
         }          }
   
         (void)snprintf(title, BUFSIZ - 1,          snprintf(title, BUFSIZ - 1, "%s(%s)", m->title, m->msec);
                         "%s(%s)", m->title, m->msec);  
   
         /* XXX: see note in mdoc_root_post() about divs. */  
   
         PAIR_CLASS_INIT(&tag[0], "header");          PAIR_CLASS_INIT(&tag[0], "header");
         bufcat_style(h, "width", "100%");          bufcat_style(h, "width", "100%");
         PAIR_STYLE_INIT(&tag[1], h);          PAIR_STYLE_INIT(&tag[1], h);
Line 843  mdoc_xx_pre(MDOC_ARGS)
Line 835  mdoc_xx_pre(MDOC_ARGS)
   
         switch (n->tok) {          switch (n->tok) {
         case (MDOC_Bsx):          case (MDOC_Bsx):
                 pp = "BSDI BSD/OS";                  pp = "BSD/OS";
                 break;                  break;
         case (MDOC_Dx):          case (MDOC_Dx):
                 pp = "DragonFly";                  pp = "DragonFly";
Line 891  mdoc_bx_pre(MDOC_ARGS)
Line 883  mdoc_bx_pre(MDOC_ARGS)
         return(0);          return(0);
 }  }
   
   
 /* ARGSUSED */  
 static int  static int
 mdoc_it_block_pre(MDOC_ARGS, enum mdoc_list type, int comp,  mdoc_it_pre(MDOC_ARGS)
                 struct roffsu *offs, struct roffsu *width)  
 {  {
         struct htmlpair          tag;          struct roffsu    su;
         const struct mdoc_node  *nn;          enum mdoc_list   type;
         struct roffsu            su;          struct htmlpair  tag[2];
           const struct mdoc_node *bl;
   
         nn = n->parent->parent;          bl = n->parent;
           while (bl && MDOC_Bl != bl->tok)
                   bl = bl->parent;
   
         /* XXX: see notes in mdoc_it_pre(). */          assert(bl);
   
         if (LIST_column == type) {          type = bl->data.Bl->type;
                 /* Don't width-pad on the left. */  
                 SCALE_HS_INIT(width, 0);  
                 /* Also disallow non-compact. */  
                 comp = 1;  
         }  
         if (LIST_diag == type)  
                 /* Mandate non-compact with empty prior. */  
                 if (n->prev && NULL == n->prev->body->child)  
                         comp = 1;  
   
         bufcat_style(h, "clear", "both");          assert(lists[type]);
         if (offs->scale > 0)          PAIR_CLASS_INIT(&tag[0], lists[type]);
                 bufcat_su(h, "margin-left", offs);  
         if (width->scale > 0)  
                 bufcat_su(h, "padding-left", width);  
   
         PAIR_STYLE_INIT(&tag, h);          SCALE_VS_INIT(&su, ! bl->data.Bl->comp);
           bufcat_su(h, "margin-top", &su);
           PAIR_STYLE_INIT(&tag[1], h);
   
         /* Mandate compact following `Ss' and `Sh' starts. */          if (MDOC_HEAD == n->type) {
                   switch (type) {
         for (nn = n; nn && ! comp; nn = nn->parent) {                  case(LIST_bullet):
                 if (MDOC_BLOCK != nn->type)                          /* FALLTHROUGH */
                         continue;                  case(LIST_dash):
                 if (MDOC_Ss == nn->tok || MDOC_Sh == nn->tok)                          /* FALLTHROUGH */
                         comp = 1;                  case(LIST_item):
                 if (nn->prev)                          /* FALLTHROUGH */
                   case(LIST_hyphen):
                           /* FALLTHROUGH */
                   case(LIST_enum):
                           return(0);
                   case(LIST_diag):
                           /* FALLTHROUGH */
                   case(LIST_hang):
                           /* FALLTHROUGH */
                   case(LIST_inset):
                           /* FALLTHROUGH */
                   case(LIST_ohang):
                           /* FALLTHROUGH */
                   case(LIST_tag):
                           print_otag(h, TAG_DT, 2, tag);
                         break;                          break;
                   case(LIST_column):
                           break;
                   default:
                           break;
                   }
           } else if (MDOC_BODY == n->type) {
                   switch (type) {
                   case(LIST_bullet):
                           /* FALLTHROUGH */
                   case(LIST_hyphen):
                           /* FALLTHROUGH */
                   case(LIST_dash):
                           /* FALLTHROUGH */
                   case(LIST_enum):
                           /* FALLTHROUGH */
                   case(LIST_item):
                           /* FALLTHROUGH */
                           print_otag(h, TAG_LI, 2, tag);
                           break;
                   case(LIST_diag):
                           /* FALLTHROUGH */
                   case(LIST_hang):
                           /* FALLTHROUGH */
                   case(LIST_inset):
                           /* FALLTHROUGH */
                   case(LIST_ohang):
                           /* FALLTHROUGH */
                   case(LIST_tag):
                           print_otag(h, TAG_DD, 1, tag);
                           break;
                   case(LIST_column):
                           print_otag(h, TAG_TD, 2, tag);
                           break;
                   default:
                           break;
                   }
           } else {
                   switch (type) {
                   case (LIST_column):
                           print_otag(h, TAG_TR, 1, tag);
                           break;
                   default:
                           break;
                   }
         }          }
   
         if ( ! comp) {  
                 SCALE_VS_INIT(&su, 1);  
                 bufcat_su(h, "padding-top", &su);  
         }  
   
         PAIR_STYLE_INIT(&tag, h);  
         print_otag(h, TAG_DIV, 1, &tag);  
         return(1);          return(1);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
 mdoc_it_body_pre(MDOC_ARGS, enum mdoc_list type, struct roffsu *width)  mdoc_bl_pre(MDOC_ARGS)
 {  {
         struct htmlpair  tag;          size_t           i;
           struct htmlpair  tag[3];
         struct roffsu    su;          struct roffsu    su;
   
         switch (type) {          if (MDOC_BODY == n->type) {
         case (LIST_item):                  if (LIST_column == n->data.Bl->type)
                 /* FALLTHROUGH */                          print_otag(h, TAG_TBODY, 0, NULL);
         case (LIST_ohang):                  return(1);
                 /* FALLTHROUGH */  
         case (LIST_column):  
                 bufcat_su(h, "min-width", width);  
                 bufcat_style(h, "clear", "none");  
                 if (n->next)  
                         bufcat_style(h, "float", "left");  
                 PAIR_STYLE_INIT(&tag, h);  
                 print_otag(h, TAG_DIV, 1, &tag);  
                 break;  
         default:  
                 /*  
                  * XXX: this tricks CSS into aligning the bodies with  
                  * the right-padding in the head.  
                  */  
                 SCALE_HS_INIT(&su, 2);  
                 bufcat_su(h, "margin-left", &su);  
                 PAIR_STYLE_INIT(&tag, h);  
                 print_otag(h, TAG_DIV, 1, &tag);  
                 break;  
         }          }
   
         return(1);          if (MDOC_HEAD == n->type) {
 }                  if (LIST_column != n->data.Bl->type)
                           return(0);
   
                   /*
                    * For each column, print out the <COL> tag with our
                    * suggested width.  The last column gets min-width, as
                    * in terminal mode it auto-sizes to the width of the
                    * screen and we want to preserve that behaviour.
                    */
   
 /* ARGSUSED */                  for (i = 0; i < n->data.Bl->ncols; i++) {
 static int                          a2width(n->data.Bl->cols[i], &su);
 mdoc_it_head_pre(MDOC_ARGS, enum mdoc_list type, struct roffsu *width)                          bufinit(h);
 {                          if (i < n->data.Bl->ncols - 1)
         struct htmlpair  tag;                                  bufcat_su(h, "width", &su);
         struct ord      *ord;                          else
         char             nbuf[BUFSIZ];                                  bufcat_su(h, "min-width", &su);
                           PAIR_STYLE_INIT(&tag[0], h);
                           print_otag(h, TAG_COL, 1, tag);
                   }
   
         switch (type) {  
         case (LIST_item):  
                 return(0);                  return(0);
         case (LIST_ohang):  
                 print_otag(h, TAG_DIV, 0, &tag);  
                 return(1);  
         case (LIST_column):  
                 break;  
         default:  
                 bufcat_su(h, "min-width", width);  
                 SCALE_INVERT(width);  
                 bufcat_su(h, "margin-left", width);  
                 if (n->next && n->next->child)  
                         bufcat_style(h, "float", "left");  
   
                 /* XXX: buffer if we run into body. */  
                 SCALE_HS_INIT(width, 1);  
                 bufcat_su(h, "margin-right", width);  
                 PAIR_STYLE_INIT(&tag, h);  
                 print_otag(h, TAG_DIV, 1, &tag);  
                 break;  
         }          }
   
         switch (type) {          SCALE_VS_INIT(&su, 0);
         case (LIST_diag):          bufcat_su(h, "margin-top", &su);
                 PAIR_CLASS_INIT(&tag, "diag");          bufcat_su(h, "margin-bottom", &su);
                 print_otag(h, TAG_SPAN, 1, &tag);          PAIR_STYLE_INIT(&tag[0], h);
                 break;  
         case (LIST_enum):  
                 ord = h->ords.head;  
                 assert(ord);  
                 nbuf[BUFSIZ - 1] = 0;  
                 (void)snprintf(nbuf, BUFSIZ - 1, "%d.", ord->pos++);  
                 print_text(h, nbuf);  
                 return(0);  
         case (LIST_dash):  
                 print_text(h, "\\(en");  
                 return(0);  
         case (LIST_hyphen):  
                 print_text(h, "\\(hy");  
                 return(0);  
         case (LIST_bullet):  
                 print_text(h, "\\(bu");  
                 return(0);  
         default:  
                 break;  
         }  
   
         return(1);          assert(lists[n->data.Bl->type]);
 }          PAIR_CLASS_INIT(&tag[1], lists[n->data.Bl->type]);
           i = 2;
   
           /* Set the block's left-hand margin. */
   
 static int          if (n->data.Bl->offs) {
 mdoc_it_pre(MDOC_ARGS)                  a2offs(n->data.Bl->offs, &su);
 {                  bufcat_su(h, "margin-left", &su);
         int                      i, comp;                  PAIR_STYLE_INIT(&tag[2], h);
         const struct mdoc_node  *bl, *nn;                  i = 3;
         struct roffsu            width, offs;          }
         enum mdoc_list           type;  
   
         /*          switch (n->data.Bl->type) {
          * XXX: be very careful in changing anything, here.  Lists in          case(LIST_bullet):
          * mandoc have many peculiarities; furthermore, they don't  
          * translate well into HTML and require a bit of mangling.  
          */  
   
         bl = n->parent->parent;  
         if (MDOC_BLOCK != n->type)  
                 bl = bl->parent;  
   
         SCALE_HS_INIT(&offs, 0);  
   
         assert(bl->data.Bl);  
         type = bl->data.Bl->type;  
         comp = bl->data.Bl->comp;  
   
         if (bl->data.Bl->offs)  
                 a2offs(bl->data.Bl->offs, &offs);  
   
         switch (type) {  
         case (LIST_enum):  
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_dash):          case(LIST_dash):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_hyphen):          case(LIST_hyphen):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_bullet):          case(LIST_item):
                 SCALE_HS_INIT(&width, 2);                  print_otag(h, TAG_UL, i, tag);
                 break;                  break;
         default:          case(LIST_enum):
                 SCALE_HS_INIT(&width, INDENT);                  print_otag(h, TAG_OL, i, tag);
                 break;                  break;
         }          case(LIST_diag):
   
         if (bl->data.Bl->width)  
                 a2width(bl->data.Bl->width, &width);  
   
         /* Override width in some cases. */  
   
         switch (type) {  
         case (LIST_ohang):  
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_item):          case(LIST_hang):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_inset):          case(LIST_inset):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (LIST_diag):          case(LIST_ohang):
                 SCALE_HS_INIT(&width, 0);                  /* FALLTHROUGH */
           case(LIST_tag):
                   print_otag(h, TAG_DL, i, tag);
                 break;                  break;
         default:          case(LIST_column):
                 if (0 == width.scale)                  print_otag(h, TAG_TABLE, i, tag);
                         SCALE_HS_INIT(&width, INDENT);  
                 break;                  break;
           default:
                   abort();
                   /* NOTREACHED */
         }          }
   
         if (LIST_column == type && MDOC_BODY == n->type) {  
                 nn = n->parent->child;  
                 for (i = 0; nn && nn != n; nn = nn->next)  
                         if (MDOC_BODY == nn->type)  
                                 i++;  
                 if (i < (int)bl->data.Bl->ncols)  
                         a2width(bl->data.Bl->cols[i], &width);  
         }  
   
         if (MDOC_HEAD == n->type)  
                 return(mdoc_it_head_pre(m, n, h, type, &width));  
         else if (MDOC_BODY == n->type)  
                 return(mdoc_it_body_pre(m, n, h, type, &width));  
   
         return(mdoc_it_block_pre(m, n, h, type, comp, &offs, &width));  
 }  
   
   
 /* ARGSUSED */  
 static int  
 mdoc_bl_pre(MDOC_ARGS)  
 {  
         struct ord      *ord;  
   
         if (MDOC_HEAD == n->type)  
                 return(0);  
         if (MDOC_BLOCK != n->type)  
                 return(1);  
         assert(n->data.Bl);  
         if (LIST_enum != n->data.Bl->type)  
                 return(1);  
   
         ord = malloc(sizeof(struct ord));  
         if (NULL == ord) {  
                 perror(NULL);  
                 exit((int)MANDOCLEVEL_SYSERR);  
         }  
         ord->cookie = n;  
         ord->pos = 1;  
         ord->next = h->ords.head;  
         h->ords.head = ord;  
         return(1);          return(1);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  
 mdoc_bl_post(MDOC_ARGS)  
 {  
         struct ord      *ord;  
   
         if (MDOC_BLOCK != n->type)  
                 return;  
         if (LIST_enum != n->data.Bl->type)  
                 return;  
   
         ord = h->ords.head;  
         assert(ord);  
         h->ords.head = ord->next;  
         free(ord);  
 }  
   
   
 /* ARGSUSED */  
 static int  static int
 mdoc_ex_pre(MDOC_ARGS)  mdoc_ex_pre(MDOC_ARGS)
 {  {
Line 1226  mdoc_d1_pre(MDOC_ARGS)
Line 1128  mdoc_d1_pre(MDOC_ARGS)
         if (MDOC_BLOCK != n->type)          if (MDOC_BLOCK != n->type)
                 return(1);                  return(1);
   
         /* FIXME: D1 shouldn't be literal. */          SCALE_VS_INIT(&su, 0);
           bufcat_su(h, "margin-top", &su);
           bufcat_su(h, "margin-bottom", &su);
           PAIR_STYLE_INIT(&tag[0], h);
   
         SCALE_VS_INIT(&su, INDENT - 2);          if (MDOC_Dl == n->tok) {
         bufcat_su(h, "margin-left", &su);                  PAIR_CLASS_INIT(&tag[1], "lit");
         PAIR_CLASS_INIT(&tag[0], "lit");                  print_otag(h, TAG_BLOCKQUOTE, 2, tag);
         PAIR_STYLE_INIT(&tag[1], h);          } else
         print_otag(h, TAG_DIV, 2, tag);                  print_otag(h, TAG_BLOCKQUOTE, 1, tag);
   
         return(1);          return(1);
 }  }
   
Line 1323  mdoc_bd_pre(MDOC_ARGS)
Line 1229  mdoc_bd_pre(MDOC_ARGS)
                  * anyway, so don't sweat it.                   * anyway, so don't sweat it.
                  */                   */
                 switch (nn->tok) {                  switch (nn->tok) {
                   case (MDOC_Sm):
                           /* FALLTHROUGH */
                 case (MDOC_br):                  case (MDOC_br):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_sp):                  case (MDOC_sp):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Bl):                  case (MDOC_Bl):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                   case (MDOC_D1):
                           /* FALLTHROUGH */
                   case (MDOC_Dl):
                           /* FALLTHROUGH */
                 case (MDOC_Lp):                  case (MDOC_Lp):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Pp):                  case (MDOC_Pp):
Line 1603  mdoc_sm_pre(MDOC_ARGS)
Line 1515  mdoc_sm_pre(MDOC_ARGS)
   
         assert(n->child && MDOC_TEXT == n->child->type);          assert(n->child && MDOC_TEXT == n->child->type);
         if (0 == strcmp("on", n->child->string)) {          if (0 == strcmp("on", n->child->string)) {
                 /* FIXME: no p->col to check... */                  /*
                    * FIXME: no p->col to check.  Thus, if we have
                    *  .Bd -literal
                    *  .Sm off
                    *  1 2
                    *  .Sm on
                    *  3
                    *  .Ed
                    * the "3" is preceded by a space.
                    */
                 h->flags &= ~HTML_NOSPACE;                  h->flags &= ~HTML_NOSPACE;
                 h->flags &= ~HTML_NONOSPACE;                  h->flags &= ~HTML_NONOSPACE;
         } else          } else
Line 1664  mdoc_lk_pre(MDOC_ARGS)
Line 1585  mdoc_lk_pre(MDOC_ARGS)
         PAIR_HREF_INIT(&tag[1], nn->string);          PAIR_HREF_INIT(&tag[1], nn->string);
         print_otag(h, TAG_A, 2, tag);          print_otag(h, TAG_A, 2, tag);
   
         if (NULL == nn->next)          if (NULL == nn || NULL == nn->next)
                 return(1);                  return(1);
   
         for (nn = nn->next; nn; nn = nn->next)          for (nn = nn->next; nn; nn = nn->next)
Line 1911  mdoc_ms_pre(MDOC_ARGS)
Line 1832  mdoc_ms_pre(MDOC_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
 mdoc_pf_pre(MDOC_ARGS)  mdoc_igndelim_pre(MDOC_ARGS)
 {  {
   
         h->flags |= HTML_IGNDELIM;          h->flags |= HTML_IGNDELIM;
Line 1924  static void
Line 1845  static void
 mdoc_pf_post(MDOC_ARGS)  mdoc_pf_post(MDOC_ARGS)
 {  {
   
         h->flags &= ~HTML_IGNDELIM;  
         h->flags |= HTML_NOSPACE;          h->flags |= HTML_NOSPACE;
 }  }
   
Line 2157  mdoc_quote_pre(MDOC_ARGS)
Line 2077  mdoc_quote_pre(MDOC_ARGS)
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Op):          case (MDOC_Op):
                 print_text(h, "\\(lB");                  print_text(h, "\\(lB");
                   h->flags |= HTML_NOSPACE;
                 PAIR_CLASS_INIT(&tag, "opt");                  PAIR_CLASS_INIT(&tag, "opt");
                 print_otag(h, TAG_SPAN, 1, &tag);                  print_otag(h, TAG_SPAN, 1, &tag);
                 break;                  break;
Legend:
Removed from v.1.108  
changed lines
  Added in v.1.119
CVSweb