[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.102 and 1.117

version 1.102, 2009/11/12 05:50:12 version 1.117, 2010/04/08 08:17:55
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>
Line 33 
Line 37 
   
 struct  termpair {  struct  termpair {
         struct termpair  *ppair;          struct termpair  *ppair;
         int               flag;  
         int               count;          int               count;
 };  };
   
Line 64  static void   print_mdoc_head(DECL_ARGS);
Line 67  static void   print_mdoc_head(DECL_ARGS);
 static  void      print_mdoc_nodelist(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 95  static void   termp_sq_post(DECL_ARGS);
Line 93  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 134  static int   termp_sq_pre(DECL_ARGS);
Line 132  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 148  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 177  static const struct termact termacts[MDOC_MAX] = {
Line 176  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 187  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 203  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 271  terminal_mdoc(void *arg, const struct mdoc *mdoc)
Line 270  terminal_mdoc(void *arg, const struct mdoc *mdoc)
   
         p = (struct termp *)arg;          p = (struct termp *)arg;
   
           p->overstep = 0;
           p->maxrmargin = 78;
   
         if (NULL == p->symtab)          if (NULL == p->symtab)
                 switch (p->enc) {                  switch (p->enc) {
                 case (TERMENC_ASCII):                  case (TERMENC_ASCII):
Line 471  a2width(const struct mdoc_argv *arg, int pos)
Line 473  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);  
 }  }
   
   
Line 537  a2offs(const struct mdoc_argv *arg)
Line 538  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 545  arg_hasattr(int arg, const struct mdoc_node *n)
Line 550  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 554  arg_getattr(int v, const struct mdoc_node *n)
Line 563  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 573  arg_getattrs(const int *keys, int *vals, 
Line 588  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 651  termp_it_pre(DECL_ARGS)
Line 671  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, type, keys[3], vals[3];
         size_t                  width, offset;          size_t                  width, offset, ncols, dcol;
   
         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 660  termp_it_pre(DECL_ARGS)
Line 680  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 = arg_listtype(bl);          type = arg_listtype(bl);
         assert(-1 != type);          assert(-1 != type);
   
         /* Calculate real width and offset. */          /*
            * 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.
            */
   
           width = offset = 0;
   
           if (vals[1] >= 0)
                   offset = a2offs(&bl->args->argv[vals[1]]);
   
         switch (type) {          switch (type) {
         case (MDOC_Column):          case (MDOC_Column):
                 if (MDOC_BODY == n->type)                  if (MDOC_BODY == 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;
   
                   for (i = 0, nn = n->prev;
                                   nn && 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 782  termp_it_pre(DECL_ARGS)
Line 821  termp_it_pre(DECL_ARGS)
         }          }
   
         /*          /*
          * 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) {
Line 898  termp_it_pre(DECL_ARGS)
Line 936  termp_it_pre(DECL_ARGS)
                  * 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)                                  MDOC_BODY == n->next->type &&
                                   p->rmargin < p->maxrmargin)
                         p->rmargin = p->maxrmargin;                          p->rmargin = p->maxrmargin;
                 break;                  break;
         default:          default:
Line 926  termp_it_pre(DECL_ARGS)
Line 965  termp_it_pre(DECL_ARGS)
                         break;                          break;
                 case (MDOC_Enum):                  case (MDOC_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 969  termp_it_post(DECL_ARGS)
Line 1008  termp_it_post(DECL_ARGS)
 {  {
         int                type;          int                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 = arg_listtype(n->parent->parent->parent);
Line 993  termp_it_post(DECL_ARGS)
Line 1032  termp_it_post(DECL_ARGS)
                 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 1020  termp_fl_pre(DECL_ARGS)
Line 1069  termp_fl_pre(DECL_ARGS)
   
         term_fontpush(p, TERMFONT_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 1196  termp_nd_pre(DECL_ARGS)
Line 1250  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 1223  termp_xr_pre(DECL_ARGS)
Line 1286  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 1240  termp_xr_pre(DECL_ARGS)
Line 1306  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 1522  termp_bd_pre(DECL_ARGS)
Line 1603  termp_bd_pre(DECL_ARGS)
         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;
   
Line 1969  termp_sm_pre(DECL_ARGS)
Line 2050  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 1999  termp____post(DECL_ARGS)
Line 2079  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 ? "," : ".");
 }  }
   
Line 2054  termp_under_pre(DECL_ARGS)
Line 2126  termp_under_pre(DECL_ARGS)
 {  {
   
         term_fontpush(p, TERMFONT_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.102  
changed lines
  Added in v.1.117
CVSweb