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

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

version 1.199, 2011/09/18 21:18:19 version 1.203, 2012/05/31 22:29:13
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 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, 2012 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
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 33 
Line 33 
 #include "term.h"  #include "term.h"
 #include "main.h"  #include "main.h"
   
   static  size_t           cond_width(const struct termp *, int, int *);
 static  void             adjbuf(struct termp *p, int);  static  void             adjbuf(struct termp *p, int);
 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);
Line 79  term_end(struct termp *p)
Line 80  term_end(struct termp *p)
  *   *
  * The following flags may be specified:   * The following flags may be specified:
  *   *
  *  - TERMP_NOLPAD: when beginning to write the line, don't left-pad the  
  *    offset value.  This is useful when doing columnar lists where the  
  *    prior column has right-padded.  
  *  
  *  - TERMP_NOBREAK: this is the most important and is used when making   *  - TERMP_NOBREAK: this is the most important and is used when making
  *    columns.  In short: don't print a newline and instead pad to the   *    columns.  In short: don't print a newline and instead expect the
  *    right margin.  Used in conjunction with TERMP_NOLPAD.   *    next call to do the padding up to the start of the next column.
  *   *
  *  - TERMP_TWOSPACE: when padding, make sure there are at least two   *  - TERMP_TWOSPACE: make sure there is room for at least two space
  *    space characters of padding.  Otherwise, rather break the line.   *    characters of padding.  Otherwise, rather break the line.
  *   *
  *  - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and   *  - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and
  *    the line is overrun, and don't pad-right if it's underrun.   *    the line is overrun, and don't pad-right if it's underrun.
  *   *
  *  - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when   *  - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when
  *    overruning, instead save the position and continue at that point   *    overrunning, instead save the position and continue at that point
  *    when the next invocation.   *    when the next invocation.
  *   *
  *  In-line line breaking:   *  In-line line breaking:
Line 134  term_flushln(struct termp *p)
Line 131  term_flushln(struct termp *p)
         bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;          bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
   
         /*          /*
          * Indent the first line of a paragraph.           * Calculate the required amount of padding.
          */           */
         vbl = p->flags & TERMP_NOLPAD ? (size_t)0 : p->offset;          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 187  term_flushln(struct termp *p)
Line 185  term_flushln(struct termp *p)
                 if (vend > bp && 0 == jhy && vis > 0) {                  if (vend > bp && 0 == jhy && vis > 0) {
                         vend -= vis;                          vend -= vis;
                         (*p->endline)(p);                          (*p->endline)(p);
                           p->viscol = 0;
                         if (TERMP_NOBREAK & p->flags) {                          if (TERMP_NOBREAK & p->flags) {
                                 p->viscol = p->rmargin;                                  vbl = p->rmargin;
                                 (*p->advance)(p, p->rmargin);  
                                 vend += p->rmargin - p->offset;                                  vend += p->rmargin - p->offset;
                         } else {                          } else
                                 p->viscol = 0;  
                                 vbl = p->offset;                                  vbl = p->offset;
                         }  
   
                         /* Remove the p->overstep width. */                          /* Remove the p->overstep width. */
   
Line 236  term_flushln(struct termp *p)
Line 232  term_flushln(struct termp *p)
                         if (ASCII_HYPH == p->buf[i]) {                          if (ASCII_HYPH == p->buf[i]) {
                                 (*p->letter)(p, '-');                                  (*p->letter)(p, '-');
                                 p->viscol += (*p->width)(p, '-');                                  p->viscol += (*p->width)(p, '-');
                         } else {                                  continue;
                                 (*p->letter)(p, p->buf[i]);  
                                 p->viscol += (*p->width)(p, p->buf[i]);  
                         }                          }
   
                           (*p->letter)(p, p->buf[i]);
                           if (8 == p->buf[i])
                                   p->viscol -= (*p->width)(p, p->buf[i-1]);
                           else
                                   p->viscol += (*p->width)(p, p->buf[i]);
                 }                  }
                 vis = vend;                  vis = vend;
         }          }
Line 248  term_flushln(struct termp *p)
Line 248  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.
          */           */
         vis -= vbl;          if (vis)
                   vis -= vbl;
   
         p->col = 0;          p->col = 0;
         p->overstep = 0;          p->overstep = 0;
