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

Diff for /mandoc/term.c between version 1.227 and 1.237

version 1.227, 2014/08/10 23:54:41 version 1.237, 2014/12/02 10:08:06
Line 42  void
Line 42  void
 term_free(struct termp *p)  term_free(struct termp *p)
 {  {
   
         if (p->buf)          free(p->buf);
                 free(p->buf);  
         if (p->symtab)  
                 mchars_free(p->symtab);  
   
         free(p);          free(p);
 }  }
   
Line 104  term_flushln(struct termp *p)
Line 100  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 */          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 117  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);          rmargin = p->rmargin > p->offset ? p->rmargin : p->offset;
         dv     = p->rmargin - p->offset;          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 192  term_flushln(struct termp *p)
Line 192  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 = p->rmargin;                                  vbl = rmargin;
                                 vend += p->rmargin - p->offset;                                  vend += rmargin - p->offset;
                         } else                          } else
                                 vbl = p->offset;                                  vbl = p->offset;
   
Line 220  term_flushln(struct termp *p)
Line 220  term_flushln(struct termp *p)
                                 break;                                  break;
                         if (' ' == p->buf[i]) {                          if (' ' == p->buf[i]) {
                                 j = i;                                  j = i;
                                 while (' ' == p->buf[i])                                  while (i < p->col && ' ' == p->buf[i])
                                         i++;                                          i++;
                                 dv = (i - j) * (*p->width)(p, ' ');                                  dv = (i - j) * (*p->width)(p, ' ');
                                 vbl += dv;                                  vbl += dv;
Line 258  term_flushln(struct termp *p)
Line 258  term_flushln(struct termp *p)
          * If there was trailing white space, it was not printed;           * If there was trailing white space, it was not printed;
          * so reset the cursor position accordingly.           * so reset the cursor position accordingly.
          */           */
         if (vis)          if (vis > vbl)
                 vis -= vbl;                  vis -= vbl;
           else
                   vis = 0;
   
         p->col = 0;          p->col = 0;
         p->overstep = 0;          p->overstep = 0;
Line 395  term_word(struct termp *p, const char *word)
Line 397  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;
         char             c;  
         int              sz, uc;          int              sz, uc;
         size_t           ssz;          size_t           ssz;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
Line 416  term_word(struct termp *p, const char *word)
Line 417  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 444  term_word(struct termp *p, const char *word)
Line 445  term_word(struct termp *p, const char *word)
                 if (ESCAPE_ERROR == esc)                  if (ESCAPE_ERROR == esc)
                         continue;                          continue;
   
                 if (TERMENC_ASCII != p->enc)  
                         switch (esc) {  
                         case ESCAPE_UNICODE:  
                                 uc = mchars_num2uc(seq + 1, sz - 1);  
                                 if ('\0' == uc)  
                                         break;  
                                 encode1(p, uc);  
                                 continue;  
                         case ESCAPE_SPECIAL:  
                                 uc = mchars_spec2cp(p->symtab, seq, sz);  
                                 if (uc <= 0)  
                                         break;  
                                 encode1(p, uc);  
                                 continue;  
                         default:  
                                 break;  
                         }  
   
                 switch (esc) {                  switch (esc) {
                 case ESCAPE_UNICODE:                  case ESCAPE_UNICODE:
                         encode1(p, '?');                          uc = mchars_num2uc(seq + 1, sz - 1);
                         break;                          break;
                 case ESCAPE_NUMBERED:                  case ESCAPE_NUMBERED:
                         c = mchars_num2char(seq, sz);                          uc = mchars_num2char(seq, sz);
                         if ('\0' != c)                          if (uc < 0)
                                 encode(p, &c, 1);                                  continue;
                         break;                          break;
                 case ESCAPE_SPECIAL:                  case ESCAPE_SPECIAL:
                         cp = mchars_spec2str(p->symtab, seq, sz, &ssz);                          if (p->enc == TERMENC_ASCII) {
                         if (NULL != cp)                                  cp = mchars_spec2str(p->symtab,
                                 encode(p, cp, ssz);                                      seq, sz, &ssz);
                         else if (1 == ssz)                                  if (cp != NULL)
                                 encode(p, seq, sz);                                          encode(p, cp, ssz);
                         break;                          } else {
                                   uc = mchars_spec2cp(p->symtab, seq, sz);
                                   if (uc > 0)
                                           encode1(p, uc);
                           }
                           continue;
                 case ESCAPE_FONTBOLD:                  case ESCAPE_FONTBOLD:
                         term_fontrepl(p, TERMFONT_BOLD);                          term_fontrepl(p, TERMFONT_BOLD);
                         break;                          continue;
                 case ESCAPE_FONTITALIC:                  case ESCAPE_FONTITALIC:
                         term_fontrepl(p, TERMFONT_UNDER);                          term_fontrepl(p, TERMFONT_UNDER);
                         break;                          continue;
                 case ESCAPE_FONTBI:                  case ESCAPE_FONTBI:
                         term_fontrepl(p, TERMFONT_BI);                          term_fontrepl(p, TERMFONT_BI);
                         break;                          continue;
                 case ESCAPE_FONT:                  case ESCAPE_FONT:
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case ESCAPE_FONTROMAN:                  case ESCAPE_FONTROMAN:
                         term_fontrepl(p, TERMFONT_NONE);                          term_fontrepl(p, TERMFONT_NONE);
                         break;                          continue;
                 case ESCAPE_FONTPREV:                  case ESCAPE_FONTPREV:
                         term_fontlast(p);                          term_fontlast(p);
                         break;                          continue;
                 case ESCAPE_NOSPACE:                  case ESCAPE_NOSPACE:
                         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);
                         break;                          continue;
                 case ESCAPE_SKIPCHAR:                  case ESCAPE_SKIPCHAR:
                         p->flags |= TERMP_SKIPCHAR;                          p->flags |= TERMP_SKIPCHAR;
                         break;                          continue;
                 default:                  default:
                         break;                          continue;
                 }                  }
   
                   /*
                    * Common handling for Unicode and numbered
                    * character escape sequences.
                    */
   
                   if (p->enc == TERMENC_ASCII) {
                           cp = ascii_uc2str(uc);
                           encode(p, cp, strlen(cp));
                   } else {
                           if ((uc < 0x20 && uc != 0x09) ||
                               (uc > 0x7E && uc < 0xA0))
                                   uc = 0xFFFD;
                           encode1(p, uc);
                   }
         }          }
         p->flags &= ~TERMP_NBRWORD;          p->flags &= ~TERMP_NBRWORD;
 }  }
