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

Diff for /mandoc/mdoc_man.c between version 1.57 and 1.66

version 1.57, 2013/12/25 22:00:45 version 1.66, 2014/07/04 16:12:08
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2011, 2012, 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 23 
Line 23 
 #include <string.h>  #include <string.h>
   
 #include "mandoc.h"  #include "mandoc.h"
   #include "mandoc_aux.h"
 #include "out.h"  #include "out.h"
 #include "man.h"  #include "man.h"
 #include "mdoc.h"  #include "mdoc.h"
Line 50  static void   post_bf(DECL_ARGS);
Line 51  static void   post_bf(DECL_ARGS);
 static  void      post_bk(DECL_ARGS);  static  void      post_bk(DECL_ARGS);
 static  void      post_bl(DECL_ARGS);  static  void      post_bl(DECL_ARGS);
 static  void      post_dl(DECL_ARGS);  static  void      post_dl(DECL_ARGS);
   static  void      post_en(DECL_ARGS);
 static  void      post_enc(DECL_ARGS);  static  void      post_enc(DECL_ARGS);
 static  void      post_eo(DECL_ARGS);  static  void      post_eo(DECL_ARGS);
 static  void      post_fa(DECL_ARGS);  static  void      post_fa(DECL_ARGS);
Line 77  static int   pre_bl(DECL_ARGS);
Line 79  static int   pre_bl(DECL_ARGS);
 static  int       pre_br(DECL_ARGS);  static  int       pre_br(DECL_ARGS);
 static  int       pre_bx(DECL_ARGS);  static  int       pre_bx(DECL_ARGS);
 static  int       pre_dl(DECL_ARGS);  static  int       pre_dl(DECL_ARGS);
   static  int       pre_en(DECL_ARGS);
 static  int       pre_enc(DECL_ARGS);  static  int       pre_enc(DECL_ARGS);
 static  int       pre_em(DECL_ARGS);  static  int       pre_em(DECL_ARGS);
   static  int       pre_es(DECL_ARGS);
 static  int       pre_fa(DECL_ARGS);  static  int       pre_fa(DECL_ARGS);
 static  int       pre_fd(DECL_ARGS);  static  int       pre_fd(DECL_ARGS);
 static  int       pre_fl(DECL_ARGS);  static  int       pre_fl(DECL_ARGS);
Line 89  static int   pre_in(DECL_ARGS);
Line 93  static int   pre_in(DECL_ARGS);
 static  int       pre_it(DECL_ARGS);  static  int       pre_it(DECL_ARGS);
 static  int       pre_lk(DECL_ARGS);  static  int       pre_lk(DECL_ARGS);
 static  int       pre_li(DECL_ARGS);  static  int       pre_li(DECL_ARGS);
   static  int       pre_ll(DECL_ARGS);
 static  int       pre_nm(DECL_ARGS);  static  int       pre_nm(DECL_ARGS);
 static  int       pre_no(DECL_ARGS);  static  int       pre_no(DECL_ARGS);
 static  int       pre_ns(DECL_ARGS);  static  int       pre_ns(DECL_ARGS);
