public void ParseRunnerShouldHandleCleanupOfUnUsedIgnoreLexemes()
{
var ebnfGrammar = new EbnfGrammar();
var parseEngine = new ParseEngine(ebnfGrammar);
var stringBuilder = new StringBuilder()
.AppendLine("ws = [ ows ] ; /* white space */")
.AppendLine("ows = \"_\" ; /* obligatory white space */");
RunParse(parseEngine, stringBuilder.ToString());
var chart = parseEngine.Chart;
Assert.IsTrue(chart.Count > 7);
var seventhSet = chart[7];
Assert.IsNotNull(seventhSet);
Assert.AreEqual(1, seventhSet.Completions.Count);
var onlyCompletion = seventhSet.Completions[0];
Assert.IsNotNull(onlyCompletion);
var parseNode = onlyCompletion.ParseNode as IInternalForestNode;
Assert.IsNotNull(parseNode);
var parseNodeAndNode = parseNode.Children[0];
var tokenParseNode = parseNodeAndNode.First as ITokenForestNode;
Assert.IsNotNull(tokenParseNode);
var token = tokenParseNode.Token;
Assert.AreEqual(EbnfGrammar.TokenClasses.Identifier, token.TokenName);
Assert.AreEqual("ows", token.Value);
}
public void Simple()
{
var grammarString = @"
ws := {? Terminals.WhiteSpace ?};
letter or digit := ? Terminals.LetterOrDigit ?;
simple value := letter or digit, {letter or digit};
bracket value = simple value, {simple value};
optional bracket = '(', bracket value, ')' | simple value;
first = optional bracket;
second = optional bracket;
grammar = ws, first, second, ws;
";
var input = " hello ( parsing world ) ";
// our grammar
var grammar = new EbnfGrammar(EbnfStyle.Iso14977).Build(grammarString, "grammar");
var match = grammar.Match(input);
Assert.True(match.Success, match.ErrorMessage);
Assert.Equal("hello", match["first"]["simple value", true].Text);
Assert.Equal("parsing world", match["second"]["bracket value", true].Text);
}
public void EbnfParserShouldParseComplexGrammarWithRepeat()
{
var stringBuilder = new StringBuilder()
//.AppendLine("file = ws directives ws ;")
.AppendLine("file = \"1\" { \"2\" } \"1\";");
//.AppendLine("directives = directive { ows directive };")
//.AppendLine("directive = \"0\" | \"1\"; ");
var actual = Parse(stringBuilder.ToString());
var grammar = new EbnfGrammar();
var parseEngine = new ParseEngine(grammar, new ParseEngineOptions(false));
var parseRunner = new ParseRunner(parseEngine, stringBuilder.ToString());
while (!parseRunner.EndOfStream())
{
if (!parseRunner.Read())
{
throw new Exception(
$"Unable to parse Ebnf. Error at position {parseRunner.Position}.");
}
}
if (!parseEngine.IsAccepted())
{
throw new Exception(
$"Unable to parse Ebnf. Error at position {parseRunner.Position}");
}
var parseForest = parseEngine.GetParseForestRootNode();
var visitor = new LoggingForestNodeVisitor(Console.Out);
parseForest.Accept(visitor);
}
static Grammar GetIncludesGrammar()
{
if (grammarForIncludes == null)
{
var fileContent = LoadFromResource(DefaultNamespaceName, "Grammar", "IncludesGrammar1.ebnf");
EbnfStyle style = (EbnfStyle)(
(uint)EbnfStyle.Iso14977
//& ~(uint) EbnfStyle.WhitespaceSeparator
| (uint)EbnfStyle.EscapeTerminalStrings);
EbnfGrammar grammar;
try
{
grammar = new EbnfGrammar(style);
grammarForIncludes = grammar.Build(fileContent, "file");
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
/*
* System.ArgumentException: the topParser specified is not found in this ebnf
* at Eto.Parse.Grammars.EbnfGrammar.Build (System.String bnf, System.String startParserName) [0x00048] in <filename unknown>:0
* at Globals.Main (System.String[] args) [0x0002b] in /var/calculate/remote/distfiles/egit-src/SqlParser-on-EtoParse.git/test1/Program.cs:20
*/
throw;
}
}
return(grammarForIncludes);
}
public void TestEbnf()
{
var ebnfGrammar = new EbnfGrammar(EbnfStyle.Iso14977 | EbnfStyle.UseCommentRuleWithSeparator);
var myEbnf = ebnfGrammar.Build(ebnf, "syntax");
SetEbnfRules(myEbnf);
var match = myEbnf.Match(ebnf);
Assert.IsTrue(match.Success, match.ErrorMessage);
}
public void TestSqlParser()
{
const string sqlStatement = @"select * from MyTable where MyColumn = hello";
var ebnfGrammar = new EbnfGrammar(EbnfStyle.W3c | EbnfStyle.SquareBracketAsOptional | EbnfStyle.WhitespaceSeparator);
var xmlGrammar = ebnfGrammar.Build(sqlW3cEbnf, "command");
var match = xmlGrammar.Match(sqlStatement);
Assert.IsTrue(match.Success, match.ErrorMessage);
}
public void ParseRunnerShouldRunInCompleteIgnoreRulesBeforeMovingToGrammarLexerRules()
{
var ebnfGrammar = new EbnfGrammar();
var parseEngine = new ParseEngine(ebnfGrammar);
var input = @"
/* letters and digits */
letter ~ /[a-zA-Z]/;" ;
RunParse(parseEngine, input);
}
BnfGrammar Convert(EbnfGrammar EG)
{
Bnf = new BnfGrammar();
Footprint = new OperationFootprintGroup <EbnfGrammar, BnfGrammar> (EG, Bnf);
foreach (var er in EG.Rules)
{
BnfRule br = Convert(er);
}
Footprint.Parts = ops.ToArray();
return(Bnf);
}
public void EbnfToCode()
{
var ebnfGrammar = new EbnfGrammar(EbnfStyle.Iso14977 | EbnfStyle.UseCommentRuleWithSeparator);
var code = ebnfGrammar.ToCode(ebnf, "syntax", "MyEbnfGrammar");
var myEbnf = Helper.Create<Grammar>(code, "MyEbnfGrammar");
SetEbnfRules(myEbnf);
var match = myEbnf.Match(ebnf);
Assert.IsTrue(match.Success, match.ErrorMessage);
}
EbnfGrammar Convert(EbnfGrammar input)
{
Before = input;
After = new EbnfGrammar();
Footprint = new OperationFootprintGroup <EbnfGrammar, EbnfGrammar> (Before, After);
foreach (var er in Before.Rules)
{
//ProcessRuleRecursivelyAddNewRulesWhenNeeded (er);
//BnfRule br = Convert (er);
}
Footprint.Parts = ops.ToArray();
return(After);
}
public void TestXmlParser()
{
const string xmlDocument = @"<?xml version='1.0' encoding='utf-8' ?>
<body class=""blah"">
<div>some text</div>
<!-- some comment -->
</body>";
var ebnfGrammar = new EbnfGrammar(EbnfStyle.W3c & ~EbnfStyle.UseCommentRuleWithSeparator);
var xmlGrammar = ebnfGrammar.Build(xmlW3cEbnf, "document");
var match = xmlGrammar.Match(xmlDocument);
Assert.True(match.Success, match.ErrorMessage);
}
public void TestXmlParser()
{
const string xmlDocument = @"<?xml version='1.0' encoding='utf-8' ?>
<body class=""blah"">
<div>some text</div>
<!-- some comment -->
</body>";
var ebnfGrammar = new EbnfGrammar(EbnfStyle.W3c & ~EbnfStyle.UseCommentRuleWithSeparator);
var xmlGrammar = ebnfGrammar.Build(xmlW3cEbnf, "document");
// define the terminals in the grammar
xmlGrammar.SetTerminals("Letter", "BaseChar", "Ideographic", "CombiningChar", "Digit", "Extender", "PubidChar", "Char", "S", "EnumeratedType", "NameChar", "Eq");
var match = xmlGrammar.Match(xmlDocument);
Assert.IsTrue(match.Success, match.ErrorMessage);
}
/*public static void DumpAllMatches(Match m, string name)
{
for (int pos = 0; pos < m.Matches.Count; pos++)
{
Match nm = m.Matches [pos];
var full_name = nm.Name + " <- " + name;
bool low = IsTooLow (nm.Name);
if (nm.Text != m.Text) {
string fmt = "\"{0}\"" + Environment.NewLine + "\t" + "{1}";
Console.WriteLine (fmt, nm.Text, full_name);
}
if (!low) {
DumpAllMatches (nm, full_name);
}
}
}
static bool IsTooLow(string rule)
{
if (rule == "identifier") return true;
if (rule == "character_string_literal") return true;
return false;
}*/
public static void ParseWithIrony (/*string grammar_text,*/ string text_to_compile)
{
var grammar = new EbnfGrammar();
var parser = new Irony.Parsing.Parser(grammar);
var errors = parser.Language.Errors;
if (errors.Count > 0)
{
var msg = new StringBuilder("Unexpected grammar contains error(s):" + Environment.NewLine);
foreach (var e in errors) {
msg.AppendFormat ("{0}" + Environment.NewLine, e.ToString ());
}
Console.WriteLine (msg.ToString ());
throw new Exception(msg.ToString());
}
var tree = parser.Parse (text_to_compile);
Debug.Assert (tree != null); // to suppress warning and for expression evaluator
Debug.Assert (tree.Status == ParseTreeStatus.Parsed);
}
private static string GetCode(CommandLineOptions opts)
{
switch (Path.GetExtension(opts.GrammarFile))
{
case ".bnf":
var gr = new BnfGrammar();
return(gr.ToCode(File.ReadAllText(opts.GrammarFile), opts.StartParser, opts.GrammarName));
case ".ebnf":
var egr = new EbnfGrammar(EbnfStyle.W3c | EbnfStyle.SquareBracketAsOptional | EbnfStyle.WhitespaceSeparator);
return(egr.ToCode(File.ReadAllText(opts.GrammarFile), opts.StartParser, opts.GrammarName));
case ".gold":
var ggr = new GoldGrammar();
return(ggr.ToCode(File.ReadAllText(opts.GrammarFile), opts.GrammarName));
}
throw new Exception("Unknown Grammar. Try .ebnf .bnf .gold");
}
static void Main(string[] args)
{
var fileContent = LoadFromResource(nameof(rus_gramm_norm), "Grammar", "syntax2.ebnf");
EbnfStyle style = (EbnfStyle)(
(uint)EbnfStyle.Iso14977
//& ~(uint) EbnfStyle.WhitespaceSeparator
| (uint)EbnfStyle.EscapeTerminalStrings);
EbnfGrammar grammar;
Grammar parser;
try
{
grammar = new EbnfGrammar(style);
parser = grammar.Build(fileContent, nameOfTheStartingRule);
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
/*
* System.ArgumentException: the topParser specified is not found in this ebnf
* at Eto.Parse.Grammars.EbnfGrammar.Build (System.String bnf, System.String startParserName) [0x00048] in <filename unknown>:0
* at Globals.Main (System.String[] args) [0x0002b] in /var/calculate/remote/distfiles/egit-src/SqlParser-on-EtoParse.git/test1/Program.cs:20
*/
throw;
}
var originalContent = LoadFromResource(nameof(rus_gramm_norm), "Grammar", "syntax1.ebnf");
var match = parser.Match(originalContent);
if (match.Success == false)
{
Console.Out.WriteLine("No luck!");
}
else
{
DumpAllMatches(match, nameOfTheStartingRule);
}
}
static IEnumerable <ProductionDifference> CompareGrammars(EbnfGrammar authority, EbnfGrammar copy)
{
Func <EbnfGrammar, Dictionary <string, Production> > ToDictionary;
ToDictionary = g =>
{
var d = new Dictionary <string, Production>();
foreach (var pp in g.Productions)
{
if (pp.Name != null)
{
d[pp.Name] = pp;
}
}
return(d);
};
var dauthority = ToDictionary(authority);
var dcopy = ToDictionary(copy);
foreach (var p in dauthority.Keys)
{
if (!dcopy.ContainsKey(p))
{
continue;
}
Production pauthority0 = dauthority[p], pcopy0 = dcopy[p];
string pauthority = Antlr.ToString(pauthority0), pcopy = Antlr.ToString(pcopy0);
if (pauthority == pcopy)
{
continue;
}
yield return(new ProductionDifference {
productionName = p, authority = pauthority, copy = pcopy
});
}
foreach (var p in dauthority.Keys)
{
if (p == "start")
{
continue;
}
if (!dcopy.ContainsKey(p))
{
yield return(new ProductionDifference {
productionName = p, authority = "<defined>", copy = null
});
}
}
foreach (var p in dcopy.Keys)
{
if (p == "start")
{
continue;
}
if (!dauthority.ContainsKey(p))
{
yield return(new ProductionDifference {
productionName = p, authority = null, copy = "<defined>"
});
}
}
}
public ExpansionsionRun(EbnfGrammar Input)
{
After = Convert(Input);
}
public void CreateGrammarAndSource()
{
grammar = new EbnfGrammar(EbnfStyle.CharacterSets | EbnfStyle.CardinalityFlags |
EbnfStyle.WhitespaceSeparator | EbnfStyle.EscapeTerminalStrings);
source = File.ReadAllText("Strict.ebnf");
}
private MarkdownSpec(IEnumerable <Tuple <string, MarkdownDocument> > sources)
{
var grammar = new EbnfGrammar();
Sources = sources;
// (1) Add sections into the dictionary
string url = "", title = "";
// (2) Turn all the antlr code blocks into a grammar
var sbantlr = new StringBuilder();
foreach (var src in sources)
{
var reporter = new Reporter(src.Item1);
var filename = Path.GetFileName(src.Item1);
var md = src.Item2;
foreach (var mdp in md.Paragraphs)
{
reporter.CurrentParagraph = mdp;
reporter.CurrentSection = null;
if (mdp.IsHeading)
{
try
{
var sr = new SectionRef(mdp as MarkdownParagraph.Heading, filename);
if (Sections.Any(s => s.Url == sr.Url))
{
reporter.Error("MD02", $"Duplicate section title {sr.Url}");
}
else
{
Sections.Add(sr);
url = sr.Url;
title = sr.Title;
reporter.CurrentSection = sr;
}
}
catch (Exception ex)
{
reporter.Error("MD03", ex.Message); // constructor of SectionRef might throw
}
}
else if (mdp.IsCodeBlock)
{
var mdc = mdp as MarkdownParagraph.CodeBlock;
string code = mdc.code, lang = mdc.language;
if (lang != "antlr")
{
continue;
}
var g = Antlr.ReadString(code, "");
Productions.Add(new ProductionRef(code, g.Productions));
foreach (var p in g.Productions)
{
p.Link = url; p.LinkName = title;
if (p.Name != null && grammar.Productions.Any(dupe => dupe.Name == p.Name))
{
reporter.Warning("MD04", $"Duplicate grammar for {p.Name}");
}
grammar.Productions.Add(p);
}
}
}
}
}
public FromEbnfToBnf_ByCopying(EbnfGrammar EG)
{
Convert(EG);
}
public static EbnfGrammar Test3()
{
var G = new EbnfGrammar();
EbnfNonterminal N06 = new EbnfNonterminal("файл");
EbnfNonterminal N07 = new EbnfNonterminal("маркер");
EbnfNonterminal N08 = new EbnfNonterminal("гм");
EbnfNonterminal N09 = new EbnfNonterminal("обм");
EbnfNonterminal N10 = new EbnfNonterminal("ябм");
EbnfNonterminal N11 = new EbnfNonterminal("тп");
EbnfNonterminal N12 = new EbnfNonterminal("табуляция");
EbnfNonterminal N13 = new EbnfNonterminal("пробел");
EbnfNonterminal N14 = new EbnfNonterminal("новая строка");
EbnfNonterminal N15 = new EbnfNonterminal("перевод строки");
EbnfNonterminal N16 = new EbnfNonterminal("возврат каретки");
EbnfNonterminal N17 = new EbnfNonterminal("комментарий");
EbnfNonterminal N18 = new EbnfNonterminal("знак");
EbnfNonterminal N21 = new EbnfNonterminal("десятичная цифра");
EbnfNonterminal N22 = new EbnfNonterminal("буква");
EbnfNonterminal N30 = new EbnfNonterminal("знак препинания");
EbnfNonterminal N32 = new EbnfNonterminal("расширение текстореза");
EbnfNonterminal N33 = new EbnfNonterminal("двойная кавычка");
EbnfNonterminal N34 = new EbnfNonterminal("правило");
EbnfNonterminal N35 = new EbnfNonterminal("выражение");
EbnfNonterminal N36 = new EbnfNonterminal("перечисление");
EbnfNonterminal N37 = new EbnfNonterminal("выбор");
EbnfNonterminal N38 = new EbnfNonterminal("имя");
EbnfNonterminal N39 = new EbnfNonterminal("часть имени");
EbnfNonterminal N40 = new EbnfNonterminal("строка");
EbnfNonterminal N41 = new EbnfNonterminal("символ в строке");
EbnfNonterminal N42 = new EbnfNonterminal("символ из битов");
EbnfNonterminal N43 = new EbnfNonterminal("шестнадцатеричная цифра");
EbnfNonterminal N44 = new EbnfNonterminal("любой символ");
EbnfNonterminal N45 = new EbnfNonterminal("утаивание");
EbnfNonterminal N46 = new EbnfNonterminal("группировка");
EbnfNonterminal N47 = new EbnfNonterminal("повторение");
EbnfNonterminal N49 = new EbnfNonterminal("не менее");
EbnfNonterminal N50 = new EbnfNonterminal("десятичное число");
EbnfNonterminal N51 = new EbnfNonterminal("не более");
EbnfNonterminal N52 = new EbnfNonterminal("исключение");
EbnfTerminal T430 = new EbnfTerminal("а"); EbnfTerminal T410 = new EbnfTerminal("А");
EbnfTerminal T431 = new EbnfTerminal("б"); EbnfTerminal T411 = new EbnfTerminal("Б");
EbnfTerminal T432 = new EbnfTerminal("в"); EbnfTerminal T412 = new EbnfTerminal("В");
EbnfTerminal T433 = new EbnfTerminal("г"); EbnfTerminal T413 = new EbnfTerminal("Г");
EbnfTerminal T434 = new EbnfTerminal("д"); EbnfTerminal T414 = new EbnfTerminal("Д");
EbnfTerminal T435 = new EbnfTerminal("е"); EbnfTerminal T415 = new EbnfTerminal("Е");
EbnfTerminal T451 = new EbnfTerminal("ё"); EbnfTerminal T401 = new EbnfTerminal("Ё");
EbnfTerminal T436 = new EbnfTerminal("ж"); EbnfTerminal T116 = new EbnfTerminal("Ж");
EbnfTerminal T437 = new EbnfTerminal("з"); EbnfTerminal T417 = new EbnfTerminal("З");
EbnfTerminal T438 = new EbnfTerminal("и"); EbnfTerminal T418 = new EbnfTerminal("И");
EbnfTerminal T439 = new EbnfTerminal("й"); EbnfTerminal T419 = new EbnfTerminal("Й");
EbnfTerminal T43A = new EbnfTerminal("к"); EbnfTerminal T41A = new EbnfTerminal("К");
EbnfTerminal T43B = new EbnfTerminal("л"); EbnfTerminal T41B = new EbnfTerminal("Л");
EbnfTerminal T43C = new EbnfTerminal("м"); EbnfTerminal T41C = new EbnfTerminal("М");
EbnfTerminal T43D = new EbnfTerminal("н"); EbnfTerminal T41В = new EbnfTerminal("Н");
EbnfTerminal T43E = new EbnfTerminal("о"); EbnfTerminal T41E = new EbnfTerminal("О");
EbnfTerminal T43F = new EbnfTerminal("п"); EbnfTerminal T41F = new EbnfTerminal("П");
EbnfTerminal T440 = new EbnfTerminal("р"); EbnfTerminal T420 = new EbnfTerminal("Р");
EbnfTerminal T441 = new EbnfTerminal("с"); EbnfTerminal T421 = new EbnfTerminal("С");
EbnfTerminal T442 = new EbnfTerminal("т"); EbnfTerminal T422 = new EbnfTerminal("Т");
EbnfTerminal T443 = new EbnfTerminal("у"); EbnfTerminal T423 = new EbnfTerminal("У");
EbnfTerminal T444 = new EbnfTerminal("ф"); EbnfTerminal T424 = new EbnfTerminal("Ф");
EbnfTerminal T445 = new EbnfTerminal("х"); EbnfTerminal T425 = new EbnfTerminal("Х");
EbnfTerminal T446 = new EbnfTerminal("ц"); EbnfTerminal T426 = new EbnfTerminal("Ц");
EbnfTerminal T447 = new EbnfTerminal("ч"); EbnfTerminal T427 = new EbnfTerminal("Ч");
EbnfTerminal T448 = new EbnfTerminal("ш"); EbnfTerminal T428 = new EbnfTerminal("Ш");
EbnfTerminal T449 = new EbnfTerminal("щ"); EbnfTerminal T429 = new EbnfTerminal("Щ");
EbnfTerminal T44A = new EbnfTerminal("ъ"); EbnfTerminal T42A = new EbnfTerminal("Ъ");
EbnfTerminal T44B = new EbnfTerminal("ы"); EbnfTerminal T42B = new EbnfTerminal("Ы");
EbnfTerminal T44C = new EbnfTerminal("ь"); EbnfTerminal T42C = new EbnfTerminal("Ь");
EbnfTerminal T44D = new EbnfTerminal("э"); EbnfTerminal T42D = new EbnfTerminal("Э");
EbnfTerminal T44E = new EbnfTerminal("ю"); EbnfTerminal T42E = new EbnfTerminal("Ю");
EbnfTerminal T44F = new EbnfTerminal("я"); EbnfTerminal T42А = new EbnfTerminal("Я");
EbnfTerminal T030 = new EbnfTerminal("0"); EbnfTerminal T031 = new EbnfTerminal("1");
EbnfTerminal T032 = new EbnfTerminal("2"); EbnfTerminal T033 = new EbnfTerminal("3");
EbnfTerminal T034 = new EbnfTerminal("4"); EbnfTerminal T035 = new EbnfTerminal("5");
EbnfTerminal T036 = new EbnfTerminal("6"); EbnfTerminal T037 = new EbnfTerminal("7");
EbnfTerminal T038 = new EbnfTerminal("8"); EbnfTerminal T039 = new EbnfTerminal("9");
EbnfTerminal T03D = new EbnfTerminal("=");
EbnfTerminal T03A = new EbnfTerminal(":");
EbnfTerminal T028 = new EbnfTerminal("("); EbnfTerminal T029 = new EbnfTerminal(")");
EbnfTerminal T05B = new EbnfTerminal("["); EbnfTerminal T05D = new EbnfTerminal("]");
EbnfTerminal T07B = new EbnfTerminal("{"); EbnfTerminal T07D = new EbnfTerminal("}");
EbnfTerminal T03B = new EbnfTerminal(";");
EbnfTerminal T03F = new EbnfTerminal("?");
EbnfTerminal T02E = new EbnfTerminal("."); EbnfTerminal T02C = new EbnfTerminal(",");
EbnfTerminal T02A = new EbnfTerminal("*"); EbnfTerminal T02D = new EbnfTerminal("-");
var R07 = new EbnfRule(N07, new EbnfEnumeration(new IEbnfEnumerationPart [] {
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T414, T415 })),
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T411, T411 })),
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T411, T415 }))
}));
var R12 = new EbnfRule(N12,
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T030, T037 }))
);
var R13 = new EbnfRule(N13,
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T032, T030 }))
);
var R15 = new EbnfRule(N15,
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T030, T410 }))
);
var R16 = new EbnfRule(N16,
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T030, T411 }))
);
var R21 = new EbnfRule(N21, new EbnfEnumeration(new IEbnfEnumerationPart [] {
T030, T031, T032, T033, T034, T035, T036, T037, T038, T039
}));
var R22 = new EbnfRule(N22, new EbnfExpression(new IEbnfExpressionPart [] {
T430, T410, T431, T411, T432, T412, T433, T413, T434, T414, T435, T415, T451, T401,
T436, T116, T437, T417, T438, T418, T439, T419, T43A, T41A, T43B, T41B, T43C, T41C,
T43D, T41В, T43E, T41E, T43F, T41F, T440, T420, T441, T421, T442, T422, T443, T423,
T444, T424, T445, T425, T446, T426, T447, T427, T448, T428, T449, T429, T44A, T42A,
T44B, T42B, T44C, T42C, T44D, T42D, T44E, T42E, T44F, T42А
}));
var R33 = new EbnfRule(N33,
CreateTerminalFromBits(new EbnfEnumeration(new IEbnfEnumerationPart [] { T030, T448, T032, T032 }))
);
var R30 = new EbnfRule(N30, new EbnfExpression(new IEbnfExpressionPart [] {
T02D, T03B, T03D, T02C, T02A, T05B, T05D, T07B, T07D, T028, T029, T03F, T02E, R33.Nonterminal
}));
G.Add(R07);
G.Add(R12);
G.Add(R13);
G.Add(R15);
G.Add(R16);
G.Add(R21);
G.Add(R22);
G.Add(R30);
G.Add(R33);
return(G);
}
