private static AstNodeBase Create(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
if (IsRoot(node, args))
{
return(CreateRoot(node, args));
}
if (IsConcat(node, args))
{
return(CreateConcat(node, args));
}
if (IsAtom(node, args))
{
return(CreateAtom(node, args));
}
if (IsGroup(node, args))
{
return(CreateGroup(node, args));
}
if (IsUnOper(node, args))
{
return(CreateUnOper(node, args));
}
if (IsBinOper(node, args))
{
return(CreateBinOper(node, args));
}
return(Create(node.GetChild(0), args)); //fictive node, skip him
}
private static AstGroupNode CreateGroup(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
var predicate = node.GetChild(0).GetText();
var inner = Create(node.GetChild(1), args);
var children = new List <AstNodeBase>();
if (inner is AstConcatNode)
{
children.AddRange(inner.GetChildren());
}
else
{
children.Add(inner);
}
QuantifierBase quantifier = null;
if (CaptureQuantifier.IsCapture(predicate))
{
var cq = new CaptureQuantifier(predicate, args.CaptureGroupNames.Count);
args.CaptureGroupNames.Add(cq.CaptureName);
quantifier = cq;
}
else if (LookAheadQuantifier.IsLook(predicate))
{
quantifier = new LookAheadQuantifier(predicate);
}
return(new AstGroupNode(children, quantifier, new Range(node)));
}
private static AstNodeBase CreateAtom(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
if (node.ChildCount == 1)
{
var name = node.GetChild(0).GetText();
if (name == ".")
{
return(new AstAtomNode <TValue>(name, args.GetPredicate(name), new Range(node)));
}
return(CreateNAtom(node.GetChild(0), args));
}
var children = new List <AstAtomNode <TValue> >();
for (int i = 1; i < node.ChildCount - 1; i++)
{
var child = CreateNAtom(node.GetChild(i), args);
children.Add(child);
}
var isNegate = node.GetChild(0).GetText().Length == 2;
if (isNegate)
{
PredicateEdgeBase <TValue> p;
string n;
args.GetInvertedPredicate(children.Select(x => x.Name), out p, out n);
return(new AstAtomNode <TValue>(n, p, new Range(node)));
}
return(new AstOrNode(children, new Range(node)));
}
private static AstRepeatNode CreateUnOper(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
var arg = Create(node.GetChild(0), args);
var oper = node.GetChild(1).ToString();
int min,
max;
bool isLazy = false;
var match = Regex.Match(oper, @"{(?<min>\d+),(?<max>\d+)?}(?<greed>\?)?");
if (match.Success)
{
isLazy = match.Groups["greed"].Success;
min = int.Parse(match.Groups["min"].Value);
max = match.Groups["max"].Success ? int.Parse(match.Groups["max"].Value) : int.MaxValue;
}
else
{
switch (oper)
{
case "*":
min = 0;
max = int.MaxValue;
break;
case "*?":
min = 0;
max = int.MaxValue;
isLazy = true;
break;
case "+":
min = 1;
max = int.MaxValue;
break;
case "+?":
min = 1;
max = int.MaxValue;
isLazy = true;
break;
case "?":
min = 0;
max = 1;
break;
case "??":
min = 0;
max = 1;
isLazy = true;
break;
default:
throw new NotImplementedException("Unsuported operator.");
}
}
return(new AstRepeatNode(arg, min, max, isLazy, new Range(node)));
}
private static AstAtomNode <TValue> CreateNAtom(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
var name = node.GetChild(0).ToString();
var atomName = name.Substring(1, name.Length - 2);
var atomPredicate = args.GetPredicate(atomName);
return(new AstAtomNode <TValue>(atomName, atomPredicate, new Range(node)));
}
private static AstConcatNode CreateConcat(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
List <AstNodeBase> children = new List <AstNodeBase>();
for (int i = 0; i < node.ChildCount; i++)
{
var child = node.GetChild(i);
children.Add(Create(child, args));
}
return(new AstConcatNode(children, new Range(node)));
}
private static AstOrNode CreateBinOper(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
List <AstNodeBase> children = new List <AstNodeBase>();
for (int i = 0; i < node.ChildCount; i++)
{
var childNode = node.GetChild(i);
if (childNode.GetText() != "|")
{
var child = Create(childNode, args);
children.Add(child);
}
}
return(new AstOrNode(children, new Range(node)));
}
public AstRootNode Parse(string input, PredicateTable <TValue> predicateTable)
{
var lexer = new RegexGrammarLexer(new AntlrInputStream(input));
var tokenStream = new CommonTokenStream(lexer);
var parser = new RegexGrammarParser(tokenStream);
parser.AddErrorListener(new ORegexErrorListener());
var context = parser.expr();
var args = new ORegexAstFactoryArgs <TValue>(predicateTable, parser);
var result = ORegexAstFactory <TValue> .CreateAstTree(context, args);
#if DEBUG
AstNodeBase.Print(result);
#endif
return(result);
}
private static AstRootNode CreateRoot(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
args.CaptureGroupNames.Add(MainCaptureName);
bool matchBegin = false;
bool matchEnd = false;
if (node.GetChild(0).GetText() == "^")
{
matchBegin = true;
}
if (node.GetChild(node.ChildCount - 1).GetText() == "$")
{
matchEnd = true;
}
var inner = Create(matchBegin ? node.GetChild(1) : node.GetChild(0), args);
return(new AstRootNode(inner, matchBegin, matchEnd, new Range(node), args.CaptureGroupNames));
}
private static bool IsUnOper(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
return(node.ChildCount == 2 && args.IsName(node, "unOper"));
}
private static bool IsGroup(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
return(node.ChildCount == 3 && args.IsName(node, "group"));
}
private static bool IsAtom(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
return(args.IsName(node, "natom") || args.IsName(node, "atom"));
}
private static bool IsConcat(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
return(node.ChildCount > 1 && args.IsName(node, "concat"));
}
private static bool IsRoot(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
return(args.IsName(node, "expr"));
}
public static AstRootNode CreateAstTree(IParseTree node, ORegexAstFactoryArgs <TValue> args)
{
var tree = CreateRoot(node, args);
return(tree);
}
