You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1106 lines
48 KiB
1106 lines
48 KiB
Index: /icu/trunk/source/common/unicode/utypes.h
|
|
===================================================================
|
|
--- /icu/trunk/source/common/unicode/utypes.h (revision 36800)
|
|
+++ /icu/trunk/source/common/unicode/utypes.h (revision 36801)
|
|
@@ -648,4 +648,5 @@
|
|
U_REGEX_TIME_OUT, /**< Maximum allowed match time exceeded */
|
|
U_REGEX_STOPPED_BY_CALLER, /**< Matching operation aborted by user callback fn. */
|
|
+ U_REGEX_PATTERN_TOO_BIG, /**< Pattern exceeds limits on size or complexity. @draft ICU 55 */
|
|
U_REGEX_ERROR_LIMIT, /**< This must always be the last value to indicate the limit for regexp errors */
|
|
|
|
Index: /icu/trunk/source/common/utypes.c
|
|
===================================================================
|
|
--- /icu/trunk/source/common/utypes.c (revision 36800)
|
|
+++ /icu/trunk/source/common/utypes.c (revision 36801)
|
|
@@ -2,5 +2,5 @@
|
|
******************************************************************************
|
|
*
|
|
-* Copyright (C) 1997-2011, International Business Machines
|
|
+* Copyright (C) 1997-2014, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
@@ -166,5 +166,6 @@
|
|
"U_REGEX_STACK_OVERFLOW",
|
|
"U_REGEX_TIME_OUT",
|
|
- "U_REGEX_STOPPED_BY_CALLER"
|
|
+ "U_REGEX_STOPPED_BY_CALLER",
|
|
+ "U_REGEX_PATTERN_TOO_BIG"
|
|
};
|
|
|
|
Index: /icu/trunk/source/i18n/regexcmp.cpp
|
|
===================================================================
|
|
--- /icu/trunk/source/i18n/regexcmp.cpp (revision 36800)
|
|
+++ /icu/trunk/source/i18n/regexcmp.cpp (revision 36801)
|
|
@@ -305,5 +305,5 @@
|
|
// the position in the compiled pattern.
|
|
//
|
|
- fRXPat->fFrameSize+=RESTACKFRAME_HDRCOUNT;
|
|
+ allocateStackData(RESTACKFRAME_HDRCOUNT);
|
|
|
|
//
|
|
@@ -371,7 +371,7 @@
|
|
//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
|
|
@@ -396,5 +396,5 @@
|
|
|
|
// 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.
|
|
@@ -418,5 +418,5 @@
|
|
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);
|
|
|
|
@@ -424,6 +424,5 @@
|
|
// 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.
|
|
@@ -434,5 +433,5 @@
|
|
// 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);
|
|
}
|
|
@@ -460,10 +459,8 @@
|
|
{
|
|
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
|
|
@@ -490,6 +487,6 @@
|
|
{
|
|
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
|
|
@@ -513,10 +510,8 @@
|
|
{
|
|
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
|
|
@@ -561,24 +556,12 @@
|
|
{
|
|
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
|
|
@@ -605,14 +588,8 @@
|
|
{
|
|
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
|
|
@@ -652,21 +629,17 @@
|
|
|
|
// 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.
|
|
-
|
|
- // Emit the NOP
|
|
- op = URX_BUILD(URX_NOP, 0);
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ 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 NOPs
|
|
+ appendOp(URX_NOP, 0);
|
|
+ appendOp(URX_NOP, 0);
|
|
|
|
// On the Parentheses stack, start a new frame and add the postions
|
|
@@ -708,22 +681,18 @@
|
|
|
|
// 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.
|
|
-
|
|
- // Emit the NOP
|
|
- op = URX_BUILD(URX_NOP, 0);
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ 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 NOPs
|
|
+ appendOp(URX_NOP, 0);
|
|
+ appendOp(URX_NOP, 0);
|
|
|
|
// On the Parentheses stack, start a new frame and add the postions
|
|
@@ -795,10 +764,7 @@
|
|
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;
|
|
}
|
|
@@ -808,5 +774,5 @@
|
|
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.
|
|
@@ -816,9 +782,7 @@
|
|
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;
|
|
}
|
|
@@ -834,16 +798,13 @@
|
|
// Emit the code sequence that can handle it.
|
|
insertOp(topLoc);
|
|
- frameLoc = fRXPat->fFrameSize;
|
|
- fRXPat->fFrameSize++;
|
|
-
|
|
- int32_t op = URX_BUILD(URX_STO_INP_LOC, frameLoc);
|
|
+ frameLoc = allocateStackData(1);
|
|
+
|
|
+ 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);
|
|
}
|
|
}
|
|
@@ -857,6 +818,5 @@
|
|
{
|
|
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;
|
|
@@ -872,5 +832,5 @@
|
|
{
|
|
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);
|
|
}
|
|
@@ -891,12 +851,10 @@
|
|
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);
|
|
-
|
|
- int32_t save_op = URX_BUILD(URX_STATE_SAVE, jmp1_loc+1);
|
|
- fRXPat->fCompiledPat->addElement(save_op, *fStatus);
|
|
+ appendOp(URX_JMP, jmp2_loc+2);
|
|
+
|
|
+ appendOp(URX_STATE_SAVE, jmp1_loc+1);
|
|
}
|
|
break;
|
|
@@ -938,10 +896,8 @@
|
|
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;
|
|
}
|
|
@@ -951,5 +907,5 @@
|
|
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.
|
|
@@ -960,8 +916,6 @@
|
|
}
|
|
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;
|
|
}
|
|
@@ -972,5 +926,5 @@
|
|
|
|
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
|
|
@@ -978,10 +932,9 @@
|
|
if (minMatchLength(saveStateLoc, fRXPat->fCompiledPat->size()-1) == 0) {
|
|
insertOp(saveStateLoc);
|
|
- dataLoc = fRXPat->fFrameSize;
|
|
- fRXPat->fFrameSize++;
|
|
-
|
|
- int32_t op = URX_BUILD(URX_STO_INP_LOC, dataLoc);
|
|
+ dataLoc = allocateStackData(1);
|
|
+
|
|
+ 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);
|
|
}
|
|
|
|
@@ -990,10 +943,10 @@
|
|
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;
|
|
@@ -1009,8 +962,7 @@
|
|
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;
|
|
@@ -1085,7 +1037,7 @@
|
|
// 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);
|
|
|
|
@@ -1096,6 +1048,5 @@
|
|
|
|
// 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);
|
|
}
|
|
|
|
@@ -1133,13 +1084,11 @@
|
|
{
|
|
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);
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ appendOp(URX_DOTANY, 0);
|
|
+ }
|
|
}
|
|
break;
|
|
@@ -1148,15 +1097,13 @@
|
|
{
|
|
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;
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus);
|
|
+ appendOp(URX_CARET_M_UNIX, 0);
|
|
+ }
|
|
}
|
|
break;
|
|
@@ -1165,15 +1112,13 @@
|
|
{
|
|
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;
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(URX_BUILD(op, 0), *fStatus);
|
|
+ appendOp(URX_DOLLAR_MD, 0);
|
|
+ }
|
|
}
|
|
break;
|
|
@@ -1181,5 +1126,5 @@
|
|
case doBackslashA:
|
|
fixLiterals(FALSE);
|
|
- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_CARET, 0), *fStatus);
|
|
+ appendOp(URX_CARET, 0);
|
|
break;
|
|
|
|
@@ -1193,5 +1138,5 @@
|
|
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;
|
|
@@ -1206,5 +1151,5 @@
|
|
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;
|
|
@@ -1212,44 +1157,40 @@
|
|
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 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 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;
|
|
|
|
@@ -1257,10 +1198,10 @@
|
|
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;
|
|
|
|
@@ -1322,11 +1263,9 @@
|
|
// 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);
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ appendOp(URX_BACKREF, groupNum);
|
|
+ }
|
|
}
|
|
break;
|
|
@@ -1349,20 +1288,16 @@
|
|
// 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;
|
|
@@ -1384,21 +1319,18 @@
|
|
|
|
// 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;
|
|
@@ -1419,17 +1351,15 @@
|
|
|
|
// 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;
|
|
@@ -1488,6 +1418,6 @@
|
|
{
|
|
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
|
|
@@ -1826,5 +1756,4 @@
|
|
//------------------------------------------------------------------------------
|
|
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
|
|
@@ -1865,21 +1794,21 @@
|
|
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);
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ appendOp(URX_ONECHAR, lastCodePoint);
|
|
+ }
|
|
} 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());
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
- op = URX_BUILD(URX_STRING_LEN, fLiteralChars.length());
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ appendOp(URX_STRING, fRXPat->fLiteralText.length());
|
|
+ }
|
|
+ appendOp(URX_STRING_LEN, fLiteralChars.length());
|
|
|
|
// Add this string into the accumulated strings of the compiled pattern.
|
|
@@ -1891,6 +1820,56 @@
|
|
|
|
|
|
-
|
|
-
|
|
+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));
|
|
+}
|
|
|
|
|
|
@@ -1908,5 +1887,5 @@
|
|
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);
|
|
|
|
@@ -1929,5 +1908,5 @@
|
|
// needs to be incremented to adjust for the insertion.
|
|
opValue++;
|
|
- op = URX_BUILD(opType, opValue);
|
|
+ op = buildOp(opType, opValue);
|
|
code->setElementAt(op, loc);
|
|
}
|
|
@@ -1953,4 +1932,56 @@
|
|
}
|
|
|
|
+
|
|
+//------------------------------------------------------------------------------
|
|
+//
|
|
+// 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;
|
|
+}
|
|
|
|
|
|
@@ -1996,5 +2027,5 @@
|
|
}
|
|
if (reserveLoc) {
|
|
- int32_t nop = URX_BUILD(URX_NOP, 0);
|
|
+ int32_t nop = buildOp(URX_NOP, 0);
|
|
fRXPat->fCompiledPat->insertElementAt(nop, theLoc, *fStatus);
|
|
}
|
|
@@ -2071,6 +2102,5 @@
|
|
|
|
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;
|
|
@@ -2083,6 +2113,5 @@
|
|
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;
|
|
@@ -2093,6 +2122,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;
|
|
@@ -2104,10 +2132,7 @@
|
|
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.
|
|
@@ -2116,5 +2141,5 @@
|
|
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);
|
|
}
|
|
@@ -2129,8 +2154,6 @@
|
|
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
|
|
@@ -2168,6 +2191,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
|
|
@@ -2194,5 +2216,5 @@
|
|
// 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);
|
|
}
|
|
@@ -2235,5 +2257,5 @@
|
|
{
|
|
// Set of no elements. Always fails to match.
|
|
- fRXPat->fCompiledPat->addElement(URX_BUILD(URX_BACKTRACK, 0), *fStatus);
|
|
+ appendOp(URX_BACKTRACK, 0);
|
|
delete theSet;
|
|
}
|
|
@@ -2256,6 +2278,5 @@
|
|
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);
|
|
}
|
|
}
|
|
@@ -2296,11 +2317,8 @@
|
|
// +1 --> Input index (for breaking non-progressing loops)
|
|
// (Only present if unbounded upper limit on loop)
|
|
- int32_t counterLoc = fRXPat->fFrameSize;
|
|
- fRXPat->fFrameSize++;
|
|
- if (fIntervalUpper < 0) {
|
|
- fRXPat->fFrameSize++;
|
|
- }
|
|
-
|
|
- int32_t op = URX_BUILD(InitOp, counterLoc);
|
|
+ int32_t dataSize = fIntervalUpper < 0 ? 2 : 1;
|
|
+ int32_t counterLoc = allocateStackData(dataSize);
|
|
+
|
|
+ int32_t op = buildOp(InitOp, counterLoc);
|
|
fRXPat->fCompiledPat->setElementAt(op, topOfBlock);
|
|
|
|
@@ -2310,5 +2328,5 @@
|
|
// 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);
|
|
|
|
@@ -2319,6 +2337,5 @@
|
|
// 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 ||
|
|
@@ -2373,5 +2390,5 @@
|
|
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);
|
|
@@ -2386,11 +2403,8 @@
|
|
int32_t i;
|
|
for (i=1; i<fIntervalUpper; i++ ) {
|
|
- if (i == fIntervalLow) {
|
|
- fRXPat->fCompiledPat->addElement(saveOp, *fStatus);
|
|
- }
|
|
- if (i > fIntervalLow) {
|
|
- fRXPat->fCompiledPat->addElement(saveOp, *fStatus);
|
|
- }
|
|
- fRXPat->fCompiledPat->addElement(op, *fStatus);
|
|
+ if (i >= fIntervalLow) {
|
|
+ appendOp(saveOp);
|
|
+ }
|
|
+ appendOp(op);
|
|
}
|
|
return TRUE;
|
|
@@ -3612,5 +3626,5 @@
|
|
U_ASSERT(operandAddress>=0 && operandAddress<deltas.size());
|
|
int32_t fixedOperandAddress = operandAddress - deltas.elementAti(operandAddress);
|
|
- op = URX_BUILD(opType, fixedOperandAddress);
|
|
+ op = buildOp(opType, fixedOperandAddress);
|
|
fRXPat->fCompiledPat->setElementAt(op, dst);
|
|
dst++;
|
|
@@ -3627,5 +3641,5 @@
|
|
}
|
|
where = fRXPat->fGroupMap->elementAti(where-1);
|
|
- op = URX_BUILD(opType, where);
|
|
+ op = buildOp(opType, where);
|
|
fRXPat->fCompiledPat->setElementAt(op, dst);
|
|
dst++;
|
|
@@ -3979,5 +3993,5 @@
|
|
//
|
|
// 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
|
|
Index: /icu/trunk/source/i18n/regexcmp.h
|
|
===================================================================
|
|
--- /icu/trunk/source/i18n/regexcmp.h (revision 36800)
|
|
+++ /icu/trunk/source/i18n/regexcmp.h (revision 36801)
|
|
@@ -105,4 +105,11 @@
|
|
void insertOp(int32_t where); // Open up a slot for a new op in the
|
|
// generated code at the specified location.
|
|
+ void appendOp(int32_t op); // Append a new op to the compiled pattern.
|
|
+ void appendOp(int32_t type, int32_t val); // Build & append a new op to the compiled pattern.
|
|
+ int32_t buildOp(int32_t type, int32_t val); // Construct a new pcode instruction.
|
|
+ int32_t allocateData(int32_t size); // Allocate space in the matcher data area.
|
|
+ // Return index of the newly allocated data.
|
|
+ int32_t allocateStackData(int32_t size); // Allocate space in the match back-track stack frame.
|
|
+ // Return offset index in the frame.
|
|
int32_t minMatchLength(int32_t start,
|
|
int32_t end);
|
|
Index: /icu/trunk/source/i18n/regeximp.h
|
|
===================================================================
|
|
--- /icu/trunk/source/i18n/regeximp.h (revision 36800)
|
|
+++ /icu/trunk/source/i18n/regeximp.h (revision 36801)
|
|
@@ -1,4 +1,4 @@
|
|
//
|
|
-// Copyright (C) 2002-2013 International Business Machines Corporation
|
|
+// Copyright (C) 2002-2014 International Business Machines Corporation
|
|
// and others. All rights reserved.
|
|
//
|
|
@@ -242,5 +242,4 @@
|
|
// Convenience macros for assembling and disassembling a compiled operation.
|
|
//
|
|
-#define URX_BUILD(type, val) (int32_t)((type << 24) | (val))
|
|
#define URX_TYPE(x) ((uint32_t)(x) >> 24)
|
|
#define URX_VAL(x) ((x) & 0xffffff)
|
|
Index: /icu/trunk/source/test/intltest/regextst.cpp
|
|
===================================================================
|
|
--- /icu/trunk/source/test/intltest/regextst.cpp (revision 36800)
|
|
+++ /icu/trunk/source/test/intltest/regextst.cpp (revision 36801)
|
|
@@ -145,4 +145,7 @@
|
|
if (exec) TestBug11049();
|
|
break;
|
|
+ case 25: name = "TestBug11371";
|
|
+ if (exec) TestBug11371();
|
|
+ break;
|
|
default: name = "";
|
|
break; //needed to end loop
|
|
@@ -5368,4 +5371,47 @@
|
|
|
|
|
|
+void RegexTest::TestBug11371() {
|
|
+ if (quick) {
|
|
+ logln("Skipping test. Runs in exhuastive mode only.");
|
|
+ return;
|
|
+ }
|
|
+ UErrorCode status = U_ZERO_ERROR;
|
|
+ UnicodeString patternString;
|
|
+
|
|
+ for (int i=0; i<8000000; i++) {
|
|
+ patternString.append(UnicodeString("()"));
|
|
+ }
|
|
+ LocalPointer<RegexPattern> compiledPat(RegexPattern::compile(patternString, 0, status));
|
|
+ if (status != U_REGEX_PATTERN_TOO_BIG) {
|
|
+ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
|
|
+ __FILE__, __LINE__, u_errorName(status));
|
|
+ }
|
|
+
|
|
+ status = U_ZERO_ERROR;
|
|
+ patternString = "(";
|
|
+ for (int i=0; i<20000000; i++) {
|
|
+ patternString.append(UnicodeString("A++"));
|
|
+ }
|
|
+ patternString.append(UnicodeString("){0}B++"));
|
|
+ LocalPointer<RegexPattern> compiledPat2(RegexPattern::compile(patternString, 0, status));
|
|
+ if (status != U_REGEX_PATTERN_TOO_BIG) {
|
|
+ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
|
|
+ __FILE__, __LINE__, u_errorName(status));
|
|
+ }
|
|
+
|
|
+ // Pattern with too much string data, such that string indexes overflow operand data field size
|
|
+ // in compiled instruction.
|
|
+ status = U_ZERO_ERROR;
|
|
+ patternString = "";
|
|
+ while (patternString.length() < 0x00ffffff) {
|
|
+ patternString.append(UnicodeString("stuff and things dont you know, these are a few of my favorite strings\n"));
|
|
+ }
|
|
+ patternString.append(UnicodeString("X? trailing string"));
|
|
+ LocalPointer<RegexPattern> compiledPat3(RegexPattern::compile(patternString, 0, status));
|
|
+ if (status != U_REGEX_PATTERN_TOO_BIG) {
|
|
+ errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
|
|
+ __FILE__, __LINE__, u_errorName(status));
|
|
+ }
|
|
+}
|
|
|
|
#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
|
|
Index: /icu/trunk/source/test/intltest/regextst.h
|
|
===================================================================
|
|
--- /icu/trunk/source/test/intltest/regextst.h (revision 36800)
|
|
+++ /icu/trunk/source/test/intltest/regextst.h (revision 36801)
|
|
@@ -51,4 +51,5 @@
|
|
virtual void TestCaseInsensitiveStarters();
|
|
virtual void TestBug11049();
|
|
+ virtual void TestBug11371();
|
|
|
|
// The following functions are internal to the regexp tests.
|