/**************************************************      Perl-Compatible Regular Expressions       **************************************************//* PCRE is a library of functions to support regular expressions whose syntaxand semantics are as close as possible to those of the Perl 5 language.                       Written by Philip Hazel           Copyright (c) 1997-2007 University of Cambridge-----------------------------------------------------------------------------Redistribution and use in source and binary forms, with or withoutmodification, are permitted provided that the following conditions are met:    * Redistributions of source code must retain the above copyright notice,      this list of conditions and the following disclaimer.    * Redistributions in binary form must reproduce the above copyright      notice, this list of conditions and the following disclaimer in the      documentation and/or other materials provided with the distribution.    * Neither the name of the University of Cambridge nor the names of its      contributors may be used to endorse or promote products derived from      this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THEIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSEARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BELIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, ORCONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OFSUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESSINTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER INCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THEPOSSIBILITY OF SUCH DAMAGE.-----------------------------------------------------------------------------*//* This module contains the external function pcre_study(), along with localsupporting functions. */#ifdef HAVE_CONFIG_H#include "config.h"#endif#include "pcre_internal.h"/* Returns from set_start_bits() */enum { SSB_FAIL, SSB_DONE, SSB_CONTINUE };/**************************************************      Set a bit and maybe its alternate case    **************************************************//* Given a character, set its bit in the table, and also the bit for the otherversion of a letter if we are caseless.Arguments:  start_bits    points to the bit map  c             is the character  caseless      the caseless flag  cd            the block with char table pointersReturns:        nothing*/static voidset_bit(uschar *start_bits, unsigned int c, BOOL caseless, compile_data *cd){start_bits[c/8] |= (1 << (c&7));if (caseless && (cd->ctypes[c] & ctype_letter) != 0)  start_bits[cd->fcc[c]/8] |= (1 << (cd->fcc[c]&7));}/**************************************************          Create bitmap of starting bytes       **************************************************//* This function scans a compiled unanchored expression recursively andattempts to build a bitmap of the set of possible starting bytes. As time goesby, we may be able to get more clever at doing this. The SSB_CONTINUE return isuseful for parenthesized groups in patterns such as (a*)b where the groupprovides some optional starting bytes but scanning must continue at the outerlevel to find at least one mandatory byte. At the outermost level, thisfunction fails unless the result is SSB_DONE.Arguments:  code         points to an expression  start_bits   points to a 32-byte table, initialized to 0  caseless     the current state of the caseless flag  utf8         TRUE if in UTF-8 mode  cd           the block with char table pointersReturns:       SSB_FAIL     => Failed to find any starting bytes               SSB_DONE     => Found mandatory starting bytes               SSB_CONTINUE => Found optional starting bytes*/static intset_start_bits(const uschar *code, uschar *start_bits, BOOL caseless,  BOOL utf8, compile_data *cd){register int c;int yield = SSB_DONE;#if 0/* ========================================================================= *//* The following comment and code was inserted in January 1999. In May 2006,when it was observed to cause compiler warnings about unused values, I took itout again. If anybody is still using OS/2, they will have to put it backmanually. *//* This next statement and the later reference to dummy are here in order totrick the optimizer of the IBM C compiler for OS/2 into generating correctcode. Apparently IBM isn't going to fix the problem, and we would rather notdisable optimization (in this module it actually makes a big difference, andthe pcre module can use all the optimization it can get). */volatile int dummy;/* ========================================================================= */#endifdo  {  const uschar *tcode = code + (((int)*code == OP_CBRA)? 3:1) + LINK_SIZE;  BOOL try_next = TRUE;  while (try_next)    /* Loop for items in this branch */    {    int rc;    switch(*tcode)      {      /* Fail if we reach something we don't understand */      default:      return SSB_FAIL;      /* If we hit a bracket or a positive lookahead assertion, recurse to set      bits from within the subpattern. If it can't find anything, we have to      give up. If it finds some mandatory character(s), we are done for this      branch. Otherwise, carry on scanning after the subpattern. */      case OP_BRA:      case OP_SBRA:      case OP_CBRA:      case OP_SCBRA:      case OP_ONCE:      case OP_ASSERT:      rc = set_start_bits(tcode, start_bits, caseless, utf8, cd);      if (rc == SSB_FAIL) return SSB_FAIL;      if (rc == SSB_DONE) try_next = FALSE; else        {        do tcode += GET(tcode, 1); while (*tcode == OP_ALT);        tcode += 1 + LINK_SIZE;        }      break;      /* If we hit ALT or KET, it means we haven't found anything mandatory in      this branch, though we might have found something optional. For ALT, we      continue with the next alternative, but we have to arrange that the final      result from subpattern is SSB_CONTINUE rather than SSB_DONE. For KET,      return SSB_CONTINUE: if this is the top level, that indicates failure,      but after a nested subpattern, it causes scanning to continue. */      case OP_ALT:      yield = SSB_CONTINUE;      try_next = FALSE;      break;      case OP_KET:      case OP_KETRMAX:      case OP_KETRMIN:      return SSB_CONTINUE;      /* Skip over callout */      case OP_CALLOUT:      tcode += 2 + 2*LINK_SIZE;      break;      /* Skip over lookbehind and negative lookahead assertions */      case OP_ASSERT_NOT:      case OP_ASSERTBACK:      case OP_ASSERTBACK_NOT:      do tcode += GET(tcode, 1); while (*tcode == OP_ALT);      tcode += 1 + LINK_SIZE;      break;      /* Skip over an option setting, changing the caseless flag */      case OP_OPT:      caseless = (tcode[1] & PCRE_CASELESS) != 0;      tcode += 2;      break;      /* BRAZERO does the bracket, but carries on. */      case OP_BRAZERO:      case OP_BRAMINZERO:      if (set_start_bits(++tcode, start_bits, caseless, utf8, cd) == SSB_FAIL)        return SSB_FAIL;/* =========================================================================      See the comment at the head of this function concerning the next line,      which was an old fudge for the benefit of OS/2.      dummy = 1;  ========================================================================= */      do tcode += GET(tcode,1); while (*tcode == OP_ALT);      tcode += 1 + LINK_SIZE;      break;      /* Single-char * or ? sets the bit and tries the next item */      case OP_STAR:      case OP_MINSTAR:      case OP_POSSTAR:      case OP_QUERY:      case OP_MINQUERY:      case OP_POSQUERY:      set_bit(start_bits, tcode[1], caseless, cd);      tcode += 2;#ifdef SUPPORT_UTF8      if (utf8 && tcode[-1] >= 0xc0)        tcode += _pcre_utf8_table4[tcode[-1] & 0x3f];#endif      break;      /* Single-char upto sets the bit and tries the next */      case OP_UPTO:      case OP_MINUPTO:      case OP_POSUPTO:      set_bit(start_bits, tcode[3], caseless, cd);      tcode += 4;#ifdef SUPPORT_UTF8      if (utf8 && tcode[-1] >= 0xc0)        tcode += _pcre_utf8_table4[tcode[-1] & 0x3f];#endif      break;      /* At least one single char sets the bit and stops */      case OP_EXACT:       /* Fall through */      tcode += 2;      case OP_CHAR:      case OP_CHARNC:      case OP_PLUS:      case OP_MINPLUS:      case OP_POSPLUS:      set_bit(start_bits, tcode[1], caseless, cd);      try_next = FALSE;      break;      /* Single character type sets the bits and stops */      case OP_NOT_DIGIT:      for (c = 0; c < 32; c++)        start_bits[c] |= ~cd->cbits[c+cbit_digit];      try_next = FALSE;      break;      case OP_DIGIT:      for (c = 0; c < 32; c++)        start_bits[c] |= cd->cbits[c+cbit_digit];      try_next = FALSE;      break;      /* The cbit_space table has vertical tab as whitespace; we have to      discard it. */      case OP_NOT_WHITESPACE:      for (c = 0; c < 32; c++)        {        int d = cd->cbits[c+cbit_space];        if (c == 1) d &= ~0x08;        start_bits[c] |= ~d;        }      try_next = FALSE;      break;      /* The cbit_space table has vertical tab as whitespace; we have to