Line 273  term_flushln(struct termp *p)
Line 274  term_flushln(struct termp *p)
                  * move it one step LEFT and flag the rest of the line                   * move it one step LEFT and flag the rest of the line
                  * to be longer.                   * to be longer.
                  */                   */
                 if (p->overstep >= -1) {                  if (p->overstep < -1)
                         assert((int)maxvis + p->overstep >= 0);  
                         maxvis += (size_t)p->overstep;  
                 } else  
                         p->overstep = 0;                          p->overstep = 0;
                   return;
   
         } else if (TERMP_DANGLE & p->flags)          } else if (TERMP_DANGLE & p->flags)
                 return;                  return;
   
         /* Right-pad. */          /* If the column was overrun, break the line. */
         if (maxvis > vis +          if (maxvis <= vis +
             ((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) {              ((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) {
                 p->viscol += maxvis - vis;  
                 (*p->advance)(p, maxvis - vis);  
                 vis += (maxvis - vis);  
         } else {        /* ...or newline break. */  
                 (*p->endline)(p);                  (*p->endline)(p);
                 p->viscol = p->rmargin;                  p->viscol = 0;
                 (*p->advance)(p, p->rmargin);  
         }          }
 }  }
   
Line 306  term_newln(struct termp *p)
Line 300  term_newln(struct termp *p)
 {  {
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         if (0 == p->col && 0 == p->viscol) {          if (p->col || p->viscol)
                 p->flags &= ~TERMP_NOLPAD;                  term_flushln(p);
                 return;  
         }  
         term_flushln(p);  
         p->flags &= ~TERMP_NOLPAD;  
 }  }
   
   
Line 327  term_vspace(struct termp *p)
Line 317  term_vspace(struct termp *p)
   
         term_newln(p);          term_newln(p);
         p->viscol = 0;          p->viscol = 0;
         (*p->endline)(p);          if (0 < p->skipvsp)
                   p->skipvsp--;
           else
                   (*p->endline)(p);
 }  }
   
 void  void
Line 427  term_word(struct termp *p, const char *word)
Line 420  term_word(struct termp *p, const char *word)
         p->flags &= ~(TERMP_SENTENCE | TERMP_IGNDELIM);          p->flags &= ~(TERMP_SENTENCE | TERMP_IGNDELIM);
   
         while ('\0' != *word) {          while ('\0' != *word) {
                 if ((ssz = strcspn(word, "\\")) > 0)                  if ('\\' != *word) {
                           if (TERMP_SKIPCHAR & p->flags) {
                                   p->flags &= ~TERMP_SKIPCHAR;
                                   word++;
                                   continue;
                           }
                           ssz = strcspn(word, "\\");
                         encode(p, word, ssz);                          encode(p, word, ssz);
                           word += (int)ssz;
                 word += (int)ssz;  
                 if ('\\' != *word)  
                         continue;                          continue;
                   }
   
                 word++;                  word++;
                 esc = mandoc_escape(&word, &seq, &sz);                  esc = mandoc_escape(&word, &seq, &sz);
Line 488  term_word(struct termp *p, const char *word)
Line 486  term_word(struct termp *p, const char *word)
                         term_fontlast(p);                          term_fontlast(p);
                         break;                          break;
                 case (ESCAPE_NOSPACE):                  case (ESCAPE_NOSPACE):
                         if ('\0' == *word)                          if (TERMP_SKIPCHAR & p->flags)
                                   p->flags &= ~TERMP_SKIPCHAR;
                           else if ('\0' == *word)
                                 p->flags |= TERMP_NOSPACE;                                  p->flags |= TERMP_NOSPACE;
                         break;                          break;
                   case (ESCAPE_SKIPCHAR):
                           p->flags |= TERMP_SKIPCHAR;
                           break;
                 default:                  default:
                         break;                          break;
                 }                  }
Line 530  encode1(struct termp *p, int c)
Line 533  encode1(struct termp *p, int c)
 {  {
         enum termfont     f;          enum termfont     f;
   
           if (TERMP_SKIPCHAR & p->flags) {
                   p->flags &= ~TERMP_SKIPCHAR;
                   return;
           }
   
         if (p->col + 4 >= p->maxcols)          if (p->col + 4 >= p->maxcols)
                 adjbuf(p, p->col + 4);                  adjbuf(p, p->col + 4);
   
Line 553  encode(struct termp *p, const char *word, size_t sz)
Line 561  encode(struct termp *p, const char *word, size_t sz)
         enum termfont     f;          enum termfont     f;
         int               i, len;          int               i, len;
   
           if (TERMP_SKIPCHAR & p->flags) {
                   p->flags &= ~TERMP_SKIPCHAR;
                   return;
           }
   
         /* LINTED */          /* LINTED */
         len = sz;          len = sz;
   
Line 601  term_len(const struct termp *p, size_t sz)
Line 614  term_len(const struct termp *p, size_t sz)
         return((*p->width)(p, ' ') * sz);          return((*p->width)(p, ' ') * sz);
 }  }
   
   static size_t
   cond_width(const struct termp *p, int c, int *skip)
   {
   
           if (*skip) {
                   (*skip) = 0;
                   return(0);
           } else
                   return((*p->width)(p, c));
   }
   
 size_t  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, c;          int              ssz, skip, c;
         const char      *seq, *rhs;          const char      *seq, *rhs;
         enum mandoc_esc  esc;          enum mandoc_esc  esc;
         static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };          static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };
