OK = category == code[2];          break;          case PT_PC:          OK = chartype == code[2];          break;          case PT_SC:          OK = script == code[2];          break;          /* Should never occur, but keep compilers from grumbling. */          default:          OK = codevalue != OP_PROP;          break;          }        if (OK == (codevalue == OP_PROP)) { ADD_NEW(state_offset + 3, 0); }        }      break;#endif/* ========================================================================== */      /* These opcodes likewise inspect the subject character, but have an      argument that is not a data character. It is one of these opcodes:      OP_ANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE, OP_WORDCHAR,      OP_NOT_WORDCHAR. The value is loaded into d. */      case OP_TYPEPLUS:      case OP_TYPEMINPLUS:      case OP_TYPEPOSPLUS:      count = current_state->count;  /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }      if (clen > 0)        {        if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||            (c < 256 &&              (d != OP_ANY ||               (ims & PCRE_DOTALL) != 0 ||               !IS_NEWLINE(ptr)              ) &&              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))          {          if (count > 0 && codevalue == OP_TYPEPOSPLUS)            {            active_count--;            /* Remove non-match possibility */            next_active_state--;            }          count++;          ADD_NEW(state_offset, count);          }        }      break;      /*-----------------------------------------------------------------*/      case OP_TYPEQUERY:      case OP_TYPEMINQUERY:      case OP_TYPEPOSQUERY:      ADD_ACTIVE(state_offset + 2, 0);      if (clen > 0)        {        if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||            (c < 256 &&              (d != OP_ANY ||               (ims & PCRE_DOTALL) != 0 ||               !IS_NEWLINE(ptr)              ) &&              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))          {          if (codevalue == OP_TYPEPOSQUERY)            {            active_count--;            /* Remove non-match possibility */            next_active_state--;            }          ADD_NEW(state_offset + 2, 0);          }        }      break;      /*-----------------------------------------------------------------*/      case OP_TYPESTAR:      case OP_TYPEMINSTAR:      case OP_TYPEPOSSTAR:      ADD_ACTIVE(state_offset + 2, 0);      if (clen > 0)        {        if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||            (c < 256 &&              (d != OP_ANY ||               (ims & PCRE_DOTALL) != 0 ||               !IS_NEWLINE(ptr)              ) &&              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))          {          if (codevalue == OP_TYPEPOSSTAR)            {            active_count--;            /* Remove non-match possibility */            next_active_state--;            }          ADD_NEW(state_offset, 0);          }        }      break;      /*-----------------------------------------------------------------*/      case OP_TYPEEXACT:      count = current_state->count;  /* Number already matched */      if (clen > 0)        {        if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||            (c < 256 &&              (d != OP_ANY ||               (ims & PCRE_DOTALL) != 0 ||               !IS_NEWLINE(ptr)              ) &&              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))          {          if (++count >= GET2(code, 1))            { ADD_NEW(state_offset + 4, 0); }          else            { ADD_NEW(state_offset, count); }          }        }      break;      /*-----------------------------------------------------------------*/      case OP_TYPEUPTO:      case OP_TYPEMINUPTO:      case OP_TYPEPOSUPTO:      ADD_ACTIVE(state_offset + 4, 0);      count = current_state->count;  /* Number already matched */      if (clen > 0)        {        if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||            (c < 256 &&              (d != OP_ANY ||               (ims & PCRE_DOTALL) != 0 ||               !IS_NEWLINE(ptr)              ) &&              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))          {          if (codevalue == OP_TYPEPOSUPTO)            {            active_count--;           /* Remove non-match possibility */            next_active_state--;            }          if (++count >= GET2(code, 1))            { ADD_NEW(state_offset + 4, 0); }          else            { ADD_NEW(state_offset, count); }          }        }      break;/* ========================================================================== */      /* These are virtual opcodes that are used when something like      OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its      argument. It keeps the code above fast for the other cases. The argument      is in the d variable. */#ifdef SUPPORT_UCP      case OP_PROP_EXTRA + OP_TYPEPLUS:      case OP_PROP_EXTRA + OP_TYPEMINPLUS:      case OP_PROP_EXTRA + OP_TYPEPOSPLUS:      count = current_state->count;           /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); }      if (clen > 0)        {        BOOL OK;        int category = _pcre_ucp_findprop(c, &chartype, &script);        switch(code[2])          {          case PT_ANY:          OK = TRUE;          break;          case PT_LAMP:          OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;          break;          case PT_GC:          OK = category == code[3];          break;          case PT_PC:          OK = chartype == code[3];          break;          case PT_SC:          OK = script == code[3];          break;          /* Should never occur, but keep compilers from grumbling. */          default:          OK = codevalue != OP_PROP;          break;          }        if (OK == (d == OP_PROP))          {          if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS)            {            active_count--;           /* Remove non-match possibility */            next_active_state--;            }          count++;          ADD_NEW(state_offset, count);          }        }      break;      /*-----------------------------------------------------------------*/      case OP_EXTUNI_EXTRA + OP_TYPEPLUS:      case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS:      case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:      count = current_state->count;  /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }      if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)        {        const uschar *nptr = ptr + clen;        int ncount = 0;        if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)          {          active_count--;           /* Remove non-match possibility */          next_active_state--;          }        while (nptr < end_subject)          {          int nd;          int ndlen = 1;          GETCHARLEN(nd, nptr, ndlen);          if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;          ncount++;          nptr += ndlen;          }        count++;        ADD_NEW_DATA(-state_offset, count, ncount);        }      break;#endif      /*-----------------------------------------------------------------*/      case OP_ANYNL_EXTRA + OP_TYPEPLUS:      case OP_ANYNL_EXTRA + OP_TYPEMINPLUS:      case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS:      count = current_state->count;  /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }      if (clen > 0)        {        int ncount = 0;        switch (c)          {          case 0x000b:          case 0x000c:          case 0x0085:          case 0x2028:          case 0x2029:          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;          goto ANYNL01;          case 0x000d:          if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;          /* Fall through */          ANYNL01:          case 0x000a:          if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)            {            active_count--;           /* Remove non-match possibility */            next_active_state--;            }          count++;          ADD_NEW_DATA(-state_offset, count, ncount);          break;          default:          break;          }        }      break;      /*-----------------------------------------------------------------*/      case OP_VSPACE_EXTRA + OP_TYPEPLUS:      case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:      case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:      count = current_state->count;  /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }      if (clen > 0)        {        BOOL OK;        switch (c)          {          case 0x000a:          case 0x000b:          case 0x000c:          case 0x000d:          case 0x0085:          case 0x2028:          case 0x2029:          OK = TRUE;          break;          default:          OK = FALSE;          break;          }        if (OK == (d == OP_VSPACE))          {          if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)            {            active_count--;           /* Remove non-match possibility */            next_active_state--;            }          count++;          ADD_NEW_DATA(-state_offset, count, 0);          }        }      break;      /*-----------------------------------------------------------------*/      case OP_HSPACE_EXTRA + OP_TYPEPLUS:      case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:      case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:      count = current_state->count;  /* Already matched */      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }      if (clen > 0)        {        BOOL OK;        switch (c)          {          case 0x09:      /* HT */          case 0x20:      /* SPACE */          case 0xa0:      /* NBSP */          case 0x1680:    /* OGHAM SPACE MARK */          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */          case 0x2000:    /* EN QUAD */          case 0x2001:    /* EM QUAD */          case 0x2002:    /* EN SPACE */          case 0x2003:    /* EM SPACE */          case 0x2004:    /* THREE-PER-EM SPACE */          case 0x2005:    /* FOUR-PER-EM SPACE */          case 0x2006:    /* SIX-PER-EM SPACE */          case 0x2007:    /* FIGURE SPACE */          case 0x2008:    /* PUNCTUATION SPACE */          case 0x2009:    /* THIN SPACE */          case 0x200A:    /* HAIR SPACE */          case 0x202f:    /* NARROW NO-BREAK SPACE */          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */          case 0x3000:    /* IDEOGRAPHIC SPACE */          OK = TRUE;          break;          default:          OK = FALSE;          break;          }        if (OK == (d == OP_HSPACE))          {          if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)            {            active_count--;           /* Remove non-match possibility */            next_active_state--;            }          count++;          ADD_NEW_DATA(-state_offset, count, 0);          }        }      break;      /*-----------------------------------------------------------------*/#ifdef SUPPORT_UCP      case OP_PROP_EXTRA + OP_TYPEQUERY:      case OP_PROP_EXTRA + OP_TYPEMINQUERY:      case OP_PROP_EXTRA + OP_TYPEPOSQUERY:      count = 4;      goto QS1;      case OP_PROP_EXTRA + OP_TYPESTAR:      case OP_PROP_EXTRA + OP_TYPEMINSTAR:      case OP_PROP_EXTRA + OP_TYPEPOSSTAR:      count = 0;      QS1:      ADD_ACTIVE(state_offset + 4, 0);      if (clen > 0)        {        BOOL OK;        int category = _pcre_ucp_findprop(c, &chartype, &script);        switch(code[2])          {          case PT_ANY:          OK = TRUE;          break;          case PT_LAMP:          OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;          break;          case PT_GC:          OK = category == code[3];          break;          case PT_PC:          OK = chartype == code[3];          break;