// public static PegBuilder<ConsumeChoice> Builder = new PegBuilder<ConsumeChoice>(Grammar);
public static ConsumeExpression Parse(string s)
{
var result = Parser.ParseString(s);
// Bypass BnfBuilder because that depends on this in order to work
CstNonterminalNode cst = CstBuilder.Build(result);
return(BuildChoice(cst));
}
/// <summary>
/// Replaces all occurances of the pattern within input according to the definition provided
/// by replacements.
/// </summary>
public static string Replace(this Expression expression, string input, params Replacement[] replacements)
{
// We want the expression to act like a nonterminal so that its contents get grouped up in the CST
if (!(expression is Nonterminal))
{
expression = expression.Capture();
}
// Modify the expression to allow any character (allows matching substrings)
var exp = +(expression | new AnyCharacter(true));
var parser = CreateParser(exp);
var output = parser.ParseString(input);
if (!output.Any())
{
return(input);
}
var cst = CstBuilder.Build(output);
cst = (CstNonterminalNode)cst.Children[0];
var transformedCst = new CstNonterminalNode(cst.Nonterminal, -1);
foreach (var child in cst.Children)
{
if (child is CstNonterminalNode)
{
var childNonterminal = (CstNonterminalNode)child;
var cache = new CstCache(childNonterminal);
var map = replacements.ToDictionary(x => x.From, x => x.To.Replace(cache));
var transformed = childNonterminal.Transform(x => map.ContainsKey(x.Nonterminal) ? map[x.Nonterminal] : null);
transformedCst.Children.Add(transformed);
}
else
{
transformedCst.Children.Add(child);
}
}
return(transformedCst.Coalesce());
}
/// <summary>
/// Performs a transformation on the input substituting the values as defined by the provided
/// replacements. This requires an exact match similar to the Match(...) method.
/// </summary>
public static string Transform(this Expression expression, string input, params Replacement[] replacements)
{
var parser = CreateParser(expression);
var output = parser.ParseString(input);
if (!output.Any())
{
return(input);
}
var cst = CstBuilder.Build(output);
cst = (CstNonterminalNode)cst.Children[0];
var cache = new CstCache(cst);
var map = replacements.ToDictionary(x => x.From, x => x.To.Replace(cache));
var transformed = cst.Transform(x => map.ContainsKey(x.Nonterminal) ? map[x.Nonterminal] : null);
return(transformed.Coalesce());
}
public static Dictionary <Nonterminal, string> Parse(this Expression expression, string input)
{
var parser = CreateParser(expression);
var output = CstBuilder.Build(parser.ParseString(input));
if (output == null)
{
return(null);
}
var dictionary = new Dictionary <Nonterminal, string>();
foreach (var nonterminal in output.FindAllNonterminalNodes())
{
if (nonterminal.Nonterminal != null)
{
dictionary[nonterminal.Nonterminal] = nonterminal.Coalesce();
}
}
return(dictionary);
}
public T Build(IEnumerable <OutputRecord> outputStream)
{
CstNonterminalNode cstNode = CstBuilder.Build(outputStream);
return(Build((CstNonterminalNode)cstNode.Children[0]));
}
