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

Diff for /mandoc/term.c between version 1.224 and 1.232

version 1.224, 2014/07/06 18:51:13 version 1.232, 2014/10/28 18:49:33
Line 15 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
 #include <sys/types.h>  #include <sys/types.h>
   
Line 44  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 222  term_flushln(struct termp *p)
Line 216  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 446  term_word(struct termp *p, const char *word)
Line 440  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);
                           if (p->enc == TERMENC_ASCII) {
                                   cp = ascii_uc2str(uc);
                                   encode(p, cp, strlen(cp));
                           } else
                                   encode1(p, uc);
                         break;                          break;
                 case ESCAPE_NUMBERED:                  case ESCAPE_NUMBERED:
                         c = mchars_num2char(seq, sz);                          c = mchars_num2char(seq, sz);
Line 474  term_word(struct termp *p, const char *word)
Line 455  term_word(struct termp *p, const char *word)
                                 encode(p, &c, 1);                                  encode(p, &c, 1);
                         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);
                           } else {
                                   uc = mchars_spec2cp(p->symtab, seq, sz);
                                   if (uc > 0)
                                           encode1(p, uc);
                           }
                         break;                          break;
                 case ESCAPE_FONTBOLD:                  case ESCAPE_FONTBOLD:
                         term_fontrepl(p, TERMFONT_BOLD);                          term_fontrepl(p, TERMFONT_BOLD);
Line 685  term_strlen(const struct termp *p, const char *cp)
Line 671  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);                                  c = mchars_num2uc(seq + 1, sz - 1);
                                   if (p->enc == TERMENC_ASCII) {
                                           rhs = ascii_uc2str(c);
                                           rsz = strlen(rhs);
                                   } else
                                           sz += cond_width(p, c, &skip);
                                 break;                                  break;
                         case ESCAPE_NUMBERED:                          case ESCAPE_NUMBERED:
                                 c = mchars_num2char(seq, ssz);                                  c = mchars_num2char(seq, ssz);
Line 717  term_strlen(const struct termp *p, const char *cp)
Line 688  term_strlen(const struct termp *p, const char *cp)
                                         sz += cond_width(p, c, &skip);                                          sz += cond_width(p, c, &skip);
                                 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)                                  else {
                                         break;                                          c = mchars_spec2cp(p->symtab,
                                               seq, ssz);
                                 rhs = seq;                                          if (c > 0)
                                 rsz = ssz;                                                  sz += cond_width(p, c, &skip);
                                   }
                                 break;                                  break;
                         case ESCAPE_SKIPCHAR:                          case ESCAPE_SKIPCHAR:
                                 skip = 1;                                  skip = 1;
Line 769  term_vspan(const struct termp *p, const struct roffsu 
Line 741  term_vspan(const struct termp *p, const struct roffsu 
   
         switch (su->unit) {          switch (su->unit) {
         case SCALE_CM:          case SCALE_CM:
                 r = su->scale * 2;                  r = su->scale * 2.0;
                 break;                  break;
         case SCALE_IN:          case SCALE_IN:
                 r = su->scale * 6;                  r = su->scale * 6.0;
                 break;                  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;                  r = su->scale / 8.0;
                 break;                  break;
         case SCALE_MM:          case SCALE_MM:
                 r = su->scale / 1000;                  r = su->scale / 1000.0;
                 break;                  break;
         case SCALE_VS:          case SCALE_VS:
                 r = su->scale;                  r = su->scale;
                 break;                  break;
         default:          default:
                 r = su->scale - 1;                  r = su->scale - 1.0;
                 break;                  break;
         }          }
   
         if (r < 0.0)          if (r < 0.0)
                 r = 0.0;                  r = 0.0;
         return((size_t)r);          return((size_t)(r + 0.0005));
 }  }
   
 size_t  size_t
Line 801  term_hspan(const struct termp *p, const struct roffsu 
Line 773  term_hspan(const struct termp *p, const struct roffsu 
 {  {
         double           v;          double           v;
   
         v = ((*p->hspan)(p, su));          v = (*p->hspan)(p, su);
         if (v < 0.0)          if (v < 0.0)
                 v = 0.0;                  v = 0.0;
         return((size_t)v);          return((size_t)(v + 0.0005));
 }  }
Legend:
Removed from v.1.224  
changed lines
  Added in v.1.232
CVSweb