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);
}
