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

Diff for /mandoc/term.c between version 1.262 and 1.264

version 1.262, 2017/06/02 19:21:23 version 1.264, 2017/06/04 22:44:15
Line 36  static void   adjbuf(struct termp *p, size_t);
Line 36  static void   adjbuf(struct termp *p, size_t);
 static  void             bufferc(struct termp *, char);  static  void             bufferc(struct termp *, char);
 static  void             encode(struct termp *, const char *, size_t);  static  void             encode(struct termp *, const char *, size_t);
 static  void             encode1(struct termp *, int);  static  void             encode1(struct termp *, int);
   static  void             endline(struct termp *);
   
   
 void  void
Line 84  term_end(struct termp *p)
Line 85  term_end(struct termp *p)
  *    to be broken, start the next line at the right margin instead   *    to be broken, start the next line at the right margin instead
  *    of at the offset.  Used together with TERMP_NOBREAK for the tags   *    of at the offset.  Used together with TERMP_NOBREAK for the tags
  *    in various kinds of tagged lists.   *    in various kinds of tagged lists.
  *  - TERMP_DANGLE: Do not break the output line at the right margin,   *  - TERMP_HANG: Do not break the output line at the right margin,
  *    append the next chunk after it even if this one is too long.   *    append the next chunk after it even if this one is too long.
  *    To be used together with TERMP_NOBREAK.   *    To be used together with TERMP_NOBREAK.
  *  - TERMP_HANG: Like TERMP_DANGLE, and also suppress padding before   *  - TERMP_NOPAD: Start writing at the current position,
  *    the next chunk if this column is not full.   *    do not pad with blank characters up to the offset.
  */   */
 void  void
 term_flushln(struct termp *p)  term_flushln(struct termp *p)
Line 104  term_flushln(struct termp *p)
Line 105  term_flushln(struct termp *p)
         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 */
   
         /*          vbl = (p->flags & TERMP_NOPAD) || p->offset < p->viscol ? 0 :
          * First, establish the maximum columns of "visible" content.              p->offset - p->viscol;
          * This is usually the difference between the right-margin and          if (p->minbl && vbl < p->minbl)
          * an indentation, but can be, for tagged lists or columns, a                  vbl = p->minbl;
          * small set of values.          maxvis = p->rmargin > p->viscol + vbl ?
          *              p->rmargin - p->viscol - vbl : 0;
          * The following unsigned-signed subtractions look strange,          bp = !(p->flags & TERMP_NOBREAK) ? maxvis :
          * but they are actually correct.  If the int p->overstep              p->maxrmargin > p->viscol + vbl ?
          * is negative, it gets sign extended.  Subtracting that              p->maxrmargin - p->viscol - vbl : 0;
          * very large size_t effectively adds a small number to dv.  
          */  
         dv = p->rmargin > p->offset ? p->rmargin - p->offset : 0;  
         maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;  
   
         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.  
          */  
         vbl = p->offset + p->overstep > p->viscol ?  
               p->offset + p->overstep - p->viscol : 0;  
   
         vis = vend = 0;          vis = vend = 0;
         i = 0;          i = 0;
   
