This reverts commit dc6efdab29. This
patch completely regressed performance for regexes in the same class
as the regexes it fixed. Xamarin bug #6198 details the regressions,
and I've confirmed that reverting this commit fixes the 2 order of
magnitude performance drop (with the patch, the test takes almost 7
seconds, without it, it takes .07 seconds). The bug still needs to be
fixed, but this is not the right fix.
What this fixes:
IF you were checking a regex which contained something like "(A|AB)C" and then you
checked something like "ABC" against it, it would fail previously, because its
first trip thru the regex it would match "A" first and short circuit out of the
"or" (|) then next try to match "C" but find "B" and fail. In this case, it should
be obvious that it needs to, after it fails, go back and try "AB" rather than "A"
and that's where this patch comes in.
Brief summary of each change in order that "git diff --staged" is giving them to
me:
This first one summarizes the background of goal of project:
New Function: EmitJumpTest
For when we are evaluating Alternatives (or's) we now want to be able to go back
and try or paths we haven't already tried if and only if we fail. This alternate to
EmitJump instead of jumping to target if we have a match immediately, will
on first attempt do the jump, but later if we have already tried this jump
combination, it will jump to ElseTarget, which is the equivalent of this test
failing on subsequent attempts with the same combination of 'or's passing.
RxCompiler:
EmitJumpTest isn't implemented for RxCompiler because i didn't have sample
code to test it on, so it falls back to a regular jump, nothing changes in
RxCompiler in other words other than having this required fucntion front.
arch.cs:
New OpCode added for JumpTest (see EmitJumpTest above)
compiler.cs:
EmitJumpTest added here for regular compiler, it now takes two arguments (two
items on stack) first was the standard where to jump to address, the second
argument is where to jump to in case where we have already tried this
combination)
interpreter.cs:
JumpTestEntry - What we keep track of to know if we've been here before, for
now i presumed just 'pc' (program counter') and 'ptr' (pointer - where we are)
were enough to tell us if we've been to this particular spot before.
Eval has been moved into Eval_Real
Eval if it gets called with parameters indicating we've already been here
(i.e we're being called recursively) just passes the call directly to eval_real
as-was.
Otherwise eval will loop on eval_real while we fail and haven't tried every
possible path through all the or's. (Note: The special case of where we're
running a 'test' (i.e. checking !(a|b|c) rather than just matching (a|b|c)),
and if we're running a test, we turn off JumpTestTracking while it's in its
recursive section. The reason for this is because while we can rightly check
all the options of (a|ab|abc) first for a then try again with ab then try again
with abc, we cannot do the same for a not (i.e. !(something or something else)
is really (not something AND not somtehing else), and it is not (not something
or not something else))
JumpTestList tracks our current run's JumpTest calls...
TriedCombo's tracks all the combos (all the JumpTestList results) that we've
already tried.
All calls to anything which calls Eval were modified to call eval passing
the optional new parameters that we now need, and remember if we call
eval with those parameters having a value, it will just forward the call
to Eval_Real.
This included modifying TryMatch because it calls Eval.
OpCode.JumpTest handler was added, what it does is first check if we need
to ByPass to jump to 'else' right away, which again happens when we're in
a test recursive call (Checking not, for example).
Next, it will create and populate a new JumpTestEntry with the current values.
It then calls CheckComboMatch() which sees if we match a combo already on file.
If we don't have a Match we jump to the first label (at pc+1) which is the
regular jump call. If we have a match, though, it will jump to the else label
which is now at (pc+2).
CheckComboMatch had to be broken up into two functions because it was going
too deep in terms of nesting. What it does by now should be somewhat understood
it will see if we have a match between our current run and previous runs, and
if we have a match, it returns true. If we don't have a match, it returns
false. I have some doubts about whether this function is 100% correct, there
may remain a bug or two, but it does pass all the "System" unit tests which
includes all the regular expression tests, plus it works for all the tests
in the bug report, so i have little reason to mess with it.
syntax.cs:
Here's where i modified so that when evaluating alternatives ("or"s or "|"s)
we instead call EmitJumpTest rather than just a regular EmitJump.
RegExBugs.cs:
This is the unit test (a bunch in one) which fails on mono without this patch
but succeeds with it
commit 48027ac2bdd9b60d18985ec2537eb188607f8164 1 parent 91c4180d55
This patch was originally submitted under another branch which had a bunch of
unrelated commits in it. I'm hoping if i did this right, these changes stand
alone.
* parser.cs (ParseEscape): Now parses with some context, whether
we are parsing inside a character range which can not contain
back-references or when we are parsing on a string context which
can contain back references.
This fixes bug #577346 which exposed a bug parsing this:
new Regex("[\\177-\\377]")
svn path=/trunk/mcs/; revision=160626
* parser.cs (gap): New.
(GetMapping): Return it.
(ResolveReferences): Collect explicit numeric groups which may not
match their indices.
(HandleExplicitNumericGroups): New. Process the above list to
assign appropriate indices, and compute the correct value of 'gap'.
svn path=/trunk/mcs/; revision=140290
* System.Text.RegularExpressions/parser.cs (ResolveReferences):
Allow named groups to be referred-to by their group numbers too.
* RegexMatchTests.cs (RegexTrial0053): New.
svn path=/trunk/mcs/; revision=139655
evaluator are not null, as documented in MSDN (and the variance found
while testing DbLinq).
* Test/System.Text.RegularExpressions/RegexReplace.cs: Add null
argument checks for Regex.Replace().
svn path=/trunk/mcs/; revision=128241
In System/System.Text.RegularExpressions:
* BaseMachine.cs (LTRReplace): Don't use non-advancement of 'ptr'
to deduce absence of matches -- a match can have length 0.
(RTLReplace): Likewise.
In System/Test/System.Text.RegularExpressions:
* RegexReplace.cs (tests): New test from #324390.
svn path=/trunk/mcs/; revision=89176
In b/class/System/System.Text.RegularExpressions:
* BaseMachine.cs (Replace): Use either LTRReplace or RTLReplace
based on regex.
(LTRReplace): Make internal and rename the MatchAppendEvaluator
version of Replace to this.
(RTLReplace): New.
* Regex.cs (Replace): Use LTRReplace and RTLReplace from BaseMachine.
* replace.cs (ReplacementEvaluator.Evaluate): Optimize simple case.
Based on patch by Stephane Delcroix.
In b/class/System/Test/System.Text.RegularExpressions:
* MatchTest.cs (Match_Backref): New.
* RegexReplace.cs (direction, testcase.direction): New.
(testcase..ctor): Allow specifying the direction of the replace.
(ReplaceTests): Test replace in both directions.
(EvaluatorTests): New test based on #321036.
svn path=/trunk/mcs/; revision=89034
* replace.cs (Compile): Don't unescape string.
In Test/System.Text.RegularExpressions:
* RegexReplace.cs (tests): New test from #317092.
(ReplaceTests): Don't catch an AssertException.
svn path=/trunk/mcs/; revision=89021
* MatchTest.cs: Improved tests for null argument checks. Added and
fixed replacement tests.
* RegexMatchTest.cs: Marked tests that do not pass on MS as NotDotNet.
Fixed expected result for trial 5.
* RegexResultTests.cs: Fixed Assert.
* Match.cs: Do not throw NotSupportedException on zero-length
replacement argument.
svn path=/trunk/mcs/; revision=88685
Fix#80554
* parser.cs (ResolveReferences): Don't throw an expression if a
capture assertion reference cannot be resolved.
(ParseGroupingConstruct): Provide fallback expression to a capture
assertion.
* syntax.cs (CaptureAssertion): If the bareword doesn't refer to
the name of a capture group, fallback to treating it as a literal
expression.
In Test/System.Text.RegularExpressions:
* RegexBugs.cs (bug80554_trials): New tests based on #80554.
svn path=/trunk/mcs/; revision=75885
Fix#79472
* parser.cs (Parser.GetMapping): Use the actual group numbers to
build the mapping.
In Test/System.Text.RegularExpressions:
* RegexBugs.cs (GroupNumbers): New test based on #79472.
svn path=/trunk/mcs/; revision=70374
Fix#78278
Remove 65535-limit on number of repetitions matched by a pattern.
We still have a 65535 limit on the length of a pattern and the
number of groups in a pattern.
* compiler.cs (PatternCompiler.EmitCount): New. Emits an int as
two ushorts into the program stream.
(EmitInfo, EmitRepeat, EmitFastRepeat): Use it to emit integers
rather than shorts.
* interpreter.cs (Intepreter.ReadProgramCount): Read an int
emitted into the program stream.
(Interpreter): Use it. Update counts.
(Interpreter.Eval) [OpCode.Repeat, OpCode.FastRepeat]: Likewise.
* parser.cs (ParseGroup): Pass 0x7ffffff as the max value for '*'
and '+' repetition patterns.
* arch.cs (Info, Repeat, FastRepeat): Update description.
In Test/System.Text.RegularExpressions:
* RegexBugs.cs (Kill65535_1, Kill65535_2, No65535Limit): New tests
based on #78278.
svn path=/trunk/mcs/; revision=60401
2006-04-17 Florian Gross <[email protected]>
Raja R Harinath <[email protected]>
* syntax.cs (CharacterClass.Compile): Emit categories after the
character intervals so that the evaluator can pick up the
'IgnoreCase' flag.
In Test/System.Text.RegularExpressions:
2006-04-17 Florian Gross <[email protected]>
* RegexBugs.cs (CharClassWithIgnoreCase): Ensure that character
classes don't interfere with RegexOptions.IgnoreCase.
Started looking at some of Florian's patches, which I realized now that
he hadn't applied.
svn path=/trunk/mcs/; revision=59538
Fix#78007
* interpreter.cs (Interpreter.Eval) [Anchor, Position.StartOfString]:
Don't reset 'ptr' to 0 during forward scan.
In Test/System.Text.RegularExpressions:
* RegexBugs.cs (Bug78007): New test from #78007.
svn path=/trunk/mcs/; revision=59177
Fix#76345
* interpreter.cs (Interpreter.FastEval) [FastRepeat]: If the first
tail operation has a 'negate' flag, avoid the "match next char"
optimization.
In Test/System.Text.RegularExpressions:
* RegexBugs.cs (Bug76345): New test from #76345.
svn path=/trunk/mcs/; revision=59174