public void TestNotEscaped()
{
var result = RegExParser.Parse("(\\(\\+\\))*");
var regEx = RegExFactory.Star(RegExFactory.Concat(RegExFactory.Range('(', (char)('(' + 1)), RegExFactory.Range('+', (char)('+' + 1)), RegExFactory.Range(')', (char)(')' + 1))));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestComplements()
{
var result = RegExParser.Parse("^(^a^b)");
var regEx = RegExFactory.Complement(RegExFactory.Concat(RegExFactory.Complement(RegExFactory.Range('a', 'b')), RegExFactory.Complement(RegExFactory.Range('b', 'c'))));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestAllAtOnce()
{
var result = RegExParser.Parse("(^(a|(b|c)*))[^:space:]");
var regEx = RegExFactory.Concat(RegExFactory.Complement(RegExFactory.Union(RegExFactory.Range('a', 'b'), RegExFactory.Star(RegExFactory.Union(RegExFactory.Range('b', 'c'), RegExFactory.Range('c', 'd'))))), RegExFactory.Intersection(RegExFactory.Range((char)0), RegExFactory.Complement(CharactersClasses.space)));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestStars()
{
var result = RegExParser.Parse("(a******b********)***");
var regEx = RegExFactory.Star(RegExFactory.Concat(RegExFactory.Star(RegExFactory.Range('a', 'b')), RegExFactory.Star(RegExFactory.Range('b', 'c'))));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestParentheses()
{
var result = RegExParser.Parse("((a(b))((a)((b))))");
var regEx = RegExFactory.Concat(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'), RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestIntersection()
{
var result = RegExParser.Parse("a&b&c");
var regEx = RegExFactory.Intersection(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'), RegExFactory.Range('c', 'd'));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public void TestNotAllowedCharacters()
{
var result = RegExParser.Parse("[^ab]");
var regEx = RegExFactory.Intersection(RegExFactory.Range((char)0), RegExFactory.Complement(RegExFactory.Union(RegExFactory.Range('a', 'b'), RegExFactory.Range('b', 'c'))));
Assert.AreEqual(result, RegExFactory.Intersection(regEx, RegExFactory.Star(CharactersClasses.print)));
}
public bool Matches(string expression)
{
if (DoCodeGeneration)
{
PrintLine("");
PrintLine($"accept{InstanceId}_{NumProcessedCases}:");
PrintLine(" pNext = pEnd;");
NumProcessedCases++;
return(true);
}
var parser = new RegExParser(expression, NamedExpressions);
var root = parser.Parse();
var accept = new RegExNodeAccept(root, NumAcceptCases);
if (Expression == null)
{
Expression = accept;
}
else
{
Expression = RegExNodeUnion.Of(Expression, accept);
}
++NumAcceptCases;
return(false);
}
public void EmptyGrammarTest()
{
var start = new CharSymbol('S');
var prodChar = RegExParser.Parse("$");
var prodSymbol = new StringProduction(start.C, prodChar);
var grammar = new Grammar <CharSymbol>(start, new Dictionary <CharSymbol, IProduction <CharSymbol>[]> {
{ start, new [] { prodSymbol } }
});
var parser = new LlParser <CharSymbol>(grammar);
var emptyInput = new List <ParseLeaf <CharSymbol> >();
var res = parser.Parse(emptyInput);
Assert.IsTrue(res);
var resAsBranch = ((OK <CharSymbol>)res).Tree as ParseBranch <CharSymbol>;
Assert.IsNotNull(resAsBranch);
Assert.AreEqual(resAsBranch.Children.Count(), 1);
Assert.AreEqual(resAsBranch.Symbol, start);
var resLeaf = resAsBranch.Children.ElementAt(0) as ParseLeaf <CharSymbol>;
Assert.IsNotNull(resLeaf);
Assert.AreEqual(resLeaf.Symbol, new CharSymbol('$'));
}
public void TestSyntaxError()
{
try {
RegExParser.Parse("((a)*)|*");
Assert.Fail();
} catch (ParseError) {
}
}
public void TestNotBalancedParenteses()
{
try {
RegExParser.Parse("(((a))");
Assert.Fail();
} catch (ParseError) {
}
}
static void TestRegExParser2()
{
var dict = new Dictionary <string, RegExNode> {
{ "name42", new RegExNodeName("+name42+") }
};
var parser = new RegExParser(@" name42 'ab'+'.'?[\[\]0-9]+ ~1| 'testing\'s'""more \""testing\"""" [0-5] ([a-f]~2|[0-34-9a-da-f]~3) ", dict);
var tree = parser.Parse();
Console.Write(tree);
}
public void LexerMainTest()
{
var lexer = new Nicodem.Lexer.Lexer(RegExParser.Parse("[:space:]*main[:space:]*\\(\\)[:space:]*"));
Assert.IsEmpty(lexer.Process("a"));
Assert.IsEmpty(lexer.Process("\tain()"));
Assert.IsTrue(lexer.Process("\rmain()").Tokens().SequenceEqual(new[] { "\rmain()" }));
Assert.IsTrue(lexer.Process("\tmain()\n\n\n\n\n").Tokens().SequenceEqual(new[] { "\tmain()\n\n\n\n\n" }));
Assert.IsTrue(lexer.Process(" main \n \r \t ()tttt").Tokens().SequenceEqual(new[] { " main \n \r \t ()" }));
Assert.IsTrue(lexer.Process("main()").Tokens().SequenceEqual(new[] { "main()" }));
}
public void Define(string name, string expression)
{
if (DoCodeGeneration)
{
return;
}
var parser = new RegExParser(expression, NamedExpressions);
var root = parser.Parse();
NamedExpressions[name] = root;
}
public void TestClasses()
{
var result1 = RegExParser.Parse("[:digit:]");
var regEx1 = CharactersClasses.digit;
Assert.AreEqual(result1, RegExFactory.Intersection(regEx1, RegExFactory.Star(CharactersClasses.print)));
var result2 = RegExParser.Parse("[:space:]");
var regEx2 = CharactersClasses.space;
Assert.AreEqual(result2, RegExFactory.Intersection(regEx2, RegExFactory.Star(CharactersClasses.print)));
}
static void TestRegExParser2Scanner()
{
var parser = new RegExParser(@" name42 'ab'+'.'?[\[\]0-9]+ ~1| 'testing\'s'""more \""testing\"""" [0-5] ([a-f]~2|[0-34-9a-da-f]~3) ");
while (true)
{
var token = parser.NextToken();
Console.WriteLine($"{token.Key},{token.Value}");
if (token.Key == RegExParser.Token.END)
{
break;
}
}
}
public void LexerWhiteSpaceTest()
{
//var lexer = new Nicodem.Lexer.Lexer(RegExFactory.Concat(MakeCharRegex(' '), RegExFactory.Star(MakeCharRegex(' '))));
var lexer = new Nicodem.Lexer.Lexer(RegExParser.Parse("[:space:]+"));
Assert.IsEmpty(lexer.Process("a "));
Assert.IsEmpty(lexer.Process("a"));
Assert.IsTrue(lexer.Process(" a").Tokens().SequenceEqual(new[] { " " }));
Assert.IsTrue(lexer.Process("\n\t").Tokens().SequenceEqual(new[] { "\n\t" }));
Assert.IsTrue(lexer.Process("\n").Tokens().SequenceEqual(new[] { "\n" }));
Assert.IsTrue(lexer.Process("\t").Tokens().SequenceEqual(new[] { "\t" }));
Assert.IsTrue(lexer.Process("\n ").Tokens().SequenceEqual(new[] { "\n " }));
Assert.IsTrue(lexer.Process("\t\r\n a b c").Tokens().SequenceEqual(new[] { "\t\r\n " }));
}
public ModuleMainForm()
{
InitializeComponent();
try
{
// set property windows
regExPropertys = new PropertiesToolsWindows("Options");
regExPropertys.AddProperty(RegexOptions.IgnoreCase.ToString(), "Ignore case", false);
regExPropertys.AddProperty(RegexOptions.Multiline.ToString(), "Multiline mode", false);
regExPropertys.AddProperty(RegexOptions.Singleline.ToString(), "Dot match all", false);
regExPropertys.Change += new PropertiesToolsWindows.PropertiesToolsWindowsEventHandler(regExOptions_Change);
// create instance of regex parser
RegexOptions regexOptions = System.Text.RegularExpressions.RegexOptions.None;
regExParser = new RegExParser(regexOptions);
}
catch (Exception ex)
{
Log.Write(ex, this, "ModuleMainForm", Log.LogType.ERROR);
}
}
static void TestParser()
{
while (true)
{
Console.Write('>');
var line = Console.ReadLine();
if (string.IsNullOrEmpty(line))
break; }
try
{
var parser = new RegExParser(line);
var tree = parser.Parse();
var sb = new StringBuilder();
tree.Print(sb, string.Empty, string.Empty);
Console.WriteLine(sb);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public ModuleMainForm()
{
InitializeComponent();
try
{
// set property windows
regExPropertys = new PropertiesToolsWindows("Options");
regExPropertys.AddProperty(RegexOptions.IgnoreCase.ToString(), "Ignore case", false);
regExPropertys.AddProperty(RegexOptions.Multiline.ToString(), "Multiline mode", false);
regExPropertys.AddProperty(RegexOptions.Singleline.ToString(), "Dot match all", false);
regExPropertys.Change += new PropertiesToolsWindows.PropertiesToolsWindowsEventHandler(regExOptions_Change);
// create instance of regex parser
RegexOptions regexOptions = System.Text.RegularExpressions.RegexOptions.None;
regExParser = new RegExParser(regexOptions);
}
catch (Exception ex)
{
Log.Write(ex, this, "ModuleMainForm", Log.LogType.ERROR);
}
}
public StringProduction(CharSymbol symbol, string production)
{
Lhs = symbol;
Rhs = RegEx <char> .Convert <CharSymbol>(RegExParser.Parse(production), c => new CharSymbol(c));
}
