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

Diff for /mandoc/mandoc.c between version 1.64 and 1.65

version 1.64, 2012/05/31 22:34:06 version 1.65, 2012/05/31 22:38:16
Line 42  static char *time2a(time_t);
Line 42  static char *time2a(time_t);
 enum mandoc_esc  enum mandoc_esc
 mandoc_escape(const char **end, const char **start, int *sz)  mandoc_escape(const char **end, const char **start, int *sz)
 {  {
         char             c, term;          const char      *local_start;
         int              i, rlim;          int              local_sz;
         const char      *cp, *rstart;          char             term;
         enum mandoc_esc  gly;          enum mandoc_esc  gly;
   
         cp = *end;          /*
         rstart = cp;           * When the caller doesn't provide return storage,
         if (start)           * use local storage.
                 *start = rstart;           */
         i = rlim = 0;  
           if (NULL == start)
                   start = &local_start;
           if (NULL == sz)
                   sz = &local_sz;
   
           /*
            * Beyond the backslash, at least one input character
            * is part of the escape sequence.  With one exception
            * (see below), that character won't be returned.
            */
   
         gly = ESCAPE_ERROR;          gly = ESCAPE_ERROR;
           *start = ++*end;
           *sz = 0;
         term = '\0';          term = '\0';
   
         switch ((c = cp[i++])) {          switch ((*start)[-1]) {
         /*          /*
          * First the glyphs.  There are several different forms of           * First the glyphs.  There are several different forms of
          * these, but each eventually returns a substring of the glyph           * these, but each eventually returns a substring of the glyph
Line 63  mandoc_escape(const char **end, const char **start, in
Line 76  mandoc_escape(const char **end, const char **start, in
          */           */
         case ('('):          case ('('):
                 gly = ESCAPE_SPECIAL;                  gly = ESCAPE_SPECIAL;
                 rlim = 2;                  *sz = 2;
                 break;                  break;
         case ('['):          case ('['):
                 gly = ESCAPE_SPECIAL;                  gly = ESCAPE_SPECIAL;
Line 73  mandoc_escape(const char **end, const char **start, in
Line 86  mandoc_escape(const char **end, const char **start, in
                  * Unicode codepoint.  Here, however, only check whether                   * Unicode codepoint.  Here, however, only check whether
                  * it's not a zero-width escape.                   * it's not a zero-width escape.
                  */                   */
                 if ('u' == cp[i] && ']' != cp[i + 1])                  if ('u' == (*start)[0] && ']' != (*start)[1])
                         gly = ESCAPE_UNICODE;                          gly = ESCAPE_UNICODE;
                 term = ']';                  term = ']';
                 break;                  break;
         case ('C'):          case ('C'):
                 if ('\'' != cp[i])                  if ('\'' != **start)
                         return(ESCAPE_ERROR);                          return(ESCAPE_ERROR);
                 gly = ESCAPE_SPECIAL;                  gly = ESCAPE_SPECIAL;
                   *start = ++*end;
                 term = '\'';                  term = '\'';
                 break;                  break;
   
Line 91  mandoc_escape(const char **end, const char **start, in
Line 105  mandoc_escape(const char **end, const char **start, in
          * let us just skip the next character.           * let us just skip the next character.
          */           */
         case ('z'):          case ('z'):
                 (*end)++;  
                 return(ESCAPE_SKIPCHAR);                  return(ESCAPE_SKIPCHAR);
   
         /*          /*
Line 118  mandoc_escape(const char **end, const char **start, in
Line 131  mandoc_escape(const char **end, const char **start, in
         case ('f'):          case ('f'):
                 if (ESCAPE_ERROR == gly)                  if (ESCAPE_ERROR == gly)
                         gly = ESCAPE_FONT;                          gly = ESCAPE_FONT;
                   switch (**start) {
                 rstart= &cp[i];  
                 if (start)  
                         *start = rstart;  
   
                 switch (cp[i++]) {  
                 case ('('):                  case ('('):
                         rlim = 2;                          *start = ++*end;
                           *sz = 2;
                         break;                          break;
                 case ('['):                  case ('['):
                           *start = ++*end;
                         term = ']';                          term = ']';
                         break;                          break;
                 default:                  default:
                         rlim = 1;                          *sz = 1;
                         i--;  
                         break;                          break;
                 }                  }
                 break;                  break;
Line 154  mandoc_escape(const char **end, const char **start, in
Line 163  mandoc_escape(const char **end, const char **start, in
         case ('X'):          case ('X'):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case ('Z'):          case ('Z'):
                 if ('\'' != cp[i++])                  if ('\'' != **start)
                         return(ESCAPE_ERROR);                          return(ESCAPE_ERROR);
                 gly = ESCAPE_IGNORE;                  gly = ESCAPE_IGNORE;
                   *start = ++*end;
                 term = '\'';                  term = '\'';
                 break;                  break;
   
Line 182  mandoc_escape(const char **end, const char **start, in
Line 192  mandoc_escape(const char **end, const char **start, in
         case ('w'):          case ('w'):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case ('x'):          case ('x'):
                   if ('\'' != **start)
                           return(ESCAPE_ERROR);
                 if (ESCAPE_ERROR == gly)                  if (ESCAPE_ERROR == gly)
                         gly = ESCAPE_IGNORE;                          gly = ESCAPE_IGNORE;
                 if ('\'' != cp[i++])                  *start = ++*end;
                         return(ESCAPE_ERROR);  
                 term = '\'';                  term = '\'';
                 break;                  break;
   
Line 194  mandoc_escape(const char **end, const char **start, in
Line 205  mandoc_escape(const char **end, const char **start, in
          * XXX Do any other escapes need similar handling?           * XXX Do any other escapes need similar handling?
          */           */
         case ('N'):          case ('N'):
                 if ('\0' == cp[i])                  if ('\0' == **start)
                         return(ESCAPE_ERROR);                          return(ESCAPE_ERROR);
                 *end = &cp[++i];                  (*end)++;
                 if (isdigit((unsigned char)cp[i-1]))                  if (isdigit((unsigned char)**start)) {
                           *sz = 1;
                         return(ESCAPE_IGNORE);                          return(ESCAPE_IGNORE);
                   }
                   (*start)++;
                 while (isdigit((unsigned char)**end))                  while (isdigit((unsigned char)**end))
                         (*end)++;                          (*end)++;
                 if (start)                  *sz = *end - *start;
                         *start = &cp[i];  
                 if (sz)  
                         *sz = *end - &cp[i];  
                 if ('\0' != **end)                  if ('\0' != **end)
                         (*end)++;                          (*end)++;
                 return(ESCAPE_NUMBERED);                  return(ESCAPE_NUMBERED);
Line 215  mandoc_escape(const char **end, const char **start, in
Line 226  mandoc_escape(const char **end, const char **start, in
         case ('s'):          case ('s'):
                 gly = ESCAPE_IGNORE;                  gly = ESCAPE_IGNORE;
   
                 rstart = &cp[i];  
                 if (start)  
                         *start = rstart;  
   
                 /* See +/- counts as a sign. */                  /* See +/- counts as a sign. */
                 c = cp[i];                  if ('+' == **end || '-' == **end || ASCII_HYPH == **end)
                 if ('+' == c || '-' == c || ASCII_HYPH == c)                          (*end)++;
                         ++i;  
   
                 switch (cp[i++]) {                  switch (**end) {
                 case ('('):                  case ('('):
                         rlim = 2;                          *start = ++*end;
                           *sz = 2;
                         break;                          break;
                 case ('['):                  case ('['):
                           *start = ++*end;
                         term = ']';                          term = ']';
                         break;                          break;
                 case ('\''):                  case ('\''):
                           *start = ++*end;
                         term = '\'';                          term = '\'';
                         break;                          break;
                 default:                  default:
                         rlim = 1;                          *sz = 1;
                         i--;  
                         break;                          break;
                 }                  }
   
                 /* See +/- counts as a sign. */  
                 c = cp[i];  
                 if ('+' == c || '-' == c || ASCII_HYPH == c)  
                         ++i;  
   
                 break;                  break;
   
         /*          /*
          * Anything else is assumed to be a glyph.           * Anything else is assumed to be a glyph.
            * In this case, pass back the character after the backslash.
          */           */
         default:          default:
                 gly = ESCAPE_SPECIAL;                  gly = ESCAPE_SPECIAL;
                 rlim = 1;                  *start = --*end;
                 i--;                  *sz = 1;
                 break;                  break;
         }          }
   
         assert(ESCAPE_ERROR != gly);          assert(ESCAPE_ERROR != gly);
   
         *end = rstart = &cp[i];  
         if (start)  
                 *start = rstart;  
   
         /*          /*
          * Read up to the terminating character,           * Read up to the terminating character,
          * paying attention to nested escapes.           * paying attention to nested escapes.
Line 284  mandoc_escape(const char **end, const char **start, in
Line 284  mandoc_escape(const char **end, const char **start, in
                                 break;                                  break;
                         }                          }
                 }                  }
                 rlim = (*end)++ - rstart;                  *sz = (*end)++ - *start;
         } else {          } else {
                 assert(rlim > 0);                  assert(*sz > 0);
                 if ((size_t)rlim > strlen(rstart))                  if ((size_t)*sz > strlen(*start))
                         return(ESCAPE_ERROR);                          return(ESCAPE_ERROR);
                 *end += rlim;                  *end += *sz;
         }          }
         if (sz)  
                 *sz = rlim;  
   
         /* Run post-processors. */          /* Run post-processors. */
   
Line 302  mandoc_escape(const char **end, const char **start, in
Line 300  mandoc_escape(const char **end, const char **start, in
                  * Pretend that the constant-width font modes are the                   * Pretend that the constant-width font modes are the
                  * same as the regular font modes.                   * same as the regular font modes.
                  */                   */
                 if (2 == rlim && 'C' == *rstart)                  if (2 == *sz && 'C' == **start) {
                         rstart++;                          (*start)++;
                 else if (1 != rlim)                          (*sz)--;
                   } else if (1 != *sz)
                         break;                          break;
   
                 switch (*rstart) {                  switch (**start) {
                 case ('3'):                  case ('3'):
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case ('B'):                  case ('B'):
Line 329  mandoc_escape(const char **end, const char **start, in
Line 328  mandoc_escape(const char **end, const char **start, in
                 }                  }
                 break;                  break;
         case (ESCAPE_SPECIAL):          case (ESCAPE_SPECIAL):
                 if (1 != rlim)                  if (1 == *sz && 'c' == **start)
                         break;  
                 if ('c' == *rstart)  
                         gly = ESCAPE_NOSPACE;                          gly = ESCAPE_NOSPACE;
                 break;                  break;
         default:          default:
Legend:
Removed from v.1.64  
changed lines
  Added in v.1.65
CVSweb