Line 148  static const struct manact manacts[MDOC_MAX + 1] = {
Line 153  static const struct manact manacts[MDOC_MAX + 1] = {
         { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */          { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
         { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */          { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
         { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */          { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
         { NULL, NULL, NULL, NULL, NULL }, /* Ot */          { NULL, pre_ft, post_font, NULL, NULL }, /* Ot */
         { NULL, pre_em, post_font, NULL, NULL }, /* Pa */          { NULL, pre_em, post_font, NULL, NULL }, /* Pa */
         { NULL, pre_enc, post_enc, "The \\fB",          { NULL, pre_enc, post_enc, "The \\fB",
                 "\\fP\nfunction returns the value 0 if successful;\n"                  "\\fP\nfunction returns the value 0 if successful;\n"
Line 222  static const struct manact manacts[MDOC_MAX + 1] = {
Line 227  static const struct manact manacts[MDOC_MAX + 1] = {
         { NULL, NULL, NULL, NULL, NULL }, /* Ek */          { NULL, NULL, NULL, NULL, NULL }, /* Ek */
         { NULL, pre_ux, NULL, "is currently in beta test.", NULL }, /* Bt */          { NULL, pre_ux, NULL, "is currently in beta test.", NULL }, /* Bt */
         { NULL, NULL, NULL, NULL, NULL }, /* Hf */          { NULL, NULL, NULL, NULL, NULL }, /* Hf */
         { NULL, NULL, NULL, NULL, NULL }, /* Fr */          { NULL, pre_em, post_font, NULL, NULL }, /* Fr */
         { NULL, pre_ux, NULL, "currently under development.", NULL }, /* Ud */          { NULL, pre_ux, NULL, "currently under development.", NULL }, /* Ud */
         { NULL, NULL, post_lb, NULL, NULL }, /* Lb */          { NULL, NULL, post_lb, NULL, NULL }, /* Lb */
         { NULL, pre_pp, NULL, NULL, NULL }, /* Lp */          { NULL, pre_pp, NULL, NULL, NULL }, /* Lp */
Line 232  static const struct manact manacts[MDOC_MAX + 1] = {
Line 237  static const struct manact manacts[MDOC_MAX + 1] = {
         { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */          { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
         { NULL, NULL, NULL, NULL, NULL }, /* Brc */          { NULL, NULL, NULL, NULL, NULL }, /* Brc */
         { NULL, NULL, post_percent, NULL, NULL }, /* %C */          { NULL, NULL, post_percent, NULL, NULL }, /* %C */
         { NULL, NULL, NULL, NULL, NULL }, /* Es */          { NULL, pre_es, NULL, NULL, NULL }, /* Es */
         { NULL, NULL, NULL, NULL, NULL }, /* En */          { cond_body, pre_en, post_en, NULL, NULL }, /* En */
         { NULL, pre_ux, NULL, "DragonFly", NULL }, /* Dx */          { NULL, pre_ux, NULL, "DragonFly", NULL }, /* Dx */
         { NULL, NULL, post_percent, NULL, NULL }, /* %Q */          { NULL, NULL, post_percent, NULL, NULL }, /* %Q */
         { NULL, pre_br, NULL, NULL, NULL }, /* br */          { NULL, pre_br, NULL, NULL, NULL }, /* br */
         { NULL, pre_sp, post_sp, NULL, NULL }, /* sp */          { NULL, pre_sp, post_sp, NULL, NULL }, /* sp */
         { NULL, NULL, post_percent, NULL, NULL }, /* %U */          { NULL, NULL, post_percent, NULL, NULL }, /* %U */
         { NULL, NULL, NULL, NULL, NULL }, /* Ta */          { NULL, NULL, NULL, NULL, NULL }, /* Ta */
           { NULL, pre_ll, post_sp, NULL, NULL }, /* ll */
         { NULL, NULL, NULL, NULL, NULL }, /* ROOT */          { NULL, NULL, NULL, NULL, NULL }, /* ROOT */
 };  };
   
Line 271  static struct {
Line 277  static struct {
         size_t   size;          size_t   size;
 }       fontqueue;  }       fontqueue;
   
   
 static void  static void
 font_push(char newfont)  font_push(char newfont)
 {  {
Line 278  font_push(char newfont)
Line 285  font_push(char newfont)
         if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {          if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
                 fontqueue.size += 8;                  fontqueue.size += 8;
                 fontqueue.head = mandoc_realloc(fontqueue.head,                  fontqueue.head = mandoc_realloc(fontqueue.head,
                                 fontqueue.size);                      fontqueue.size);
         }          }
         *fontqueue.tail = newfont;          *fontqueue.tail = newfont;
         print_word("");          print_word("");
Line 304  print_word(const char *s)
Line 311  print_word(const char *s)
 {  {
   
         if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {          if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
                 /*                  /*
                  * If we need a newline, print it now and start afresh.                   * If we need a newline, print it now and start afresh.
                  */                   */
                 if (MMAN_PP & outflags) {                  if (MMAN_PP & outflags) {
Line 359  print_word(const char *s)
Line 366  print_word(const char *s)
   
         for ( ; *s; s++) {          for ( ; *s; s++) {
                 switch (*s) {                  switch (*s) {
                 case (ASCII_NBRSP):                  case ASCII_NBRSP:
                         printf("\\ ");                          printf("\\ ");
                         break;                          break;
                 case (ASCII_HYPH):                  case ASCII_HYPH:
                         putchar('-');                          putchar('-');
                         break;                          break;
                 case (' '):                  case ASCII_BREAK:
                           printf("\\:");
                           break;
                   case ' ':
                         if (MMAN_nbrword & outflags) {                          if (MMAN_nbrword & outflags) {
                                 printf("\\ ");                                  printf("\\ ");
                                 break;                                  break;
Line 450  print_offs(const char *v)
Line 460  print_offs(const char *v)
         if (Bl_stack_len)          if (Bl_stack_len)
                 sz += Bl_stack[Bl_stack_len - 1];                  sz += Bl_stack[Bl_stack_len - 1];
   
         snprintf(buf, sizeof(buf), "%zun", sz);          (void)snprintf(buf, sizeof(buf), "%zun", sz);
         print_word(buf);          print_word(buf);
         outflags |= MMAN_nl;          outflags |= MMAN_nl;
 }  }
Line 458  print_offs(const char *v)
Line 468  print_offs(const char *v)
 /*  /*
  * Set up the indentation for a list item; used from pre_it().   * Set up the indentation for a list item; used from pre_it().
  */   */
 void  static void
 print_width(const char *v, const struct mdoc_node *child, size_t defsz)  print_width(const char *v, const struct mdoc_node *child, size_t defsz)
 {  {
         char              buf[24];          char              buf[24];
Line 484  print_width(const char *v, const struct mdoc_node *chi
Line 494  print_width(const char *v, const struct mdoc_node *chi
   
         /* XXX Rough estimation, might have multiple parts. */          /* XXX Rough estimation, might have multiple parts. */
         chsz = (NULL != child && MDOC_TEXT == child->type) ?          chsz = (NULL != child && MDOC_TEXT == child->type) ?
                         strlen(child->string) : 0;              strlen(child->string) : 0;
   
         /* Maybe we are inside an enclosing list? */          /* Maybe we are inside an enclosing list? */
         mid_it();          mid_it();
Line 503  print_width(const char *v, const struct mdoc_node *chi
Line 513  print_width(const char *v, const struct mdoc_node *chi
                 remain = sz + 2;                  remain = sz + 2;
         }          }
         if (numeric) {          if (numeric) {
                 snprintf(buf, sizeof(buf), "%zun", sz + 2);                  (void)snprintf(buf, sizeof(buf), "%zun", sz + 2);
                 print_word(buf);                  print_word(buf);
         } else          } else
                 print_word(v);                  print_word(v);
         TPremain = remain;          TPremain = remain;
 }  }
   
 void  static void
 print_count(int *count)  print_count(int *count)
 {  {
         char              buf[12];          char              buf[24];
   
         snprintf(buf, sizeof(buf), "%d.", ++*count);          (void)snprintf(buf, sizeof(buf), "%d.", ++*count);
         print_word(buf);          print_word(buf);
 }  }
   
Line 542  man_mdoc(void *arg, const struct mdoc *mdoc)
Line 552  man_mdoc(void *arg, const struct mdoc *mdoc)
         n = mdoc_node(mdoc);          n = mdoc_node(mdoc);
   
         printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",          printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
                         meta->title, meta->msec, meta->date,              meta->title, meta->msec, meta->date,
                         meta->os, meta->vol);              meta->os, meta->vol);
   
         /* Disable hyphenation and if nroff, disable justification. */          /* Disable hyphenation and if nroff, disable justification. */
         printf(".nh\n.if n .ad l");          printf(".nh\n.if n .ad l");
Line 581  print_node(DECL_ARGS)
Line 591  print_node(DECL_ARGS)
                  * Make sure that we don't happen to start with a                   * Make sure that we don't happen to start with a
                  * control character at the start of a line.                   * control character at the start of a line.
                  */                   */
                 if (MMAN_nl & outflags && ('.' == *n->string ||                  if (MMAN_nl & outflags &&
                                         '\'' == *n->string)) {                      ('.' == *n->string || '\'' == *n->string)) {
                         print_word("");                          print_word("");
                         printf("\\&");                          printf("\\&");
                         outflags &= ~MMAN_spc;                          outflags &= ~MMAN_spc;
Line 595  print_node(DECL_ARGS)
Line 605  print_node(DECL_ARGS)
                  */                   */
                 act = manacts + n->tok;                  act = manacts + n->tok;
                 cond = NULL == act->cond || (*act->cond)(meta, n);                  cond = NULL == act->cond || (*act->cond)(meta, n);
                 if (cond && act->pre)                  if (cond && act->pre && ENDBODY_NOT == n->end)
                         do_sub = (*act->pre)(meta, n);                          do_sub = (*act->pre)(meta, n);
         }          }
   
         /*          /*
          * Conditionally run all child nodes.           * Conditionally run all child nodes.
          * Note that this iterates over children instead of using           * Note that this iterates over children instead of using
          * recursion.  This prevents unnecessary depth in the stack.           * recursion.  This prevents unnecessary depth in the stack.
Line 611  print_node(DECL_ARGS)
Line 621  print_node(DECL_ARGS)
         /*          /*
          * Lastly, conditionally run the post-node handler.           * Lastly, conditionally run the post-node handler.
          */           */
           if (MDOC_ENDED & n->flags)
                   return;
   
         if (cond && act->post)          if (cond && act->post)
                 (*act->post)(meta, n);                  (*act->post)(meta, n);
   
           if (ENDBODY_NOT != n->end)
                   n->pending->flags |= MDOC_ENDED;
   
           if (ENDBODY_NOSPACE == n->end)
                   outflags &= ~(MMAN_spc | MMAN_nl);
 }  }
   
 static int  static int
Line 650  post_enc(DECL_ARGS)
Line 669  post_enc(DECL_ARGS)
         suffix = manacts[n->tok].suffix;          suffix = manacts[n->tok].suffix;
         if (NULL == suffix)          if (NULL == suffix)
                 return;                  return;
         outflags &= ~MMAN_spc;          outflags &= ~(MMAN_spc | MMAN_nl);
         print_word(suffix);          print_word(suffix);
 }  }
   
Line 682  static int
Line 701  static int
 pre__t(DECL_ARGS)  pre__t(DECL_ARGS)
 {  {
   
         if (n->parent && MDOC_Rs == n->parent->tok &&          if (n->parent && MDOC_Rs == n->parent->tok &&
                         n->parent->norm->Rs.quote_T) {              n->parent->norm->Rs.quote_T) {
                 print_word("");                  print_word("");
                 putchar('\"');                  putchar('\"');
                 outflags &= ~MMAN_spc;                  outflags &= ~MMAN_spc;
Line 696  static void
Line 715  static void
 post__t(DECL_ARGS)  post__t(DECL_ARGS)
 {  {
   
         if (n->parent && MDOC_Rs == n->parent->tok &&          if (n->parent && MDOC_Rs == n->parent->tok &&
                         n->parent->norm->Rs.quote_T) {              n->parent->norm->Rs.quote_T) {
                 outflags &= ~MMAN_spc;                  outflags &= ~MMAN_spc;
                 print_word("");                  print_word("");
                 putchar('\"');                  putchar('\"');
Line 749  pre_syn(const struct mdoc_node *n)
Line 768  pre_syn(const struct mdoc_node *n)
                 return;                  return;
   
         if (n->prev->tok == n->tok &&          if (n->prev->tok == n->tok &&
                         MDOC_Ft != n->tok &&              MDOC_Ft != n->tok &&
                         MDOC_Fo != n->tok &&              MDOC_Fo != n->tok &&
                         MDOC_Fn != n->tok) {              MDOC_Fn != n->tok) {
                 outflags |= MMAN_br;                  outflags |= MMAN_br;
                 return;                  return;
         }          }
   
         switch (n->prev->tok) {          switch (n->prev->tok) {
         case (MDOC_Fd):          case MDOC_Fd:
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Fn):          case MDOC_Fn:
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Fo):          case MDOC_Fo:
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_In):          case MDOC_In:
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Vt):          case MDOC_Vt:
                 outflags |= MMAN_sp;                  outflags |= MMAN_sp;
                 break;                  break;
         case (MDOC_Ft):          case MDOC_Ft:
                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {                  if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
                         outflags |= MMAN_sp;                          outflags |= MMAN_sp;
                         break;                          break;
Line 785  pre_an(DECL_ARGS)
Line 804  pre_an(DECL_ARGS)
 {  {
   
         switch (n->norm->An.auth) {          switch (n->norm->An.auth) {
         case (AUTH_split):          case AUTH_split:
                 outflags &= ~MMAN_An_nosplit;                  outflags &= ~MMAN_An_nosplit;
                 outflags |= MMAN_An_split;                  outflags |= MMAN_An_split;
                 return(0);                  return(0);
         case (AUTH_nosplit):          case AUTH_nosplit:
                 outflags &= ~MMAN_An_split;                  outflags &= ~MMAN_An_split;
                 outflags |= MMAN_An_nosplit;                  outflags |= MMAN_An_nosplit;
                 return(0);                  return(0);
Line 848  pre_bf(DECL_ARGS)
Line 867  pre_bf(DECL_ARGS)
 {  {
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_BLOCK):          case MDOC_BLOCK:
                 return(1);                  return(1);
         case (MDOC_BODY):          case MDOC_BODY:
                 break;                  break;
         default:          default:
                 return(0);                  return(0);
         }          }
         switch (n->norm->Bf.font) {          switch (n->norm->Bf.font) {
         case (FONT_Em):          case FONT_Em:
                 font_push('I');                  font_push('I');
                 break;                  break;
         case (FONT_Sy):          case FONT_Sy:
                 font_push('B');                  font_push('B');
                 break;                  break;
         default:          default:
Line 882  pre_bk(DECL_ARGS)
Line 901  pre_bk(DECL_ARGS)
 {  {
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_BLOCK):          case MDOC_BLOCK:
                 return(1);                  return(1);
         case (MDOC_BODY):          case MDOC_BODY:
                 outflags |= MMAN_Bk;                  outflags |= MMAN_Bk;
                 return(1);                  return(1);
         default:          default:
Line 916  pre_bl(DECL_ARGS)
Line 935  pre_bl(DECL_ARGS)
         }          }
   
         switch (n->norm->Bl.type) {          switch (n->norm->Bl.type) {
         case (LIST_enum):          case LIST_enum:
                 n->norm->Bl.count = 0;                  n->norm->Bl.count = 0;
                 return(1);                  return(1);
         case (LIST_column):          case LIST_column:
                 break;                  break;
         default:          default:
                 return(1);                  return(1);
Line 938  post_bl(DECL_ARGS)
Line 957  post_bl(DECL_ARGS)
 {  {
   
         switch (n->norm->Bl.type) {          switch (n->norm->Bl.type) {
         case (LIST_column):          case LIST_column:
                 print_line(".TE", 0);                  print_line(".TE", 0);
                 break;                  break;
         case (LIST_enum):          case LIST_enum:
                 n->norm->Bl.count = 0;                  n->norm->Bl.count = 0;
                 break;                  break;
         default:          default:
Line 1019  pre_em(DECL_ARGS)
Line 1038  pre_em(DECL_ARGS)
         return(1);          return(1);
 }  }
   
   static int
   pre_en(DECL_ARGS)
   {
   
           if (NULL == n->norm->Es ||
               NULL == n->norm->Es->child)
                   return(1);
   
           print_word(n->norm->Es->child->string);
           outflags &= ~MMAN_spc;
           return(1);
   }
   
 static void  static void
   post_en(DECL_ARGS)
   {
   
           if (NULL == n->norm->Es ||
               NULL == n->norm->Es->child ||
               NULL == n->norm->Es->child->next)
                   return;
   
           outflags &= ~MMAN_spc;
           print_word(n->norm->Es->child->next->string);
           return;
   }
   
   static void
 post_eo(DECL_ARGS)  post_eo(DECL_ARGS)
 {  {
   
Line 1028  post_eo(DECL_ARGS)
Line 1074  post_eo(DECL_ARGS)
 }  }
   
 static int  static int
   pre_es(DECL_ARGS)
   {
   
           return(0);
   }
   
   static int
 pre_fa(DECL_ARGS)  pre_fa(DECL_ARGS)
 {  {
         int      am_Fa;          int      am_Fa;
Line 1136  pre_fo(DECL_ARGS)
Line 1189  pre_fo(DECL_ARGS)
 {  {
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_BLOCK):          case MDOC_BLOCK:
                 pre_syn(n);                  pre_syn(n);
                 break;                  break;
         case (MDOC_HEAD):          case MDOC_HEAD:
                 if (MDOC_SYNPRETTY & n->flags)                  if (MDOC_SYNPRETTY & n->flags)
                         print_block(".HP 4n", MMAN_nl);                          print_block(".HP 4n", MMAN_nl);
                 font_push('B');                  font_push('B');
                 break;                  break;
         case (MDOC_BODY):          case MDOC_BODY:
                 outflags &= ~MMAN_spc;                  outflags &= ~MMAN_spc;
                 print_word("(");                  print_word("(");
                 outflags &= ~MMAN_spc;                  outflags &= ~MMAN_spc;
Line 1160  post_fo(DECL_ARGS)
Line 1213  post_fo(DECL_ARGS)
 {  {
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_HEAD):          case MDOC_HEAD:
                 font_pop();                  font_pop();
                 break;                  break;
         case (MDOC_BODY):          case MDOC_BODY:
                 post_fn(meta, n);                  post_fn(meta, n);
                 break;                  break;
         default:          default:
Line 1219  pre_it(DECL_ARGS)
Line 1272  pre_it(DECL_ARGS)
         const struct mdoc_node *bln;          const struct mdoc_node *bln;
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_HEAD):          case MDOC_HEAD:
                 outflags |= MMAN_PP | MMAN_nl;                  outflags |= MMAN_PP | MMAN_nl;
                 bln = n->parent->parent;                  bln = n->parent->parent;
                 if (0 == bln->norm->Bl.comp ||                  if (0 == bln->norm->Bl.comp ||
Line 1228  pre_it(DECL_ARGS)
Line 1281  pre_it(DECL_ARGS)
                         outflags |= MMAN_sp;                          outflags |= MMAN_sp;
                 outflags &= ~MMAN_br;                  outflags &= ~MMAN_br;
                 switch (bln->norm->Bl.type) {                  switch (bln->norm->Bl.type) {
                 case (LIST_item):                  case LIST_item:
                         return(0);                          return(0);
                 case (LIST_inset):                  case LIST_inset:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_diag):                  case LIST_diag:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_ohang):                  case LIST_ohang:
                         if (bln->norm->Bl.type == LIST_diag)                          if (bln->norm->Bl.type == LIST_diag)
                                 print_line(".B \"", 0);                                  print_line(".B \"", 0);
                         else                          else
                                 print_line(".R \"", 0);                                  print_line(".R \"", 0);
                         outflags &= ~MMAN_spc;                          outflags &= ~MMAN_spc;
                         return(1);                          return(1);
                 case (LIST_bullet):                  case LIST_bullet:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_dash):                  case LIST_dash:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_hyphen):                  case LIST_hyphen:
                         print_width(bln->norm->Bl.width, NULL, 0);                          print_width(bln->norm->Bl.width, NULL, 0);
                         TPremain = 0;                          TPremain = 0;
                         outflags |= MMAN_nl;                          outflags |= MMAN_nl;
Line 1255  pre_it(DECL_ARGS)
Line 1308  pre_it(DECL_ARGS)
                         else                          else
                                 print_word("-");                                  print_word("-");
                         font_pop();                          font_pop();
                         break;                          outflags |= MMAN_nl;
                 case (LIST_enum):                          return(0);
                   case LIST_enum:
                         print_width(bln->norm->Bl.width, NULL, 0);                          print_width(bln->norm->Bl.width, NULL, 0);
                         TPremain = 0;                          TPremain = 0;
                         outflags |= MMAN_nl;                          outflags |= MMAN_nl;
                         print_count(&bln->norm->Bl.count);                          print_count(&bln->norm->Bl.count);
                         break;                          outflags |= MMAN_nl;
                 case (LIST_hang):                          return(0);
                   case LIST_hang:
                         print_width(bln->norm->Bl.width, n->child, 6);                          print_width(bln->norm->Bl.width, n->child, 6);
                         TPremain = 0;                          TPremain = 0;
                         break;                          outflags |= MMAN_nl;
                 case (LIST_tag):                          return(1);
                   case LIST_tag:
                         print_width(bln->norm->Bl.width, n->child, 0);                          print_width(bln->norm->Bl.width, n->child, 0);
                         putchar('\n');                          putchar('\n');
                         outflags &= ~MMAN_spc;                          outflags &= ~MMAN_spc;
Line 1274  pre_it(DECL_ARGS)
Line 1330  pre_it(DECL_ARGS)
                 default:                  default:
                         return(1);                          return(1);
                 }                  }
                 outflags |= MMAN_nl;  
         default:          default:
                 break;                  break;
         }          }
Line 1300  mid_it(void)
Line 1355  mid_it(void)
   
         /* Restore the indentation of the enclosing list. */          /* Restore the indentation of the enclosing list. */
         print_line(".RS", MMAN_Bk_susp);          print_line(".RS", MMAN_Bk_susp);
         snprintf(buf, sizeof(buf), "%zun", Bl_stack[Bl_stack_len - 1]);          (void)snprintf(buf, sizeof(buf), "%zun",
               Bl_stack[Bl_stack_len - 1]);
         print_word(buf);          print_word(buf);
   
         /* Remeber to close out this .RS block later. */          /* Remeber to close out this .RS block later. */
Line 1315  post_it(DECL_ARGS)
Line 1371  post_it(DECL_ARGS)
         bln = n->parent->parent;          bln = n->parent->parent;
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_HEAD):          case MDOC_HEAD:
                 switch (bln->norm->Bl.type) {                  switch (bln->norm->Bl.type) {
                 case (LIST_diag):                  case LIST_diag:
                         outflags &= ~MMAN_spc;                          outflags &= ~MMAN_spc;
                         print_word("\\ ");                          print_word("\\ ");
                         break;                          break;
                 case (LIST_ohang):                  case LIST_ohang:
                         outflags |= MMAN_br;                          outflags |= MMAN_br;
                         break;                          break;
                 default:                  default:
                         break;                          break;
                 }                  }
                 break;                  break;
         case (MDOC_BODY):          case MDOC_BODY:
                 switch (bln->norm->Bl.type) {                  switch (bln->norm->Bl.type) {
                 case (LIST_bullet):                  case LIST_bullet:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_dash):                  case LIST_dash:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_hyphen):                  case LIST_hyphen:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_enum):                  case LIST_enum:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_hang):                  case LIST_hang:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (LIST_tag):                  case LIST_tag:
                         assert(Bl_stack_len);                          assert(Bl_stack_len);
                         Bl_stack[--Bl_stack_len] = 0;                          Bl_stack[--Bl_stack_len] = 0;
   
Line 1354  post_it(DECL_ARGS)
Line 1410  post_it(DECL_ARGS)
                                 Bl_stack_post[Bl_stack_len] = 0;                                  Bl_stack_post[Bl_stack_len] = 0;
                         }                          }
                         break;                          break;
                 case (LIST_column):                  case LIST_column:
                         if (NULL != n->next) {                          if (NULL != n->next) {
                                 putchar('\t');                                  putchar('\t');
                                 outflags &= ~MMAN_spc;                                  outflags &= ~MMAN_spc;
Line 1402  pre_lk(DECL_ARGS)
Line 1458  pre_lk(DECL_ARGS)
 }  }
   
 static int  static int
   pre_ll(DECL_ARGS)
   {
   
           print_line(".ll", 0);
           return(1);
   }
   
   static int
 pre_li(DECL_ARGS)  pre_li(DECL_ARGS)
 {  {
   
Line 1441  post_nm(DECL_ARGS)
Line 1505  post_nm(DECL_ARGS)
 {  {
   
         switch (n->type) {          switch (n->type) {
         case (MDOC_BLOCK):          case MDOC_BLOCK:
                 outflags &= ~MMAN_Bk;                  outflags &= ~MMAN_Bk;
                 break;                  break;
         case (MDOC_HEAD):          case MDOC_HEAD:
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_ELEM):          case MDOC_ELEM:
                 font_pop();                  font_pop();
                 break;                  break;
         default:          default:
Line 1503  static int
Line 1567  static int
 pre_sm(DECL_ARGS)  pre_sm(DECL_ARGS)
 {  {
   
         assert(n->child && MDOC_TEXT == n->child->type);          if (NULL == n->child)
         if (0 == strcmp("on", n->child->string))                  outflags ^= MMAN_Sm;
                 outflags |= MMAN_Sm | MMAN_spc;          else if (0 == strcmp("on", n->child->string))
                   outflags |= MMAN_Sm;
         else          else
                 outflags &= ~MMAN_Sm;                  outflags &= ~MMAN_Sm;
   
           if (MMAN_Sm & outflags)
                   outflags |= MMAN_spc;
   
         return(0);          return(0);
 }  }
   
Line 1544  pre_vt(DECL_ARGS)
Line 1613  pre_vt(DECL_ARGS)
   
         if (MDOC_SYNPRETTY & n->flags) {          if (MDOC_SYNPRETTY & n->flags) {
                 switch (n->type) {                  switch (n->type) {
                 case (MDOC_BLOCK):                  case MDOC_BLOCK:
                         pre_syn(n);                          pre_syn(n);
                         return(1);                          return(1);
                 case (MDOC_BODY):                  case MDOC_BODY:
                         break;                          break;
                 default:                  default:
                         return(0);                          return(0);
Legend:
Removed from v.1.57  
changed lines
  Added in v.1.66
CVSweb