[BACK]Return to pcre_study.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre

Diff for /embedaddon/pcre/pcre_study.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2012/10/09 09:19:17 version 1.1.1.4, 2013/07/22 08:25:55
Line 98  for (;;) Line 98  for (;;)
   {    {
   int d, min;    int d, min;
   pcre_uchar *cs, *ce;    pcre_uchar *cs, *ce;
  register int op = *cc;  register pcre_uchar op = *cc;
   
   switch (op)    switch (op)
     {      {
Line 323  for (;;) Line 323  for (;;)
   
     /* Check a class for variable quantification */      /* Check a class for variable quantification */
   
 #if defined SUPPORT_UTF || !defined COMPILE_PCRE8  
     case OP_XCLASS:  
     cc += GET(cc, 1) - PRIV(OP_lengths)[OP_CLASS];  
     /* Fall through */  
 #endif  
   
     case OP_CLASS:      case OP_CLASS:
     case OP_NCLASS:      case OP_NCLASS:
   #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
       case OP_XCLASS:
       /* The original code caused an unsigned overflow in 64 bit systems,
       so now we use a conditional statement. */
       if (op == OP_XCLASS)
         cc += GET(cc, 1);
       else
         cc += PRIV(OP_lengths)[OP_CLASS];
   #else
     cc += PRIV(OP_lengths)[OP_CLASS];      cc += PRIV(OP_lengths)[OP_CLASS];
   #endif
   
     switch (*cc)      switch (*cc)
       {        {
Line 538  Arguments: Line 542  Arguments:
   p             points to the character    p             points to the character
   caseless      the caseless flag    caseless      the caseless flag
   cd            the block with char table pointers    cd            the block with char table pointers
  utf           TRUE for UTF-8 / UTF-16 mode  utf           TRUE for UTF-8 / UTF-16 / UTF-32 mode
   
 Returns:        pointer after the character  Returns:        pointer after the character
 */  */
Line 547  static const pcre_uchar * Line 551  static const pcre_uchar *
 set_table_bit(pcre_uint8 *start_bits, const pcre_uchar *p, BOOL caseless,  set_table_bit(pcre_uint8 *start_bits, const pcre_uchar *p, BOOL caseless,
   compile_data *cd, BOOL utf)    compile_data *cd, BOOL utf)
 {  {
unsigned int c = *p;pcre_uint32 c = *p;
   
 #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
 SET_BIT(c);  SET_BIT(c);
Line 564  if (utf && c > 127) Line 568  if (utf && c > 127)
     (void)PRIV(ord2utf)(c, buff);      (void)PRIV(ord2utf)(c, buff);
     SET_BIT(buff[0]);      SET_BIT(buff[0]);
     }      }
#endif#endif  /* Not SUPPORT_UCP */
   return p;    return p;
   }    }
#endif#else   /* Not SUPPORT_UTF */
 (void)(utf);   /* Stops warning for unused parameter */
 #endif  /* SUPPORT_UTF */
   
 /* Not UTF-8 mode, or character is less than 127. */  /* Not UTF-8 mode, or character is less than 127. */
   
 if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);  if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);
 return p + 1;  return p + 1;
#endif#endif  /* COMPILE_PCRE8 */
   
#ifdef COMPILE_PCRE16#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
 if (c > 0xff)  if (c > 0xff)
   {    {
   c = 0xff;    c = 0xff;
Line 595  if (utf && c > 127) Line 601  if (utf && c > 127)
       c = 0xff;        c = 0xff;
     SET_BIT(c);      SET_BIT(c);
     }      }
#endif#endif  /* SUPPORT_UCP */
   return p;    return p;
   }    }
#endif#else   /* Not SUPPORT_UTF */
 (void)(utf);   /* Stops warning for unused parameter */
 #endif  /* SUPPORT_UTF */
   
 if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);  if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);
 return p + 1;  return p + 1;
Line 628  Returns:         nothing Line 636  Returns:         nothing
 */  */
   
 static void  static void
