else  {  end_code = this_start_code;  /* Restarting */  if (rlevel == 1 && (md->moptions & PCRE_DFA_RESTART) != 0)    {    do { end_code += GET(end_code, 1); } while (*end_code == OP_ALT);    new_count = workspace[1];    if (!workspace[0])      memcpy(new_states, active_states, new_count * sizeof(stateblock));    }  /* Not restarting */  else    {    int length = 1 + LINK_SIZE +      ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);    do      {      ADD_NEW(end_code - start_code + length, 0);      end_code += GET(end_code, 1);      length = 1 + LINK_SIZE;      }    while (*end_code == OP_ALT);    }  }workspace[0] = 0;    /* Bit indicating which vector is current */DPRINTF(("%.*sEnd state = %d\n", rlevel*2-2, SP, end_code - start_code));/* Loop for scanning the subject */ptr = current_subject;for (;;)  {  int i, j;  int clen, dlen;  unsigned int c, d;  /* Make the new state list into the active state list and empty the  new state list. */  temp_states = active_states;  active_states = new_states;  new_states = temp_states;  active_count = new_count;  new_count = 0;  workspace[0] ^= 1;              /* Remember for the restarting feature */  workspace[1] = active_count;#ifdef DEBUG  printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);  pchars((uschar *)ptr, strlen((char *)ptr), stdout);  printf("\"\n");  printf("%.*sActive states: ", rlevel*2-2, SP);  for (i = 0; i < active_count; i++)    printf("%d/%d ", active_states[i].offset, active_states[i].count);  printf("\n");#endif  /* Set the pointers for adding new states */  next_active_state = active_states + active_count;  next_new_state = new_states;  /* Load the current character from the subject outside the loop, as many  different states may want to look at it, and we assume that at least one  will. */  if (ptr < end_subject)    {    clen = 1;        /* Number of bytes in the character */#ifdef SUPPORT_UTF8    if (utf8) { GETCHARLEN(c, ptr, clen); } else#endif  /* SUPPORT_UTF8 */    c = *ptr;    }  else    {    clen = 0;        /* This indicates the end of the subject */    c = NOTACHAR;    /* This value should never actually be used */    }  /* Scan up the active states and act on each one. The result of an action  may be to add more states to the currently active list (e.g. on hitting a  parenthesis) or it may be to put states on the new list, for considering  when we move the character pointer on. */  for (i = 0; i < active_count; i++)    {    stateblock *current_state = active_states + i;    const uschar *code;    int state_offset = current_state->offset;    int count, codevalue;#ifdef SUPPORT_UCP    int chartype, script;#endif#ifdef DEBUG    printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);    if (clen == 0) printf("EOL\n");      else if (c > 32 && c < 127) printf("'%c'\n", c);        else printf("0x%02x\n", c);#endif    /* This variable is referred to implicity in the ADD_xxx macros. */    ims = current_state->ims;    /* A negative offset is a special case meaning "hold off going to this    (negated) state until the number of characters in the data field have    been skipped". */    if (state_offset < 0)      {      if (current_state->data > 0)        {        DPRINTF(("%.*sSkipping this character\n", rlevel*2-2, SP));        ADD_NEW_DATA(state_offset, current_state->count,          current_state->data - 1);        continue;        }      else        {        current_state->offset = state_offset = -state_offset;        }      }    /* Check for a duplicate state with the same count, and skip if found. */    for (j = 0; j < i; j++)      {      if (active_states[j].offset == state_offset &&          active_states[j].count == current_state->count)        {        DPRINTF(("%.*sDuplicate state: skipped\n", rlevel*2-2, SP));        goto NEXT_ACTIVE_STATE;        }      }    /* The state offset is the offset to the opcode */    code = start_code + state_offset;    codevalue = *code;    /* If this opcode is followed by an inline character, load it. It is    tempting to test for the presence of a subject character here, but that    is wrong, because sometimes zero repetitions of the subject are    permitted.    We also use this mechanism for opcodes such as OP_TYPEPLUS that take an    argument that is not a data character - but is always one byte long. We    have to take special action to deal with  \P, \p, \H, \h, \V, \v and \X in    this case. To keep the other cases fast, convert these ones to new opcodes.    */    if (coptable[codevalue] > 0)      {      dlen = 1;#ifdef SUPPORT_UTF8      if (utf8) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else#endif  /* SUPPORT_UTF8 */      d = code[coptable[codevalue]];      if (codevalue >= OP_TYPESTAR)        {        switch(d)          {          case OP_ANYBYTE: return PCRE_ERROR_DFA_UITEM;          case OP_NOTPROP:          case OP_PROP: codevalue += OP_PROP_EXTRA; break;          case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;          case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;          case OP_NOT_HSPACE:          case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;          case OP_NOT_VSPACE:          case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;          default: break;          }        }      }    else      {      dlen = 0;         /* Not strictly necessary, but compilers moan */      d = NOTACHAR;     /* if these variables are not set. */      }    /* Now process the individual opcodes */    switch (codevalue)      {/* ========================================================================== */      /* Reached a closing bracket. If not at the end of the pattern, carry      on with the next opcode. Otherwise, unless we have an empty string and      PCRE_NOTEMPTY is set, save the match data, shifting up all previous      matches so we always have the longest first. */      case OP_KET:      case OP_KETRMIN:      case OP_KETRMAX:      if (code != end_code)        {        ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);        if (codevalue != OP_KET)          {          ADD_ACTIVE(state_offset - GET(code, 1), 0);          }        }      else if (ptr > current_subject || (md->moptions & PCRE_NOTEMPTY) == 0)        {        if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;          else if (match_count > 0 && ++match_count * 2 >= offsetcount)            match_count = 0;        count = ((match_count == 0)? offsetcount : match_count * 2) - 2;        if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));        if (offsetcount >= 2)          {          offsets[0] = current_subject - start_subject;          offsets[1] = ptr - start_subject;          DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,            offsets[1] - offsets[0], current_subject));          }        if ((md->moptions & PCRE_DFA_SHORTEST) != 0)          {          DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"            "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,            match_count, rlevel*2-2, SP));          return match_count;          }        }      break;/* ========================================================================== */      /* These opcodes add to the current list of states without looking      at the current character. */      /*-----------------------------------------------------------------*/      case OP_ALT:      do { code += GET(code, 1); } while (*code == OP_ALT);      ADD_ACTIVE(code - start_code, 0);      break;      /*-----------------------------------------------------------------*/      case OP_BRA:      case OP_SBRA:      do        {        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);        code += GET(code, 1);        }      while (*code == OP_ALT);      break;      /*-----------------------------------------------------------------*/      case OP_CBRA:      case OP_SCBRA:      ADD_ACTIVE(code - start_code + 3 + LINK_SIZE,  0);      code += GET(code, 1);      while (*code == OP_ALT)        {        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE,  0);        code += GET(code, 1);        }      break;      /*-----------------------------------------------------------------*/      case OP_BRAZERO:      case OP_BRAMINZERO:      ADD_ACTIVE(state_offset + 1, 0);      code += 1 + GET(code, 2);      while (*code == OP_ALT) code += GET(code, 1);      ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);      break;      /*-----------------------------------------------------------------*/      case OP_CIRC:      if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||          ((ims & PCRE_MULTILINE) != 0 &&            ptr != end_subject &&            WAS_NEWLINE(ptr)))        { ADD_ACTIVE(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_EOD:      if (ptr >= end_subject) { ADD_ACTIVE(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_OPT:      ims = code[1];      ADD_ACTIVE(state_offset + 2, 0);      break;      /*-----------------------------------------------------------------*/      case OP_SOD:      if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_SOM:      if (ptr == start_subject + start_offset) { ADD_ACTIVE(state_offset + 1, 0); }      break;/* ========================================================================== */      /* These opcodes inspect the next subject character, and sometimes      the previous one as well, but do not have an argument. The variable      clen contains the length of the current character and is zero if we are      at the end of the subject. */      /*-----------------------------------------------------------------*/      case OP_ANY:      if (clen > 0 && ((ims & PCRE_DOTALL) != 0 || !IS_NEWLINE(ptr)))        { ADD_NEW(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_EODN:      if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))        { ADD_ACTIVE(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_DOLL:      if ((md->moptions & PCRE_NOTEOL) == 0)        {        if (clen == 0 ||            (IS_NEWLINE(ptr) &&               ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)            ))          { ADD_ACTIVE(state_offset + 1, 0); }        }      else if ((ims & PCRE_MULTILINE) != 0 && IS_NEWLINE(ptr))        { ADD_ACTIVE(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_DIGIT:      case OP_WHITESPACE:      case OP_WORDCHAR:      if (clen > 0 && c < 256 &&            ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0)        { ADD_NEW(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_NOT_DIGIT:      case OP_NOT_WHITESPACE:      case OP_NOT_WORDCHAR:      if (clen > 0 && (c >= 256 ||            ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0))        { ADD_NEW(state_offset + 1, 0); }      break;      /*-----------------------------------------------------------------*/      case OP_WORD_BOUNDARY:      case OP_NOT_WORD_BOUNDARY:        {        int left_word, right_word;        if (ptr > start_subject)          {          const uschar *temp = ptr - 1;#ifdef SUPPORT_UTF8          if (utf8) BACKCHAR(temp);#endif          GETCHARTEST(d, temp);          left_word = d < 256 && (ctypes[d] & ctype_word) != 0;          }        else left_word = 0;        if (clen > 0) right_word = c < 256 && (ctypes[c] & ctype_word) != 0;          else right_word = 0;        if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))          { ADD_ACTIVE(state_offset + 1, 0); }        }      break;      /*-----------------------------------------------------------------*/      /* Check the next character by Unicode property. We will get here only      if the support is in the binary; otherwise a compile-time error occurs.      */#ifdef SUPPORT_UCP      case OP_PROP:      case OP_NOTPROP:      if (clen > 0)        {        BOOL OK;        int category = _pcre_ucp_findprop(c, &chartype, &script);        switch(code[1])          {          case PT_ANY:          OK = TRUE;          break;          case PT_LAMP:          OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;          break;          case PT_GC: