static void ExecTest(Context context, IMatch testToken) { var token = new CaptureGroup(testToken); if (token.Match(context)) { WriteInfo("Match success."); WriteLine(context); while (token.MatchNext(context)) { WriteInfo("MatchNext success."); WriteLine(context); } WriteError("MatchNext failed."); WriteLine(context); } else { WriteError("Match failed."); WriteLine(context); } if (context.offset != 0) { WriteError("Warning: Context offset not reset to 0."); } }
public void InstructionWithOneStackArgumentShouldResultInAssignmentAndExpressionStatementWithArgument() { var cfg = ConstructAst(new[] { DummyInstruction.Push(0, 1), DummyInstruction.Pop(1, 1), DummyInstruction.Ret(2) }); var variableCapture = new CaptureGroup("variable"); var pattern = new SequencePattern <Statement <DummyInstruction> >( // stack_slot = push 1() StatementPattern .Assignment <DummyInstruction>() .WithExpression(ExpressionPattern.Instruction(new DummyInstructionPattern(DummyOpCode.Push))) .CaptureVariables(variableCapture), // pop(stack_slot) StatementPattern.Expression(ExpressionPattern .Instruction(new DummyInstructionPattern(DummyOpCode.Pop)) .WithArguments(ExpressionPattern .Variable <DummyInstruction>() .CaptureVariable(variableCapture))), // ret() StatementPattern.Instruction(new DummyInstructionPattern(DummyOpCode.Ret)) ); var result = pattern.Match(cfg.Nodes[0].Contents.Instructions); Assert.True(result.IsSuccess); Assert.Single(result.Captures[variableCapture].Distinct()); }
public void TestComplexCapture() { var valueExpression = new InstructionExpression <DummyInstruction>(DummyInstruction.Push(0, 1), ArraySegment <Expression <DummyInstruction> > .Empty); var statement = new ExpressionStatement <DummyInstruction>(new InstructionExpression <DummyInstruction>(DummyInstruction.Ret(1), new List <Expression <DummyInstruction> > { valueExpression })); // Define capture group. var returnValueGroup = new CaptureGroup("returnValue"); // Create ret(?) pattern. var pattern = StatementPattern.Expression( ExpressionPattern .Instruction(new DummyInstructionPattern(DummyOpCode.Ret)) .WithArguments( ExpressionPattern.Any <DummyInstruction>().CaptureAs(returnValueGroup) ) ); // Match. var result = pattern.Match(statement); // Extract return expression node. var capturedObject = result.Captures[returnValueGroup][0]; Assert.Same(valueExpression, capturedObject); }
protected override void Build() { base.Build(); var simpleIdentifier = new Pattern("simpleIdentifier") { Data = identifier.Data }; var identifierOrInline = new Pattern("identifierOrInline") { Data = new PrioritizedChoice(identifier, new CaptureGroup((int)ExtendedCaptureKeys.InlinePattern, new Sequence( "\\(", spacing, internalExpression, ')' ) ) ) }; // Prevent 'export' from being seen as a non-terminal // This effectively reserves export as a global keyword prefix.Data = new Sequence(new Not(CharacterClass.String("export")), prefix.Data); var parameterizedIdentifier = BuildParameterizedIdentifier(simpleIdentifier, identifierOrInline); var parameterizedIdentifierDeclaration = BuildParameterizedIdentifier(simpleIdentifier, new CaptureGroup((int)ExtendedCaptureKeys.PatternParameterReference, simpleIdentifier)); var complexIdentifier = new Pattern("complexIdentifier") { Data = new PrioritizedChoice(parameterizedIdentifier, simpleIdentifier) }; var namespacedIdentifier = new Pattern("namespacedIdentifier"); namespacedIdentifier.Data = new PrioritizedChoice( new CaptureGroup((int)ExtendedCaptureKeys.Namespace, new Sequence(simpleIdentifier, "::", namespacedIdentifier) ), complexIdentifier ); identifier.Data = namespacedIdentifier; var possibleDeclarationIdentifiers = new PrioritizedChoice(parameterizedIdentifierDeclaration, simpleIdentifier); identifierDeclaration.Data = new PrioritizedChoice( new CaptureGroup((int)ExtendedCaptureKeys.Export, new Sequence("export", spacing, possibleDeclarationIdentifiers) ), possibleDeclarationIdentifiers ); var number = Operator.OneOrMore(new CharacterClass(new CharacterRange('0', '9'))); var fixedRepeat = new CaptureGroup((int)ExtendedCaptureKeys.FixedRepeat, new Sequence(primary, '^', number, Operator.Optional(new Sequence("..", number)))); suffix.Data = new PrioritizedChoice(new Sequence(fixedRepeat, spacing), suffix.Data); }
internal void Add(CaptureGroup g, ILInstruction n) { if (results == null) { results = new List <KeyValuePair <CaptureGroup, ILInstruction> >(); } results.Add(new KeyValuePair <CaptureGroup, ILInstruction>(g, n)); }
public void JoiningControlFlowPathsWithDifferentVariableVersionsShouldResultInPhiNode() { var variable = new DummyVariable("temp"); var cfg = ConstructAst(new[] { DummyInstruction.Push(0, 1), DummyInstruction.JmpCond(1, 5), DummyInstruction.Push(2, 1), DummyInstruction.Set(3, variable), DummyInstruction.Jmp(4, 7), DummyInstruction.Push(5, 1), DummyInstruction.Set(6, variable), DummyInstruction.Get(7, variable), DummyInstruction.Pop(8, 1), DummyInstruction.Ret(9) }); var phiSourcesCapture = new CaptureGroup("sources"); var variablesCapture = new CaptureGroup("variables"); // temp_vx = set(?) var assignPattern = StatementPattern .Assignment <DummyInstruction>() .WithExpression(ExpressionPattern .Instruction(new DummyInstructionPattern(DummyOpCode.Set)) .WithArguments(1)) .CaptureVariables(variablesCapture); // variable = phi(?, ?) var phiPattern = StatementPattern .Phi <DummyInstruction>() .WithSources(2) .CaptureSources(phiSourcesCapture); var set1Result = assignPattern.FindFirstMatch(cfg.Nodes[2].Contents.Instructions); var set2Result = assignPattern.FindFirstMatch(cfg.Nodes[5].Contents.Instructions); var phiResult = phiPattern.Match(cfg.Nodes[7].Contents.Header); Assert.True(set1Result.IsSuccess, "Node 2 was expected to contain an assignment statement."); Assert.True(set2Result.IsSuccess, "Node 5 was expected to contain an assignment statement."); Assert.True(phiResult.IsSuccess, "Node 7 was expected to start with a phi statement."); var sources = phiResult.Captures[phiSourcesCapture] .Cast <VariableExpression <DummyInstruction> >() .Select(s => s.Variable); var allVariables = new[] { (IVariable)set1Result.Captures[variablesCapture][0], (IVariable)set2Result.Captures[variablesCapture][0] }; Assert.Equal(allVariables.ToHashSet(), sources.ToHashSet()); }
public static void CaptureGroupPreformCapture(MenuCommand command) { WeaverSettingsEditor[] inspectors = Resources.FindObjectsOfTypeAll <WeaverSettingsEditor>(); CaptureGroup.CapturePadding = new RectOffset(4, 4, 4, 4); if (inspectors.Length > 0) { CaptureGroup.PreformCapture(inspectors[0]); } }
public void CaptureGroup_NoName() { var regex = RegularExpression.Of( CaptureGroup.Of( Literal.For("A") ) ).ToRegex(); Assert.AreEqual("(A)", regex.ToString()); }
public void Backreference_Number() { var regex = RegularExpression.Of( CaptureGroup.Of(Quantifiers.OneOrMore(Literal.For("a"))), Quantifiers.ZeroOrMore(Literal.For("b")), Backreference.For(1) ).ToRegex(); Assert.AreEqual(@"(a+)b*\1", regex.ToString()); }
public IEnumerable<ILInstruction> Get(CaptureGroup captureGroup) { if (results != null) { foreach (var pair in results) { if (pair.Key == captureGroup) yield return pair.Value; } } }
public void BalancedGroup_AngleBrackets() { var regex = RegularExpression.Of( CaptureGroup.Of(new CaptureGroupOptions() { Name = "Open" }, Literal.For("<")), BalancedGroup.Of("Close", "Open", Literal.For(">")) ).ToRegex(); Assert.AreEqual("(?<Open><)(?<Close-Open>>)", regex.ToString()); }
public void Alternation_ByCapture() { var regex = RegularExpression.Of( CaptureGroup.Of(new CaptureGroupOptions() { Name = "A" }, Quantifiers.OneOrMore(Literal.For("A"))), ConditionalAlternation.For(Literal.For("A"), Literal.For("Abc"), Literal.For("Xyz")) ).ToRegex(); Assert.AreEqual("(?<A>A+)(?(A)Abc|Xyz)", regex.ToString()); }
public static void test_backref() { var context = new Context("aaaaab"); var chara = new Character('a'); var lazya = new Lazy(chara, 1); var cap1 = new CaptureGroup(lazya, 1); var back1 = new Backreference(cap1); var list = new List(new IMatch[] { cap1, back1 }); // ((a+?)\1) ExecTest(context, list); }
public static void test_possessive() { var context = new Context("aaaab"); var chara = new Character('a'); var charb = new Character('b'); var alt = new CaptureGroup(new Alternate(new IMatch[] { chara, charb }), 2); var posa = new Possessive(alt, 2); var list = new List(new IMatch[] { new CaptureGroup(posa, 1), alt }); // (((a|b){2,}+)(a|b)) ExecTest(context, list); }
public void PushingTwoValuesOnStackWithDifferentConsumers() { var cfg = ConstructAst(new[] { DummyInstruction.Push(0, 2), DummyInstruction.Pop(1, 1), DummyInstruction.Pop(2, 1), DummyInstruction.Ret(3) }); var variableCapture = new CaptureGroup("variable"); var argumentsCapture1 = new CaptureGroup("argument1"); var argumentsCapture2 = new CaptureGroup("argument2"); var pattern = new SequencePattern <Statement <DummyInstruction> >( // stack_slot_1, stack_slot_2 = push 2() StatementPattern .Assignment <DummyInstruction>() .WithVariables(2) .CaptureVariables(variableCapture), // pop(?) StatementPattern.Expression(ExpressionPattern .Instruction <DummyInstruction>() .WithArguments(1) .CaptureArguments(argumentsCapture1)), // pop(?) StatementPattern.Expression(ExpressionPattern .Instruction <DummyInstruction>() .WithArguments(1) .CaptureArguments(argumentsCapture2)), // ret() StatementPattern.Instruction(new DummyInstructionPattern(DummyOpCode.Ret)) ); var result = pattern.Match(cfg.Nodes[0].Contents.Instructions); Assert.True(result.IsSuccess); var variables = result.Captures[variableCapture] .Cast <IVariable>() .ToArray(); var argument1 = (VariableExpression <DummyInstruction>)result.Captures[argumentsCapture1][0]; var argument2 = (VariableExpression <DummyInstruction>)result.Captures[argumentsCapture2][0]; // Note: we expect the first pop statement to use the second variable that was pushed by the push instruction. Assert.Equal(variables[1], argument1.Variable); Assert.Equal(variables[0], argument2.Variable); }
public void Backreference_Name() { var regex = RegularExpression.Of( CaptureGroup.Of(new CaptureGroupOptions() { Name = "a" }, Quantifiers.OneOrMore(Literal.For("a"))), Quantifiers.ZeroOrMore(Literal.For("b")), Backreference.For("a") ).ToRegex(); Assert.AreEqual(@"(?<a>a+)b*\k<a>", regex.ToString()); }
public void Backreference_Name_WithQuotes() { var regex = RegularExpression.Of( CaptureGroup.Of(new CaptureGroupOptions() { Name = "a", UseQuotes = true }, Quantifiers.OneOrMore(Literal.For("a"))), Quantifiers.ZeroOrMore(Literal.For("b")), Backreference.For("a", true) ).ToRegex(); Assert.AreEqual(@"(?'a'a+)b*\k'a'", regex.ToString()); }
public void CaptureGroup_Name_WithQuotes() { var regex = RegularExpression.Of( CaptureGroup.Of( new CaptureGroupOptions() { Name = "A", UseQuotes = true }, Literal.For("A") ) ).ToRegex(); Assert.AreEqual("(?'A'A)", regex.ToString()); }
public void CaptureGroup_Name() { var regex = RegularExpression.Of( CaptureGroup.Of( new CaptureGroupOptions() { Name = "A" }, Literal.For("A") ) ).ToRegex(); Assert.AreEqual("(?<A>A)", regex.ToString()); }
public static void test_greedyaltcapture() { var context = new Context("aaaaa"); var chara = new Character('a'); var list2a = new List(new IMatch[] { chara, chara }); var grp1 = new CaptureGroup(chara, 1); var grp2 = new CaptureGroup(list2a, 2); var alt = new Alternate(new IMatch[] { grp1, grp2 }); var greedy = new Greedy(alt, 1, 2); // ((a)|(aa)){1,2} ExecTest(context, greedy); }
public void JoiningControlFlowPathsWithPositiveStackDeltaShouldResultInPhiNode() { var cfg = ConstructAst(new[] { DummyInstruction.Push(0, 1), DummyInstruction.JmpCond(1, 4), DummyInstruction.Push(2, 1), DummyInstruction.Jmp(3, 5), DummyInstruction.Push(4, 1), DummyInstruction.Pop(5, 1), DummyInstruction.Ret(6) }); var phiSourcesCapture = new CaptureGroup("sources"); var variablesCapture = new CaptureGroup("variables"); // stack_slot = push 1() var assignPattern = StatementPattern .Assignment <DummyInstruction>() .CaptureVariables(variablesCapture); // variable = phi(?, ?) var phiPattern = StatementPattern .Phi <DummyInstruction>() .WithSources(2) .CaptureSources(phiSourcesCapture); var push1Result = assignPattern.Match(cfg.Nodes[2].Contents.Header); var push2Result = assignPattern.Match(cfg.Nodes[4].Contents.Header); var phiResult = phiPattern.Match(cfg.Nodes[5].Contents.Header); Assert.True(push1Result.IsSuccess, "Node 2 was expected to start with an assignment statement."); Assert.True(push2Result.IsSuccess, "Node 4 was expected to start with an assignment statement."); Assert.True(phiResult.IsSuccess, "Node 5 was expected to start with a phi statement."); var sources = phiResult.Captures[phiSourcesCapture] .Cast <VariableExpression <DummyInstruction> >() .Select(s => s.Variable); var allVariables = new[] { (IVariable)push1Result.Captures[variablesCapture][0], (IVariable)push2Result.Captures[variablesCapture][0] }; Assert.Equal(allVariables.ToHashSet(), sources.ToHashSet()); }
public void BalancedGroup_WithQuotes() { var regex = RegularExpression.Of( CaptureGroup.Of(new CaptureGroupOptions() { Name = "Open", UseQuotes = true }, Literal.For("<")), BalancedGroup.Of("Close", "Open", new BalanceGroupOptions() { UseQuotes = true }, Literal.For(">")) ).ToRegex(); Assert.AreEqual("(?'Open'<)(?'Close-Open'>)", regex.ToString()); }
public void PushingTwoValuesOnStackShouldResultInTwoVariablesAssigned() { var cfg = ConstructAst(new[] { DummyInstruction.Push(0, 2), DummyInstruction.Pop(1, 2), DummyInstruction.Ret(2) }); var variableCapture = new CaptureGroup("variable"); var argumentsCapture = new CaptureGroup("argument"); var pattern = new SequencePattern <Statement <DummyInstruction> >( // stack_slot_1, stack_slot_2 = push 2() StatementPattern .Assignment <DummyInstruction>() .WithVariables(2) .CaptureVariables(variableCapture), // pop(?, ?) StatementPattern.Expression(ExpressionPattern .Instruction <DummyInstruction>() .WithArguments(2) .CaptureArguments(argumentsCapture)), // ret() StatementPattern.Instruction(new DummyInstructionPattern(DummyOpCode.Ret)) ); var result = pattern.Match(cfg.Nodes[0].Contents.Instructions); Assert.True(result.IsSuccess); var variables = result.Captures[variableCapture] .Cast <IVariable>() .ToArray(); var arguments = result.Captures[argumentsCapture] .Cast <VariableExpression <DummyInstruction> >() .Select(e => e.Variable) .ToArray(); Assert.Equal(variables, arguments); }
public void SpecificVariable() { var group = new CaptureGroup("group"); var statement = new AssignmentStatement <int>(new IVariable[] { new AstVariable("var1"), }, new InstructionExpression <int>(1, ArraySegment <Expression <int> > .Empty)); var pattern = StatementPattern .Assignment <int>() .WithVariables(Pattern.Any <IVariable>().CaptureAs(group)); var result = pattern.Match(statement); Assert.True(result.IsSuccess); Assert.Contains(group, result.Captures); Assert.Contains(statement.Variables[0], result.Captures[group]); }
private void OnGUI() { CaptureGroup.Begin(GetSavePath("FullWindow")); { CaptureGroup.Begin(GetSavePath("Toolbar")); { DrawToolbar(); } CaptureGroup.End(); CaptureGroup.Begin(GetSavePath("Grid")); { Rect gridRect = GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth, 50f, GUILayout.ExpandHeight(true)); _styleGrid.DoLayout(gridRect); } CaptureGroup.End(); } CaptureGroup.End(); }
public void AnyPhiWithSpecificTargetPattern() { var group = new CaptureGroup("phiGroup"); var statement = new PhiStatement <int>(new AstVariable("phi1"), new List <VariableExpression <int> > { new VariableExpression <int>(new AstVariable("v1")), new VariableExpression <int>(new AstVariable("v2")), new VariableExpression <int>(new AstVariable("v3")), new VariableExpression <int>(new AstVariable("v4")), }); var pattern = StatementPattern.Phi <int>() .WithTarget(Pattern.Any <IVariable>().CaptureAs(group)); var result = pattern.Match(statement); Assert.True(result.IsSuccess); Assert.Contains(group, result.Captures); Assert.Contains(statement.Target, result.Captures[group]); }
public AnyNode(CaptureGroup group = null) : base(OpCode.AnyNode) { this.group = group; }
public void JoiningPathsWithMultipleAssignmentsShouldOnlyUseLatestVersion() { var variable = new DummyVariable("temp"); var cfg = ConstructAst(new[] { // if (cond) goto else: DummyInstruction.Push(0, 1), DummyInstruction.JmpCond(1, 7), // temp = some_value (not used). DummyInstruction.Push(2, 1), DummyInstruction.Set(3, variable), // temp = some_value (render previous value useless) DummyInstruction.Push(4, 1), DummyInstruction.Set(5, variable), // goto end DummyInstruction.Jmp(6, 9), // else: // temp = some_value DummyInstruction.Push(7, 1), DummyInstruction.Set(8, variable), // end: // pop(temp) DummyInstruction.Get(9, variable), DummyInstruction.Pop(10, 1), // return DummyInstruction.Ret(11) }); var phiSourcesCapture = new CaptureGroup("sources"); var variablesCapture = new CaptureGroup("variables"); // variable = phi(?, ?) var phiPattern = StatementPattern .Phi <DummyInstruction>() .WithSources(2) .CaptureSources(phiSourcesCapture); // temp_vx = set(?) var assignPattern = StatementPattern .Assignment <DummyInstruction>() .WithExpression(ExpressionPattern .Instruction(new DummyInstructionPattern(DummyOpCode.Set)) .WithArguments(1)) .CaptureVariables(variablesCapture); var assignment1Results = assignPattern .FindAllMatches(cfg.Nodes[7].Contents.Instructions) .ToArray(); var assignment2Results = assignPattern .FindAllMatches(cfg.Nodes[2].Contents.Instructions) .ToArray(); var phiResult = phiPattern.Match(cfg.Nodes[9].Contents.Header); Assert.True(assignment1Results.Length == 1, "Node 7 was expected to have one assignment to 'temp'."); Assert.True(assignment2Results.Length == 2, "Node 2 was expected to have two assignments to 'temp'."); Assert.True(phiResult.IsSuccess, "Node 9 was expected to start with a phi node with two sources."); var sources = phiResult.Captures[phiSourcesCapture] .Cast <VariableExpression <DummyInstruction> >() .Select(s => s.Variable); var allVariables = new[] { (IVariable)assignment1Results[0].Captures[variablesCapture][0], (IVariable)assignment2Results[1].Captures[variablesCapture][0] }; Assert.Equal(allVariables.ToHashSet(), sources.ToHashSet()); }
private void PreformCaputre() { position = new Rect(50, 50, 700, 400); CaptureGroup.PreformCapture(this); }
public RegexGrammar(PatternCompiler patternCompiler) { var RE = new Pattern("RE"); var simpleRE = new Pattern("SimpleRE"); var metaCharacter = new Pattern("metaCharacter") { Data = new PrioritizedChoice( new CharacterClass('*', '+', '^', '$', '|', '(', ')', '[', ']'), new Sequence(new CharacterClass('\\'), new CharacterClass('t', 'n', 'r', 'f', 'b', 'B', 'd', 'D', 's', 'S', 'w', 'W', 'Q', 'U', 'L')), CharacterClass.String(@"*?"), CharacterClass.String(@"+?"), CharacterClass.String(@"$`"), CharacterClass.String(@"$'"), CharacterClass.String(@"$&"), CharacterClass.String(@"\cX"), new Sequence(new CharacterClass('\\', '$'), CharacterClass.Range('0', '9')), new Sequence(new CharacterClass('\\'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7')) ) }; var allowedMetaCharacters = new Pattern("allowedMetaCharacter") { Data = new CaptureGroup((int)CaptureType.MetaCharacter, new PrioritizedChoice( new Sequence(new CharacterClass('\\'), new CharacterClass('t', 'n', 'r', 'f', 'b', 'B', 'd', 'D', 's', 'S', 'w', 'W', 'Q', 'U', 'L')), CharacterClass.String(@"*?"), CharacterClass.String(@"+?"), CharacterClass.String(@"$`"), CharacterClass.String(@"$'"), CharacterClass.String(@"$&"), CharacterClass.String(@"\cX"), new Sequence(new CharacterClass('\\', '$'), CharacterClass.Range('0', '9')), new Sequence(new CharacterClass('\\'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7')) ) ) }; var character = new Pattern("character") { Data = new CaptureGroup((int)CaptureType.Char, new PrioritizedChoice( new Sequence( new CharacterClass('\\'), metaCharacter ), new Sequence( new Not(metaCharacter), new Any() ) ) ) }; var range = new CaptureGroup((int)CaptureType.Range, new Sequence(character, new CharacterClass('-'), character)); var setItem = new PrioritizedChoice(range, character); var setItems = new Pattern() { Data = Operator.OneOrMore(setItem) }; var positiveSet = new CaptureGroup((int)CaptureType.PositiveSet, new Sequence(new CharacterClass('['), setItems, new CharacterClass(']'))); var negativeSet = new CaptureGroup((int)CaptureType.NegativeSet, new Sequence(CharacterClass.String("[^"), setItems, new CharacterClass(']'))); var set = new Pattern("set") { Data = new PrioritizedChoice(negativeSet, positiveSet) }; var eos = new CaptureGroup((int)CaptureType.Eos, new CharacterClass('$')); var any = new CaptureGroup((int)CaptureType.Any, new CharacterClass('.')); var group = new Sequence(new CharacterClass('('), RE, new CharacterClass(')')); var elementaryRE = new Pattern("elementaryRE") { Data = new PrioritizedChoice(group, any, eos, set, character, allowedMetaCharacters) }; var number = Operator.OneOrMore(CharacterClass.Range('0', '9')); var repeatRange = new Sequence(new CharacterClass('{'), new CaptureGroup((int)CaptureType.RepeatRange, new Sequence(number, Operator.Optional(new Sequence(new CharacterClass(','), number)))), new CharacterClass('}')); var plus = new Pattern("plus") { Data = new CaptureGroup((int)CaptureType.Plus, new Sequence(elementaryRE, new CharacterClass('+'))) }; var star = new Pattern("star") { Data = new CaptureGroup((int)CaptureType.Star, new Sequence(elementaryRE, new CharacterClass('*'))) }; var repeat = new Pattern("repeat") { Data = new CaptureGroup((int)CaptureType.Repeat, new Sequence(elementaryRE, repeatRange)) }; var basicRE = new PrioritizedChoice(star, plus, repeat, elementaryRE); simpleRE.Data = new CaptureGroup((int)CaptureType.Concatenation, Operator.OneOrMore(basicRE)); RE.Data = new CaptureGroup((int)CaptureType.Union, new Sequence(simpleRE, new ZeroOrMore(new Sequence(new CharacterClass('|'), RE)))); Parser = patternCompiler.Compile(RE); }