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

Diff for /mandoc/term.c between version 1.261 and 1.263

version 1.261, 2017/06/01 19:05:37 version 1.263, 2017/06/04 18:50:35
Line 84  term_end(struct termp *p)
Line 84  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 104  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 201  term_flushln(struct termp *p)
Line 182  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 243  term_flushln(struct termp *p)
                 vis = 0;                  vis = 0;
   
         p->col = 0;          p->col = 0;
         p->overstep = 0;          p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE | TERMP_NOPAD);
         p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE);  
   
         if ( ! (TERMP_NOBREAK & p->flags)) {          if ( ! (TERMP_NOBREAK & p->flags)) {
                 p->viscol = 0;                  p->viscol = 0;
                   p->minbl = 0;
                 (*p->endline)(p);                  (*p->endline)(p);
                 return;                  return;
         }          }
   
         if (TERMP_HANG & p->flags) {          if (TERMP_HANG & p->flags) {
                 p->overstep += (int)(p->offset + vis - p->rmargin +                  p->minbl = p->trailspace;
                     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;                  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;
Line 304  term_flushln(struct termp *p)
Line 265  term_flushln(struct termp *p)
         if (maxvis < vis + p->trailspace * (*p->width)(p, ' ')) {          if (maxvis < vis + p->trailspace * (*p->width)(p, ' ')) {
                 (*p->endline)(p);                  (*p->endline)(p);
                 p->viscol = 0;                  p->viscol = 0;
         }                  p->minbl = 0;
           } else
                   p->minbl = p->trailspace;
 }  }
   
 /*  /*
Line 404  term_word(struct termp *p, const char *word)
Line 367  term_word(struct termp *p, const char *word)
         const char       nbrsp[2] = { ASCII_NBRSP, 0 };          const char       nbrsp[2] = { ASCII_NBRSP, 0 };
         const char      *seq, *cp;          const char      *seq, *cp;
         int              sz, uc;          int              sz, uc;
         size_t           ssz;          size_t           csz, lsz, ssz;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
   
         if ( ! (TERMP_NOSPACE & p->flags)) {          if ( ! (TERMP_NOSPACE & p->flags)) {
Line 508  term_word(struct termp *p, const char *word)
Line 471  term_word(struct termp *p, const char *word)
                                         p->ti -= p->offset;                                          p->ti -= p->offset;
                                         p->offset = 0;                                          p->offset = 0;
                                 }                                  }
                           }
                           continue;
                   case ESCAPE_HLINE:
                           if (a2roffsu(seq, &su, SCALE_EM) == 0)
                                   continue;
                           uc = term_hspan(p, &su) / 24;
                           if (uc <= 0) {
                                   if (p->rmargin <= p->offset)
                                           continue;
                                   lsz = p->rmargin - p->offset;
                           } else
                                   lsz = uc;
                           while (sz &&
                               strchr(" %&()*+-./0123456789:<=>", *seq)) {
                                   seq++;
                                   sz--;
                           }
                           if (sz && strchr("cifMmnPpuv", *seq)) {
                                   seq++;
                                   sz--;
                           }
                           if (sz == 0)
                                   uc = -1;
                           else if (*seq == '\\') {
                                   seq++;
                                   esc = mandoc_escape(&seq, &cp, &sz);
                                   switch (esc) {
                                   case ESCAPE_UNICODE:
                                           uc = mchars_num2uc(cp + 1, sz - 1);
                                           break;
                                   case ESCAPE_NUMBERED:
                                           uc = mchars_num2char(cp, sz);
                                           break;
                                   case ESCAPE_SPECIAL:
                                           uc = mchars_spec2cp(cp, sz);
                                           break;
                                   default:
                                           uc = -1;
                                           break;
                                   }
                           } else
                                   uc = *seq;
                           if (uc < 0x20 || (uc > 0x7E && uc < 0xA0))
                                   uc = '_';
                           if (p->enc == TERMENC_ASCII) {
                                   cp = ascii_uc2str(uc);
                                   csz = term_strlen(p, cp);
                                   ssz = strlen(cp);
                           } else
                                   csz = (*p->width)(p, uc);
                           while (lsz >= csz) {
                                   if (p->enc == TERMENC_ASCII)
                                           encode(p, cp, ssz);
                                   else
                                           encode1(p, uc);
                                   lsz -= csz;
                         }                          }
                         continue;                          continue;
                 case ESCAPE_SKIPCHAR:                  case ESCAPE_SKIPCHAR:
Legend:
Removed from v.1.261  
changed lines
  Added in v.1.263
CVSweb