/[pcre]/code/trunk/pcre_compile.c

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 240 by ph10,
Tue Sep 11 15:47:20 2007 UTC
+revision 265 by ph10,
Wed Nov 14 11:35:48 2007 UTC
 Line 140 
 static const short int escapes[] = {
  #endif
  /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
  searched linearly. Put all the names into a single string, in order to reduce
  the number of relocations when a shared library is dynamically linked. */
  typedef struct verbitem {
 Line 150 
 typedef struct verbitem {
  } verbitem;
  static const char verbnames[] =
    "ACCEPT\0"
    "COMMIT\0"
    "F\0"
    "FAIL\0"
    "PRUNE\0"
    "SKIP\0"
    "THEN";
  static verbitem verbs[] = {
    { 6, OP_ACCEPT },
 Line 171 
 static verbitem verbs[] = {
  static int verbcount = sizeof(verbs)/sizeof(verbitem);
  /* Tables of names of POSIX character classes and their lengths. The names are
  now all in a single string, to reduce the number of relocations when a shared
  library is dynamically loaded. The list of lengths is terminated by a zero
  length entry. The first three must be alpha, lower, upper, as this is assumed
  for handling case independence. */
  static const char posix_names[] =
    "alpha\0"  "lower\0"  "upper\0"  "alnum\0"  "ascii\0"  "blank\0"
    "cntrl\0"  "digit\0"  "graph\0"  "print\0"  "punct\0"  "space\0"
    "word\0"   "xdigit";
  static const uschar posix_name_lengths[] = {
 Line 219 
 static const int posix_class_maps[] = {
  /* The texts of compile-time error messages. These are "char *" because they
  are passed to the outside world. Do not ever re-use any error number, because
  they are documented. Always add a new error instead. Messages marked DEAD below
  are no longer used. This used to be a table of strings, but in order to reduce
  the number of relocations needed when a shared library is loaded dynamically,
  it is now one long string. We cannot use a table of offsets, because the
  lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
  simply count through to the one we want - this isn't a performance issue
  because these strings are used only when there is a compilation error. */
  static const char error_texts[] =
 Line 439 
 static BOOL
  *            Find an error text                  *
  *************************************************/
  /* The error texts are now all in one long string, to save on relocations. As
  some of the text is of unknown length, we can't use a table of offsets.
  Instead, just count through the strings. This is not a performance issue
  because it happens only when there has been a compilation error.
  Argument:   the error number
 Line 452 
 static const char *
  find_error_text(int n)
  {
  const char *s = error_texts;
  for (; n > 0; n--) while (*s++ != 0);
  return s;
  }
 Line 1777 
 while (posix_name_lengths[yield] != 0)
    {
    if (len == posix_name_lengths[yield] &&
      strncmp((const char *)ptr, pn, len) == 0) return yield;
    pn += posix_name_lengths[yield] + 1;
    yield++;
    }
  return -1;
 Line 2383 
 req_caseopt = ((options & PCRE_CASELESS)
  for (;; ptr++)
    {
    BOOL negate_class;
+   BOOL should_flip_negation;
    BOOL possessive_quantifier;
    BOOL is_quantifier;
    BOOL is_recurse;
-Line 2631 
 for (;; ptr++)
+Line 2632 
 for (;; ptr++)
        else break;
        }
+     /* If a class contains a negative special such as \S, we need to flip the
+     negation flag at the end, so that support for characters > 255 works
+     correctly (they are all included in the class). */
+     should_flip_negation = FALSE;
      /* Keep a count of chars with values < 256 so that we can optimize the case
      of just a single character (as long as it's < 256). However, For higher
      valued UTF-8 characters, we don't yet do any optimization. */
-Line 2703 
 for (;; ptr++)
+Line 2710 
 for (;; ptr++)
          if (*ptr == '^')
            {
            local_negate = TRUE;
+           should_flip_negation = TRUE;  /* Note negative special */
            ptr++;
            }
-Line 2805 
 for (;; ptr++)
+Line 2813 
 for (;; ptr++)
              continue;
              case ESC_D:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
              continue;
-Line 2813 
 for (;; ptr++)
+Line 2822 
 for (;; ptr++)
              continue;
              case ESC_W:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
              continue;
-Line 2822 
 for (;; ptr++)
+Line 2832 
 for (;; ptr++)
              continue;
              case ESC_S:
+             should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
              classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
              continue;
-Line 3327 
 we set the flag only if there is a liter
+Line 3338 
 we set the flag only if there is a liter
      zeroreqbyte = reqbyte;
      /* If there are characters with values > 255, we have to compile an
-     extended class, with its own opcode. If there are no characters < 256,
+     extended class, with its own opcode, unless there was a negated special
-     we can omit the bitmap in the actual compiled code. */
+     such as \S in the class, because in that case all characters > 255 are in
+     the class, so any that were explicitly given as well can be ignored. If
+     (when there are explicit characters > 255 that must be listed) there are no
+     characters < 256, we can omit the bitmap in the actual compiled code. */
  #ifdef SUPPORT_UTF8
-     if (class_utf8)
+     if (class_utf8 && !should_flip_negation)
        {
        *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
        *code++ = OP_XCLASS;
-Line 3357 
 we set the flag only if there is a liter
+Line 3371 
 we set the flag only if there is a liter
        }
  #endif
-     /* If there are no characters > 255, negate the 32-byte map if necessary,
+     /* If there are no characters > 255, set the opcode to OP_CLASS or
-     and copy it into the code vector. If this is the first thing in the branch,
+     OP_NCLASS, depending on whether the whole class was negated and whether
-     there can be no first char setting, whatever the repeat count. Any reqbyte
+     there were negative specials such as \S in the class. Then copy the 32-byte
-     setting must remain unchanged after any kind of repeat. */
+     map into the code vector, negating it if necessary. */
+     *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
      if (negate_class)
        {
-       *code++ = OP_NCLASS;
        if (lengthptr == NULL)    /* Save time in the pre-compile phase */
          for (c = 0; c < 32; c++) code[c] = ~classbits[c];
        }
      else
        {
-       *code++ = OP_CLASS;
        memcpy(code, classbits, 32);
        }
      code += 32;
-Line 4064 
 we set the flag only if there is a liter
+Line 4077 
 we set the flag only if there is a liter
      if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
        {
        int i, namelen;
        const char *vn = verbnames;
        const uschar *name = ++ptr;
        previous = NULL;
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0);
-Line 4088 
 we set the flag only if there is a liter
+Line 4101 
 we set the flag only if there is a liter
            if (*code++ == OP_ACCEPT) cd->had_accept = TRUE;
            break;
            }
          vn += verbs[i].len + 1;
          }
        if (i < verbcount) continue;
        *errorcodeptr = ERR60;

 Legend:



Removed from v.240
 


changed lines


 
Added in v.265
 Legend:



Removed from v.240
 


changed lines


 
Added in v.265
-Removed from v.240
+Added in v.265

	ViewVC Help
Powered by ViewVC 1.1.5