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

Diff for /mandoc/term.c between version 1.190 and 1.199

version 1.190, 2011/05/15 15:47:46 version 1.199, 2011/09/18 21:18:19
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 33 
Line 33 
 #include "term.h"  #include "term.h"
 #include "main.h"  #include "main.h"
   
 static  void              spec(struct termp *, const char *, size_t);  static  void             adjbuf(struct termp *p, int);
 static  void              res(struct termp *, const char *, 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              adjbuf(struct termp *p, int);  static  void             encode1(struct termp *, int);
 static  void              encode(struct termp *, const char *, size_t);  
   
   
 void  void
 term_free(struct termp *p)  term_free(struct termp *p)
 {  {
Line 72  term_end(struct termp *p)
Line 70  term_end(struct termp *p)
         (*p->end)(p);          (*p->end)(p);
 }  }
   
   
 struct termp *  
 term_alloc(enum termenc enc)  
 {  
         struct termp    *p;  
   
         p = mandoc_calloc(1, sizeof(struct termp));  
         p->enc = enc;  
         return(p);  
 }  
   
   
 /*  /*
  * Flush a line of text.  A "line" is loosely defined as being something   * Flush a line of text.  A "line" is loosely defined as being something
  * that should be followed by a newline, regardless of whether it's   * that should be followed by a newline, regardless of whether it's
Line 344  term_vspace(struct termp *p)
Line 330  term_vspace(struct termp *p)
         (*p->endline)(p);          (*p->endline)(p);
 }  }
   
   
 static void  
 numbered(struct termp *p, const char *word, size_t len)  
 {  
         char             c;  
   
         if ('\0' != (c = mchars_num2char(word, len)))  
                 encode(p, &c, 1);  
 }  
   
   
 static void  
 spec(struct termp *p, const char *word, size_t len)  
 {  
         const char      *rhs;  
         size_t           sz;  
   
         rhs = mchars_spec2str(p->symtab, word, len, &sz);  
         if (rhs)  
                 encode(p, rhs, sz);  
         else if (1 == len)  
                 encode(p, word, len);  
 }  
   
   
 static void  
 res(struct termp *p, const char *word, size_t len)  
 {  
         const char      *rhs;  
         size_t           sz;  
   
         rhs = mchars_res2str(p->symtab, word, len, &sz);  
         if (rhs)  
                 encode(p, rhs, sz);  
 }  
   
   
 void  void
 term_fontlast(struct termp *p)  term_fontlast(struct termp *p)
 {  {
Line 445  term_fontpop(struct termp *p)
Line 394  term_fontpop(struct termp *p)
         p->fonti--;          p->fonti--;
 }  }
   
   
 /*  /*
  * Handle pwords, partial words, which may be either a single word or a   * Handle pwords, partial words, which may be either a single word or a
  * phrase that cannot be broken down (such as a literal string).  This   * phrase that cannot be broken down (such as a literal string).  This
Line 454  term_fontpop(struct termp *p)
Line 402  term_fontpop(struct termp *p)
 void  void
 term_word(struct termp *p, const char *word)  term_word(struct termp *p, const char *word)
 {  {
         const char      *seq;          const char      *seq, *cp;
         int              sz;          char             c;
           int              sz, uc;
         size_t           ssz;          size_t           ssz;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
   
Line 490  term_word(struct termp *p, const char *word)
Line 439  term_word(struct termp *p, const char *word)
                 if (ESCAPE_ERROR == esc)                  if (ESCAPE_ERROR == esc)
                         break;                          break;
   
                   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):
                           encode1(p, '?');
                           break;
                 case (ESCAPE_NUMBERED):                  case (ESCAPE_NUMBERED):
                         numbered(p, seq, sz);                          c = mchars_num2char(seq, sz);
                           if ('\0' != c)
                                   encode(p, &c, 1);
                         break;                          break;
                 case (ESCAPE_PREDEF):  
                         res(p, seq, sz);  
                         break;  
                 case (ESCAPE_SPECIAL):                  case (ESCAPE_SPECIAL):
                         spec(p, seq, sz);                          cp = mchars_spec2str(p->symtab, seq, sz, &ssz);
                           if (NULL != cp)
                                   encode(p, cp, ssz);
                           else if (1 == ssz)
                                   encode(p, seq, sz);
                         break;                          break;
                 case (ESCAPE_FONTBOLD):                  case (ESCAPE_FONTBOLD):
                         term_fontrepl(p, TERMFONT_BOLD);                          term_fontrepl(p, TERMFONT_BOLD);
Line 506  term_word(struct termp *p, const char *word)
Line 479  term_word(struct termp *p, const char *word)
                 case (ESCAPE_FONTITALIC):                  case (ESCAPE_FONTITALIC):
                         term_fontrepl(p, TERMFONT_UNDER);                          term_fontrepl(p, TERMFONT_UNDER);
                         break;                          break;
                   case (ESCAPE_FONT):
                           /* FALLTHROUGH */
                 case (ESCAPE_FONTROMAN):                  case (ESCAPE_FONTROMAN):
                         term_fontrepl(p, TERMFONT_NONE);                          term_fontrepl(p, TERMFONT_NONE);
                         break;                          break;
Line 522  term_word(struct termp *p, const char *word)
Line 497  term_word(struct termp *p, const char *word)
         }          }
 }  }
   
   
 static void  static void
 adjbuf(struct termp *p, int sz)  adjbuf(struct termp *p, int sz)
 {  {
Line 536  adjbuf(struct termp *p, int sz)
Line 510  adjbuf(struct termp *p, int sz)
                 (p->buf, sizeof(int) * (size_t)p->maxcols);                  (p->buf, sizeof(int) * (size_t)p->maxcols);
 }  }
   
   
 static void  static void
 bufferc(struct termp *p, char c)  bufferc(struct termp *p, char c)
 {  {
Line 547  bufferc(struct termp *p, char c)
Line 520  bufferc(struct termp *p, char c)
         p->buf[p->col++] = c;          p->buf[p->col++] = c;
 }  }
   
   /*
    * See encode().
    * Do this for a single (probably unicode) value.
    * Does not check for non-decorated glyphs.
    */
   static void
   encode1(struct termp *p, int c)
   {
           enum termfont     f;
   
           if (p->col + 4 >= p->maxcols)
                   adjbuf(p, p->col + 4);
   
           f = term_fonttop(p);
   
           if (TERMFONT_NONE == f) {
                   p->buf[p->col++] = c;
                   return;
           } else if (TERMFONT_UNDER == f) {
                   p->buf[p->col++] = '_';
           } else
                   p->buf[p->col++] = c;
   
           p->buf[p->col++] = 8;
           p->buf[p->col++] = c;
   }
   
 static void  static void
 encode(struct termp *p, const char *word, size_t sz)  encode(struct termp *p, const char *word, size_t sz)
 {  {
Line 577  encode(struct termp *p, const char *word, size_t sz)
Line 576  encode(struct termp *p, const char *word, size_t sz)
                 adjbuf(p, p->col + 1 + (len * 3));                  adjbuf(p, p->col + 1 + (len * 3));
   
         for (i = 0; i < len; i++) {          for (i = 0; i < len; i++) {
                 if ( ! isgraph((unsigned char)word[i])) {                  if (ASCII_HYPH != word[i] &&
                       ! isgraph((unsigned char)word[i])) {
                         p->buf[p->col++] = word[i];                          p->buf[p->col++] = word[i];
                         continue;                          continue;
                 }                  }
   
                 if (TERMFONT_UNDER == f)                  if (TERMFONT_UNDER == f)
                         p->buf[p->col++] = '_';                          p->buf[p->col++] = '_';
                   else if (ASCII_HYPH == word[i])
                           p->buf[p->col++] = '-';
                 else                  else
                         p->buf[p->col++] = word[i];                          p->buf[p->col++] = word[i];
   
Line 592  encode(struct termp *p, const char *word, size_t sz)
Line 594  encode(struct termp *p, const char *word, size_t sz)
         }          }
 }  }
   
   
 size_t  size_t
 term_len(const struct termp *p, size_t sz)  term_len(const struct termp *p, size_t sz)
 {  {
Line 607  term_strlen(const struct termp *p, const char *cp)
Line 608  term_strlen(const struct termp *p, const char *cp)
         size_t           sz, rsz, i;          size_t           sz, rsz, i;
         int              ssz, c;          int              ssz, c;
         const char      *seq, *rhs;          const char      *seq, *rhs;
           enum mandoc_esc  esc;
         static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };          static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };
   
         /*          /*
Line 621  term_strlen(const struct termp *p, const char *cp)
Line 623  term_strlen(const struct termp *p, const char *cp)
                 for (i = 0; i < rsz; i++)                  for (i = 0; i < rsz; i++)
                         sz += (*p->width)(p, *cp++);                          sz += (*p->width)(p, *cp++);
   
                   c = 0;
                 switch (*cp) {                  switch (*cp) {
                 case ('\\'):                  case ('\\'):
                         cp++;                          cp++;
                         rhs = NULL;                          esc = mandoc_escape(&cp, &seq, &ssz);
                         switch (mandoc_escape(&cp, &seq, &ssz)) {                          if (ESCAPE_ERROR == esc)
                         case (ESCAPE_ERROR):  
                                 return(sz);                                  return(sz);
   
                           if (TERMENC_ASCII != p->enc)
                                   switch (esc) {
                                   case (ESCAPE_UNICODE):
                                           c = mchars_num2uc
                                                   (seq + 1, ssz - 1);
                                           if ('\0' == c)
                                                   break;
                                           sz += (*p->width)(p, c);
                                           continue;
                                   case (ESCAPE_SPECIAL):
                                           c = mchars_spec2cp
                                                   (p->symtab, seq, ssz);
                                           if (c <= 0)
                                                   break;
                                           sz += (*p->width)(p, c);
                                           continue;
                                   default:
                                           break;
                                   }
   
                           rhs = NULL;
   
                           switch (esc) {
                           case (ESCAPE_UNICODE):
                                   sz += (*p->width)(p, '?');
                                   break;
                         case (ESCAPE_NUMBERED):                          case (ESCAPE_NUMBERED):
                                 c = mchars_num2char(seq, ssz);                                  c = mchars_num2char(seq, ssz);
                                 if ('\0' != c)                                  if ('\0' != c)
                                         sz += (*p->width)(p, c);                                          sz += (*p->width)(p, c);
                                 break;  
                         case (ESCAPE_PREDEF):  
                                 rhs = mchars_res2str  
                                         (p->symtab, seq, ssz, &rsz);  
                                 break;                                  break;
                         case (ESCAPE_SPECIAL):                          case (ESCAPE_SPECIAL):
                                 rhs = mchars_spec2str                                  rhs = mchars_spec2str
Legend:
Removed from v.1.190  
changed lines
  Added in v.1.199
CVSweb