Line 618  term_strlen(const struct termp *p, const char *cp)
Line 641  term_strlen(const struct termp *p, const char *cp)
          */           */
   
         sz = 0;          sz = 0;
           skip = 0;
         while ('\0' != *cp) {          while ('\0' != *cp) {
                 rsz = strcspn(cp, rej);                  rsz = strcspn(cp, rej);
                 for (i = 0; i < rsz; i++)                  for (i = 0; i < rsz; i++)
                         sz += (*p->width)(p, *cp++);                          sz += cond_width(p, *cp++, &skip);
   
                 c = 0;                  c = 0;
                 switch (*cp) {                  switch (*cp) {
Line 638  term_strlen(const struct termp *p, const char *cp)
Line 662  term_strlen(const struct termp *p, const char *cp)
                                                 (seq + 1, ssz - 1);                                                  (seq + 1, ssz - 1);
                                         if ('\0' == c)                                          if ('\0' == c)
                                                 break;                                                  break;
                                         sz += (*p->width)(p, c);                                          sz += cond_width(p, c, &skip);
                                         continue;                                          continue;
                                 case (ESCAPE_SPECIAL):                                  case (ESCAPE_SPECIAL):
                                         c = mchars_spec2cp                                          c = mchars_spec2cp
                                                 (p->symtab, seq, ssz);                                                  (p->symtab, seq, ssz);
                                         if (c <= 0)                                          if (c <= 0)
                                                 break;                                                  break;
                                         sz += (*p->width)(p, c);                                          sz += cond_width(p, c, &skip);
                                         continue;                                          continue;
                                 default:                                  default:
                                         break;                                          break;
Line 655  term_strlen(const struct termp *p, const char *cp)
Line 679  term_strlen(const struct termp *p, const char *cp)
   
                         switch (esc) {                          switch (esc) {
                         case (ESCAPE_UNICODE):                          case (ESCAPE_UNICODE):
                                 sz += (*p->width)(p, '?');                                  sz += cond_width(p, '?', &skip);
                                 break;                                  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 += cond_width(p, c, &skip);
                                 break;                                  break;
                         case (ESCAPE_SPECIAL):                          case (ESCAPE_SPECIAL):
                                 rhs = mchars_spec2str                                  rhs = mchars_spec2str
Line 672  term_strlen(const struct termp *p, const char *cp)
Line 696  term_strlen(const struct termp *p, const char *cp)
                                 rhs = seq;                                  rhs = seq;
                                 rsz = ssz;                                  rsz = ssz;
                                 break;                                  break;
                           case (ESCAPE_SKIPCHAR):
                                   skip = 1;
                                   break;
                         default:                          default:
                                 break;                                  break;
                         }                          }
Line 679  term_strlen(const struct termp *p, const char *cp)
Line 706  term_strlen(const struct termp *p, const char *cp)
                         if (NULL == rhs)                          if (NULL == rhs)
                                 break;                                  break;
   
                           if (skip) {
                                   skip = 0;
                                   break;
                           }
   
                         for (i = 0; i < rsz; i++)                          for (i = 0; i < rsz; i++)
                                 sz += (*p->width)(p, *rhs++);                                  sz += (*p->width)(p, *rhs++);
                         break;                          break;
                 case (ASCII_NBRSP):                  case (ASCII_NBRSP):
                         sz += (*p->width)(p, ' ');                          sz += cond_width(p, ' ', &skip);
                         cp++;                          cp++;
                         break;                          break;
                 case (ASCII_HYPH):                  case (ASCII_HYPH):
                         sz += (*p->width)(p, '-');                          sz += cond_width(p, '-', &skip);
                         cp++;                          cp++;
                         break;                          break;
                 default:                  default:
Legend:
Removed from v.1.199  
changed lines
  Added in v.1.203
CVSweb