public void Compile_WhenTheGrammarContainsAnAndExpression_TheTypeOfTheAndExpressionReflectsTheInnerExpression(string type)
{
var grammar = new PegParser().Parse("a = x:&(<" + type + "> 'OK' { null })");
var compiled = PegCompiler.Compile(grammar);
Assert.That(compiled.ExpressionTypes[grammar.Rules.Single().Expression].ToString(), Is.EqualTo(type));
}
public void Compile_WhenGivenAGrammarWithARuleWithAnImmediateTypedExpression_DoesNotThrowAnExceptionOrReturnErrors()
{
var grammar = new PegParser().Parse("top = item:(<string> 'a' 'b') {item}");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_ForAllFoundTutorials_Succeeds(Tutorial tutorial)
{
var grammar = new PegParser().Parse(tutorial.GrammarText);
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_WhenGivenAGrammarWithUnusedRules_YieldsNoErrors()
{
var grammar = new PegParser().Parse("i = 'OK'; unused = '';");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty);
}
public void Compile_WhenTheGrammarHasAnErrorExpressionInTheMiddleOfASequenceWrappedInParentheses_ThrowsException()
{
var grammar = new PegParser().Parse("a = 'OK' (#error{ \"OK\" }) 'OK'");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(() => parser.Parse("OK"), Throws.InstanceOf <FormatException>().With.Message.EqualTo("OK"));
}
public void Compile_WithRulesOnlyUsedByExportOrPublic_YieldsNone()
{
var grammar = new PegParser().Parse("start = 'OK'; B -export = 'OK'; C -public = 'OK';");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_WhenTheGrammarRepeatsAZeroWidthExpressionWithSameMinAndMax_YieldsNone()
{
var grammar = new PegParser().Parse("a = ''<5>");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_WhenErrorExpressionIsRepeated_YieldsNoErrors()
{
var grammar = new PegParser().Parse("a = (#error{ \"\" })*");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty);
}
public void Compile_WhenAZeroLengthProductionIsRepeatedWithADelimiter_YieldsNoErrors()
{
var grammar = new PegParser().Parse("start = ''<0,,'OK'>");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty);
}
public void Parse_WhenZeroWidthRepetitionIsBlockedByAssertions_YieldsNoErrors(string grammarText)
{
var grammar = new PegParser().Parse(grammarText);
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors.Where(e => !e.IsWarning).Select(e => e.ErrorText), Is.Empty);
}
public void Compile_WhenARuleContainsAStateExpressionAsPartOfASequenceThatEndsWithACodeExpression_IncludesTheContentOfTheCodeExpression()
{
var grammar = new PegParser().Parse("foo = #{OK;} a:'OK' {TEST};");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Code, Contains.Substring("TEST"));
}
public void Compile_WithRulesOnlyUsedByExportOrPublic_YieldsNone(string flag)
{
var grammar = new PegParser().Parse($"other = 'OK'; A {flag} = other;");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_WithSingleSimpleRule_Succeeds()
{
var grammar = new PegParser().Parse("start = 'OK'");
var result = PegCompiler.Compile(grammar);
Assert.That(result.Errors, Is.Empty);
}
public void Compile_WhenTheGrammarContainsANotCodeExpression_ExecutesExpression()
{
var grammar = new PegParser().Parse("a = !{false} 'OK'");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse("OK"), Is.EqualTo("OK"));
}
public void Compile_WhenEmptyParensAreIncluded_CompilesCorrectly()
{
var grammar = new PegParser().Parse("a = () b; b = 'OK';");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse("OK"), Is.EqualTo("OK"));
}
public void Parse_WhenARepetitionDelimiterFollowsTheRepeatedRule_DoesNotConsumeTheDelimiter()
{
var grammar = new PegParser().Parse("start = ' ' 'hoge'<1,,' '> ' ';");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse(" hoge "), Is.EqualTo(" hoge "));
}
public void Compile_WhenTheGrammarContainsAParseExpression_ExecutesTheParseExpression()
{
var grammar = new PegParser().Parse("a = #parse{ this.ReturnHelper<string>(state, ref state, _ => \"OK\") };");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse(string.Empty), Is.EqualTo("OK"));
}
public void Compile_WhenRuleNameIsAReservedWord_CompilesCorrectly(string grammarText)
{
var grammar = new PegParser().Parse(grammarText);
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse("OK"), Is.EqualTo("OK"));
}
public void Compile_WhenTheGrammarContainsAnAndExpression_ExecutesExpression()
{
var grammar = new PegParser().Parse("a = &other 'OK'; other <int> = 'OK' { 0 }");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse("OK"), Is.EqualTo("OK"));
}
public void Compile_WithStartRule_ProducesCorrectParser()
{
var grammar = new PegParser().Parse("@start b; a = #error{ \"wrong start rule\" }; b = 'OK';");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse("OK"), Is.EqualTo("OK"));
}
public void Compile_WithSimpleLeftRecursion_ProducesCorrectParser()
{
var grammar = new PegParser().Parse("a <int> -memoize = a:a '+' b:b { a + b } / b; b <int> = c:[0-9] { int.Parse(c) };");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <int>(compiled);
Assert.That(parser.Parse("1+3"), Is.EqualTo(4));
}
public void Compile_WithCaseSensitivityCombinations_ProducesCorrectParser(string subject, string match, string unmatch)
{
var grammar = new PegParser().Parse(subject);
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
Assert.That(parser.Parse(match), Is.EqualTo(match));
Assert.That(() => parser.Parse(unmatch), Throws.Exception);
}
public void Compile_Performance_PegGrammar()
{
var pegGrammar = new PegParser().Parse(File.ReadAllText("PegParser.peg"));
Evaluate(() =>
{
PegCompiler.Compile(pegGrammar);
});
}
// Load and start the catalog
void Start()
{
Logger.WriteLine(2, ">Gateway: Start");
_catalog = Catalog.Create();
_catalog.LoadFlag = true;
_catalog.ExecuteFlag = true;
_catalog.SetConfig(_settings);
_catalog.Start(_database);
_parser = PegCompiler.Create(_catalog);
}
public void Compile_WhenRepetitionExpressionContainsDelimiterButRepetitionIsLimitedToOne_YieldsWarning()
{
var grammar = new PegParser().Parse("a = 'foo'<0,1,','>");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0024"));
}
public void Parse_WhenLeftRecursiveRulesAreNested_YieldsErrors()
{
var grammar = new PegParser().Parse("exp -memoize = dot / call / name; dot -memoize = exp '.' name; call -memoize = exp '(' ')'; name = '' [a-z]+;");
var result = PegCompiler.Compile(grammar);
var errorNumber = result.Errors.Select(e => e.ErrorNumber).Distinct().Single();
Assert.That(errorNumber, Is.EqualTo("PEG0023"));
}
public void Compile_WhenTheResultOfAnAndExpressionIsReturned_ReturnsTheResultOfTheAndExpression([Range(0, 9)] int value)
{
var grammar = new PegParser().Parse("a <int> = x:&(<int> d:. { int.Parse(d) }) { x }");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <int>(compiled);
var result = parser.Parse(value.ToString());
Assert.That(result, Is.EqualTo(value));
}
public void Compile_WhenAZeroLengthProductionIsRepeated_YieldsError(string grammarText)
{
var grammar = new PegParser().Parse(grammarText);
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Where(e => !e.IsWarning).Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0021"));
}
public void Compile_WhenGivenAGrammarWithAnInvalidAccessibilitySetting_YieldsError(string settingName, string value)
{
var grammar = new PegParser().Parse("@" + settingName + " {" + value + "}; a = 'OK';");
var result = PegCompiler.Compile(grammar);
var error = result.Errors.Single();
Assert.That(error.ErrorNumber, Is.EqualTo("PEG0012"));
}
public void Compile_WhenTheGrammarHasACodeAssertion_RespectsTheReturnValueOfTheExpression(bool expression, string assertion, string expected)
{
var grammar = new PegParser().Parse($"a = 'OK' {assertion}{{ {expression.ToString().ToLower()} }} / ;");
var compiled = PegCompiler.Compile(grammar);
var parser = CodeCompiler.Compile <string>(compiled);
var result = parser.Parse("OK");
Assert.That(result, Is.EqualTo(expected));
}