Line 188  term_flushln(struct termp *p)
Line 170  term_flushln(struct termp *p)
                  * Find out whether we would exceed the right margin.                   * Find out whether we would exceed the right margin.
                  * If so, break to the next line.                   * If so, break to the next line.
                  */                   */
                 if (vend > bp && 0 == jhy && vis > 0) {                  if (vend > bp && 0 == jhy && vis > 0 &&
                       (p->flags & TERMP_BRNEVER) == 0) {
                         vend -= vis;                          vend -= vis;
                         (*p->endline)(p);                          endline(p);
                         p->viscol = 0;  
   
                         /* Use pending tabs on the new line. */                          /* Use pending tabs on the new line. */
   
Line 201  term_flushln(struct termp *p)
Line 183  term_flushln(struct termp *p)
   
                         /* Re-establish indentation. */                          /* Re-establish indentation. */
   
                         if (p->flags & TERMP_BRIND) {                          if (p->flags & TERMP_BRIND)
                                 vbl += p->rmargin;                                  vbl += p->rmargin;
                                 vend += p->rmargin - p->offset;                          else
                         } else  
                                 vbl += p->offset;                                  vbl += p->offset;
                           maxvis = p->rmargin > vbl ? p->rmargin - vbl : 0;
                         /*                          bp = !(p->flags & TERMP_NOBREAK) ? maxvis :
                          * Remove the p->overstep width.                              p->maxrmargin > vbl ?  p->maxrmargin - vbl : 0;
                          * Again, if p->overstep is negative,  
                          * sign extension does the right thing.  
                          */  
   
                         bp += (size_t)p->overstep;  
                         p->overstep = 0;  
                 }                  }
   
                 /* Write out the [remaining] word. */                  /* Write out the [remaining] word. */
