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

Diff for /mandoc/term.c between version 1.238 and 1.243

version 1.238, 2014/12/19 17:12:04 version 1.243, 2015/01/21 20:33:25
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010-2015 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 101  term_flushln(struct termp *p)
Line 101  term_flushln(struct termp *p)
         size_t           j;     /* temporary loop index for p->buf */          size_t           j;     /* temporary loop index for p->buf */
         size_t           jhy;   /* last hyph before overflow w/r/t j */          size_t           jhy;   /* last hyph before overflow w/r/t j */
         size_t           maxvis; /* output position of visible boundary */          size_t           maxvis; /* output position of visible boundary */
         size_t           rmargin; /* the rightmost of the two margins */  
   
         /*          /*
          * First, establish the maximum columns of "visible" content.           * First, establish the maximum columns of "visible" content.
Line 114  term_flushln(struct termp *p)
Line 113  term_flushln(struct termp *p)
          * is negative, it gets sign extended.  Subtracting that           * is negative, it gets sign extended.  Subtracting that
          * very large size_t effectively adds a small number to dv.           * very large size_t effectively adds a small number to dv.
          */           */
         rmargin = p->rmargin > p->offset ? p->rmargin : p->offset;          dv = p->rmargin > p->offset ? p->rmargin - p->offset : 0;
         dv = p->rmargin - p->offset;  
         maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;          maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
   
         if (p->flags & TERMP_NOBREAK) {          if (p->flags & TERMP_NOBREAK) {
Line 193  term_flushln(struct termp *p)
Line 191  term_flushln(struct termp *p)
                         (*p->endline)(p);                          (*p->endline)(p);
                         p->viscol = 0;                          p->viscol = 0;
                         if (TERMP_BRIND & p->flags) {                          if (TERMP_BRIND & p->flags) {
                                 vbl = rmargin;                                  vbl = p->rmargin;
                                 vend += rmargin - p->offset;                                  vend += p->rmargin;
                                   vend -= p->offset;
                         } else                          } else
                                 vbl = p->offset;                                  vbl = p->offset;
   
Line 274  term_flushln(struct termp *p)
Line 273  term_flushln(struct termp *p)
         }          }
   
         if (TERMP_HANG & p->flags) {          if (TERMP_HANG & p->flags) {
                 p->overstep = (int)(vis - maxvis +                  p->overstep += (int)(p->offset + vis - p->rmargin +
                     p->trailspace * (*p->width)(p, ' '));                      p->trailspace * (*p->width)(p, ' '));
   
                 /*                  /*
Line 496  term_word(struct termp *p, const char *word)
Line 495  term_word(struct termp *p, const char *word)
                 case ESCAPE_SKIPCHAR:                  case ESCAPE_SKIPCHAR:
                         p->flags |= TERMP_SKIPCHAR;                          p->flags |= TERMP_SKIPCHAR;
                         continue;                          continue;
                   case ESCAPE_OVERSTRIKE:
                           cp = seq + sz;
                           while (seq < cp) {
                                   if (*seq == '\\') {
                                           mandoc_escape(&seq, NULL, NULL);
                                           continue;
                                   }
                                   encode1(p, *seq++);
                                   if (seq < cp)
                                           encode(p, "\b", 1);
                           }
                 default:                  default:
                         continue;                          continue;
                 }                  }
Line 717  term_strlen(const struct termp *p, const char *cp)
Line 727  term_strlen(const struct termp *p, const char *cp)
                         case ESCAPE_SKIPCHAR:                          case ESCAPE_SKIPCHAR:
                                 skip = 1;                                  skip = 1;
                                 continue;                                  continue;
                           case ESCAPE_OVERSTRIKE:
                                   rsz = 0;
                                   rhs = seq + ssz;
                                   while (seq < rhs) {
                                           if (*seq == '\\') {
                                                   mandoc_escape(&seq, NULL, NULL);
                                                   continue;
                                           }
                                           i = (*p->width)(p, *seq++);
                                           if (rsz < i)
                                                   rsz = i;
                                   }
                                   sz += rsz;
                                   continue;
                         default:                          default:
                                 continue;                                  continue;
                         }                          }
Line 770  term_strlen(const struct termp *p, const char *cp)
Line 794  term_strlen(const struct termp *p, const char *cp)
         return(sz);          return(sz);
 }  }
   
 size_t  int
 term_vspan(const struct termp *p, const struct roffsu *su)  term_vspan(const struct termp *p, const struct roffsu *su)
 {  {
         double           r;          double           r;
           int              ri;
   
         switch (su->unit) {          switch (su->unit) {
           case SCALE_BU:
                   r = su->scale / 40.0;
                   break;
         case SCALE_CM:          case SCALE_CM:
                 r = su->scale * 2.0;                  r = su->scale * 6.0 / 2.54;
                 break;                  break;
           case SCALE_FS:
                   r = su->scale * 65536.0 / 40.0;
                   break;
         case SCALE_IN:          case SCALE_IN:
                 r = su->scale * 6.0;                  r = su->scale * 6.0;
                 break;                  break;
           case SCALE_MM:
                   r = su->scale * 0.006;
                   break;
         case SCALE_PC:          case SCALE_PC:
                 r = su->scale;                  r = su->scale;
                 break;                  break;
         case SCALE_PT:          case SCALE_PT:
                 r = su->scale / 8.0;                  r = su->scale / 12.0;
                 break;                  break;
         case SCALE_MM:          case SCALE_EN:
                 r = su->scale / 1000.0;                  /* FALLTHROUGH */
           case SCALE_EM:
                   r = su->scale * 0.6;
                 break;                  break;
         case SCALE_VS:          case SCALE_VS:
                 r = su->scale;                  r = su->scale;
                 break;                  break;
         default:          default:
                 r = su->scale - 1.0;                  abort();
                 break;                  /* NOTREACHED */
         }          }
           ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
         if (r < 0.0)          return(ri < 66 ? ri : 1);
                 r = 0.0;  
         return((size_t)(r + 0.0005));  
 }  }
   
 size_t  int
 term_hspan(const struct termp *p, const struct roffsu *su)  term_hspan(const struct termp *p, const struct roffsu *su)
 {  {
         double           v;          double           v;
   
         v = (*p->hspan)(p, su);          v = (*p->hspan)(p, su);
         if (v < 0.0)          return(v > 0.0 ? v + 0.0005 : v - 0.0005);
                 v = 0.0;  
         return((size_t)(v + 0.0005));  
 }  }
Legend:
Removed from v.1.238  
changed lines
  Added in v.1.243
CVSweb