Line 657  size_t
Line 660  size_t
 term_strlen(const struct termp *p, const char *cp)  term_strlen(const struct termp *p, const char *cp)
 {  {
         size_t           sz, rsz, i;          size_t           sz, rsz, i;
         int              ssz, skip, c;          int              ssz, skip, uc;
         const char      *seq, *rhs;          const char      *seq, *rhs;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
         static const char rej[] = { '\\', ASCII_NBRSP, ASCII_HYPH,          static const char rej[] = { '\\', ASCII_NBRSP, ASCII_HYPH,
Line 683  term_strlen(const struct termp *p, const char *cp)
Line 686  term_strlen(const struct termp *p, const char *cp)
                         if (ESCAPE_ERROR == esc)                          if (ESCAPE_ERROR == esc)
                                 continue;                                  continue;
   
                         if (TERMENC_ASCII != p->enc)  
                                 switch (esc) {  
                                 case ESCAPE_UNICODE:  
                                         c = mchars_num2uc(seq + 1,  
                                             ssz - 1);  
                                         if ('\0' == c)  
                                                 break;  
                                         sz += cond_width(p, c, &skip);  
                                         continue;  
                                 case ESCAPE_SPECIAL:  
                                         c = mchars_spec2cp(p->symtab,  
                                             seq, ssz);  
                                         if (c <= 0)  
                                                 break;  
                                         sz += cond_width(p, c, &skip);  
                                         continue;  
                                 default:  
                                         break;  
                                 }  
   
                         rhs = NULL;                          rhs = NULL;
   
                         switch (esc) {                          switch (esc) {
                         case ESCAPE_UNICODE:                          case ESCAPE_UNICODE:
                                 sz += cond_width(p, '?', &skip);                                  uc = mchars_num2uc(seq + 1, ssz - 1);
                                 break;                                  break;
                         case ESCAPE_NUMBERED:                          case ESCAPE_NUMBERED:
                                 c = mchars_num2char(seq, ssz);                                  uc = mchars_num2char(seq, ssz);
                                 if ('\0' != c)                                  if (uc < 0)
                                         sz += cond_width(p, c, &skip);                                          continue;
                                 break;                                  break;
                         case ESCAPE_SPECIAL:                          case ESCAPE_SPECIAL:
                                 rhs = mchars_spec2str(p->symtab,                                  if (p->enc == TERMENC_ASCII) {
                                     seq, ssz, &rsz);                                          rhs = mchars_spec2str(p->symtab,
                                               seq, ssz, &rsz);
                                 if (ssz != 1 || rhs)                                          if (rhs != NULL)
                                         break;                                                  break;
                                   } else {
                                 rhs = seq;                                          uc = mchars_spec2cp(p->symtab,
                                 rsz = ssz;                                              seq, ssz);
                                 break;                                          if (uc > 0)
                                                   sz += cond_width(p, uc, &skip);
                                   }
                                   continue;
                         case ESCAPE_SKIPCHAR:                          case ESCAPE_SKIPCHAR:
                                 skip = 1;                                  skip = 1;
                                 break;                                  continue;
                         default:                          default:
                                 break;                                  continue;
                         }                          }
   
                         if (NULL == rhs)                          /*
                                 break;                           * Common handling for Unicode and numbered
                            * character escape sequences.
                            */
   
                           if (rhs == NULL) {
                                   if (p->enc == TERMENC_ASCII) {
                                           rhs = ascii_uc2str(uc);
                                           rsz = strlen(rhs);
                                   } else {
                                           if ((uc < 0x20 && uc != 0x09) ||
                                               (uc > 0x7E && uc < 0xA0))
                                                   uc = 0xFFFD;
                                           sz += cond_width(p, uc, &skip);
                                           continue;
                                   }
                           }
   
                         if (skip) {                          if (skip) {
                                 skip = 0;                                  skip = 0;
                                 break;                                  break;
                         }                          }
   
                           /*
                            * Common handling for all escape sequences
                            * printing more than one character.
                            */
   
                         for (i = 0; i < rsz; i++)                          for (i = 0; i < rsz; i++)
                                 sz += (*p->width)(p, *rhs++);                                  sz += (*p->width)(p, *rhs++);
Legend:
Removed from v.1.227  
changed lines
  Added in v.1.237
CVSweb