/// <summary>Create the parser to read grammar definition</summary>
/// <exclude/>
private static void CreateMetaParser()
{
if (_instance != null)
{
return;
}
int step = 1;
TextBuffer buffer = new FlatBuffer(MetaParser.SoftMetaGrammarAndSettings);
CodeDocument metaGrammarDoc = null;
try
{
// Hard coded parser
Parser hardcodeParser = GetHardCodeParser(buffer.Status);
if (buffer.Status.Error == null)
{
step = 2;
// Use hard coded grammar to read meta grammar.
metaGrammarDoc = hardcodeParser.ParseString(buffer);
string gg = metaGrammarDoc.ToMarkup();
step = 3;
}
if (buffer.Status.Error == null)
{
_instance = new Parser()
{
Level = 2
};
ParserBuilder.BuildRules(_instance, metaGrammarDoc, buffer.Status);
}
}
catch (Exception e)
{
// if an exception occurs under parsing MetaGrammar it is an HardGrammar error
var e2 = new ParserException((step <= 2 ? HardGrammar_ : MetaGrammar_) + " " + e.Message);
if (e is ParserException)
{
e2.AllErrors = ((ParserException)e).AllErrors;
}
throw e2;
}
if (buffer.Status.Error != null)
{
// if an proces-error occurs under parsing MetaGrammar it is an MetaGrammar error
var e2 = new ParserException((step == 1 ? HardGrammar_ : MetaGrammar_) + " " + buffer.Status.Error.Message);
e2.AllErrors = buffer.Status.AllErrors;
throw e2;
}
}
internal static Parser GetHardCodeParser(ParserStatus status)
{
List <Rule> list = new List <Rule>();
// Build Parser in code.
// grammar = {rule} [settings];
list.Add(new Rule(MetaGrammar_,
new Sequence(new RuleLink(Rule_______)),
new Optional(new RuleLink(Settings___)))
{
Comment = true
});
// rule = identifier '=' expression ';'
list.Add(new Rule(Rule_______,
new WordIdent(),
new WordSymbol("="),
new RuleLink(Expression_),
new WordSymbol(";")));
// expression = element {[or] element};
list.Add(new Rule(Expression_,
new RuleLink(Element____),
new Sequence(
new Optional(
new RuleLink(Or_________)),
new RuleLink(Element____)))
{
Collapse = true
});
// element = identifier | symbol | block;
list.Add(new Rule(Element____,
new Or(new WordIdent(),
new Or(new RuleLink(WordSymbol_),
new RuleLink(Block______))))
{
Collapse = true
});
// block = sequence | optional | parentheses;
list.Add(new Rule(Block______,
new Or(new RuleLink(Sequence___),
new Or(new RuleLink(Optional___),
new RuleLink(Parentheses))))
{
Collapse = true
});
// sequence = '{' expression '}';
list.Add(new Rule(Sequence___,
new WordSymbol("{"),
new RuleLink(Expression_),
new WordSymbol("}")));
// optional = '[' expression ']';
list.Add(new Rule(Optional___,
new WordSymbol("["),
new RuleLink(Expression_),
new WordSymbol("]")));
// parentheses = '(' expression ')';
list.Add(new Rule(Parentheses,
new WordSymbol("("),
new RuleLink(Expression_),
new WordSymbol(")")));
// or = '|';
list.Add(new Rule(Or_________,
new WordSymbol("|")));
// symbol = string;
list.Add(new Rule(WordSymbol_,
new WordString()));
// settings > 'settings' {setter};
list.Add(new Rule(Settings___,
new WordSymbol(Settings___),
new Sequence(
new RuleLink(Setter_____)))
{
Collapse = true
});
// setter > identifier assignment {',' assignment} ';';
list.Add(new Rule("setter",
new WordIdent(),
new RuleLink(Assignment_),
new Sequence(
new WordSymbol(","),
new RuleLink(Assignment_)),
new WordSymbol(";")));
// assignment > property '=' value;
list.Add(new Rule(Assignment_,
new RuleLink(Property___),
new Optional(
new WordSymbol("="),
new RuleLink(Value______))));
// property > identifier;
list.Add(new Rule(Property___,
new WordIdent()));
// value > string;";
list.Add(new Rule(Value______,
new WordString()));
Parser parser = new Parser()
{
Level = 1
}; // { Name = HardGrammar_ };
parser.Rules = list;
//foreach (var eq in list) eq.Parser = parser;
ParserBuilder.InitializeGrammar(parser, parser.Rules, status);
return(parser);
}
