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

Diff for /mandoc/term.c between version 1.235 and 1.242

version 1.235, 2014/11/16 21:29:35 version 1.242, 2014/12/24 23:32:42
Line 43  term_free(struct termp *p)
Line 43  term_free(struct termp *p)
 {  {
   
         free(p->buf);          free(p->buf);
           free(p->fontq);
         free(p);          free(p);
 }  }
   
Line 100  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           mmax; /* used in calculating bp */  
   
         /*          /*
          * First, establish the maximum columns of "visible" content.           * First, establish the maximum columns of "visible" content.
Line 113  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.
          */           */
         assert  (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;
         dv     = p->maxrmargin - p->offset;  
         mmax   = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;  
   
         bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;          if (p->flags & TERMP_NOBREAK) {
                   dv = p->maxrmargin > p->offset ?
                        p->maxrmargin - p->offset : 0;
                   bp = (int)dv > p->overstep ?
                        dv - (size_t)p->overstep : 0;
           } else
                   bp = maxvis;
   
         /*          /*
          * Calculate the required amount of padding.           * Calculate the required amount of padding.
Line 189  term_flushln(struct termp *p)
Line 192  term_flushln(struct termp *p)
                         p->viscol = 0;                          p->viscol = 0;
                         if (TERMP_BRIND & p->flags) {                          if (TERMP_BRIND & p->flags) {
                                 vbl = p->rmargin;                                  vbl = p->rmargin;
                                 vend += p->rmargin - p->offset;                                  vend += p->rmargin;
                                   vend -= p->offset;
                         } else                          } else
                                 vbl = p->offset;                                  vbl = p->offset;
   
Line 269  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 325  term_vspace(struct termp *p)
Line 329  term_vspace(struct termp *p)
                 (*p->endline)(p);                  (*p->endline)(p);
 }  }
   
   /* Swap current and previous font; for \fP and .ft P */
 void  void
 term_fontlast(struct termp *p)  term_fontlast(struct termp *p)
 {  {
Line 335  term_fontlast(struct termp *p)
Line 340  term_fontlast(struct termp *p)
         p->fontq[p->fonti] = f;          p->fontq[p->fonti] = f;
 }  }
   
   /* Set font, save current, discard previous; for \f, .ft, .B etc. */
 void  void
 term_fontrepl(struct termp *p, enum termfont f)  term_fontrepl(struct termp *p, enum termfont f)
 {  {
Line 343  term_fontrepl(struct termp *p, enum termfont f)
Line 349  term_fontrepl(struct termp *p, enum termfont f)
         p->fontq[p->fonti] = f;          p->fontq[p->fonti] = f;
 }  }
   
   /* Set font, save previous. */
 void  void
 term_fontpush(struct termp *p, enum termfont f)  term_fontpush(struct termp *p, enum termfont f)
 {  {
   
         assert(p->fonti + 1 < 10);  
         p->fontl = p->fontq[p->fonti];          p->fontl = p->fontq[p->fonti];
         p->fontq[++p->fonti] = f;          if (++p->fonti == p->fontsz) {
                   p->fontsz += 8;
                   p->fontq = mandoc_reallocarray(p->fontq,
                       p->fontsz, sizeof(enum termfont *));
           }
           p->fontq[p->fonti] = f;
 }  }
   
 const void *  /* Retrieve pointer to current font. */
   const enum termfont *
 term_fontq(struct termp *p)  term_fontq(struct termp *p)
 {  {
   
         return(&p->fontq[p->fonti]);          return(&p->fontq[p->fonti]);
 }  }
   
 enum termfont  /* Flush to make the saved pointer current again. */
 term_fonttop(struct termp *p)  
 {  
   
         return(p->fontq[p->fonti]);  
 }  
   
 void  void
 term_fontpopq(struct termp *p, const void *key)  term_fontpopq(struct termp *p, const enum termfont *key)
 {  {
   
         while (p->fonti >= 0 && key < (void *)(p->fontq + p->fonti))          while (p->fonti >= 0 && key < p->fontq + p->fonti)
                 p->fonti--;                  p->fonti--;
         assert(p->fonti >= 0);          assert(p->fonti >= 0);
 }  }
   
   /* Pop one font off the stack. */
 void  void
 term_fontpop(struct termp *p)  term_fontpop(struct termp *p)
 {  {
Line 413  term_word(struct termp *p, const char *word)
Line 420  term_word(struct termp *p, const char *word)
         else          else
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
   
         p->flags &= ~TERMP_SENTENCE;          p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
   
         while ('\0' != *word) {          while ('\0' != *word) {
                 if ('\\' != *word) {                  if ('\\' != *word) {
Line 483  term_word(struct termp *p, const char *word)
Line 490  term_word(struct termp *p, const char *word)
                         if (TERMP_SKIPCHAR & p->flags)                          if (TERMP_SKIPCHAR & p->flags)
                                 p->flags &= ~TERMP_SKIPCHAR;                                  p->flags &= ~TERMP_SKIPCHAR;
                         else if ('\0' == *word)                          else if ('\0' == *word)
                                 p->flags |= TERMP_NOSPACE;                                  p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
                         continue;                          continue;
                 case ESCAPE_SKIPCHAR:                  case ESCAPE_SKIPCHAR:
                         p->flags |= TERMP_SKIPCHAR;                          p->flags |= TERMP_SKIPCHAR;
Line 550  encode1(struct termp *p, int c)
Line 557  encode1(struct termp *p, int c)
         if (p->col + 6 >= p->maxcols)          if (p->col + 6 >= p->maxcols)
                 adjbuf(p, p->col + 6);                  adjbuf(p, p->col + 6);
   
         f = term_fonttop(p);          f = *term_fontq(p);
   
         if (TERMFONT_UNDER == f || TERMFONT_BI == f) {          if (TERMFONT_UNDER == f || TERMFONT_BI == f) {
                 p->buf[p->col++] = '_';                  p->buf[p->col++] = '_';
Line 582  encode(struct termp *p, const char *word, size_t sz)
Line 589  encode(struct termp *p, const char *word, size_t sz)
          * character by character.           * character by character.
          */           */
   
         if (TERMFONT_NONE == term_fonttop(p)) {          if (*term_fontq(p) == TERMFONT_NONE) {
                 if (p->col + sz >= p->maxcols)                  if (p->col + sz >= p->maxcols)
                         adjbuf(p, p->col + sz);                          adjbuf(p, p->col + sz);
                 for (i = 0; i < sz; i++)                  for (i = 0; i < sz; i++)
Line 762  term_strlen(const struct termp *p, const char *cp)
Line 769  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.235  
changed lines
  Added in v.1.242
CVSweb