Line 269  term_flushln(struct termp *p)
Line 244  term_flushln(struct termp *p)
                 vis = 0;                  vis = 0;
   
         p->col = 0;          p->col = 0;
         p->overstep = 0;          p->minbl = p->trailspace;
         p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE);          p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE | TERMP_NOPAD);
   
         if ( ! (TERMP_NOBREAK & p->flags)) {  
                 p->viscol = 0;  
                 (*p->endline)(p);  
                 return;  
         }  
   
         if (TERMP_HANG & p->flags) {  
                 p->overstep += (int)(p->offset + vis - p->rmargin +  
                     p->trailspace * (*p->width)(p, ' '));  
   
                 /*  
                  * If we have overstepped the margin, temporarily move  
                  * it to the right and flag the rest of the line to be  
                  * shorter.  
                  * If there is a request to keep the columns together,  
                  * allow negative overstep when the column is not full.  
                  */  
                 if (p->trailspace && p->overstep < 0)  
                         p->overstep = 0;  
                 return;  
   
         } else if (TERMP_DANGLE & p->flags)  
                 return;  
   
         /* Trailing whitespace is significant in some columns. */          /* Trailing whitespace is significant in some columns. */
         if (vis && vbl && (TERMP_BRTRSP & p->flags))          if (vis && vbl && (TERMP_BRTRSP & p->flags))
                 vis += vbl;                  vis += vbl;
   
         /* If the column was overrun, break the line. */          /* If the column was overrun, break the line. */
         if (maxvis < vis + p->trailspace * (*p->width)(p, ' ')) {          if ((p->flags & TERMP_NOBREAK) == 0 ||
                 (*p->endline)(p);              ((p->flags & TERMP_HANG) == 0 &&
                 p->viscol = 0;               vis + p->trailspace * (*p->width)(p, ' ') > maxvis))
                   endline(p);
   }
   
   static void
   endline(struct termp *p)
   {
           if ((p->flags & (TERMP_NEWMC | TERMP_ENDMC)) == TERMP_ENDMC) {
                   p->mc = NULL;
                   p->flags &= ~TERMP_ENDMC;
         }          }
           if (p->mc != NULL) {
                   if (p->viscol && p->maxrmargin >= p->viscol)
                           (*p->advance)(p, p->maxrmargin - p->viscol + 1);
                   p->flags |= TERMP_NOBUF | TERMP_NOSPACE;
                   term_word(p, p->mc);
                   p->flags &= ~(TERMP_NOBUF | TERMP_NEWMC);
           }
           p->viscol = 0;
           p->minbl = 0;
           (*p->endline)(p);
 }  }
   
 /*  /*
Line 333  term_vspace(struct termp *p)
Line 303  term_vspace(struct termp *p)
   
         term_newln(p);          term_newln(p);
         p->viscol = 0;          p->viscol = 0;
           p->minbl = 0;
         if (0 < p->skipvsp)          if (0 < p->skipvsp)
                 p->skipvsp--;                  p->skipvsp--;
         else          else
Line 407  term_word(struct termp *p, const char *word)
Line 378  term_word(struct termp *p, const char *word)
         size_t           csz, lsz, ssz;          size_t           csz, lsz, ssz;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
   
         if ( ! (TERMP_NOSPACE & p->flags)) {          if ((p->flags & TERMP_NOBUF) == 0) {
                 if ( ! (TERMP_KEEP & p->flags)) {                  if ((p->flags & TERMP_NOSPACE) == 0) {
                         bufferc(p, ' ');                          if ((p->flags & TERMP_KEEP) == 0) {
                         if (TERMP_SENTENCE & p->flags)  
                                 bufferc(p, ' ');                                  bufferc(p, ' ');
                 } else                                  if (p->flags & TERMP_SENTENCE)
                         bufferc(p, ASCII_NBRSP);                                          bufferc(p, ' ');
                           } else
                                   bufferc(p, ASCII_NBRSP);
                   }
                   if (p->flags & TERMP_PREKEEP)
                           p->flags |= TERMP_KEEP;
                   if (p->flags & TERMP_NONOSPACE)
                           p->flags |= TERMP_NOSPACE;
                   else
                           p->flags &= ~TERMP_NOSPACE;
                   p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
                   p->skipvsp = 0;
         }          }
         if (TERMP_PREKEEP & p->flags)  
                 p->flags |= TERMP_KEEP;  
   
         if ( ! (p->flags & TERMP_NONOSPACE))  
                 p->flags &= ~TERMP_NOSPACE;  
         else  
                 p->flags |= TERMP_NOSPACE;  
   
         p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);  
         p->skipvsp = 0;  
   
         while ('\0' != *word) {          while ('\0' != *word) {
                 if ('\\' != *word) {                  if ('\\' != *word) {
                         if (TERMP_NBRWORD & p->flags) {                          if (TERMP_NBRWORD & p->flags) {
Line 627  adjbuf(struct termp *p, size_t sz)
Line 598  adjbuf(struct termp *p, size_t sz)
 static void  static void
 bufferc(struct termp *p, char c)  bufferc(struct termp *p, char c)
 {  {
           if (p->flags & TERMP_NOBUF) {
                   (*p->letter)(p, c);
                   return;
           }
         if (p->col + 1 >= p->maxcols)          if (p->col + 1 >= p->maxcols)
                 adjbuf(p, p->col + 1);                  adjbuf(p, p->col + 1);
   
         p->buf[p->col++] = c;          p->buf[p->col++] = c;
 }  }
   
Line 644  encode1(struct termp *p, int c)
Line 617  encode1(struct termp *p, int c)
 {  {
         enum termfont     f;          enum termfont     f;
   
           if (p->flags & TERMP_NOBUF) {
                   (*p->letter)(p, c);
                   return;
           }
   
         if (p->col + 7 >= p->maxcols)          if (p->col + 7 >= p->maxcols)
                 adjbuf(p, p->col + 7);                  adjbuf(p, p->col + 7);
   
Line 679  static void
Line 657  static void
 encode(struct termp *p, const char *word, size_t sz)  encode(struct termp *p, const char *word, size_t sz)
 {  {
         size_t            i;          size_t            i;
   
           if (p->flags & TERMP_NOBUF) {
                   for (i = 0; i < sz; i++)
                           (*p->letter)(p, word[i]);
                   return;
           }
   
         if (p->col + 2 + (sz * 5) >= p->maxcols)          if (p->col + 2 + (sz * 5) >= p->maxcols)
                 adjbuf(p, p->col + 2 + (sz * 5));                  adjbuf(p, p->col + 2 + (sz * 5));
Legend:
Removed from v.1.262  
changed lines
  Added in v.1.264
CVSweb