public Parser Generate(ParserGenerationContext ctx)
{
if (Defined)
{
return(GeneratedParser);
}
Defined = true;
GeneratedParser.Definition = Expression.Generate(ctx);
var matchWhitespace = Options.Any(x => x.Option == "match-whitespace");
var ignoreWhitespace = Options.Any(x => x.Option == "skip-whitespace");
foreach (var option in Options.Where(x => x.Option == "whitespace-rule"))
{
var arg = option.Args.First();
var rule = ctx.GetRule(arg, ((Identifier)arg).Value);
GeneratedParser.Definition = new WhitespaceRuleParser(GeneratedParser.Definition, rule);
}
if (matchWhitespace && !ignoreWhitespace)
{
GeneratedParser.Definition = GeneratedParser.Definition.MatchWhitespace;
}
else if (ignoreWhitespace && !matchWhitespace)
{
GeneratedParser.Definition = GeneratedParser.Definition.IgnoreWhitespace;
}
return(GeneratedParser);
}
public Parser Generate(string rootParserName = null)
{
if (rootParserName == null)
{
return(ParserGenerationContext.Generate(Rules));
}
var root = Rules.FirstOrDefault(x => x.Identifier == rootParserName);
if (root == null)
{
throw new ArgumentException("No rule found with the given name.", "rootParserName");
}
return(ParserGenerationContext.Generate(new[] { root }.Concat(Rules.Where(x => x != root)).ToArray()));
}
public static Parser Generate(params Rule[] rules)
{
if (rules.Length == 0)
{
return(Parser.Null("No rules specified"));
}
var ctx = new ParserGenerationContext();
ctx.AddRules(rules);
var result = rules.First().Generate(ctx);
if (ctx._errors.Any())
{
throw new ParserGenerationException(ctx._errors.ToArray());
}
return(result);
}
public Parser Generate(ParserGenerationContext ctx)
{
if (Defined)
{
return(GeneratedParser);
}
Defined = true;
GeneratedParser.Definition = Expression.Generate(ctx);
var matchWhitespace = Options.Contains("match-whitespace");
var ignoreWhitespace = Options.Contains("skip-whitespace");
if (matchWhitespace && !ignoreWhitespace)
{
GeneratedParser.Definition = GeneratedParser.Definition.MatchWhitespace;
}
else if (ignoreWhitespace && !matchWhitespace)
{
GeneratedParser.Definition = GeneratedParser.Definition.IgnoreWhitespace;
}
return(GeneratedParser);
}
public override Parser Generate(ParserGenerationContext ctx)
{
return base.Generate(ctx).Repeated;
}
public static Parser Generate(params Rule[] rules)
{
if (rules.Length == 0) {
return Parser.Null("No rules specified");
}
var ctx = new ParserGenerationContext();
ctx.AddRules(rules);
var result = rules.First().Generate(ctx);
if (ctx._errors.Any()) {
throw new ParserGenerationException(ctx._errors.ToArray());
}
return result;
}
public override Parser Generate(ParserGenerationContext ctx)
{
return Value;
}
public override Parser Generate(ParserGenerationContext ctx)
{
return Expression.Generate(ctx);
}
public Parser Generate(ParserGenerationContext ctx)
{
return Alternation.Generate(ctx);
}
public abstract Parser Generate(ParserGenerationContext ctx);
public Parser Generate(ParserGenerationContext ctx)
{
return(Parser.Concat(Factors.Select(x => x.Generate(ctx)).ToArray()));
}
public Parser Generate(ParserGenerationContext ctx)
{
return(Parser.Alternation(Concatenations.Select(x => x.Generate(ctx)).ToArray()));
}
public Parser Generate(ParserGenerationContext ctx)
{
return(Alternation.Generate(ctx));
}
public Parser Generate(ParserGenerationContext ctx)
{
return Parser.Alternation(Concatenations.Select(x => x.Generate(ctx)).ToArray());
}
public override Parser Generate(ParserGenerationContext ctx)
{
return(ctx.GetRule(this, Value));
}
public Parser Generate(ParserGenerationContext ctx)
{
return Parser.Concat(Factors.Select(x => x.Generate(ctx)).ToArray());
}
public override Parser Generate(ParserGenerationContext ctx)
{
return(Value);
}
public abstract Parser Generate(ParserGenerationContext ctx);
public override Parser Generate(ParserGenerationContext ctx)
{
return(Regex);
}
public override Parser Generate(ParserGenerationContext ctx)
{
return ctx.GetRule(this, Value);
}
public override Parser Generate(ParserGenerationContext ctx)
{
return(Expression.Generate(ctx));
}
public override Parser Generate(ParserGenerationContext ctx)
{
return base.Generate(ctx).Optional;
}
public override Parser Generate(ParserGenerationContext ctx)
{
return(base.Generate(ctx).Optional);
}
public override Parser Generate(ParserGenerationContext ctx)
{
return Regex;
}
public override Parser Generate(ParserGenerationContext ctx)
{
return(base.Generate(ctx).Repeated);
}
public Parser Generate(ParserGenerationContext ctx)
{
if (Defined) return GeneratedParser;
Defined = true;
GeneratedParser.Definition = Expression.Generate(ctx);
var matchWhitespace = Options.Contains("match-whitespace");
var ignoreWhitespace = Options.Contains("skip-whitespace");
if (matchWhitespace && !ignoreWhitespace) {
GeneratedParser.Definition = GeneratedParser.Definition.MatchWhitespace;
} else if (ignoreWhitespace && !matchWhitespace) {
GeneratedParser.Definition = GeneratedParser.Definition.IgnoreWhitespace;
}
return GeneratedParser;
}
public Parser Generate(ParserGenerationContext ctx)
{
if (Defined) return GeneratedParser;
Defined = true;
GeneratedParser.Definition = Expression.Generate(ctx);
var matchWhitespace = Options.Any(x => x.Option == "match-whitespace");
var ignoreWhitespace = Options.Any(x => x.Option == "skip-whitespace");
foreach (var option in Options.Where(x => x.Option == "whitespace-rule"))
{
var arg = option.Args.First();
var rule = ctx.GetRule(arg, ((Identifier) arg).Value);
GeneratedParser.Definition = new WhitespaceRuleParser(GeneratedParser.Definition, rule);
}
if (matchWhitespace && !ignoreWhitespace) {
GeneratedParser.Definition = GeneratedParser.Definition.MatchWhitespace;
} else if (ignoreWhitespace && !matchWhitespace) {
GeneratedParser.Definition = GeneratedParser.Definition.IgnoreWhitespace;
}
return GeneratedParser;
}
