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

Diff for /mandoc/mdoc_term.c between version 1.96 and 1.138

version 1.96, 2009/10/26 04:09:46 version 1.138, 2010/06/04 21:49:39
Line 14 
Line 14 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
   #ifdef HAVE_CONFIG_H
   #include "config.h"
   #endif
   
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <err.h>  #include <stdint.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
   #include "mandoc.h"
 #include "out.h"  #include "out.h"
 #include "term.h"  #include "term.h"
 #include "mdoc.h"  #include "mdoc.h"
Line 34 
Line 39 
   
 struct  termpair {  struct  termpair {
         struct termpair  *ppair;          struct termpair  *ppair;
         int               flag;  
         int               count;          int               count;
 };  };
   
Line 56  static int   arg_hasattr(int, const struct mdoc_node *
Line 60  static int   arg_hasattr(int, const struct mdoc_node *
 static  int       arg_getattrs(const int *, int *, size_t,  static  int       arg_getattrs(const int *, int *, size_t,
                         const struct mdoc_node *);                          const struct mdoc_node *);
 static  int       arg_getattr(int, const struct mdoc_node *);  static  int       arg_getattr(int, const struct mdoc_node *);
 static  int       arg_listtype(const struct mdoc_node *);  static  int       arg_disptype(const struct mdoc_node *);
 static  void      print_bvspace(struct termp *,  static  void      print_bvspace(struct termp *,
                         const struct mdoc_node *,                          const struct mdoc_node *,
                         const struct mdoc_node *);                          const struct mdoc_node *);
 static  void      print_node(DECL_ARGS);  static  void      print_mdoc_node(DECL_ARGS);
 static  void      print_head(DECL_ARGS);  static  void      print_mdoc_head(DECL_ARGS);
 static  void      print_body(DECL_ARGS);  static  void      print_mdoc_nodelist(DECL_ARGS);
 static  void      print_foot(DECL_ARGS);  static  void      print_foot(DECL_ARGS);
   
 #ifdef __linux__  
 extern  size_t    strlcpy(char *, const char *, size_t);  
 extern  size_t    strlcat(char *, const char *, size_t);  
 #endif  
   
 static  void      termp____post(DECL_ARGS);  static  void      termp____post(DECL_ARGS);
 static  void      termp_an_post(DECL_ARGS);  static  void      termp_an_post(DECL_ARGS);
 static  void      termp_aq_post(DECL_ARGS);  static  void      termp_aq_post(DECL_ARGS);
Line 96  static void   termp_sq_post(DECL_ARGS);
Line 95  static void   termp_sq_post(DECL_ARGS);
 static  void      termp_ss_post(DECL_ARGS);  static  void      termp_ss_post(DECL_ARGS);
 static  void      termp_vt_post(DECL_ARGS);  static  void      termp_vt_post(DECL_ARGS);
   
 static  int       termp__t_pre(DECL_ARGS);  
 static  int       termp_an_pre(DECL_ARGS);  static  int       termp_an_pre(DECL_ARGS);
 static  int       termp_ap_pre(DECL_ARGS);  static  int       termp_ap_pre(DECL_ARGS);
 static  int       termp_aq_pre(DECL_ARGS);  static  int       termp_aq_pre(DECL_ARGS);
 static  int       termp_bd_pre(DECL_ARGS);  static  int       termp_bd_pre(DECL_ARGS);
 static  int       termp_bf_pre(DECL_ARGS);  static  int       termp_bf_pre(DECL_ARGS);
   static  int       termp_bl_pre(DECL_ARGS);
 static  int       termp_bold_pre(DECL_ARGS);  static  int       termp_bold_pre(DECL_ARGS);
 static  int       termp_bq_pre(DECL_ARGS);  static  int       termp_bq_pre(DECL_ARGS);
 static  int       termp_brq_pre(DECL_ARGS);  static  int       termp_brq_pre(DECL_ARGS);
Line 117  static int   termp_fo_pre(DECL_ARGS);
Line 116  static int   termp_fo_pre(DECL_ARGS);
 static  int       termp_ft_pre(DECL_ARGS);  static  int       termp_ft_pre(DECL_ARGS);
 static  int       termp_in_pre(DECL_ARGS);  static  int       termp_in_pre(DECL_ARGS);
 static  int       termp_it_pre(DECL_ARGS);  static  int       termp_it_pre(DECL_ARGS);
   static  int       termp_li_pre(DECL_ARGS);
 static  int       termp_lk_pre(DECL_ARGS);  static  int       termp_lk_pre(DECL_ARGS);
 static  int       termp_nd_pre(DECL_ARGS);  static  int       termp_nd_pre(DECL_ARGS);
 static  int       termp_nm_pre(DECL_ARGS);  static  int       termp_nm_pre(DECL_ARGS);
Line 134  static int   termp_sq_pre(DECL_ARGS);
Line 134  static int   termp_sq_pre(DECL_ARGS);
 static  int       termp_ss_pre(DECL_ARGS);  static  int       termp_ss_pre(DECL_ARGS);
 static  int       termp_under_pre(DECL_ARGS);  static  int       termp_under_pre(DECL_ARGS);
 static  int       termp_ud_pre(DECL_ARGS);  static  int       termp_ud_pre(DECL_ARGS);
   static  int       termp_vt_pre(DECL_ARGS);
 static  int       termp_xr_pre(DECL_ARGS);  static  int       termp_xr_pre(DECL_ARGS);
 static  int       termp_xx_pre(DECL_ARGS);  static  int       termp_xx_pre(DECL_ARGS);
   
Line 149  static const struct termact termacts[MDOC_MAX] = {
Line 150  static const struct termact termacts[MDOC_MAX] = {
         { termp_d1_pre, termp_d1_post }, /* Dl */          { termp_d1_pre, termp_d1_post }, /* Dl */
         { termp_bd_pre, termp_bd_post }, /* Bd */          { termp_bd_pre, termp_bd_post }, /* Bd */
         { NULL, NULL }, /* Ed */          { NULL, NULL }, /* Ed */
         { NULL, termp_bl_post }, /* Bl */          { termp_bl_pre, termp_bl_post }, /* Bl */
         { NULL, NULL }, /* El */          { NULL, NULL }, /* El */
         { termp_it_pre, termp_it_post }, /* It */          { termp_it_pre, termp_it_post }, /* It */
         { NULL, NULL }, /* Ad */          { NULL, NULL }, /* Ad */
Line 168  static const struct termact termacts[MDOC_MAX] = {
Line 169  static const struct termact termacts[MDOC_MAX] = {
         { termp_ft_pre, termp_ft_post }, /* Ft */          { termp_ft_pre, termp_ft_post }, /* Ft */
         { termp_bold_pre, NULL }, /* Ic */          { termp_bold_pre, NULL }, /* Ic */
         { termp_in_pre, termp_in_post }, /* In */          { termp_in_pre, termp_in_post }, /* In */
         { NULL, NULL }, /* Li */          { termp_li_pre, NULL }, /* Li */
         { termp_nd_pre, NULL }, /* Nd */          { termp_nd_pre, NULL }, /* Nd */
         { termp_nm_pre, NULL }, /* Nm */          { termp_nm_pre, NULL }, /* Nm */
         { termp_op_pre, termp_op_post }, /* Op */          { termp_op_pre, termp_op_post }, /* Op */
Line 177  static const struct termact termacts[MDOC_MAX] = {
Line 178  static const struct termact termacts[MDOC_MAX] = {
         { termp_rv_pre, NULL }, /* Rv */          { termp_rv_pre, NULL }, /* Rv */
         { NULL, NULL }, /* St */          { NULL, NULL }, /* St */
         { termp_under_pre, NULL }, /* Va */          { termp_under_pre, NULL }, /* Va */
         { termp_under_pre, termp_vt_post }, /* Vt */          { termp_vt_pre, termp_vt_post }, /* Vt */
         { termp_xr_pre, NULL }, /* Xr */          { termp_xr_pre, NULL }, /* Xr */
         { NULL, termp____post }, /* %A */          { NULL, termp____post }, /* %A */
         { termp_under_pre, termp____post }, /* %B */          { termp_under_pre, termp____post }, /* %B */
Line 188  static const struct termact termacts[MDOC_MAX] = {
Line 189  static const struct termact termacts[MDOC_MAX] = {
         { NULL, termp____post }, /* %O */          { NULL, termp____post }, /* %O */
         { NULL, termp____post }, /* %P */          { NULL, termp____post }, /* %P */
         { NULL, termp____post }, /* %R */          { NULL, termp____post }, /* %R */
         { termp__t_pre, termp____post }, /* %T */          { termp_under_pre, termp____post }, /* %T */
         { NULL, termp____post }, /* %V */          { NULL, termp____post }, /* %V */
         { NULL, NULL }, /* Ac */          { NULL, NULL }, /* Ac */
         { termp_aq_pre, termp_aq_post }, /* Ao */          { termp_aq_pre, termp_aq_post }, /* Ao */
Line 204  static const struct termact termacts[MDOC_MAX] = {
Line 205  static const struct termact termacts[MDOC_MAX] = {
         { NULL, NULL }, /* Dc */          { NULL, NULL }, /* Dc */
         { termp_dq_pre, termp_dq_post }, /* Do */          { termp_dq_pre, termp_dq_post }, /* Do */
         { termp_dq_pre, termp_dq_post }, /* Dq */          { termp_dq_pre, termp_dq_post }, /* Dq */
         { NULL, NULL }, /* Ec */          { NULL, NULL }, /* Ec */ /* FIXME: no space */
         { NULL, NULL }, /* Ef */          { NULL, NULL }, /* Ef */
         { termp_under_pre, NULL }, /* Em */          { termp_under_pre, NULL }, /* Em */
         { NULL, NULL }, /* Eo */          { NULL, NULL }, /* Eo */
Line 259  static const struct termact termacts[MDOC_MAX] = {
Line 260  static const struct termact termacts[MDOC_MAX] = {
         { termp_sp_pre, NULL }, /* br */          { termp_sp_pre, NULL }, /* br */
         { termp_sp_pre, NULL }, /* sp */          { termp_sp_pre, NULL }, /* sp */
         { termp_under_pre, termp____post }, /* %U */          { termp_under_pre, termp____post }, /* %U */
           { NULL, NULL }, /* Ta */
 };  };
   
   
Line 271  terminal_mdoc(void *arg, const struct mdoc *mdoc)
Line 273  terminal_mdoc(void *arg, const struct mdoc *mdoc)
   
         p = (struct termp *)arg;          p = (struct termp *)arg;
   
           p->overstep = 0;
           p->maxrmargin = p->defrmargin;
           p->tabwidth = 5;
   
         if (NULL == p->symtab)          if (NULL == p->symtab)
                 switch (p->enc) {                  switch (p->enc) {
                 case (TERMENC_ASCII):                  case (TERMENC_ASCII):
Line 284  terminal_mdoc(void *arg, const struct mdoc *mdoc)
Line 290  terminal_mdoc(void *arg, const struct mdoc *mdoc)
         n = mdoc_node(mdoc);          n = mdoc_node(mdoc);
         m = mdoc_meta(mdoc);          m = mdoc_meta(mdoc);
   
         print_head(p, NULL, m, n);          print_mdoc_head(p, NULL, m, n);
         if (n->child)          if (n->child)
                 print_body(p, NULL, m, n->child);                  print_mdoc_nodelist(p, NULL, m, n->child);
         print_foot(p, NULL, m, n);          print_foot(p, NULL, m, n);
 }  }
   
   
 static void  static void
 print_body(DECL_ARGS)  print_mdoc_nodelist(DECL_ARGS)
 {  {
   
         print_node(p, pair, m, n);          print_mdoc_node(p, pair, m, n);
         if (n->next)          if (n->next)
                 print_body(p, pair, m, n->next);                  print_mdoc_nodelist(p, pair, m, n->next);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 print_node(DECL_ARGS)  print_mdoc_node(DECL_ARGS)
 {  {
         int              chld, bold, under;          int              chld;
           const void      *font;
         struct termpair  npair;          struct termpair  npair;
         size_t           offset, rmargin;          size_t           offset, rmargin;
   
         chld = 1;          chld = 1;
         offset = p->offset;          offset = p->offset;
         rmargin = p->rmargin;          rmargin = p->rmargin;
         bold = p->bold;          font = term_fontq(p);
         under = p->under;  
   
         bzero(&npair, sizeof(struct termpair));          memset(&npair, 0, sizeof(struct termpair));
         npair.ppair = pair;          npair.ppair = pair;
   
         if (MDOC_TEXT != n->type) {          if (MDOC_TEXT != n->type) {
Line 323  print_node(DECL_ARGS)
Line 329  print_node(DECL_ARGS)
                         chld = (*termacts[n->tok].pre)(p, &npair, m, n);                          chld = (*termacts[n->tok].pre)(p, &npair, m, n);
         } else          } else
                 term_word(p, n->string);                  term_word(p, n->string);
   
         if (chld && n->child)          if (chld && n->child)
                 print_body(p, &npair, m, n->child);                  print_mdoc_nodelist(p, &npair, m, n->child);
   
         /*          term_fontpopq(p, font);
          * XXX - if bold/under were to span scopes, this wouldn't be  
          * possible, but because decoration is always in-scope, we can  
          * get away with this.  
          */  
   
         p->bold = bold;  
         p->under = under;  
   
         if (MDOC_TEXT != n->type)          if (MDOC_TEXT != n->type)
                 if (termacts[n->tok].post)                  if (termacts[n->tok].post)
                         (*termacts[n->tok].post)(p, &npair, m, n);                          (*termacts[n->tok].post)(p, &npair, m, n);
   
           if (MDOC_EOS & n->flags)
                   p->flags |= TERMP_SENTENCE;
   
         p->offset = offset;          p->offset = offset;
         p->rmargin = rmargin;          p->rmargin = rmargin;
 }  }
Line 348  print_node(DECL_ARGS)
Line 351  print_node(DECL_ARGS)
 static void  static void
 print_foot(DECL_ARGS)  print_foot(DECL_ARGS)
 {  {
         char             buf[DATESIZ];          char            buf[DATESIZ], os[BUFSIZ];
         char            *os;  
   
           term_fontrepl(p, TERMFONT_NONE);
   
         /*          /*
          * Output the footer in new-groff style, that is, three columns           * Output the footer in new-groff style, that is, three columns
          * with the middle being the manual date and flanking columns           * with the middle being the manual date and flanking columns
Line 359  print_foot(DECL_ARGS)
Line 363  print_foot(DECL_ARGS)
          * SYSTEM                  DATE                    SYSTEM           * SYSTEM                  DATE                    SYSTEM
          */           */
   
         if (NULL == (os = malloc(p->rmargin)))  
                 err(EXIT_FAILURE, "malloc");  
   
         time2a(m->date, buf, DATESIZ);          time2a(m->date, buf, DATESIZ);
           strlcpy(os, m->os, BUFSIZ);
   
         (void)strlcpy(os, m->os, p->rmargin);  
   
         term_vspace(p);          term_vspace(p);
   
         p->offset = 0;          p->offset = 0;
Line 393  print_foot(DECL_ARGS)
Line 393  print_foot(DECL_ARGS)
         p->offset = 0;          p->offset = 0;
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->flags = 0;          p->flags = 0;
   
         free(os);  
 }  }
   
   
 /* FIXME: put in utility library. */  
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 print_head(DECL_ARGS)  print_mdoc_head(DECL_ARGS)
 {  {
         char            *buf, *title;          char            buf[BUFSIZ], title[BUFSIZ];
   
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->offset = 0;          p->offset = 0;
   
         if (NULL == (buf = malloc(p->rmargin)))  
                 err(EXIT_FAILURE, "malloc");  
         if (NULL == (title = malloc(p->rmargin)))  
                 err(EXIT_FAILURE, "malloc");  
   
         /*          /*
          * The header is strange.  It has three components, which are           * The header is strange.  It has three components, which are
          * really two with the first duplicated.  It goes like this:           * really two with the first duplicated.  It goes like this:
Line 427  print_head(DECL_ARGS)
Line 419  print_head(DECL_ARGS)
          */           */
   
         assert(m->vol);          assert(m->vol);
         (void)strlcpy(buf, m->vol, p->rmargin);          strlcpy(buf, m->vol, BUFSIZ);
   
         if (m->arch) {          if (m->arch) {
                 (void)strlcat(buf, " (", p->rmargin);                  strlcat(buf, " (", BUFSIZ);
                 (void)strlcat(buf, m->arch, p->rmargin);                  strlcat(buf, m->arch, BUFSIZ);
                 (void)strlcat(buf, ")", p->rmargin);                  strlcat(buf, ")", BUFSIZ);
         }          }
   
         snprintf(title, p->rmargin, "%s(%d)", m->title, m->msec);          snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
   
         p->offset = 0;          p->offset = 0;
         p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;          p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
Line 462  print_head(DECL_ARGS)
Line 454  print_head(DECL_ARGS)
         p->offset = 0;          p->offset = 0;
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->flags &= ~TERMP_NOSPACE;          p->flags &= ~TERMP_NOSPACE;
   
         free(title);  
         free(buf);  
 }  }
   
   
Line 491  a2width(const struct mdoc_argv *arg, int pos)
Line 480  a2width(const struct mdoc_argv *arg, int pos)
         if ( ! a2roffsu(arg->value[pos], &su, SCALE_MAX))          if ( ! a2roffsu(arg->value[pos], &su, SCALE_MAX))
                 SCALE_HS_INIT(&su, strlen(arg->value[pos]));                  SCALE_HS_INIT(&su, strlen(arg->value[pos]));
   
         /* XXX: pachemu? */          return(term_hspan(&su));
         return(term_hspan(&su) + 2);  
 }  }
   
   
 static int  static int
 arg_listtype(const struct mdoc_node *n)  arg_disptype(const struct mdoc_node *n)
 {  {
         int              i, len;          int              i, len;
   
Line 505  arg_listtype(const struct mdoc_node *n)
Line 493  arg_listtype(const struct mdoc_node *n)
   
         len = (int)(n->args ? n->args->argc : 0);          len = (int)(n->args ? n->args->argc : 0);
   
         for (i = 0; i < len; i++)          for (i = 0; i < len; i++)
                 switch (n->args->argv[i].arg) {                  switch (n->args->argv[i].arg) {
                 case (MDOC_Bullet):                  case (MDOC_Centred):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Dash):                  case (MDOC_Ragged):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Enum):                  case (MDOC_Filled):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Hyphen):                  case (MDOC_Unfilled):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Tag):                  case (MDOC_Literal):
                         /* FALLTHROUGH */  
                 case (MDOC_Inset):  
                         /* FALLTHROUGH */  
                 case (MDOC_Diag):  
                         /* FALLTHROUGH */  
                 case (MDOC_Item):  
                         /* FALLTHROUGH */  
                 case (MDOC_Column):  
                         /* FALLTHROUGH */  
                 case (MDOC_Hang):  
                         /* FALLTHROUGH */  
                 case (MDOC_Ohang):  
                         return(n->args->argv[i].arg);                          return(n->args->argv[i].arg);
                 default:                  default:
                         break;                          break;
Line 557  a2offs(const struct mdoc_argv *arg)
Line 533  a2offs(const struct mdoc_argv *arg)
 }  }
   
   
   /*
    * Return 1 if an argument has a particular argument value or 0 if it
    * does not.  See arg_getattr().
    */
 static int  static int
 arg_hasattr(int arg, const struct mdoc_node *n)  arg_hasattr(int arg, const struct mdoc_node *n)
 {  {
Line 565  arg_hasattr(int arg, const struct mdoc_node *n)
Line 545  arg_hasattr(int arg, const struct mdoc_node *n)
 }  }
   
   
   /*
    * Get the index of an argument in a node's argument list or -1 if it
    * does not exist.  See arg_getattrs().
    */
 static int  static int
 arg_getattr(int v, const struct mdoc_node *n)  arg_getattr(int v, const struct mdoc_node *n)
 {  {
Line 574  arg_getattr(int v, const struct mdoc_node *n)
Line 558  arg_getattr(int v, const struct mdoc_node *n)
 }  }
   
   
   /*
    * Walk through the argument list for a node and fill an array "vals"
    * with the positions of the argument structures listed in "keys".
    * Return the number of elements that were written into "vals", which
    * can be zero.
    */
 static int  static int
 arg_getattrs(const int *keys, int *vals,  arg_getattrs(const int *keys, int *vals,
                 size_t sz, const struct mdoc_node *n)                  size_t sz, const struct mdoc_node *n)
Line 593  arg_getattrs(const int *keys, int *vals, 
Line 583  arg_getattrs(const int *keys, int *vals, 
 }  }
   
   
   /*
    * Determine how much space to print out before block elements of `It'
    * (and thus `Bl') and `Bd'.  And then go ahead and print that space,
    * too.
    */
 static void  static void
 print_bvspace(struct termp *p,  print_bvspace(struct termp *p,
                 const struct mdoc_node *bl,                  const struct mdoc_node *bl,
Line 620  print_bvspace(struct termp *p, 
Line 615  print_bvspace(struct termp *p, 
   
         /* A `-column' does not assert vspace within the list. */          /* A `-column' does not assert vspace within the list. */
   
         if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Column, bl))          if (MDOC_Bl == bl->tok && LIST_column == bl->data.list)
                 if (n->prev && MDOC_It == n->prev->tok)                  if (n->prev && MDOC_It == n->prev->tok)
                         return;                          return;
   
         /* A `-diag' without body does not vspace. */          /* A `-diag' without body does not vspace. */
   
         if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Diag, bl))          if (MDOC_Bl == bl->tok && LIST_diag == bl->data.list)
                 if (n->prev && MDOC_It == n->prev->tok) {                  if (n->prev && MDOC_It == n->prev->tok) {
                         assert(n->prev->body);                          assert(n->prev->body);
                         if (NULL == n->prev->body->child)                          if (NULL == n->prev->body->child)
Line 670  termp_it_pre(DECL_ARGS)
Line 665  termp_it_pre(DECL_ARGS)
 {  {
         const struct mdoc_node *bl, *nn;          const struct mdoc_node *bl, *nn;
         char                    buf[7];          char                    buf[7];
         int                     i, type, keys[3], vals[3];          int                     i, keys[3], vals[3];
         size_t                  width, offset;          size_t                  width, offset, ncols, dcol;
           enum mdoc_list          type;
   
         if (MDOC_BLOCK == n->type) {          if (MDOC_BLOCK == n->type) {
                 print_bvspace(p, n->parent->parent, n);                  print_bvspace(p, n->parent->parent, n);
Line 680  termp_it_pre(DECL_ARGS)
Line 676  termp_it_pre(DECL_ARGS)
   
         bl = n->parent->parent->parent;          bl = n->parent->parent->parent;
   
         /* Save parent attributes. */          /* Get list width, offset, and list type from argument list. */
   
         pair->flag = p->flags;  
   
         /* Get list width and offset. */  
   
         keys[0] = MDOC_Width;          keys[0] = MDOC_Width;
         keys[1] = MDOC_Offset;          keys[1] = MDOC_Offset;
         keys[2] = MDOC_Column;          keys[2] = MDOC_Column;
   
         vals[0] = vals[1] = vals[2] = -1;          vals[0] = vals[1] = vals[2] = -1;
   
         width = offset = 0;          arg_getattrs(keys, vals, 3, bl);
   
         (void)arg_getattrs(keys, vals, 3, bl);          type = bl->data.list;
   
         type = arg_listtype(bl);          /*
         assert(-1 != type);           * First calculate width and offset.  This is pretty easy unless
            * we're a -column list, in which case all prior columns must
            * be accounted for.
            */
   
         /* Calculate real width and offset. */          width = offset = 0;
   
           if (vals[1] >= 0)
                   offset = a2offs(&bl->args->argv[vals[1]]);
   
         switch (type) {          switch (type) {
         case (MDOC_Column):          case (LIST_column):
                 if (MDOC_BODY == n->type)                  if (MDOC_HEAD == n->type)
                         break;                          break;
                 /*                  /*
                  * Work around groff's column handling.  The offset is                   * Imitate groff's column handling:
                  * equal to the sum of all widths leading to the current                   * - For each earlier column, add its width.
                  * column (plus the -offset value).  If this column                   * - For less than 5 columns, add four more blanks per
                  * exceeds the stated number of columns, the width is                   *   column.
                  * set as 0, else it's the stated column width (later                   * - For exactly 5 columns, add three more blank per
                  * the 0 will be adjusted to default 10 or, if in the                   *   column.
                  * last column case, set to stretch to the margin).                   * - For more than 5 columns, add only one column.
                  */                   */
                 for (i = 0, nn = n->prev; nn &&                  ncols = bl->args->argv[vals[2]].sz;
                                 i < (int)bl->args->argv[vals[2]].sz;                  /* LINTED */
                   dcol = ncols < 5 ? 4 : ncols == 5 ? 3 : 1;
   
                   /*
                    * Calculate the offset by applying all prior MDOC_BODY,
                    * so we stop at the MDOC_HEAD (NULL == nn->prev).
                    */
   
                   for (i = 0, nn = n->prev;
                                   nn->prev && i < (int)ncols;
                                 nn = nn->prev, i++)                                  nn = nn->prev, i++)
                         offset += a2width                          offset += dcol + a2width
                                 (&bl->args->argv[vals[2]], i);                                  (&bl->args->argv[vals[2]], i);
   
                 /* Whether exceeds maximum column. */  
                 if (i < (int)bl->args->argv[vals[2]].sz)  
                         width = a2width(&bl->args->argv[vals[2]], i);  
                 else  
                         width = 0;  
   
                 if (vals[1] >= 0)                  /*
                         offset += a2offs(&bl->args->argv[vals[1]]);                   * When exceeding the declared number of columns, leave
                    * the remaining widths at 0.  This will later be
                    * adjusted to the default width of 10, or, for the last
                    * column, stretched to the right margin.
                    */
                   if (i >= (int)ncols)
                           break;
   
                   /*
                    * Use the declared column widths, extended as explained
                    * in the preceding paragraph.
                    */
                   width = a2width(&bl->args->argv[vals[2]], i) + dcol;
                 break;                  break;
         default:          default:
                 if (vals[0] >= 0)                  if (vals[0] < 0)
                         width = a2width(&bl->args->argv[vals[0]], 0);                          break;
                 if (vals[1] >= 0)  
                         offset += a2offs(&bl->args->argv[vals[1]]);                  /*
                    * Note: buffer the width by 2, which is groff's magic
                    * number for buffering single arguments.  See the above
                    * handling for column for how this changes.
                    */
                   width = a2width(&bl->args->argv[vals[0]], 0) + 2;
                 break;                  break;
         }          }
   
Line 744  termp_it_pre(DECL_ARGS)
Line 763  termp_it_pre(DECL_ARGS)
          */           */
   
         switch (type) {          switch (type) {
         case (MDOC_Bullet):          case (LIST_bullet):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Dash):          case (LIST_dash):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Hyphen):          case (LIST_hyphen):
                 if (width < 4)                  if (width < 4)
                         width = 4;                          width = 4;
                 break;                  break;
         case (MDOC_Enum):          case (LIST_enum):
                 if (width < 5)                  if (width < 5)
                         width = 5;                          width = 5;
                 break;                  break;
         case (MDOC_Hang):          case (LIST_hang):
                 if (0 == width)                  if (0 == width)
                         width = 8;                          width = 8;
                 break;                  break;
         case (MDOC_Column):          case (LIST_column):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Tag):          case (LIST_tag):
                 if (0 == width)                  if (0 == width)
                         width = 10;                          width = 10;
                 break;                  break;
Line 778  termp_it_pre(DECL_ARGS)
Line 797  termp_it_pre(DECL_ARGS)
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
   
         switch (type) {          switch (type) {
         case (MDOC_Diag):          case (LIST_diag):
                 if (MDOC_BODY == n->type)                  if (MDOC_BODY == n->type)
                         term_word(p, "\\ \\ ");                          term_word(p, "\\ \\ ");
                 break;                  break;
         case (MDOC_Inset):          case (LIST_inset):
                 if (MDOC_BODY == n->type)                  if (MDOC_BODY == n->type)
                         term_word(p, "\\ ");                          term_word(p, "\\ ");
                 break;                  break;
Line 793  termp_it_pre(DECL_ARGS)
Line 812  termp_it_pre(DECL_ARGS)
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
   
         switch (type) {          switch (type) {
         case (MDOC_Diag):          case (LIST_diag):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->bold++;                          term_fontpush(p, TERMFONT_BOLD);
                 break;                  break;
         default:          default:
                 break;                  break;
         }          }
   
         /*          /*
          * Pad and break control.  This is the tricker part.  Lists with           * Pad and break control.  This is the tricky part.  These flags
          * set right-margins for the head get TERMP_NOBREAK because, if           * are documented in term_flushln() in term.c.  Note that we're
          * they overrun the margin, they wrap to the new margin.           * going to unset all of these flags in termp_it_post() when we
          * Correspondingly, the body for these types don't left-pad, as           * exit.
          * the head will pad out to to the right.  
          */           */
   
         switch (type) {          switch (type) {
         case (MDOC_Bullet):          case (LIST_bullet):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Dash):          case (LIST_dash):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Enum):          case (LIST_enum):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Hyphen):          case (LIST_hyphen):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->flags |= TERMP_NOBREAK;                          p->flags |= TERMP_NOBREAK;
                 else                  else
                         p->flags |= TERMP_NOLPAD;                          p->flags |= TERMP_NOLPAD;
                 break;                  break;
         case (MDOC_Hang):          case (LIST_hang):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->flags |= TERMP_NOBREAK;                          p->flags |= TERMP_NOBREAK;
                 else                  else
Line 845  termp_it_pre(DECL_ARGS)
Line 863  termp_it_pre(DECL_ARGS)
                 } else                  } else
                         p->flags |= TERMP_HANG;                          p->flags |= TERMP_HANG;
                 break;                  break;
         case (MDOC_Tag):          case (LIST_tag):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE;                          p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE;
                 else                  else
Line 856  termp_it_pre(DECL_ARGS)
Line 874  termp_it_pre(DECL_ARGS)
                 if (NULL == n->next || NULL == n->next->child)                  if (NULL == n->next || NULL == n->next->child)
                         p->flags |= TERMP_DANGLE;                          p->flags |= TERMP_DANGLE;
                 break;                  break;
         case (MDOC_Column):          case (LIST_column):
                 if (MDOC_HEAD == n->type) {                  if (MDOC_HEAD == n->type)
                         assert(n->next);                          break;
                         if (MDOC_BODY == n->next->type)  
                                 p->flags &= ~TERMP_NOBREAK;                  if (NULL == n->next)
                         else                          p->flags &= ~TERMP_NOBREAK;
                                 p->flags |= TERMP_NOBREAK;                  else
                         if (n->prev)                          p->flags |= TERMP_NOBREAK;
                                 p->flags |= TERMP_NOLPAD;  
                 }                  assert(n->prev);
                   if (MDOC_BODY == n->prev->type)
                           p->flags |= TERMP_NOLPAD;
   
                 break;                  break;
         case (MDOC_Diag):          case (LIST_diag):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->flags |= TERMP_NOBREAK;                          p->flags |= TERMP_NOBREAK;
                 break;                  break;
Line 884  termp_it_pre(DECL_ARGS)
Line 905  termp_it_pre(DECL_ARGS)
         p->offset += offset;          p->offset += offset;
   
         switch (type) {          switch (type) {
         case (MDOC_Hang):          case (LIST_hang):
                 /*                  /*
                  * Same stipulation as above, regarding `-hang'.  We                   * Same stipulation as above, regarding `-hang'.  We
                  * don't want to recalculate rmargin and offsets when                   * don't want to recalculate rmargin and offsets when
Line 895  termp_it_pre(DECL_ARGS)
Line 916  termp_it_pre(DECL_ARGS)
                                  MDOC_Bd == n->next->child->tok))                                   MDOC_Bd == n->next->child->tok))
                         break;                          break;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Bullet):          case (LIST_bullet):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Dash):          case (LIST_dash):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Enum):          case (LIST_enum):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Hyphen):          case (LIST_hyphen):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Tag):          case (LIST_tag):
                 assert(width);                  assert(width);
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         p->rmargin = p->offset + width;                          p->rmargin = p->offset + width;
                 else                  else
                         p->offset += width;                          p->offset += width;
                 break;                  break;
         case (MDOC_Column):          case (LIST_column):
                 assert(width);                  assert(width);
                 p->rmargin = p->offset + width;                  p->rmargin = p->offset + width;
                 /*                  /*
                  * XXX - this behaviour is not documented: the                   * XXX - this behaviour is not documented: the
                  * right-most column is filled to the right margin.                   * right-most column is filled to the right margin.
                  */                   */
                 if (MDOC_HEAD == n->type &&                  if (MDOC_HEAD == n->type)
                                 MDOC_BODY == n->next->type)                          break;
                   if (NULL == n->next && p->rmargin < p->maxrmargin)
                         p->rmargin = p->maxrmargin;                          p->rmargin = p->maxrmargin;
                 break;                  break;
         default:          default:
Line 932  termp_it_pre(DECL_ARGS)
Line 954  termp_it_pre(DECL_ARGS)
   
         if (MDOC_HEAD == n->type)          if (MDOC_HEAD == n->type)
                 switch (type) {                  switch (type) {
                 case (MDOC_Bullet):                  case (LIST_bullet):
                         p->bold++;                          term_fontpush(p, TERMFONT_BOLD);
                         term_word(p, "\\[bu]");                          term_word(p, "\\[bu]");
                         p->bold--;                          term_fontpop(p);
                         break;                          break;
                 case (MDOC_Dash):                  case (LIST_dash):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case (MDOC_Hyphen):                  case (LIST_hyphen):
                         p->bold++;                          term_fontpush(p, TERMFONT_BOLD);
                         term_word(p, "\\(hy");                          term_word(p, "\\(hy");
                         p->bold--;                          term_fontpop(p);
                         break;                          break;
                 case (MDOC_Enum):                  case (LIST_enum):
                         (pair->ppair->ppair->count)++;                          (pair->ppair->ppair->count)++;
                         (void)snprintf(buf, sizeof(buf), "%d.",                          snprintf(buf, sizeof(buf), "%d.",
                                         pair->ppair->ppair->count);                                          pair->ppair->ppair->count);
                         term_word(p, buf);                          term_word(p, buf);
                         break;                          break;
Line 959  termp_it_pre(DECL_ARGS)
Line 981  termp_it_pre(DECL_ARGS)
          */           */
   
         switch (type) {          switch (type) {
         case (MDOC_Bullet):          case (LIST_bullet):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Item):          case (LIST_item):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Dash):          case (LIST_dash):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Hyphen):          case (LIST_hyphen):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Enum):          case (LIST_enum):
                 if (MDOC_HEAD == n->type)                  if (MDOC_HEAD == n->type)
                         return(0);                          return(0);
                 break;                  break;
         case (MDOC_Column):          case (LIST_column):
                 if (MDOC_BODY == n->type)                  if (MDOC_HEAD == n->type)
                         return(0);                          return(0);
                 break;                  break;
         default:          default:
Line 987  termp_it_pre(DECL_ARGS)
Line 1009  termp_it_pre(DECL_ARGS)
 static void  static void
 termp_it_post(DECL_ARGS)  termp_it_post(DECL_ARGS)
 {  {
         int                type;          enum mdoc_list     type;
   
         if (MDOC_BODY != n->type && MDOC_HEAD != n->type)          if (MDOC_BLOCK == n->type)
                 return;                  return;
   
         type = arg_listtype(n->parent->parent->parent);          type = n->parent->parent->parent->data.list;
         assert(-1 != type);  
   
         switch (type) {          switch (type) {
         case (MDOC_Item):          case (LIST_item):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Diag):          case (LIST_diag):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (MDOC_Inset):          case (LIST_inset):
                 if (MDOC_BODY == n->type)                  if (MDOC_BODY == n->type)
                         term_flushln(p);                          term_newln(p);
                 break;                  break;
         case (MDOC_Column):          case (LIST_column):
                 if (MDOC_HEAD == n->type)                  if (MDOC_BODY == n->type)
                         term_flushln(p);                          term_flushln(p);
                 break;                  break;
         default:          default:
                 term_flushln(p);                  term_newln(p);
                 break;                  break;
         }          }
   
         p->flags = pair->flag;          /*
            * Now that our output is flushed, we can reset our tags.  Since
            * only `It' sets these flags, we're free to assume that nobody
            * has munged them in the meanwhile.
            */
   
           p->flags &= ~TERMP_DANGLE;
           p->flags &= ~TERMP_NOBREAK;
           p->flags &= ~TERMP_TWOSPACE;
           p->flags &= ~TERMP_NOLPAD;
           p->flags &= ~TERMP_HANG;
 }  }
   
   
Line 1022  static int
Line 1053  static int
 termp_nm_pre(DECL_ARGS)  termp_nm_pre(DECL_ARGS)
 {  {
   
         if (SEC_SYNOPSIS == n->sec)          if (NULL == n->child && NULL == m->name)
                   return(1);
   
           if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)
                 term_newln(p);                  term_newln(p);
         p->bold++;  
           term_fontpush(p, TERMFONT_BOLD);
   
         if (NULL == n->child)          if (NULL == n->child)
                 term_word(p, m->name);                  term_word(p, m->name);
   
         return(1);          return(1);
 }  }
   
Line 1036  static int
Line 1073  static int
 termp_fl_pre(DECL_ARGS)  termp_fl_pre(DECL_ARGS)
 {  {
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         term_word(p, "\\-");          term_word(p, "\\-");
         p->flags |= TERMP_NOSPACE;  
           if (n->child)
                   p->flags |= TERMP_NOSPACE;
           else if (n->next && n->next->line == n->line)
                   p->flags |= TERMP_NOSPACE;
   
         return(1);          return(1);
 }  }
   
Line 1090  termp_an_post(DECL_ARGS)
Line 1132  termp_an_post(DECL_ARGS)
                 return;                  return;
         }          }
   
         if (arg_getattr(MDOC_Split, n) > -1) {          if (arg_hasattr(MDOC_Split, n)) {
                 p->flags &= ~TERMP_NOSPLIT;                  p->flags &= ~TERMP_NOSPLIT;
                 p->flags |= TERMP_SPLIT;                  p->flags |= TERMP_SPLIT;
         } else {          } else {
Line 1134  termp_rv_pre(DECL_ARGS)
Line 1176  termp_rv_pre(DECL_ARGS)
         term_word(p, "The");          term_word(p, "The");
   
         for (nn = n->child; nn; nn = nn->next) {          for (nn = n->child; nn; nn = nn->next) {
                 p->bold++;                  term_fontpush(p, TERMFONT_BOLD);
                 term_word(p, nn->string);                  term_word(p, nn->string);
                 p->bold--;                  term_fontpop(p);
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 if (nn->next && NULL == nn->next->next)                  if (nn->next && NULL == nn->next->next)
                         term_word(p, "(), and");                          term_word(p, "(), and");
Line 1146  termp_rv_pre(DECL_ARGS)
Line 1188  termp_rv_pre(DECL_ARGS)
                         term_word(p, "()");                          term_word(p, "()");
         }          }
   
         if (n->child->next)          if (n->child && n->child->next)
                 term_word(p, "functions return");                  term_word(p, "functions return");
         else          else
                 term_word(p, "function returns");                  term_word(p, "function returns");
Line 1154  termp_rv_pre(DECL_ARGS)
Line 1196  termp_rv_pre(DECL_ARGS)
         term_word(p, "the value 0 if successful; otherwise the value "          term_word(p, "the value 0 if successful; otherwise the value "
                         "-1 is returned and the global variable");                          "-1 is returned and the global variable");
   
         p->under++;          term_fontpush(p, TERMFONT_UNDER);
         term_word(p, "errno");          term_word(p, "errno");
         p->under--;          term_fontpop(p);
   
         term_word(p, "is set to indicate the error.");          term_word(p, "is set to indicate the error.");
           p->flags |= TERMP_SENTENCE;
   
         return(0);          return(0);
 }  }
Line 1173  termp_ex_pre(DECL_ARGS)
Line 1216  termp_ex_pre(DECL_ARGS)
         term_word(p, "The");          term_word(p, "The");
   
         for (nn = n->child; nn; nn = nn->next) {          for (nn = n->child; nn; nn = nn->next) {
                 p->bold++;                  term_fontpush(p, TERMFONT_BOLD);
                 term_word(p, nn->string);                  term_word(p, nn->string);
                 p->bold--;                  term_fontpop(p);
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 if (nn->next && NULL == nn->next->next)                  if (nn->next && NULL == nn->next->next)
                         term_word(p, ", and");                          term_word(p, ", and");
Line 1185  termp_ex_pre(DECL_ARGS)
Line 1228  termp_ex_pre(DECL_ARGS)
                         p->flags &= ~TERMP_NOSPACE;                          p->flags &= ~TERMP_NOSPACE;
         }          }
   
         if (n->child->next)          if (n->child && n->child->next)
                 term_word(p, "utilities exit");                  term_word(p, "utilities exit");
         else          else
                 term_word(p, "utility exits");                  term_word(p, "utility exits");
   
         term_word(p, "0 on success, and >0 if an error occurs.");          term_word(p, "0 on success, and >0 if an error occurs.");
           p->flags |= TERMP_SENTENCE;
   
         return(0);          return(0);
 }  }
Line 1214  termp_nd_pre(DECL_ARGS)
Line 1258  termp_nd_pre(DECL_ARGS)
   
   
 /* ARGSUSED */  /* ARGSUSED */
   static int
   termp_bl_pre(DECL_ARGS)
   {
   
           return(MDOC_HEAD != n->type);
   }
   
   
   /* ARGSUSED */
 static void  static void
 termp_bl_post(DECL_ARGS)  termp_bl_post(DECL_ARGS)
 {  {
Line 1241  termp_xr_pre(DECL_ARGS)
Line 1294  termp_xr_pre(DECL_ARGS)
 {  {
         const struct mdoc_node *nn;          const struct mdoc_node *nn;
   
         assert(n->child && MDOC_TEXT == n->child->type);          if (NULL == n->child)
                   return(0);
   
           assert(MDOC_TEXT == n->child->type);
         nn = n->child;          nn = n->child;
   
         term_word(p, nn->string);          term_word(p, nn->string);
Line 1258  termp_xr_pre(DECL_ARGS)
Line 1314  termp_xr_pre(DECL_ARGS)
 }  }
   
   
   static int
   termp_vt_pre(DECL_ARGS)
   {
   
           if (MDOC_ELEM == n->type)
                   return(termp_under_pre(p, pair, m, n));
           else if (MDOC_HEAD == n->type)
                   return(0);
           else if (MDOC_BLOCK == n->type)
                   return(1);
   
           return(termp_under_pre(p, pair, m, n));
   }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 termp_vt_post(DECL_ARGS)  termp_vt_post(DECL_ARGS)
 {  {
   
         if (n->sec != SEC_SYNOPSIS)          if (MDOC_BLOCK != n->type)
                 return;                  return;
         if (n->next && MDOC_Vt == n->next->tok)          if (n->next && MDOC_Vt == n->next->tok)
                 term_newln(p);                  term_newln(p);
Line 1277  static int
Line 1348  static int
 termp_bold_pre(DECL_ARGS)  termp_bold_pre(DECL_ARGS)
 {  {
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         return(1);          return(1);
 }  }
   
Line 1287  static void
Line 1358  static void
 termp_fd_post(DECL_ARGS)  termp_fd_post(DECL_ARGS)
 {  {
   
         if (n->sec != SEC_SYNOPSIS)  
                 return;  
   
         term_newln(p);          term_newln(p);
         if (n->next && MDOC_Fd != n->next->tok)  
                 term_vspace(p);  
 }  }
   
   
Line 1311  termp_sh_pre(DECL_ARGS)
Line 1377  termp_sh_pre(DECL_ARGS)
                 term_vspace(p);                  term_vspace(p);
                 break;                  break;
         case (MDOC_HEAD):          case (MDOC_HEAD):
                 p->bold++;                  term_fontpush(p, TERMFONT_BOLD);
                 break;                  break;
         case (MDOC_BODY):          case (MDOC_BODY):
                 p->offset = INDENT;                  p->offset = INDENT;
Line 1365  termp_bt_pre(DECL_ARGS)
Line 1431  termp_bt_pre(DECL_ARGS)
 {  {
   
         term_word(p, "is currently in beta test.");          term_word(p, "is currently in beta test.");
           p->flags |= TERMP_SENTENCE;
         return(0);          return(0);
 }  }
   
Line 1374  static void
Line 1441  static void
 termp_lb_post(DECL_ARGS)  termp_lb_post(DECL_ARGS)
 {  {
   
         if (SEC_LIBRARY == n->sec)          if (SEC_LIBRARY == n->sec && MDOC_LINE & n->flags)
                 term_newln(p);                  term_newln(p);
 }  }
   
Line 1385  termp_ud_pre(DECL_ARGS)
Line 1452  termp_ud_pre(DECL_ARGS)
 {  {
   
         term_word(p, "currently under development.");          term_word(p, "currently under development.");
           p->flags |= TERMP_SENTENCE;
         return(0);          return(0);
 }  }
   
Line 1443  static int
Line 1511  static int
 termp_ft_pre(DECL_ARGS)  termp_ft_pre(DECL_ARGS)
 {  {
   
         if (SEC_SYNOPSIS == n->sec)          if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)
                 if (n->prev && MDOC_Fo == n->prev->tok)                  if (n->prev && MDOC_Fo == n->prev->tok)
                         term_vspace(p);                          term_vspace(p);
         p->under++;  
           term_fontpush(p, TERMFONT_UNDER);
         return(1);          return(1);
 }  }
   
Line 1456  static void
Line 1525  static void
 termp_ft_post(DECL_ARGS)  termp_ft_post(DECL_ARGS)
 {  {
   
         if (SEC_SYNOPSIS == n->sec)          if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)
                 term_newln(p);                  term_newln(p);
 }  }
   
Line 1467  termp_fn_pre(DECL_ARGS)
Line 1536  termp_fn_pre(DECL_ARGS)
 {  {
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         term_word(p, n->child->string);          term_word(p, n->child->string);
         p->bold--;          term_fontpop(p);
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_word(p, "(");          term_word(p, "(");
   
         for (nn = n->child->next; nn; nn = nn->next) {          for (nn = n->child->next; nn; nn = nn->next) {
                 p->under++;                  term_fontpush(p, TERMFONT_UNDER);
                 term_word(p, nn->string);                  term_word(p, nn->string);
                 p->under--;                  term_fontpop(p);
   
                 if (nn->next)                  if (nn->next)
                         term_word(p, ",");                          term_word(p, ",");
         }          }
Line 1496  static void
Line 1566  static void
 termp_fn_post(DECL_ARGS)  termp_fn_post(DECL_ARGS)
 {  {
   
         if (n->sec == SEC_SYNOPSIS && n->next)          if (n->sec == SEC_SYNOPSIS && n->next && MDOC_LINE & n->flags)
                 term_vspace(p);                  term_vspace(p);
 }  }
   
Line 1508  termp_fa_pre(DECL_ARGS)
Line 1578  termp_fa_pre(DECL_ARGS)
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
         if (n->parent->tok != MDOC_Fo) {          if (n->parent->tok != MDOC_Fo) {
                 p->under++;                  term_fontpush(p, TERMFONT_UNDER);
                 return(1);                  return(1);
         }          }
   
         for (nn = n->child; nn; nn = nn->next) {          for (nn = n->child; nn; nn = nn->next) {
                 p->under++;                  term_fontpush(p, TERMFONT_UNDER);
                 term_word(p, nn->string);                  term_word(p, nn->string);
                 p->under--;                  term_fontpop(p);
   
                 if (nn->next)                  if (nn->next)
                         term_word(p, ",");                          term_word(p, ",");
         }          }
Line 1531  termp_fa_pre(DECL_ARGS)
Line 1602  termp_fa_pre(DECL_ARGS)
 static int  static int
 termp_bd_pre(DECL_ARGS)  termp_bd_pre(DECL_ARGS)
 {  {
           size_t                   tabwidth;
         int                      i, type;          int                      i, type;
           size_t                   rm, rmax;
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
         if (MDOC_BLOCK == n->type) {          if (MDOC_BLOCK == n->type) {
                 print_bvspace(p, n, n);                  print_bvspace(p, n, n);
                 return(1);                  return(1);
         } else if (MDOC_BODY != n->type)          } else if (MDOC_HEAD == n->type)
                 return(1);                  return(0);
   
         nn = n->parent;          nn = n->parent;
   
         for (type = -1, i = 0; i < (int)nn->args->argc; i++) {          type = arg_disptype(nn);
                 switch (nn->args->argv[i].arg) {          assert(-1 != type);
                 case (MDOC_Centred):  
                         /* FALLTHROUGH */  
                 case (MDOC_Ragged):  
                         /* FALLTHROUGH */  
                 case (MDOC_Filled):  
                         /* FALLTHROUGH */  
                 case (MDOC_Unfilled):  
                         /* FALLTHROUGH */  
                 case (MDOC_Literal):  
                         type = nn->args->argv[i].arg;  
                         break;  
                 case (MDOC_Offset):  
                         p->offset += a2offs(&nn->args->argv[i]);  
                         break;  
                 default:  
                         break;  
                 }  
         }  
   
           if (-1 != (i = arg_getattr(MDOC_Offset, nn)))
                   p->offset += a2offs(&nn->args->argv[i]);
   
         /*          /*
          * If -ragged or -filled are specified, the block does nothing           * If -ragged or -filled are specified, the block does nothing
          * but change the indentation.  If -unfilled or -literal are           * but change the indentation.  If -unfilled or -literal are
Line 1571  termp_bd_pre(DECL_ARGS)
Line 1629  termp_bd_pre(DECL_ARGS)
          * lines are allowed.           * lines are allowed.
          */           */
   
         assert(type > -1);  
         if (MDOC_Literal != type && MDOC_Unfilled != type)          if (MDOC_Literal != type && MDOC_Unfilled != type)
                 return(1);                  return(1);
   
           tabwidth = p->tabwidth;
           p->tabwidth = 8;
           rm = p->rmargin;
           rmax = p->maxrmargin;
           p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
   
         for (nn = n->child; nn; nn = nn->next) {          for (nn = n->child; nn; nn = nn->next) {
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 print_node(p, pair, m, nn);                  print_mdoc_node(p, pair, m, nn);
                 if (NULL == nn->next)                  if (NULL == nn->prev ||
                         continue;                      nn->prev->line < nn->line ||
                 if (nn->prev && nn->prev->line < nn->line)                      NULL == nn->next)
                         term_flushln(p);                          term_flushln(p);
                 else if (NULL == nn->prev)  
                         term_flushln(p);  
         }          }
           p->tabwidth = tabwidth;
   
           p->rmargin = rm;
           p->maxrmargin = rmax;
         return(0);          return(0);
 }  }
   
Line 1594  termp_bd_pre(DECL_ARGS)
Line 1658  termp_bd_pre(DECL_ARGS)
 static void  static void
 termp_bd_post(DECL_ARGS)  termp_bd_post(DECL_ARGS)
 {  {
           int              type;
           size_t           rm, rmax;
   
         if (MDOC_BODY != n->type)          if (MDOC_BODY != n->type)
                 return;                  return;
   
           type = arg_disptype(n->parent);
           assert(-1 != type);
   
           rm = p->rmargin;
           rmax = p->maxrmargin;
   
           if (MDOC_Literal == type || MDOC_Unfilled == type)
                   p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_flushln(p);          term_newln(p);
   
           p->rmargin = rm;
           p->maxrmargin = rmax;
 }  }
   
   
Line 1650  termp_xx_pre(DECL_ARGS)
Line 1729  termp_xx_pre(DECL_ARGS)
                 pp = "BSDI BSD/OS";                  pp = "BSDI BSD/OS";
                 break;                  break;
         case (MDOC_Dx):          case (MDOC_Dx):
                 pp = "DragonFlyBSD";                  pp = "DragonFly";
                 break;                  break;
         case (MDOC_Fx):          case (MDOC_Fx):
                 pp = "FreeBSD";                  pp = "FreeBSD";
Line 1731  termp_ss_pre(DECL_ARGS)
Line 1810  termp_ss_pre(DECL_ARGS)
                         term_vspace(p);                          term_vspace(p);
                 break;                  break;
         case (MDOC_HEAD):          case (MDOC_HEAD):
                 p->bold++;                  term_fontpush(p, TERMFONT_BOLD);
                 p->offset = HALFINDENT;                  p->offset = HALFINDENT;
                 break;                  break;
         default:          default:
Line 1757  static int
Line 1836  static int
 termp_cd_pre(DECL_ARGS)  termp_cd_pre(DECL_ARGS)
 {  {
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         term_newln(p);          term_newln(p);
         return(1);          return(1);
 }  }
Line 1768  static int
Line 1847  static int
 termp_in_pre(DECL_ARGS)  termp_in_pre(DECL_ARGS)
 {  {
   
         p->bold++;          if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) {
         if (SEC_SYNOPSIS == n->sec)                  term_fontpush(p, TERMFONT_BOLD);
                 term_word(p, "#include");                  term_word(p, "#include");
                   term_word(p, "<");
           } else {
                   term_word(p, "<");
                   term_fontpush(p, TERMFONT_UNDER);
           }
   
         term_word(p, "<");  
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         return(1);          return(1);
 }  }
Line 1783  static void
Line 1866  static void
 termp_in_post(DECL_ARGS)  termp_in_post(DECL_ARGS)
 {  {
   
         p->bold++;          if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)
                   term_fontpush(p, TERMFONT_BOLD);
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_word(p, ">");          term_word(p, ">");
         p->bold--;  
   
         if (SEC_SYNOPSIS != n->sec)          if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) {
                 return;                  term_fontpop(p);
                   term_newln(p);
         term_newln(p);          }
         /*  
          * XXX Not entirely correct.  If `.In foo bar' is specified in  
          * the SYNOPSIS section, then it produces a single break after  
          * the <foo>; mandoc asserts a vertical space.  Since this  
          * construction is rarely used, I think it's fine.  
          */  
         if (n->next && MDOC_In != n->next->tok)  
                 term_vspace(p);  
 }  }
   
   
Line 1918  termp_fo_pre(DECL_ARGS)
Line 1994  termp_fo_pre(DECL_ARGS)
         } else if (MDOC_HEAD != n->type)          } else if (MDOC_HEAD != n->type)
                 return(1);                  return(1);
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         for (nn = n->child; nn; nn = nn->next) {          for (nn = n->child; nn; nn = nn->next) {
                 assert(MDOC_TEXT == nn->type);                  assert(MDOC_TEXT == nn->type);
                 term_word(p, nn->string);                  term_word(p, nn->string);
         }          }
         p->bold--;          term_fontpop(p);
   
         return(0);          return(0);
 }  }
Line 1957  termp_bf_pre(DECL_ARGS)
Line 2033  termp_bf_pre(DECL_ARGS)
   
         if (NULL == (nn = n->head->child)) {          if (NULL == (nn = n->head->child)) {
                 if (arg_hasattr(MDOC_Emphasis, n))                  if (arg_hasattr(MDOC_Emphasis, n))
                         p->under++;                          term_fontpush(p, TERMFONT_UNDER);
                 else if (arg_hasattr(MDOC_Symbolic, n))                  else if (arg_hasattr(MDOC_Symbolic, n))
                         p->bold++;                          term_fontpush(p, TERMFONT_BOLD);
                   else
                           term_fontpush(p, TERMFONT_NONE);
   
                 return(1);                  return(1);
         }          }
   
         assert(MDOC_TEXT == nn->type);          assert(MDOC_TEXT == nn->type);
         if (0 == strcmp("Em", nn->string))          if (0 == strcmp("Em", nn->string))
                 p->under++;                  term_fontpush(p, TERMFONT_UNDER);
         else if (0 == strcmp("Sy", nn->string))          else if (0 == strcmp("Sy", nn->string))
                 p->bold++;                  term_fontpush(p, TERMFONT_BOLD);
           else
                   term_fontpush(p, TERMFONT_NONE);
   
         return(1);          return(1);
 }  }
Line 1980  termp_sm_pre(DECL_ARGS)
Line 2060  termp_sm_pre(DECL_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))
                 p->flags &= ~TERMP_NONOSPACE;                  p->flags &= ~TERMP_NONOSPACE;
                 p->flags &= ~TERMP_NOSPACE;          else
         } else  
                 p->flags |= TERMP_NONOSPACE;                  p->flags |= TERMP_NONOSPACE;
   
         return(0);          return(0);
Line 2010  termp____post(DECL_ARGS)
Line 2089  termp____post(DECL_ARGS)
         /* TODO: %U. */          /* TODO: %U. */
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         switch (n->tok) {  
         case (MDOC__T):  
                 term_word(p, "\\(rq");  
                 p->flags |= TERMP_NOSPACE;  
                 break;  
         default:  
                 break;  
         }  
         term_word(p, n->next ? "," : ".");          term_word(p, n->next ? "," : ".");
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
   termp_li_pre(DECL_ARGS)
   {
   
           term_fontpush(p, TERMFONT_NONE);
           return(1);
   }
   
   
   /* ARGSUSED */
   static int
 termp_lk_pre(DECL_ARGS)  termp_lk_pre(DECL_ARGS)
 {  {
         const struct mdoc_node *nn;          const struct mdoc_node *nn;
   
         p->under++;          term_fontpush(p, TERMFONT_UNDER);
         nn = n->child;          nn = n->child;
   
         if (NULL == nn->next)          if (NULL == nn->next)
                 return(1);                  return(1);
   
         term_word(p, nn->string);          term_word(p, nn->string);
         p->under--;          term_fontpop(p);
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_word(p, ":");          term_word(p, ":");
   
         p->bold++;          term_fontpush(p, TERMFONT_BOLD);
         for (nn = nn->next; nn; nn = nn->next)          for (nn = nn->next; nn; nn = nn->next)
                 term_word(p, nn->string);                  term_word(p, nn->string);
         p->bold--;          term_fontpop(p);
   
         return(0);          return(0);
 }  }
Line 2054  static int
Line 2135  static int
 termp_under_pre(DECL_ARGS)  termp_under_pre(DECL_ARGS)
 {  {
   
         p->under++;          term_fontpush(p, TERMFONT_UNDER);
         return(1);  
 }  
   
   
 /* ARGSUSED */  
 static int  
 termp__t_pre(DECL_ARGS)  
 {  
   
         term_word(p, "\\(lq");  
         p->flags |= TERMP_NOSPACE;  
         return(1);          return(1);
 }  }

Legend:
Removed from v.1.96  
changed lines
  Added in v.1.138

CVSweb