public IGrammar Generate(EbnfDefinition ebnf)
{
var grammarModel = new GrammarModel();
Definition(ebnf, grammarModel);
return(grammarModel.ToGrammar());
}
public void GrammarModelToGrammarShouldCreateGrammar()
{
var grammarModel = new GrammarModel();
var S = new ProductionModel("S");
var A = new ProductionModel("A");
var B = new ProductionModel("B");
var a = new StringLiteralLexerRule("a");
var b = new StringLiteralLexerRule("b");
var space = new StringLiteralLexerRule(" ");
S.AddWithAnd(A.LeftHandSide);
S.AddWithAnd(B.LeftHandSide);
S.AddWithOr(B.LeftHandSide);
A.AddWithAnd(new LexerRuleModel(a));
B.AddWithAnd(new LexerRuleModel(b));
grammarModel.Productions.Add(S);
grammarModel.Productions.Add(A);
grammarModel.Productions.Add(B);
grammarModel.IgnoreRules.Add(new LexerRuleModel(space));
grammarModel.Start = S;
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(4, grammar.Productions.Count);
Assert.AreEqual(1, grammar.Ignores.Count);
}
public void GrammarModelToGrammarShouldCreateGrammar()
{
var grammarModel = new GrammarModel();
var S = ProductionModel.From("S");
var A = ProductionModel.From("A");
var B = ProductionModel.From("B");
var a = new StringLiteralLexerRule("a");
var b = new StringLiteralLexerRule("b");
var space = new StringLiteralLexerRule(" ");
S.AddWithAnd(A.LeftHandSide);
S.AddWithAnd(B.LeftHandSide);
S.AddWithOr(B.LeftHandSide);
A.AddWithAnd(new LexerRuleModel(a));
B.AddWithAnd(new LexerRuleModel(b));
grammarModel.AddProduction(S);
grammarModel.AddProduction(A);
grammarModel.AddProduction(B);
var lexerRuleModel = new LexerRuleModel(space);
grammarModel.AddLexerRule(lexerRuleModel);
grammarModel.AddIgnoreSetting(new IgnoreSettingModel(new QualifiedName(lexerRuleModel.LexerRule.TokenName.Id)));
grammarModel.Start = S;
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(4, grammar.Productions.Count);
Assert.AreEqual(1, grammar.Ignores.Count);
}
public void GrammarModelShouldAddProductionModel()
{
var grammar = new GrammarModel();
grammar.AddProduction(ProductionModel.From(""));
Assert.AreEqual(1, grammar.ProductionModels.Count);
}
public GrammarExpression(
ProductionExpression start,
IEnumerable <ProductionExpression> productions,
IEnumerable <ILexerRule> ignore)
{
GrammarModel = new GrammarModel
{
Start = start.ProductionModel
};
if (productions != null)
{
foreach (var production in productions)
{
GrammarModel.Productions.Add(production.ProductionModel);
}
}
if (ignore != null)
{
foreach (var ignoreRule in ignore)
{
GrammarModel.IgnoreRules.Add(new LexerRuleModel(ignoreRule));
}
}
}
public void GrammarModelToGrammarShouldAddProductionWhenEmptyDefinition()
{
var S = new ProductionModel("S");
var grammarModel = new GrammarModel(S);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(1, grammar.Productions.Count);
}
public void GrammarModelShouldAddIgnoreLexerRuleModel()
{
var grammar = new GrammarModel();
grammar.IgnoreRules.Add(new LexerRuleModel {
Value = new StringLiteralLexerRule("this is a literal")
});
Assert.AreEqual(1, grammar.IgnoreRules.Count);
}
private void Definition(IEbnfDefinition definition, GrammarModel grammarModel)
{
Block(definition.Block, grammarModel);
if (definition is EbnfDefinitionConcatenation definitionConcatenation)
{
Definition(definitionConcatenation.Definition, grammarModel);
}
}
public void GrammarModelShouldAddIgnoreLexerRuleModel()
{
var grammar = new GrammarModel();
var lexerRuleModel = new LexerRuleModel(new StringLiteralLexerRule("this is a literal"));
grammar.AddIgnoreSetting(new IgnoreSettingModel(new QualifiedName("AAA")));
grammar.AddLexerRule(lexerRuleModel);
Assert.AreEqual(1, grammar.LexerRuleModels.Count);
Assert.AreEqual(1, grammar.IgnoreSettings.Count);
}
public void GrammarModelToGrammarShouldResolverProductionReferencesFromOtherGrammars()
{
var S = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns1", "S"))
};
var A = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns1", "A"))
};
S.Alterations.Add(
new AlterationModel(
new[] { A }));
A.Alterations.Add(
new AlterationModel(
new[] { new LexerRuleModel(
new StringLiteralLexerRule("a")) })
);
var ns1GrammarModel = new GrammarModel
{
Start = S
};
ns1GrammarModel.Productions.Add(S);
ns1GrammarModel.Productions.Add(A);
var ns1ProductionReferece = new ProductionReferenceModel(ns1GrammarModel.ToGrammar());
var Z = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns2", "Z"))
};
var X = new ProductionModel {
LeftHandSide = new NonTerminalModel(new FullyQualifiedName("ns2", "X"))
};
X.Alterations.Add(
new AlterationModel(
new SymbolModel[]
{
Z, ns1ProductionReferece
}));
var ns2GrammarModel = new GrammarModel
{
Start = Z
};
ns2GrammarModel.Productions.Add(Z);
ns2GrammarModel.Productions.Add(X);
var ns2Grammar = ns2GrammarModel.ToGrammar();
Assert.AreEqual(4, ns2Grammar.Productions.Count);
}
private void Definition(EbnfDefinition definition, GrammarModel grammarModel)
{
Block(definition.Block, grammarModel);
if (definition.NodeType != EbnfNodeType.EbnfDefinitionConcatenation)
{
return;
}
var definitionConcatenation = definition as EbnfDefinitionConcatenation;
Definition(definitionConcatenation.Definition, grammarModel);
}
public void GrammarModelConstructorGivenOnlyStartProductionShouldTraverseRecursiveStructureOnlyOnce()
{
var S = new ProductionModel("S");
var A = new ProductionModel("A");
S.AddWithAnd(S);
S.AddWithOr(A);
A.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("a")));
var grammarModel = new GrammarModel(S);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(3, grammar.Productions.Count);
}
void Block(EbnfBlock block, GrammarModel grammarModel)
{
switch (block.NodeType)
{
case EbnfNodeType.EbnfBlockLexerRule:
var blockLexerRule = block as EbnfBlockLexerRule;
grammarModel.LexerRules.Add(LexerRule(blockLexerRule));
break;
case EbnfNodeType.EbnfBlockRule:
var blockRule = block as EbnfBlockRule;
foreach (var production in Rule(blockRule.Rule))
{
grammarModel.Productions.Add(production);
}
break;
case EbnfNodeType.EbnfBlockSetting:
var blockSetting = block as EbnfBlockSetting;
switch (blockSetting.Setting.SettingIdentifier.Value)
{
case StartProductionSettingModel.SettingKey:
grammarModel.StartSetting = StartSetting(blockSetting);
break;
case IgnoreSettingModel.SettingKey:
var ignoreSettings = IgnoreSettings(blockSetting);
for (var i = 0; i < ignoreSettings.Count; i++)
{
grammarModel.IgnoreSettings.Add(ignoreSettings[i]);
}
break;
case TriviaSettingModel.SettingKey:
var triviaSettings = TriviaSettings(blockSetting);
for (var i = 0; i < triviaSettings.Count; i++)
{
grammarModel.TriviaSettings.Add(triviaSettings[i]);
}
break;
}
break;
}
}
public void GrammarModelToGrammarShouldResolverProductionReferencesFromOtherGrammars()
{
var S = ProductionModel.From(new QualifiedName("ns1", "S"));
var A = ProductionModel.From(new QualifiedName("ns1", "A"));
S.Alterations.Add(
new AlterationModel(
new[] { A }));
A.Alterations.Add(
new AlterationModel(
new[] { new LexerRuleModel(
new StringLiteralLexerRule("a")) })
);
var ns1GrammarModel = new GrammarModel
{
Start = S
};
ns1GrammarModel.AddProduction(S);
ns1GrammarModel.AddProduction(A);
var ns1ProductionReference = new GrammarReferenceModel(ns1GrammarModel.ToGrammar());
var Z = ProductionModel.From(new QualifiedName("ns2", "Z"));
var X = ProductionModel.From(new QualifiedName("ns2", "X"));
X.Alterations.Add(
new AlterationModel(
new SymbolModel[]
{
Z, ns1ProductionReference
}));
var ns2GrammarModel = new GrammarModel
{
Start = Z
};
ns2GrammarModel.AddProduction(Z);
ns2GrammarModel.AddProduction(X);
var ns2Grammar = ns2GrammarModel.ToGrammar();
Assert.AreEqual(4, ns2Grammar.Productions.Count);
}
public void GrammarModelConstructorGivenOnlyStartProductionShouldDiscoverLinkedProductions()
{
var S = new ProductionModel("S");
var A = new ProductionModel("A");
var B = new ProductionModel("B");
var C = new ProductionModel("C");
S.AddWithAnd(A);
A.AddWithAnd(B);
A.AddWithOr(C);
B.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("b")));
C.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("c")));
var grammarModel = new GrammarModel(S);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(5, grammar.Productions.Count);
}
void Block(EbnfBlock block, GrammarModel grammarModel)
{
switch (block.NodeType)
{
case EbnfNodeType.EbnfBlockLexerRule:
break;
case EbnfNodeType.EbnfBlockRule:
var blockRule = block as EbnfBlockRule;
foreach (var production in Rule(blockRule.Rule))
{
grammarModel.Productions.Add(production);
}
break;
case EbnfNodeType.EbnfBlockSetting:
break;
}
}
private void Block(IEbnfBlock block, GrammarModel grammarModel)
{
switch (block)
{
case EbnfBlockLexerRule blockLexerRule:
grammarModel.AddLexerRule(LexerRule(blockLexerRule));
break;
case EbnfBlockRule blockRule:
foreach (var production in Rule(blockRule.Rule))
{
grammarModel.AddProduction(production);
}
break;
case EbnfBlockSetting blockSetting:
switch (blockSetting.Setting.SettingIdentifier.Value)
{
case StartProductionSettingModel.SettingKey:
grammarModel.StartSetting = StartSetting(blockSetting);
break;
case IgnoreSettingModel.SettingKey:
grammarModel.AddIgnoreSetting(IgnoreSetting(blockSetting));
break;
case TriviaSettingModel.SettingKey:
grammarModel.AddTriviaSetting(TriviaSetting(blockSetting));
break;
default:
throw new NotImplementedException($"invalid setting `{blockSetting.Setting.SettingIdentifier}´" +
$" with value `{blockSetting.Setting.Identifier}´");
}
break;
default:
throw new NotImplementedException();
}
}
private static void writeGrammar(FixtureModel model, TextWriter writer, GrammarModel grammar, bool inParagraph)
{
if (inParagraph)
{
writer.WriteLine($"* {grammar.TitleOrFormat()}");
}
else
{
writer.WriteLine($"## {grammar.key}");
writer.WriteLine($"### {grammar.TitleOrFormat()}");
}
if (grammar is Sentence)
{
writeSentence((Sentence)grammar, writer);
}
if (grammar is Table)
{
writeTable((Table)grammar, writer);
}
if (grammar is EmbeddedSection)
{
writeEmbed((EmbeddedSection)grammar, writer);
}
if (grammar is Paragraph)
{
writeParagraph(grammar.As <Paragraph>(), model, writer);
}
if (!inParagraph)
{
writer.WriteLine();
writer.WriteLine();
}
}
private static void writeGrammar(FixtureModel model, TextWriter writer, GrammarModel grammar, bool inParagraph)
{
if (inParagraph)
{
writer.WriteLine($"* {grammar.TitleOrFormat()}");
}
else
{
writer.WriteLine($"## {grammar.key}");
writer.WriteLine($"### {grammar.TitleOrFormat()}");
}
if (grammar is Sentence)
{
writeSentence((Sentence) grammar, writer);
}
if (grammar is Table)
{
writeTable((Table) grammar, writer);
}
if (grammar is EmbeddedSection)
{
writeEmbed((EmbeddedSection) grammar, writer);
}
if (grammar is Paragraph)
{
writeParagraph(grammar.As<Paragraph>(), model, writer);
}
if (!inParagraph)
{
writer.WriteLine();
writer.WriteLine();
}
}
private void Initialize(ProductionExpression start, IReadOnlyList <ProductionExpression> productions, IReadOnlyList <LexerRuleModel> ignore, IReadOnlyList <LexerRuleModel> trivia)
{
GrammarModel = new GrammarModel
{
Start = start.ProductionModel
};
if (productions != null)
{
for (var p = 0; p < productions.Count; p++)
{
GrammarModel.Productions.Add(productions[p].ProductionModel);
}
}
if (ignore != null)
{
for (var i = 0; i < ignore.Count; i++)
{
var ignoreRule = ignore[i];
GrammarModel.IgnoreSettings.Add(
new IgnoreSettingModel(ignoreRule));
GrammarModel.LexerRules.Add(
ignoreRule);
}
}
if (trivia != null)
{
for (var t = 0; t < trivia.Count; t++)
{
var triviaRule = trivia[t];
GrammarModel.TriviaSettings.Add(
new TriviaSettingModel(triviaRule));
GrammarModel.LexerRules.Add(
triviaRule);
}
}
}
private void Initialize(ProductionExpression start, IReadOnlyList <ProductionExpression> productions, IReadOnlyList <LexerRuleModel> ignore, IReadOnlyList <LexerRuleModel> trivia)
{
GrammarModel = new GrammarModel
{
Start = start.ProductionModel
};
if (productions != null)
{
foreach (var production in productions)
{
GrammarModel.Productions.Add(production.ProductionModel);
}
}
if (ignore != null)
{
foreach (var ignoreRule in ignore)
{
GrammarModel.IgnoreSettings.Add(
new IgnoreSettingModel(ignoreRule));
GrammarModel.LexerRules.Add(
ignoreRule);
}
}
if (trivia != null)
{
foreach (var triviaRule in trivia)
{
GrammarModel.TriviaSettings.Add(
new TriviaSettingModel(triviaRule));
GrammarModel.LexerRules.Add(
triviaRule);
}
}
}
public void GrammarModelGivenNullStartShouldResolveStartFromProductions()
{
var S = new ProductionModel("S");
var A = new ProductionModel("A");
var B = new ProductionModel("B");
S.AddWithAnd(A);
S.AddWithAnd(B);
A.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("a")));
A.AddWithAnd(B);
B.AddWithAnd(new LexerRuleModel(new StringLiteralLexerRule("b")));
var grammarModel = new GrammarModel();
grammarModel.Productions.Add(S);
grammarModel.Productions.Add(A);
grammarModel.Productions.Add(B);
var grammar = grammarModel.ToGrammar();
Assert.AreEqual(3, grammar.Productions.Count);
Assert.IsNotNull(grammar.Start);
}
private void Initialize(ProductionExpression start,
IReadOnlyList <ProductionExpression> productions,
IReadOnlyList <LexerRuleModel> ignore,
IReadOnlyList <LexerRuleModel> trivia)
{
GrammarModel = new GrammarModel
{
Start = start.ProductionModel
};
if (productions != null)
{
foreach (var production in productions)
{
GrammarModel.AddProduction(production.ProductionModel);
}
}
if (ignore != null)
{
foreach (var ignoreRule in ignore)
{
GrammarModel.AddIgnoreSetting(new IgnoreSettingModel(new QualifiedName(ignoreRule.LexerRule.TokenName.Id)));
GrammarModel.AddLexerRule(ignoreRule);
}
}
if (trivia != null)
{
foreach (var triviaRule in trivia)
{
GrammarModel.AddTriviaSetting(new TriviaSettingModel(new QualifiedName(triviaRule.LexerRule.TokenName.Id)));
GrammarModel.AddLexerRule(triviaRule);
}
}
}
public TextGenerator(GrammarDefinitionReader reader)
{
reader.ReadGrammar();
_grammar = reader.Grammar;
}
