public void ZeroOrMore_should_match(string text)
{
// arrange
var buffer = text.ToSinglyLinked();
// act
var(isMatch, start, end) = ZeroOrMore(Space())(buffer);
// assert
isMatch.ShouldBeTrue();
start.Head.ShouldBe(text.First());
end.ShouldBeNull();
}
public void ZeroOrMore_should_match_empty_string()
{
// arrange
var buffer = "".ToSinglyLinked();
// act
var(isMatch, start, end) = ZeroOrMore(Space())(buffer);
// assert
isMatch.ShouldBeTrue();
start.ShouldBeNull();
end.ShouldBeNull();
}
public override void VisitLeave(ZeroOrMore expression)
{
IsMatchPredicate local = _matchStack.Pop();
_matchStack.Push(
delegate(IInputIterator iterator)
{
Int32 savePosition = iterator.Index;
while (local(iterator))
{
if (savePosition == iterator.Index)
{
//Exception ex = new InfiniteLoopDetectedException();
//ex.Data.Add("Iterator.Index", iterator.Index);
//var rulewriter = new WriteRuleVisitor();
//expression.Accept(rulewriter);
//ex.Data.Add("Expression", rulewriter.GrammarOutput);
//throw ex;
break;
}
savePosition = iterator.Index;
}
iterator.Index = savePosition;
return(true);
}
);
}
public void TestGrammarZeroOrMoreLetterA()
{
TestGrammar1 grammar = TestGrammar1.Create();
Nonterminal nonterminal = grammar.GetNonterminal(o => o.ZeroOrMoreLetterA());
Assert.AreEqual("ZeroOrMoreLetterA", nonterminal.Name);
ZeroOrMore expression = (ZeroOrMore)nonterminal.Expression;
Assert.AreEqual("LetterA", ((Nonterminal)expression.Operand).Name);
}
public void ShouldEquals()
{
ZeroOrMore a, b;
a = new ZeroOrMore();
a.Item = new Terminal('a');
b = new ZeroOrMore();
b.Item = new Terminal('a');
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(b.Equals(a));
}
public void Repetition()
{
var p = new ZeroOrMore(letters);
MustMatch(p, "xa");
MustMatch(p, "");
MustMatch(p, "aaaaaaaaaaaaaaaaaaaaaaaaaaa");
MustMatch(p, "arsndhtaibtarsbt");
MustNotMatch(p, "+");
MustNotMatch(p, "+aaaaaa");
MustNotMatch(p, "Baaaaa");
MustMatchPartial(p, "abcdefNHNEISH", 6);
MustNotMatch(p, "++++++");
}
public void ShouldNotEquals()
{
ZeroOrMore a, b;
a = new ZeroOrMore();
a.Item = new Terminal('a');
b = new ZeroOrMore();
b.Item = new Terminal('b');
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(a.Equals(null));
Assert.IsFalse(a.Equals(new AnyTerminal()));
Assert.IsFalse(a.Equals(new EOS()));
}
public void BasicCapture()
{
var p = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, letters), new Any()));
var captures = Match(p, "...a...b...c");
Assert.AreEqual(3, captures.Count);
Assert.IsTrue(captures.Contains("a"));
Assert.IsTrue(captures.Contains("b"));
Assert.IsTrue(captures.Contains("c"));
Assert.IsFalse(captures.Contains(""));
Assert.IsFalse(captures.Contains("."));
Assert.IsFalse(captures.Any(item => item.Length != 1));
}
public void WordCapture()
{
var p = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, Operator.OneOrMore(letters)), new Any()));
var captures = Match(p, "hello world test ABC ...");
Assert.AreEqual(3, captures.Count);
Assert.IsTrue(captures.Contains("hello"));
Assert.IsTrue(captures.Contains("world"));
Assert.IsTrue(captures.Contains("test"));
Assert.IsFalse(captures.Contains("ABC"));
Assert.IsFalse(captures.Contains("."));
Assert.IsFalse(captures.Contains("..."));
}
public void SparqlPropertyPathEvaluationZeroOrMorePath()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("InferenceTest.ttl");
store.Add(g);
InMemoryDataset dataset = new InMemoryDataset(store, g.BaseUri);
ZeroOrMore path = new ZeroOrMore(new Property(this._factory.CreateUriNode(new Uri(NamespaceMapper.RDFS + "subClassOf"))));
ISparqlAlgebra algebra = this.GetAlgebra(path);
BaseMultiset results = algebra.Evaluate(new SparqlEvaluationContext(null, dataset));
TestTools.ShowMultiset(results);
Assert.IsFalse(results.IsEmpty, "Results should not be empty");
}
public void SparqlPropertyPathEvaluationZeroOrMorePathForward()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("resources\\InferenceTest.ttl");
store.Add(g);
InMemoryDataset dataset = new InMemoryDataset(store);
ZeroOrMore path =
new ZeroOrMore(new Property(this._factory.CreateUriNode(new Uri(NamespaceMapper.RDFS + "subClassOf"))));
INode sportsCar = this._factory.CreateUriNode(new Uri("http://example.org/vehicles/SportsCar"));
ISparqlAlgebra algebra = this.GetAlgebra(path, sportsCar, null);
BaseMultiset results = algebra.Evaluate(new SparqlEvaluationContext(null, dataset));
TestTools.ShowMultiset(results);
Assert.False(results.IsEmpty, "Results should not be empty");
}
public void ShouldConvertToStringWithBullet()
{
ZeroOrMore predicate;
Sequence sequence;
Terminal terminal;
terminal = new Terminal(new Token("C", "a"));
predicate = new ZeroOrMore();
predicate.Item = terminal;
Assert.AreEqual("•<C,a>*", predicate.ToString(terminal));
sequence = new Sequence();
sequence.Items.Add(new Terminal(new Token("C", "a")));
sequence.Items.Add(terminal);
sequence.Items.Add(new Terminal(new Token("C", "a")));
predicate = new ZeroOrMore();
predicate.Item = sequence;
Assert.AreEqual("(<C,a>•<C,a><C,a>)*", predicate.ToString(terminal));
}
public void ShouldConvertToStringWithBullet()
{
ZeroOrMore predicate;
Sequence sequence;
Terminal terminal;
terminal = new Terminal('a');
predicate = new ZeroOrMore();
predicate.Item = terminal;
Assert.AreEqual("•a*", predicate.ToString(terminal));
sequence = new Sequence();
sequence.Items.Add(new Terminal('a'));
sequence.Items.Add(terminal);
sequence.Items.Add(new Terminal('a'));
predicate = new ZeroOrMore();
predicate.Item = sequence;
Assert.AreEqual("(a•aa)*", predicate.ToString(terminal));
}
private static int GetNumCaptures(string regex, string strData)
{
var data = strData.ToCharArray();
var g = new RegexGrammar(PatternCompiler.Default);
var converter = new RegexConverter();
var c = converter.Convert(g.ParseExpression(regex));
var matchPattern = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, c), new Any()));
var p = new Pattern(null)
{
Data = matchPattern
};
var runner = PatternCompiler.Default.Compile(p);
var captures = new List <Capture>();
var result = runner.Run(data, 0, data.Length, captures);
return(result.IsSuccessful ? captures.Count : -1);
}
public void ShouldNotBuildZeroOrMoreSegment()
{
SituationGraphSegmentFactory <char> factory;
ISituationGraph <char> graph;
LexicalRule rule;
MockedSituationEdge capEdge;
ZeroOrMore predicate;
capEdge = new MockedSituationEdge();
graph = new SituationGraph <char>();
factory = new SituationGraphSegmentFactory <char>();
predicate = new ZeroOrMore();
rule = new LexicalRule()
{
Name = "A", Predicate = predicate
};
Assert.ThrowsException <ArgumentNullException>(() => factory.BuildSegment(null, rule, predicate, capEdge.AsEnumerable()));
Assert.ThrowsException <ArgumentNullException>(() => factory.BuildSegment(graph, null, predicate, capEdge.AsEnumerable()));
Assert.ThrowsException <ArgumentNullException>(() => factory.BuildSegment(graph, rule, null as ZeroOrMore, capEdge.AsEnumerable()));
Assert.ThrowsException <ArgumentNullException>(() => factory.BuildSegment(graph, rule, predicate, null));
}
public override void VisitEnter(ZeroOrMore expression)
{
terminal.Peek().Append("(");
}
public virtual void Visit(ZeroOrMore expression, T context)
{
expression.Operand.Accept(this, context);
}
public abstract void VisitLeave(ZeroOrMore expression);
public abstract void VisitExecute(ZeroOrMore expression);
public abstract void VisitEnter(ZeroOrMore expression);
static void Main(string[] args)
{
//---------------------------------単体先頭マッチテスト--------------------------------------------
const string text = "aaabbbbTTTXYZAAA123456789";
var list = new List <Tuple <string, Regex> >();
//list.Add(Tuple.Create("Literal: match", Regex.Make().Literal("aaa")));
//list.Add(Tuple.Create("Literal: match", Regex.Make().Literal("aab")));
//list.Add(Tuple.Create("Any: match", Regex.Make().To(new Any())));
//list.Add(Tuple.Create("Any: match many times", Regex.Make().To(new Any()).To(new Any()).To(new Any()).To(new Any()).To(new Any())));
//list.Add(Tuple.Create("Not: unmatch", Regex.Make().To(new Not("a"))));
//list.Add(Tuple.Create("Not: unmatch", Regex.Make().To(new Not("aaa"))));
//list.Add(Tuple.Create("Not: match", Regex.Make().To(new Not("aab"))));
//list.Add(Tuple.Create("Or: match on second arg", Regex.Make().To(new Or("xxxxxx", "aaa", "eeeee"))));
//list.Add(Tuple.Create("Head: match", Regex.Make().To(new Head())));
//list.Add(Tuple.Create("Head: unmatch", Regex.Make().Literal("aaa").To(new Head())));
//list.Add(Tuple.Create("Tail: unmatch", Regex.Make().To(new Tail())));
//list.Add(Tuple.Create("Tail: match", Regex.Make().Literal(text).To(new Tail())));
//list.Add(Tuple.Create("?: match one", Regex.Make().To(new ZeroOrOne("a"))));
//list.Add(Tuple.Create("?: match zero", Regex.Make().To(new ZeroOrOne("x"))));
//list.Add(Tuple.Create("*: match zero", Regex.Make().To(new ZeroOrMore("x"))));
//list.Add(Tuple.Create("*: match three", Regex.Make().To(new ZeroOrMore("a"))));
//list.Add(Tuple.Create("+: unmatch", Regex.Make().To(new OneOrMore("x"))));
//list.Add(Tuple.Create("+: match three", Regex.Make().To(new OneOrMore("a"))));
//list.Add(Tuple.Create("+: match six", Regex.Make().To(new OneOrMore(new OneOrMore("a")))));//GREAT!
//list.Add(Tuple.Create("(?=): unmatch", Regex.Make().To(new PositiveLookahead("aaa", "a"))));
//list.Add(Tuple.Create("(?=): match", Regex.Make().To(new PositiveLookahead("aaa", "b"))));
//list.Add(Tuple.Create("(?!): unmatch", Regex.Make().To(new NegativeLookahead("aaa", "a"))));
//list.Add(Tuple.Create("(?!): match", Regex.Make().To(new NegativeLookahead("aaa", "b"))));
//list.Add(Tuple.Create("(?!): match", Regex.Make().To(new PositiveLookbehind("bbb", "a"))));
//list.Add(Tuple.Create("(?!): unmatch", Regex.Make().To(new PositiveLookbehind("bbb", "x"))));
//list.Add(Tuple.Create("(?!): 1 match", Regex.Make().To(new NegativeLookbehind("bbb", "a"))));
//list.Add(Tuple.Create("(?!): 2 match", Regex.Make().To(new NegativeLookbehind("bbb", "x"))));
for (int i = 0; i < list.Count; i++)
{
ShowLog(list[i].Item1, text, list[i].Item2);
}
//---------------------------------結合先頭マッチテスト--------------------------------------------
var list2 = new List <Tuple <string, Regex, string> >();
var rgx1 =
Regex.Make()
.Literal("r")
.To(new ZeroOrOne("e"))
.To(new Any())
.To(new OrInvert('g'))
.To(new Or("e", "x"))
.To(new Or("e"));
//list2.Add(Tuple.Create("re?.[^g][ex][e]: match", rgx1, "rgrxe"));
//list2.Add(Tuple.Create("re?.[^g][ex][e]: match", rgx1, "rexee"));
//list2.Add(Tuple.Create("re?.[^g][ex][e]: match", rgx1, "rekvee"));
//list2.Add(Tuple.Create("re?.[^g][ex][e]: unmatch", rgx1, "rekverrr"));
foreach (var tuple in list2)
{
ShowLog(tuple.Item1, tuple.Item3, tuple.Item2);
}
//---------------------------------全体マッチテスト--------------------------------------------
var list3 = new List <Tuple <string, Regex> >();
var regg = new Capture(new OneOrMore(new Or(new OrInvert('|'), new Escaped(new Char('|'))))); //|に挟まれる奴
var a = new ZeroOrMore(new Or(regg, new UnEscaped('|'))); //[]の中身
var aa = new UnEscaped('[').To(a).To(new UnEscaped(']'));
var aasaa = new OneOrMore(regg.To(new Literal("a"))).To(regg);
var b0 = new OrInvert('\\', '[', ']');//\じゃないやつ
var b1 = new Literal(@"\").To(new Any());
var b2 = new OneOrMore(new Capture(new Or(b0, b1)));
var b3 = new UnEscaped('[');
var b4 = new UnEscaped(']');
var b = b3.To(b2);
//list3.Add(Tuple.Create(@"as\[asd[a\d\]d\ds]", new UnEscapedOrBrace() as Regex));
//list3.Add(Tuple.Create("ffabtabeaabbab", Regex.Make().To(new OneOrMore(new Literal("a").To(new Literal("b"))))));
//list3.Add(Tuple.Create("aatestatest", Regex.Make().Literal("test")));
//list3.Add(Tuple.Create("aatestatesttasttust", Regex.Make().Literal("t").To(new Capture(new Any())).Literal("st")));
//list3.Add(Tuple.Create("aatestteaatestesaates", Regex.Make().To(new Named("Label",new Literal("a"))).To(new Reference("Label"))));
var rg = Regex.Make().Literal("(").To(new ZeroOrMore(new Any())).Literal(")"); //単純括弧ok
var rg2 = Regex.Make().To(new ZeroOrMore(new OrInvert('(', ')'))); //括弧じゃない奴らの連続ちょっとちがうけどok
var rg3 = Regex.Make().To(new Or("()", new OneOrMore(new OrInvert('(', ')')))); //ok
var rgx4 = Regex.Make().To(new Named("kakko", new UnEscaped('(').To(new ZeroOrMore(new Or(new OrInvert('(', ')'), new Reference("kakko")))).Literal(")"))); //括弧とれた！！！！
//var rg5 = new UnEscaped(new Literal("("));//エスケープされない括弧開き
var escapedB = new PositiveLookbehind(new Literal("("), new Or(new Head(), new OrInvert('\\')).To(new Literal(@"\")).To(new ZeroOrMore(new Literal(@"\\"))));
var escapedB2 = new PositiveLookbehind(new Literal(")"), new Or(new Head(), new OrInvert('\\')).To(new Literal(@"\")).To(new ZeroOrMore(new Literal(@"\\"))));
var independentPatern = new Or(new Literal(@"\"), new UnEscapedBraces(), new OrInvert(new MetaChar()), ".", "^", "$");
var patern = new ZeroOrOne(new LookBehindSyntax()).To(independentPatern).To(new ZeroOrOne(new Or(new LookAheadSyntax(), new Repeater().To(new ZeroOrOne("?")))));//後置、前置ともに最大ひとつしか取れない仕様で
var patterns = new OneOrMore(patern);
var regexPattern = new Named("RGP", new Capture(patterns).To(new ZeroOrOne(new Literal("|").To(new Reference("RGP")))));
//var rgx44 = Regex.Make().To(new Named("kakko", new UnEscaped(new Literal("(")).To(new ZeroOrMore(new Or(new OrInvert('(', ')'),escapedB,escapedB2, new Reference("kakko")))).To(new UnEscaped(new Literal(")")))));//括弧とれた！！！！
//list3.Add(Tuple.Create("aaa(ddd)fff", rg));//ok
//list3.Add(Tuple.Create("a.a?a*a+(ddd)f+f*f", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?<=a)aa", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?<!a)aa", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?=a)aa", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?!a)aa", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?<=a)a(?=a)a", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?!a)aa(?=a)a", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?!a)aa*a", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("aa(?!a)a|a*a|a", regexPattern as Regex));//ok
//list3.Add(Tuple.Create("aa(?!a)a++a", rgrg2 as Regex));//ok
//list3.Add(Tuple.Create("{1,3a}", new CountRepeaterSyntax() as Regex));//ok
//list3.Add(Tuple.Create("{1, }", new CountRepeaterSyntax() as Regex));//ok
//list3.Add(Tuple.Create("{14}", new CountRepeaterSyntax() as Regex));//ok
//list3.Add(Tuple.Create("aaa(ddd)f(f)f", rg));//ok
//list3.Add(Tuple.Create("aaa(d(d)d)f(f)f", rg));//ok
//list3.Add(Tuple.Create("aatestatest", Regex.Make().To(new OneOrMore(new Literal("a")))));
//list3.Add(Tuple.Create("xy", Regex.Make().To(new ZeroOrMore("a"))));
//list3.Add(Tuple.Create("aaasd(dsff)fsdf()(sdf)sd((dfg(df)A(A)S()F(A",rg2));
//list3.Add(Tuple.Create("fsdf()(sdf))A(A)S()F(A",rg3));
//list3.Add(Tuple.Create("()",rgx4));
//list3.Add(Tuple.Create("(a)",rgx4));
//list3.Add(Tuple.Create("(aa)",rgx4));
//list3.Add(Tuple.Create("(a(a))",rgx4));
//list3.Add(Tuple.Create("bb(a(a))", rgx4));
//list3.Add(Tuple.Create("nn(a(a)nn", rgx4));
//list3.Add(Tuple.Create("a", new CountRepeater("a",0,1) as Regex));
//list3.Add(Tuple.Create("a,aa,aaa,aaaa,aaaaa", new CountRepeater("a",1,1) as Regex));
//list3.Add(Tuple.Create("a,aa,aaa,aaaa,aaaaa", new CountRepeater("a",2,2) as Regex));
//list3.Add(Tuple.Create("a,aa,aaa,aaaa,aaaaa", new CountRepeater("a",1,2) as Regex));
//list3.Add(Tuple.Create("a,aa,aaa,aaaa,aaaaa", new CountRepeater("a",2,3) as Regex));
//list3.Add(Tuple.Create("nn(ann", RegexParser.RegexPattern));
//list3.Add(Tuple.Create("123", Regex.Make().To(new Digit())));
//list3.Add(Tuple.Create("123", Regex.Make().To(new OneOrMore(new Digit()))));
//list3.Add(Tuple.Create(@"\\(()a\()aa(\\\(a)", new UnEscapedBraces() as Regex));
//list3.Add(Tuple.Create(@"\\a\))\da(a\\s\(", new NegativeLookBehindSyntax(true).To(new Capture(independentPatern.To(new ZeroOrOne(new Or(new LookAheadSyntax(), new Repeater().To(new ZeroOrOne("?"))))))) as Regex));
foreach (var tuple in list3)
{
ShowLog("3rdTest::", tuple.Item1, tuple.Item2);
Console.ReadLine();
}
//Console.ReadLine();
var strList = new List <string>();
//strList.Add(@"aaaaaaaaaaa");//単純リテラル
//strList.Add(@"\\aaa\\ss\\sss");//エスケープリテラル
//strList.Add(@"\\a\daa\\s\d\ds\\\dsss");//エスケープ
//strList.Add(@"\\a\))\da(a\\s\(");//エスケープ
//strList.Add(@"\\d");//エスケープ
//strList.Add(@"\\(a)\d");//エスケープ
//strList.Add(@"\\a(\))a)(as\(");//エスケープ
//strList.Add(@"\\a(\))\da)(a\\s\(");//エスケープ
//strList.Add(@"\\ddf(gh(df)gh)(df)gh");//エスケープ
//strList.Add(@"aaaaa(bbbb)ccc");//エスケープ
//strList.Add(@"aaaaa(?:bbbb)ccc");//エスケープ
//strList.Add(@"aaaaa(?=bbbb)ccc");//エスケープ
//strList.Add(@"aaaaa(?!bbbb)ccc");//エスケープ
//strList.Add(@"aaaaa(?<=bbbb)ccc");//エスケープ
//strList.Add(@"aaaa(?=a(??bbbb)c)cc");//エスケープ
//strList.Add(@"aaaa(?=a(??bbbb)c)cc");//エスケープ
//strList.Add(@"a+bc");//エスケープ
//strList.Add(@"a?bc");//エスケープ
//strList.Add(@"a*bc");//エスケープ
//strList.Add(@"a.bc");//エスケープ
//strList.Add(@"a^bc");//エスケープ
//strList.Add(@"a\$\[$b]c");//エスケープ
//strList.Add(@"a[abcde]b");//エスケープ
//strList.Add(@"a[^abcde]b");//エスケープ
//strList.Add(@"a(");//エスケープ
int count = 0;
foreach (var regStr in strList)
{
Console.WriteLine("------------" + (count++) + "----------------");
Console.WriteLine("\n@@@ParseProccess@@@");
var reg = RegexParser.Parse(regStr);
Console.WriteLine("\n@@@Structure@@@");
Console.WriteLine(reg.ToStructureString());
Console.ReadLine();
}
var parseList = new List <Tuple <string, string> >();
//parseList.Add(Tuple.Create(@"\d\d\d-\d\d\d\d", "00000000"));
//parseList.Add(Tuple.Create(@"\d\d\d-\d\d\d\d", "000-0000"));
//parseList.Add(Tuple.Create(@"b.k", "bak"));
//parseList.Add(Tuple.Create(@"b.k", "btk"));
//parseList.Add(Tuple.Create(@"b.k", "btrk"));
//parseList.Add(Tuple.Create(@"b.+k", "btrk"));
//parseList.Add(Tuple.Create(@"b.+k", "bk"));
//parseList.Add(Tuple.Create(@"b.+k", "btssrkss"));
//parseList.Add(Tuple.Create(@"b.*k", "btrk"));
//parseList.Add(Tuple.Create(@"b.*k", "bk"));
//parseList.Add(Tuple.Create(@"[13579]", "4"));
//parseList.Add(Tuple.Create(@"[13579]", "4123445678"));
foreach (var tuple in parseList)
{
var reg = RegexParser.Parse(tuple.Item1);
ShowLog(tuple.Item1 + " ===> " + tuple.Item2, tuple.Item2, reg);
Console.ReadLine();
}
while (true)
{
Console.Write("imput [Rr]egex: \t>");
string reg = Console.ReadLine();
Console.Write("input [Tt]ext: \t>");
string te = Console.ReadLine();
var regex = RegexParser.Parse(reg);
ShowLog(reg + " ===> " + te, te, regex);
Console.WriteLine("\n\n");
}
}
public void SparqlPropertyPathTransformationZeroOrMore()
{
ZeroOrMore path = new ZeroOrMore(new Property(this._factory.CreateUriNode(new Uri(RdfSpecsHelper.RdfType))));
this.RunTest(path, new String[] { "ZeroOrMorePath" });
}
public override void Visit(ZeroOrMore expression, object context)
{
expressions.Add(expression);
base.Visit(expression, context);
}
public override void VisitEnter(ZeroOrMore expression)
{
}
public void Visit(ZeroOrMore expression, Nonterminal context)
{
expression.Operand.Accept(this, context);
}
public override void VisitExecute(ZeroOrMore expression)
{
}
public override void VisitLeave(ZeroOrMore expression)
{
terminal.Peek().Append(")*");
}
public void ShouldConvertToGrammarString()
{
var expr = new ZeroOrMore(new LiteralTerminal("a"));
Assert.Equal("'a'*", expr.ToString());
}
static void Main(string[] args)
{
//{
// var jitter = new CustomJitter("Regex.dll");
// var rg = new RegexGrammar(new PatternCompiler(new Compiler(), new DefaultOptimizer(), jitter));
// jitter.Save();
// rg.ParseExpression("abc");
//}
var patternCompiler = new PatternCompiler(new Compiler(), null, new ILJitter());
var regexGrammar = new Lazy <RegexGrammar>(() => new RegexGrammar(patternCompiler));
var converter = new RegexConverter();
var helper = new PegHelper(patternCompiler);
helper.EnsureExpressionBuilt();
//CompileAndWritePatternToFile("PegExpression", helper.GetExpressionPattern());
//var input = "AAA AAAas ntAar ".ToCharArray();
var input = GenerateInputData(1 << 20);
//var pattern = new PointerImplementation();
//var patternStr = "([A-Za-z] 'awyer' [ \t] / [A-Za-z] 'inn' [ \t])";
//var patternStr = "([A-Za-z] 'x')";
//var patternStr = "([A-Za-z] 'awyer' [ \t] / [A-Za-z] 'inn' [ \t])";
//var patternStr = "'Tom' / 'Finn' / 'Sawyer' / 'Huckleberry'";
//var patternStr = "'Tom' / 'Sawyer' / 'Huckleberry' / 'Finn' ";
//var patternStr = "[ -z][ -z]([ -z][ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / [ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / ('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn'))";
//var patternStr = "[ -z][ -z]([ -z][ -z]('T' / 'S') / [ -z]('T' / 'Sawye' / 'Huck') / 'Huckleberry')";
//var patternStr = "[ -z][ -z]([ -z][ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / [ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / ('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn'))";
//var patternStr = "[ -z][ -z]([ -z][ -z]('T' / 'S' / 'H') / [ -z]('T' / 'S' / 'H') / ('T' / 'S'))";
//var patternStr = $"[ -{char.MaxValue}][ -z]([ -z][ -z]('T' / 'S') / [ -z]('T'))";
//var patternStr = ".. ('T' / 'SS' / 'HHH' / 'FFFF')";
//var patternStr = "('T' / 'SS' / 'HHH' / 'FFFF')";
//var patternStr = ".. ('TT' / 'FFF')";
//var patternStr = "'Twain'";
//var patternStr = "[a-z] 'shing'";
//var patternStr = "[a-z]+";
//var patternStr = "('Huck'[a-zA-Z]+) / ('Saw'[a-zA-Z]+)";
//var m = $"[{char.MinValue}-uz-{char.MaxValue}]";
//var patternStr = $"[a-q]{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m} 'x'";
//var pattern = CompileAndWritePatternToFile("SimpleMatch", new Pattern("SimpleMatch") { Data = helper.ParseExpression("[a-z]*") });
//var p = converter.Convert(regexGrammar.Value.ParseExpression("Twain"));
//var p = converter.Convert(regexGrammar.Value.ParseExpression("river.{20,50}Tom|Tom.{20,50}river"));
//var p = converter.Convert(regexGrammar.Value.ParseExpression("river.{10,25}Tom|Tom.{10,25}river"));
//var a = new Pattern("A");
//a.Data = new PrioritizedChoice(new Sequence(letters, a), new Empty());
//var p = new Sequence(letters, a);
//var p = new Sequence(new PrioritizedChoice('T', 'R'), "om");//Operator.EndingWithGreedy(capitalsAndNonCapitals, CharacterClass.String("ing"));
//var ws = new Pattern { Data = new ZeroOrMore(new CharacterClass(' ')) };
//var p1 = new Pattern { Data = new Sequence(ws, CharacterClass.String("abc")) };
//var p2 = new Pattern { Data = new Sequence(ws, CharacterClass.String("xyz")) };
//var p = new PrioritizedChoice(p1, p2);
var p = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, converter.Convert(regexGrammar.Value.ParseExpression("([A-Za-z]awyer|[A-Za-z]inn)\\s"))), new Any()));
var s2 = new Stopwatch();
s2.Start();
var peg = new Pattern("SimpleMatch")
{
Data = p,
//Data = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, p), new Any()))
};
var pattern = CompileAndWritePatternToFile("SimpleMatch", peg);
Console.WriteLine($"Saved ({s2.ElapsedMilliseconds}ms)");
var text = "Tom..Huckleberry Finn Tom Tom Huck\nFinn,";
var capts = new List <Capture>();
var runResult = pattern.Run(text, capts);
if (runResult.IsSuccessful && runResult.InputPosition == text.Length)
{
Console.WriteLine($"Successful match on '{text}'");
}
//for (var n = 0; n < 10; n++)
//{
// for (var x = 0; x < 25; x++)
// {
// //var pegGrammar = new PegGrammar(new ILInterpreterFactory());
// //pegGrammar.EnsureExpressionBuilt();
// //var expression = pegGrammar.ParseExpression("'th' [a-z]+");
// //var compiler = (new ILCompilerFactory()).Create(new Pattern
// //{
// // Data = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, expression), new Any()))
// //});
// Stopwatch s = new Stopwatch();
// s.Start();
// var result = default(RunResult);
// var captures = new List<Capture>();
// for (var i = 0; i < 1000; i++)
// {
// captures = new List<Capture>();
// result = pattern.Run(input, 0, input.Length, captures);
// if (!result.IsSuccessful)
// {
// Console.WriteLine("Match fail");
// }
// }
// s.Stop();
// Console.WriteLine($"That took {s.ElapsedMilliseconds}ms ({captures.Count})");
// }
//}
Console.ReadKey();
}
/// <summary>
/// Formats a SPARQL Property Path
/// </summary>
/// <param name="path">SPARQL Property Path</param>
/// <returns></returns>
protected virtual String FormatPath(ISparqlPath path)
{
StringBuilder output = new StringBuilder();
if (path is AlternativePath)
{
AlternativePath alt = (AlternativePath)path;
output.Append('(');
output.Append(this.FormatPath(alt.LhsPath));
output.Append(" | ");
output.Append(this.FormatPath(alt.RhsPath));
output.Append(')');
}
else if (path is FixedCardinality)
{
FixedCardinality card = (FixedCardinality)path;
if (card.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(card.Path));
if (card.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(card.MaxCardinality);
output.Append('}');
}
else if (path is InversePath)
{
InversePath inv = (InversePath)path;
output.Append('^');
if (inv.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(inv.Path));
if (inv.Path is BaseBinaryPath)
{
output.Append(')');
}
}
else if (path is NOrMore)
{
NOrMore nOrMore = (NOrMore)path;
if (nOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(nOrMore.Path));
if (nOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(nOrMore.MinCardinality);
output.Append(",}");
}
else if (path is NToM)
{
NToM nToM = (NToM)path;
if (nToM.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(nToM.Path));
if (nToM.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('{');
output.Append(nToM.MinCardinality);
output.Append(',');
output.Append(nToM.MaxCardinality);
output.Append('}');
}
else if (path is OneOrMore)
{
OneOrMore oneOrMore = (OneOrMore)path;
if (oneOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(oneOrMore.Path));
if (oneOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('+');
}
else if (path is Property)
{
Property prop = (Property)path;
output.Append(this.Format(prop.Predicate, TripleSegment.Predicate));
}
else if (path is SequencePath)
{
SequencePath seq = (SequencePath)path;
output.Append(this.FormatPath(seq.LhsPath));
output.Append(" / ");
output.Append(this.FormatPath(seq.RhsPath));
}
else if (path is ZeroOrMore)
{
ZeroOrMore zeroOrMore = (ZeroOrMore)path;
if (zeroOrMore.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroOrMore.Path));
if (zeroOrMore.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('*');
}
else if (path is ZeroOrOne)
{
ZeroOrOne zeroOrOne = (ZeroOrOne)path;
if (zeroOrOne.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroOrOne.Path));
if (zeroOrOne.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append('?');
}
else if (path is ZeroToN)
{
ZeroToN zeroToN = (ZeroToN)path;
if (zeroToN.Path is BaseBinaryPath)
{
output.Append('(');
}
output.Append(this.FormatPath(zeroToN.Path));
if (zeroToN.Path is BaseBinaryPath)
{
output.Append(')');
}
output.Append("{,");
output.Append(zeroToN.MaxCardinality);
output.Append('}');
}
else if (path is NegatedSet)
{
NegatedSet negSet = (NegatedSet)path;
output.Append('!');
if (negSet.Properties.Count() + negSet.InverseProperties.Count() > 1)
{
output.Append('(');
}
foreach (Property p in negSet.Properties)
{
output.Append(this.FormatPath(p));
output.Append(" | ");
}
foreach (Property p in negSet.InverseProperties)
{
output.Append(this.FormatPath(p));
output.Append(" | ");
}
output.Remove(output.Length - 3, 3);
if (negSet.Properties.Count() + negSet.InverseProperties.Count() > 1)
{
output.Append(')');
}
}
else
{
throw new RdfOutputException("Unable to Format an unknown ISparqlPath implementations as a String");
}
return(output.ToString());
}
private Sequence ParseSequence(string s, ref int pos)
{
int startPos = pos;
var elements = new List <RegexElement>();
for (;;)
{
switch (PeekSym(s, pos))
{
case null:
case ")":
AdvancePos(s, ref pos);
goto AFTER_RPAR;
case ".":
elements.Add(new ItemMatchAndMore(pos));
AdvancePos(s, ref pos);
break;
case ":":
elements.Add(new AnyDependency(pos));
AdvancePos(s, ref pos);
break;
case "[":
AdvancePos(s, ref pos);
elements.Add(ParseSet(s, ref pos));
AdvancePos(s, ref pos);
break;
case "(":
AdvancePos(s, ref pos);
Sequence sequence = ParseSequence(s, ref pos);
Subsequence sub = sequence as Subsequence;
if (sub != null)
{
elements.AddRange(sub.Elements);
}
else
{
elements.Add(sequence);
}
AdvancePos(s, ref pos);
break;
default:
throw new RegexValidationException(null, null, $"Invalid symbol at {s.Substring(pos)}");
}
}
AFTER_RPAR:
Sequence result;
switch (PeekSym(s, pos))
{
case "*":
result = new ZeroOrMore(startPos, elements);
AdvancePos(s, ref pos);
break;
case "+":
result = new OneOrMore(startPos, elements);
AdvancePos(s, ref pos);
break;
case "?":
result = new Optional(startPos, elements);
AdvancePos(s, ref pos);
break;
default:
result = new Subsequence(startPos, elements);
break;
}
return(result);
}
