Ignore:
Timestamp:
Nov 12, 2007, 3:04:41 PM (18 years ago)
Author:
Darin Adler
Message:

Reviewed by Geoff.

  • fix use of prefix and config.h, got rid of a few unneeded things in the PCRE code; no behavior changes
  • API/JSBase.cpp: Added include of config.h.
  • API/JSCallbackConstructor.cpp: Ditto.
  • API/JSCallbackFunction.cpp: Ditto.
  • API/JSCallbackObject.cpp: Ditto.
  • API/JSClassRef.cpp: Ditto.
  • API/JSContextRef.cpp: Ditto.
  • API/JSObjectRef.cpp: Ditto.
  • API/JSStringRef.cpp: Ditto.
  • API/JSValueRef.cpp: Ditto.
  • JavaScriptCorePrefix.h: Removed obsolete <ctype.h> workaround. Moved new/delete macros after includes, as they are in WebCore's prefix. Removed "config.h".
  • pcre/dftables.cpp: (main): Changed back to not use a separate maketables function. This is needed for PCRE, but not helpful for our use. Also changed the tables to all be 128 entries long instead of 256, since only the first 128 are ever used.
  • pcre/pcre_compile.cpp: Added include of config.h. Eliminated digitab, which was only being used to check hex digits. Changed all uses of TRUE and FALSE to use the C++ true and false instead. (check_escape): Just the TRUE/FALSE thing. (is_counted_repeat): Ditto. (could_be_empty_branch): Ditto. (get_othercase_range): Ditto. (compile_branch): Ditto. (compile_regex): Ditto. (is_anchored): Ditto. (is_startline): Ditto. (find_firstassertedchar): Ditto. (jsRegExpCompile): Ditto.
  • pcre/pcre_exec.cpp: Added include of config.h. Changed all uses of TRUE and FALSE to use the C++ true and false instead. (match_ref): Just the TRUE/FALSE thing. (match): Ditto. Removed some unneeded braces. (jsRegExpExecute): Just the TRUE/FALSE thing.
  • pcre/pcre_internal.h: Moved the constants needed by dftables.cpp to the top of the file instead of the bottom, so they can be used. Also changed the table sizes to 128 instead of 256. Removed macro definitions of FALSE and TRUE. Set array sizes for all the const arrays. Changed _pcre_utf8_table1_size to be a macro instead of a extern int.
  • pcre/pcre_maketables.cpp: Removed. It's all in dftables.cpp now.
  • pcre/pcre_tables.cpp: Made table sizes explicit.
  • pcre/pcre_xclass.cpp: Just the TRUE/FALSE thing.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/pcre/pcre_compile.cpp

    r27686 r27730  
    4141supporting internal functions that are not used by other modules. */
    4242
     43#include "config.h"
     44
    4345#include "pcre_internal.h"
    4446
    … …  
    4749
    4850using namespace WTF;
    49 
    50 /* WARNING: This macro evaluates its parameters more than once. */
    51 #define DIGITAB(x) ((x) < 128 ? digitab[(x)] : 0)
    5251
    5352/*************************************************
    … …  
    130129}
    131130
    132 /* Table to hex digits. This is used when compiling
    133 patterns. Note that the tables in chartables are dependent on the locale, and
    134 may mark arbitrary characters as digits - but the PCRE compiling code expects
    135 to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
    136 a private table here. It costs 256 bytes, but it is a lot faster than doing
    137 character value tests (at least in some simple cases I timed), and in some
    138 applications one wants PCRE to compile efficiently as well as match
    139 efficiently.
    140 
    141 For convenience, we use the same bit definition as in chartables:
    142 
    143   0x08   hexadecimal digit
    144 
    145 Then we can use ctype_xdigit in the code. */
    146 
    147 static const unsigned char digitab[] =
    148   {
    149   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
    150   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */
    151   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
    152   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
    153   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
    154   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
    155   0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */
    156   0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
    157   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */
    158   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */
    159   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */
    160   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */
    161   0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */
    162   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */
    163   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */
    164   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
    165   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
    166   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
    167   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
    168   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
    169   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
    170   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
    171   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
    172   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
    173   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
    174   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
    175   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
    176   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
    177   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
    178   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
    179   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
    180   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
    181 
    182131/* Definition to allow mutual recursion */
    183132
    … …  
    201150  bracount       number of previous extracting brackets
    202151  options        the options bits
    203   isclass        TRUE if inside a character class
     152  isclass        true if inside a character class
    204153
    205154Returns:         zero or positive => a data character
    … …  
    302251
    303252      c = 0;
    304       while (pt < patternEnd && (DIGITAB(*pt) & ctype_xdigit) != 0)
     253      while (pt < patternEnd && isASCIIHexDigit(*pt))
    305254        {
    306255        register int cc = *pt++;
    … …  
    331280
    332281    c = 0;
    333     while (i++ < 2 && ptr + 1 < patternEnd && (DIGITAB(ptr[1]) & ctype_xdigit) != 0)
     282    while (i++ < 2 && ptr + 1 < patternEnd && isASCIIHexDigit(ptr[1]))
    334283      {
    335284      int cc;                               /* Some compilers don't like ++ */
    … …  
    345294    while (i++ < 4)
    346295      {
    347       if (pt + 1 >= patternEnd || (DIGITAB(pt[1]) & ctype_xdigit) == 0)
     296      if (pt + 1 >= patternEnd || !isASCIIHexDigit(pt[1]))
    348297        {
    349298        pt = ptr;
    … …  
    374323
    375324    /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
    376     is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
    377     (However, an EBCDIC equivalent has now been added.) */
     325    is ASCII-specific, but then the whole concept of \cx is ASCII-specific. */
    378326
    379327    if (c >= 'a' && c <= 'z') c -= 32;
    380328    c ^= 0x40;
    381     break;
    382 
    383     default:
    384329    break;
    385330    }
    … …  
    404349  p         pointer to the first char after '{'
    405350
    406 Returns:    TRUE or FALSE
     351Returns:    true or false
    407352*/
    408353
    … …  
    411356{
    412357if (p >= patternEnd || !isASCIIDigit(*p))
    413     return FALSE;
     358    return false;
    414359p++;
    415360while (p < patternEnd && isASCIIDigit(*p))
    416361    p++;
    417362if (p < patternEnd && *p == '}')
    418     return TRUE;
     363    return true;
    419364
    420365if (p >= patternEnd || *p++ != ',')
    421     return FALSE;
     366    return false;
    422367if (p < patternEnd && *p == '}')
    423     return TRUE;
     368    return true;
    424369
    425370if (p >= patternEnd || !isASCIIDigit(*p))
    426     return FALSE;
     371    return false;
    427372p++;
    428373while (p < patternEnd && isASCIIDigit(*p))
    … …  
    513458Arguments:
    514459  code         pointer to the start of the group
    515   skipassert   TRUE if certain assertions are to be skipped
     460  skipassert   true if certain assertions are to be skipped
    516461
    517462Returns:       pointer to the first significant opcode
    … …  
    726671  endcode     points to where to stop
    727672
    728 Returns:      TRUE if what is matched could be empty
     673Returns:      true if what is matched could be empty
    729674*/
    730675
    … …  
    733678{
    734679register int c;
    735 for (code = first_significant_code(code + 1 + LINK_SIZE, TRUE);
     680for (code = first_significant_code(code + 1 + LINK_SIZE, true);
    736681     code < endcode;
    737      code = first_significant_code(code + OP_lengths[c], TRUE))
     682     code = first_significant_code(code + OP_lengths[c], true))
    738683  {
    739684  const uschar *ccode;
    … …  
    744689    {
    745690    BOOL empty_branch;
    746     if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
     691    if (GET(code, 1) == 0) return true;    /* Hit unclosed bracket */
    747692
    748693    /* Scan a closed bracket */
    749694
    750     empty_branch = FALSE;
     695    empty_branch = false;
    751696    do
    752697      {
    753698      if (!empty_branch && could_be_empty_branch(code, endcode))
    754         empty_branch = TRUE;
     699        empty_branch = true;
    755700      code += GET(code, 1);
    756701      }
    757702    while (*code == OP_ALT);
    758     if (!empty_branch) return FALSE;   /* All branches are non-empty */
     703    if (!empty_branch) return false;   /* All branches are non-empty */
    759704    code += 1 + LINK_SIZE;
    760705    c = *code;
    … …  
    786731      case OP_CRPLUS:            /* These repeats aren't empty */
    787732      case OP_CRMINPLUS:
    788       return FALSE;
     733      return false;
    789734
    790735      case OP_CRRANGE:
    791736      case OP_CRMINRANGE:
    792       if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
     737      if (GET2(ccode, 1) > 0) return false;  /* Minimum > 0 */
    793738      break;
    794739      }
    … …  
    818763    case OP_TYPEMINPLUS:
    819764    case OP_TYPEEXACT:
    820     return FALSE;
     765    return false;
    821766
    822767    /* End of branch */
    … …  
    826771    case OP_KETRMIN:
    827772    case OP_ALT:
    828     return TRUE;
     773    return true;
    829774
    830775    /* In UTF-8 mode, STAR, MINSTAR, QUERY, MINQUERY, UPTO, and MINUPTO  may be
    … …  
    842787  }
    843788
    844 return TRUE;
     789return true;
    845790}
    846791
    … …  
    887832  odptr       where to put end of othercase range
    888833
    889 Yield:        TRUE when range returned; FALSE when no more
     834Yield:        true when range returned; false when no more
    890835*/
    891836
    … …  
    898843  { if ((othercase = _pcre_ucp_othercase(c)) >= 0) break; }
    899844
    900 if (c > d) return FALSE;
     845if (c > d) return false;
    901846
    902847*ocptr = othercase;
    … …  
    912857*cptr = c;
    913858
    914 return TRUE;
     859return true;
    915860}
    916861
    … …  
    934879  cd             contains pointers to tables etc.
    935880
    936 Returns:         TRUE on success
    937                  FALSE, with *errorcodeptr set non-zero on error
     881Returns:         true on success
     882                 false, with *errorcodeptr set non-zero on error
    938883*/
    939884
    … …  
    953898register uschar *code = *codeptr;
    954899uschar *tempcode;
    955 BOOL groupsetfirstbyte = FALSE;
     900BOOL groupsetfirstbyte = false;
    956901const pcre_uchar *ptr = *ptrptr;
    957902const pcre_uchar *tempptr;
    … …  
    1030975    *codeptr = code;
    1031976    *ptrptr = ptr;
    1032     return TRUE;
     977    return true;
    1033978
    1034979    /* Handle single-character metacharacters. In multiline mode, ^ disables
    … …  
    10741019    case '[':
    10751020    previous = code;
    1076     should_flip_negation = FALSE;
     1021    should_flip_negation = false;
    10771022
    10781023    /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
    … …  
    10831028    if ((c = *(++ptr)) == '^')
    10841029      {
    1085       negate_class = TRUE;
     1030      negate_class = true;
    10861031      c = *(++ptr);
    10871032      }
    10881033    else
    10891034      {
    1090       negate_class = FALSE;
     1035      negate_class = false;
    10911036      }
    10921037
    … …  
    10981043    class_lastchar = -1;
    10991044
    1100     class_utf8 = FALSE;                       /* No chars >= 256 */
     1045    class_utf8 = false;                       /* No chars >= 256 */
    11011046    class_utf8data = code + LINK_SIZE + 34;   /* For UTF-8 items */
    11021047
    … …  
    11311076      if (c == '\\')
    11321077        {
    1133         c = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, TRUE);
     1078        c = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, true);
    11341079
    11351080        if (-c == ESC_b) c = '\b';       /* \b is backslash in a class */
    … …  
    11461091
    11471092            case ESC_D:
    1148             should_flip_negation = TRUE;
     1093            should_flip_negation = true;
    11491094            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
    11501095            continue;
    … …  
    11551100
    11561101            case ESC_W:
    1157             should_flip_negation = TRUE;
     1102            should_flip_negation = true;
    11581103            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
    11591104            continue;
    … …  
    11641109
    11651110            case ESC_S:
    1166             should_flip_negation = TRUE;
     1111            should_flip_negation = true;
    11671112            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
    11681113            continue;
    … …  
    12011146          {
    12021147          const pcre_uchar *oldptr = ptr;
    1203           d = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, TRUE);
     1148          d = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, true);
    12041149
    12051150          /* \b is backslash; \X is literal X; any other special means the '-'
    … …  
    12291174        if ((d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
    12301175          {
    1231           class_utf8 = TRUE;
     1176          class_utf8 = true;
    12321177
    12331178          /* With UCP support, we can find the other case equivalents of
    … …  
    13111256      if ((c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
    13121257        {
    1313         class_utf8 = TRUE;
     1258        class_utf8 = true;
    13141259        *class_utf8data++ = XCL_SINGLE;
    13151260        class_utf8data += _pcre_ord2utf8(c, class_utf8data);
    … …  
    14861431
    14871432    op_type = 0;                    /* Default single-char op codes */
    1488     possessive_quantifier = FALSE;  /* Default not possessive quantifier */
     1433    possessive_quantifier = false;  /* Default not possessive quantifier */
    14891434
    14901435    /* Save start of previous item, in case we have to move it up to make space
    … …  
    15021447      {
    15031448      repeat_type = 0;                  /* Force greedy */
    1504       possessive_quantifier = TRUE;
     1449      possessive_quantifier = true;
    15051450      ptr++;
    15061451      }
    … …  
    20031948    zeroreqbyte = reqbyte;
    20041949    zerofirstbyte = firstbyte;
    2005     groupsetfirstbyte = FALSE;
     1950    groupsetfirstbyte = false;
    20061951
    20071952    if (bravalue >= OP_BRA || bravalue == OP_ONCE)
    … …  
    20181963          {
    20191964          firstbyte = subfirstbyte;
    2020           groupsetfirstbyte = TRUE;
     1965          groupsetfirstbyte = true;
    20211966          }
    20221967        else firstbyte = REQ_NONE;
    … …  
    20662011    case '\\':
    20672012    tempptr = ptr;
    2068     c = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, FALSE);
     2013    c = check_escape(&ptr, patternEnd, errorcodeptr, *brackets, false);
    20692014
    20702015    /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
    … …  
    21862131FAILED:
    21872132*ptrptr = ptr;
    2188 return FALSE;
     2133return false;
    21892134}
    21902135
    … …  
    22152160  cd             points to the data block with tables pointers etc.
    22162161
    2217 Returns:      TRUE on success
     2162Returns:      true on success
    22182163*/
    22192164
    … …  
    22472192    {
    22482193    *ptrptr = ptr;
    2249     return FALSE;
     2194    return false;
    22502195    }
    22512196
    … …  
    23222267    *firstbyteptr = firstbyte;
    23232268    *reqbyteptr = reqbyte;
    2324     return TRUE;
     2269    return true;
    23252270    }
    23262271
    … …  
    23772322  backref_map    the back reference bitmap
    23782323
    2379 Returns:     TRUE or FALSE
     2324Returns:     true or false
    23802325*/
    23812326
    … …  
    23862331do {
    23872332   const uschar *scode =
    2388      first_significant_code(code + 1+LINK_SIZE, FALSE);
     2333     first_significant_code(code + 1+LINK_SIZE, false);
    23892334   register int op = *scode;
    23902335
    … …  
    23972342     if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
    23982343     new_map = bracket_map | ((op < 32)? (1 << op) : 1);
    2399      if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
     2344     if (!is_anchored(scode, options, new_map, backref_map)) return false;
    24002345     }
    24012346
    … …  
    24042349   else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE)
    24052350     {
    2406      if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
     2351     if (!is_anchored(scode, options, bracket_map, backref_map)) return false;
    24072352     }
    24082353
    … …  
    24102355
    24112356   else if (((options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
    2412      return FALSE;
     2357     return false;
    24132358   code += GET(code, 1);
    24142359   }
    24152360while (*code == OP_ALT);   /* Loop for each alternative */
    2416 return TRUE;
     2361return true;
    24172362}
    24182363
    … …  
    24372382  backref_map    the back reference bitmap
    24382383
    2439 Returns:         TRUE or FALSE
     2384Returns:         true or false
    24402385*/
    24412386
    … …  
    24452390{
    24462391do {
    2447    const uschar *scode = first_significant_code(code + 1+LINK_SIZE, FALSE);
     2392   const uschar *scode = first_significant_code(code + 1+LINK_SIZE, false);
    24482393   register int op = *scode;
    24492394
    … …  
    24562401     if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
    24572402     new_map = bracket_map | ((op < 32)? (1 << op) : 1);
    2458      if (!is_startline(scode, new_map, backref_map)) return FALSE;
     2403     if (!is_startline(scode, new_map, backref_map)) return false;
    24592404     }
    24602405
    … …  
    24622407
    24632408   else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE)
    2464      { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
     2409     { if (!is_startline(scode, bracket_map, backref_map)) return false; }
    24652410
    24662411   /* .* means "start at start or after \n" if it isn't in brackets that
    … …  
    24692414   else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
    24702415     {
    2471      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
     2416     if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return false;
    24722417     }
    24732418
    24742419   /* Check for explicit circumflex */
    24752420
    2476    else if (op != OP_CIRC) return FALSE;
     2421   else if (op != OP_CIRC) return false;
    24772422
    24782423   /* Move on to the next alternative */
    … …  
    24812426   }
    24822427while (*code == OP_ALT);  /* Loop for each alternative */
    2483 return TRUE;
     2428return true;
    24842429}
    24852430
    … …  
    25012446  code       points to start of expression (the bracket)
    25022447  options    pointer to the options (used to check casing changes)
    2503   inassert   TRUE if in an assertion
     2448  inassert   true if in an assertion
    25042449
    25052450Returns:     -1 or the fixed first char
    … …  
    25132458   int d;
    25142459   const uschar *scode =
    2515      first_significant_code(code + 1+LINK_SIZE, TRUE);
     2460     first_significant_code(code + 1+LINK_SIZE, true);
    25162461   register int op = *scode;
    25172462
    … …  
    26572602  c = *ptr;
    26582603 
    2659   /* If we are inside a \Q...\E sequence, all chars are literal */
    2660 
    26612604  item_count++;    /* Is zero for the first non-comment item */
    26622605
    … …  
    26672610
    26682611    case '\\':
    2669     c = check_escape(&ptr, patternEnd, &errorcode, bracount, FALSE);
     2612    c = check_escape(&ptr, patternEnd, &errorcode, bracount, false);
    26702613    if (errorcode != 0) goto PCRE_ERROR_RETURN;
    26712614
    … …  
    27912734    else class_optcount = 0;
    27922735
    2793     class_utf8 = FALSE;
     2736    class_utf8 = false;
    27942737
    27952738    /* Written as a "do" so that an initial ']' is taken as data */
    … …  
    28012744      if (*ptr == '\\')
    28022745        {
    2803         c = check_escape(&ptr, patternEnd, &errorcode, bracount, TRUE);
     2746        c = check_escape(&ptr, patternEnd, &errorcode, bracount, true);
    28042747        if (errorcode != 0) goto PCRE_ERROR_RETURN;
    28052748
    … …  
    28492792            {
    28502793            ptr++;
    2851             d = check_escape(&ptr, patternEnd, &errorcode, bracount, TRUE);
     2794            d = check_escape(&ptr, patternEnd, &errorcode, bracount, true);
    28522795            if (errorcode != 0) goto PCRE_ERROR_RETURN;
    28532796            if (-d == ESC_b) d = '\b';        /* backspace */
    … …  
    28822825            if (!class_utf8)         /* Allow for XCLASS overhead */
    28832826              {
    2884               class_utf8 = TRUE;
     2827              class_utf8 = true;
    28852828              length += LINK_SIZE + 2;
    28862829              }
    … …  
    29392882            if (!class_utf8)         /* Allow for XCLASS overhead */
    29402883              {
    2941               class_utf8 = TRUE;
     2884              class_utf8 = true;
    29422885              length += LINK_SIZE + 2;
    29432886              }
    … …  
    29892932    branch_newextra = 0;
    29902933    bracket_length = 1 + LINK_SIZE;
    2991     capturing = FALSE;
     2934    capturing = false;
    29922935
    29932936    /* Handle special forms of bracket, which all start (? */
    … …  
    32373180    {
    32383181    if (firstbyte < 0)
    3239       firstbyte = find_firstassertedchar(codestart, re->options, FALSE);
     3182      firstbyte = find_firstassertedchar(codestart, re->options, false);
    32403183    if (firstbyte >= 0)   /* Remove caseless flag for non-caseable chars */
    32413184      {
Note: See TracChangeset for help on using the changeset viewer.