set_type_bits(pcre_uint8 *start_bits, int cbit_type, int table_limit,set_type_bits(pcre_uint8 *start_bits, int cbit_type, unsigned int table_limit,
   compile_data *cd)    compile_data *cd)
 {  {
register int c;register pcre_uint32 c;
 for (c = 0; c < table_limit; c++) start_bits[c] |= cd->cbits[c+cbit_type];  for (c = 0; c < table_limit; c++) start_bits[c] |= cd->cbits[c+cbit_type];
 #if defined SUPPORT_UTF && defined COMPILE_PCRE8  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
 if (table_limit == 32) return;  if (table_limit == 32) return;
Line 670  Returns:         nothing Line 678  Returns:         nothing
 */  */
   
 static void  static void
set_nottype_bits(pcre_uint8 *start_bits, int cbit_type, int table_limit,set_nottype_bits(pcre_uint8 *start_bits, int cbit_type, unsigned int table_limit,
   compile_data *cd)    compile_data *cd)
 {  {
register int c;register pcre_uint32 c;
 for (c = 0; c < table_limit; c++) start_bits[c] |= ~cd->cbits[c+cbit_type];  for (c = 0; c < table_limit; c++) start_bits[c] |= ~cd->cbits[c+cbit_type];
 #if defined SUPPORT_UTF && defined COMPILE_PCRE8  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
 if (table_limit != 32) for (c = 24; c < 32; c++) start_bits[c] = 0xff;  if (table_limit != 32) for (c = 24; c < 32; c++) start_bits[c] = 0xff;
Line 697  function fails unless the result is SSB_DONE. Line 705  function fails unless the result is SSB_DONE.
 Arguments:  Arguments:
   code         points to an expression    code         points to an expression
   start_bits   points to a 32-byte table, initialized to 0    start_bits   points to a 32-byte table, initialized to 0
  utf          TRUE if in UTF-8 / UTF-16 mode  utf          TRUE if in UTF-8 / UTF-16 / UTF-32 mode
   cd           the block with char table pointers    cd           the block with char table pointers
   
 Returns:       SSB_FAIL     => Failed to find any starting bytes  Returns:       SSB_FAIL     => Failed to find any starting bytes
Line 710  static int Line 718  static int
 set_start_bits(const pcre_uchar *code, pcre_uint8 *start_bits, BOOL utf,  set_start_bits(const pcre_uchar *code, pcre_uint8 *start_bits, BOOL utf,
   compile_data *cd)    compile_data *cd)
 {  {
register int c;register pcre_uint32 c;
 int yield = SSB_DONE;  int yield = SSB_DONE;
 #if defined SUPPORT_UTF && defined COMPILE_PCRE8  #if defined SUPPORT_UTF && defined COMPILE_PCRE8
 int table_limit = utf? 16:32;  int table_limit = utf? 16:32;
Line 986  do Line 994  do
       identical. */        identical. */
   
       case OP_HSPACE:        case OP_HSPACE:
      SET_BIT(0x09);      SET_BIT(CHAR_HT);
      SET_BIT(0x20);      SET_BIT(CHAR_SPACE);
 #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
       if (utf)        if (utf)
         {          {
Line 996  do Line 1004  do
         SET_BIT(0xE1);  /* For U+1680, U+180E */          SET_BIT(0xE1);  /* For U+1680, U+180E */
         SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */          SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
         SET_BIT(0xE3);  /* For U+3000 */          SET_BIT(0xE3);  /* For U+3000 */
#endif#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
#ifdef COMPILE_PCRE16 
         SET_BIT(0xA0);          SET_BIT(0xA0);
         SET_BIT(0xFF);  /* For characters > 255 */          SET_BIT(0xFF);  /* For characters > 255 */
#endif#endif  /* COMPILE_PCRE[8|16|32] */
         }          }
       else        else
 #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
         {          {
   #ifndef EBCDIC
         SET_BIT(0xA0);          SET_BIT(0xA0);
#ifdef COMPILE_PCRE16#endif  /* Not EBCDIC */
 #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
         SET_BIT(0xFF);  /* For characters > 255 */          SET_BIT(0xFF);  /* For characters > 255 */
#endif#endif  /* COMPILE_PCRE[16|32] */
         }          }
       try_next = FALSE;        try_next = FALSE;
       break;        break;
   
       case OP_ANYNL:        case OP_ANYNL:
       case OP_VSPACE:        case OP_VSPACE:
      SET_BIT(0x0A);      SET_BIT(CHAR_LF);
      SET_BIT(0x0B);      SET_BIT(CHAR_VT);
      SET_BIT(0x0C);      SET_BIT(CHAR_FF);
      SET_BIT(0x0D);      SET_BIT(CHAR_CR);
 #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
       if (utf)        if (utf)
         {          {
 #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
         SET_BIT(0xC2);  /* For U+0085 */          SET_BIT(0xC2);  /* For U+0085 */
         SET_BIT(0xE2);  /* For U+2028, U+2029 */          SET_BIT(0xE2);  /* For U+2028, U+2029 */
#endif#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
#ifdef COMPILE_PCRE16        SET_BIT(CHAR_NEL);
        SET_BIT(0x85); 
         SET_BIT(0xFF);  /* For characters > 255 */          SET_BIT(0xFF);  /* For characters > 255 */
#endif#endif  /* COMPILE_PCRE[8|16|32] */
         }          }
       else        else
 #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
         {          {
        SET_BIT(0x85);        SET_BIT(CHAR_NEL);
#ifdef COMPILE_PCRE16#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
         SET_BIT(0xFF);  /* For characters > 255 */          SET_BIT(0xFF);  /* For characters > 255 */
 #endif  #endif
         }          }
Line 1058  do Line 1066  do
       break;        break;
   
       /* The cbit_space table has vertical tab as whitespace; we have to        /* The cbit_space table has vertical tab as whitespace; we have to
      ensure it is set as not whitespace. */      ensure it is set as not whitespace. Luckily, the code value is the same
       (0x0b) in ASCII and EBCDIC, so we can just adjust the appropriate bit. */
   
       case OP_NOT_WHITESPACE:        case OP_NOT_WHITESPACE:
       set_nottype_bits(start_bits, cbit_space, table_limit, cd);        set_nottype_bits(start_bits, cbit_space, table_limit, cd);
Line 1066  do Line 1075  do
       try_next = FALSE;        try_next = FALSE;
       break;        break;
   
      /* The cbit_space table has vertical tab as whitespace; we have to      /* The cbit_space table has vertical tab as whitespace; we have to not
      not set it from the table. */      set it from the table. Luckily, the code value is the same (0x0b) in
       ASCII and EBCDIC, so we can just adjust the appropriate bit. */
   
       case OP_WHITESPACE:        case OP_WHITESPACE:
       c = start_bits[1];    /* Save in case it was already set */        c = start_bits[1];    /* Save in case it was already set */
Line 1121  do Line 1131  do
         return SSB_FAIL;          return SSB_FAIL;
   
         case OP_HSPACE:          case OP_HSPACE:
        SET_BIT(0x09);        SET_BIT(CHAR_HT);
        SET_BIT(0x20);        SET_BIT(CHAR_SPACE);
 #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
         if (utf)          if (utf)
           {            {
Line 1131  do Line 1141  do
           SET_BIT(0xE1);  /* For U+1680, U+180E */            SET_BIT(0xE1);  /* For U+1680, U+180E */
           SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */            SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
           SET_BIT(0xE3);  /* For U+3000 */            SET_BIT(0xE3);  /* For U+3000 */
#endif#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
#ifdef COMPILE_PCRE16 
           SET_BIT(0xA0);            SET_BIT(0xA0);
           SET_BIT(0xFF);  /* For characters > 255 */            SET_BIT(0xFF);  /* For characters > 255 */
#endif#endif  /* COMPILE_PCRE[8|16|32] */
           }            }
         else          else
 #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
   #ifndef EBCDIC
           SET_BIT(0xA0);            SET_BIT(0xA0);
   #endif  /* Not EBCDIC */
         break;          break;
   
         case OP_ANYNL:          case OP_ANYNL:
         case OP_VSPACE:          case OP_VSPACE:
        SET_BIT(0x0A);        SET_BIT(CHAR_LF);
        SET_BIT(0x0B);        SET_BIT(CHAR_VT);
        SET_BIT(0x0C);        SET_BIT(CHAR_FF);
        SET_BIT(0x0D);        SET_BIT(CHAR_CR);
 #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
         if (utf)          if (utf)
           {            {
 #ifdef COMPILE_PCRE8  #ifdef COMPILE_PCRE8
           SET_BIT(0xC2);  /* For U+0085 */            SET_BIT(0xC2);  /* For U+0085 */
           SET_BIT(0xE2);  /* For U+2028, U+2029 */            SET_BIT(0xE2);  /* For U+2028, U+2029 */
#endif#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
#ifdef COMPILE_PCRE16          SET_BIT(CHAR_NEL);
          SET_BIT(0x85); 
           SET_BIT(0xFF);  /* For characters > 255 */            SET_BIT(0xFF);  /* For characters > 255 */
#endif#endif  /* COMPILE_PCRE16 */
           }            }
         else          else
 #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
          SET_BIT(0x85);          SET_BIT(CHAR_NEL);
         break;          break;
   
         case OP_NOT_DIGIT:          case OP_NOT_DIGIT:
Line 1174  do Line 1184  do
         break;          break;
   
         /* The cbit_space table has vertical tab as whitespace; we have to          /* The cbit_space table has vertical tab as whitespace; we have to
        ensure it gets set as not whitespace. */        ensure it gets set as not whitespace. Luckily, the code value is the
         same (0x0b) in ASCII and EBCDIC, so we can just adjust the appropriate
         bit. */
   
         case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
         set_nottype_bits(start_bits, cbit_space, table_limit, cd);          set_nottype_bits(start_bits, cbit_space, table_limit, cd);
Line 1182  do Line 1194  do
         break;          break;
   
         /* The cbit_space table has vertical tab as whitespace; we have to          /* The cbit_space table has vertical tab as whitespace; we have to
        avoid setting it. */        avoid setting it. Luckily, the code value is the same (0x0b) in ASCII
         and EBCDIC, so we can just adjust the appropriate bit. */
   
         case OP_WHITESPACE:          case OP_WHITESPACE:
         c = start_bits[1];    /* Save in case it was already set */          c = start_bits[1];    /* Save in case it was already set */
Line 1216  do Line 1229  do
         memset(start_bits+25, 0xff, 7);      /* Bits for 0xc9 - 0xff */          memset(start_bits+25, 0xff, 7);      /* Bits for 0xc9 - 0xff */
         }          }
 #endif  #endif
#ifdef COMPILE_PCRE16#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
       SET_BIT(0xFF);                         /* For characters > 255 */        SET_BIT(0xFF);                         /* For characters > 255 */
 #endif  #endif
       /* Fall through */        /* Fall through */
Line 1312  Returns:    pointer to a pcre[16]_extra block, with st Line 1325  Returns:    pointer to a pcre[16]_extra block, with st
             NULL on error or if no optimization possible              NULL on error or if no optimization possible
 */  */
   
#ifdef COMPILE_PCRE8#if defined COMPILE_PCRE8
 PCRE_EXP_DEFN pcre_extra * PCRE_CALL_CONVENTION  PCRE_EXP_DEFN pcre_extra * PCRE_CALL_CONVENTION
 pcre_study(const pcre *external_re, int options, const char **errorptr)  pcre_study(const pcre *external_re, int options, const char **errorptr)
#else#elif defined COMPILE_PCRE16
 PCRE_EXP_DEFN pcre16_extra * PCRE_CALL_CONVENTION  PCRE_EXP_DEFN pcre16_extra * PCRE_CALL_CONVENTION
 pcre16_study(const pcre16 *external_re, int options, const char **errorptr)  pcre16_study(const pcre16 *external_re, int options, const char **errorptr)
   #elif defined COMPILE_PCRE32
   PCRE_EXP_DEFN pcre32_extra * PCRE_CALL_CONVENTION
   pcre32_study(const pcre32 *external_re, int options, const char **errorptr)
 #endif  #endif
 {  {
 int min;  int min;
Line 1340  if (re == NULL || re->magic_number != MAGIC_NUMBER) Line 1356  if (re == NULL || re->magic_number != MAGIC_NUMBER)
   
 if ((re->flags & PCRE_MODE) == 0)  if ((re->flags & PCRE_MODE) == 0)
   {    {
#ifdef COMPILE_PCRE8#if defined COMPILE_PCRE8
  *errorptr = "argument is compiled in 16 bit mode";  *errorptr = "argument not compiled in 8 bit mode";
#else#elif defined COMPILE_PCRE16
  *errorptr = "argument is compiled in 8 bit mode";  *errorptr = "argument not compiled in 16 bit mode";
 #elif defined COMPILE_PCRE32
   *errorptr = "argument not compiled in 32 bit mode";
 #endif  #endif
   return NULL;    return NULL;
   }    }
Line 1370  if ((re->options & PCRE_ANCHORED) == 0 && Line 1388  if ((re->options & PCRE_ANCHORED) == 0 &&
   
   tables = re->tables;    tables = re->tables;
   
#ifdef COMPILE_PCRE8#if defined COMPILE_PCRE8
   if (tables == NULL)    if (tables == NULL)
     (void)pcre_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,      (void)pcre_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
     (void *)(&tables));      (void *)(&tables));
#else#elif defined COMPILE_PCRE16
   if (tables == NULL)    if (tables == NULL)
     (void)pcre16_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,      (void)pcre16_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
     (void *)(&tables));      (void *)(&tables));
   #elif defined COMPILE_PCRE32
     if (tables == NULL)
       (void)pcre32_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
       (void *)(&tables));
 #endif  #endif
   
   compile_block.lcc = tables + lcc_offset;    compile_block.lcc = tables + lcc_offset;
Line 1408  switch(min = find_minlength(code, code, re->options, 0 Line 1430  switch(min = find_minlength(code, code, re->options, 0
   }    }
   
 /* If a set of starting bytes has been identified, or if the minimum length is  /* If a set of starting bytes has been identified, or if the minimum length is
greater than zero, or if JIT optimization has been requested, get agreater than zero, or if JIT optimization has been requested, or if
pcre[16]_extra block and a pcre_study_data block. The study data is put in thePCRE_STUDY_EXTRA_NEEDED is set, get a pcre[16]_extra block and a
latter, which is pointed to by the former, which may also get additional datapcre_study_data block. The study data is put in the latter, which is pointed to
set later by the calling program. At the moment, the size of pcre_study_databy the former, which may also get additional data set later by the calling
is fixed. We nevertheless save it in a field for returning via theprogram. At the moment, the size of pcre_study_data is fixed. We nevertheless
pcre_fullinfo() function so that if it becomes variable in the future,save it in a field for returning via the pcre_fullinfo() function so that if it
we don't have to change that code. */becomes variable in the future, we don't have to change that code. */
   
if (bits_set || min > 0if (bits_set || min > 0 || (options & (
 #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
    || (options & (PCRE_STUDY_JIT_COMPILE | PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE    PCRE_STUDY_JIT_COMPILE | PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE |
                 | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE)) != 0    PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE |
 #endif  #endif
  )    PCRE_STUDY_EXTRA_NEEDED)) != 0)
   {    {
   extra = (PUBL(extra) *)(PUBL(malloc))    extra = (PUBL(extra) *)(PUBL(malloc))
     (sizeof(PUBL(extra)) + sizeof(pcre_study_data));      (sizeof(PUBL(extra)) + sizeof(pcre_study_data));
Line 1475  if (bits_set || min > 0 Line 1497  if (bits_set || min > 0
   
   /* If JIT support was compiled and requested, attempt the JIT compilation.    /* If JIT support was compiled and requested, attempt the JIT compilation.
   If no starting bytes were found, and the minimum length is zero, and JIT    If no starting bytes were found, and the minimum length is zero, and JIT
  compilation fails, abandon the extra block and return NULL. */  compilation fails, abandon the extra block and return NULL, unless
   PCRE_STUDY_EXTRA_NEEDED is set. */
   
 #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
   extra->executable_jit = NULL;    extra->executable_jit = NULL;
Line 1486  if (bits_set || min > 0 Line 1509  if (bits_set || min > 0
   if ((options & PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE) != 0)    if ((options & PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE) != 0)
     PRIV(jit_compile)(re, extra, JIT_PARTIAL_HARD_COMPILE);      PRIV(jit_compile)(re, extra, JIT_PARTIAL_HARD_COMPILE);
   
  if (study->flags == 0 && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) == 0)  if (study->flags == 0 && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) == 0 &&
       (options & PCRE_STUDY_EXTRA_NEEDED) == 0)
     {      {
#ifdef COMPILE_PCRE8#if defined COMPILE_PCRE8
     pcre_free_study(extra);      pcre_free_study(extra);
#endif#elif defined COMPILE_PCRE16
#ifdef COMPILE_PCRE16 
     pcre16_free_study(extra);      pcre16_free_study(extra);
   #elif defined COMPILE_PCRE32
       pcre32_free_study(extra);
 #endif  #endif
     extra = NULL;      extra = NULL;
     }      }
Line 1513  Argument:   a pointer to the pcre[16]_extra block Line 1538  Argument:   a pointer to the pcre[16]_extra block
 Returns:    nothing  Returns:    nothing
 */  */
   
#ifdef COMPILE_PCRE8#if defined COMPILE_PCRE8
 PCRE_EXP_DEFN void  PCRE_EXP_DEFN void
 pcre_free_study(pcre_extra *extra)  pcre_free_study(pcre_extra *extra)
#else#elif defined COMPILE_PCRE16
 PCRE_EXP_DEFN void  PCRE_EXP_DEFN void
 pcre16_free_study(pcre16_extra *extra)  pcre16_free_study(pcre16_extra *extra)
   #elif defined COMPILE_PCRE32
   PCRE_EXP_DEFN void
   pcre32_free_study(pcre32_extra *extra)
 #endif  #endif
 {  {
 if (extra == NULL)  if (extra == NULL)
Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>