X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/4388f060552cc537e71e957d32f35e9d75a61233..b331163bffd790ced0e88b73f44f86d49ccc48a5:/icuSources/i18n/regexcmp.cpp?ds=sidebyside diff --git a/icuSources/i18n/regexcmp.cpp b/icuSources/i18n/regexcmp.cpp index 146d73cf..e518e84c 100644 --- a/icuSources/i18n/regexcmp.cpp +++ b/icuSources/i18n/regexcmp.cpp @@ -1,7 +1,7 @@ // // file: regexcmp.cpp // -// Copyright (C) 2002-2012 International Business Machines Corporation and others. +// Copyright (C) 2002-2015 International Business Machines Corporation and others. // All Rights Reserved. // // This file contains the ICU regular expression compiler, which is responsible @@ -30,7 +30,6 @@ #include "uvectr32.h" #include "uvectr64.h" #include "uassert.h" -#include "ucln_in.h" #include "uinvchar.h" #include "regeximp.h" @@ -71,6 +70,7 @@ RegexCompile::RegexCompile(RegexPattern *rxp, UErrorCode &status) : fMatchOpenParen = -1; fMatchCloseParen = -1; + fCaptureName = NULL; if (U_SUCCESS(status) && U_FAILURE(rxp->fDeferredStatus)) { status = rxp->fDeferredStatus; @@ -87,6 +87,8 @@ static const UChar chDash = 0x2d; // '-' // //------------------------------------------------------------------------------ RegexCompile::~RegexCompile() { + delete fCaptureName; // Normally will be NULL, but can exist if pattern + // compilation stops with a syntax error. } static inline void addCategory(UnicodeSet *set, int32_t value, UErrorCode& ec) { @@ -109,7 +111,7 @@ void RegexCompile::compile( fRXPat->fPatternString = new UnicodeString(pat); UText patternText = UTEXT_INITIALIZER; utext_openConstUnicodeString(&patternText, fRXPat->fPatternString, &e); - + if (U_SUCCESS(e)) { compile(&patternText, pp, e); utext_close(&patternText); @@ -139,6 +141,9 @@ void RegexCompile::compile( // Prepare the RegexPattern object to receive the compiled pattern. fRXPat->fPattern = utext_clone(fRXPat->fPattern, pat, FALSE, TRUE, fStatus); + if (U_FAILURE(*fStatus)) { + return; + } fRXPat->fStaticSets = RegexStaticSets::gStaticSets->fPropSets; fRXPat->fStaticSets8 = RegexStaticSets::gStaticSets->fPropSets8; @@ -284,17 +289,6 @@ void RegexCompile::compile( // The pattern has now been read and processed, and the compiled code generated. // - // - // Compute the number of digits requried for the largest capture group number. - // - fRXPat->fMaxCaptureDigits = 1; - int32_t n = 10; - int32_t groupCount = fRXPat->fGroupMap->size(); - while (n <= groupCount) { - fRXPat->fMaxCaptureDigits++; - n *= 10; - } - // // The pattern's fFrameSize so far has accumulated the requirements for // storage for capture parentheses, counters, etc. that are encountered @@ -302,7 +296,7 @@ void RegexCompile::compile( // present in the saved state: the input string position (int64_t) and // the position in the compiled pattern. // - fRXPat->fFrameSize+=RESTACKFRAME_HDRCOUNT; + allocateStackData(RESTACKFRAME_HDRCOUNT); // // Optimization pass 1: NOPs, back-references, and case-folding @@ -368,9 +362,9 @@ UBool RegexCompile::doParseActions(int32_t action) // the start of an ( grouping. //4 NOP Resreved, will be replaced by a save if there are // OR | operators at the top level - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_STATE_SAVE, 2), *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_JMP, 3), *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_FAIL, 0), *fStatus); + appendOp(URX_STATE_SAVE, 2); + appendOp(URX_JMP, 3); + appendOp(URX_FAIL, 0); // Standard open nonCapture paren action emits the two NOPs and // sets up the paren stack frame. @@ -393,7 +387,7 @@ UBool RegexCompile::doParseActions(int32_t action) } // add the END operation to the compiled pattern. - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_END, 0), *fStatus); + appendOp(URX_END, 0); // Terminate the pattern compilation state machine. returnVal = FALSE; @@ -415,14 +409,13 @@ UBool RegexCompile::doParseActions(int32_t action) int32_t savePosition = fParenStack.popi(); int32_t op = (int32_t)fRXPat->fCompiledPat->elementAti(savePosition); U_ASSERT(URX_TYPE(op) == URX_NOP); // original contents of reserved location - op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+1); + op = buildOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+1); fRXPat->fCompiledPat->setElementAt(op, savePosition); // Append an JMP operation into the compiled pattern. The operand for // the JMP will eventually be the location following the ')' for the // group. This will be patched in later, when the ')' is encountered. - op = URX_BUILD(URX_JMP, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_JMP, 0); // Push the position of the newly added JMP op onto the parentheses stack. // This registers if for fixup when this block's close paren is encountered. @@ -431,14 +424,31 @@ UBool RegexCompile::doParseActions(int32_t action) // Append a NOP to the compiled pattern. This is the slot reserved // for a SAVE in the event that there is yet another '|' following // this one. - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); + appendOp(URX_NOP, 0); fParenStack.push(fRXPat->fCompiledPat->size()-1, *fStatus); } break; + case doBeginNamedCapture: + // Scanning (?append(fC.fChar); + break; + + case doBadNamedCapture: + error(U_REGEX_INVALID_CAPTURE_GROUP_NAME); + break; + case doOpenCaptureParen: - // Open Paren. + // Open Capturing Paren, possibly named. // Compile to a // - NOP, which later may be replaced by a save-state if the // parenthesized group gets a * quantifier, followed by @@ -457,12 +467,10 @@ UBool RegexCompile::doParseActions(int32_t action) // END_CAPTURE is encountered. { fixLiterals(); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); - int32_t varsLoc = fRXPat->fFrameSize; // Reserve three slots in match stack frame. - fRXPat->fFrameSize += 3; - int32_t cop = URX_BUILD(URX_START_CAPTURE, varsLoc); - fRXPat->fCompiledPat->addElement(cop, *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); + appendOp(URX_NOP, 0); + int32_t varsLoc = allocateStackData(3); // Reserve three slots in match stack frame. + appendOp(URX_START_CAPTURE, varsLoc); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the two NOPs. Depending on what follows in the pattern, the @@ -475,8 +483,18 @@ UBool RegexCompile::doParseActions(int32_t action) // Save the mapping from group number to stack frame variable position. fRXPat->fGroupMap->addElement(varsLoc, *fStatus); + + // If this is a named capture group, add the name->group number mapping. + if (fCaptureName != NULL) { + int32_t groupNumber = fRXPat->fGroupMap->size(); + int32_t previousMapping = uhash_puti(fRXPat->fNamedCaptureMap, fCaptureName, groupNumber, fStatus); + fCaptureName = NULL; // hash table takes ownership of the name (key) string. + if (previousMapping > 0 && U_SUCCESS(*fStatus)) { + error(U_REGEX_INVALID_CAPTURE_GROUP_NAME); + } + } } - break; + break; case doOpenNonCaptureParen: // Open non-caputuring (grouping only) Paren. @@ -487,8 +505,8 @@ UBool RegexCompile::doParseActions(int32_t action) // is an '|' alternation within the parens. { fixLiterals(); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); + appendOp(URX_NOP, 0); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the two NOPs. @@ -510,12 +528,10 @@ UBool RegexCompile::doParseActions(int32_t action) // is an '|' alternation within the parens. { fixLiterals(); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); - int32_t varLoc = fRXPat->fDataSize; // Reserve a data location for saving the - fRXPat->fDataSize += 1; // state stack ptr. - int32_t stoOp = URX_BUILD(URX_STO_SP, varLoc); - fRXPat->fCompiledPat->addElement(stoOp, *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); + appendOp(URX_NOP, 0); + int32_t varLoc = allocateData(1); // Reserve a data location for saving the state stack ptr. + appendOp(URX_STO_SP, varLoc); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the two NOPs. Depending on what follows in the pattern, the @@ -558,26 +574,14 @@ UBool RegexCompile::doParseActions(int32_t action) // Two data slots are reserved, for saving the stack ptr and the input position. { fixLiterals(); - int32_t dataLoc = fRXPat->fDataSize; - fRXPat->fDataSize += 2; - int32_t op = URX_BUILD(URX_LA_START, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+ 2); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_JMP, fRXPat->fCompiledPat->size()+ 3); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_LA_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_BACKTRACK, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_NOP, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); - fRXPat->fCompiledPat->addElement(op, *fStatus); + int32_t dataLoc = allocateData(2); + appendOp(URX_LA_START, dataLoc); + appendOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+ 2); + appendOp(URX_JMP, fRXPat->fCompiledPat->size()+ 3); + appendOp(URX_LA_END, dataLoc); + appendOp(URX_BACKTRACK, 0); + appendOp(URX_NOP, 0); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the NOPs. @@ -602,16 +606,10 @@ UBool RegexCompile::doParseActions(int32_t action) // an alternate (transparent) region. { fixLiterals(); - int32_t dataLoc = fRXPat->fDataSize; - fRXPat->fDataSize += 2; - int32_t op = URX_BUILD(URX_LA_START, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_STATE_SAVE, 0); // dest address will be patched later. - fRXPat->fCompiledPat->addElement(op, *fStatus); - - op = URX_BUILD(URX_NOP, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); + int32_t dataLoc = allocateData(2); + appendOp(URX_LA_START, dataLoc); + appendOp(URX_STATE_SAVE, 0); // dest address will be patched later. + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the StateSave and NOP. @@ -649,23 +647,19 @@ UBool RegexCompile::doParseActions(int32_t action) fixLiterals(); // Allocate data space - int32_t dataLoc = fRXPat->fDataSize; - fRXPat->fDataSize += 4; + int32_t dataLoc = allocateData(4); // Emit URX_LB_START - int32_t op = URX_BUILD(URX_LB_START, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LB_START, dataLoc); // Emit URX_LB_CONT - op = URX_BUILD(URX_LB_CONT, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - fRXPat->fCompiledPat->addElement(0, *fStatus); // MinMatchLength. To be filled later. - fRXPat->fCompiledPat->addElement(0, *fStatus); // MaxMatchLength. To be filled later. + appendOp(URX_LB_CONT, dataLoc); + appendOp(URX_RESERVED_OP, 0); // MinMatchLength. To be filled later. + appendOp(URX_RESERVED_OP, 0); // MaxMatchLength. To be filled later. - // Emit the NOP - op = URX_BUILD(URX_NOP, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); - fRXPat->fCompiledPat->addElement(op, *fStatus); + // Emit the NOPs + appendOp(URX_NOP, 0); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the URX_LB_CONT and the NOP. @@ -705,24 +699,20 @@ UBool RegexCompile::doParseActions(int32_t action) fixLiterals(); // Allocate data space - int32_t dataLoc = fRXPat->fDataSize; - fRXPat->fDataSize += 4; + int32_t dataLoc = allocateData(4); // Emit URX_LB_START - int32_t op = URX_BUILD(URX_LB_START, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LB_START, dataLoc); // Emit URX_LBN_CONT - op = URX_BUILD(URX_LBN_CONT, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - fRXPat->fCompiledPat->addElement(0, *fStatus); // MinMatchLength. To be filled later. - fRXPat->fCompiledPat->addElement(0, *fStatus); // MaxMatchLength. To be filled later. - fRXPat->fCompiledPat->addElement(0, *fStatus); // Continue Loc. To be filled later. + appendOp(URX_LBN_CONT, dataLoc); + appendOp(URX_RESERVED_OP, 0); // MinMatchLength. To be filled later. + appendOp(URX_RESERVED_OP, 0); // MaxMatchLength. To be filled later. + appendOp(URX_RESERVED_OP, 0); // Continue Loc. To be filled later. - // Emit the NOP - op = URX_BUILD(URX_NOP, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); - fRXPat->fCompiledPat->addElement(op, *fStatus); + // Emit the NOPs + appendOp(URX_NOP, 0); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the URX_LB_CONT and the NOP. @@ -792,12 +782,9 @@ UBool RegexCompile::doParseActions(int32_t action) if (URX_TYPE(repeatedOp) == URX_SETREF) { // Emit optimized code for [char set]+ - int32_t loopOpI = URX_BUILD(URX_LOOP_SR_I, URX_VAL(repeatedOp)); - fRXPat->fCompiledPat->addElement(loopOpI, *fStatus); - frameLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; - int32_t loopOpC = URX_BUILD(URX_LOOP_C, frameLoc); - fRXPat->fCompiledPat->addElement(loopOpC, *fStatus); + appendOp(URX_LOOP_SR_I, URX_VAL(repeatedOp)); + frameLoc = allocateStackData(1); + appendOp(URX_LOOP_C, frameLoc); break; } @@ -805,7 +792,7 @@ UBool RegexCompile::doParseActions(int32_t action) URX_TYPE(repeatedOp) == URX_DOTANY_ALL || URX_TYPE(repeatedOp) == URX_DOTANY_UNIX) { // Emit Optimized code for .+ operations. - int32_t loopOpI = URX_BUILD(URX_LOOP_DOT_I, 0); + int32_t loopOpI = buildOp(URX_LOOP_DOT_I, 0); if (URX_TYPE(repeatedOp) == URX_DOTANY_ALL) { // URX_LOOP_DOT_I operand is a flag indicating ". matches any" mode. loopOpI |= 1; @@ -813,11 +800,9 @@ UBool RegexCompile::doParseActions(int32_t action) if (fModeFlags & UREGEX_UNIX_LINES) { loopOpI |= 2; } - fRXPat->fCompiledPat->addElement(loopOpI, *fStatus); - frameLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; - int32_t loopOpC = URX_BUILD(URX_LOOP_C, frameLoc); - fRXPat->fCompiledPat->addElement(loopOpC, *fStatus); + appendOp(loopOpI); + frameLoc = allocateStackData(1); + appendOp(URX_LOOP_C, frameLoc); break; } @@ -831,18 +816,15 @@ UBool RegexCompile::doParseActions(int32_t action) // Zero length match is possible. // Emit the code sequence that can handle it. insertOp(topLoc); - frameLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; + frameLoc = allocateStackData(1); - int32_t op = URX_BUILD(URX_STO_INP_LOC, frameLoc); + int32_t op = buildOp(URX_STO_INP_LOC, frameLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc); - op = URX_BUILD(URX_JMP_SAV_X, topLoc+1); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_JMP_SAV_X, topLoc+1); } else { // Simpler code when the repeated body must match something non-empty - int32_t jmpOp = URX_BUILD(URX_JMP_SAV, topLoc); - fRXPat->fCompiledPat->addElement(jmpOp, *fStatus); + appendOp(URX_JMP_SAV, topLoc); } } break; @@ -854,8 +836,7 @@ UBool RegexCompile::doParseActions(int32_t action) // 3. ... { int32_t topLoc = blockTopLoc(FALSE); - int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, topLoc); - fRXPat->fCompiledPat->addElement(saveStateOp, *fStatus); + appendOp(URX_STATE_SAVE, topLoc); } break; @@ -869,7 +850,7 @@ UBool RegexCompile::doParseActions(int32_t action) // Insert the state save into the compiled pattern, and we're done. { int32_t saveStateLoc = blockTopLoc(TRUE); - int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()); + int32_t saveStateOp = buildOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()); fRXPat->fCompiledPat->setElementAt(saveStateOp, saveStateLoc); } break; @@ -888,14 +869,12 @@ UBool RegexCompile::doParseActions(int32_t action) int32_t jmp1_loc = blockTopLoc(TRUE); int32_t jmp2_loc = fRXPat->fCompiledPat->size(); - int32_t jmp1_op = URX_BUILD(URX_JMP, jmp2_loc+1); + int32_t jmp1_op = buildOp(URX_JMP, jmp2_loc+1); fRXPat->fCompiledPat->setElementAt(jmp1_op, jmp1_loc); - int32_t jmp2_op = URX_BUILD(URX_JMP, jmp2_loc+2); - fRXPat->fCompiledPat->addElement(jmp2_op, *fStatus); + appendOp(URX_JMP, jmp2_loc+2); - int32_t save_op = URX_BUILD(URX_STATE_SAVE, jmp1_loc+1); - fRXPat->fCompiledPat->addElement(save_op, *fStatus); + appendOp(URX_STATE_SAVE, jmp1_loc+1); } break; @@ -935,12 +914,10 @@ UBool RegexCompile::doParseActions(int32_t action) if (URX_TYPE(repeatedOp) == URX_SETREF) { // Emit optimized code for a [char set]* - int32_t loopOpI = URX_BUILD(URX_LOOP_SR_I, URX_VAL(repeatedOp)); + int32_t loopOpI = buildOp(URX_LOOP_SR_I, URX_VAL(repeatedOp)); fRXPat->fCompiledPat->setElementAt(loopOpI, topLoc); - dataLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; - int32_t loopOpC = URX_BUILD(URX_LOOP_C, dataLoc); - fRXPat->fCompiledPat->addElement(loopOpC, *fStatus); + dataLoc = allocateStackData(1); + appendOp(URX_LOOP_C, dataLoc); break; } @@ -948,7 +925,7 @@ UBool RegexCompile::doParseActions(int32_t action) URX_TYPE(repeatedOp) == URX_DOTANY_ALL || URX_TYPE(repeatedOp) == URX_DOTANY_UNIX) { // Emit Optimized code for .* operations. - int32_t loopOpI = URX_BUILD(URX_LOOP_DOT_I, 0); + int32_t loopOpI = buildOp(URX_LOOP_DOT_I, 0); if (URX_TYPE(repeatedOp) == URX_DOTANY_ALL) { // URX_LOOP_DOT_I operand is a flag indicating . matches any mode. loopOpI |= 1; @@ -957,10 +934,8 @@ UBool RegexCompile::doParseActions(int32_t action) loopOpI |= 2; } fRXPat->fCompiledPat->setElementAt(loopOpI, topLoc); - dataLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; - int32_t loopOpC = URX_BUILD(URX_LOOP_C, dataLoc); - fRXPat->fCompiledPat->addElement(loopOpC, *fStatus); + dataLoc = allocateStackData(1); + appendOp(URX_LOOP_C, dataLoc); break; } } @@ -969,30 +944,29 @@ UBool RegexCompile::doParseActions(int32_t action) // The optimizations did not apply. int32_t saveStateLoc = blockTopLoc(TRUE); - int32_t jmpOp = URX_BUILD(URX_JMP_SAV, saveStateLoc+1); + int32_t jmpOp = buildOp(URX_JMP_SAV, saveStateLoc+1); // Check for minimum match length of zero, which requires // extra loop-breaking code. if (minMatchLength(saveStateLoc, fRXPat->fCompiledPat->size()-1) == 0) { insertOp(saveStateLoc); - dataLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; + dataLoc = allocateStackData(1); - int32_t op = URX_BUILD(URX_STO_INP_LOC, dataLoc); + int32_t op = buildOp(URX_STO_INP_LOC, dataLoc); fRXPat->fCompiledPat->setElementAt(op, saveStateLoc+1); - jmpOp = URX_BUILD(URX_JMP_SAV_X, saveStateLoc+2); + jmpOp = buildOp(URX_JMP_SAV_X, saveStateLoc+2); } // Locate the position in the compiled pattern where the match will continue // after completing the *. (4 or 5 in the comment above) int32_t continueLoc = fRXPat->fCompiledPat->size()+1; - // Put together the save state op store it into the compiled code. - int32_t saveStateOp = URX_BUILD(URX_STATE_SAVE, continueLoc); + // Put together the save state op and store it into the compiled code. + int32_t saveStateOp = buildOp(URX_STATE_SAVE, continueLoc); fRXPat->fCompiledPat->setElementAt(saveStateOp, saveStateLoc); // Append the URX_JMP_SAV or URX_JMPX operation to the compiled pattern. - fRXPat->fCompiledPat->addElement(jmpOp, *fStatus); + appendOp(jmpOp); } break; @@ -1006,10 +980,9 @@ UBool RegexCompile::doParseActions(int32_t action) { int32_t jmpLoc = blockTopLoc(TRUE); // loc 1. int32_t saveLoc = fRXPat->fCompiledPat->size(); // loc 3. - int32_t jmpOp = URX_BUILD(URX_JMP, saveLoc); - int32_t stateSaveOp = URX_BUILD(URX_STATE_SAVE, jmpLoc+1); + int32_t jmpOp = buildOp(URX_JMP, saveLoc); fRXPat->fCompiledPat->setElementAt(jmpOp, jmpLoc); - fRXPat->fCompiledPat->addElement(stateSaveOp, *fStatus); + appendOp(URX_STATE_SAVE, jmpLoc+1); } break; @@ -1027,9 +1000,11 @@ UBool RegexCompile::doParseActions(int32_t action) { int32_t digitValue = u_charDigitValue(fC.fChar); U_ASSERT(digitValue >= 0); - fIntervalLow = fIntervalLow*10 + digitValue; - if (fIntervalLow < 0) { + int64_t val = (int64_t)fIntervalLow*10 + digitValue; + if (val > INT32_MAX) { error(U_REGEX_NUMBER_TOO_BIG); + } else { + fIntervalLow = (int32_t)val; } } break; @@ -1042,9 +1017,11 @@ UBool RegexCompile::doParseActions(int32_t action) } int32_t digitValue = u_charDigitValue(fC.fChar); U_ASSERT(digitValue >= 0); - fIntervalUpper = fIntervalUpper*10 + digitValue; - if (fIntervalUpper < 0) { + int64_t val = (int64_t)fIntervalUpper*10 + digitValue; + if (val > INT32_MAX) { error(U_REGEX_NUMBER_TOO_BIG); + } else { + fIntervalUpper = (int32_t)val; } } break; @@ -1078,9 +1055,9 @@ UBool RegexCompile::doParseActions(int32_t action) // First the STO_SP before the start of the loop insertOp(topLoc); - int32_t varLoc = fRXPat->fDataSize; // Reserve a data location for saving the - fRXPat->fDataSize += 1; // state stack ptr. - int32_t op = URX_BUILD(URX_STO_SP, varLoc); + + int32_t varLoc = allocateData(1); // Reserve a data location for saving the + int32_t op = buildOp(URX_STO_SP, varLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc); int32_t loopOp = (int32_t)fRXPat->fCompiledPat->popi(); @@ -1089,8 +1066,7 @@ UBool RegexCompile::doParseActions(int32_t action) fRXPat->fCompiledPat->push(loopOp, *fStatus); // Then the LD_SP after the end of the loop - op = URX_BUILD(URX_LD_SP, varLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LD_SP, varLoc); } break; @@ -1126,55 +1102,49 @@ UBool RegexCompile::doParseActions(int32_t action) // scanned a ".", match any single character. { fixLiterals(FALSE); - int32_t op; if (fModeFlags & UREGEX_DOTALL) { - op = URX_BUILD(URX_DOTANY_ALL, 0); + appendOp(URX_DOTANY_ALL, 0); } else if (fModeFlags & UREGEX_UNIX_LINES) { - op = URX_BUILD(URX_DOTANY_UNIX, 0); + appendOp(URX_DOTANY_UNIX, 0); } else { - op = URX_BUILD(URX_DOTANY, 0); + appendOp(URX_DOTANY, 0); } - fRXPat->fCompiledPat->addElement(op, *fStatus); } break; case doCaret: { fixLiterals(FALSE); - int32_t op = 0; if ( (fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) { - op = URX_CARET; + appendOp(URX_CARET, 0); } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) { - op = URX_CARET_M; + appendOp(URX_CARET_M, 0); } else if ((fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) { - op = URX_CARET; // Only testing true start of input. + appendOp(URX_CARET, 0); // Only testing true start of input. } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) { - op = URX_CARET_M_UNIX; + appendOp(URX_CARET_M_UNIX, 0); } - fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus); } break; case doDollar: { fixLiterals(FALSE); - int32_t op = 0; if ( (fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) { - op = URX_DOLLAR; + appendOp(URX_DOLLAR, 0); } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) == 0) { - op = URX_DOLLAR_M; + appendOp(URX_DOLLAR_M, 0); } else if ((fModeFlags & UREGEX_MULTILINE) == 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) { - op = URX_DOLLAR_D; + appendOp(URX_DOLLAR_D, 0); } else if ((fModeFlags & UREGEX_MULTILINE) != 0 && (fModeFlags & UREGEX_UNIX_LINES) != 0) { - op = URX_DOLLAR_MD; + appendOp(URX_DOLLAR_MD, 0); } - fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus); } break; case doBackslashA: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_CARET, 0), *fStatus); + appendOp(URX_CARET, 0); break; case doBackslashB: @@ -1186,7 +1156,7 @@ UBool RegexCompile::doParseActions(int32_t action) #endif fixLiterals(FALSE); int32_t op = (fModeFlags & UREGEX_UWORD)? URX_BACKSLASH_BU : URX_BACKSLASH_B; - fRXPat->fCompiledPat->addElement(URX_BUILD(op, 1), *fStatus); + appendOp(op, 1); } break; @@ -1199,63 +1169,84 @@ UBool RegexCompile::doParseActions(int32_t action) #endif fixLiterals(FALSE); int32_t op = (fModeFlags & UREGEX_UWORD)? URX_BACKSLASH_BU : URX_BACKSLASH_B; - fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus); + appendOp(op, 0); } break; case doBackslashD: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_D, 1), *fStatus); + appendOp(URX_BACKSLASH_D, 1); break; case doBackslashd: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_D, 0), *fStatus); + appendOp(URX_BACKSLASH_D, 0); break; case doBackslashG: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_G, 0), *fStatus); + appendOp(URX_BACKSLASH_G, 0); + break; + + case doBackslashH: + fixLiterals(FALSE); + appendOp(URX_BACKSLASH_H, 1); + break; + + case doBackslashh: + fixLiterals(FALSE); + appendOp(URX_BACKSLASH_H, 0); + break; + + case doBackslashR: + fixLiterals(FALSE); + appendOp(URX_BACKSLASH_R, 0); break; case doBackslashS: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement( - URX_BUILD(URX_STAT_SETREF_N, URX_ISSPACE_SET), *fStatus); + appendOp(URX_STAT_SETREF_N, URX_ISSPACE_SET); break; case doBackslashs: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement( - URX_BUILD(URX_STATIC_SETREF, URX_ISSPACE_SET), *fStatus); + appendOp(URX_STATIC_SETREF, URX_ISSPACE_SET); + break; + + case doBackslashV: + fixLiterals(FALSE); + appendOp(URX_BACKSLASH_V, 1); + break; + + case doBackslashv: + fixLiterals(FALSE); + appendOp(URX_BACKSLASH_V, 0); break; case doBackslashW: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement( - URX_BUILD(URX_STAT_SETREF_N, URX_ISWORD_SET), *fStatus); + appendOp(URX_STAT_SETREF_N, URX_ISWORD_SET); break; case doBackslashw: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement( - URX_BUILD(URX_STATIC_SETREF, URX_ISWORD_SET), *fStatus); + appendOp(URX_STATIC_SETREF, URX_ISWORD_SET); break; case doBackslashX: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_X, 0), *fStatus); + appendOp(URX_BACKSLASH_X, 0); break; case doBackslashZ: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_DOLLAR, 0), *fStatus); + appendOp(URX_DOLLAR, 0); break; case doBackslashz: fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKSLASH_Z, 0), *fStatus); + appendOp(URX_BACKSLASH_Z, 0); break; case doEscapeError: @@ -1281,7 +1272,7 @@ UBool RegexCompile::doParseActions(int32_t action) literalChar(c); } break; - + case doBackRef: // BackReference. Somewhat unusual in that the front-end can not completely parse @@ -1315,17 +1306,49 @@ UBool RegexCompile::doParseActions(int32_t action) U_ASSERT(groupNum > 0); // Shouldn't happen. '\0' begins an octal escape sequence, // and shouldn't enter this code path at all. fixLiterals(FALSE); - int32_t op; if (fModeFlags & UREGEX_CASE_INSENSITIVE) { - op = URX_BUILD(URX_BACKREF_I, groupNum); + appendOp(URX_BACKREF_I, groupNum); } else { - op = URX_BUILD(URX_BACKREF, groupNum); + appendOp(URX_BACKREF, groupNum); } - fRXPat->fCompiledPat->addElement(op, *fStatus); } break; + case doBeginNamedBackRef: + U_ASSERT(fCaptureName == NULL); + fCaptureName = new UnicodeString; + if (fCaptureName == NULL) { + error(U_MEMORY_ALLOCATION_ERROR); + } + break; + + case doContinueNamedBackRef: + fCaptureName->append(fC.fChar); + break; + case doCompleteNamedBackRef: + { + int32_t groupNumber = uhash_geti(fRXPat->fNamedCaptureMap, fCaptureName); + if (groupNumber == 0) { + // Group name has not been defined. + // Could be a forward reference. If we choose to support them at some + // future time, extra mechanism will be required at this point. + error(U_REGEX_INVALID_CAPTURE_GROUP_NAME); + } else { + // Given the number, handle identically to a \n numbered back reference. + // See comments above, under doBackRef + fixLiterals(FALSE); + if (fModeFlags & UREGEX_CASE_INSENSITIVE) { + appendOp(URX_BACKREF_I, groupNumber); + } else { + appendOp(URX_BACKREF, groupNumber); + } + } + delete fCaptureName; + fCaptureName = NULL; + break; + } + case doPossessivePlus: // Possessive ++ quantifier. // Compiles to @@ -1342,22 +1365,18 @@ UBool RegexCompile::doParseActions(int32_t action) { // Emit the STO_SP int32_t topLoc = blockTopLoc(TRUE); - int32_t stoLoc = fRXPat->fDataSize; - fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr. - int32_t op = URX_BUILD(URX_STO_SP, stoLoc); + int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr. + int32_t op = buildOp(URX_STO_SP, stoLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc); // Emit the STATE_SAVE - op = URX_BUILD(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+2); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_STATE_SAVE, fRXPat->fCompiledPat->size()+2); // Emit the JMP - op = URX_BUILD(URX_JMP, topLoc+1); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_JMP, topLoc+1); // Emit the LD_SP - op = URX_BUILD(URX_LD_SP, stoLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LD_SP, stoLoc); } break; @@ -1377,23 +1396,20 @@ UBool RegexCompile::doParseActions(int32_t action) insertOp(topLoc); // emit STO_SP loc - int32_t stoLoc = fRXPat->fDataSize; - fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr. - int32_t op = URX_BUILD(URX_STO_SP, stoLoc); + int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr. + int32_t op = buildOp(URX_STO_SP, stoLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc); // Emit the SAVE_STATE 5 int32_t L7 = fRXPat->fCompiledPat->size()+1; - op = URX_BUILD(URX_STATE_SAVE, L7); + op = buildOp(URX_STATE_SAVE, L7); fRXPat->fCompiledPat->setElementAt(op, topLoc+1); // Append the JMP operation. - op = URX_BUILD(URX_JMP, topLoc+1); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_JMP, topLoc+1); // Emit the LD_SP loc - op = URX_BUILD(URX_LD_SP, stoLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LD_SP, stoLoc); } break; @@ -1412,19 +1428,17 @@ UBool RegexCompile::doParseActions(int32_t action) insertOp(topLoc); // Emit the STO_SP - int32_t stoLoc = fRXPat->fDataSize; - fRXPat->fDataSize++; // Reserve the data location for storing save stack ptr. - int32_t op = URX_BUILD(URX_STO_SP, stoLoc); + int32_t stoLoc = allocateData(1); // Reserve the data location for storing save stack ptr. + int32_t op = buildOp(URX_STO_SP, stoLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc); // Emit the SAVE_STATE int32_t continueLoc = fRXPat->fCompiledPat->size()+1; - op = URX_BUILD(URX_STATE_SAVE, continueLoc); + op = buildOp(URX_STATE_SAVE, continueLoc); fRXPat->fCompiledPat->setElementAt(op, topLoc+1); // Emit the LD_SP - op = URX_BUILD(URX_LD_SP, stoLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LD_SP, stoLoc); } break; @@ -1481,8 +1495,8 @@ UBool RegexCompile::doParseActions(int32_t action) // is an '|' alternation within the parens. { fixLiterals(FALSE); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_NOP, 0), *fStatus); + appendOp(URX_NOP, 0); + appendOp(URX_NOP, 0); // On the Parentheses stack, start a new frame and add the postions // of the two NOPs (a normal non-capturing () frame, except for the @@ -1559,6 +1573,48 @@ UBool RegexCompile::doParseActions(int32_t action) break; } + case doSetBackslash_h: + { + UnicodeSet *set = (UnicodeSet *)fSetStack.peek(); + UnicodeSet h; + h.applyIntPropertyValue(UCHAR_GENERAL_CATEGORY_MASK, U_GC_ZS_MASK, *fStatus); + h.add((UChar32)9); // Tab + set->addAll(h); + break; + } + + case doSetBackslash_H: + { + UnicodeSet *set = (UnicodeSet *)fSetStack.peek(); + UnicodeSet h; + h.applyIntPropertyValue(UCHAR_GENERAL_CATEGORY_MASK, U_GC_ZS_MASK, *fStatus); + h.add((UChar32)9); // Tab + h.complement(); + set->addAll(h); + break; + } + + case doSetBackslash_v: + { + UnicodeSet *set = (UnicodeSet *)fSetStack.peek(); + set->add((UChar32)0x0a, (UChar32)0x0d); // add range + set->add((UChar32)0x85); + set->add((UChar32)0x2028, (UChar32)0x2029); + break; + } + + case doSetBackslash_V: + { + UnicodeSet *set = (UnicodeSet *)fSetStack.peek(); + UnicodeSet v; + v.add((UChar32)0x0a, (UChar32)0x0d); // add range + v.add((UChar32)0x85); + v.add((UChar32)0x2028, (UChar32)0x2029); + v.complement(); + set->addAll(v); + break; + } + case doSetBackslash_w: { UnicodeSet *set = (UnicodeSet *)fSetStack.peek(); @@ -1643,7 +1699,7 @@ UBool RegexCompile::doParseActions(int32_t action) compileSet(theSet); break; } - + case doSetIntersection2: // Have scanned something like [abc&& setPushOp(setIntersection2); @@ -1654,7 +1710,7 @@ UBool RegexCompile::doParseActions(int32_t action) // This operation is the highest precedence set operation, so we can always do // it immediately, without waiting to see what follows. It is necessary to perform // any pending '-' or '&' operation first, because these have the same precedence - // as union-ing in a literal' + // as union-ing in a literal' { setEval(setUnion); UnicodeSet *s = (UnicodeSet *)fSetStack.peek(); @@ -1749,7 +1805,7 @@ UBool RegexCompile::doParseActions(int32_t action) } // else error. scanProp() reported the error status already. } break; - + case doSetProp: // Scanned a \p \P within [brackets]. { @@ -1771,7 +1827,7 @@ UBool RegexCompile::doParseActions(int32_t action) // and ICU UnicodeSet behavior. { if (fLastSetLiteral > fC.fChar) { - error(U_REGEX_INVALID_RANGE); + error(U_REGEX_INVALID_RANGE); } UnicodeSet *s = (UnicodeSet *)fSetStack.peek(); s->add(fLastSetLiteral, fC.fChar); @@ -1819,7 +1875,6 @@ void RegexCompile::literalChar(UChar32 c) { // //------------------------------------------------------------------------------ void RegexCompile::fixLiterals(UBool split) { - int32_t op = 0; // An op from/for the compiled pattern. // If no literal characters have been scanned but not yet had code generated // for them, nothing needs to be done. @@ -1830,7 +1885,7 @@ void RegexCompile::fixLiterals(UBool split) { int32_t indexOfLastCodePoint = fLiteralChars.moveIndex32(fLiteralChars.length(), -1); UChar32 lastCodePoint = fLiteralChars.char32At(indexOfLastCodePoint); - // Split: We need to ensure that the last item in the compiled pattern + // Split: We need to ensure that the last item in the compiled pattern // refers only to the last literal scanned in the pattern, so that // quantifiers (*, +, etc.) affect only it, and not a longer string. // Split before case folding for case insensitive matches. @@ -1856,26 +1911,26 @@ void RegexCompile::fixLiterals(UBool split) { if (indexOfLastCodePoint == 0) { // Single character, emit a URX_ONECHAR op to match it. - if ((fModeFlags & UREGEX_CASE_INSENSITIVE) && + if ((fModeFlags & UREGEX_CASE_INSENSITIVE) && u_hasBinaryProperty(lastCodePoint, UCHAR_CASE_SENSITIVE)) { - op = URX_BUILD(URX_ONECHAR_I, lastCodePoint); + appendOp(URX_ONECHAR_I, lastCodePoint); } else { - op = URX_BUILD(URX_ONECHAR, lastCodePoint); + appendOp(URX_ONECHAR, lastCodePoint); } - fRXPat->fCompiledPat->addElement(op, *fStatus); } else { // Two or more chars, emit a URX_STRING to match them. + if (fLiteralChars.length() > 0x00ffffff || fRXPat->fLiteralText.length() > 0x00ffffff) { + error(U_REGEX_PATTERN_TOO_BIG); + } if (fModeFlags & UREGEX_CASE_INSENSITIVE) { - op = URX_BUILD(URX_STRING_I, fRXPat->fLiteralText.length()); + appendOp(URX_STRING_I, fRXPat->fLiteralText.length()); } else { // TODO here: add optimization to split case sensitive strings of length two // into two single char ops, for efficiency. - op = URX_BUILD(URX_STRING, fRXPat->fLiteralText.length()); + appendOp(URX_STRING, fRXPat->fLiteralText.length()); } - fRXPat->fCompiledPat->addElement(op, *fStatus); - op = URX_BUILD(URX_STRING_LEN, fLiteralChars.length()); - fRXPat->fCompiledPat->addElement(op, *fStatus); - + appendOp(URX_STRING_LEN, fLiteralChars.length()); + // Add this string into the accumulated strings of the compiled pattern. fRXPat->fLiteralText.append(fLiteralChars); } @@ -1884,8 +1939,58 @@ void RegexCompile::fixLiterals(UBool split) { } +int32_t RegexCompile::buildOp(int32_t type, int32_t val) { + if (U_FAILURE(*fStatus)) { + return 0; + } + if (type < 0 || type > 255) { + U_ASSERT(FALSE); + error(U_REGEX_INTERNAL_ERROR); + type = URX_RESERVED_OP; + } + if (val > 0x00ffffff) { + U_ASSERT(FALSE); + error(U_REGEX_INTERNAL_ERROR); + val = 0; + } + if (val < 0) { + if (!(type == URX_RESERVED_OP_N || type == URX_RESERVED_OP)) { + U_ASSERT(FALSE); + error(U_REGEX_INTERNAL_ERROR); + return -1; + } + if (URX_TYPE(val) != 0xff) { + U_ASSERT(FALSE); + error(U_REGEX_INTERNAL_ERROR); + return -1; + } + type = URX_RESERVED_OP_N; + } + return (type << 24) | val; +} + +//------------------------------------------------------------------------------ +// +// appendOp() Append a new instruction onto the compiled pattern +// Includes error checking, limiting the size of the +// pattern to lengths that can be represented in the +// 24 bit operand field of an instruction. +// +//------------------------------------------------------------------------------ +void RegexCompile::appendOp(int32_t op) { + if (U_FAILURE(*fStatus)) { + return; + } + fRXPat->fCompiledPat->addElement(op, *fStatus); + if ((fRXPat->fCompiledPat->size() > 0x00fffff0) && U_SUCCESS(*fStatus)) { + error(U_REGEX_PATTERN_TOO_BIG); + } +} +void RegexCompile::appendOp(int32_t type, int32_t val) { + appendOp(buildOp(type, val)); +} //------------------------------------------------------------------------------ @@ -1901,7 +2006,7 @@ void RegexCompile::insertOp(int32_t where) { UVector64 *code = fRXPat->fCompiledPat; U_ASSERT(where>0 && where < code->size()); - int32_t nop = URX_BUILD(URX_NOP, 0); + int32_t nop = buildOp(URX_NOP, 0); code->insertElementAt(nop, where, *fStatus); // Walk through the pattern, looking for any ops with targets that @@ -1922,7 +2027,7 @@ void RegexCompile::insertOp(int32_t where) { // Target location for this opcode is after the insertion point and // needs to be incremented to adjust for the insertion. opValue++; - op = URX_BUILD(opType, opValue); + op = buildOp(opType, opValue); code->setElementAt(op, loc); } } @@ -1947,6 +2052,58 @@ void RegexCompile::insertOp(int32_t where) { } +//------------------------------------------------------------------------------ +// +// allocateData() Allocate storage in the matcher's static data area. +// Return the index for the newly allocated data. +// The storage won't actually exist until we are running a match +// operation, but the storage indexes are inserted into various +// opcodes while compiling the pattern. +// +//------------------------------------------------------------------------------ +int32_t RegexCompile::allocateData(int32_t size) { + if (U_FAILURE(*fStatus)) { + return 0; + } + if (size <= 0 || size > 0x100 || fRXPat->fDataSize < 0) { + error(U_REGEX_INTERNAL_ERROR); + return 0; + } + int32_t dataIndex = fRXPat->fDataSize; + fRXPat->fDataSize += size; + if (fRXPat->fDataSize >= 0x00fffff0) { + error(U_REGEX_INTERNAL_ERROR); + } + return dataIndex; +} + + +//------------------------------------------------------------------------------ +// +// allocateStackData() Allocate space in the back-tracking stack frame. +// Return the index for the newly allocated data. +// The frame indexes are inserted into various +// opcodes while compiling the pattern, meaning that frame +// size must be restricted to the size that will fit +// as an operand (24 bits). +// +//------------------------------------------------------------------------------ +int32_t RegexCompile::allocateStackData(int32_t size) { + if (U_FAILURE(*fStatus)) { + return 0; + } + if (size <= 0 || size > 0x100 || fRXPat->fFrameSize < 0) { + error(U_REGEX_INTERNAL_ERROR); + return 0; + } + int32_t dataIndex = fRXPat->fFrameSize; + fRXPat->fFrameSize += size; + if (fRXPat->fFrameSize >= 0x00fffff0) { + error(U_REGEX_PATTERN_TOO_BIG); + } + return dataIndex; +} + //------------------------------------------------------------------------------ // @@ -1989,7 +2146,7 @@ int32_t RegexCompile::blockTopLoc(UBool reserveLoc) { theLoc--; } if (reserveLoc) { - int32_t nop = URX_BUILD(URX_NOP, 0); + int32_t nop = buildOp(URX_NOP, 0); fRXPat->fCompiledPat->insertElementAt(nop, theLoc, *fStatus); } } @@ -2064,8 +2221,7 @@ void RegexCompile::handleCloseParen() { U_ASSERT(URX_TYPE(captureOp) == URX_START_CAPTURE); int32_t frameVarLocation = URX_VAL(captureOp); - int32_t endCaptureOp = URX_BUILD(URX_END_CAPTURE, frameVarLocation); - fRXPat->fCompiledPat->addElement(endCaptureOp, *fStatus); + appendOp(URX_END_CAPTURE, frameVarLocation); } break; case atomic: @@ -2076,8 +2232,7 @@ void RegexCompile::handleCloseParen() { int32_t stoOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen+1); U_ASSERT(URX_TYPE(stoOp) == URX_STO_SP); int32_t stoLoc = URX_VAL(stoOp); - int32_t ldOp = URX_BUILD(URX_LD_SP, stoLoc); - fRXPat->fCompiledPat->addElement(ldOp, *fStatus); + appendOp(URX_LD_SP, stoLoc); } break; @@ -2086,8 +2241,7 @@ void RegexCompile::handleCloseParen() { int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-5); U_ASSERT(URX_TYPE(startOp) == URX_LA_START); int32_t dataLoc = URX_VAL(startOp); - int32_t op = URX_BUILD(URX_LA_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LA_END, dataLoc); } break; @@ -2097,19 +2251,16 @@ void RegexCompile::handleCloseParen() { int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-1); U_ASSERT(URX_TYPE(startOp) == URX_LA_START); int32_t dataLoc = URX_VAL(startOp); - int32_t op = URX_BUILD(URX_LA_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - op = URX_BUILD(URX_BACKTRACK, 0); - fRXPat->fCompiledPat->addElement(op, *fStatus); - op = URX_BUILD(URX_LA_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LA_END, dataLoc); + appendOp(URX_BACKTRACK, 0); + appendOp(URX_LA_END, dataLoc); // Patch the URX_SAVE near the top of the block. // The destination of the SAVE is the final LA_END that was just added. int32_t saveOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen); U_ASSERT(URX_TYPE(saveOp) == URX_STATE_SAVE); int32_t dest = fRXPat->fCompiledPat->size()-1; - saveOp = URX_BUILD(URX_STATE_SAVE, dest); + saveOp = buildOp(URX_STATE_SAVE, dest); fRXPat->fCompiledPat->setElementAt(saveOp, fMatchOpenParen); } break; @@ -2122,10 +2273,8 @@ void RegexCompile::handleCloseParen() { int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-4); U_ASSERT(URX_TYPE(startOp) == URX_LB_START); int32_t dataLoc = URX_VAL(startOp); - int32_t op = URX_BUILD(URX_LB_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); - op = URX_BUILD(URX_LA_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LB_END, dataLoc); + appendOp(URX_LA_END, dataLoc); // Determine the min and max bounds for the length of the // string that the pattern can match. @@ -2133,6 +2282,10 @@ void RegexCompile::handleCloseParen() { int32_t patEnd = fRXPat->fCompiledPat->size() - 1; int32_t minML = minMatchLength(fMatchOpenParen, patEnd); int32_t maxML = maxMatchLength(fMatchOpenParen, patEnd); + if (URX_TYPE(maxML) != 0) { + error(U_REGEX_LOOK_BEHIND_LIMIT); + break; + } if (maxML == INT32_MAX) { error(U_REGEX_LOOK_BEHIND_LIMIT); break; @@ -2157,8 +2310,7 @@ void RegexCompile::handleCloseParen() { int32_t startOp = (int32_t)fRXPat->fCompiledPat->elementAti(fMatchOpenParen-5); U_ASSERT(URX_TYPE(startOp) == URX_LB_START); int32_t dataLoc = URX_VAL(startOp); - int32_t op = URX_BUILD(URX_LBN_END, dataLoc); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(URX_LBN_END, dataLoc); // Determine the min and max bounds for the length of the // string that the pattern can match. @@ -2166,6 +2318,10 @@ void RegexCompile::handleCloseParen() { int32_t patEnd = fRXPat->fCompiledPat->size() - 1; int32_t minML = minMatchLength(fMatchOpenParen, patEnd); int32_t maxML = maxMatchLength(fMatchOpenParen, patEnd); + if (URX_TYPE(maxML) != 0) { + error(U_REGEX_LOOK_BEHIND_LIMIT); + break; + } if (maxML == INT32_MAX) { error(U_REGEX_LOOK_BEHIND_LIMIT); break; @@ -2179,7 +2335,7 @@ void RegexCompile::handleCloseParen() { // Insert the pattern location to continue at after a successful match // as the last operand of the URX_LBN_CONT - op = URX_BUILD(URX_RELOC_OPRND, fRXPat->fCompiledPat->size()); + int32_t op = buildOp(URX_RELOC_OPRND, fRXPat->fCompiledPat->size()); fRXPat->fCompiledPat->setElementAt(op, fMatchOpenParen-1); } break; @@ -2220,7 +2376,7 @@ void RegexCompile::compileSet(UnicodeSet *theSet) case 0: { // Set of no elements. Always fails to match. - fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKTRACK, 0), *fStatus); + appendOp(URX_BACKTRACK, 0); delete theSet; } break; @@ -2241,8 +2397,7 @@ void RegexCompile::compileSet(UnicodeSet *theSet) // Put it into the compiled pattern as a set. int32_t setNumber = fRXPat->fSets->size(); fRXPat->fSets->addElement(theSet, *fStatus); - int32_t setOp = URX_BUILD(URX_SETREF, setNumber); - fRXPat->fCompiledPat->addElement(setOp, *fStatus); + appendOp(URX_SETREF, setNumber); } } } @@ -2254,6 +2409,8 @@ void RegexCompile::compileSet(UnicodeSet *theSet) // Except for the specific opcodes used, the code is the same // for all three types (greedy, non-greedy, possessive) of // intervals. The opcodes are supplied as parameters. +// (There are two sets of opcodes - greedy & possessive use the +// same ones, while non-greedy has it's own.) // // The code for interval loops has this form: // 0 CTR_INIT counter loc (in stack frame) @@ -2275,11 +2432,14 @@ void RegexCompile::compileInterval(int32_t InitOp, int32_t LoopOp) insertOp(topOfBlock); // The operands for the CTR_INIT opcode include the index in the matcher data - // of the counter. Allocate it now. - int32_t counterLoc = fRXPat->fFrameSize; - fRXPat->fFrameSize++; - - int32_t op = URX_BUILD(InitOp, counterLoc); + // of the counter. Allocate it now. There are two data items + // counterLoc --> Loop counter + // +1 --> Input index (for breaking non-progressing loops) + // (Only present if unbounded upper limit on loop) + int32_t dataSize = fIntervalUpper < 0 ? 2 : 1; + int32_t counterLoc = allocateStackData(dataSize); + + int32_t op = buildOp(InitOp, counterLoc); fRXPat->fCompiledPat->setElementAt(op, topOfBlock); // The second operand of CTR_INIT is the location following the end of the loop. @@ -2287,7 +2447,7 @@ void RegexCompile::compileInterval(int32_t InitOp, int32_t LoopOp) // compilation of something later on causes the code to grow and the target // position to move. int32_t loopEnd = fRXPat->fCompiledPat->size(); - op = URX_BUILD(URX_RELOC_OPRND, loopEnd); + op = buildOp(URX_RELOC_OPRND, loopEnd); fRXPat->fCompiledPat->setElementAt(op, topOfBlock+1); // Followed by the min and max counts. @@ -2296,8 +2456,7 @@ void RegexCompile::compileInterval(int32_t InitOp, int32_t LoopOp) // Apend the CTR_LOOP op. The operand is the location of the CTR_INIT op. // Goes at end of the block being looped over, so just append to the code so far. - op = URX_BUILD(LoopOp, topOfBlock); - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(LoopOp, topOfBlock); if ((fIntervalLow & 0xff000000) != 0 || (fIntervalUpper > 0 && (fIntervalUpper & 0xff000000) != 0)) { @@ -2321,7 +2480,15 @@ UBool RegexCompile::compileInlineInterval() { int32_t topOfBlock = blockTopLoc(FALSE); if (fIntervalUpper == 0) { // Pathological case. Attempt no matches, as if the block doesn't exist. + // Discard the generated code for the block. + // If the block included parens, discard the info pertaining to them as well. fRXPat->fCompiledPat->setSize(topOfBlock); + if (fMatchOpenParen >= topOfBlock) { + fMatchOpenParen = -1; + } + if (fMatchCloseParen >= topOfBlock) { + fMatchCloseParen = -1; + } return TRUE; } @@ -2342,7 +2509,7 @@ UBool RegexCompile::compileInlineInterval() { // int32_t endOfSequenceLoc = fRXPat->fCompiledPat->size()-1 + fIntervalUpper + (fIntervalUpper-fIntervalLow); - int32_t saveOp = URX_BUILD(URX_STATE_SAVE, endOfSequenceLoc); + int32_t saveOp = buildOp(URX_STATE_SAVE, endOfSequenceLoc); if (fIntervalLow == 0) { insertOp(topOfBlock); fRXPat->fCompiledPat->setElementAt(saveOp, topOfBlock); @@ -2355,19 +2522,115 @@ UBool RegexCompile::compileInlineInterval() { // it was put there when it was originally encountered. int32_t i; for (i=1; ifCompiledPat->addElement(saveOp, *fStatus); - } - if (i > fIntervalLow) { - fRXPat->fCompiledPat->addElement(saveOp, *fStatus); + if (i >= fIntervalLow) { + appendOp(saveOp); } - fRXPat->fCompiledPat->addElement(op, *fStatus); + appendOp(op); } return TRUE; } +//------------------------------------------------------------------------------ +// +// caseInsensitiveStart given a single code point from a pattern string, determine the +// set of characters that could potentially begin a case-insensitive +// match of a string beginning with that character, using full Unicode +// case insensitive matching. +// +// This is used in optimizing find(). +// +// closeOver(USET_CASE_INSENSITIVE) does most of what is needed, but +// misses cases like this: +// A string from the pattern begins with 'ss' (although all we know +// in this context is that it begins with 's') +// The pattern could match a string beginning with a German sharp-s +// +// To the ordinary case closure for a character c, we add all other +// characters cx where the case closure of cx incudes a string form that begins +// with the original character c. +// +// This function could be made smarter. The full pattern string is available +// and it would be possible to verify that the extra characters being added +// to the starting set fully match, rather than having just a first-char of the +// folded form match. +// +//------------------------------------------------------------------------------ +void RegexCompile::findCaseInsensitiveStarters(UChar32 c, UnicodeSet *starterChars) { + +// Machine Generated below. +// It may need updating with new versions of Unicode. +// Intltest test RegexTest::TestCaseInsensitiveStarters will fail if an update is needed. +// The update tool is here: svn+ssh://source.icu-project.org/repos/icu/tools/trunk/unicode/c/genregexcasing + +// Machine Generated Data. Do not hand edit. + static const UChar32 RECaseFixCodePoints[] = { + 0x61, 0x66, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x77, 0x79, 0x2bc, + 0x3ac, 0x3ae, 0x3b1, 0x3b7, 0x3b9, 0x3c1, 0x3c5, 0x3c9, 0x3ce, 0x565, + 0x574, 0x57e, 0x1f00, 0x1f01, 0x1f02, 0x1f03, 0x1f04, 0x1f05, 0x1f06, 0x1f07, + 0x1f20, 0x1f21, 0x1f22, 0x1f23, 0x1f24, 0x1f25, 0x1f26, 0x1f27, 0x1f60, 0x1f61, + 0x1f62, 0x1f63, 0x1f64, 0x1f65, 0x1f66, 0x1f67, 0x1f70, 0x1f74, 0x1f7c, 0x110000}; + + static const int16_t RECaseFixStringOffsets[] = { + 0x0, 0x1, 0x6, 0x7, 0x8, 0x9, 0xd, 0xe, 0xf, 0x10, + 0x11, 0x12, 0x13, 0x17, 0x1b, 0x20, 0x21, 0x2a, 0x2e, 0x2f, + 0x30, 0x34, 0x35, 0x37, 0x39, 0x3b, 0x3d, 0x3f, 0x41, 0x43, + 0x45, 0x47, 0x49, 0x4b, 0x4d, 0x4f, 0x51, 0x53, 0x55, 0x57, + 0x59, 0x5b, 0x5d, 0x5f, 0x61, 0x63, 0x65, 0x66, 0x67, 0}; + + static const int16_t RECaseFixCounts[] = { + 0x1, 0x5, 0x1, 0x1, 0x1, 0x4, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x4, 0x4, 0x5, 0x1, 0x9, 0x4, 0x1, 0x1, + 0x4, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, + 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, + 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0}; + + static const UChar RECaseFixData[] = { + 0x1e9a, 0xfb00, 0xfb01, 0xfb02, 0xfb03, 0xfb04, 0x1e96, 0x130, 0x1f0, 0xdf, + 0x1e9e, 0xfb05, 0xfb06, 0x1e97, 0x1e98, 0x1e99, 0x149, 0x1fb4, 0x1fc4, 0x1fb3, + 0x1fb6, 0x1fb7, 0x1fbc, 0x1fc3, 0x1fc6, 0x1fc7, 0x1fcc, 0x390, 0x1fd2, 0x1fd3, + 0x1fd6, 0x1fd7, 0x1fe4, 0x3b0, 0x1f50, 0x1f52, 0x1f54, 0x1f56, 0x1fe2, 0x1fe3, + 0x1fe6, 0x1fe7, 0x1ff3, 0x1ff6, 0x1ff7, 0x1ffc, 0x1ff4, 0x587, 0xfb13, 0xfb14, + 0xfb15, 0xfb17, 0xfb16, 0x1f80, 0x1f88, 0x1f81, 0x1f89, 0x1f82, 0x1f8a, 0x1f83, + 0x1f8b, 0x1f84, 0x1f8c, 0x1f85, 0x1f8d, 0x1f86, 0x1f8e, 0x1f87, 0x1f8f, 0x1f90, + 0x1f98, 0x1f91, 0x1f99, 0x1f92, 0x1f9a, 0x1f93, 0x1f9b, 0x1f94, 0x1f9c, 0x1f95, + 0x1f9d, 0x1f96, 0x1f9e, 0x1f97, 0x1f9f, 0x1fa0, 0x1fa8, 0x1fa1, 0x1fa9, 0x1fa2, + 0x1faa, 0x1fa3, 0x1fab, 0x1fa4, 0x1fac, 0x1fa5, 0x1fad, 0x1fa6, 0x1fae, 0x1fa7, + 0x1faf, 0x1fb2, 0x1fc2, 0x1ff2, 0}; + +// End of machine generated data. + + if (u_hasBinaryProperty(c, UCHAR_CASE_SENSITIVE)) { + UChar32 caseFoldedC = u_foldCase(c, U_FOLD_CASE_DEFAULT); + starterChars->set(caseFoldedC, caseFoldedC); + + int32_t i; + for (i=0; RECaseFixCodePoints[i]add(cpToAdd); + } + } + + starterChars->closeOver(USET_CASE_INSENSITIVE); + starterChars->removeAllStrings(); + } else { + // Not a cased character. Just return it alone. + starterChars->set(c, c); + } +} + + + + //------------------------------------------------------------------------------ // // matchStartType Determine how a match can start. @@ -2441,7 +2704,7 @@ void RegexCompile::matchStartType() { case URX_STO_INP_LOC: case URX_BACKREF: // BackRef. Must assume that it might be a zero length match case URX_BACKREF_I: - + case URX_STO_SP: // Setup for atomic or possessive blocks. Doesn't change what can match. case URX_LD_SP: break; @@ -2553,22 +2816,54 @@ void RegexCompile::matchStartType() { break; + case URX_BACKSLASH_H: + // Horiz white space + if (currentLen == 0) { + UnicodeSet s; + s.applyIntPropertyValue(UCHAR_GENERAL_CATEGORY_MASK, U_GC_ZS_MASK, *fStatus); + s.add((UChar32)9); // Tab + if (URX_VAL(op) != 0) { + s.complement(); + } + fRXPat->fInitialChars->addAll(s); + numInitialStrings += 2; + } + currentLen++; + atStart = FALSE; + break; + + + case URX_BACKSLASH_R: // Any line ending sequence + case URX_BACKSLASH_V: // Any line ending code point, with optional negation + if (currentLen == 0) { + UnicodeSet s; + s.add((UChar32)0x0a, (UChar32)0x0d); // add range + s.add((UChar32)0x85); + s.add((UChar32)0x2028, (UChar32)0x2029); + if (URX_VAL(op) != 0) { + // Complement option applies to URX_BACKSLASH_V only. + s.complement(); + } + fRXPat->fInitialChars->addAll(s); + numInitialStrings += 2; + } + currentLen++; + atStart = FALSE; + break; + + + case URX_ONECHAR_I: // Case Insensitive Single Character. if (currentLen == 0) { UChar32 c = URX_VAL(op); if (u_hasBinaryProperty(c, UCHAR_CASE_SENSITIVE)) { - - // Disable optimizations on first char of match. - // TODO: Compute the set of chars that case fold to this char, or to - // a string that begins with this char. - // For simple case folding, this code worked: - // UnicodeSet s(c, c); - // s.closeOver(USET_CASE_INSENSITIVE); - // fRXPat->fInitialChars->addAll(s); - - fRXPat->fInitialChars->clear(); - fRXPat->fInitialChars->complement(); + UnicodeSet starters(c, c); + starters.closeOver(USET_CASE_INSENSITIVE); + // findCaseInsensitiveStarters(c, &starters); + // For ONECHAR_I, no need to worry about text chars that expand on folding into strings. + // The expanded folding can't match the pattern. + fRXPat->fInitialChars->addAll(starters); } else { // Char has no case variants. Just add it as-is to the // set of possible starting chars. @@ -2691,14 +2986,8 @@ void RegexCompile::matchStartType() { // characters for this pattern. int32_t stringStartIdx = URX_VAL(op); UChar32 c = fRXPat->fLiteralText.char32At(stringStartIdx); - UnicodeSet s(c, c); - - // TODO: compute correct set of starting chars for full case folding. - // For the moment, say any char can start. - // s.closeOver(USET_CASE_INSENSITIVE); - s.clear(); - s.complement(); - + UnicodeSet s; + findCaseInsensitiveStarters(c, &s); fRXPat->fInitialChars->addAll(s); numInitialStrings += 2; // Matching on an initial string not possible. } @@ -2754,7 +3043,7 @@ void RegexCompile::matchStartType() { { // Look-around. Scan forward until the matching look-ahead end, // without processing the look-around block. This is overly pessimistic. - + // Keep track of the nesting depth of look-around blocks. Boilerplate code for // lookahead contains two LA_END instructions, so count goes up by two // for each LA_START. @@ -2952,6 +3241,9 @@ int32_t RegexCompile::minMatchLength(int32_t start, int32_t end) { case URX_STAT_SETREF_N: case URX_SETREF: case URX_BACKSLASH_D: + case URX_BACKSLASH_H: + case URX_BACKSLASH_R: + case URX_BACKSLASH_V: case URX_ONECHAR_I: case URX_BACKSLASH_X: // Grahpeme Cluster. Minimum is 1, max unbounded. case URX_DOTANY_ALL: // . matches one or two. @@ -3233,6 +3525,9 @@ int32_t RegexCompile::maxMatchLength(int32_t start, int32_t end) { case URX_STAT_SETREF_N: case URX_SETREF: case URX_BACKSLASH_D: + case URX_BACKSLASH_H: + case URX_BACKSLASH_R: + case URX_BACKSLASH_V: case URX_ONECHAR_I: case URX_DOTANY_ALL: case URX_DOTANY: @@ -3314,7 +3609,7 @@ int32_t RegexCompile::maxMatchLength(int32_t start, int32_t end) { // compiled (folded) string. Folding may add code points, but // not remove them. // - // There is a potential problem if a supplemental code point + // There is a potential problem if a supplemental code point // case-folds to a BMP code point. In this case our compiled string // could be shorter (in code units) than a matching user string. // @@ -3335,14 +3630,47 @@ int32_t RegexCompile::maxMatchLength(int32_t start, int32_t end) { case URX_CTR_INIT: case URX_CTR_INIT_NG: + // For Loops, recursively call this function on the pattern for the loop body, + // then multiply the result by the maximum loop count. + { + int32_t loopEndLoc = URX_VAL(fRXPat->fCompiledPat->elementAti(loc+1)); + if (loopEndLoc == loc+4) { + // Loop has an empty body. No affect on max match length. + // Continue processing with code after the loop end. + loc = loopEndLoc; + break; + } + + int32_t maxLoopCount = static_cast(fRXPat->fCompiledPat->elementAti(loc+3)); + if (maxLoopCount == -1) { + // Unbounded Loop. No upper bound on match length. + currentLen = INT32_MAX; + break; + } + + U_ASSERT(loopEndLoc >= loc+4); + int64_t blockLen = maxMatchLength(loc+4, loopEndLoc-1); // Recursive call. + int64_t updatedLen = (int64_t)currentLen + blockLen * maxLoopCount; + if (updatedLen >= INT32_MAX) { + currentLen = INT32_MAX; + break; + } + currentLen = (int32_t)updatedLen; + loc = loopEndLoc; + break; + } + case URX_CTR_LOOP: case URX_CTR_LOOP_NG: + // These opcodes will be skipped over by code for URX_CRT_INIT. + // We shouldn't encounter them here. + U_ASSERT(FALSE); + break; + case URX_LOOP_SR_I: case URX_LOOP_DOT_I: case URX_LOOP_C: // For anything to do with loops, make the match length unbounded. - // Note: INIT instructions are multi-word. Can ignore because - // INT32_MAX length will stop the per-instruction loop. currentLen = INT32_MAX; break; @@ -3431,7 +3759,7 @@ void RegexCompile::stripNOPs() { d++; } } - + UnicodeString caseStringBuffer; // Make a second pass over the code, removing the NOPs by moving following @@ -3460,7 +3788,7 @@ void RegexCompile::stripNOPs() { int32_t operandAddress = URX_VAL(op); U_ASSERT(operandAddress>=0 && operandAddressfCompiledPat->setElementAt(op, dst); dst++; break; @@ -3475,10 +3803,10 @@ void RegexCompile::stripNOPs() { break; } where = fRXPat->fGroupMap->elementAti(where-1); - op = URX_BUILD(opType, where); + op = buildOp(opType, where); fRXPat->fCompiledPat->setElementAt(op, dst); dst++; - + fRXPat->fNeedsAltInput = TRUE; break; } @@ -3528,6 +3856,9 @@ void RegexCompile::stripNOPs() { case URX_LOOP_C: case URX_DOLLAR_D: case URX_DOLLAR_MD: + case URX_BACKSLASH_H: + case URX_BACKSLASH_R: + case URX_BACKSLASH_V: // These instructions are unaltered by the relocation. fRXPat->fCompiledPat->setElementAt(op, dst); dst++; @@ -3569,7 +3900,7 @@ void RegexCompile::error(UErrorCode e) { fParseErr->line = (int32_t)fLineNum; fParseErr->offset = (int32_t)fCharNum; } - + UErrorCode status = U_ZERO_ERROR; // throwaway status for extracting context // Fill in the context. @@ -3595,10 +3926,10 @@ static const UChar chDigit7 = 0x37; // '9' static const UChar chColon = 0x3A; // ':' static const UChar chE = 0x45; // 'E' static const UChar chQ = 0x51; // 'Q' -static const UChar chN = 0x4E; // 'N' +//static const UChar chN = 0x4E; // 'N' static const UChar chP = 0x50; // 'P' static const UChar chBackSlash = 0x5c; // '\' introduces a char escape -static const UChar chLBracket = 0x5b; // '[' +//static const UChar chLBracket = 0x5b; // '[' static const UChar chRBracket = 0x5d; // ']' static const UChar chUp = 0x5e; // '^' static const UChar chLowerP = 0x70; @@ -3623,7 +3954,7 @@ UChar32 RegexCompile::nextCharLL() { fPeekChar = -1; return ch; } - + // assume we're already in the right place ch = UTEXT_NEXT32(fRXPat->fPattern); if (ch == U_SENTINEL) { @@ -3679,7 +4010,7 @@ void RegexCompile::nextChar(RegexPatternChar &c) { if (fQuoteMode) { c.fQuoted = TRUE; - if ((c.fChar==chBackSlash && peekCharLL()==chE && ((fModeFlags & UREGEX_LITERAL) == 0)) || + if ((c.fChar==chBackSlash && peekCharLL()==chE && ((fModeFlags & UREGEX_LITERAL) == 0)) || c.fChar == (UChar32)-1) { fQuoteMode = FALSE; // Exit quote mode, nextCharLL(); // discard the E @@ -3740,11 +4071,11 @@ void RegexCompile::nextChar(RegexPatternChar &c) { // nextCharLL(); // get & discard the peeked char. c.fQuoted = TRUE; - + if (UTEXT_FULL_TEXT_IN_CHUNK(fRXPat->fPattern, fPatternLength)) { int32_t endIndex = (int32_t)pos; c.fChar = u_unescapeAt(uregex_ucstr_unescape_charAt, &endIndex, (int32_t)fPatternLength, (void *)fRXPat->fPattern->chunkContents); - + if (endIndex == pos) { error(U_REGEX_BAD_ESCAPE_SEQUENCE); } @@ -3753,7 +4084,7 @@ void RegexCompile::nextChar(RegexPatternChar &c) { } else { int32_t offset = 0; struct URegexUTextUnescapeCharContext context = U_REGEX_UTEXT_UNESCAPE_CONTEXT(fRXPat->fPattern); - + UTEXT_SETNATIVEINDEX(fRXPat->fPattern, pos); c.fChar = u_unescapeAt(uregex_utext_unescape_charAt, &offset, INT32_MAX, &context); @@ -3796,8 +4127,8 @@ void RegexCompile::nextChar(RegexPatternChar &c) { c.fChar >>= 3; } } - c.fQuoted = TRUE; - } + c.fQuoted = TRUE; + } else if (peekCharLL() == chQ) { // "\Q" enter quote mode, which will continue until "\E" fQuoteMode = TRUE; @@ -3827,7 +4158,7 @@ void RegexCompile::nextChar(RegexPatternChar &c) { //------------------------------------------------------------------------------ // // scanNamedChar - // Get a UChar32 from a \N{UNICODE CHARACTER NAME} in the pattern. +// Get a UChar32 from a \N{UNICODE CHARACTER NAME} in the pattern. // // The scan position will be at the 'N'. On return // the scan position should be just after the '}' @@ -3845,7 +4176,7 @@ UChar32 RegexCompile::scanNamedChar() { error(U_REGEX_PROPERTY_SYNTAX); return 0; } - + UnicodeString charName; for (;;) { nextChar(fC); @@ -3858,7 +4189,7 @@ UChar32 RegexCompile::scanNamedChar() { } charName.append(fC.fChar); } - + char name[100]; if (!uprv_isInvariantUString(charName.getBuffer(), charName.length()) || (uint32_t)charName.length()>=sizeof(name)) { @@ -3897,6 +4228,7 @@ UnicodeSet *RegexCompile::scanProp() { if (U_FAILURE(*fStatus)) { return NULL; } + (void)chLowerP; // Suppress compiler unused variable warning. U_ASSERT(fC.fChar == chLowerP || fC.fChar == chP); UBool negated = (fC.fChar == chP); @@ -3966,7 +4298,7 @@ UnicodeSet *RegexCompile::scanPosixProp() { // Scan for a closing ]. A little tricky because there are some perverse // edge cases possible. "[:abc\Qdef:] \E]" is a valid non-property expression, - // ending on the second closing ]. + // ending on the second closing ]. UnicodeString propName; UBool negated = FALSE; @@ -3977,7 +4309,7 @@ UnicodeSet *RegexCompile::scanPosixProp() { negated = TRUE; nextChar(fC); } - + // Scan for the closing ":]", collecting the property name along the way. UBool sawPropSetTerminator = FALSE; for (;;) { @@ -3995,7 +4327,7 @@ UnicodeSet *RegexCompile::scanPosixProp() { break; } } - + if (sawPropSetTerminator) { uset = createSetForProperty(propName, negated); } @@ -4028,7 +4360,7 @@ static inline void addIdentifierIgnorable(UnicodeSet *set, UErrorCode& ec) { // Create a Unicode Set from a Unicode Property expression. // This is common code underlying both \p{...} ane [:...:] expressions. // Includes trying the Java "properties" that aren't supported as -// normal ICU UnicodeSet properties +// normal ICU UnicodeSet properties // static const UChar posSetPrefix[] = {0x5b, 0x5c, 0x70, 0x7b, 0}; // "[\p{" static const UChar negSetPrefix[] = {0x5b, 0x5c, 0x50, 0x7b, 0}; // "[\P{" @@ -4036,7 +4368,7 @@ UnicodeSet *RegexCompile::createSetForProperty(const UnicodeString &propName, UB UnicodeString setExpr; UnicodeSet *set; uint32_t usetFlags = 0; - + if (U_FAILURE(*fStatus)) { return NULL; } @@ -4061,13 +4393,13 @@ UnicodeSet *RegexCompile::createSetForProperty(const UnicodeString &propName, UB } delete set; set = NULL; - + // // The property as it was didn't work. - // Do [:word:]. It is not recognized as a property by UnicodeSet. "word" not standard POSIX + // Do [:word:]. It is not recognized as a property by UnicodeSet. "word" not standard POSIX // or standard Java, but many other regular expression packages do recognize it. - + if (propName.caseCompare(UNICODE_STRING_SIMPLE("word"), 0) == 0) { *fStatus = U_ZERO_ERROR; set = new UnicodeSet(*(fRXPat->fStaticSets[URX_ISWORD_SET])); @@ -4087,7 +4419,7 @@ UnicodeSet *RegexCompile::createSetForProperty(const UnicodeString &propName, UB // InCombiningMarksforSymbols -> InCombiningDiacriticalMarksforSymbols. // // Note on Spaces: either "InCombiningMarksForSymbols" or "InCombining Marks for Symbols" - // is accepted by Java. The property part of the name is compared + // is accepted by Java. The property part of the name is compared // case-insenstively. The spaces must be exactly as shown, either // all there, or all omitted, with exactly one at each position // if they are present. From checking against JDK 1.6 @@ -4106,7 +4438,7 @@ UnicodeSet *RegexCompile::createSetForProperty(const UnicodeString &propName, UB else if (mPropName.compare(UNICODE_STRING_SIMPLE("all")) == 0) { mPropName = UNICODE_STRING_SIMPLE("javaValidCodePoint"); } - + // See if the property looks like a Java "InBlockName", which // we will recast as "Block=BlockName" // @@ -4230,7 +4562,7 @@ UnicodeSet *RegexCompile::createSetForProperty(const UnicodeString &propName, UB set = NULL; } error(*fStatus); - return NULL; + return NULL; }