1 /* This is JavaScriptCore's variant of the PCRE library. While this library

     2 started out as a copy of PCRE, many of the features of PCRE have been

     3 removed. This library now supports only the regular expression features

     4 required by the JavaScript language specification, and has only the functions

     5 needed by JavaScriptCore and the rest of WebKit.

     6 

     7                  Originally written by Philip Hazel

     8            Copyright (c) 1997-2006 University of Cambridge

     9     Copyright (C) 2002, 2004, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

    10     Copyright (C) 2007 Eric Seidel <eric@webkit.org>

    11 

    12 -----------------------------------------------------------------------------

    13 Redistribution and use in source and binary forms, with or without

    14 modification, are permitted provided that the following conditions are met:

    15 

    16     * Redistributions of source code must retain the above copyright notice,

    17       this list of conditions and the following disclaimer.

    18 

    19     * Redistributions in binary form must reproduce the above copyright

    20       notice, this list of conditions and the following disclaimer in the

    21       documentation and/or other materials provided with the distribution.

    22 

    23     * Neither the name of the University of Cambridge nor the names of its

    24       contributors may be used to endorse or promote products derived from

    25       this software without specific prior written permission.

    26 

    27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

    31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    37 POSSIBILITY OF SUCH DAMAGE.

    38 -----------------------------------------------------------------------------

    39 */

    40 

    41 /* This module contains jsRegExpExecute(), the externally visible function

    42 that does pattern matching using an NFA algorithm, following the rules from

    43 the JavaScript specification. There are also some supporting functions. */

    44 

    45 #include "config.h"

    46 #include "pcre_internal.h"

    47 

    48 #include <limits.h>

    49 #include <wtf/ASCIICType.h>

    50 #include <wtf/Vector.h>

    51 

    52 #if REGEXP_HISTOGRAM

    53 #include <wtf/DateMath.h>

    54 #include <runtime/UString.h>

    55 #endif

    56 

    57 using namespace WTF;

    58 

    59 #if COMPILER(GCC)

    60 #define USE_COMPUTED_GOTO_FOR_MATCH_RECURSION

    61 //#define USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

    62 #endif

    63 

    64 /* Avoid warnings on Windows. */

    65 #undef min

    66 #undef max

    67 

    68 #ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION

    69 typedef int ReturnLocation;

    70 #else

    71 typedef void* ReturnLocation;

    72 #endif

    73 

    74 #if !REGEXP_HISTOGRAM

    75 

    76 class HistogramTimeLogger {

    77 public:

    78     HistogramTimeLogger(const JSRegExp*) { }

    79 };

    80 

    81 #else

    82 

    83 using namespace JSC;

    84 

    85 class Histogram {

    86 public:

    87     ~Histogram();

    88     void add(const JSRegExp*, double);

    89 

    90 private:

    91     typedef HashMap<RefPtr<UString::Rep>, double> Map;

    92     Map times;

    93 };

    94 

    95 class HistogramTimeLogger {

    96 public:

    97     HistogramTimeLogger(const JSRegExp*);

    98     ~HistogramTimeLogger();

    99 

   100 private:

   101     const JSRegExp* m_re;

   102     double m_startTime;

   103 };

   104 

   105 #endif

   106 

   107 /* Structure for building a chain of data for holding the values of

   108 the subject pointer at the start of each bracket, used to detect when

   109 an empty string has been matched by a bracket to break infinite loops. */ 

   110 struct BracketChainNode {

   111     BracketChainNode* previousBracket;

   112     const UChar* bracketStart;

   113 };

   114 

   115 struct MatchFrame : FastAllocBase {

   116     ReturnLocation returnLocation;

   117     struct MatchFrame* previousFrame;

   118     

   119     /* Function arguments that may change */

   120     struct {

   121         const UChar* subjectPtr;

   122         const unsigned char* instructionPtr;

   123         int offsetTop;

   124         BracketChainNode* bracketChain;

   125     } args;

   126     

   127     

   128     /* PCRE uses "fake" recursion built off of gotos, thus

   129      stack-based local variables are not safe to use.  Instead we have to

   130      store local variables on the current MatchFrame. */

   131     struct {

   132         const unsigned char* data;

   133         const unsigned char* startOfRepeatingBracket;

   134         const UChar* subjectPtrAtStartOfInstruction; // Several instrutions stash away a subjectPtr here for later compare

   135         const unsigned char* instructionPtrAtStartOfOnce;

   136         

   137         int repeatOthercase;

   138         

   139         int ctype;

   140         int fc;

   141         int fi;

   142         int length;

   143         int max;

   144         int number;

   145         int offset;

   146         int saveOffset1;

   147         int saveOffset2;

   148         int saveOffset3;

   149         

   150         BracketChainNode bracketChainNode;

   151     } locals;

   152 };

   153 

   154 /* Structure for passing "static" information around between the functions

   155 doing traditional NFA matching, so that they are thread-safe. */

   156 

   157 struct MatchData {

   158   int*   offsetVector;         /* Offset vector */

   159   int    offsetEnd;            /* One past the end */

   160   int    offsetMax;            /* The maximum usable for return data */

   161   bool   offsetOverflow;       /* Set if too many extractions */

   162   const UChar*  startSubject;         /* Start of the subject string */

   163   const UChar*  endSubject;           /* End of the subject string */

   164   const UChar*  endMatchPtr;         /* Subject position at end match */

   165   int    endOffsetTop;        /* Highwater mark at end of match */

   166   bool   multiline;

   167   bool   ignoreCase;

   168 };

   169 

   170 /* The maximum remaining length of subject we are prepared to search for a

   171 reqByte match. */

   172 

   173 #define REQ_BYTE_MAX 1000

   174 

   175 /* The below limit restricts the number of "recursive" match calls in order to

   176 avoid spending exponential time on complex regular expressions. */

   177 

   178 static const unsigned matchLimit = 1000000;

   179 

   180 #ifdef DEBUG

   181 /*************************************************

   182 *        Debugging function to print chars       *

   183 *************************************************/

   184 

   185 /* Print a sequence of chars in printable format, stopping at the end of the

   186 subject if the requested.

   187 

   188 Arguments:

   189   p           points to characters

   190   length      number to print

   191   isSubject  true if printing from within md.startSubject

   192   md          pointer to matching data block, if isSubject is true

   193 */

   194 

   195 static void pchars(const UChar* p, int length, bool isSubject, const MatchData& md)

   196 {

   197     if (isSubject && length > md.endSubject - p)

   198         length = md.endSubject - p;

   199     while (length-- > 0) {

   200         int c;

   201         if (isASCIIPrintable(c = *(p++)))

   202             printf("%c", c);

   203         else if (c < 256)

   204             printf("\\x%02x", c);

   205         else

   206             printf("\\x{%x}", c);

   207     }

   208 }

   209 #endif

   210 

   211 /*************************************************

   212 *          Match a back-reference                *

   213 *************************************************/

   214 

   215 /* If a back reference hasn't been set, the length that is passed is greater

   216 than the number of characters left in the string, so the match fails.

   217 

   218 Arguments:

   219   offset      index into the offset vector

   220   subjectPtr        points into the subject

   221   length      length to be matched

   222   md          points to match data block

   223 

   224 Returns:      true if matched

   225 */

   226 

   227 static bool matchRef(int offset, const UChar* subjectPtr, int length, const MatchData& md)

   228 {

   229     const UChar* p = md.startSubject + md.offsetVector[offset];

   230     

   231 #ifdef DEBUG

   232     if (subjectPtr >= md.endSubject)

   233         printf("matching subject <null>");

   234     else {

   235         printf("matching subject ");

   236         pchars(subjectPtr, length, true, md);

   237     }

   238     printf(" against backref ");

   239     pchars(p, length, false, md);

   240     printf("\n");

   241 #endif

   242     

   243     /* Always fail if not enough characters left */

   244     

   245     if (length > md.endSubject - subjectPtr)

   246         return false;

   247     

   248     /* Separate the caselesss case for speed */

   249     

   250     if (md.ignoreCase) {

   251         while (length-- > 0) {

   252             UChar c = *p++;

   253             int othercase = jsc_pcre_ucp_othercase(c);

   254             UChar d = *subjectPtr++;

   255             if (c != d && othercase != d)

   256                 return false;

   257         }

   258     }

   259     else {

   260         while (length-- > 0)

   261             if (*p++ != *subjectPtr++)

   262                 return false;

   263     }

   264     

   265     return true;

   266 }

   267 

   268 #ifndef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION

   269 

   270 /* Use numbered labels and switch statement at the bottom of the match function. */

   271 

   272 #define RMATCH_WHERE(num) num

   273 #define RRETURN_LABEL RRETURN_SWITCH

   274 

   275 #else

   276 

   277 /* Use GCC's computed goto extension. */

   278 

   279 /* For one test case this is more than 40% faster than the switch statement.

   280 We could avoid the use of the num argument entirely by using local labels,

   281 but using it for the GCC case as well as the non-GCC case allows us to share

   282 a bit more code and notice if we use conflicting numbers.*/

   283 

   284 #define RMATCH_WHERE(num) &&RRETURN_##num

   285 #define RRETURN_LABEL *stack.currentFrame->returnLocation

   286 

   287 #endif

   288 

   289 #define RECURSIVE_MATCH_COMMON(num) \

   290     goto RECURSE;\

   291     RRETURN_##num: \

   292     stack.popCurrentFrame();

   293 

   294 #define RECURSIVE_MATCH(num, ra, rb) \

   295     do { \

   296         stack.pushNewFrame((ra), (rb), RMATCH_WHERE(num)); \

   297         RECURSIVE_MATCH_COMMON(num) \

   298     } while (0)

   299 

   300 #define RECURSIVE_MATCH_NEW_GROUP(num, ra, rb) \

   301     do { \

   302         stack.pushNewFrame((ra), (rb), RMATCH_WHERE(num)); \

   303         startNewGroup(stack.currentFrame); \

   304         RECURSIVE_MATCH_COMMON(num) \

   305     } while (0)

   306 

   307 #define RRETURN goto RRETURN_LABEL

   308 

   309 #define RRETURN_NO_MATCH do { isMatch = false; RRETURN; } while (0)

   310 

   311 /*************************************************

   312 *         Match from current position            *

   313 *************************************************/

   314 

   315 /* On entry instructionPtr points to the first opcode, and subjectPtr to the first character

   316 in the subject string, while substringStart holds the value of subjectPtr at the start of the

   317 last bracketed group - used for breaking infinite loops matching zero-length

   318 strings. This function is called recursively in many circumstances. Whenever it

   319 returns a negative (error) response, the outer match() call must also return the

   320 same response.

   321 

   322 Arguments:

   323    subjectPtr        pointer in subject

   324    instructionPtr       position in code

   325    offsetTop  current top pointer

   326    md          pointer to "static" info for the match

   327 

   328 Returns:       1 if matched          )  these values are >= 0

   329                0 if failed to match  )

   330                a negative error value if aborted by an error condition

   331                  (e.g. stopped by repeated call or recursion limit)

   332 */

   333 

   334 static const unsigned numFramesOnStack = 16;

   335 

   336 struct MatchStack {

   337     MatchStack()

   338         : framesEnd(frames + numFramesOnStack)

   339         , currentFrame(frames)

   340         , size(1) // match() creates accesses the first frame w/o calling pushNewFrame

   341     {

   342         ASSERT((sizeof(frames) / sizeof(frames[0])) == numFramesOnStack);

   343     }

   344     

   345     MatchFrame frames[numFramesOnStack];

   346     MatchFrame* framesEnd;

   347     MatchFrame* currentFrame;

   348     unsigned size;

   349     

   350     inline bool canUseStackBufferForNextFrame()

   351     {

   352         return size < numFramesOnStack;

   353     }

   354     

   355     inline MatchFrame* allocateNextFrame()

   356     {

   357         if (canUseStackBufferForNextFrame())

   358             return currentFrame + 1;

   359         return new MatchFrame;

   360     }

   361     

   362     inline void pushNewFrame(const unsigned char* instructionPtr, BracketChainNode* bracketChain, ReturnLocation returnLocation)

   363     {

   364         MatchFrame* newframe = allocateNextFrame();

   365         newframe->previousFrame = currentFrame;

   366 

   367         newframe->args.subjectPtr = currentFrame->args.subjectPtr;

   368         newframe->args.offsetTop = currentFrame->args.offsetTop;

   369         newframe->args.instructionPtr = instructionPtr;

   370         newframe->args.bracketChain = bracketChain;

   371         newframe->returnLocation = returnLocation;

   372         size++;

   373 

   374         currentFrame = newframe;

   375     }

   376     

   377     inline void popCurrentFrame()

   378     {

   379         MatchFrame* oldFrame = currentFrame;

   380         currentFrame = currentFrame->previousFrame;

   381         if (size > numFramesOnStack)

   382             delete oldFrame;

   383         size--;

   384     }

   385 

   386     void popAllFrames()

   387     {

   388         while (size)

   389             popCurrentFrame();

   390     }

   391 };

   392 

   393 static int matchError(int errorCode, MatchStack& stack)

   394 {

   395     stack.popAllFrames();

   396     return errorCode;

   397 }

   398 

   399 /* Get the next UTF-8 character, not advancing the pointer, incrementing length

   400  if there are extra bytes. This is called when we know we are in UTF-8 mode. */

   401 

   402 static inline void getUTF8CharAndIncrementLength(int& c, const unsigned char* subjectPtr, int& len)

   403 {

   404     c = *subjectPtr;

   405     if ((c & 0xc0) == 0xc0) {

   406         int gcaa = jsc_pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */

   407         int gcss = 6 * gcaa;

   408         c = (c & jsc_pcre_utf8_table3[gcaa]) << gcss;

   409         for (int gcii = 1; gcii <= gcaa; gcii++) {

   410             gcss -= 6;

   411             c |= (subjectPtr[gcii] & 0x3f) << gcss;

   412         }

   413         len += gcaa;

   414     }

   415 }

   416 

   417 static inline void startNewGroup(MatchFrame* currentFrame)

   418 {

   419     /* At the start of a bracketed group, add the current subject pointer to the

   420      stack of such pointers, to be re-instated at the end of the group when we hit

   421      the closing ket. When match() is called in other circumstances, we don't add to

   422      this stack. */

   423     

   424     currentFrame->locals.bracketChainNode.previousBracket = currentFrame->args.bracketChain;

   425     currentFrame->locals.bracketChainNode.bracketStart = currentFrame->args.subjectPtr;

   426     currentFrame->args.bracketChain = &currentFrame->locals.bracketChainNode;

   427 }

   428 

   429 // FIXME: "minimize" means "not greedy", we should invert the callers to ask for "greedy" to be less confusing

   430 static inline void repeatInformationFromInstructionOffset(int instructionOffset, bool& minimize, int& minimumRepeats, int& maximumRepeats)

   431 {

   432     // Instruction offsets are based off of OP_CRSTAR, OP_STAR, OP_TYPESTAR, OP_NOTSTAR

   433     static const char minimumRepeatsFromInstructionOffset[] = { 0, 0, 1, 1, 0, 0 };

   434     static const int maximumRepeatsFromInstructionOffset[] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX, 1, 1 };

   435 

   436     ASSERT(instructionOffset >= 0);

   437     ASSERT(instructionOffset <= (OP_CRMINQUERY - OP_CRSTAR));

   438 

   439     minimize = (instructionOffset & 1); // this assumes ordering: Instruction, MinimizeInstruction, Instruction2, MinimizeInstruction2

   440     minimumRepeats = minimumRepeatsFromInstructionOffset[instructionOffset];

   441     maximumRepeats = maximumRepeatsFromInstructionOffset[instructionOffset];

   442 }

   443 

   444 static int match(const UChar* subjectPtr, const unsigned char* instructionPtr, int offsetTop, MatchData& md)

   445 {

   446     bool isMatch = false;

   447     int min;

   448     bool minimize = false; /* Initialization not really needed, but some compilers think so. */

   449     unsigned remainingMatchCount = matchLimit;

   450     int othercase; /* Declare here to avoid errors during jumps */

   451     

   452     MatchStack stack;

   453 

   454     /* The opcode jump table. */

   455 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

   456 #define EMIT_JUMP_TABLE_ENTRY(opcode) &&LABEL_OP_##opcode,

   457     static void* opcodeJumpTable[256] = { FOR_EACH_OPCODE(EMIT_JUMP_TABLE_ENTRY) };

   458 #undef EMIT_JUMP_TABLE_ENTRY

   459 #endif

   460     

   461     /* One-time setup of the opcode jump table. */

   462 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

   463     for (int i = 255; !opcodeJumpTable[i]; i--)

   464         opcodeJumpTable[i] = &&CAPTURING_BRACKET;

   465 #endif

   466     

   467 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION

   468     // Shark shows this as a hot line

   469     // Using a static const here makes this line disappear, but makes later access hotter (not sure why)

   470     stack.currentFrame->returnLocation = &&RETURN;

   471 #else

   472     stack.currentFrame->returnLocation = 0;

   473 #endif

   474     stack.currentFrame->args.subjectPtr = subjectPtr;

   475     stack.currentFrame->args.instructionPtr = instructionPtr;

   476     stack.currentFrame->args.offsetTop = offsetTop;

   477     stack.currentFrame->args.bracketChain = 0;

   478     startNewGroup(stack.currentFrame);

   479     

   480     /* This is where control jumps back to to effect "recursion" */

   481     

   482 RECURSE:

   483     if (!--remainingMatchCount)

   484         return matchError(JSRegExpErrorHitLimit, stack);

   485 

   486     /* Now start processing the operations. */

   487     

   488 #ifndef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

   489     while (true)

   490 #endif

   491     {

   492         

   493 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

   494 #define BEGIN_OPCODE(opcode) LABEL_OP_##opcode

   495 #define NEXT_OPCODE goto *opcodeJumpTable[*stack.currentFrame->args.instructionPtr]

   496 #else

   497 #define BEGIN_OPCODE(opcode) case OP_##opcode

   498 #define NEXT_OPCODE continue

   499 #endif

   500         

   501 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP

   502         NEXT_OPCODE;

   503 #else

   504         switch (*stack.currentFrame->args.instructionPtr)

   505 #endif

   506         {

   507             /* Non-capturing bracket: optimized */

   508                 

   509             BEGIN_OPCODE(BRA):

   510             NON_CAPTURING_BRACKET:

   511                 DPRINTF(("start bracket 0\n"));

   512                 do {

   513                     RECURSIVE_MATCH_NEW_GROUP(2, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);

   514                     if (isMatch)

   515                         RRETURN;

   516                     stack.currentFrame->args.instructionPtr += getLinkValue(stack.currentFrame->args.instructionPtr + 1);

   517                 } while (*stack.currentFrame->args.instructionPtr == OP_ALT);

   518                 DPRINTF(("bracket 0 failed\n"));

   519                 RRETURN;

   520                 

   521             /* Skip over large extraction number data if encountered. */

   522                 

   523             BEGIN_OPCODE(BRANUMBER):

   524                 stack.currentFrame->args.instructionPtr += 3;

   525                 NEXT_OPCODE;

   526                 

   527             /* End of the pattern. */

   528                 

   529             BEGIN_OPCODE(END):

   530                 md.endMatchPtr = stack.currentFrame->args.subjectPtr;          /* Record where we ended */

   531                 md.endOffsetTop = stack.currentFrame->args.offsetTop;   /* and how many extracts were taken */

   532                 isMatch = true;

   533                 RRETURN;

   534                 

   535             /* Assertion brackets. Check the alternative branches in turn - the

   536              matching won't pass the KET for an assertion. If any one branch matches,

   537              the assertion is true. Lookbehind assertions have an OP_REVERSE item at the

   538              start of each branch to move the current point backwards, so the code at

   539              this level is identical to the lookahead case. */

   540                 

   541             BEGIN_OPCODE(ASSERT):

   542                 do {

   543                     RECURSIVE_MATCH_NEW_GROUP(6, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);

   544                     if (isMatch)

   545                         break;

   546                     stack.currentFrame->args.instructionPtr += getLinkValue(stack.currentFrame->args.instructionPtr + 1);

   547                 } while (*stack.currentFrame->args.instructionPtr == OP_ALT);

   548                 if (*stack.currentFrame->args.instructionPtr == OP_KET)

   549                     RRETURN_NO_MATCH;

   550                 

   551                 /* Continue from after the assertion, updating the offsets high water

   552                  mark, since extracts may have been taken during the assertion. */

   553                 

   554                 advanceToEndOfBracket(stack.currentFrame->args.instructionPtr);

   555                 stack.currentFrame->args.instructionPtr += 1 + LINK_SIZE;

   556                 stack.currentFrame->args.offsetTop = md.endOffsetTop;

   557                 NEXT_OPCODE;

   558                 

   559             /* Negative assertion: all branches must fail to match */

   560                 

   561             BEGIN_OPCODE(ASSERT_NOT):

   562                 do {

   563                     RECURSIVE_MATCH_NEW_GROUP(7, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, NULL);

   564                     if (isMatch)

   565                         RRETURN_NO_MATCH;

   566                     stack.currentFrame->args.instructionPtr += getLinkValue(stack.currentFrame->args.instructionPtr + 1);

   567                 } while (*stack.currentFrame->args.instructionPtr == OP_ALT);

   568                 

   569                 stack.currentFrame->args.instructionPtr += 1 + LINK_SIZE;

   570                 NEXT_OPCODE;

   571                 

   572             /* An alternation is the end of a branch; scan along to find the end of the

   573              bracketed group and go to there. */

   574                 

   575             BEGIN_OPCODE(ALT):

   576                 advanceToEndOfBracket(stack.currentFrame->args.instructionPtr);

   577                 NEXT_OPCODE;

   578                 

   579             /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating

   580              that it may occur zero times. It may repeat infinitely, or not at all -

   581              i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper

   582              repeat limits are compiled as a number of copies, with the optional ones

   583              preceded by BRAZERO or BRAMINZERO. */

   584                 

   585             BEGIN_OPCODE(BRAZERO): {

   586                 stack.currentFrame->locals.startOfRepeatingBracket = stack.currentFrame->args.instructionPtr + 1;

   587                 RECURSIVE_MATCH_NEW_GROUP(14, stack.currentFrame->locals.startOfRepeatingBracket, stack.currentFrame->args.bracketChain);

   588                 if (isMatch)

   589                     RRETURN;

   590                 advanceToEndOfBracket(stack.currentFrame->locals.startOfRepeatingBracket);

   591                 stack.currentFrame->args.instructionPtr = stack.currentFrame->locals.startOfRepeatingBracket + 1 + LINK_SIZE;

   592                 NEXT_OPCODE;

   593             }

   594                 

   595             BEGIN_OPCODE(BRAMINZERO): {

   596                 stack.currentFrame->locals.startOfRepeatingBracket = stack.currentFrame->args.instructionPtr + 1;

   597                 advanceToEndOfBracket(stack.currentFrame->locals.startOfRepeatingBracket);

   598                 RECURSIVE_MATCH_NEW_GROUP(15, stack.currentFrame->locals.startOfRepeatingBracket + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);

   599                 if (isMatch)

   600                     RRETURN;

   601                 stack.currentFrame->args.instructionPtr++;

   602                 NEXT_OPCODE;

   603             }

   604                 

   605             /* End of a group, repeated or non-repeating. If we are at the end of

   606              an assertion "group", stop matching and return 1, but record the

   607              current high water mark for use by positive assertions. Do this also

   608              for the "once" (not-backup up) groups. */

   609                 

   610             BEGIN_OPCODE(KET):

   611             BEGIN_OPCODE(KETRMIN):

   612             BEGIN_OPCODE(KETRMAX):

   613                 stack.currentFrame->locals.instructionPtrAtStartOfOnce = stack.currentFrame->args.instructionPtr - getLinkValue(stack.currentFrame->args.instructionPtr + 1);

   614                 stack.currentFrame->locals.subjectPtrAtStartOfInstruction = stack.currentFrame->args.bracketChain->bracketStart;

   615 

   616                 /* Back up the stack of bracket start pointers. */

   617 

   618                 stack.currentFrame->args.bracketChain = stack.currentFrame->args.bracketChain->previousBracket;

   619 

   620                 if (*stack.currentFrame->locals.instructionPtrAtStartOfOnce == OP_ASSERT || *stack.currentFrame->locals.instructionPtrAtStartOfOnce == OP_ASSERT_NOT) {

   621                     md.endOffsetTop = stack.currentFrame->args.offsetTop;

   622                     isMatch = true;

   623                     RRETURN;

   624                 }

   625                 

   626                 /* In all other cases except a conditional group we have to check the

   627                  group number back at the start and if necessary complete handling an

   628                  extraction by setting the offsets and bumping the high water mark. */

   629                 

   630                 stack.currentFrame->locals.number = *stack.currentFrame->locals.instructionPtrAtStartOfOnce - OP_BRA;

   631                 

   632                 /* For extended extraction brackets (large number), we have to fish out

   633                  the number from a dummy opcode at the start. */

   634                 

   635                 if (stack.currentFrame->locals.number > EXTRACT_BASIC_MAX)

   636                     stack.currentFrame->locals.number = get2ByteValue(stack.currentFrame->locals.instructionPtrAtStartOfOnce + 2 + LINK_SIZE);

   637                 stack.currentFrame->locals.offset = stack.currentFrame->locals.number << 1;

   638                 

   639 #ifdef DEBUG

   640                 printf("end bracket %d", stack.currentFrame->locals.number);

   641                 printf("\n");

   642 #endif

   643                 

   644                 /* Test for a numbered group. This includes groups called as a result

   645                  of recursion. Note that whole-pattern recursion is coded as a recurse

   646                  into group 0, so it won't be picked up here. Instead, we catch it when

   647                  the OP_END is reached. */

   648                 

   649                 if (stack.currentFrame->locals.number > 0) {

   650                     if (stack.currentFrame->locals.offset >= md.offsetMax)

   651                         md.offsetOverflow = true;

   652                     else {

   653                         md.offsetVector[stack.currentFrame->locals.offset] =

   654                         md.offsetVector[md.offsetEnd - stack.currentFrame->locals.number];

   655                         md.offsetVector[stack.currentFrame->locals.offset+1] = stack.currentFrame->args.subjectPtr - md.startSubject;

   656                         if (stack.currentFrame->args.offsetTop <= stack.currentFrame->locals.offset)

   657                             stack.currentFrame->args.offsetTop = stack.currentFrame->locals.offset + 2;

   658                     }

   659                 }

   660                 

   661                 /* For a non-repeating ket, just continue at this level. This also

   662                  happens for a repeating ket if no characters were matched in the group.

   663                  This is the forcible breaking of infinite loops as implemented in Perl

   664                  5.005. If there is an options reset, it will get obeyed in the normal

   665                  course of events. */

   666                 

   667                 if (*stack.currentFrame->args.instructionPtr == OP_KET || stack.currentFrame->args.subjectPtr == stack.currentFrame->locals.subjectPtrAtStartOfInstruction) {

   668                     stack.currentFrame->args.instructionPtr += 1 + LINK_SIZE;

   669                     NEXT_OPCODE;

   670                 }

   671                 

   672                 /* The repeating kets try the rest of the pattern or restart from the

   673                  preceding bracket, in the appropriate order. */

   674                 

   675                 if (*stack.currentFrame->args.instructionPtr == OP_KETRMIN) {

   676                     RECURSIVE_MATCH(16, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);

   677                     if (isMatch)

   678                         RRETURN;

   679                     RECURSIVE_MATCH_NEW_GROUP(17, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);

   680                     if (isMatch)

   681                         RRETURN;

   682                 } else { /* OP_KETRMAX */

   683                     RECURSIVE_MATCH_NEW_GROUP(18, stack.currentFrame->locals.instructionPtrAtStartOfOnce, stack.currentFrame->args.bracketChain);

   684                     if (isMatch)

   685                         RRETURN;

   686                     RECURSIVE_MATCH(19, stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE, stack.currentFrame->args.bracketChain);

   687                     if (isMatch)

   688                         RRETURN;

   689                 }

   690                 RRETURN;

   691                 

   692             /* Start of subject. */

   693 

   694             BEGIN_OPCODE(CIRC):

   695                 if (stack.currentFrame->args.subjectPtr != md.startSubject)

   696                     RRETURN_NO_MATCH;

   697                 stack.currentFrame->args.instructionPtr++;

   698                 NEXT_OPCODE;

   699 

   700             /* After internal newline if multiline. */

   701 

   702             BEGIN_OPCODE(BOL):

   703                 if (stack.currentFrame->args.subjectPtr != md.startSubject && !isNewline(stack.currentFrame->args.subjectPtr[-1]))

   704                     RRETURN_NO_MATCH;

   705                 stack.currentFrame->args.instructionPtr++;

   706                 NEXT_OPCODE;

   707 

   708             /* End of subject. */

   709 

   710             BEGIN_OPCODE(DOLL):

   711                 if (stack.currentFrame->args.subjectPtr < md.endSubject)

   712                     RRETURN_NO_MATCH;

   713                 stack.currentFrame->args.instructionPtr++;

   714                 NEXT_OPCODE;

   715 

   716             /* Before internal newline if multiline. */

   717 

   718             BEGIN_OPCODE(EOL):

   719                 if (stack.currentFrame->args.subjectPtr < md.endSubject && !isNewline(*stack.currentFrame->args.subjectPtr))

   720                     RRETURN_NO_MATCH;

   721                 stack.currentFrame->args.instructionPtr++;

   722                 NEXT_OPCODE;

   723                 

   724             /* Word boundary assertions */

   725                 

   726             BEGIN_OPCODE(NOT_WORD_BOUNDARY):

   727             BEGIN_OPCODE(WORD_BOUNDARY): {

   728                 bool currentCharIsWordChar = false;

   729                 bool previousCharIsWordChar = false;

   730                 

   731                 if (stack.currentFrame->args.subjectPtr > md.startSubject)

   732                     previousCharIsWordChar = isWordChar(stack.currentFrame->args.subjectPtr[-1]);

   733                 if (stack.currentFrame->args.subjectPtr < md.endSubject)

   734                     currentCharIsWordChar = isWordChar(*stack.currentFrame->args.subjectPtr);

   735                 

   736                 /* Now see if the situation is what we want */

   737                 bool wordBoundaryDesired = (*stack.currentFrame->args.instructionPtr++ == OP_WORD_BOUNDARY);

   738                 if (wordBoundaryDesired ? currentCharIsWordChar == previousCharIsWordChar : currentCharIsWordChar != previousCharIsWordChar)

   739                     RRETURN_NO_MATCH;

   740                 NEXT_OPCODE;

   741             }

   742                 

   743             /* Match a single character type; inline for speed */

   744                 

   745             BEGIN_OPCODE(NOT_NEWLINE):

   746                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   747                     RRETURN_NO_MATCH;

   748                 if (isNewline(*stack.currentFrame->args.subjectPtr++))

   749                     RRETURN_NO_MATCH;

   750                 stack.currentFrame->args.instructionPtr++;

   751                 NEXT_OPCODE;

   752 

   753             BEGIN_OPCODE(NOT_DIGIT):

   754                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   755                     RRETURN_NO_MATCH;

   756                 if (isASCIIDigit(*stack.currentFrame->args.subjectPtr++))

   757                     RRETURN_NO_MATCH;

   758                 stack.currentFrame->args.instructionPtr++;

   759                 NEXT_OPCODE;

   760 

   761             BEGIN_OPCODE(DIGIT):

   762                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   763                     RRETURN_NO_MATCH;

   764                 if (!isASCIIDigit(*stack.currentFrame->args.subjectPtr++))

   765                     RRETURN_NO_MATCH;

   766                 stack.currentFrame->args.instructionPtr++;

   767                 NEXT_OPCODE;

   768 

   769             BEGIN_OPCODE(NOT_WHITESPACE):

   770                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   771                     RRETURN_NO_MATCH;

   772                 if (isSpaceChar(*stack.currentFrame->args.subjectPtr++))

   773                     RRETURN_NO_MATCH;

   774                 stack.currentFrame->args.instructionPtr++;

   775                 NEXT_OPCODE;

   776 

   777             BEGIN_OPCODE(WHITESPACE):

   778                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   779                     RRETURN_NO_MATCH;

   780                 if (!isSpaceChar(*stack.currentFrame->args.subjectPtr++))

   781                     RRETURN_NO_MATCH;

   782                 stack.currentFrame->args.instructionPtr++;

   783                 NEXT_OPCODE;

   784                 

   785             BEGIN_OPCODE(NOT_WORDCHAR):

   786                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   787                     RRETURN_NO_MATCH;

   788                 if (isWordChar(*stack.currentFrame->args.subjectPtr++))

   789                     RRETURN_NO_MATCH;

   790                 stack.currentFrame->args.instructionPtr++;

   791                 NEXT_OPCODE;

   792                 

   793             BEGIN_OPCODE(WORDCHAR):

   794                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   795                     RRETURN_NO_MATCH;

   796                 if (!isWordChar(*stack.currentFrame->args.subjectPtr++))

   797                     RRETURN_NO_MATCH;

   798                 stack.currentFrame->args.instructionPtr++;

   799                 NEXT_OPCODE;

   800                 

   801             /* Match a back reference, possibly repeatedly. Look past the end of the

   802              item to see if there is repeat information following. The code is similar

   803              to that for character classes, but repeated for efficiency. Then obey

   804              similar code to character type repeats - written out again for speed.

   805              However, if the referenced string is the empty string, always treat

   806              it as matched, any number of times (otherwise there could be infinite

   807              loops). */

   808                 

   809             BEGIN_OPCODE(REF):

   810                 stack.currentFrame->locals.offset = get2ByteValue(stack.currentFrame->args.instructionPtr + 1) << 1;               /* Doubled ref number */

   811                 stack.currentFrame->args.instructionPtr += 3;                                 /* Advance past item */

   812                 

   813                 /* If the reference is unset, set the length to be longer than the amount

   814                  of subject left; this ensures that every attempt at a match fails. We

   815                  can't just fail here, because of the possibility of quantifiers with zero

   816                  minima. */

   817                 

   818                 if (stack.currentFrame->locals.offset >= stack.currentFrame->args.offsetTop || md.offsetVector[stack.currentFrame->locals.offset] < 0)

   819                     stack.currentFrame->locals.length = 0;

   820                 else

   821                     stack.currentFrame->locals.length = md.offsetVector[stack.currentFrame->locals.offset+1] - md.offsetVector[stack.currentFrame->locals.offset];

   822                 

   823                 /* Set up for repetition, or handle the non-repeated case */

   824                 

   825                 switch (*stack.currentFrame->args.instructionPtr) {

   826                     case OP_CRSTAR:

   827                     case OP_CRMINSTAR:

   828                     case OP_CRPLUS:

   829                     case OP_CRMINPLUS:

   830                     case OP_CRQUERY:

   831                     case OP_CRMINQUERY:

   832                         repeatInformationFromInstructionOffset(*stack.currentFrame->args.instructionPtr++ - OP_CRSTAR, minimize, min, stack.currentFrame->locals.max);

   833                         break;

   834                         

   835                     case OP_CRRANGE:

   836                     case OP_CRMINRANGE:

   837                         minimize = (*stack.currentFrame->args.instructionPtr == OP_CRMINRANGE);

   838                         min = get2ByteValue(stack.currentFrame->args.instructionPtr + 1);

   839                         stack.currentFrame->locals.max = get2ByteValue(stack.currentFrame->args.instructionPtr + 3);

   840                         if (stack.currentFrame->locals.max == 0)

   841                             stack.currentFrame->locals.max = INT_MAX;

   842                         stack.currentFrame->args.instructionPtr += 5;

   843                         break;

   844                     

   845                     default:               /* No repeat follows */

   846                         if (!matchRef(stack.currentFrame->locals.offset, stack.currentFrame->args.subjectPtr, stack.currentFrame->locals.length, md))

   847                             RRETURN_NO_MATCH;

   848                         stack.currentFrame->args.subjectPtr += stack.currentFrame->locals.length;

   849                         NEXT_OPCODE;

   850                 }

   851                 

   852                 /* If the length of the reference is zero, just continue with the

   853                  main loop. */

   854                 

   855                 if (stack.currentFrame->locals.length == 0)

   856                     NEXT_OPCODE;

   857                 

   858                 /* First, ensure the minimum number of matches are present. */

   859                 

   860                 for (int i = 1; i <= min; i++) {

   861                     if (!matchRef(stack.currentFrame->locals.offset, stack.currentFrame->args.subjectPtr, stack.currentFrame->locals.length, md))

   862                         RRETURN_NO_MATCH;

   863                     stack.currentFrame->args.subjectPtr += stack.currentFrame->locals.length;

   864                 }

   865                 

   866                 /* If min = max, continue at the same level without recursion.

   867                  They are not both allowed to be zero. */

   868                 

   869                 if (min == stack.currentFrame->locals.max)

   870                     NEXT_OPCODE;

   871                 

   872                 /* If minimizing, keep trying and advancing the pointer */

   873                 

   874                 if (minimize) {

   875                     for (stack.currentFrame->locals.fi = min;; stack.currentFrame->locals.fi++) {

   876                         RECURSIVE_MATCH(20, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

   877                         if (isMatch)

   878                             RRETURN;

   879                         if (stack.currentFrame->locals.fi >= stack.currentFrame->locals.max || !matchRef(stack.currentFrame->locals.offset, stack.currentFrame->args.subjectPtr, stack.currentFrame->locals.length, md))

   880                             RRETURN;

   881                         stack.currentFrame->args.subjectPtr += stack.currentFrame->locals.length;

   882                     }

   883                     /* Control never reaches here */

   884                 }

   885                 

   886                 /* If maximizing, find the longest string and work backwards */

   887                 

   888                 else {

   889                     stack.currentFrame->locals.subjectPtrAtStartOfInstruction = stack.currentFrame->args.subjectPtr;

   890                     for (int i = min; i < stack.currentFrame->locals.max; i++) {

   891                         if (!matchRef(stack.currentFrame->locals.offset, stack.currentFrame->args.subjectPtr, stack.currentFrame->locals.length, md))

   892                             break;

   893                         stack.currentFrame->args.subjectPtr += stack.currentFrame->locals.length;

   894                     }

   895                     while (stack.currentFrame->args.subjectPtr >= stack.currentFrame->locals.subjectPtrAtStartOfInstruction) {

   896                         RECURSIVE_MATCH(21, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

   897                         if (isMatch)

   898                             RRETURN;

   899                         stack.currentFrame->args.subjectPtr -= stack.currentFrame->locals.length;

   900                     }

   901                     RRETURN_NO_MATCH;

   902                 }

   903                 /* Control never reaches here */

   904                 

   905             /* Match a bit-mapped character class, possibly repeatedly. This op code is

   906              used when all the characters in the class have values in the range 0-255,

   907              and either the matching is caseful, or the characters are in the range

   908              0-127 when UTF-8 processing is enabled. The only difference between

   909              OP_CLASS and OP_NCLASS occurs when a data character outside the range is

   910              encountered.

   911              

   912              First, look past the end of the item to see if there is repeat information

   913              following. Then obey similar code to character type repeats - written out

   914              again for speed. */

   915                 

   916             BEGIN_OPCODE(NCLASS):

   917             BEGIN_OPCODE(CLASS):

   918                 stack.currentFrame->locals.data = stack.currentFrame->args.instructionPtr + 1;                /* Save for matching */

   919                 stack.currentFrame->args.instructionPtr += 33;                     /* Advance past the item */

   920                 

   921                 switch (*stack.currentFrame->args.instructionPtr) {

   922                     case OP_CRSTAR:

   923                     case OP_CRMINSTAR:

   924                     case OP_CRPLUS:

   925                     case OP_CRMINPLUS:

   926                     case OP_CRQUERY:

   927                     case OP_CRMINQUERY:

   928                         repeatInformationFromInstructionOffset(*stack.currentFrame->args.instructionPtr++ - OP_CRSTAR, minimize, min, stack.currentFrame->locals.max);

   929                         break;

   930                         

   931                     case OP_CRRANGE:

   932                     case OP_CRMINRANGE:

   933                         minimize = (*stack.currentFrame->args.instructionPtr == OP_CRMINRANGE);

   934                         min = get2ByteValue(stack.currentFrame->args.instructionPtr + 1);

   935                         stack.currentFrame->locals.max = get2ByteValue(stack.currentFrame->args.instructionPtr + 3);

   936                         if (stack.currentFrame->locals.max == 0)

   937                             stack.currentFrame->locals.max = INT_MAX;

   938                         stack.currentFrame->args.instructionPtr += 5;

   939                         break;

   940                         

   941                     default:               /* No repeat follows */

   942                         min = stack.currentFrame->locals.max = 1;

   943                         break;

   944                 }

   945                 

   946                 /* First, ensure the minimum number of matches are present. */

   947                 

   948                 for (int i = 1; i <= min; i++) {

   949                     if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   950                         RRETURN_NO_MATCH;

   951                     int c = *stack.currentFrame->args.subjectPtr++;

   952                     if (c > 255) {

   953                         if (stack.currentFrame->locals.data[-1] == OP_CLASS)

   954                             RRETURN_NO_MATCH;

   955                     } else {

   956                         if (!(stack.currentFrame->locals.data[c / 8] & (1 << (c & 7))))

   957                             RRETURN_NO_MATCH;

   958                     }

   959                 }

   960                 

   961                 /* If max == min we can continue with the main loop without the

   962                  need to recurse. */

   963                 

   964                 if (min == stack.currentFrame->locals.max)

   965                     NEXT_OPCODE;      

   966                 

   967                 /* If minimizing, keep testing the rest of the expression and advancing

   968                  the pointer while it matches the class. */

   969                 if (minimize) {

   970                     for (stack.currentFrame->locals.fi = min;; stack.currentFrame->locals.fi++) {

   971                         RECURSIVE_MATCH(22, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

   972                         if (isMatch)

   973                             RRETURN;

   974                         if (stack.currentFrame->locals.fi >= stack.currentFrame->locals.max || stack.currentFrame->args.subjectPtr >= md.endSubject)

   975                             RRETURN;

   976                         int c = *stack.currentFrame->args.subjectPtr++;

   977                         if (c > 255) {

   978                             if (stack.currentFrame->locals.data[-1] == OP_CLASS)

   979                                 RRETURN;

   980                         } else {

   981                             if ((stack.currentFrame->locals.data[c/8] & (1 << (c&7))) == 0)

   982                                 RRETURN;

   983                         }

   984                     }

   985                     /* Control never reaches here */

   986                 }

   987                 /* If maximizing, find the longest possible run, then work backwards. */

   988                 else {

   989                     stack.currentFrame->locals.subjectPtrAtStartOfInstruction = stack.currentFrame->args.subjectPtr;

   990                     

   991                     for (int i = min; i < stack.currentFrame->locals.max; i++) {

   992                         if (stack.currentFrame->args.subjectPtr >= md.endSubject)

   993                             break;

   994                         int c = *stack.currentFrame->args.subjectPtr;

   995                         if (c > 255) {

   996                             if (stack.currentFrame->locals.data[-1] == OP_CLASS)

   997                                 break;

   998                         } else {

   999                             if (!(stack.currentFrame->locals.data[c / 8] & (1 << (c & 7))))

  1000                                 break;

  1001                         }

  1002                         ++stack.currentFrame->args.subjectPtr;

  1003                     }

  1004                     for (;;) {

  1005                         RECURSIVE_MATCH(24, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

  1006                         if (isMatch)

  1007                             RRETURN;

  1008                         if (stack.currentFrame->args.subjectPtr-- == stack.currentFrame->locals.subjectPtrAtStartOfInstruction)

  1009                             break;        /* Stop if tried at original pos */

  1010                     }

  1011                     

  1012                     RRETURN;

  1013                 }

  1014                 /* Control never reaches here */

  1015                 

  1016             /* Match an extended character class. */

  1017                 

  1018             BEGIN_OPCODE(XCLASS):

  1019                 stack.currentFrame->locals.data = stack.currentFrame->args.instructionPtr + 1 + LINK_SIZE;                /* Save for matching */

  1020                 stack.currentFrame->args.instructionPtr += getLinkValue(stack.currentFrame->args.instructionPtr + 1);                      /* Advance past the item */

  1021                 

  1022                 switch (*stack.currentFrame->args.instructionPtr) {

  1023                     case OP_CRSTAR:

  1024                     case OP_CRMINSTAR:

  1025                     case OP_CRPLUS:

  1026                     case OP_CRMINPLUS:

  1027                     case OP_CRQUERY:

  1028                     case OP_CRMINQUERY:

  1029                         repeatInformationFromInstructionOffset(*stack.currentFrame->args.instructionPtr++ - OP_CRSTAR, minimize, min, stack.currentFrame->locals.max);

  1030                         break;

  1031                         

  1032                     case OP_CRRANGE:

  1033                     case OP_CRMINRANGE:

  1034                         minimize = (*stack.currentFrame->args.instructionPtr == OP_CRMINRANGE);

  1035                         min = get2ByteValue(stack.currentFrame->args.instructionPtr + 1);

  1036                         stack.currentFrame->locals.max = get2ByteValue(stack.currentFrame->args.instructionPtr + 3);

  1037                         if (stack.currentFrame->locals.max == 0)

  1038                             stack.currentFrame->locals.max = INT_MAX;

  1039                         stack.currentFrame->args.instructionPtr += 5;

  1040                         break;

  1041                         

  1042                     default:               /* No repeat follows */

  1043                         min = stack.currentFrame->locals.max = 1;

  1044                 }

  1045                 

  1046                 /* First, ensure the minimum number of matches are present. */

  1047                 

  1048                 for (int i = 1; i <= min; i++) {

  1049                     if (stack.currentFrame->args.subjectPtr >= md.endSubject)

  1050                         RRETURN_NO_MATCH;

  1051                     int c = *stack.currentFrame->args.subjectPtr++;

  1052                     if (!jsc_pcre_xclass(c, stack.currentFrame->locals.data))

  1053                         RRETURN_NO_MATCH;

  1054                 }

  1055                 

  1056                 /* If max == min we can continue with the main loop without the

  1057                  need to recurse. */

  1058                 

  1059                 if (min == stack.currentFrame->locals.max)

  1060                     NEXT_OPCODE;

  1061                 

  1062                 /* If minimizing, keep testing the rest of the expression and advancing

  1063                  the pointer while it matches the class. */

  1064                 

  1065                 if (minimize) {

  1066                     for (stack.currentFrame->locals.fi = min;; stack.currentFrame->locals.fi++) {

  1067                         RECURSIVE_MATCH(26, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

  1068                         if (isMatch)

  1069                             RRETURN;

  1070                         if (stack.currentFrame->locals.fi >= stack.currentFrame->locals.max || stack.currentFrame->args.subjectPtr >= md.endSubject)

  1071                             RRETURN;

  1072                         int c = *stack.currentFrame->args.subjectPtr++;

  1073                         if (!jsc_pcre_xclass(c, stack.currentFrame->locals.data))

  1074                             RRETURN;

  1075                     }

  1076                     /* Control never reaches here */

  1077                 }

  1078                 

  1079                 /* If maximizing, find the longest possible run, then work backwards. */

  1080                 

  1081                 else {

  1082                     stack.currentFrame->locals.subjectPtrAtStartOfInstruction = stack.currentFrame->args.subjectPtr;

  1083                     for (int i = min; i < stack.currentFrame->locals.max; i++) {

  1084                         if (stack.currentFrame->args.subjectPtr >= md.endSubject)

  1085                             break;

  1086                         int c = *stack.currentFrame->args.subjectPtr;

  1087                         if (!jsc_pcre_xclass(c, stack.currentFrame->locals.data))

  1088                             break;

  1089                         ++stack.currentFrame->args.subjectPtr;

  1090                     }

  1091                     for(;;) {

  1092                         RECURSIVE_MATCH(27, stack.currentFrame->args.instructionPtr, stack.currentFrame->args.bracketChain);

  1093                         if (isMatch)

  1094                             RRETURN;

  1095                         if (stack.currentFrame->args.subjectPtr-- == stack.currentFrame->locals.subjectPtrAtStartOfInstruction)

  1096                             break;        /* Stop if tried at original pos */

  1097                     }

  1098                     RRETURN;

  1099                 }

  1100                 

  1101                 /* Control never reaches here */

  1102                 

  1103             /* Match a single character, casefully */

  1104                 

  1105             BEGIN_OPCODE(CHAR):

  1106                 stack.currentFrame->locals.length = 1;

  1107                 stack.currentFrame->args.instructionPtr++;

  1108                 getUTF8CharAndIncrementLength(stack.currentFrame->locals.fc, stack.currentFrame->args.instructionPtr, stack.currentFrame->locals.length);

  1109                 stack.currentFrame->args.instructionPtr += stack.currentFrame->locals.length;

  1110                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

  1111                     RRETURN_NO_MATCH;

  1112                 if (stack.currentFrame->locals.fc != *stack.currentFrame->args.subjectPtr++)

  1113                     RRETURN_NO_MATCH;

  1114                 NEXT_OPCODE;

  1115                 

  1116             /* Match a single character, caselessly */

  1117                 

  1118             BEGIN_OPCODE(CHAR_IGNORING_CASE): {

  1119                 stack.currentFrame->locals.length = 1;

  1120                 stack.currentFrame->args.instructionPtr++;

  1121                 getUTF8CharAndIncrementLength(stack.currentFrame->locals.fc, stack.currentFrame->args.instructionPtr, stack.currentFrame->locals.length);

  1122                 stack.currentFrame->args.instructionPtr += stack.currentFrame->locals.length;

  1123                 if (stack.currentFrame->args.subjectPtr >= md.endSubject)

  1124                     RRETURN_NO_MATCH;

  1125                 int dc = *stack.currentFrame->args.subjectPtr++;

  1126                 if (stack.currentFrame->locals.fc != dc && jsc_pcre_ucp_othercase(stack.currentFrame->locals.fc) != dc)

  1127                     RRETURN_NO_MATCH;

  1128                 NEXT_OPCODE;

  1129             }

  1130                 

  1131             /* Match a single ASCII character. */

  1132                 

  1133             BEGIN_OPCODE(ASCII_CHAR):

  1134                 if (md.endSubject == stack.currentFrame->args.subjectPtr)

  1135                     RRETURN_NO_MATCH;