/[pcre]/code/branches/pcre16/pcre_compile.c

Diff of /code/branches/pcre16/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-code/trunk/pcre_compile.c
revision 691 by ph10,
Sun Sep 11 14:31:21 2011 UTC
+code/branches/pcre16/pcre_compile.c
revision 764 by zherczeg,
Wed Nov 23 17:23:20 2011 UTC
 Line 231 
 static const char posix_names[] =
    STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
    STRING_word0  STRING_xdigit;
- static const uschar posix_name_lengths[] = {
+ static const pcre_uint8 posix_name_lengths[] = {
 , 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
  /* Table of class bit maps for each POSIX class. Each class is formed from a
 Line 266 
 substitutes must be in the order of the
  both positive and negative cases. NULL means no substitute. */
  #ifdef SUPPORT_UCP
- static const uschar *substitutes[] = {
+ static const pcre_uchar string_PNd[]  = {
-   (uschar *)"\\P{Nd}",    /* \D */
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
-   (uschar *)"\\p{Nd}",    /* \d */
+   CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   (uschar *)"\\P{Xsp}",   /* \S */       /* NOTE: Xsp is Perl space */
+ static const pcre_uchar string_pNd[]  = {
-   (uschar *)"\\p{Xsp}",   /* \s */
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
-   (uschar *)"\\P{Xwd}",   /* \W */
+   CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   (uschar *)"\\p{Xwd}"    /* \w */
+ static const pcre_uchar string_PXsp[] = {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_pXsp[] = {
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_PXwd[] = {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_pXwd[] = {
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar *substitutes[] = {
+   string_PNd,           /* \D */
+   string_pNd,           /* \d */
+   string_PXsp,          /* \S */       /* NOTE: Xsp is Perl space */
+   string_pXsp,          /* \s */
+   string_PXwd,          /* \W */
+   string_pXwd           /* \w */
  };
- static const uschar *posix_substitutes[] = {
+ static const pcre_uchar string_pL[] =   {
-   (uschar *)"\\p{L}",     /* alpha */
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
-   (uschar *)"\\p{Ll}",    /* lower */
+   CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   (uschar *)"\\p{Lu}",    /* upper */
+ static const pcre_uchar string_pLl[] =  {
-   (uschar *)"\\p{Xan}",   /* alnum */
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
-   NULL,                   /* ascii */
+   CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   (uschar *)"\\h",        /* blank */
+ static const pcre_uchar string_pLu[] =  {
-   NULL,                   /* cntrl */
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
-   (uschar *)"\\p{Nd}",    /* digit */
+   CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   NULL,                   /* graph */
+ static const pcre_uchar string_pXan[] = {
-   NULL,                   /* print */
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
-   NULL,                   /* punct */
+   CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-   (uschar *)"\\p{Xps}",   /* space */    /* NOTE: Xps is POSIX space */
+ static const pcre_uchar string_h[] =    {
-   (uschar *)"\\p{Xwd}",   /* word */
+   CHAR_BACKSLASH, CHAR_h, '\0' };
-   NULL,                   /* xdigit */
+ static const pcre_uchar string_pXps[] = {
+   CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_PL[] =   {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_PLl[] =  {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_PLu[] =  {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_PXan[] = {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar string_H[] =    {
+   CHAR_BACKSLASH, CHAR_H, '\0' };
+ static const pcre_uchar string_PXps[] = {
+   CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+   CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+ static const pcre_uchar *posix_substitutes[] = {
+   string_pL,            /* alpha */
+   string_pLl,           /* lower */
+   string_pLu,           /* upper */
+   string_pXan,          /* alnum */
+   NULL,                 /* ascii */
+   string_h,             /* blank */
+   NULL,                 /* cntrl */
+   string_pNd,           /* digit */
+   NULL,                 /* graph */
+   NULL,                 /* print */
+   NULL,                 /* punct */
+   string_pXps,          /* space */    /* NOTE: Xps is POSIX space */
+   string_pXwd,          /* word */
+   NULL,                 /* xdigit */
    /* Negated cases */
-   (uschar *)"\\P{L}",     /* ^alpha */
+   string_PL,            /* ^alpha */
-   (uschar *)"\\P{Ll}",    /* ^lower */
+   string_PLl,           /* ^lower */
-   (uschar *)"\\P{Lu}",    /* ^upper */
+   string_PLu,           /* ^upper */
-   (uschar *)"\\P{Xan}",   /* ^alnum */
+   string_PXan,          /* ^alnum */
-   NULL,                   /* ^ascii */
+   NULL,                 /* ^ascii */
-   (uschar *)"\\H",        /* ^blank */
+   string_H,             /* ^blank */
-   NULL,                   /* ^cntrl */
+   NULL,                 /* ^cntrl */
-   (uschar *)"\\P{Nd}",    /* ^digit */
+   string_PNd,           /* ^digit */
-   NULL,                   /* ^graph */
+   NULL,                 /* ^graph */
-   NULL,                   /* ^print */
+   NULL,                 /* ^print */
-   NULL,                   /* ^punct */
+   NULL,                 /* ^punct */
-   (uschar *)"\\P{Xps}",   /* ^space */   /* NOTE: Xps is POSIX space */
+   string_PXps,          /* ^space */   /* NOTE: Xps is POSIX space */
-   (uschar *)"\\P{Xwd}",   /* ^word */
+   string_PXwd,          /* ^word */
-   NULL                    /* ^xdigit */
+   NULL                  /* ^xdigit */
  };
- #define POSIX_SUBSIZE (sizeof(posix_substitutes)/sizeof(uschar *))
+ #define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))
  #endif
  #define STRING(a)  # a
-Line 410 
 static const char error_texts[] =
+Line 464 
 static const char error_texts[] =
    "this version of PCRE is not compiled with PCRE_UCP support\0"
    "\\c must be followed by an ASCII character\0"
    "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
+   /* 70 */
+   "internal error: unknown opcode in find_fixedlength()\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 546 
 static const unsigned char ebcdic_charta
+Line 602 
 static const unsigned char ebcdic_charta
  /* Definition to allow mutual recursion */
  static BOOL
-   compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int,
+   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
      int *, int *, branch_chain *, compile_data *, int *);
-Line 593 
 Returns:    TRUE or FALSE
+Line 649 
 Returns:    TRUE or FALSE
  */
  static BOOL
- is_counted_repeat(const uschar *p)
+ is_counted_repeat(const pcre_uchar *p)
  {
  if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
  while ((digitab[*p] & ctype_digit) != 0) p++;
-Line 635 
 Returns:         zero or positive => a d
+Line 691 
 Returns:         zero or positive => a d
  */
  static int
- check_escape(const uschar **ptrptr, int *errorcodeptr, int bracount,
+ check_escape(const pcre_uchar **ptrptr, int *errorcodeptr, int bracount,
    int options, BOOL isclass)
  {
  BOOL utf8 = (options & PCRE_UTF8) != 0;
- const uschar *ptr = *ptrptr + 1;
+ const pcre_uchar *ptr = *ptrptr + 1;
  int c, i;
  GETCHARINCTEST(c, ptr);           /* Get character value, increment pointer */
-Line 666 
 else if ((i = escapes[c - 0x48]) != 0)
+Line 722 
 else if ((i = escapes[c - 0x48]) != 0)
  else
    {
-   const uschar *oldptr;
+   const pcre_uchar *oldptr;
    BOOL braced, negated;
    switch (c)
-Line 676 
 else
+Line 732 
 else
      case CHAR_l:
      case CHAR_L:
+     *errorcodeptr = ERR37;
+     break;
      case CHAR_u:
+     if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       /* In JavaScript, \u must be followed by four hexadecimal numbers.
+       Otherwise it is a lowercase u letter. */
+       if ((digitab[ptr[1]] & ctype_xdigit) != 0 && (digitab[ptr[2]] & ctype_xdigit) != 0
+            && (digitab[ptr[3]] & ctype_xdigit) != 0 && (digitab[ptr[4]] & ctype_xdigit) != 0)
+         {
+         c = 0;
+         for (i = 0; i < 4; ++i)
+           {
+           register int cc = *(++ptr);
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
+           if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+           c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+ #else           /* EBCDIC coding */
+           if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+           c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+ #endif
+           }
+         }
+       }
+     else
+       *errorcodeptr = ERR37;
+     break;
      case CHAR_U:
-     *errorcodeptr = ERR37;
+     /* In JavaScript, \U is an uppercase U letter. */
+     if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;
      break;
      /* In a character class, \g is just a literal "g". Outside a character
-Line 710 
 else
+Line 795 
 else
      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
-       const uschar *p;
+       const pcre_uchar *p;
        for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
          if (*p != CHAR_MINUS && (digitab[*p] & ctype_digit) == 0) break;
        if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)
-Line 828 
 else
+Line 913 
 else
      treated as a data character. */
      case CHAR_x:
+     if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       /* In JavaScript, \x must be followed by two hexadecimal numbers.
+       Otherwise it is a lowercase x letter. */
+       if ((digitab[ptr[1]] & ctype_xdigit) != 0 && (digitab[ptr[2]] & ctype_xdigit) != 0)
+         {
+         c = 0;
+         for (i = 0; i < 2; ++i)
+           {
+           register int cc = *(++ptr);
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
+           if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+           c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+ #else           /* EBCDIC coding */
+           if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+           c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+ #endif
+           }
+         }
+       break;
+       }
      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
-       const uschar *pt = ptr + 2;
+       const pcre_uchar *pt = ptr + 2;
        int count = 0;
        c = 0;
-Line 961 
 Returns:         type value from ucp_typ
+Line 1068 
 Returns:         type value from ucp_typ
  */
  static int
- get_ucp(const uschar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
+ get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
  {
  int c, i, bot, top;
- const uschar *ptr = *ptrptr;
+ const pcre_uchar *ptr = *ptrptr;
- char name[32];
+ pcre_uchar name[32];
  c = *(++ptr);
  if (c == 0) goto ERROR_RETURN;
-Line 1006 
 else
+Line 1113 
 else
  /* Search for a recognized property name using binary chop */
  bot = 0;
- top = _pcre_utt_size;
+ top = PRIV(utt_size);
  while (bot < top)
    {
    i = (bot + top) >> 1;
-   c = strcmp(name, _pcre_utt_names + _pcre_utt[i].name_offset);
+   c = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
    if (c == 0)
      {
-     *dptr = _pcre_utt[i].value;
+     *dptr = PRIV(utt)[i].value;
-     return _pcre_utt[i].type;
+     return PRIV(utt)[i].type;
      }
    if (c > 0) bot = i + 1; else top = i;
    }
-Line 1053 
 Returns:         pointer to '}' on succe
+Line 1160 
 Returns:         pointer to '}' on succe
                   current ptr on error, with errorcodeptr set non-zero
  */
- static const uschar *
+ static const pcre_uchar *
- read_repeat_counts(const uschar *p, int *minp, int *maxp, int *errorcodeptr)
+ read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)
  {
  int min = 0;
  int max = -1;
-Line 1139 
 Returns:       the number of the named s
+Line 1246 
 Returns:       the number of the named s
  */
  static int
- find_parens_sub(uschar **ptrptr, compile_data *cd, const uschar *name, int lorn,
+ find_parens_sub(pcre_uchar **ptrptr, compile_data *cd, const pcre_uchar *name, int lorn,
    BOOL xmode, BOOL utf8, int *count)
  {
- uschar *ptr = *ptrptr;
+ pcre_uchar *ptr = *ptrptr;
  int start_count = *count;
  int hwm_count = start_count;
  BOOL dup_parens = FALSE;
-Line 1209 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1316 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
          ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)
        {
        int term;
-       const uschar *thisname;
+       const pcre_uchar *thisname;
        *count += 1;
        if (name == NULL && *count == lorn) return *count;
        term = *ptr++;
-Line 1217 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1324 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
        thisname = ptr;
        while (*ptr != term) ptr++;
        if (name != NULL && lorn == ptr - thisname &&
-           strncmp((const char *)name, (const char *)thisname, lorn) == 0)
+           STRNCMP_UC_UC(name, thisname, lorn) == 0)
          return *count;
        term++;
        }
-Line 1260 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1367 
 for (; ptr < cd->end_pattern; ptr++)
          {
          if (ptr[2] == CHAR_E)
            ptr+= 2;
-         else if (strncmp((const char *)ptr+2,
+         else if (STRNCMP_UC_C8(ptr + 2,
                   STR_Q STR_BACKSLASH STR_E, 3) == 0)
            ptr += 4;
          else
-Line 1372 
 Returns:       the number of the found s
+Line 1479 
 Returns:       the number of the found s
  */
  static int
- find_parens(compile_data *cd, const uschar *name, int lorn, BOOL xmode,
+ find_parens(compile_data *cd, const pcre_uchar *name, int lorn, BOOL xmode,
    BOOL utf8)
  {
- uschar *ptr = (uschar *)cd->start_pattern;
+ pcre_uchar *ptr = (pcre_uchar *)cd->start_pattern;
  int count = 0;
  int rc;
-Line 1413 
 Arguments:
+Line 1520 
 Arguments:
  Returns:       pointer to the first significant opcode
  */
- static const uschar*
+ static const pcre_uchar*
- first_significant_code(const uschar *code, BOOL skipassert)
+ first_significant_code(const pcre_uchar *code, BOOL skipassert)
  {
  for (;;)
    {
-Line 1425 
 for (;;)
+Line 1532 
 for (;;)
      case OP_ASSERTBACK_NOT:
      if (!skipassert) return code;
      do code += GET(code, 1); while (*code == OP_ALT);
-     code += _pcre_OP_lengths[*code];
+     code += PRIV(OP_lengths)[*code];
      break;
      case OP_WORD_BOUNDARY:
-Line 1439 
 for (;;)
+Line 1546 
 for (;;)
      case OP_RREF:
      case OP_NRREF:
      case OP_DEF:
-     code += _pcre_OP_lengths[*code];
+     code += PRIV(OP_lengths)[*code];
      break;
      default:
-Line 1475 
 Arguments:
+Line 1582 
 Arguments:
  Returns:   the fixed length,
               or -1 if there is no fixed length,
-              or -2 if \C was encountered
+              or -2 if \C was encountered (in UTF-8 mode only)
               or -3 if an OP_RECURSE item was encountered and atend is FALSE
+              or -4 if an unknown opcode was encountered (internal error)
  */
  static int
- find_fixedlength(uschar *code, BOOL utf8, BOOL atend, compile_data *cd)
+ find_fixedlength(pcre_uchar *code, BOOL utf8, BOOL atend, compile_data *cd)
  {
  int length = -1;
  register int branchlength = 0;
- register uschar *cc = code + 1 + LINK_SIZE;
+ register pcre_uchar *cc = code + 1 + LINK_SIZE;
  /* Scan along the opcodes for this branch. If we get to the end of the
  branch, check the length against that of the other branches. */
-Line 1493 
 branch, check the length against that of
+Line 1601 
 branch, check the length against that of
  for (;;)
    {
    int d;
-   uschar *ce, *cs;
+   pcre_uchar *ce, *cs;
    register int op = *cc;
    switch (op)
      {
      /* We only need to continue for OP_CBRA (normal capturing bracket) and
      OP_BRA (normal non-capturing bracket) because the other variants of these
      opcodes are all concerned with unlimited repeated groups, which of course
-     are not of fixed length. They will cause a -1 response from the default
+     are not of fixed length. */
-     case of this switch. */
      case OP_CBRA:
      case OP_BRA:
      case OP_ONCE:
+     case OP_ONCE_NC:
      case OP_COND:
      d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), utf8, atend, cd);
      if (d < 0) return d;
-Line 1514 
 for (;;)
+Line 1622 
 for (;;)
      cc += 1 + LINK_SIZE;
      break;
-     /* Reached end of a branch; if it's a ket it is the end of a nested
+     /* Reached end of a branch; if it's a ket it is the end of a nested call.
-     call. If it's ALT it is an alternation in a nested call. If it is
+     If it's ALT it is an alternation in a nested call. An ACCEPT is effectively
-     END it's the end of the outer call. All can be handled by the same code.
+     an ALT. If it is END it's the end of the outer call. All can be handled by
-     Note that we must not include the OP_KETRxxx opcodes here, because they
+     the same code. Note that we must not include the OP_KETRxxx opcodes here,
-     all imply an unlimited repeat. */
+     because they all imply an unlimited repeat. */
      case OP_ALT:
      case OP_KET:
      case OP_END:
+     case OP_ACCEPT:
+     case OP_ASSERT_ACCEPT:
      if (length < 0) length = branchlength;
        else if (length != branchlength) return -1;
      if (*cc != OP_ALT) return length;
-Line 1536 
 for (;;)
+Line 1646 
 for (;;)
      case OP_RECURSE:
      if (!atend) return -3;
-     cs = ce = (uschar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
+     cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
-     do ce += GET(ce, 1); while (*ce == OP_ALT);       /* End subpattern */
+     do ce += GET(ce, 1); while (*ce == OP_ALT);           /* End subpattern */
-     if (cc > cs && cc < ce) return -1;                /* Recursion */
+     if (cc > cs && cc < ce) return -1;                    /* Recursion */
      d = find_fixedlength(cs + 2, utf8, atend, cd);
      if (d < 0) return d;
      branchlength += d;
-Line 1556 
 for (;;)
+Line 1666 
 for (;;)
      /* Skip over things that don't match chars */
-     case OP_REVERSE:
+     case OP_MARK:
-     case OP_CREF:
+     case OP_PRUNE_ARG:
-     case OP_NCREF:
+     case OP_SKIP_ARG:
-     case OP_RREF:
+     case OP_THEN_ARG:
-     case OP_NRREF:
+     cc += cc[1] + PRIV(OP_lengths)[*cc];
-     case OP_DEF:
+     break;
      case OP_CALLOUT:
-     case OP_SOD:
-     case OP_SOM:
-     case OP_SET_SOM:
-     case OP_EOD:
-     case OP_EODN:
      case OP_CIRC:
      case OP_CIRCM:
+     case OP_CLOSE:
+     case OP_COMMIT:
+     case OP_CREF:
+     case OP_DEF:
      case OP_DOLL:
      case OP_DOLLM:
+     case OP_EOD:
+     case OP_EODN:
+     case OP_FAIL:
+     case OP_NCREF:
+     case OP_NRREF:
      case OP_NOT_WORD_BOUNDARY:
+     case OP_PRUNE:
+     case OP_REVERSE:
+     case OP_RREF:
+     case OP_SET_SOM:
+     case OP_SKIP:
+     case OP_SOD:
+     case OP_SOM:
+     case OP_THEN:
      case OP_WORD_BOUNDARY:
-     cc += _pcre_OP_lengths[*cc];
+     cc += PRIV(OP_lengths)[*cc];
      break;
      /* Handle literal characters */
-Line 1586 
 for (;;)
+Line 1709 
 for (;;)
      branchlength++;
      cc += 2;
  #ifdef SUPPORT_UTF8
-     if (utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+     if (utf8 && cc[-1] >= 0xc0) cc += PRIV(utf8_table4)[cc[-1] & 0x3f];
  #endif
      break;
-Line 1594 
 for (;;)
+Line 1717 
 for (;;)
      need to skip over a multibyte character in UTF8 mode.  */
      case OP_EXACT:
+     case OP_EXACTI:
+     case OP_NOTEXACT:
+     case OP_NOTEXACTI:
      branchlength += GET2(cc,1);
      cc += 4;
  #ifdef SUPPORT_UTF8
-     if (utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
+     if (utf8 && cc[-1] >= 0xc0) cc += PRIV(utf8_table4)[cc[-1] & 0x3f];
  #endif
      break;
-Line 1614 
 for (;;)
+Line 1740 
 for (;;)
      cc += 2;
      /* Fall through */
+     case OP_HSPACE:
+     case OP_VSPACE:
+     case OP_NOT_HSPACE:
+     case OP_NOT_VSPACE:
      case OP_NOT_DIGIT:
      case OP_DIGIT:
      case OP_NOT_WHITESPACE:
-Line 1626 
 for (;;)
+Line 1756 
 for (;;)
      cc++;
      break;
-     /* The single-byte matcher isn't allowed */
+     /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;
+     otherwise \C is coded as OP_ALLANY. */
      case OP_ANYBYTE:
      return -2;
-Line 1645 
 for (;;)
+Line 1776 
 for (;;)
      switch (*cc)
        {
+       case OP_CRPLUS:
+       case OP_CRMINPLUS:
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRQUERY:
-Line 1665 
 for (;;)
+Line 1798 
 for (;;)
      /* Anything else is variable length */
-     default:
+     case OP_ANYNL:
+     case OP_BRAMINZERO:
+     case OP_BRAPOS:
+     case OP_BRAPOSZERO:
+     case OP_BRAZERO:
+     case OP_CBRAPOS:
+     case OP_EXTUNI:
+     case OP_KETRMAX:
+     case OP_KETRMIN:
+     case OP_KETRPOS:
+     case OP_MINPLUS:
+     case OP_MINPLUSI:
+     case OP_MINQUERY:
+     case OP_MINQUERYI:
+     case OP_MINSTAR:
+     case OP_MINSTARI:
+     case OP_MINUPTO:
+     case OP_MINUPTOI:
+     case OP_NOTMINPLUS:
+     case OP_NOTMINPLUSI:
+     case OP_NOTMINQUERY:
+     case OP_NOTMINQUERYI:
+     case OP_NOTMINSTAR:
+     case OP_NOTMINSTARI:
+     case OP_NOTMINUPTO:
+     case OP_NOTMINUPTOI:
+     case OP_NOTPLUS:
+     case OP_NOTPLUSI:
+     case OP_NOTPOSPLUS:
+     case OP_NOTPOSPLUSI:
+     case OP_NOTPOSQUERY:
+     case OP_NOTPOSQUERYI:
+     case OP_NOTPOSSTAR:
+     case OP_NOTPOSSTARI:
+     case OP_NOTPOSUPTO:
+     case OP_NOTPOSUPTOI:
+     case OP_NOTQUERY:
+     case OP_NOTQUERYI:
+     case OP_NOTSTAR:
+     case OP_NOTSTARI:
+     case OP_NOTUPTO:
+     case OP_NOTUPTOI:
+     case OP_PLUS:
+     case OP_PLUSI:
+     case OP_POSPLUS:
+     case OP_POSPLUSI:
+     case OP_POSQUERY:
+     case OP_POSQUERYI:
+     case OP_POSSTAR:
+     case OP_POSSTARI:
+     case OP_POSUPTO:
+     case OP_POSUPTOI:
+     case OP_QUERY:
+     case OP_QUERYI:
+     case OP_REF:
+     case OP_REFI:
+     case OP_SBRA:
+     case OP_SBRAPOS:
+     case OP_SCBRA:
+     case OP_SCBRAPOS:
+     case OP_SCOND:
+     case OP_SKIPZERO:
+     case OP_STAR:
+     case OP_STARI:
+     case OP_TYPEMINPLUS:
+     case OP_TYPEMINQUERY:
+     case OP_TYPEMINSTAR:
+     case OP_TYPEMINUPTO:
+     case OP_TYPEPLUS:
+     case OP_TYPEPOSPLUS:
+     case OP_TYPEPOSQUERY:
+     case OP_TYPEPOSSTAR:
+     case OP_TYPEPOSUPTO:
+     case OP_TYPEQUERY:
+     case OP_TYPESTAR:
+     case OP_TYPEUPTO:
+     case OP_UPTO:
+     case OP_UPTOI:
      return -1;
+     /* Catch unrecognized opcodes so that when new ones are added they
+     are not forgotten, as has happened in the past. */
+     default:
+     return -4;
      }
    }
  /* Control never gets here */
-Line 1693 
 Arguments:
+Line 1909 
 Arguments:
  Returns:      pointer to the opcode for the bracket, or NULL if not found
  */
- const uschar *
+ const pcre_uchar *
- _pcre_find_bracket(const uschar *code, BOOL utf8, int number)
+ PRIV(find_bracket)(const pcre_uchar *code, BOOL utf8, int number)
  {
  for (;;)
    {
-Line 1712 
 for (;;)
+Line 1928 
 for (;;)
    else if (c == OP_REVERSE)
      {
-     if (number < 0) return (uschar *)code;
+     if (number < 0) return (pcre_uchar *)code;
-     code += _pcre_OP_lengths[c];
+     code += PRIV(OP_lengths)[c];
      }
    /* Handle capturing bracket */
-Line 1722 
 for (;;)
+Line 1938 
 for (;;)
             c == OP_CBRAPOS || c == OP_SCBRAPOS)
      {
      int n = GET2(code, 1+LINK_SIZE);
-     if (n == number) return (uschar *)code;
+     if (n == number) return (pcre_uchar *)code;
-     code += _pcre_OP_lengths[c];
+     code += PRIV(OP_lengths)[c];
      }
    /* Otherwise, we can get the item's length from the table, except that for
-Line 1761 
 for (;;)
+Line 1977 
 for (;;)
        break;
        case OP_THEN_ARG:
-       code += code[1+LINK_SIZE];
+       code += code[1];
        break;
        }
      /* Add in the fixed length from the table */
-     code += _pcre_OP_lengths[c];
+     code += PRIV(OP_lengths)[c];
    /* In UTF-8 mode, opcodes that are followed by a character may be followed by
    a multi-byte character. The length in the table is a minimum, so we have to
-Line 1804 
 for (;;)
+Line 2020 
 for (;;)
        case OP_MINQUERYI:
        case OP_POSQUERY:
        case OP_POSQUERYI:
-       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
+       if (code[-1] >= 0xc0) code += PRIV(utf8_table4)[code[-1] & 0x3f];
        break;
        }
  #else
-Line 1830 
 Arguments:
+Line 2046 
 Arguments:
  Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
  */
- static const uschar *
+ static const pcre_uchar *
- find_recurse(const uschar *code, BOOL utf8)
+ find_recurse(const pcre_uchar *code, BOOL utf8)
  {
  for (;;)
    {
-Line 1880 
 for (;;)
+Line 2096 
 for (;;)
        break;
        case OP_THEN_ARG:
-       code += code[1+LINK_SIZE];
+       code += code[1];
        break;
        }
      /* Add in the fixed length from the table */
-     code += _pcre_OP_lengths[c];
+     code += PRIV(OP_lengths)[c];
      /* In UTF-8 mode, opcodes that are followed by a character may be followed
      by a multi-byte character. The length in the table is a minimum, so we have
-Line 1923 
 for (;;)
+Line 2139 
 for (;;)
        case OP_MINQUERYI:
        case OP_POSQUERY:
        case OP_POSQUERYI:
-       if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
+       if (code[-1] >= 0xc0) code += PRIV(utf8_table4)[code[-1] & 0x3f];
        break;
        }
  #else
-Line 1957 
 Returns:      TRUE if what is matched co
+Line 2173 
 Returns:      TRUE if what is matched co
  */
  static BOOL
- could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8,
+ could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
-   compile_data *cd)
+   BOOL utf8, compile_data *cd)
  {
  register int c;
- for (code = first_significant_code(code + _pcre_OP_lengths[*code], TRUE);
+ for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
       code < endcode;
-      code = first_significant_code(code + _pcre_OP_lengths[c], TRUE))
+      code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
    {
-   const uschar *ccode;
+   const pcre_uchar *ccode;
    c = *code;
-Line 1988 
 for (code = first_significant_code(code
+Line 2204 
 for (code = first_significant_code(code
    if (c == OP_RECURSE)
      {
-     const uschar *scode;
+     const pcre_uchar *scode;
      BOOL empty_branch;
      /* Test for forward reference */
-Line 2024 
 for (code = first_significant_code(code
+Line 2240 
 for (code = first_significant_code(code
    if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||
        c == OP_BRAPOSZERO)
      {
-     code += _pcre_OP_lengths[c];
+     code += PRIV(OP_lengths)[c];
      do code += GET(code, 1); while (*code == OP_ALT);
      c = *code;
      continue;
-Line 2045 
 for (code = first_significant_code(code
+Line 2261 
 for (code = first_significant_code(code
    if (c == OP_BRA  || c == OP_BRAPOS ||
        c == OP_CBRA || c == OP_CBRAPOS ||
-       c == OP_ONCE || c == OP_COND)
+       c == OP_ONCE || c == OP_ONCE_NC ||
+       c == OP_COND)
      {
      BOOL empty_branch;
      if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
-Line 2079 
 for (code = first_significant_code(code
+Line 2296 
 for (code = first_significant_code(code
      {
      /* Check for quantifiers after a class. XCLASS is used for classes that
      cannot be represented just by a bit map. This includes negated single
-     high-valued characters. The length in _pcre_OP_lengths[] is zero; the
+     high-valued characters. The length in PRIV(OP_lengths)[] is zero; the
      actual length is stored in the compiled code, so we must update "code"
      here. */
-Line 2194 
 for (code = first_significant_code(code
+Line 2411 
 for (code = first_significant_code(code
      case OP_MINQUERYI:
      case OP_POSQUERY:
      case OP_POSQUERYI:
-     if (utf8 && code[1] >= 0xc0) code += _pcre_utf8_table4[code[1] & 0x3f];
+     if (utf8 && code[1] >= 0xc0) code += PRIV(utf8_table4)[code[1] & 0x3f];
      break;
      case OP_UPTO:
-Line 2203 
 for (code = first_significant_code(code
+Line 2420 
 for (code = first_significant_code(code
      case OP_MINUPTOI:
      case OP_POSUPTO:
      case OP_POSUPTOI:
-     if (utf8 && code[3] >= 0xc0) code += _pcre_utf8_table4[code[3] & 0x3f];
+     if (utf8 && code[3] >= 0xc0) code += PRIV(utf8_table4)[code[3] & 0x3f];
      break;
  #endif
-Line 2217 
 for (code = first_significant_code(code
+Line 2434 
 for (code = first_significant_code(code
      break;
      case OP_THEN_ARG:
-     code += code[1+LINK_SIZE];
+     code += code[1];
      break;
      /* None of the remaining opcodes are required to match a character. */
-Line 2254 
 Returns:      TRUE if what is matched co
+Line 2471 
 Returns:      TRUE if what is matched co
  */
  static BOOL
- could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
+ could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,
-   BOOL utf8, compile_data *cd)
+   branch_chain *bcptr, BOOL utf8, compile_data *cd)
  {
  while (bcptr != NULL && bcptr->current_branch >= code)
    {
-Line 2311 
 Returns:   TRUE or FALSE
+Line 2528 
 Returns:   TRUE or FALSE
  */
  static BOOL
- check_posix_syntax(const uschar *ptr, const uschar **endptr)
+ check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
  {
  int terminator;          /* Don't combine these lines; the Solaris cc */
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
-Line 2355 
 Returns:     a value representing the na
+Line 2572 
 Returns:     a value representing the na
  */
  static int
- check_posix_name(const uschar *ptr, int len)
+ check_posix_name(const pcre_uchar *ptr, int len)
  {
  const char *pn = posix_names;
  register int yield = 0;
  while (posix_name_lengths[yield] != 0)
    {
    if (len == posix_name_lengths[yield] &&
-     strncmp((const char *)ptr, pn, len) == 0) return yield;
+     STRNCMP_UC_C8(ptr, pn, len) == 0) return yield;
    pn += posix_name_lengths[yield] + 1;
    yield++;
    }
-Line 2402 
 Returns:     nothing
+Line 2619 
 Returns:     nothing
  */
  static void
- adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd,
+ adjust_recurse(pcre_uchar *group, int adjust, BOOL utf8, compile_data *cd,
-   uschar *save_hwm)
+   pcre_uchar *save_hwm)
  {
- uschar *ptr = group;
+ pcre_uchar *ptr = group;
- while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
+ while ((ptr = (pcre_uchar *)find_recurse(ptr, utf8)) != NULL)
    {
    int offset;
-   uschar *hc;
+   pcre_uchar *hc;
    /* See if this recursion is on the forward reference list. If so, adjust the
    reference. */
-Line 2455 
 Arguments:
+Line 2672 
 Arguments:
  Returns:         new code pointer
  */
- static uschar *
+ static pcre_uchar *
- auto_callout(uschar *code, const uschar *ptr, compile_data *cd)
+ auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
  {
  *code++ = OP_CALLOUT;
  *code++ = 255;
  PUT(code, 0, (int)(ptr - cd->start_pattern));  /* Pattern offset */
  PUT(code, LINK_SIZE, 0);                       /* Default length */
- return code + 2*LINK_SIZE;
+ return code + 2 * LINK_SIZE;
  }
-Line 2484 
 Returns:             nothing
+Line 2701 
 Returns:             nothing
  */
  static void
- complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
+ complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
  {
  int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
  PUT(previous_callout, 2 + LINK_SIZE, length);
-Line 2567 
 switch(ptype)
+Line 2784 
 switch(ptype)
            prop->chartype == ucp_Lt) == negated;
    case PT_GC:
-   return (pdata == _pcre_ucp_gentype[prop->chartype]) == negated;
+   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
    case PT_PC:
    return (pdata == prop->chartype) == negated;
-Line 2578 
 switch(ptype)
+Line 2795 
 switch(ptype)
    /* These are specials */
    case PT_ALNUM:
-   return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-           _pcre_ucp_gentype[prop->chartype] == ucp_N) == negated;
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
    case PT_SPACE:    /* Perl space */
-   return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
            c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
            == negated;
    case PT_PXSPACE:  /* POSIX space */
-   return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
            c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
            c == CHAR_FF || c == CHAR_CR)
            == negated;
    case PT_WORD:
-   return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-           _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
            c == CHAR_UNDERSCORE) == negated;
    }
  return FALSE;
-Line 2622 
 Returns:        TRUE if possessifying is
+Line 2839 
 Returns:        TRUE if possessifying is
  */
  static BOOL
- check_auto_possessive(const uschar *previous, BOOL utf8, const uschar *ptr,
+ check_auto_possessive(const pcre_uchar *previous, BOOL utf8,
-   int options, compile_data *cd)
+   const pcre_uchar *ptr, int options, compile_data *cd)
  {
  int c, next;
  int op_code = *previous++;
-Line 2698 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2915 
 if ((options & PCRE_EXTENDED) != 0)
  /* If the next thing is itself optional, we have to give up. */
  if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
-   strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+   STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
      return FALSE;
  /* Now compare the next item with the previous opcode. First, handle cases when
-Line 2960 
 switch(op_code)
+Line 3177 
 switch(op_code)
        to the original \d etc. At this point, ptr will point to a zero byte. */
        if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
-         strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+         STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
            return FALSE;
        /* Do the property check. */
-Line 3051 
 Returns:         TRUE on success
+Line 3268 
 Returns:         TRUE on success
  */
  static BOOL
- compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
+ compile_branch(int *optionsptr, pcre_uchar **codeptr,
-   int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
+   const pcre_uchar **ptrptr, int *errorcodeptr, int *firstbyteptr,
-   int cond_depth, compile_data *cd, int *lengthptr)
+   int *reqbyteptr, branch_chain *bcptr, int cond_depth, compile_data *cd,
+   int *lengthptr)
  {
  int repeat_type, op_type;
  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
-Line 3066 
 int options = *optionsptr;
+Line 3284 
 int options = *optionsptr;
  int after_manual_callout = 0;
  int length_prevgroup = 0;
  register int c;
- register uschar *code = *codeptr;
+ register pcre_uchar *code = *codeptr;
- uschar *last_code = code;
+ pcre_uchar *last_code = code;
- uschar *orig_code = code;
+ pcre_uchar *orig_code = code;
- uschar *tempcode;
+ pcre_uchar *tempcode;
  BOOL inescq = FALSE;
  BOOL groupsetfirstbyte = FALSE;
- const uschar *ptr = *ptrptr;
+ const pcre_uchar *ptr = *ptrptr;
- const uschar *tempptr;
+ const pcre_uchar *tempptr;
- const uschar *nestptr = NULL;
+ const pcre_uchar *nestptr = NULL;
- uschar *previous = NULL;
+ pcre_uchar *previous = NULL;
- uschar *previous_callout = NULL;
+ pcre_uchar *previous_callout = NULL;
- uschar *save_hwm = NULL;
+ pcre_uchar *save_hwm = NULL;
- uschar classbits[32];
+ pcre_uchar classbits[32];
  /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
  must not do this for other options (e.g. PCRE_EXTENDED) because they may change
-Line 3087 
 dynamically as we process the pattern. *
+Line 3305 
 dynamically as we process the pattern. *
  #ifdef SUPPORT_UTF8
  BOOL class_utf8;
  BOOL utf8 = (options & PCRE_UTF8) != 0;
- uschar *class_utf8data;
+ pcre_uint8 *class_utf8data;
- uschar *class_utf8data_base;
+ pcre_uint8 *class_utf8data_base;
- uschar utf8_char[6];
+ pcre_uint8 utf8_char[6];
  #else
  BOOL utf8 = FALSE;
  #endif
-Line 3142 
 for (;; ptr++)
+Line 3360 
 for (;; ptr++)
    int subfirstbyte;
    int terminator;
    int mclength;
-   uschar mcbuffer[8];
+   int tempbracount;
+   pcre_uchar mcbuffer[8];
    /* Get next byte in the pattern */
-Line 3189 
 for (;; ptr++)
+Line 3408 
 for (;; ptr++)
        }
      *lengthptr += (int)(code - last_code);
-     DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
+     DPRINTF(("length=%d added %d c=%c\n", *lengthptr, (int)(code - last_code),
+       c));
      /* If "previous" is set and it is not at the start of the work space, move
      it back to there, in order to avoid filling up the work space. Otherwise,
-Line 3397 
 for (;; ptr++)
+Line 3617 
 for (;; ptr++)
          {
          if (ptr[1] == CHAR_E)
            ptr++;
-         else if (strncmp((const char *)ptr+1,
+         else if (STRNCMP_UC_C8(ptr + 1,
                            STR_Q STR_BACKSLASH STR_E, 3) == 0)
            ptr += 3;
          else
-Line 3440 
 for (;; ptr++)
+Line 3660 
 for (;; ptr++)
      than 256), because in that case the compiled code doesn't use the bit map.
      */
-     memset(classbits, 0, 32 * sizeof(uschar));
+     memset(classbits, 0, 32 * sizeof(pcre_uint8));
  #ifdef SUPPORT_UTF8
      class_utf8 = FALSE;                       /* No chars >= 256 */
-Line 3454 
 for (;; ptr++)
+Line 3674 
 for (;; ptr++)
      if (c != 0) do
        {
-       const uschar *oldptr;
+       const pcre_uchar *oldptr;
  #ifdef SUPPORT_UTF8
        if (utf8 && c > 127)
-Line 3500 
 for (;; ptr++)
+Line 3720 
 for (;; ptr++)
          {
          BOOL local_negate = FALSE;
          int posix_class, taboffset, tabopt;
-         register const uschar *cbits = cd->cbits;
+         register const pcre_uint8 *cbits = cd->cbits;
-         uschar pbits[32];
+         pcre_uint8 pbits[32];
          if (ptr[1] != CHAR_COLON)
            {
-Line 3556 
 for (;; ptr++)
+Line 3776 
 for (;; ptr++)
          /* Copy in the first table (always present) */
          memcpy(pbits, cbits + posix_class_maps[posix_class],
-* sizeof(uschar));
+* sizeof(pcre_uint8));
          /* If there is a second table, add or remove it as required. */
-Line 3618 
 for (;; ptr++)
+Line 3838 
 for (;; ptr++)
          if (c < 0)
            {
-           register const uschar *cbits = cd->cbits;
+           register const pcre_uint8 *cbits = cd->cbits;
            class_charcount += 2;     /* Greater than 1 is what matters */
            switch (-c)
-Line 3678 
 for (;; ptr++)
+Line 3898 
 for (;; ptr++)
                {
                class_utf8 = TRUE;
                *class_utf8data++ = XCL_SINGLE;
-               class_utf8data += _pcre_ord2utf8(0x1680, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x1680, class_utf8data);
                *class_utf8data++ = XCL_SINGLE;
-               class_utf8data += _pcre_ord2utf8(0x180e, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x180e, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x2000, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2000, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x200A, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x200A, class_utf8data);
                *class_utf8data++ = XCL_SINGLE;
-               class_utf8data += _pcre_ord2utf8(0x202f, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x202f, class_utf8data);
                *class_utf8data++ = XCL_SINGLE;
-               class_utf8data += _pcre_ord2utf8(0x205f, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x205f, class_utf8data);
                *class_utf8data++ = XCL_SINGLE;
-               class_utf8data += _pcre_ord2utf8(0x3000, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x3000, class_utf8data);
                }
  #endif
              continue;
-Line 3713 
 for (;; ptr++)
+Line 3933 
 for (;; ptr++)
                {
                class_utf8 = TRUE;
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x0100, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x167f, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x167f, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x1681, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x1681, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x180d, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x180d, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x180f, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x180f, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x1fff, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x1fff, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x200B, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x200B, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x202e, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x202e, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x2030, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2030, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x205e, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x205e, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x2060, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2060, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x2fff, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2fff, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x3001, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x3001, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x7fffffff, class_utf8data);
                }
  #endif
              continue;
-Line 3748 
 for (;; ptr++)
+Line 3968 
 for (;; ptr++)
                {
                class_utf8 = TRUE;
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x2028, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2028, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2029, class_utf8data);
                }
  #endif
              continue;
-Line 3776 
 for (;; ptr++)
+Line 3996 
 for (;; ptr++)
                {
                class_utf8 = TRUE;
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x0100, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x2027, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2027, class_utf8data);
                *class_utf8data++ = XCL_RANGE;
-               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x2029, class_utf8data);
-               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(0x7fffffff, class_utf8data);
                }
  #endif
              continue;
-Line 3958 
 for (;; ptr++)
+Line 4178 
 for (;; ptr++)
                else
                  {
                  *class_utf8data++ = XCL_RANGE;
-                 class_utf8data += _pcre_ord2utf8(occ, class_utf8data);
+                 class_utf8data += PRIV(ord2utf8)(occ, class_utf8data);
                  }
-               class_utf8data += _pcre_ord2utf8(ocd, class_utf8data);
+               class_utf8data += PRIV(ord2utf8)(ocd, class_utf8data);
                }
              }
  #endif  /* SUPPORT_UCP */
-Line 3969 
 for (;; ptr++)
+Line 4189 
 for (;; ptr++)
            overlapping ranges. */
            *class_utf8data++ = XCL_RANGE;
-           class_utf8data += _pcre_ord2utf8(c, class_utf8data);
+           class_utf8data += PRIV(ord2utf8)(c, class_utf8data);
-           class_utf8data += _pcre_ord2utf8(d, class_utf8data);
+           class_utf8data += PRIV(ord2utf8)(d, class_utf8data);
            /* With UCP support, we are done. Without UCP support, there is no
            caseless matching for UTF-8 characters > 127; we can use the bit map
-Line 4024 
 for (;; ptr++)
+Line 4244 
 for (;; ptr++)
          {
          class_utf8 = TRUE;
          *class_utf8data++ = XCL_SINGLE;
-         class_utf8data += _pcre_ord2utf8(c, class_utf8data);
+         class_utf8data += PRIV(ord2utf8)(c, class_utf8data);
  #ifdef SUPPORT_UCP
          if ((options & PCRE_CASELESS) != 0)
-Line 4033 
 for (;; ptr++)
+Line 4253 
 for (;; ptr++)
            if ((othercase = UCD_OTHERCASE(c)) != c)
              {
              *class_utf8data++ = XCL_SINGLE;
-             class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
+             class_utf8data += PRIV(ord2utf8)(othercase, class_utf8data);
              }
            }
  #endif  /* SUPPORT_UCP */
-Line 4114 
 for (;; ptr++)
+Line 4334 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
        if (utf8 && class_lastchar > 127)
-         mclength = _pcre_ord2utf8(class_lastchar, mcbuffer);
+         mclength = PRIV(ord2utf8)(class_lastchar, mcbuffer);
        else
  #endif
          {
-Line 4261 
 for (;; ptr++)
+Line 4481 
 for (;; ptr++)
      past, but it no longer happens for non-repeated recursions. In fact, the
      repeated ones could be re-implemented independently so as not to need this,
      but for the moment we rely on the code for repeating groups. */
      if (*previous == OP_RECURSE)
        {
        memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
-Line 4303 
 for (;; ptr++)
+Line 4523 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
        if (utf8 && (code[-1] & 0x80) != 0)
          {
-         uschar *lastchar = code - 1;
+         pcre_uchar *lastchar = code - 1;
          while((*lastchar & 0xc0) == 0x80) lastchar--;
          c = code - lastchar;            /* Length of UTF-8 character */
          memcpy(utf8_char, lastchar, c); /* Save the char */
-Line 4365 
 for (;; ptr++)
+Line 4585 
 for (;; ptr++)
      else if (*previous < OP_EODN)
        {
-       uschar *oldcode;
+       pcre_uchar *oldcode;
        int prop_type, prop_value;
        op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
        c = *previous;
-Line 4587 
 for (;; ptr++)
+Line 4807 
 for (;; ptr++)
        {
        register int i;
        int len = (int)(code - previous);
-       uschar *bralink = NULL;
+       pcre_uchar *bralink = NULL;
-       uschar *brazeroptr = NULL;
+       pcre_uchar *brazeroptr = NULL;
        /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so
        we just ignore the repeat. */
-Line 4719 
 for (;; ptr++)
+Line 4939 
 for (;; ptr++)
              if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
              for (i = 1; i < repeat_min; i++)
                {
-               uschar *hc;
+               pcre_uchar *hc;
-               uschar *this_hwm = cd->hwm;
+               pcre_uchar *this_hwm = cd->hwm;
                memcpy(code, previous, len);
                for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
                  {
-Line 4771 
 for (;; ptr++)
+Line 4991 
 for (;; ptr++)
          else for (i = repeat_max - 1; i >= 0; i--)
            {
-           uschar *hc;
+           pcre_uchar *hc;
-           uschar *this_hwm = cd->hwm;
+           pcre_uchar *this_hwm = cd->hwm;
            *code++ = OP_BRAZERO + repeat_type;
-Line 4805 
 for (;; ptr++)
+Line 5025 
 for (;; ptr++)
            {
            int oldlinkoffset;
            int offset = (int)(code - bralink + 1);
-           uschar *bra = code - offset;
+           pcre_uchar *bra = code - offset;
            oldlinkoffset = GET(bra, 1);
            bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
            *code++ = OP_KET;
-Line 4819 
 for (;; ptr++)
+Line 5039 
 for (;; ptr++)
        ONCE brackets can be converted into non-capturing brackets, as the
        behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
        deal with possessive ONCEs specially.
-       Otherwise, if the quantifier was possessive, we convert the BRA code to
+       Otherwise, when we are doing the actual compile phase, check to see
-       the POS form, and the KET code to KETRPOS. (It turns out to be convenient
+       whether this group is one that could match an empty string. If so,
-       at runtime to detect this kind of subpattern at both the start and at the
+       convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
-       end.) The use of special opcodes makes it possible to reduce greatly the
+       that runtime checking can be done. [This check is also applied to ONCE
-       stack usage in pcre_exec(). If the group is preceded by OP_BRAZERO,
+       groups at runtime, but in a different way.]
-       convert this to OP_BRAPOSZERO. Then cancel the possessive flag so that
-       the default action below, of wrapping everything inside atomic brackets,
+       Then, if the quantifier was possessive and the bracket is not a
-       does not happen.
+       conditional, we convert the BRA code to the POS form, and the KET code to
+       KETRPOS. (It turns out to be convenient at runtime to detect this kind of
-       Then, when we are doing the actual compile phase, check to see whether
+       subpattern at both the start and at the end.) The use of special opcodes
-       this group is one that could match an empty string. If so, convert the
+       makes it possible to reduce greatly the stack usage in pcre_exec(). If
-       initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so that runtime
+       the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
-       checking can be done. [This check is also applied to ONCE groups at
-       runtime, but in a different way.] */
+       Then, if the minimum number of matches is 1 or 0, cancel the possessive
+       flag so that the default action below, of wrapping everything inside
+       atomic brackets, does not happen. When the minimum is greater than 1,
+       there will be earlier copies of the group, and so we still have to wrap
+       the whole thing. */
        else
          {
-         uschar *ketcode = code - 1 - LINK_SIZE;
+         pcre_uchar *ketcode = code - 1 - LINK_SIZE;
-         uschar *bracode = ketcode - GET(ketcode, 1);
+         pcre_uchar *bracode = ketcode - GET(ketcode, 1);
-         if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;
+         /* Convert possessive ONCE brackets to non-capturing */
-         if (*bracode == OP_ONCE)
+         if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&
+             possessive_quantifier) *bracode = OP_BRA;
+         /* For non-possessive ONCE brackets, all we need to do is to
+         set the KET. */
+         if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)
            *ketcode = OP_KETRMAX + repeat_type;
+         /* Handle non-ONCE brackets and possessive ONCEs (which have been
+         converted to non-capturing above). */
          else
            {
-           if (possessive_quantifier)
+           /* In the compile phase, check for empty string matching. */
-             {
-             *bracode += 1;                   /* Switch to xxxPOS opcodes */
-             *ketcode = OP_KETRPOS;
-             if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
-             possessive_quantifier = FALSE;
-             }
-           else *ketcode = OP_KETRMAX + repeat_type;
            if (lengthptr == NULL)
              {
-             uschar *scode = bracode;
+             pcre_uchar *scode = bracode;
              do
                {
                if (could_be_empty_branch(scode, ketcode, utf8, cd))
-Line 4868 
 for (;; ptr++)
+Line 5096 
 for (;; ptr++)
                }
              while (*scode == OP_ALT);
              }
+           /* Handle possessive quantifiers. */
+           if (possessive_quantifier)
+             {
+             /* For COND brackets, we wrap the whole thing in a possessively
+             repeated non-capturing bracket, because we have not invented POS
+             versions of the COND opcodes. Because we are moving code along, we
+             must ensure that any pending recursive references are updated. */
+             if (*bracode == OP_COND || *bracode == OP_SCOND)
+               {
+               int nlen = (int)(code - bracode);
+               *code = OP_END;
+               adjust_recurse(bracode, 1 + LINK_SIZE, utf8, cd, save_hwm);
+               memmove(bracode + 1+LINK_SIZE, bracode, nlen);
+               code += 1 + LINK_SIZE;
+               nlen += 1 + LINK_SIZE;
+               *bracode = OP_BRAPOS;
+               *code++ = OP_KETRPOS;
+               PUTINC(code, 0, nlen);
+               PUT(bracode, 1, nlen);
+               }
+             /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
+             else
+               {
+               *bracode += 1;              /* Switch to xxxPOS opcodes */
+               *ketcode = OP_KETRPOS;
+               }
+             /* If the minimum is zero, mark it as possessive, then unset the
+             possessive flag when the minimum is 0 or 1. */
+             if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
+             if (repeat_min < 2) possessive_quantifier = FALSE;
+             }
+           /* Non-possessive quantifier */
+           else *ketcode = OP_KETRMAX + repeat_type;
            }
          }
        }
-Line 4894 
 for (;; ptr++)
+Line 5164 
 for (;; ptr++)
      notation is just syntactic sugar, taken from Sun's Java package, but the
      special opcodes can optimize it.
-     Possessively repeated subpatterns have already been handled in the code
+     Some (but not all) possessively repeated subpatterns have already been
-     just above, so possessive_quantifier is always FALSE for them at this
+     completely handled in the code just above. For them, possessive_quantifier
-     stage.
+     is always FALSE at this stage.
      Note that the repeated item starts at tempcode, not at previous, which
      might be the first part of a string whose (former) last char we repeated.
-Line 4910 
 for (;; ptr++)
+Line 5180 
 for (;; ptr++)
        int len;
        if (*tempcode == OP_TYPEEXACT)
-         tempcode += _pcre_OP_lengths[*tempcode] +
+         tempcode += PRIV(OP_lengths)[*tempcode] +
            ((tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP)? 2 : 0);
        else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
          {
-         tempcode += _pcre_OP_lengths[*tempcode];
+         tempcode += PRIV(OP_lengths)[*tempcode];
  #ifdef SUPPORT_UTF8
          if (utf8 && tempcode[-1] >= 0xc0)
-           tempcode += _pcre_utf8_table4[tempcode[-1] & 0x3f];
+           tempcode += PRIV(utf8_table4)[tempcode[-1] & 0x3f];
  #endif
          }
-Line 4997 
 for (;; ptr++)
+Line 5267 
 for (;; ptr++)
        int i, namelen;
        int arglen = 0;
        const char *vn = verbnames;
-       const uschar *name = ptr + 1;
+       const pcre_uchar *name = ptr + 1;
-       const uschar *arg = NULL;
+       const pcre_uchar *arg = NULL;
        previous = NULL;
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
        namelen = (int)(ptr - name);
-Line 5025 
 for (;; ptr++)
+Line 5295 
 for (;; ptr++)
        for (i = 0; i < verbcount; i++)
          {
          if (namelen == verbs[i].len &&
-             strncmp((char *)name, vn, namelen) == 0)
+             STRNCMP_UC_C8(name, vn, namelen) == 0)
            {
            /* Check for open captures before ACCEPT and convert it to
            ASSERT_ACCEPT if in an assertion. */
-Line 5045 
 for (;; ptr++)
+Line 5315 
 for (;; ptr++)
                PUT2INC(code, 0, oc->number);
                }
              *code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
+             /* Do not set firstbyte after *ACCEPT */
+             if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
              }
            /* Handle other cases with/without an argument */
-Line 5057 
 for (;; ptr++)
+Line 5330 
 for (;; ptr++)
                goto FAILED;
                }
              *code = verbs[i].op;
-             if (*code++ == OP_THEN)
+             if (*code++ == OP_THEN) cd->external_flags |= PCRE_HASTHEN;
-               {
-               PUT(code, 0, code - bcptr->current_branch - 1);
-               code += LINK_SIZE;
-               }
              }
            else
-Line 5072 
 for (;; ptr++)
+Line 5341 
 for (;; ptr++)
                goto FAILED;
                }
              *code = verbs[i].op_arg;
-             if (*code++ == OP_THEN_ARG)
+             if (*code++ == OP_THEN_ARG) cd->external_flags |= PCRE_HASTHEN;
-               {
-               PUT(code, 0, code - bcptr->current_branch - 1);
-               code += LINK_SIZE;
-               }
              *code++ = arglen;
              memcpy(code, arg, arglen);
              code += arglen;
-Line 5101 
 for (;; ptr++)
+Line 5366 
 for (;; ptr++)
        {
        int i, set, unset, namelen;
        int *optset;
-       const uschar *name;
+       const pcre_uchar *name;
-       uschar *slot;
+       pcre_uchar *slot;
        switch (*(++ptr))
          {
-Line 5254 
 for (;; ptr++)
+Line 5519 
 for (;; ptr++)
          slot = cd->name_table;
          for (i = 0; i < cd->names_found; i++)
            {
-           if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
+           if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0) break;
            slot += cd->name_entry_size;
            }
-Line 5311 
 for (;; ptr++)
+Line 5576 
 for (;; ptr++)
          /* Similarly, check for the (?(DEFINE) "condition", which is always
          false. */
-         else if (namelen == 6 && strncmp((char *)name, STRING_DEFINE, 6) == 0)
+         else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)
            {
            code[1+LINK_SIZE] = OP_DEF;
            skipbytes = 1;
-Line 5391 
 for (;; ptr++)
+Line 5656 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
          case CHAR_C:                 /* Callout - may be followed by digits; */
-         previous_callout = code;  /* Save for later completion */
+         previous_callout = code;     /* Save for later completion */
-         after_manual_callout = 1; /* Skip one item before completing */
+         after_manual_callout = 1;    /* Skip one item before completing */
          *code++ = OP_CALLOUT;
            {
            int n = 0;
-Line 5528 
 for (;; ptr++)
+Line 5793 
 for (;; ptr++)
              if (!dupname)
                {
-               uschar *cslot = cd->name_table;
+               pcre_uchar *cslot = cd->name_table;
                for (i = 0; i < cd->names_found; i++)
                  {
                  if (cslot != slot)
-Line 5584 
 for (;; ptr++)
+Line 5849 
 for (;; ptr++)
          if (lengthptr != NULL)
            {
-           const uschar *temp;
+           const pcre_uchar *temp;
            if (namelen == 0)
              {
-Line 5629 
 for (;; ptr++)
+Line 5894 
 for (;; ptr++)
            slot = cd->name_table;
            for (i = 0; i < cd->names_found; i++)
              {
-             if (strncmp((char *)name, (char *)slot+2, namelen) == 0 &&
+             if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&
                  slot[2+namelen] == 0)
                break;
              slot += cd->name_entry_size;
-Line 5666 
 for (;; ptr++)
+Line 5931 
 for (;; ptr++)
          case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
          case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
            {
-           const uschar *called;
+           const pcre_uchar *called;
            terminator = CHAR_RIGHT_PARENTHESIS;
            /* Come here from the \g<...> and \g'...' code (Oniguruma
-Line 5745 
 for (;; ptr++)
+Line 6010 
 for (;; ptr++)
              {
              *code = OP_END;
              if (recno != 0)
-               called = _pcre_find_bracket(cd->start_code, utf8, recno);
+               called = PRIV(find_bracket)(cd->start_code, utf8, recno);
              /* Forward reference */
-Line 5911 
 for (;; ptr++)
+Line 6176 
 for (;; ptr++)
      *code = bravalue;
      tempcode = code;
      tempreqvary = cd->req_varyopt;        /* Save value before bracket */
+     tempbracount = cd->bracount;          /* Save value before bracket */
      length_prevgroup = 0;                 /* Initialize for pre-compile phase */
      if (!compile_regex(
-Line 5933 
 for (;; ptr++)
+Line 6199 
 for (;; ptr++)
           ))
        goto FAILED;
+     /* If this was an atomic group and there are no capturing groups within it,
+     generate OP_ONCE_NC instead of OP_ONCE. */
+     if (bravalue == OP_ONCE && cd->bracount <= tempbracount)
+       *code = OP_ONCE_NC;
      if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
        cd->assert_depth -= 1;
      /* At the end of compiling, code is still pointing to the start of the
-     group, while tempcode has been updated to point past the end of the group
+     group, while tempcode has been updated to point past the end of the group.
-     and any option resetting that may follow it. The pattern pointer (ptr)
+     The pattern pointer (ptr) is on the bracket.
-     is on the bracket. */
-     /* If this is a conditional bracket, check that there are no more than
+     If this is a conditional bracket, check that there are no more than
      two branches in the group, or just one if it's a DEFINE group. We do this
      in the real compile phase, not in the pre-pass, where the whole group may
      not be available. */
      if (bravalue == OP_COND && lengthptr == NULL)
        {
-       uschar *tc = code;
+       pcre_uchar *tc = code;
        int condcount = 0;
        do {
-Line 6123 
 for (;; ptr++)
+Line 6394 
 for (;; ptr++)
        if (-c == ESC_g)
          {
-         const uschar *p;
+         const pcre_uchar *p;
          save_hwm = cd->hwm;   /* Normally this is set when '(' is read */
          terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
            CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
-Line 6263 
 for (;; ptr++)
+Line 6534 
 for (;; ptr++)
            }
          else
  #endif
-           {
+         /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE
+         so that it works in DFA mode and in lookbehinds. */
+           {
            previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
-           *code++ = -c;
+           *code++ = (!utf8 && c == -ESC_C)? OP_ALLANY : -c;
            }
          }
        continue;
-Line 6277 
 for (;; ptr++)
+Line 6551 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
      if (utf8 && c > 127)
-       mclength = _pcre_ord2utf8(c, mcbuffer);
+       mclength = PRIV(ord2utf8)(c, mcbuffer);
      else
  #endif
-Line 6340 
 for (;; ptr++)
+Line 6614 
 for (;; ptr++)
        else firstbyte = reqbyte = REQ_NONE;
        }
-     /* firstbyte was previously set; we can set reqbyte only the length is
+     /* firstbyte was previously set; we can set reqbyte only if the length is
 or the matching is caseful. */
      else
-Line 6399 
 Returns:         TRUE on success
+Line 6673 
 Returns:         TRUE on success
  */
  static BOOL
- compile_regex(int options, uschar **codeptr, const uschar **ptrptr,
+ compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,
    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
    int cond_depth, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
    compile_data *cd, int *lengthptr)
  {
- const uschar *ptr = *ptrptr;
+ const pcre_uchar *ptr = *ptrptr;
- uschar *code = *codeptr;
+ pcre_uchar *code = *codeptr;
- uschar *last_branch = code;
+ pcre_uchar *last_branch = code;
- uschar *start_bracket = code;
+ pcre_uchar *start_bracket = code;
- uschar *reverse_count = NULL;
+ pcre_uchar *reverse_count = NULL;
  open_capitem capitem;
  int capnumber = 0;
  int firstbyte, reqbyte;
-Line 6557 
 for (;;)
+Line 6831 
 for (;;)
          }
        else if (fixed_length < 0)
          {
-         *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;
+         *errorcodeptr = (fixed_length == -2)? ERR36 :
+                         (fixed_length == -4)? ERR70: ERR25;
          *ptrptr = ptr;
          return FALSE;
          }
-Line 6704 
 Returns:     TRUE or FALSE
+Line 6979 
 Returns:     TRUE or FALSE
  */
  static BOOL
- is_anchored(register const uschar *code, unsigned int bracket_map,
+ is_anchored(register const pcre_uchar *code, unsigned int bracket_map,
    unsigned int backref_map)
  {
  do {
-    const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
+    const pcre_uchar *scode = first_significant_code(
-      FALSE);
+      code + PRIV(OP_lengths)[*code], FALSE);
     register int op = *scode;
     /* Non-capturing brackets */
-Line 6732 
 do {
+Line 7007 
 do {
     /* Other brackets */
-    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
+    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC ||
+             op == OP_COND)
       {
       if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;
       }
-Line 6780 
 Returns:         TRUE or FALSE
+Line 7056 
 Returns:         TRUE or FALSE
  */
  static BOOL
- is_startline(const uschar *code, unsigned int bracket_map,
+ is_startline(const pcre_uchar *code, unsigned int bracket_map,
    unsigned int backref_map)
  {
  do {
-    const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
+    const pcre_uchar *scode = first_significant_code(
-      FALSE);
+      code + PRIV(OP_lengths)[*code], FALSE);
     register int op = *scode;
     /* If we are at the start of a conditional assertion group, *both* the
-Line 6796 
 do {
+Line 7072 
 do {
     if (op == OP_COND)
       {
       scode += 1 + LINK_SIZE;
-      if (*scode == OP_CALLOUT) scode += _pcre_OP_lengths[OP_CALLOUT];
+      if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
       switch (*scode)
         {
         case OP_CREF:
-Line 6836 
 do {
+Line 7112 
 do {
     /* Other brackets */
-    else if (op == OP_ASSERT || op == OP_ONCE)
+    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC)
       {
       if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
       }
-Line 6883 
 Returns:     -1 or the fixed first char
+Line 7159 
 Returns:     -1 or the fixed first char
  */
  static int
- find_firstassertedchar(const uschar *code, BOOL inassert)
+ find_firstassertedchar(const pcre_uchar *code, BOOL inassert)
  {
  register int c = -1;
  do {
     int d;
     int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
               *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? 2:0;
-    const uschar *scode = first_significant_code(code + 1+LINK_SIZE + xl, TRUE);
+    const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,
+      TRUE);
     register int op = *scode;
     switch(op)
-Line 6906 
 do {
+Line 7183 
 do {
       case OP_SCBRAPOS:
       case OP_ASSERT:
       case OP_ONCE:
+      case OP_ONCE_NC:
       case OP_COND:
       if ((d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0)
         return -1;
-Line 6969 
 Returns:        pointer to compiled data
+Line 7247 
 Returns:        pointer to compiled data
                  with errorptr and erroroffset set
  */
+ #ifndef COMPILE_PCRE16
  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
+ #else
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
+ pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,
+   int *erroroffset, const unsigned char *tables)
+ #endif
  {
+ #ifndef COMPILE_PCRE16
  return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+ #else
+ return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+ #endif
  }
+ #ifndef COMPILE_PCRE16
  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile2(const char *pattern, int options, int *errorcodeptr,
    const char **errorptr, int *erroroffset, const unsigned char *tables)
+ #else
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
+ pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,
+   const char **errorptr, int *erroroffset, const unsigned char *tables)
+ #endif
  {
  real_pcre *re;
  int length = 1;  /* For final END opcode */
-Line 6988 
 int errorcode = 0;
+Line 7282 
 int errorcode = 0;
  int skipatstart = 0;
  BOOL utf8;
  size_t size;
- uschar *code;
+ pcre_uchar *code;
- const uschar *codestart;
+ const pcre_uchar *codestart;
- const uschar *ptr;
+ const pcre_uchar *ptr;
  compile_data compile_block;
  compile_data *cd = &compile_block;
-Line 7000 
 as soon as possible, so that a fairly la
+Line 7294 
 as soon as possible, so that a fairly la
  this purpose. The same space is used in the second phase for remembering where
  to fill in forward references to subpatterns. */
- uschar cworkspace[COMPILE_WORK_SIZE];
+ pcre_uchar cworkspace[COMPILE_WORK_SIZE];
  /* Set this early so that early errors get offset 0. */
- ptr = (const uschar *)pattern;
+ ptr = (const pcre_uchar *)pattern;
  /* We can't pass back an error message if errorptr is NULL; I guess the best we
  can do is just return NULL, but we can set a code value if there is a code
-Line 7031 
 if (erroroffset == NULL)
+Line 7325 
 if (erroroffset == NULL)
  /* Set up pointers to the individual character tables */
- if (tables == NULL) tables = _pcre_default_tables;
+ if (tables == NULL) tables = PRIV(default_tables);
  cd->lcc = tables + lcc_offset;
  cd->fcc = tables + fcc_offset;
  cd->cbits = tables + cbits_offset;
-Line 7054 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 7348 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    int newnl = 0;
    int newbsr = 0;
-   if (strncmp((char *)(ptr+skipatstart+2), STRING_UTF8_RIGHTPAR, 5) == 0)
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)
      { skipatstart += 7; options |= PCRE_UTF8; continue; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_UCP_RIGHTPAR, 4) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)
      { skipatstart += 6; options |= PCRE_UCP; continue; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
      { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }
-   if (strncmp((char *)(ptr+skipatstart+2), STRING_CR_RIGHTPAR, 3) == 0)
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)
      { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_LF_RIGHTPAR, 3)  == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3)  == 0)
      { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_CRLF_RIGHTPAR, 5)  == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5)  == 0)
      { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANY_RIGHTPAR, 4) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)
      { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANYCRLF_RIGHTPAR, 8) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)
      { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
      { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
      { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }
    if (newnl != 0)
-Line 7087 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 7381 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
  utf8 = (options & PCRE_UTF8) != 0;
  /* Can't support UTF8 unless PCRE has been compiled to include the code. The
- return of an error code from _pcre_valid_utf8() is a new feature, introduced in
+ return of an error code from PRIV(valid_utf8)() is a new feature, introduced in
  release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
  not used here. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
-      (errorcode = _pcre_valid_utf8((USPTR)pattern, -1, erroroffset)) != 0)
+      (errorcode = PRIV(valid_utf8)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)
    {
    errorcode = ERR44;
    goto PCRE_EARLY_ERROR_RETURN2;
-Line 7191 
 cd->name_table = NULL;
+Line 7485 
 cd->name_table = NULL;
  cd->start_workspace = cworkspace;
  cd->start_code = cworkspace;
  cd->hwm = cworkspace;
- cd->start_pattern = (const uschar *)pattern;
+ cd->start_pattern = (const pcre_uchar *)pattern;
- cd->end_pattern = (const uschar *)(pattern + strlen(pattern));
+ cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC(pattern));
  cd->req_varyopt = 0;
  cd->external_options = options;
  cd->external_flags = 0;
-Line 7251 
 re->name_table_offset = sizeof(real_pcre
+Line 7545 
 re->name_table_offset = sizeof(real_pcre
  re->name_entry_size = cd->name_entry_size;
  re->name_count = cd->names_found;
  re->ref_count = 0;
- re->tables = (tables == _pcre_default_tables)? NULL : tables;
+ re->tables = (tables == PRIV(default_tables))? NULL : tables;
  re->nullpad = NULL;
  /* The starting points of the name/number translation table and of the code are
-Line 7265 
 cd->final_bracount = cd->bracount;  /* S
+Line 7559 
 cd->final_bracount = cd->bracount;  /* S
  cd->assert_depth = 0;
  cd->bracount = 0;
  cd->names_found = 0;
- cd->name_table = (uschar *)re + re->name_table_offset;
+ cd->name_table = (pcre_uchar *)re + re->name_table_offset;
  codestart = cd->name_table + re->name_entry_size * re->name_count;
  cd->start_code = codestart;
  cd->hwm = cworkspace;
-Line 7278 
 cd->open_caps = NULL;
+Line 7572 
 cd->open_caps = NULL;
  error, errorcode will be set non-zero, so we don't need to look at the result
  of the function here. */
- ptr = (const uschar *)pattern + skipatstart;
+ ptr = (const pcre_uchar *)pattern + skipatstart;
- code = (uschar *)codestart;
+ code = (pcre_uchar *)codestart;
  *code = OP_BRA;
  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
    &firstbyte, &reqbyte, NULL, cd, NULL);
-Line 7287 
 re->top_bracket = cd->bracount;
+Line 7581 
 re->top_bracket = cd->bracount;
  re->top_backref = cd->top_backref;
  re->flags = cd->external_flags;
- if (cd->had_accept) reqbyte = -1;   /* Must disable after (*ACCEPT) */
+ if (cd->had_accept) reqbyte = REQ_NONE;   /* Must disable after (*ACCEPT) */
  /* If not reached end of pattern on success, there's an excess bracket. */
-Line 7307 
 if (code - codestart > length) errorcode
+Line 7601 
 if (code - codestart > length) errorcode
  while (errorcode == 0 && cd->hwm > cworkspace)
    {
    int offset, recno;
-   const uschar *groupptr;
+   const pcre_uchar *groupptr;
    cd->hwm -= LINK_SIZE;
    offset = GET(cd->hwm, 0);
    recno = GET(codestart, offset);
-   groupptr = _pcre_find_bracket(codestart, utf8, recno);
+   groupptr = PRIV(find_bracket)(codestart, utf8, recno);
    if (groupptr == NULL) errorcode = ERR53;
-     else PUT(((uschar *)codestart), offset, (int)(groupptr - codestart));
+     else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));
    }
  /* Give an error if there's back reference to a non-existent capturing
-Line 7331 
 length, and set their lengths. */
+Line 7625 
 length, and set their lengths. */
  if (cd->check_lookbehind)
    {
-   uschar *cc = (uschar *)codestart;
+   pcre_uchar *cc = (pcre_uchar *)codestart;
    /* Loop, searching for OP_REVERSE items, and process those that do not have
    their length set. (Actually, it will also re-process any that have a length
    of zero, but that is a pathological case, and it does no harm.) When we find
    one, we temporarily terminate the branch it is in while we scan it. */
-   for (cc = (uschar *)_pcre_find_bracket(codestart, utf8, -1);
+   for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf8, -1);
         cc != NULL;
-        cc = (uschar *)_pcre_find_bracket(cc, utf8, -1))
+        cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf8, -1))
      {
      if (GET(cc, 1) == 0)
        {
        int fixed_length;
-       uschar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
+       pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
        int end_op = *be;
        *be = OP_END;
        fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,
-Line 7354 
 if (cd->check_lookbehind)
+Line 7648 
 if (cd->check_lookbehind)
        DPRINTF(("fixed length = %d\n", fixed_length));
        if (fixed_length < 0)
          {
-         errorcode = (fixed_length == -2)? ERR36 : ERR25;
+         errorcode = (fixed_length == -2)? ERR36 :
+                     (fixed_length == -4)? ERR70 : ERR25;
          break;
          }
        PUT(cc, 1, fixed_length);
-Line 7369 
 if (errorcode != 0)
+Line 7664 
 if (errorcode != 0)
    {
    (pcre_free)(re);
    PCRE_EARLY_ERROR_RETURN:
-   *erroroffset = (int)(ptr - (const uschar *)pattern);
+   *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);
    PCRE_EARLY_ERROR_RETURN2:
    *errorptr = find_error_text(errorcode);
    if (errorcodeptr != NULL) *errorcodeptr = errorcode;
-Line 7455 
 if (code - codestart > length)
+Line 7750 
 if (code - codestart > length)
    {
    (pcre_free)(re);
    *errorptr = find_error_text(ERR23);
-   *erroroffset = ptr - (uschar *)pattern;
+   *erroroffset = ptr - (pcre_uchar *)pattern;
    if (errorcodeptr != NULL) *errorcodeptr = ERR23;
    return NULL;
    }

 Legend:



Removed from v.691
 


changed lines


 
Added in v.764
 Legend:



Removed from v.691
 


changed lines


 
Added in v.764
-Removed from v.691
+Added in v.764

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12