public ASLGrammar()
: base(true)
{
var string_lit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(single_line_comment);
NonGrammarTerminals.Add(delimited_comment);
var state = new KeyTerm("state", "state");
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var state_def = new NonTerminal("stateDef");
var version = new NonTerminal("version");
var state_list = new NonTerminal("stateList");
var method_list = new NonTerminal("methodList");
var var_list = new NonTerminal("varList");
var var = new NonTerminal("var");
var module = new NonTerminal("module");
var method = new NonTerminal("method");
var offset_list = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var method_type = new NonTerminal("methodType");
root.Rule = state_list + method_list;
version.Rule = (comma + string_lit) | Empty;
state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}";
state_list.Rule = MakeStarRule(state_list, state_def);
method_list.Rule = MakeStarRule(method_list, method);
var_list.Rule = MakeStarRule(var_list, semi, var);
module.Rule = (string_lit + comma) | Empty;
var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty;
method.Rule = (method_type + "{" + code + "}") | Empty;
offset_list.Rule = MakePlusRule(offset_list, comma, offset);
offset.Rule = number;
method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown;
Root = root;
MarkTransient(var_list, method_list, offset, method_type);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
private KeyTerm RegisterTerm(string text, string name = null)
{
KeyTerm kt = ToTerm(text);
kt.SetFlag(TermFlags.IsReservedWord);
RegisteredTerms.Add(kt);
return(kt);
}
protected override NonTerminal MakeRoot()
{
Semicolon = ToTerm(".");
var root = new NonTerminal("root");
Productions(root);
return root;
}
//Must create new overrides here in order to support the "Operator" token color
public new void RegisterOperators(int precedence, Associativity associativity, params string[] opSymbols)
{
foreach (string op in opSymbols)
{
KeyTerm opSymbol = Operator(op);
opSymbol.Precedence = precedence;
opSymbol.Associativity = associativity;
}
}
public IndentFilter(GrammarData grammarData, KeyTerm lineContinuation, KeyTerm bracket_open, KeyTerm bracket_close)
{
this.grammarData = grammarData;
grammar = grammarData.Grammar;
grammar.LanguageFlags |= LanguageFlags.EmitLineStartToken;
opening_bracket = bracket_open;
closing_bracket = bracket_close;
}
void createKeyTerms()
{
Comma = ToTerm(",", "Comma");
Semi = ToTerm(";", "Semi");
Lbr = ToTerm("(", "Lbr");
Rbr = ToTerm(")", "Rbr");
Do = ToTerm("do", "Do");
End = ToTerm("end", "End");
}
public KeyTerm Operator(string op)
{
KeyTerm term = new KeyTerm(CaseSensitive ? op : op.ToLower(), op);
term.SetFlag(TermFlags.IsOperator, true);
term.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Keyword, TokenTriggers.None);
return(term);
}
public IndentFilter(GrammarData grammarData, KeyTerm lineContinuation, KeyTerm bracket_open, KeyTerm bracket_close)
{
this.grammarData = grammarData;
grammar = grammarData.Grammar;
grammar.LanguageFlags |= LanguageFlags.EmitLineStartToken;
opening_bracket = bracket_open;
closing_bracket = bracket_close;
}
private static string ToLaTeX(this AstNode node, int parentOperationPriority = 0)
{
switch (node)
{
case StatementListNode listNode:
return(string.Join("\\\\", listNode.ChildNodes.Select(childNode => childNode.ToLaTeX())));
case BinaryOperationNode binNode:
string opSymbol = binNode.OpSymbol;
KeyTerm operationTerm = Grammar.CurrentGrammar.ToTerm(opSymbol);
bool ignorePriorirty = binNode.Op == ExpressionType.Divide || binNode.Op == ExpressionType.Power;
string
left = binNode.Left.ToLaTeX(ignorePriorirty ? 0 : operationTerm.Precedence),
right = binNode.Right.ToLaTeX(ignorePriorirty ? 0 : operationTerm.Precedence);
switch (binNode.Op)
{
case ExpressionType.Divide:
return($"\\frac{{{left}}}{{{right}}}");
case ExpressionType.Power:
return($"{{{left}}}^{{{right}}}");
default:
if (operationTerm.Precedence < parentOperationPriority)
{
left = "\\left(" + left;
right = right + "\\right)";
}
if (binNode.Op == ExpressionType.Multiply &&
!(char.IsDigit(left[left.Length - 1]) && char.IsDigit(right[0])))
{
opSymbol = "";
}
return($"{left} {opSymbol} {right}");
}
case UnaryOperationNode unaryNode:
return($"{unaryNode.OpSymbol}{{{unaryNode.Argument.ToLaTeX()}}}");
case FunctionCallNode callNode:
string args = string.Join(
", ",
((ExpressionListNode)callNode.ChildNodes[1]).ChildNodes.Select(childNode => ToLaTeX(childNode))
);
return($"{callNode.ChildNodes[0].AsString.ToLower()}({args})");
default:
return(node.AsString);
}
}
public KeyTerm Keyword(string keyword)
{
KeyTerm term = ToTerm(keyword);
term.SetFlag(TermFlags.IsKeyword, true);
term.SetFlag(TermFlags.IsReservedWord, true);
term.EditorInfo = new TokenEditorInfo(TokenType.Keyword, TokenColor.Keyword, TokenTriggers.None);
term.AstConfig.NodeType = typeof(LuaLiteralNode);
return(term);
}
public KeyTerm Keyword(string keyword)
{
KeyTerm term = ToTerm(keyword);
//term.SetFlag(TermFlags.IsKeyword, true);
//term.SetFlag(TermFlags.IsReservedWord, true);
term.EditorInfo = new TokenEditorInfo(TokenType.Keyword, TokenColor.Keyword, TokenTriggers.None);
return(term);
}
public KeyTerm Operator(string op)
{
string opCased = CaseSensitive ? op : op.ToLower();
var term = new KeyTerm(opCased, op);
term.SetFlag(TermFlags.IsOperator, true);
term.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Text, TokenTriggers.None);
term.AstConfig.NodeType = typeof(LuaNode);
return(term);
}
public LpGrammer() : base(true)
{
NumberLiteral Number = new NumberLiteral("Number");
KeyTerm Comma = ToTerm(",");
NonTerminal Numbers = new NonTerminal("Numbers");
Numbers.Rule = Number + Comma + Number;
Root = Numbers;
}
public KeyTerm Operator(string op)
{
string opCased = this.CaseSensitive ? op : op.ToLower();
var term = new KeyTerm(opCased, op);
//term.SetOption(TermOptions.IsOperator, true);
term.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Keyword, TokenTriggers.None);
return(term);
}
public VASLGrammar() : base(true)
{
var code = new CustomTerminal("code", MatchCodeTerminal);
var stringLit = TerminalFactory.CreateCSharpString("string");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var number = TerminalFactory.CreateCSharpNumber("number");
number.Options |= NumberOptions.AllowSign;
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
// Todo: Aliases
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var undoSplit = new KeyTerm("undoSplit", "undoSplit");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var version = new NonTerminal("version");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var methodType = new NonTerminal("methodType");
root.Rule = methodList;
version.Rule = (comma + stringLit) | Empty;
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
method.Rule = (methodType + "{" + code + "}") | Empty;
methodType.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown | undoSplit;
Root = root;
MarkTransient(varList, methodList, methodType);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public CodeOutlineFilter(GrammarData grammarData, OutlineOptions options, KeyTerm continuationTerminal) {
_grammarData = grammarData;
_grammar = grammarData.Grammar;
_grammar.LanguageFlags |= LanguageFlags.EmitLineStartToken;
Options = options;
ContinuationTerminal = continuationTerminal;
if (ContinuationTerminal != null)
if (!_grammar.NonGrammarTerminals.Contains(ContinuationTerminal))
_grammarData.Language.Errors.Add(GrammarErrorLevel.Warning, null, Resources.ErrOutlineFilterContSymbol, ContinuationTerminal.Name);
//"CodeOutlineFilter: line continuation symbol '{0}' should be added to Grammar.NonGrammarTerminals list.",
_produceIndents = OptionIsSet(OutlineOptions.ProduceIndents);
_checkBraces = OptionIsSet(OutlineOptions.CheckBraces);
_checkOperator = OptionIsSet(OutlineOptions.CheckOperator);
Reset();
}
public ASLGrammar()
: base(true)
{
var stringLit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
var state = new KeyTerm("state", "state");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var stateDef = new NonTerminal("stateDef");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var offsetList = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var methodType = new NonTerminal("methodType");
root.Rule = stateDef + methodList;
stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}";
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty;
method.Rule = (methodType + "{" + code + "}") | Empty;
offsetList.Rule = MakePlusRule(offsetList, comma, offset);
offset.Rule = number;
methodType.Rule = start | split | isLoading | gameTime | reset;
this.Root = root;
MarkTransient(varList, methodList, offset, methodType);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public TermName()
{
this.GrammarComments = @"Test TermName grammar";
//Terminals
KeyTerm greater = ToTerm(">");
KeyTerm less = ToTerm("<");
KeyTerm equal = ToTerm("=");
var s = new NonTerminal("Start");
//Rules
s.Rule = greater | less | equal;
this.Root = s;
this.LanguageFlags |= LanguageFlags.NewLineBeforeEOF;
}//constructor
public ASLGrammar()
: base(true)
{
var stringLit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
var state = new KeyTerm("state", "state");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var stateDef = new NonTerminal("stateDef");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var offsetList = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var methodType = new NonTerminal("methodType");
root.Rule = stateDef + methodList;
stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}";
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty;
method.Rule = (methodType + "{" + code + "}") | Empty;
offsetList.Rule = MakePlusRule(offsetList, comma, offset);
offset.Rule = number;
methodType.Rule = start | split | isLoading | gameTime | reset;
this.Root = root;
MarkTransient(varList, methodList, offset, methodType);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public T4Grammar()
: base(false)
{
_beginSegment = ToTerm("<#", "beginSegment");
_beginSegment.SkipsWhitespaceAfter = false;
_endSegment = ToTerm("#>", "endSegment");
_endSegment.SkipsWhitespaceAfter = false;
var directive = InitDirective(BeginSegment, EndSegment);
var embeddedCs = InitEmbeddedCs(BeginSegment, EndSegment);
var embeddedClassMember = InitEmbeddedClassMember(BeginSegment, EndSegment);
var embeddedExpr = InitEmbeddedExpr(BeginSegment, EndSegment);
var staticText = new FreeTextLiteral("staticText", FreeTextOptions.AllowEof, BeginSegment.Text);
var segment = new NonTerminal("segment") { Rule = staticText | embeddedCs | embeddedExpr | embeddedClassMember | directive };
var content = new NonTerminal("content");
content.Rule = MakeStarRule(content, segment);
var root = new NonTerminal("root") {Rule = content};
Root = root;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this;
if (children == null)
{
throw new ParserException();
}
if (children.Length == 1)
{
var e = children[0].Term switch
{
KeyTerm key => key.Text == "true" ? true : key.Text == "false" ? false : key.Text == "null" ? null : throw new ParserException("Invalid"),
IdentifierTerminal => new IdentifierNode(children[0].AsString),
_ => children[0].Evaluate(thread),
};
thread.CurrentNode = Parent;
// EbisterNodeでなければおそらくリテラルの即値（としておく）
return(e is EbisterNode node ? node : new LiteralNode(EbiValueBase.ToEbiObject(e)));
}
else if (children.Length == 3)
{
if (children[0]?.Evaluate(thread) is not ExpressionNode left)
{
throw new ParserException();
}
if (children[1].Term is not KeyTerm t)
{
throw new ParserException();
}
if (children[2]?.Evaluate(thread) is not ExpressionNode right)
{
throw new ParserException();
}
thread.CurrentNode = Parent;
return(new BinaryExpressionNode(t.Text, left, right));
}
else
{
throw new ParserException("invalid children size");
}
}
private void SetupGrammar()
{
Comma = ToTerm(",");
Dot = ToTerm(".");
Colon = ToTerm(":");
As = ToTerm("AS");
MakeSimpleId();
Comments();
Keywords();
ReservedWords();
Literals();
Operators();
MarkPunctuation(",", "(", ")", "AS");
Root = MakeRoot();
}
private void RegisterKeyTerms()
{
RegisteredTerms = new List <KeyTerm>();
kConst = RegisterTerm("const");
kExtern = RegisterTerm("extern");
kLet = RegisterTerm("let");
kIf = RegisterTerm("if");
kBool = RegisterTerm("bool");
kRet = RegisterTerm("ret");
kMov = RegisterTerm("mov");
kAdd = RegisterTerm("add");
kCall = RegisterTerm("call");
kByte = RegisterTerm("byte");
kWord = RegisterTerm("word");
kDword = RegisterTerm("dword");
kQword = RegisterTerm("qword");
kString = RegisterTerm("string");
kTrue = RegisterTerm("true");
kFalse = RegisterTerm("false");
}
public HTMLGrammar() {
KeyTerm leftAnguralBracket = new KeyTerm("<", "LeftAngularBarakcet");
KeyTerm rightAnguralBracket = new KeyTerm(">", "RightAngularBarakcet");
KeyTerm leftAngularBracketEndTag = new KeyTerm("</", "LeftAngularBracketEndTag");
KeyTerm rightAngularBracketEndTag = new KeyTerm("/>", "RightAngularBracketEndTag");
NonTerminal element = new NonTerminal("Element");
NonTerminal emptyElementTag = new NonTerminal("EmptyElementTag");
NonTerminal startTag = new NonTerminal("StartTag");
NonTerminal content = new NonTerminal("Content");
NonTerminal endTag = new NonTerminal("EndTag");
RegexBasedTerminal name = new RegexBasedTerminal("Name", "\\w+");
element.Rule = emptyElementTag | startTag + content + endTag;
emptyElementTag.Rule = leftAnguralBracket + name + rightAngularBracketEndTag;
startTag.Rule = leftAnguralBracket + name + rightAnguralBracket;
endTag.Rule = leftAngularBracketEndTag + name + rightAnguralBracket;
content.Rule = MakeStarRule(content, element);
this.Root = element;
}
public HTMLGrammar()
{
KeyTerm leftAnguralBracket = new KeyTerm("<", "LeftAngularBarakcet");
KeyTerm rightAnguralBracket = new KeyTerm(">", "RightAngularBarakcet");
KeyTerm leftAngularBracketEndTag = new KeyTerm("</", "LeftAngularBracketEndTag");
KeyTerm rightAngularBracketEndTag = new KeyTerm("/>", "RightAngularBracketEndTag");
NonTerminal element = new NonTerminal("Element");
NonTerminal emptyElementTag = new NonTerminal("EmptyElementTag");
NonTerminal startTag = new NonTerminal("StartTag");
NonTerminal content = new NonTerminal("Content");
NonTerminal endTag = new NonTerminal("EndTag");
RegexBasedTerminal name = new RegexBasedTerminal("Name", "\\w+");
element.Rule = emptyElementTag | startTag + content + endTag;
emptyElementTag.Rule = leftAnguralBracket + name + rightAngularBracketEndTag;
startTag.Rule = leftAnguralBracket + name + rightAnguralBracket;
endTag.Rule = leftAngularBracketEndTag + name + rightAnguralBracket;
content.Rule = MakeStarRule(content, element);
this.Root = element;
}
public EBNF() : base(false)
{
// Terminals
IdentifierTerminal TIdentifier = new IdentifierTerminal("identifier");
StringLiteral TTerminal = new StringLiteral("terminal", "\'");
KeyTerm TConcatenation = ToTerm(",", "concatenation");
KeyTerm TAlternation = ToTerm("|", "alternation");
// Non terminals
NonTerminal TOperator = new NonTerminal("operator");
NonTerminal TExpression = new NonTerminal("expression");
NonTerminal TRule = new NonTerminal("rule");
NonTerminal TBinary = new NonTerminal("binary");
NonTerminal TStatement = new NonTerminal("statement");
NonTerminal TDefinition = new NonTerminal("definition");
NonTerminal TStatements = new NonTerminal("statements");
// Rules definition
TOperator.Rule = TConcatenation | TAlternation;
TExpression.Rule = TTerminal | TRule | TBinary;
TRule.Rule = ToTerm("<") + TIdentifier + ">" | TIdentifier;
TBinary.Rule = TExpression + TOperator + TExpression;
TStatement.Rule = TDefinition;
TDefinition.Rule = TRule + "=" + TExpression + ";";
TStatements.Rule = MakePlusRule(TStatements, TStatement);
// Operators precedence and associativity
RegisterOperators(1, TAlternation);
RegisterOperators(2, TConcatenation);
// Clean tree
MarkPunctuation("<", ">", "=", ";");
// Entry rule
this.Root = TStatements;
}
private NonTerminal InitDirective(KeyTerm beginSegment, KeyTerm endSegment)
{
_directiveName = new IdentifierTerminal("directiveName");
_expandedIncludeText = new FreeTextLiteral("expandedIncludeText");
_attributeConnector = ToTerm("=");
_attributeName = new IdentifierTerminal("attributeName") { SkipsWhitespaceAfter = false };
_attributeValue = new StringLiteral("attributeValue", "\"");
_attribute = new NonTerminal("attribute") {
Rule = _attributeName + _attributeConnector + _attributeValue };
_attributeList = new NonTerminal("attributeList");
_attributeList.Rule = MakePlusRule(_attributeList, _attribute);
var directivePrefix = ToTerm("@");
_directive = new NonTerminal("directive") {
Rule = beginSegment + directivePrefix + DirectiveName + AttributeList + endSegment };
return Directive;
}
public GramaticaLUP() : base(false)
{
CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/");
CommentTerminal lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
/* Reserved Words */
KeyTerm
login_ = ToTerm("login"),
user_ = ToTerm("user"),
pass_ = ToTerm("pass"),
logout_ = ToTerm("logout"),
query_ = ToTerm("query"),
data_ = ToTerm("data"),
struc_ = ToTerm("struc");
MarkReservedWords("login", "user", "pass", "logout", "query", "data", "struc");
/* Symbols*/
KeyTerm
leftCor = ToTerm("["),
rightCor = ToTerm("]"),
mas = ToTerm("+"),
menos = ToTerm("-");
//MarkPunctuation("[", "]");
CommentTerminal phrase = new CommentTerminal("phrase", "]", "[-");
NonTerminal
INICIO = new NonTerminal("INICIO"),
INSTRUCCIONES = new NonTerminal("INSTRUCCIONES"),
INSTRUCCION = new NonTerminal("INSTRUCCION"),
LOGIN = new NonTerminal("LOGIN"),
USER = new NonTerminal("USER"),
PASS = new NonTerminal("PASS"),
LOGOUT = new NonTerminal("LOGOUT"),
QUERY = new NonTerminal("QUERY"),
DATA = new NonTerminal("DATA"),
STRUC = new NonTerminal("STRUC");
this.Root = INICIO;
INICIO.Rule = INSTRUCCIONES;
INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION);
INSTRUCCION.Rule = LOGIN | LOGOUT | QUERY | STRUC;
LOGIN.Rule = leftCor + mas + login_ + rightCor +
USER + PASS +
leftCor + menos + login_ + rightCor;
USER.Rule = leftCor + mas + user_ +
phrase +
user_ + rightCor;
PASS.Rule = leftCor + mas + pass_ +
phrase +
pass_ + rightCor;
LOGOUT.Rule = leftCor + mas + logout_ + rightCor +
USER +
leftCor + menos + logout_ + rightCor;
QUERY.Rule = leftCor + mas + query_ + rightCor +
USER + DATA +
leftCor + menos + query_ + rightCor;
DATA.Rule = leftCor + mas + data_ +
phrase +
data_ + rightCor;
STRUC.Rule = leftCor + mas + struc_ + rightCor +
USER +
leftCor + menos + struc_ + rightCor;
}
protected override void Keywords()
{
ACCOUNT = ToTerm("ACCOUNT");
AFTER = ToTerm("AFTER");
AND = ToTerm("AND");
ANY = ToTerm("ANY");
ARRAY = ToTerm("ARRAY");
AS = ToTerm("AS");
ASC = ToTerm("ASC");
BEFORE = ToTerm("BEFORE");
BEGIN = ToTerm("BEGIN");
BETWEEN = ToTerm("BETWEEN");
BINARY = ToTerm("BINARY");
BLOB = ToTerm("BLOB");
BOOLEAN = ToTerm("BOOLEAN");
BY = ToTerm("BY");
CACHE = ToTerm("CACHE");
CALL = ToTerm("CALL");
CALLBACK = ToTerm("CALLBACK");
CASCADE = ToTerm("CASCADE");
CASE = ToTerm("CASE");
CAST = ToTerm("CAST");
CHECK = ToTerm("CHECK");
CONSTANT = ToTerm("CONSTANT");
CONSTRAINT = ToTerm("CONSTRAINT");
CREATE = ToTerm("CREATE");
CYCLE = ToTerm("CYCLE");
DECLARE = ToTerm("DECLARE");
DELETE = ToTerm("DELETE");
DEFAULT = ToTerm("DEFAULT");
EACH = ToTerm("EACH");
END = ToTerm("END");
ELSE = ToTerm("ELSE");
ELSIF = ToTerm("ELSIF");
EXCEPTION = ToTerm("EXCEPTION");
EXECUTE = ToTerm("EXECUTE");
EXISTS = ToTerm("EXISTS");
FOR = ToTerm("FOR");
FOREIGN = ToTerm("FOREIGN");
GROUPS = ToTerm("GROUPS");
KEY = ToTerm("KEY");
IDENTITY = ToTerm("IDENTITY");
IF = ToTerm("IF");
INCREMENT = ToTerm("INCREMENT");
INDEX = ToTerm("INDEX");
INSERT = ToTerm("INSERT");
LOCK = ToTerm("LOCK");
MAXVALUE = ToTerm("MAXVALUE");
MINVALUE = ToTerm("MINVALUE");
NOT = ToTerm("NOT");
NULL = ToTerm("NULL");
ON = ToTerm("ON");
OR = ToTerm("OR");
PRIMARY = ToTerm("PRIMARY");
PROCEDURE = ToTerm("PROCEDURE");
REPLACE = ToTerm("REPLACE");
REFERENCES = ToTerm("REFERENCES");
ROW = ToTerm("ROW");
SCHEMA = ToTerm("SCHEMA");
SEQUENCE = ToTerm("SEQUENCE");
SET = ToTerm("SET");
START = ToTerm("START");
TABLE = ToTerm("TABLE");
THEN = ToTerm("THEN");
TRIGGER = ToTerm("TRIGGER");
TYPE = ToTerm("TYPE");
UPDATE = ToTerm("UPDATE");
UNIQUE = ToTerm("UNIQUE");
UNLOCK = ToTerm("UNLOCK");
VIEW = ToTerm("VIEW");
WITH = ToTerm("WITH");
}
public CssGrammar()
: base(false)
{
//Terminals
Terminal comment = new CommentTerminal("comment", "/*", "*/");
NonGrammarTerminals.Add(comment);
ToTerminatorTerminal attributeSelector = new ToTerminatorTerminal("AttributeSelectorContent", ']');
IdentifierTerminal simpleSelectorId = new IdentifierTerminal(SimpleSelectorIdentifier, ".-*#", ".-*#");
IdentifierTerminal pseudoClassId = new IdentifierTerminal(PseudoClassIdentifier, "-)(", "-)(");
IdentifierTerminal propertyId = new IdentifierTerminal(Property, "-", "-");
ToTerminatorTerminal valueId = new ToTerminatorTerminal(Value, ';');
valueId.EditorInfo = new TokenEditorInfo(TokenType.Identifier, TokenColor.Identifier, TokenTriggers.None);
KeyTerm blockOpen = ToTerm("{");
KeyTerm blockClose = ToTerm("}");
KeyTerm semi = ToTerm(";");
KeyTerm colin = ToTerm(":");
KeyTerm childChain = ToTerm(">");
KeyTerm siblingProceed = ToTerm("+");
KeyTerm groupDelim = ToTerm(",");
KeyTerm attributeSelectOpen = ToTerm("[");
KeyTerm attributeSelectClose = ToTerm("]");
//Non Terminals
NonTerminal css = new NonTerminal("CSS");
NonTerminal rule = new NonTerminal("Rule");
NonTerminal rules = new NonTerminal("Rules");
NonTerminal declaration = new NonTerminal("Declaration");
NonTerminal declarations = new NonTerminal("Declarations");
NonTerminal pseudoClassRule = new NonTerminal("PseudoClassRule");
NonTerminal pseudoClasses = new NonTerminal("PseudoClasses");
NonTerminal selectorChain = new NonTerminal("Chain");
NonTerminal selectorChainDelim = new NonTerminal("ChainDelim");
NonTerminal selectorGroup = new NonTerminal("SelectorGroup");
NonTerminal selector = new NonTerminal("Selector");
NonTerminal optAttributeSelector = new NonTerminal("OptAttributeSelector");
NonTerminal multiAttributeSelector = new NonTerminal("MultiAttributeSelector");
NonTerminal simpleSelectorWithAttributeSelector = new NonTerminal("simpleSelectorWithAttributeSelector");
//Rules
this.Root = css;
optAttributeSelector.Rule = attributeSelectOpen + attributeSelector + attributeSelectClose;
multiAttributeSelector.Rule = MakeStarRule(multiAttributeSelector, optAttributeSelector);
pseudoClassRule.Rule = colin + pseudoClassId;
pseudoClasses.Rule = MakeStarRule(pseudoClasses, pseudoClassRule);
simpleSelectorWithAttributeSelector.Rule = simpleSelectorId + multiAttributeSelector;
selectorChainDelim.Rule = childChain | siblingProceed | Empty;
selectorChain.Rule = MakePlusRule(selectorChain, selectorChainDelim, simpleSelectorWithAttributeSelector);
selector.Rule = selectorChain + pseudoClasses;
selectorGroup.Rule = MakePlusRule(selectorGroup, groupDelim, selector);
declaration.Rule = propertyId + colin + valueId + semi;
declarations.Rule = MakeStarRule(declarations, declaration);
rule.Rule = selectorGroup + blockOpen + declarations + blockClose;
rules.Rule = MakeStarRule(rules, rule);
css.Rule = rules;
MarkPunctuation(blockOpen, blockClose, semi, colin, attributeSelectOpen, attributeSelectClose);
MarkTransient(pseudoClassRule, multiAttributeSelector, pseudoClasses);
}
public ShakespeareGrammar(IShakespeareCompiler compiler)
: base(false)
{
string[] endSymbols = { ".", "?", "!" };
KeyTerm COLON = ToTerm(":", "colon");
KeyTerm COMMA = ToTerm(",");
KeyTerm EXCLAMATION_MARK = ToTerm("!");
KeyTerm LEFT_BRACKET = ToTerm("[");
KeyTerm PERIOD = ToTerm(".");
KeyTerm QUESTION_MARK = ToTerm("?");
KeyTerm RIGHT_BRACKET = ToTerm("]");
KeyTerm QuestionSymbol = ToTerm("?", "QuestionMark");
var Article = BuildTerminal("Article", "article.wordlist");
var Be = BuildTerminal <BeNode>("Be", "be.wordlist");
var Character = BuildTerminal("Character", "character.wordlist");
var FirstPerson = BuildTerminal <FirstPersonNode>("FirstPerson", "first_person.wordlist");
var FirstPersonPossessive = BuildTerminal("FirstPersonPossessive", "first_person_possessive.wordlist");
var FirstPersonReflexive = BuildTerminal <FirstPersonReflexiveNode>("FirstPersonReflexive", "first_person_reflexive.wordlist");
var NegativeAdjective = BuildTerminal <NegativeAdjectiveNode>("NegativeAdjective", "negative_adjective.wordlist");
var NEGATIVE_COMPARATIVE = BuildTerminal <NegativeComparativeTermNode>("NEGATIVE_COMPARATIVE", "negative_comparative.wordlist");
var NegativeNoun = BuildTerminal <NegativeNounNode>("NegativeNoun", "negative_noun.wordlist");
var NeutralAdjective = BuildTerminal("NeutralAdjective", "neutral_adjective.wordlist");
var NeutralNoun = BuildTerminal("NeutralNoun", "neutral_noun.wordlist");
var Nothing = BuildTerminal <NothingNode>("Nothing", "nothing.wordlist");
var PositiveAdjective = BuildTerminal("PositiveAdjective", "Positive_adjective.wordlist");
var POSITIVE_COMPARATIVE = BuildTerminal("POSITIVE_COMPARATIVE", "Positive_comparative.wordlist");
var POSITIVE_NOUN = BuildTerminal("POSITIVE_NOUN", "Positive_noun.wordlist");
var SecondPerson = BuildTerminal <SecondPersonNode>("SecondPerson", "Second_person.wordlist");
var SecondPersonPossessive = BuildTerminal("SecondPersonPossessive", "Second_person_possessive.wordlist");
var SecondPersonReflexive = BuildTerminal <SecondPersonReflexiveNode>("SecondPersonReflexive", "Second_person_reflexive.wordlist");
var ThirdPersonPossessive = BuildTerminal("ThirdPersonPossessive", "Third_person_possessive.wordlist");
var AND = ToTerm("and");
var AS = ToTerm("as");
var ENTER = ToTerm("enter");
var EXEUNT = ToTerm("exeunt");
var EXIT = ToTerm("exit");
var HEART = ToTerm("heart");
var IF_NOT = ToTerm("if not");
var IF_SO = ToTerm("if so");
var LESS = ToTerm("less");
var LET_US = ToTerm("let us");
var LISTEN_TO = MultiWordTermial("listen to");
var MIND = ToTerm("mind");
var MORE = ToTerm("more");
var NOT = ToTerm("not");
var OPEN = ToTerm("open");
var PROCEED_TO = MultiWordTermial("proceed to");
var RECALL = ToTerm("recall");
var REMEMBER = ToTerm("remember");
var RETURN_TO = MultiWordTermial("return to");
var SPEAK = ToTerm("speak");
var THAN = ToTerm("than");
var THE_CUBE_OF = MultiWordTermial("the cube of");
var THE_DIFFERENCE_BETWEEN = MultiWordTermial("the difference between");
var THE_FACTORIAL_OF = MultiWordTermial("the factorial of");
var THE_PRODUCT_OF = MultiWordTermial("the product of");
var THE_QUOTIENT_BETWEEN = MultiWordTermial("the quotient between");
var THE_REMAINDER_OF_THE_QUOTIENT_BETWEEN = MultiWordTermial("the remainder of the quotient between");
var THE_SQUARE_OF = ToTerm("the square of");
var THE_SQUARE_ROOT_OF = ToTerm("the square root of");
var THE_SUM_OF = MultiWordTermial("the sum of");
var TWICE = ToTerm("twice");
var WE_MUST = ToTerm("we must");
var WE_SHALL = ToTerm("we shall");
var Play = new NonTerminal("Play", compiler.PlayNode);
var Title = new NonTerminal("Title", compiler.TitleNode);
var Act = new NonTerminal("Act", typeof(ActNode));
var ActHeader = new NonTerminal("ActHeader", compiler.ActHeaderNode);
var ActRoman = new NonTerminal("ActRoman");
var Adjective = new NonTerminal("Adjective", typeof(AdjectiveNode));
var BinaryOperator = new NonTerminal("BinaryOperator", compiler.BinaryOperatorNode);
var CharacterDeclaration = new NonTerminal("CharacterDeclaration", compiler.CharacterDeclarationNode);
var CharacterDeclarationList = new NonTerminal("CharacterDeclarationList", compiler.CharacterDeclarationListNode);
var CharacterList = new NonTerminal("CharacterList", typeof(CharacterListNode));
var Comment = new FreeTextLiteral("Comment", FreeTextOptions.ConsumeTerminator, endSymbols);
var Comparative = new NonTerminal("Comparative", compiler.ComparativeNode);
var Comparison = new NonTerminal("Comparison", compiler.ComparisonNode);
var Conditional = new NonTerminal("Conditional", compiler.ConditionalNode);
var Constant = new NonTerminal("Constant", compiler.ConstantNode);
var EndSymbol = new NonTerminal("EndSymbol", typeof(EndSymbolNode));
var Enter = new NonTerminal("Enter", compiler.EnterNode);
var Equality = new NonTerminal("Equality", compiler.EqualityNode);
var Exit = new NonTerminal("Exit", compiler.ExitNode);
var Inequality = new NonTerminal("Inequality", typeof(InequalityNode));
var InOut = new NonTerminal("InOut", compiler.InOutNode);
var Jump = new NonTerminal("Jump", compiler.JumpNode);
var JumpPhraseBeginning = new NonTerminal("JumpPhraseBeginning", typeof(JumpPhraseBeginninglNode));
var JumpPhraseEnd = new NonTerminal("JumpPhraseEnd", typeof(JumpPhraseEndNode));
var JumpPhrase = new NonTerminal("JumpPhrase", typeof(JumpPhraseNode));
var Line = new NonTerminal("Line", compiler.LineNode);
var NonnegatedComparison = new NonTerminal("NonnegatedComparison", compiler.NonnegatedComparisonNode);
var NegativeComparative = new NonTerminal("NegativeComparative", compiler.NegativeComparativeNode);
var NegativeConstant = new NonTerminal("NegativeConstant", compiler.NegativeConstantNode);
var OpenYour = new NonTerminal("OpenYour", typeof(OpenYourNode));
var PositiveComparative = new NonTerminal("PositiveComparative", compiler.PositiveComparativeNode);
var PositiveConstant = new NonTerminal("PositiveConstant", compiler.PositiveConstantNode);
var PositiveNoun = new NonTerminal("PositiveNoun", typeof(PositiveNounNode));
var Pronoun = new NonTerminal("Pronoun", compiler.PronounNode);
var Question = new NonTerminal("Question", compiler.QuestionNode);
var Recall = new NonTerminal("Recall", compiler.RecallNode);
var Remember = new NonTerminal("Remember", compiler.RememberNode);
var RomanNumber = new RegexBasedTerminal("RomanNumer", "[mdclxvi]+");
var Scene = new NonTerminal("Scene", typeof(SceneNode));
var Scenes = new NonTerminal("Scenes", typeof(ListNode));
var SceneContents = new NonTerminal("SceneContents", typeof(SceneContentsNode));
var SceneHeader = new NonTerminal("SceneHeader", compiler.SceneHeaderNode);
var SceneRoman = new NonTerminal("SceneRoman", typeof(SceneRomanNode));
var SceneStuff = new NonTerminal("SceneStuff", typeof(SceneStuffNode));
var Sentence = new NonTerminal("Sentence", compiler.SentenceNode);
var SentenceList = new NonTerminal("SentenceList", typeof(ListNode));
var Statement = new NonTerminal("Statement", compiler.StatementNode);
var StatementSymbol = new NonTerminal("StatementSymbol", typeof(StatementSymbolNode));
var Text = new FreeTextLiteral("String", FreeTextOptions.IncludeTerminator | FreeTextOptions.AllowEof, endSymbols);
var UnarticulatedConstant = new NonTerminal("UnarticulatedConstant", typeof(UnarticulatedConstantNode));
var UnaryOperator = new NonTerminal("UnaryOperator", compiler.UnaryOperatorNode);
var UnconditionalSentence = new NonTerminal("UnconditionalSentence", compiler.UnconditionalSentenceNode);
var Value = new NonTerminal("Value", compiler.ValueNode);
var Acts = new NonTerminal("Acts", typeof(ListNode));
Play.Rule = Title + CharacterDeclarationList + Acts;
Acts.Rule = MakePlusRule(Acts, Act);
Title.Rule = Text;
Act.Rule = ActHeader + Scenes;
Scenes.Rule = MakePlusRule(Scenes, Scene);
ActHeader.Rule = ActRoman + COLON + Comment;
ActRoman.Rule = ToTerm("act") + RomanNumber;
Adjective.Rule =
PositiveAdjective |
NeutralAdjective |
NegativeAdjective;
BinaryOperator.Rule =
THE_DIFFERENCE_BETWEEN |
THE_PRODUCT_OF |
THE_QUOTIENT_BETWEEN |
THE_REMAINDER_OF_THE_QUOTIENT_BETWEEN |
THE_SUM_OF;
CharacterDeclaration.Rule = Character + COMMA + Comment;
CharacterDeclarationList.Rule = MakePlusRule(CharacterDeclarationList, CharacterDeclaration);
CharacterList.Rule = Character + AND + Character
| Character + COMMA + CharacterList;
Comparative.Rule = PositiveComparative | NegativeComparative;
Comparison.Rule = NOT + NonnegatedComparison | NonnegatedComparison;
Conditional.Rule = IF_SO | IF_NOT;
Constant.Rule = Article + UnarticulatedConstant |
FirstPersonPossessive + UnarticulatedConstant |
SecondPersonPossessive + UnarticulatedConstant |
ThirdPersonPossessive + UnarticulatedConstant |
Nothing;
EndSymbol.Rule = QuestionSymbol | StatementSymbol;
Enter.Rule =
LEFT_BRACKET + ENTER + Character + RIGHT_BRACKET
| LEFT_BRACKET + ENTER + CharacterList + RIGHT_BRACKET;
Exit.Rule =
LEFT_BRACKET + EXIT + Character + RIGHT_BRACKET
| LEFT_BRACKET + EXEUNT + CharacterList + RIGHT_BRACKET
| LEFT_BRACKET + EXEUNT + RIGHT_BRACKET;
Equality.Rule = AS + Adjective + AS;
Inequality.Rule = Comparative + THAN;
OpenYour.Rule = OPEN + SecondPersonPossessive;
InOut.Rule = OpenYour + HEART + StatementSymbol |
SPEAK + SecondPersonPossessive + MIND + StatementSymbol |
LISTEN_TO + SecondPersonPossessive + HEART + StatementSymbol |
OpenYour + MIND + StatementSymbol;
JumpPhraseBeginning.Rule = LET_US | WE_MUST | WE_SHALL;
JumpPhraseEnd.Rule = PROCEED_TO | RETURN_TO;
JumpPhrase.Rule = JumpPhraseBeginning + JumpPhraseEnd;
Jump.Rule = JumpPhrase + ActRoman + StatementSymbol | JumpPhrase + SceneRoman + StatementSymbol;
Line.Rule = Character + COLON + SentenceList;
NegativeComparative.Rule =
NEGATIVE_COMPARATIVE |
MORE + NegativeAdjective |
LESS + PositiveAdjective;
NegativeConstant.Rule = NegativeNoun | NegativeAdjective + NegativeConstant | NeutralAdjective + NegativeConstant;
NonnegatedComparison.Rule = Equality | Inequality;
PositiveComparative.Rule = POSITIVE_COMPARATIVE | MORE + PositiveAdjective | LESS + NegativeAdjective;
PositiveConstant.Rule = PositiveNoun | PositiveAdjective + PositiveConstant | NeutralAdjective + PositiveConstant;
PositiveNoun.Rule = NeutralNoun | POSITIVE_NOUN;
Pronoun.Rule = FirstPerson | FirstPersonReflexive | SecondPerson | SecondPersonReflexive;
Question.Rule = Be + Value + Comparison + Value + QuestionSymbol;
Recall.Rule = RECALL + Text;
Remember.Rule = REMEMBER + Value + StatementSymbol;
Scene.Rule = SceneHeader + SceneContents;
SceneHeader.Rule = SceneRoman + COLON + Comment;
SceneRoman.Rule = ToTerm("scene") + RomanNumber;
SceneStuff.Rule = Enter | Exit | Line;
SceneContents.Rule = MakeStarRule(SceneContents, SceneStuff);
SentenceList.Rule = MakePlusRule(SentenceList, Sentence);
Sentence.Rule = UnconditionalSentence
| Conditional + COMMA + UnconditionalSentence;
StatementSymbol.Rule = EXCLAMATION_MARK | PERIOD;
UnarticulatedConstant.Rule = PositiveConstant | NegativeConstant;
UnaryOperator.Rule = THE_CUBE_OF | THE_FACTORIAL_OF | THE_SQUARE_OF | THE_SQUARE_ROOT_OF | TWICE;
UnconditionalSentence.Rule =
InOut |
Jump |
Question |
Recall |
Remember |
Statement;
Value.Rule = Character |
Constant |
Pronoun |
BinaryOperator + Value + AND + Value |
UnaryOperator + Value;
Statement.Rule = SecondPerson + Be + Constant + StatementSymbol |
SecondPerson + UnarticulatedConstant + StatementSymbol |
SecondPerson + Be + Equality + Value + StatementSymbol;
MarkPunctuation(".", "?", "!", "[", "]", ":", ",", "act", "scene", "and", "enter", "exit", "exeunt",
"as", "than",
"open");
this.Root = Play;
Text.AstConfig = SetNode <AstNode>();
Comment.AstConfig = SetNode(compiler.CommentNode);
RomanNumber.AstConfig = SetNode <RomanNumberNode>();
Character.AstConfig = SetNode <CharacterNode>();
MarkTransient(SceneStuff, ActRoman, StatementSymbol);
this.LanguageFlags = LanguageFlags.CreateAst;
}
private NonTerminal InitEmbeddedCs(KeyTerm beginSegment, KeyTerm endSegment)
{
var regexNonDirective = new RegexBasedTerminal("NonDirectivePrefix", "(?![+=@])") {
ErrorAlias = "<#@ can only be declared before any text or embedded code",
SkipsWhitespaceAfter = false };
_embeddedCs = new NonTerminal("embeddedCs");
var embeddedCsText = new FreeTextLiteral("embeddedCsText", endSegment.Text);
var stringLit = new StringLiteral("embeddedCsText");
stringLit.AddStartEnd(beginSegment.Text, endSegment.Text, StringOptions.AllowsLineBreak);
_embeddedCs.Rule = beginSegment + regexNonDirective + embeddedCsText + endSegment;
return EmbeddedCs;
}
public KeyTerm Operator(string op)
{
string opCased = this.CaseSensitive ? op : op.ToLower();
var term = new KeyTerm(opCased, op);
//term.SetOption(TermOptions.IsOperator, true);
//term.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Operator, TokenTriggers.None);
return term;
}
private NonTerminal InitEmbeddedExpr(KeyTerm beginSegment, KeyTerm endSegment)
{
_embeddedExpr = new NonTerminal("embeddedExpr");
var embeddedExprText = new FreeTextLiteral("embeddedCsText", endSegment.Text);
var embeddedExprPrefix = ToTerm("=");
_embeddedExpr.Rule = beginSegment + embeddedExprPrefix + embeddedExprText + endSegment;
return EmbeddedExpr;
}
public LuaGrammar() :
base(true)
{
#region Declare Terminals Here
StringLiteral STRING = CreateLuaString("string");
NumberLiteral NUMBER = CreateLuaNumber("number");
var LONGSTRING = new LuaLongStringTerminal("long-string");
LONGSTRING.AstConfig.NodeType = typeof(LuaLiteralNode);
// This includes both single-line and block comments
var Comment = new LuaCommentTerminal("block-comment");
// Regular Operators
// Member Select Operators
KeyTerm DOT = Operator(".");
DOT.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Text, TokenTriggers.MemberSelect);
KeyTerm COLON = Operator(":");
COLON.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Text, TokenTriggers.MemberSelect);
// Standard Operators
KeyTerm EQ = Operator("=");
KeyTerm MINUS = Operator("-");
KeyTerm UMINUS = Operator("-");
KeyTerm PLUS = Operator("+");
KeyTerm MUL = Operator("*");
KeyTerm MOD = Operator("%");
KeyTerm CONCAT = Operator("..");
KeyTerm GETN = Operator("#");
KeyTerm NOT = Keyword("not");
KeyTerm AND = Keyword("and");
KeyTerm OR = Keyword("or");
KeyTerm EQUAL = Operator("==");
KeyTerm NOTEQUAL = Operator("~=");
KeyTerm POW = Operator("^");
KeyTerm DIV = Operator("/");
KeyTerm GT = Operator(">");
KeyTerm GTE = Operator(">=");
KeyTerm LT = Operator("<");
KeyTerm LTE = Operator("<=");
NonGrammarTerminals.Add(Comment);
#region Keywords
KeyTerm LOCAL = Keyword("local");
KeyTerm DO = Keyword("do");
KeyTerm END = Keyword("end");
KeyTerm WHILE = Keyword("while");
KeyTerm REPEAT = Keyword("repeat");
KeyTerm UNTIL = Keyword("until");
KeyTerm IF = Keyword("if");
KeyTerm THEN = Keyword("then");
KeyTerm ELSEIF = Keyword("elseif");
KeyTerm ELSE = Keyword("else");
KeyTerm FOR = Keyword("for");
KeyTerm IN = Keyword("in");
KeyTerm FUNCTION = Keyword("function");
KeyTerm RETURN = Keyword("return");
KeyTerm BREAK = Keyword("break");
KeyTerm NIL = LiteralKeyword("nil");
KeyTerm FALSE = LiteralKeyword("false");
KeyTerm TRUE = LiteralKeyword("true");
//var NIL = new ConstantTerminal("nil", typeof(LuaLiteralNode));
//var FALSE = new ConstantTerminal("false", typeof(LuaLiteralNode));
//var TRUE = new ConstantTerminal("true", typeof(LuaLiteralNode));
KeyTerm ELLIPSIS = LiteralKeyword("...");
#endregion
var Name = new IdentifierTerminal("identifier");
Name.AstConfig.NodeType = typeof(LuaIdentifierNode);
#endregion
#region Declare Transient NonTerminals Here
// Organize the transient non-terminals so they are easier to find. None of these
// will have an AST type by definition
var Statement = new NonTerminal("statement");
var LastStatement = new NonTerminal("last statement", typeof(LuaLastStatementNode));
var Statements = new NonTerminal("statement list");
var StatementsEnd = new NonTerminal("statement list end");
var SingleStatementWithTermOpt = new NonTerminal("single statement", Statement | Statement + ";");
//SingleStatementWithTermOpt.AstConfig.NodeType = typeof(LuaBlockNode);
var LastStatementWithTermOpt = new NonTerminal("last statement", LastStatement | LastStatement + ";");
//LastStatementWithTermOpt.AstConfig.NodeType = typeof(LuaBlockNode);
var BinOp = new NonTerminal("binop");
var UnOp = new NonTerminal("unop");
var Expr = new NonTerminal("expr");
var PrefixExpr = new NonTerminal("prefix expr");
var Var = new NonTerminal("var");
var Args = new NonTerminal("args");
var EllipsisOpt = new NonTerminal("optional ellipsis");
var ParentheticalExpression = new NonTerminal("parentheical expression");
var ArgsParameters = new NonTerminal("parentheical arguments");
var ColonCallOpt = new NonTerminal("colon call");
ColonCallOpt.AstConfig.NodeType = typeof(LuaBlockNode);
var FunctionParameters = new NonTerminal("function parameters");
var FieldListOpt = new NonTerminal("field list optional");
var FieldSepOpt = new NonTerminal("field seperator optional");
MarkTransient(Expr, Statement, Statements, StatementsEnd, SingleStatementWithTermOpt, /* ColonCallOpt, */
FunctionParameters, FieldListOpt, FieldSepOpt,
LastStatementWithTermOpt, UnOp, BinOp, PrefixExpr, Var, Args, EllipsisOpt, ArgsParameters,
ParentheticalExpression);
#endregion
#region Declare NonTerminals Here
// These non-terminals will all require AST types. Anything that isnt really a language construct should be
// refactored into a transient
var Chunk = new NonTerminal("chunk", typeof(LuaChunkNode));
var Block = new NonTerminal("block", typeof(LuaBlockNode)); // probably should be transient
var FuncName = new NonTerminal("function name", typeof(LuaFuncIdentifierNode));
var VarList = new NonTerminal("var list", typeof(LuaIdentifierNodeList));
var NameList = new NonTerminal("name list", typeof(LuaIdentifierNodeList));
var ExprList = new NonTerminal("expr list", typeof(LuaExpressionNodeList));
var ExprListOpt = new NonTerminal("expr list opt", typeof(LuaExpressionNodeList));
var FunctionCall = new NonTerminal("function call", typeof(LuaFunctionCallNode));
var Function = new NonTerminal("anonymous function definition", typeof(LuaFunctionDefNode));
//var FuncBody = new NonTerminal("function body", typeof (LuaBlockNode));
var ParList = new NonTerminal("parlist", typeof(LuaParmListNode));
var LocalVariableDeclaration = new NonTerminal("local variable declaration", typeof(LuaLocalDeclaration));
var LocalVariableDeclarationWithAssignment = new NonTerminal("local variable declaration with assignment", typeof(LuaLocalDeclarationAssignment));
var TableConstructor = new NonTerminal("table constructor", typeof(LuaTableNode));
var TableAccess = new NonTerminal("table access", typeof(LuaTableAccessNode));
var FieldList = new NonTerminal("field list", typeof(LuaExpressionNodeList));
//var FieldList_Q = new NonTerminal("field list question", typeof(LuaNode));
var Field = new NonTerminal("field", typeof(LuaField));
var FieldSep = new NonTerminal("field seperator", typeof(LuaNode));
var FieldAndSep = new NonTerminal("field and seperator", typeof(LuaFieldAndSeperatorNode));
//var FieldSep_Q = new NonTerminal("field seperator question", typeof(LuaNode));
var IdentifierWithOptNamespace = new NonTerminal("identifier including namespace", typeof(LuaNode));
var BinExp = new NonTerminal("binexp", typeof(LuaBinaryExpressionNode))
{
Rule = Expr + BinOp + Expr
};
var UniExp = new NonTerminal("uniexp", typeof(LuaUnaryExpressionNode))
{
Rule = UnOp + Expr
};
var ElseIfBlock = new NonTerminal("ElseIfClause", typeof(LuaElseIfNode));
var ElseIfBlockList = new NonTerminal("ElseIfClause*", typeof(LuaElseIfListNode));
var ElseBlockOpt = new NonTerminal("ElseClause", typeof(LuaBlockNode));
var VariableAssignment = new NonTerminal("variable assignment", typeof(LuaAssignmentNode));
var DoBlock = new NonTerminal(NPLConstants.DoBlock, typeof(LuaDoBlockNode));
var WhileBlock = new NonTerminal(NPLConstants.WhileBlock, typeof(LuaWhileBlockNode));
var RepeatBlock = new NonTerminal(NPLConstants.RepeatBlock, typeof(LuaRepeatBlockNode));
var ConditionalBlock = new NonTerminal(NPLConstants.ConditionBlock, typeof(LuaIfNode));
var ForBlock = new NonTerminal(NPLConstants.ForBlock, typeof(LuaForBlockNode));
var GenericForBlock = new NonTerminal(NPLConstants.GenericForBlock, typeof(LuaForBlockNode));
var LocalFunctionDeclaration = new NonTerminal(NPLConstants.LocalFunctionDeclaration, typeof(LuaFunctionDefNode));
var FunctionDeclaration = new NonTerminal(NPLConstants.FunctionDeclaration, typeof(LuaFunctionDefNode));
var Expr23 = new NonTerminal("expr 23", typeof(LuaExpressionNodeList));
var SingleStatementWithTermStar = new NonTerminal(SingleStatementWithTermOpt.Name + "*", typeof(LuaNode));
#endregion
#region Place Rules Here
//Using Lua 5.1 grammar as defined in
//http://www.lua.org/manual/5.1/manual.html#8
Root = Chunk;
//chunk ::= {stat [`;´]} [laststat [`;´]]
SingleStatementWithTermStar.Rule = MakeStarRule(SingleStatementWithTermStar, SingleStatementWithTermOpt);
Statements.Rule = SingleStatementWithTermStar;
//Statements.Rule =
StatementsEnd.Rule = Empty | LastStatementWithTermOpt;
Block.Rule = Statements + StatementsEnd;
//block ::= chunk
Chunk.Rule = Block;
//stat ::= varlist `=´ explist |
VariableAssignment.Rule = VarList + EQ + ExprList;
// functioncall |
// do block end |
// while exp do block end |
// repeat block until exp |
// if exp then block {elseif exp then block} [else block] end |
// for Name `=´ exp `,´ exp [`,´ exp] do block end |
// for namelist in explist do block end |
// function funcname funcbody |
FunctionDeclaration.Rule = FUNCTION + FuncName + FunctionParameters + Block + END;
// local function Name funcbody |
LocalFunctionDeclaration.Rule = LOCAL + FUNCTION + FuncName + FunctionParameters + Block + END;
// local namelist [`=´ explist]
LocalVariableDeclaration.Rule = LOCAL + NameList;
LocalVariableDeclarationWithAssignment.Rule = LocalVariableDeclaration + EQ + ExprList;
DoBlock.Rule = DO + Block + END;
WhileBlock.Rule = WHILE + Expr + DO + Block + END;
RepeatBlock.Rule = REPEAT + Block + UNTIL + Expr;
ElseBlockOpt.Rule = Empty | ELSE + Block;
ElseIfBlock.Rule = ELSEIF + Expr + THEN + Block;
ElseIfBlockList.Rule = MakeStarRule(ElseIfBlockList, null, ElseIfBlock);
ConditionalBlock.Rule = IF + Expr + THEN + Block + ElseIfBlockList + ElseBlockOpt + END;
ForBlock.Rule = FOR + Name + EQ + Expr23 + DO + Block + END;
Expr23.Rule = Expr + "," + Expr | Expr + "," + Expr + "," + Expr;
GenericForBlock.Rule = FOR + NameList + IN + ExprList + DO + Block + END;
Statement.Rule = VariableAssignment |
FunctionCall |
DoBlock |
WhileBlock |
RepeatBlock |
ConditionalBlock |
ForBlock |
GenericForBlock |
FunctionDeclaration |
LocalFunctionDeclaration |
LocalVariableDeclaration |
LocalVariableDeclarationWithAssignment;
//laststat ::= return [explist] | break
LastStatement.Rule = RETURN + ExprList | RETURN | BREAK;
//funcname ::= Name {`.´ Name} [`:´ Name]
//FuncName.Rule = Name + (DOT + Name).Star() + (COLON + Name).Q();
ColonCallOpt.Rule = Empty | COLON + Name;
IdentifierWithOptNamespace.Rule = MakePlusRule(IdentifierWithOptNamespace, DOT, Name);
FuncName.Rule = IdentifierWithOptNamespace + ColonCallOpt;
//varlist ::= var {`,´ var}
VarList.Rule = MakePlusRule(VarList, ToTerm(","), Var);
//namelist ::= Name {`,´ Name}
NameList.Rule = MakePlusRule(NameList, ToTerm(","), Name);
//explist ::= {exp `,´} exp
ExprList.Rule = MakePlusRule(ExprList, ToTerm(","), Expr);
ExprListOpt.Rule = MakeStarRule(ExprListOpt, ToTerm(","), Expr);
//exp ::= nil | false | true | Number | String | `...´ | function |
// prefixexp | tableconstructor | exp binop exp | unop exp
Expr.Rule = NIL | FALSE | TRUE | NUMBER | STRING | LONGSTRING | ELLIPSIS | Function |
PrefixExpr | TableConstructor | BinExp | UniExp;
//var ::= Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name
TableAccess.Rule = PrefixExpr + "[" + Expr + "]" | PrefixExpr + DOT + Name;
Var.Rule = Name | TableAccess;
//prefixexp ::= var | functioncall | `(´ exp `)´
ParentheticalExpression.Rule = "(" + Expr + ")";
PrefixExpr.Rule = Var | FunctionCall | ParentheticalExpression;
//functioncall ::= prefixexp args | prefixexp `:´ Name args
FunctionCall.Rule = PrefixExpr + Args | PrefixExpr + COLON + Name + Args;
//args ::= `(´ [explist] `)´ | tableconstructor | String
ArgsParameters.Rule = "(" + ExprListOpt + ")";
Args.Rule = ArgsParameters | TableConstructor | STRING | LONGSTRING;
//function ::= function funcbody
Function.Rule = FUNCTION + FunctionParameters + Block + END;
//funcbody ::= `(´ [parlist] `)´ block end
FunctionParameters.Rule = "(" + ParList + ")";
//FuncBody.Rule = Block + END;
//parlist ::= namelist [`,´ `...´] | `...´
EllipsisOpt.Rule = Empty | ToTerm(",") + ELLIPSIS;
ParList.Rule = NameList + EllipsisOpt | ELLIPSIS | Empty;
//tableconstructor ::= `{´ [fieldlist] `}´
TableConstructor.Rule = "{" + FieldListOpt + "}";
//TableConstructor.Rule = "{" + FieldList + "}";// | "{" + "}";
//fieldlist ::= field {fieldsep field} [fieldsep]
//FieldList.Rule = Field + (FieldSep + Field).Star() + FieldSep.Q();
FieldList.Rule = MakeStarRule(FieldList, FieldAndSep);
FieldListOpt.Rule = FieldList | Empty;
//field ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp
Field.Rule = "[" + Expr + "]" + "=" + Expr | Name + "=" + Expr | Expr;
FieldAndSep.Rule = Field + FieldSepOpt;
//fieldsep ::= `,´ | `;´
FieldSep.Rule = ToTerm(",") | ";";
FieldSepOpt.Rule = FieldSep | Empty;
//binop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ |
// `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ |
// and | or
BinOp.Rule = PLUS | MINUS | MUL | DIV | POW | MOD | CONCAT |
LT | LTE | GT | GTE | EQUAL | NOTEQUAL |
AND | OR;
//unop ::= `-´ | not | `#´
UnOp.Rule = NOT | MINUS | GETN;
#endregion
#region Define Keywords and Register Symbols
//RegisterBracePair("(", ")");
//RegisterBracePair("{", "}");
//RegisterBracePair("[", "]");
// MarkPunctuation(COLON, DOT);
MarkPunctuation(",", ";");
MarkPunctuation("(", ")");
MarkPunctuation("{", "}");
MarkPunctuation("[", "]");
RegisterOperators(1, OR);
RegisterOperators(2, AND);
RegisterOperators(3, "<", ">", "<=", ">=", "~=", "==");
RegisterOperators(4, Associativity.Right, CONCAT);
RegisterOperators(5, MINUS, PLUS);
RegisterOperators(6, "*", "/", "%");
RegisterOperators(7, NOT);
RegisterOperators(8, Associativity.Right, "^");
#endregion
LanguageFlags = LanguageFlags.CreateAst |
LanguageFlags.SupportsCommandLine | LanguageFlags.TailRecursive;
}
public KeyTerm ToTerm(string text, string name) {
KeyTerm term;
if (KeyTerms.TryGetValue(text, out term)) {
//update name if it was specified now and not before
if (string.IsNullOrEmpty(term.Name) && !string.IsNullOrEmpty(name))
term.Name = name;
return term;
}
//create new term
if (!CaseSensitive)
text = text.ToLower();
#if !SILICONSTUDIO_RUNTIME_CORECLR
text = string.Intern(text);
#endif
term = new KeyTerm(text, name);
KeyTerms[text] = term;
return term;
}
public JavaStubGrammar()
{
CommentTerminal single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n");
CommentTerminal delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(single_line_comment);
NonGrammarTerminals.Add(delimited_comment);
IdentifierTerminal identifier = new IdentifierTerminal("identifier");
KeyTerm keyword_package = Keyword("package");
KeyTerm keyword_import = Keyword("import");
KeyTerm keyword_public = Keyword("public");
KeyTerm keyword_protected = Keyword("protected");
KeyTerm keyword_static = Keyword("static");
KeyTerm keyword_final = Keyword("final");
KeyTerm keyword_abstract = Keyword("abstract");
KeyTerm keyword_synchronized = Keyword("synchronized");
KeyTerm keyword_default = Keyword("default");
KeyTerm keyword_native = Keyword("native");
KeyTerm keyword_volatile = Keyword("volatile");
KeyTerm keyword_transient = Keyword("transient");
KeyTerm keyword_enum = Keyword("enum");
KeyTerm keyword_class = Keyword("class");
KeyTerm keyword_interface = Keyword("interface");
KeyTerm keyword_at_interface = Keyword("@interface");
KeyTerm keyword_extends = Keyword("extends");
KeyTerm keyword_implements = Keyword("implements");
KeyTerm keyword_throw = Keyword("throw");
KeyTerm keyword_throws = Keyword("throws");
KeyTerm keyword_null = Keyword("null");
KeyTerm keyword_super = Keyword("super");
KeyTerm keyword_true = Keyword("true");
KeyTerm keyword_false = Keyword("false");
KeyTerm keyword_new = Keyword("new");
var compile_unit = DefaultNonTerminal("compile_unit");
var opt_package_decl = DefaultNonTerminal("opt_package_declaration");
var package_decl = DefaultNonTerminal("package_declaration");
var imports = DefaultNonTerminal("imports");
var import = DefaultNonTerminal("import");
var type_decls = DefaultNonTerminal("type_decls");
var type_decl = DefaultNonTerminal("type_decl");
var enum_decl = DefaultNonTerminal("enum_decl");
var enum_body = DefaultNonTerminal("enum_body");
var class_decl = DefaultNonTerminal("class_decl");
var opt_generic_arg_decl = DefaultNonTerminal("opt_generic_arg_decl");
var opt_extends_decl = DefaultNonTerminal("opt_extends_decl");
var opt_implements_decl = DefaultNonTerminal("opt_implements_decl");
var implements_decl = DefaultNonTerminal("implements_decl");
var interface_decl = DefaultNonTerminal("interface_decl");
var iface_or_at_iface = DefaultNonTerminal("iface_or_at_iface");
var type_body = DefaultNonTerminal("type_body");
var type_members = DefaultNonTerminal("type_members");
var type_member = DefaultNonTerminal("type_member");
var nested_type_decl = DefaultNonTerminal("nested_type_decl");
var ctor_decl = DefaultNonTerminal("ctor_decl");
var method_decl = DefaultNonTerminal("method_decl");
var field_decl = DefaultNonTerminal("field_decl");
var opt_field_assignment = DefaultNonTerminal("opt_field_assignment");
var static_ctor_decl = DefaultNonTerminal("static_ctor_decl");
var enum_members_decl = DefaultNonTerminal("enum_members_decl");
var enum_member_initializers = DefaultNonTerminal("enum_member_initializers");
var enum_member_initializer = DefaultNonTerminal("enum_member_initializer");
var opt_enum_braces = DefaultNonTerminal("opt_enum_braces");
var opt_final_field_assign = DefaultNonTerminal("opt_final_field_assign");
var final_field_assign = DefaultNonTerminal("final_field_assign");
var terminate_decl_or_body = DefaultNonTerminal("terminate_decl_or_body");
var assignments = DefaultNonTerminal("assignments");
var assignment = DefaultNonTerminal("assignment");
var assign_expr = DefaultNonTerminal("assign_expr");
var rvalue_expressions = DefaultNonTerminal("rvalue_expressions");
var rvalue_expression = DefaultNonTerminal("rvalue_expression");
var array_literal = DefaultNonTerminal("array_literal");
var annotations = DefaultNonTerminal("annotations");
var annotation = DefaultNonTerminal("annotation");
var opt_annotation_args = DefaultNonTerminal("opt_annotation_args");
var annotation_value_assignments = DefaultNonTerminal("annotation_value_assignments");
var annot_assign_expr = DefaultNonTerminal("annot_assign_expr");
var modifiers_then_opt_generic_arg = DefaultNonTerminal("modifiers_then_opt_generic_arg");
var modifier_or_generic_arg = DefaultNonTerminal("modifier_or_generic_arg");
var modifiers = DefaultNonTerminal("modifiers");
var modifier = DefaultNonTerminal("modifier");
var argument_decls = DefaultNonTerminal("argument_decls");
var argument_decl = DefaultNonTerminal("argument_decl");
var comma_separated_types = DefaultNonTerminal("comma_separated_types");
var throws_decl = DefaultNonTerminal("throws_decl");
var opt_throws_decl = DefaultNonTerminal("opt_throws_decl");
var type_name = DefaultNonTerminal("type_name");
var dotted_identifier = DefaultNonTerminal("dotted_identifier");
var array_type = DefaultNonTerminal("array_type");
var vararg_type = DefaultNonTerminal("vararg_type");
var generic_type = DefaultNonTerminal("generic_type");
var generic_definition_arguments = DefaultNonTerminal("generic_definition_arguments");
var generic_definition_argument = DefaultNonTerminal("generic_definition_argument");
var generic_definition_constraints = DefaultNonTerminal("generic_definition_constraints");
var generic_definition_arguments_spec = DefaultNonTerminal("generic_definition_arguments_spec");
var generic_instance_arguments_spec = DefaultNonTerminal("generic_instance_arguments_spec");
var generic_instance_arguments = DefaultNonTerminal("generic_instance_arguments");
var generic_instance_argument = DefaultNonTerminal("generic_instance_argument");
var generic_instance_identifier_or_q = DefaultNonTerminal("generic_instance_identifier_or_q");
var generic_instance_constraints = DefaultNonTerminal("generic_instance_constraints");
var generic_instance_constraints_extends = DefaultNonTerminal("generic_instance_constraints_extends");
var generic_instance_constraints_super = DefaultNonTerminal("generic_instance_constraints_super");
var generic_instance_constraint_types = DefaultNonTerminal("generic_instance_constraint_types");
var impl_expressions = DefaultNonTerminal("impl_expressions");
var impl_expression = DefaultNonTerminal("impl_expression");
var call_super = DefaultNonTerminal("call_super");
var super_args = DefaultNonTerminal("super_args");
var default_value_expr = DefaultNonTerminal("default_value_expr");
var default_value_casted = DefaultNonTerminal("default_value_casted");
var default_value_literal = DefaultNonTerminal("default_value_literal");
var new_array = DefaultNonTerminal("new_array");
var runtime_exception = DefaultNonTerminal("runtime_exception");
var numeric_terminal = TerminalFactory.CreateCSharpNumber("numeric_value_literal");
numeric_terminal.AddPrefix("-", NumberOptions.AllowSign);
numeric_terminal.AddPrefix("+", NumberOptions.AllowSign);
//numeric_terminal.AddSuffix ("f");
numeric_terminal.AddSuffix("L");
var numeric_literal = DefaultNonTerminal("numeric_literal");
var string_literal = TerminalFactory.CreateCSharpString("string_literal");
var value_literal = DefaultNonTerminal("value_literal");
var identifier_wild = DefaultNonTerminal("identifier_wild");
// <construction_rules>
compile_unit.Rule = opt_package_decl + imports + type_decls;
opt_package_decl.Rule = package_decl | Empty;
package_decl.Rule = keyword_package + dotted_identifier + ";";
imports.Rule = MakeStarRule(imports, import);
import.Rule = keyword_import + dotted_identifier + ";";
type_decls.Rule = MakeStarRule(type_decls, type_decl);
type_decl.Rule = class_decl | interface_decl | enum_decl;
// FIXME: those modifiers_then_opt_generic_arg should be actually just modifiers... see modifiers_then_opt_generic_arg.Rule below.
enum_decl.Rule = annotations + modifiers_then_opt_generic_arg + keyword_enum + identifier + opt_implements_decl + "{" + enum_body + "}";
enum_body.Rule = Empty | enum_members_decl + type_members;
class_decl.Rule = annotations + modifiers_then_opt_generic_arg + keyword_class + identifier + opt_generic_arg_decl + opt_extends_decl + opt_implements_decl + type_body;
interface_decl.Rule = annotations + modifiers_then_opt_generic_arg + iface_or_at_iface + identifier + opt_generic_arg_decl + opt_extends_decl + opt_implements_decl + type_body;
iface_or_at_iface.Rule = keyword_interface | keyword_at_interface;
opt_generic_arg_decl.Rule = Empty | "<" + generic_definition_arguments + ">";
opt_extends_decl.Rule = Empty | keyword_extends + implements_decl; // when it is used with an interface, it can be more than one...
opt_implements_decl.Rule = Empty | keyword_implements + implements_decl;
implements_decl.Rule = MakePlusRule(implements_decl, ToTerm(","), type_name);
type_body.Rule = T("{") + type_members + T("}");
annotations.Rule = MakeStarRule(annotations, annotation);
annotation.Rule = T("@") + dotted_identifier + opt_annotation_args;
opt_annotation_args.Rule = Empty | T("(") + annotation_value_assignments + T(")");
annotation_value_assignments.Rule = rvalue_expression | MakeStarRule(annotation_value_assignments, ToTerm(","), annot_assign_expr);
annot_assign_expr.Rule = assign_expr | T("{") + rvalue_expressions + T("}");
// HACK: I believe this is an Irony bug that adding opt_generic_arg_decl here results in shift-reduce conflict, but it's too complicated to investigate the actual issue.
// As a workaround I add generic arguments as part of this "modifier" so that it can be safely added to a generic method declaration.
modifiers_then_opt_generic_arg.Rule = MakeStarRule(modifiers_then_opt_generic_arg, modifier_or_generic_arg);
modifiers.Rule = MakeStarRule(modifiers, modifier);
modifier_or_generic_arg.Rule = modifier | generic_definition_arguments_spec;
modifier.Rule = keyword_public | keyword_protected | keyword_final | keyword_abstract | keyword_synchronized | keyword_default | keyword_native | keyword_volatile | keyword_transient | keyword_static;
type_members.Rule = MakeStarRule(type_members, type_member);
type_member.Rule = nested_type_decl | ctor_decl | method_decl | field_decl | static_ctor_decl;
nested_type_decl.Rule = type_decl;
enum_members_decl.Rule = enum_member_initializers + ";";
enum_member_initializers.Rule = MakeStarRule(enum_member_initializers, ToTerm(","), enum_member_initializer);
enum_member_initializer.Rule = annotations + identifier + opt_enum_braces;
opt_enum_braces.Rule = Empty | "(" + ")";
static_ctor_decl.Rule = annotations + keyword_static + "{" + assignments + "}";
assignments.Rule = MakeStarRule(assignments, assignment);
assignment.Rule = assign_expr + ";";
assign_expr.Rule = identifier + "=" + rvalue_expression;
rvalue_expressions.Rule = MakeStarRule(rvalue_expressions, ToTerm(","), rvalue_expression);
rvalue_expression.Rule = value_literal | new_array | type_name | identifier | array_literal | annotation;
array_literal.Rule = "{" + rvalue_expressions + "}";
field_decl.Rule = annotations + modifiers_then_opt_generic_arg + type_name + identifier + opt_field_assignment + ";" + opt_final_field_assign;
opt_field_assignment.Rule = Empty | "=" + rvalue_expression;
opt_final_field_assign.Rule = Empty | "{" + assign_expr + ";" + "}";
terminate_decl_or_body.Rule = ";" | ("{" + impl_expressions + "}") | (keyword_default + default_value_literal + ";");
ctor_decl.Rule = annotations + modifiers_then_opt_generic_arg + identifier + "(" + argument_decls + ")" + opt_throws_decl + terminate_decl_or_body; // these Empties can make the structure common to method_decl.
method_decl.Rule = annotations + modifiers_then_opt_generic_arg + /*opt_generic_arg_decl*/ type_name + identifier + "(" + argument_decls + ")" + opt_throws_decl + terminate_decl_or_body;
impl_expressions.Rule = MakeStarRule(impl_expressions, impl_expression);
impl_expression.Rule = call_super | runtime_exception | assign_expr;
call_super.Rule = keyword_super + "(" + super_args + ")" + ";";
super_args.Rule = MakeStarRule(super_args, ToTerm(","), default_value_expr);
default_value_expr.Rule = keyword_null | default_value_casted | default_value_literal;
default_value_casted.Rule = "(" + type_name + ")" + default_value_expr;
default_value_literal.Rule = numeric_terminal | "\"\"" | "{" + "}" | keyword_true | keyword_false;
runtime_exception.Rule = keyword_throw + keyword_new + identifier + "(\"Stub!\"" + ")" + ";";
new_array.Rule = keyword_new + dotted_identifier + "[" + numeric_literal + "]";
argument_decls.Rule = annotations | MakeStarRule(argument_decls, ToTerm(","), argument_decl);
argument_decl.Rule = annotations + type_name + identifier;
throws_decl.Rule = keyword_throws + comma_separated_types;
comma_separated_types.Rule = MakeStarRule(comma_separated_types, ToTerm(","), type_name);
opt_throws_decl.Rule = Empty | throws_decl;
type_name.Rule = dotted_identifier | array_type | vararg_type | generic_type;
vararg_type.Rule = type_name + T("...");
array_type.Rule = type_name + ("[") + T("]");
generic_definition_arguments_spec.Rule = "<" + generic_definition_arguments + ">";
generic_type.Rule = dotted_identifier + generic_instance_arguments_spec;
generic_instance_arguments_spec.Rule = "<" + generic_instance_arguments + ">";
generic_definition_arguments.Rule = MakePlusRule(generic_definition_arguments, ToTerm(","), generic_definition_argument);
generic_definition_argument.Rule = identifier + generic_definition_constraints;
generic_definition_constraints.Rule = Empty | generic_instance_constraints_extends | generic_instance_constraints_super;
generic_instance_arguments.Rule = MakePlusRule(generic_instance_arguments, ToTerm(","), generic_instance_argument);
generic_instance_argument.Rule = generic_instance_identifier_or_q + generic_instance_constraints;
generic_instance_identifier_or_q.Rule = type_name | T("?");
generic_instance_constraints.Rule = Empty | generic_instance_constraints_extends | generic_instance_constraints_super;
generic_instance_constraints_extends.Rule = keyword_extends + generic_instance_constraint_types;
generic_instance_constraints_super.Rule = keyword_super + generic_instance_constraint_types;
generic_instance_constraint_types.Rule = MakePlusRule(generic_instance_constraint_types, ToTerm("&"), type_name);
dotted_identifier.Rule = MakePlusRule(dotted_identifier, ToTerm("."), identifier_wild);
numeric_literal.Rule = numeric_terminal;
numeric_literal.Rule |= "(" + numeric_literal + "/" + numeric_literal + ")";
value_literal.Rule = string_literal | numeric_literal | keyword_null;
identifier_wild.Rule = identifier | "*";
// Define AST node creators
Func <string, string> stripGenerics = s => s.IndexOf('<') > 0 ? s.Substring(0, s.IndexOf('<')) : s;
single_line_comment.AstConfig.NodeCreator = DoNothing;
delimited_comment.AstConfig.NodeCreator = DoNothing;
identifier.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.Token.ValueString;
compile_unit.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new JavaPackage(null)
{
Name = (string)node.ChildNodes [0].AstNode, Types = ((IEnumerable <JavaType>)node.ChildNodes [2].AstNode).ToList()
};
};
opt_package_decl.AstConfig.NodeCreator = SelectSingleChild;
package_decl.AstConfig.NodeCreator = SelectChildValueAt(1);
imports.AstConfig.NodeCreator = CreateArrayCreator <object> ();
import.AstConfig.NodeCreator = SelectChildValueAt(1);
type_decls.AstConfig.NodeCreator = CreateArrayCreator <JavaType> ();
type_decl.AstConfig.NodeCreator = SelectSingleChild;
opt_generic_arg_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode;
};
opt_extends_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode;
};
opt_implements_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode;
};
implements_decl.AstConfig.NodeCreator = CreateArrayCreator <string> ();
Action <ParseTreeNode, JavaType> fillType = (node, type) => {
var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode;
var mods = modsOrTps.OfType <string> ();
bool isEnum = node.ChildNodes [2].AstNode as string == "enum";
type.Abstract |= mods.Contains("abstract");
type.Static |= mods.Contains("static");
type.Final |= mods.Contains("final");
type.Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? "";
type.Name = (string)node.ChildNodes [3].AstNode;
type.Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated";
type.TypeParameters = isEnum ? null : (JavaTypeParameters)node.ChildNodes [4].AstNode;
type.Members = (IList <JavaMember>)node.ChildNodes [isEnum ? 6 : 7].AstNode;
};
enum_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var type = new JavaClass(null)
{
Extends = "java.lang.Enum", Final = true
};
var methods = new JavaMember [] {
new JavaMethod(null)
{
Deprecated = "not deprecated",
Name = "valueOf",
// Return needs to be filled later, with full package name.
Static = true,
Visibility = "public",
Parameters = new JavaParameter [] { new JavaParameter(null)
{
Name = "name", Type = "java.lang.String"
} },
},
new JavaMethod(null)
{
Deprecated = "not deprecated",
Name = "values",
// Return needs to be filled later, with full package name.
Static = true,
Visibility = "public",
Parameters = new JavaParameter [0],
}
};
fillType(node, type);
node.AstNode = type;
};
class_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var exts = ((IEnumerable <string>)node.ChildNodes [5].AstNode) ?? Enumerable.Empty <string> ();
var impls = ((IEnumerable <string>)node.ChildNodes [6].AstNode) ?? Enumerable.Empty <string> ();
var ext = exts.FirstOrDefault() ?? "java.lang.Object";
var type = new JavaClass(null)
{
Extends = stripGenerics(ext),
ExtendsGeneric = ext,
Implements = impls.Select(s => new JavaImplements {
Name = stripGenerics(s), NameGeneric = s
}).ToArray(),
};
fillType(node, type);
node.AstNode = type;
};
interface_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
bool annot = node.ChildNodes [2].AstNode as string == "@interface";
var exts = ((IEnumerable <string>)node.ChildNodes [5].AstNode) ?? Enumerable.Empty <string> ();
var impls = ((IEnumerable <string>)node.ChildNodes [6].AstNode) ?? Enumerable.Empty <string> ();
var type = new JavaInterface(null)
{
Implements = exts.Concat(impls).Select(s => new JavaImplements {
Name = stripGenerics(s), NameGeneric = s
}).ToList(),
};
if (annot)
{
type.Implements.Add(new JavaImplements {
Name = "java.lang.annotation.Annotation", NameGeneric = "java.lang.annotation.Annotation"
});
}
fillType(node, type);
node.AstNode = type;
};
iface_or_at_iface.AstConfig.NodeCreator = SelectSingleChild;
type_body.AstConfig.NodeCreator = SelectChildValueAt(1);
type_members.AstConfig.NodeCreator = CreateArrayCreator <JavaMember> ();
type_member.AstConfig.NodeCreator = SelectSingleChild;
nested_type_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new JavaNestedType(null)
{
Type = (JavaType)node.ChildNodes [0].AstNode
};
};
Action <ParseTreeNode, JavaMethodBase> fillMethodBase = (node, method) => {
bool ctor = node.ChildNodes.Count == 8;
var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode;
var mods = modsOrTps.OfType <string> ();
method.Static = mods.Contains("static");
method.Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? "";
method.Name = (string)node.ChildNodes [ctor ? 2 : 3].AstNode;
method.Parameters = ((IEnumerable <JavaParameter>)node.ChildNodes [ctor ? 4 : 5].AstNode).ToArray();
method.ExtendedSynthetic = mods.Contains("synthetic");
// HACK: Exception "name" can be inconsistent for nested types, and this nested type detection is hacky.
Func <string, string> stripPackage = s => {
var packageTokens = s.Split('.').TakeWhile(t => !t.Any(c => Char.IsUpper(c)));
return(s.Substring(Enumerable.Sum(packageTokens.Select(t => t.Length)) + packageTokens.Count()));
};
method.Exceptions = ((IEnumerable <string>)node.ChildNodes [ctor ? 6 : 7].AstNode)
?.Select(s => new JavaException {
Type = s, Name = stripPackage(s)
})
?.ToArray();
method.Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated";
method.Final = mods.Contains("final");
method.TypeParameters = modsOrTps.OfType <JavaTypeParameters> ().FirstOrDefault();
};
ctor_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var annots = node.ChildNodes [0].AstNode;
var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode;
var mods = modsOrTps.OfType <string> ();
var ctor = new JavaConstructor(null);
fillMethodBase(node, ctor);
node.AstNode = ctor;
};
method_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var annots = node.ChildNodes [0].AstNode;
var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode;
var mods = modsOrTps.OfType <string> ();
var method = new JavaMethod(null)
{
Return = (string)node.ChildNodes [2].AstNode,
Abstract = mods.Contains("abstract"),
Native = mods.Contains("native"),
Synchronized = mods.Contains("synchronized"),
ExtendedSynthetic = mods.Contains("synthetic"),
};
fillMethodBase(node, method);
node.AstNode = method;
};
field_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var annots = node.ChildNodes [0].AstNode;
var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode;
var mods = modsOrTps.OfType <string> ();
var value = node.ChildNodes [4].AstNode?.ToString();
var type = (string)node.ChildNodes [2].AstNode;
node.AstNode = new JavaField(null)
{
Static = mods.Contains("static"),
Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? "",
Type = stripGenerics(type),
TypeGeneric = type,
Name = (string)node.ChildNodes [3].AstNode,
Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated",
Value = value == "null" ? null : value, // null will not be explicitly written.
Volatile = mods.Contains("volatile"),
Final = mods.Contains("final"),
Transient = mods.Contains("transient"),
};
};
opt_field_assignment.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.ChildNodes.Count > 0 ? node.ChildNodes [1].AstNode : null;
opt_final_field_assign.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.ChildNodes.Count > 0 ? node.ChildNodes [1].AstNode : null;
static_ctor_decl.AstConfig.NodeCreator = DoNothing; // static constructors are ignorable.
enum_body.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var ml = new List <JavaMember> ();
foreach (var c in node.ChildNodes)
{
ml.AddRange((IEnumerable <JavaMember>)c.AstNode);
}
node.AstNode = ml;
};
enum_members_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
if (node.ChildNodes.Count > 0)
{
node.AstNode = ((IEnumerable <string>)node.ChildNodes [0].AstNode)
.Select(s => new JavaField(null)
{
Name = s,
Final = true,
Deprecated = "not deprecated",
Static = true,
// Type needs to be filled later, with full package name.
Visibility = "public"
});
}
};
enum_member_initializers.AstConfig.NodeCreator = CreateArrayCreator <string> ();
enum_member_initializer.AstConfig.NodeCreator = SelectChildValueAt(1);
opt_enum_braces.AstConfig.NodeCreator = DoNothing;
terminate_decl_or_body.AstConfig.NodeCreator = DoNothing; // method/ctor body doesn't matter.
assignments.AstConfig.NodeCreator = CreateArrayCreator <object> ();
assignment.AstConfig.NodeCreator = SelectChildValueAt(0);
assign_expr.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new KeyValuePair <string, string?> ((string)node.ChildNodes [0].AstNode, node.ChildNodes [2].AstNode?.ToString());
};
rvalue_expressions.AstConfig.NodeCreator = CreateArrayCreator <object> ();
rvalue_expression.AstConfig.NodeCreator = SelectSingleChild;
array_literal.AstConfig.NodeCreator = CreateStringFlattener();
annotations.AstConfig.NodeCreator = CreateArrayCreator <string> ();
annotation.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node.ChildNodes [1]); // we only care about name.
node.AstNode = node.ChildNodes [1].AstNode;
};
opt_annotation_args.AstConfig.NodeCreator = DoNothing;
annotation_value_assignments.AstConfig.NodeCreator = DoNothing;
annot_assign_expr.AstConfig.NodeCreator = DoNothing;
modifiers_then_opt_generic_arg.AstConfig.NodeCreator = CreateArrayCreator <object> ();
modifier_or_generic_arg.AstConfig.NodeCreator = SelectSingleChild;
modifiers.AstConfig.NodeCreator = CreateArrayCreator <string> ();
modifier.AstConfig.NodeCreator = CreateStringFlattener();
argument_decls.AstConfig.NodeCreator = CreateArrayCreator <JavaParameter> ();
argument_decl.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new JavaParameter(null)
{
Type = (string)node.ChildNodes [1].AstNode, Name = (string)node.ChildNodes [2].AstNode
};
};
opt_throws_decl.AstConfig.NodeCreator = SelectSingleChild;
throws_decl.AstConfig.NodeCreator = SelectChildValueAt(1);
comma_separated_types.AstConfig.NodeCreator = CreateArrayCreator <string> ();
type_name.AstConfig.NodeCreator = SelectSingleChild;
dotted_identifier.AstConfig.NodeCreator = CreateStringFlattener(".");
array_type.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = node.ChildNodes [0].AstNode + "[]";
};
vararg_type.AstConfig.NodeCreator = CreateStringFlattener();
generic_type.AstConfig.NodeCreator = CreateStringFlattener();
generic_definition_arguments_spec.AstConfig.NodeCreator = SelectChildValueAt(1);
generic_instance_arguments_spec.AstConfig.NodeCreator = (ctx, node) => {
// It is distinct from generic type parameters definition.
ProcessChildren(ctx, node);
node.AstNode = "<" + string.Join(", ", (IEnumerable <string>)node.ChildNodes [1].AstNode) + ">";
};
generic_definition_arguments.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new JavaTypeParameters((JavaMethod?)null)
{
TypeParameters = node.ChildNodes.Select(c => c.AstNode).Cast <JavaTypeParameter> ().ToList()
};
};
generic_definition_argument.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
node.AstNode = new JavaTypeParameter(null)
{
Name = (string)node.ChildNodes [0].AstNode,
GenericConstraints = (JavaGenericConstraints)node.ChildNodes [1].AstNode
};
};
generic_definition_constraints.AstConfig.NodeCreator = SelectSingleChild;
generic_instance_arguments.AstConfig.NodeCreator = CreateArrayCreator <string> ();
generic_instance_argument.AstConfig.NodeCreator = CreateStringFlattener();
generic_instance_identifier_or_q.AstConfig.NodeCreator = SelectSingleChild;
generic_instance_constraints.AstConfig.NodeCreator = (ctx, node) => {
ProcessChildren(ctx, node);
var c = (JavaGenericConstraints?)node.ChildNodes.FirstOrDefault()?.AstNode;
if (c != null)
{
node.AstNode = " " + c.BoundsType + " " + string.Join(" & ", c.GenericConstraints.Select(cc => cc.Type));
}
};
AstNodeCreator createGenericConstaints = (ctx, node) => {
ProcessChildren(ctx, node);
var cl = ((IEnumerable <string>)node.ChildNodes [1].AstNode).Select(s => new JavaGenericConstraint {
Type = s
});
node.AstNode = new JavaGenericConstraints()
{
BoundsType = (string)node.ChildNodes [0].AstNode,
GenericConstraints = cl.Any() ? cl.ToArray() : null,
};
};
generic_instance_constraints_extends.AstConfig.NodeCreator = createGenericConstaints;
generic_instance_constraints_super.AstConfig.NodeCreator = createGenericConstaints;
generic_instance_constraint_types.AstConfig.NodeCreator = CreateArrayCreator <string> ();
impl_expressions.AstConfig.NodeCreator = CreateArrayCreator <object> ();
impl_expression.AstConfig.NodeCreator = SelectSingleChild;
// each expression item is not seriously processed.
// They are insignificant except for consts, and for consts they are just string values.
call_super.AstConfig.NodeCreator = CreateStringFlattener();
super_args.AstConfig.NodeCreator = CreateStringFlattener();
default_value_expr.AstConfig.NodeCreator = CreateStringFlattener();
default_value_casted.AstConfig.NodeCreator = CreateStringFlattener();
default_value_literal.AstConfig.NodeCreator = CreateStringFlattener();
new_array.AstConfig.NodeCreator = DoNothing;
runtime_exception.AstConfig.NodeCreator = CreateStringFlattener();
Func <string, string, string> stripTail = (s, t) => s.EndsWith(t, StringComparison.Ordinal) ? s.Substring(0, s.Length - t.Length) : s;
numeric_terminal.AstConfig.NodeCreator = (ctx, node) => node.AstNode = stripTail(stripTail(node.Token.Text, "L"), "f");
numeric_literal.AstConfig.NodeCreator = CreateStringFlattener();
string_literal.AstConfig.NodeCreator = (ctx, node) => node.AstNode = '"' + node.Token.ValueString + '"';
value_literal.AstConfig.NodeCreator = SelectSingleChild;
identifier_wild.AstConfig.NodeCreator = SelectSingleChild;
this.Root = compile_unit;
}
///--------------------------------------------------------------------------------
/// <summary>The default constructor sets up the overall grammar.</summary>
///
/// <param name="solution">The solution containing model structure to add to the grammar.</param>
///--------------------------------------------------------------------------------
public CodeTemplateContentGrammar(Solution solution)
{
bool isFirstItem = true;
this.LanguageFlags |= LanguageFlags.CreateAst;
this.GrammarComments = "This grammar is used to parse the CONTENT section of an M+ code template.";
#region "Literals, Symbols, Operators, Punctuation, etc."
// literals
StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
NumberLiteral Number = TerminalFactory.CreateCSharpNumber("Number");
Number.Options |= NumberOptions.AllowSign;
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
// symbols
KeyTerm textOpen = ToTerm(LanguageTerms.TextOpenTag);
KeyTerm evalOpen = ToTerm(LanguageTerms.EvalOpenTag);
KeyTerm outputOpen = ToTerm(LanguageTerms.OutputOpenTag);
KeyTerm propOpen = ToTerm(LanguageTerms.PropOpenTag);
KeyTerm close = ToTerm(LanguageTerms.CloseTag);
KeyTerm dot = ToTerm(".");
KeyTerm comma = ToTerm(",");
KeyTerm Lbr = ToTerm("{");
KeyTerm Rbr = ToTerm("}");
KeyTerm Lpar = ToTerm("(");
KeyTerm Rpar = ToTerm(")");
KeyTerm slash = ToTerm("/");
// operators
RegisterOperators(1, "||");
RegisterOperators(2, "&&");
RegisterOperators(3, "==", "!=");
RegisterOperators(4, "<", ">", "<=", ">=");
RegisterOperators(5, ".");
RegisterOperators(6, "+", "-", "*", "/");
// delimiters and punctuation
this.Delimiters = "{}[](),:;+-*/%&|^!~<>=";
this.MarkPunctuation("=", ";", ",", "(", ")", "{", "}", ".", LanguageTerms.ProgressTerm, LanguageTerms.TraceTerm, LanguageTerms.DebugTerm, LanguageTerms.WhileTerm, LanguageTerms.VarTerm, LanguageTerms.ParamTerm, LanguageTerms.IfTerm, LanguageTerms.ElseTerm, LanguageTerms.WithTerm, LanguageTerms.ForeachTerm, LanguageTerms.BreakTerm, LanguageTerms.ContinueTerm, LanguageTerms.ClearTerm, LanguageTerms.ReturnTerm, LanguageTerms.SwitchTerm, LanguageTerms.CaseTerm, LanguageTerms.DefaultTerm, LanguageTerms.WhereTerm, LanguageTerms.InTerm, LanguageTerms.LimitTerm, LanguageTerms.SortTerm, LanguageTerms.FromTerm, LanguageTerms.TextOpenTag, LanguageTerms.EvalOpenTag, LanguageTerms.OutputOpenTag, LanguageTerms.PropOpenTag, LanguageTerms.CloseTag);
// whitespace and line terminators
this.LineTerminators = "\r\n\u2085\u2028\u2029";
this.WhitespaceChars = " \t\r\n\v\u2085\u2028\u2029";
// comments
CommentTerminal singleLineComment = new CommentTerminal("singleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal delimitedComment = new CommentTerminal("delimitedComment", "/*", "*/");
TextTerminal templateText = new TextTerminal("templateText", "<%%-", "%%>");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
#endregion
#region "Nodes"
// high level nodes
var template = new NonTerminal("template", typeof(TemplateNode));
var templateBlock = new NonTerminal("templateBlock");
// statements
var statementList = new NonTerminal("statementList", typeof(StatementListNode));
var statement = new NonTerminal("statement");
var ifStatement = new NonTerminal("ifStatement", typeof(IfStatementNode));
var switchStatement = new NonTerminal("switchStatement", typeof(SwitchStatementNode));
var foreachStatement = new NonTerminal("foreachStatement", typeof(ForeachStatementNode));
var whileStatement = new NonTerminal("whileStatement", typeof(WhileStatementNode));
var withStatement = new NonTerminal("withStatement", typeof(WithStatementNode));
var breakStatement = new NonTerminal("breakStatement", typeof(BreakStatementNode));
var clearStatement = new NonTerminal("clearStatement", typeof(ClearTextStatementNode));
var returnStatement = new NonTerminal("returnStatement", typeof(ReturnStatementNode));
var continueStatement = new NonTerminal("continueStatement", typeof(ContinueStatementNode));
var currentItemAssignmentStatement = new NonTerminal("currentItemAssignmentStatement", typeof(CurrentItemAssignmentStatementNode));
var templatePropertyAssignmentStatement = new NonTerminal("templatePropertyAssignmentStatement", typeof(TemplatePropertyAssignmentStatementNode));
var debugStatement = new NonTerminal("debugStatement", typeof(DebugStatementNode));
var traceStatement = new NonTerminal("traceStatement", typeof(TraceStatementNode));
var logStatement = new NonTerminal("logStatement", typeof(LogStatementNode));
var progressStatement = new NonTerminal("progressStatement", typeof(ProgressStatementNode));
var varStatement = new NonTerminal("varStatement", typeof(VarStatementNode));
var paramStatement = new NonTerminal("paramStatement", typeof(ParamStatementNode));
var assignmentStatement = new NonTerminal("assignmentStatement", typeof(AssignmentStatementNode));
// clauses
var elseClause = new NonTerminal("elseClause", typeof(ElseClauseNode));
var elseIfList = new NonTerminal("elseIfList", typeof(ElseIfListNode));
var elseIfClause = new NonTerminal("elseIfClause", typeof(ElseIfClauseNode));
var caseList = new NonTerminal("caseList", typeof(CaseListNode));
var caseClause = new NonTerminal("caseClause", typeof(CaseClauseNode));
var defaultClause = new NonTerminal("defaultClause", typeof(DefaultClauseNode));
var caseConditionList = new NonTerminal("caseConditionList", typeof(CaseConditionListNode));
var caseCondition = new NonTerminal("caseCondition", typeof(CaseConditionNode));
var foreachClause = new NonTerminal("foreachClause", typeof(ForeachClauseNode));
var whereClause = new NonTerminal("whereClause", typeof(WhereClauseNode));
var inClause = new NonTerminal("inClause", typeof(InClauseNode));
var limitClause = new NonTerminal("limitClause", typeof(LimitClauseNode));
var sortClause = new NonTerminal("sortClause", typeof(SortClauseNode));
var sortDirectionClause = new NonTerminal("sortDirectionClause", typeof(SortDirectionClauseNode));
var fromClause = new NonTerminal("fromClause", typeof(FromClauseNode));
var templateParameterList = new NonTerminal("templateParameterList", typeof(TemplateParameterListNode));
var templateParameter = new NonTerminal("templateParameter", typeof(TemplateParameterNode));
// expressions
var expression = new NonTerminal("expression", typeof(ExpressionNode));
var binOp = new NonTerminal("binOp", "operator symbol", typeof(BinaryOperatorNode));
var mathOp = new NonTerminal("mathOp", "operator symbol", typeof(MathOperatorNode));
var literal = new NonTerminal("literal", typeof(LiteralNode));
var popContext = new NonTerminal("popContext", typeof(PopContextNode));
var thisContext = new NonTerminal("thisContext", typeof(ThisContextNode));
// properties
var property = new NonTerminal("property");
var contentProperty = new NonTerminal("contentProperty");
var templateProperty = new NonTerminal("templateProperty", typeof(TemplatePropertyNode));
var inClauseItem = new NonTerminal("inClauseItem", typeof(InClauselItemNode));
var modelContext = new NonTerminal("modelContext", typeof(ModelContextNode));
var currentItem = new NonTerminal("currentItem", typeof(CurrentItemNode));
var modelProperty = new NonTerminal("modelProperty", typeof(ModelPropertyNode));
var assignableProperty = new NonTerminal("assignableProperty", typeof(AssignablePropertyNode));
var configurationProperty = new NonTerminal("configurationProperty", typeof(ConfigurationPropertyNode));
var contextHelper = new NonTerminal("contextHelper", typeof(ContextHelperNode));
var collectionHelper = new NonTerminal("collectionHelper", typeof(CollectionHelperNode));
var parameter = new NonTerminal("parameter", typeof(ParameterNode));
#endregion
#region "Rules"
// a template consists of any number of template blocks
template.Rule = MakeStarRule(template, null, templateBlock);
// a template block is a property or an evaluation (a statement list surrounded by eval tags)
templateBlock.Rule = property | evalOpen + statementList + close;
// a statement list consists of any number of statements
statementList.Rule = MakeStarRule(statementList, null, statement);
// a statement can be an if, switch, foreach, with, or a property
statement.Rule = ifStatement
| switchStatement
| foreachStatement
| whileStatement
| withStatement
| breakStatement
| continueStatement
| clearStatement
| returnStatement
| currentItemAssignmentStatement
| templatePropertyAssignmentStatement
| traceStatement
| logStatement
| varStatement
| paramStatement
| assignmentStatement
| property
| progressStatement;
// var statement
varStatement.Rule = ToTerm(LanguageTerms.VarTerm) + identifier | ToTerm(LanguageTerms.VarTerm) + identifier + "=" + parameter;
// param statement
paramStatement.Rule = ToTerm(LanguageTerms.ParamTerm) + identifier;
// assignment statement
assignmentStatement.Rule = identifier + "=" + parameter;
// if statement
ifStatement.Rule = ToTerm(LanguageTerms.IfTerm) + Lpar + expression + Rpar + Lbr + statementList + Rbr + elseIfList + elseClause;
elseIfList.Rule = MakeStarRule(elseIfList, null, elseIfClause);
elseIfClause.Rule = ToTerm(LanguageTerms.ElseTerm) + LanguageTerms.IfTerm + Lpar + expression + Rpar + Lbr + statementList + Rbr;
elseClause.Rule = Empty | ToTerm(LanguageTerms.ElseTerm) + Lbr + statementList + Rbr;
// break and return statements, etc.
breakStatement.Rule = ToTerm(LanguageTerms.BreakTerm);
continueStatement.Rule = ToTerm(LanguageTerms.ContinueTerm);
clearStatement.Rule = ToTerm(LanguageTerms.ClearTerm);
returnStatement.Rule = ToTerm(LanguageTerms.ReturnTerm);
popContext.Rule = dot + dot + slash;
thisContext.Rule = ToTerm(LanguageTerms.ThisTerm);
// switch statement
switchStatement.Rule = ToTerm(LanguageTerms.SwitchTerm) + Lpar + modelProperty + Rpar + Lbr + caseList + defaultClause + Rbr;
caseList.Rule = MakePlusRule(caseList, null, caseClause);
caseClause.Rule = caseConditionList + statementList + breakStatement;
defaultClause.Rule = Empty | ToTerm(LanguageTerms.DefaultTerm) + ":" + statementList;
caseConditionList.Rule = MakePlusRule(caseConditionList, null, caseCondition);
caseCondition.Rule = ToTerm(LanguageTerms.CaseTerm) + literal + ":";
// a foreach statement consists of a foreach keyword, followed by a model context,
// optionally followed by a where clause, and includes a set of statements
// or, a foreach statement consists of a Record item
foreachStatement.Rule = ToTerm(LanguageTerms.ForeachTerm) + Lpar + foreachClause + Rpar + Lbr + statementList + Rbr;
foreachClause.Rule = modelContext + inClause + whereClause + limitClause + sortClause | ToTerm(LanguageTerms.RecordItem) + limitClause;
inClause.Rule = Empty | ToTerm(LanguageTerms.InTerm) + inClauseItem;
whereClause.Rule = Empty | ToTerm(LanguageTerms.WhereTerm) + expression;
limitClause.Rule = Empty | ToTerm(LanguageTerms.LimitTerm) + Number;
sortClause.Rule = Empty | ToTerm(LanguageTerms.SortTerm) + modelProperty + sortDirectionClause;
sortDirectionClause.Rule = Empty | ToTerm(LanguageTerms.AscTerm) | ToTerm(LanguageTerms.DescTerm);
// a while statement consists of a while keyword, followed by an expression,
// and includes a set of statements
whileStatement.Rule = ToTerm(LanguageTerms.WhileTerm) + Lpar + expression + Rpar + Lbr + statementList + Rbr;
// current item assignment statement
currentItemAssignmentStatement.Rule = currentItem + "=" + modelContext | currentItem + "=" + "null";
// template property assignment statement
templatePropertyAssignmentStatement.Rule = ToTerm(LanguageTerms.TextProperty) + "=" + parameter;
// debug statement
debugStatement.Rule = ToTerm(LanguageTerms.DebugTerm) + Lpar + parameter + Rpar
| ToTerm(LanguageTerms.DebugTerm) + Lpar + parameter + comma + parameter + Rpar;
// trace statement
traceStatement.Rule = ToTerm(LanguageTerms.TraceTerm) + Lpar + parameter + Rpar
| ToTerm(LanguageTerms.TraceTerm) + Lpar + parameter + comma + parameter + Rpar;
// log statement
logStatement.Rule = ToTerm(LanguageTerms.LogTerm) + Lpar + parameter + comma + parameter + comma + parameter + Rpar;
// a with statement consists of a with keyword, followed by a model context,
// and includes a set of statements
withStatement.Rule = ToTerm(LanguageTerms.WithTerm) + Lpar + modelContext + fromClause + Rpar + Lbr + statementList + Rbr | LanguageTerms.WithTerm + Lpar + currentItem + Rpar + Lbr + statementList + Rbr;
fromClause.Rule = Empty | ToTerm(LanguageTerms.FromTerm) + contextHelper;
// progress statement
progressStatement.Rule = ToTerm(LanguageTerms.ProgressTerm) | LanguageTerms.ProgressTerm + Lpar + parameter + Rpar;
// a context helper is one of the specifically supported internal methods to set model context
contextHelper.Rule = modelContext + dot + LanguageTerms.FindMethod + Lpar + modelProperty + comma + parameter + Rpar
| modelContext + dot + LanguageTerms.FindMethod + Lpar + parameter + Rpar
| currentItem + dot + LanguageTerms.FindMethod + Lpar + modelProperty + comma + parameter + Rpar
| currentItem + dot + LanguageTerms.FindMethod + Lpar + parameter + Rpar;
// a property is a content property or an output property
property.Rule = contentProperty | templateText;
// a content property can be a template property, model property, or configuration property (template property is lowest precedence)
contentProperty.Rule = propOpen + configurationProperty + close
| propOpen + parameter + close;
// a parameter is a model property or string literal
parameter.Rule = modelProperty | literal | parameter + mathOp + parameter;
// an in clause item is a collection from a model context, current item, or a special collection
inClauseItem.Rule = modelContext
| currentItem
| collectionHelper;
// a collection helper gets specialized collections
collectionHelper.Rule = modelContext + dot + LanguageTerms.FindAllMethod + Lpar + modelProperty + comma + parameter + Rpar
| currentItem + dot + LanguageTerms.FindAllMethod + Lpar + modelProperty + comma + parameter + Rpar
| ToTerm(LanguageTerms.GetEntityAndBasesCollection)
| ToTerm(LanguageTerms.GetBaseAndEntitiesCollection)
| ToTerm(LanguageTerms.ExtendingEntitiesCollection)
| ToTerm(LanguageTerms.PathRelationships);
// a current item node is a valid name of a type of node in the model that can be assigned to
isFirstItem = true;
// add all CurrentItemTypeCode enums to currentItem rule
foreach (string key in GrammarHelper.CurrentItemTypes.AllKeys)
{
if (isFirstItem == true)
{
currentItem.Rule = ToTerm(key);
isFirstItem = false;
}
else
{
currentItem.Rule = currentItem.Rule | ToTerm(key);
}
}
// add all ModelObject instances in model to currentItem rule
if (solution != null)
{
foreach (string key in solution.ModelObjectNames.AllKeys)
{
currentItem.Rule = currentItem.Rule | ToTerm("Current" + key);
}
}
// add all ModelObjectProperty instances in model to currentItem rule
if (solution != null)
{
foreach (string key in solution.ModelObjectPropertyNames.AllKeys)
{
currentItem.Rule = currentItem.Rule | ToTerm("Current" + key);
}
}
// a model context node is a valid name of a type of node in the model or a pop context directive
modelContext.Rule = popContext
| popContext + modelContext
| thisContext
| thisContext + dot + modelContext;
// add all ModelContextTypeCode enums to modelContext rule
foreach (string key in GrammarHelper.ModelContextTypes.AllKeys)
{
modelContext.Rule = modelContext.Rule | ToTerm(key);
}
// add all OtherModelContextTypeCode enums to modelContext rule
foreach (string key in GrammarHelper.OtherModelContextTypes.AllKeys)
{
modelContext.Rule = modelContext.Rule | ToTerm(key);
}
// add all ModelObject instances in model to modelContext rule
if (solution != null)
{
foreach (string key in solution.ModelObjectNames.AllKeys)
{
modelContext.Rule = modelContext.Rule | ToTerm(key);
}
}
// add all ModelObjectProperty instances in model to assignableProperty rule
if (solution != null)
{
foreach (string key in solution.ModelObjectPropertyNames.AllKeys)
{
modelContext.Rule = modelContext.Rule | ToTerm(key);
}
}
// an assignable property is a model property that can have values assigned to it
isFirstItem = true;
// add all AssignablePropertyCode enums to assignableProperty rule
foreach (string key in GrammarHelper.AssignableProperties.AllKeys)
{
if (isFirstItem == true)
{
assignableProperty.Rule = ToTerm(key);
isFirstItem = false;
}
else
{
assignableProperty.Rule = assignableProperty.Rule | ToTerm(key);
}
}
// add all ModelProperty instances in model to assignableProperty rule
if (solution != null)
{
foreach (string key in solution.ModelPropertyNames.AllKeys)
{
assignableProperty.Rule = assignableProperty.Rule | ToTerm(key);
}
}
// a model property is a valid property name of a node in the model (can refer to other nodes with the dot notation)
modelProperty.Rule = assignableProperty
| ToTerm(LanguageTerms.ItemIndexProperty)
| ToTerm(LanguageTerms.TextProperty)
| ToTerm(LanguageTerms.PathProperty)
//| ToTerm(LanguageTerms.LibraryDirectoryProperty)
| ToTerm(LanguageTerms.IsRelatedToProperty)
| modelContext + dot + modelProperty
| currentItem + dot + modelProperty
| templateProperty
| popContext + modelProperty
| thisContext + dot + modelProperty
| ToTerm(LanguageTerms.ColumnMethod) + Lpar + parameter + Rpar
| ToTerm(LanguageTerms.FileMethod) + Lpar + parameter + Rpar
| ToTerm(LanguageTerms.FileExistsMethod) + Lpar + parameter + Rpar
| ToTerm(LanguageTerms.LogMethod) + Lpar + parameter + comma + parameter + Rpar
| ToTerm(LanguageTerms.HasPropertyNamed) + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringStartsWith + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringEndsWith + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringContains + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringRegexReplace + Lpar + parameter + comma + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringRegexIsMatch + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringCamelCase + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringCapitalCase + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringCapitalWordCase + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringUnderscoreCase + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringToLower + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringToUpper + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringTrim + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringTrimStart + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringTrimEnd + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringReplace + Lpar + parameter + comma + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringFilter + Lpar + parameter + comma + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringFilterProtected + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringFilterIgnored + Lpar + Rpar
| modelProperty + dot + LanguageTerms.StringSubstring + Lpar + parameter + comma + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringSubstring + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringIndexOf + Lpar + parameter + Rpar
| modelProperty + dot + LanguageTerms.StringLength;
// add all ReadOnlyPropertyCode enums to modelProperty rule
foreach (string key in GrammarHelper.ReadOnlyProperties.AllKeys)
{
modelProperty.Rule = modelProperty.Rule | ToTerm(key);
}
// a configuration property is one of the specfically supported internal methods to process model data
configurationProperty.Rule = ToTerm(LanguageTerms.TabMethod) + Number
| ToTerm(LanguageTerms.UseTabsMethod) + "true"
| ToTerm(LanguageTerms.UseTabsMethod) + "false"
| ToTerm(LanguageTerms.TabStringMethod) + StringLiteral
| ToTerm(LanguageTerms.UseProtectedAreasMethod) + "true"
| ToTerm(LanguageTerms.UseProtectedAreasMethod) + "false"
| ToTerm(LanguageTerms.ProtectedAreaStartMethod) + StringLiteral
| ToTerm(LanguageTerms.ProtectedAreaEndMethod) + StringLiteral
| ToTerm(LanguageTerms.UseIgnoredAreasMethod) + "true"
| ToTerm(LanguageTerms.UseIgnoredAreasMethod) + "false"
| ToTerm(LanguageTerms.IgnoredAreaStartMethod) + StringLiteral
| ToTerm(LanguageTerms.IgnoredAreaEndMethod) + StringLiteral
| ToTerm(LanguageTerms.UserMethod)
| ToTerm(LanguageTerms.NowMethod);
// a template property from the parser perspective is just an identifier, the interpreter will resolve template references
templateProperty.Rule = identifier
| identifier + Lpar + templateParameterList + Rpar;
// a template parameter list consists of any number of template parameters delimited by commas
templateParameterList.Rule = MakeStarRule(templateParameterList, comma, templateParameter);
// template parameter
templateParameter.Rule = identifier + "=" + parameter;
// an expression can be a hierarchy of expressions with binary operators, model properties, and literals
expression.Rule = literal
| modelProperty
| modelContext
| currentItem
| expression + binOp + expression
| expression + mathOp + expression
| Lpar + expression + Rpar;
// a literal can be a number, string, character, true, false, or null
literal.Rule = Number | StringLiteral | "true" | "false" | "null";
// binary operator
binOp.Rule = ToTerm("||") | "&&" | "==" | "!=" | "<" | ">" | "<=" | ">=";
// math operator
mathOp.Rule = ToTerm("+") | "-" | "*" | "/";
#endregion
// the template is the root of the grammar
this.Root = template;
// mark nodes to filter from the parse tree
this.MarkTransient(statement, templateBlock, property, contentProperty);
}
public void RegisterBracePair(KeyTerm open, KeyTerm close)
{
open.SetFlag(TermFlags.IsOpenBrace);
open.IsPairFor = close;
close.SetFlag(TermFlags.IsCloseBrace);
close.IsPairFor = open;
}
private NonTerminal InitEmbeddedClassMember(KeyTerm beginSegment, KeyTerm endSegment)
{
_embeddedClassMemberText = new FreeTextLiteral("embeddedClassMemberText", endSegment.Text);
_embeddedClassMemberPrefix = ToTerm("+");
_embeddedClassMember = new NonTerminal("embeddedClassMember")
{
Rule = beginSegment + EmbeddedClassMemberPrefix + EmbeddedClassMemberText + endSegment
};
return EmbeddedClassMember;
}
public Language()
: base(false)
{
CommentTerminal LINE_COMMENT = new CommentTerminal("LINE_COMMENT", ">>", "\n", "\r\n");
CommentTerminal BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "<-", "->");
NonGrammarTerminals.Add(BLOCK_COMMENT);
NonGrammarTerminals.Add(LINE_COMMENT);
////----------------------------------Terminals with precedence
KeyTerm increase = ToTerm("++");
KeyTerm decrease = ToTerm("--");
KeyTerm plus = ToTerm("+");
KeyTerm minus = ToTerm("-");
KeyTerm by = ToTerm("*");
KeyTerm divided = ToTerm("/");
KeyTerm power = ToTerm("^");
KeyTerm lessThan = ToTerm("<");
KeyTerm greaterThan = ToTerm(">");
KeyTerm lessThanEqual = ToTerm("<=");
KeyTerm greaterThanEqual = ToTerm(">=");
KeyTerm doubleEqual = ToTerm("==");
KeyTerm different = ToTerm("!=");
KeyTerm not = ToTerm("!");
KeyTerm and = ToTerm("&&");
KeyTerm or = ToTerm("||");
////----------------------------------precedence
this.RegisterOperators(1, Associativity.Left, or);
this.RegisterOperators(2, Associativity.Left, and);
this.RegisterOperators(3, Associativity.Left, not);
this.RegisterOperators(4, Associativity.Left, doubleEqual, different, lessThan, lessThanEqual, greaterThan, greaterThanEqual);
this.RegisterOperators(5, Associativity.Left, plus, minus);
this.RegisterOperators(6, Associativity.Left, by, divided);
this.RegisterOperators(7, Associativity.Left, power);
//Regex
var integer = new RegexBasedTerminal("int", "[0-9]+");
var tdouble = TerminalFactory.CreateCSharpNumber("double");
var String = TerminalFactory.CreateCSharpString("string");
var caracter = TerminalFactory.CreateCSharpChar("char");
var boolean = new RegexBasedTerminal("bool", "(true)|(false)");
var iden = TerminalFactory.CreateCSharpIdentifier("id");
var hexa = new RegexBasedTerminal("hexa", "^(\\#)[0-9A-F]+$");
//Non terminals
var START = new NonTerminal("START");
var BODY = new NonTerminal("BODY");
var DECLARATION = new NonTerminal("DECLARATION");
var DECLARATION2 = new NonTerminal("DECLARATION2");
var ASSIGNATION = new NonTerminal("ASSIGNATION");
var ASSIGN2 = new NonTerminal("ASSIGN2");
var INDEX = new NonTerminal("INDEX");
var DATATYPE = new NonTerminal("DATATYPE");
var OBJECT = new NonTerminal("OBJECT");
var ASSIGN = new NonTerminal("ASSIGN");
var ARRAY = new NonTerminal("ARRAY");
var ARRAY2 = new NonTerminal("ARRAY2");
var ARRAYASIGN = new NonTerminal("ARRAYASIGN");
var ARRAYASIGN2 = new NonTerminal("ARRAYASIGN2");
var ARRAYASIGN3 = new NonTerminal("ARRAYASIGN3");
var ARRAYLIST = new NonTerminal("ARRAYLIST");
var NATIVE = new NonTerminal("NATIVE");
var PRINT = new NonTerminal("PRINT");
var SHOW = new NonTerminal("SHOW");
var IF = new NonTerminal("IF");
var ELSE = new NonTerminal("ELSE");
var FOR = new NonTerminal("FOR");
var REPEAT = new NonTerminal("REPEAT");
var WHILE = new NonTerminal("WHILE");
var VARMANAGMENT = new NonTerminal("VARMANAGMENT");
var UPDATE = new NonTerminal("UPDATE");
var ESINGLE = new NonTerminal("ESINGLE");
var E = new NonTerminal("E");
var ID = new NonTerminal("ID");
var IDPLUS = new NonTerminal("IDPLUS");
var ARRAYS = new NonTerminal("ARRAYS");
var DOWHILE = new NonTerminal("DOWHILE");
var SWITCH = new NonTerminal("SWITCH");
var CASE = new NonTerminal("CASE");
var DEFAULT = new NonTerminal("DEFAULT");
var CASELIST = new NonTerminal("CASELIST");
var FUNCTION = new NonTerminal("FUNCTION");
var FUNCTIONARGS = new NonTerminal("FUNCTIONARGS");
var VISIBILITY = new NonTerminal("VISIBILITY");
var OVERRIDE = new NonTerminal("OVERRIDE");
var PARAMLIST = new NonTerminal("PARAMLIST");
var PARAM = new NonTerminal("PARAM");
var OPTIONAL = new NonTerminal("OPTIONAL");
var RETURN = new NonTerminal("RETURN");
var RETOPTION = new NonTerminal("RETOPTION");
var LISTMETHODS = new NonTerminal("LISTMETHODS");
var CLASS = new NonTerminal("CLASS");
var EXTENDS = new NonTerminal("EXTENDS");
var EXTENDSLIST = new NonTerminal("EXTENDSLIST");
var CALLFUNC = new NonTerminal("CALLFUNC");
var ADDFIGURE = new NonTerminal("ADDFIGURE");
var GEOMETRICAS = new NonTerminal("GEOMETRICAS");
var COLOR = new NonTerminal("COLOR");
var FIGURE = new NonTerminal("FIGURE");
var MAIN = new NonTerminal("MAIN");
var CLASSIMPLEMENTATION = new NonTerminal("CLASSIMPLEMENTATION");
var CFUNCLIST = new NonTerminal("CFUNCLIST");
var LISTCLASSMETHODS = new NonTerminal("LISTCLASSMETHODS");
var LISTCLASSMETHODS2 = new NonTerminal("LISTCLASSMETHODS2");
var LISTOBJECTS = new NonTerminal("LISTCLASSMETHODS2");
////----------------------------------Innecesary nodes
this.MarkPunctuation(".", "(", ")", "{", "}", "[", "]", ";", "=", ",", "importar", "if", "for", "repeat", "mientras", "show", "hacer", "comprobar", "salir", "caso", ":", "print", "defecto", "clase", "addfigure", "main", "return");
this.MarkTransient(DECLARATION2, LISTCLASSMETHODS2, CLASSIMPLEMENTATION, BODY, ASSIGN2, COLOR, ARRAY2, ARRAYASIGN, ARRAYASIGN2, ARRAYASIGN3, NATIVE, VARMANAGMENT, ESINGLE, ASSIGN, ARRAY, ADDFIGURE, RETOPTION);
//----------------------------------Grammar
START.Rule = MakePlusRule(START, CLASS);
CLASS.Rule = "clase" + iden + EXTENDSLIST + "{" + CLASSIMPLEMENTATION + "}";
CLASS.ErrorRule = SyntaxError + "}";
CLASS.ErrorRule = SyntaxError + ";";
CLASSIMPLEMENTATION.Rule = MakeStarRule(CLASSIMPLEMENTATION, LISTCLASSMETHODS);
EXTENDSLIST.Rule = MakeStarRule(EXTENDSLIST, ToTerm(","), EXTENDS);
EXTENDS.Rule = ToTerm("importar") + ID;
LISTMETHODS.Rule = MakePlusRule(LISTMETHODS, BODY);
BODY.Rule = ID + ";" | FIGURE | ADDFIGURE | DECLARATION | ASSIGNATION | UPDATE + ";" | PRINT | SHOW | IF | FOR | REPEAT | WHILE | DOWHILE | SWITCH | OPTIONAL + ";" | Empty | CALLFUNC;
//methods inside a function
DECLARATION.Rule = DATATYPE + DECLARATION2 + ";";
DECLARATION.ErrorRule = SyntaxError + ";";
DECLARATION2.Rule = LISTOBJECTS | ToTerm("array") + ARRAYS;
LISTOBJECTS.Rule = MakePlusRule(LISTOBJECTS, ToTerm(","), OBJECT);
ARRAYS.Rule = ID + ARRAY;
ASSIGN.Rule = ToTerm("=") + E | Empty;
ASSIGNATION.Rule = ID + ASSIGN2 + ";";
ASSIGNATION.ErrorRule = SyntaxError + ";";
ASSIGN2.Rule = ToTerm("=") + E | "[" + E + "]" + ASSIGN2;
PRINT.Rule = ToTerm("print") + "(" + E + ")" + ";";
PRINT.ErrorRule = SyntaxError + ";";
SHOW.Rule = ToTerm("show") + "(" + E + "," + E + ")" + ";";
SHOW.ErrorRule = SyntaxError + ";";
IF.Rule = ToTerm("if") + "(" + E + ")" + "{" + LISTMETHODS + "}" + ELSE;
IF.ErrorRule = SyntaxError + "}";
IF.ErrorRule = SyntaxError + ";";
ELSE.Rule = ToTerm("else") + IF | ToTerm("else") + "{" + LISTMETHODS + "}" | Empty;
FOR.Rule = ToTerm("for") + "(" + VARMANAGMENT + E + ";" + UPDATE + ")" + "{" + LISTMETHODS + "}";
FOR.ErrorRule = SyntaxError + "}";
FOR.ErrorRule = SyntaxError + ";";
REPEAT.Rule = ToTerm("repeat") + "(" + E + ")" + "{" + LISTMETHODS + "}";
REPEAT.ErrorRule = SyntaxError + "}";
REPEAT.ErrorRule = SyntaxError + ";";
VARMANAGMENT.Rule = DECLARATION | ASSIGNATION;
UPDATE.Rule = ESINGLE + increase | ESINGLE + decrease;
WHILE.Rule = ToTerm("mientras") + "(" + E + ")" + "{" + LISTMETHODS + "}";
WHILE.ErrorRule = SyntaxError + "}";
WHILE.ErrorRule = SyntaxError + ";";
DOWHILE.Rule = ToTerm("hacer") + "{" + LISTMETHODS + "}" + ToTerm("mientras") + "(" + E + ")" + ";";
DOWHILE.ErrorRule = SyntaxError + "}";
DOWHILE.ErrorRule = SyntaxError + ";";
SWITCH.Rule = ToTerm("comprobar") + "(" + E + ")" + "{" + CASELIST + DEFAULT + "}";
SWITCH.ErrorRule = SyntaxError + "}";
SWITCH.ErrorRule = SyntaxError + ";";
CASELIST.Rule = MakePlusRule(CASELIST, CASE);
CASE.Rule = ToTerm("caso") + E + ":" + LISTMETHODS + ToTerm("salir") + ";";
DEFAULT.Rule = ToTerm("defecto") + ":" + LISTMETHODS + ToTerm("salir") + ";" | Empty;
OPTIONAL.Rule = RETURN | ToTerm("continue");
RETURN.Rule = ToTerm("return") + RETOPTION;
RETOPTION.Rule = Empty | E;
CALLFUNC.Rule = iden + "(" + CFUNCLIST + ")" + ";";
CFUNCLIST.Rule = MakeStarRule(CFUNCLIST, ToTerm(","), E);
CALLFUNC.ErrorRule = SyntaxError + ";";
ADDFIGURE.Rule = ToTerm("addfigure") + "(" + GEOMETRICAS + ")" + ";";
GEOMETRICAS.Rule = ToTerm("circle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("triangle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("square") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("line") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")";
GEOMETRICAS.ErrorRule = SyntaxError + ";";
COLOR.Rule = Empty | E; //it can be a string or id
FIGURE.Rule = ToTerm("figure") + "(" + E + ")" + ";";
//Methods inside a class
LISTCLASSMETHODS.Rule = VISIBILITY + LISTCLASSMETHODS2 | MAIN;
LISTCLASSMETHODS2.Rule = DECLARATION | FUNCTION;
MAIN.Rule = ToTerm("main") + "(" + ")" + "{" + LISTMETHODS + "}";
FUNCTION.Rule = iden + FUNCTIONARGS + "(" + PARAMLIST + ")" + "{" + LISTMETHODS + "}";
FUNCTION.ErrorRule = SyntaxError + "}";
FUNCTION.ErrorRule = SyntaxError + ";";
FUNCTIONARGS.Rule = DATATYPE + OVERRIDE | ToTerm("array") + DATATYPE + INDEX + OVERRIDE | ToTerm("void");
VISIBILITY.Rule = Empty | ToTerm("publico") | ToTerm("privado");
OVERRIDE.Rule = Empty | ToTerm("override");
PARAMLIST.Rule = MakeStarRule(PARAMLIST, ToTerm(","), PARAM);
PARAM.Rule = iden + iden | DATATYPE + iden;
//datatypes
DATATYPE.Rule = ToTerm("int") | "bool" | "string" | "double" | "char" | iden;
OBJECT.Rule = ID + ASSIGN;
//Making arrays
ARRAY.Rule = "=" + ARRAYASIGN | Empty;
ARRAYASIGN.Rule = ToTerm("{") + ARRAYASIGN2 + "}";
ARRAYASIGN2.Rule = ARRAYASIGN3 | ARRAYLIST;
ARRAYASIGN3.Rule = ARRAYASIGN | MakePlusRule(ARRAYASIGN3, ToTerm(","), ARRAYASIGN);
ARRAYLIST.Rule = MakePlusRule(ARRAYLIST, ToTerm(","), E);
//Making EXP
E.Rule = E + plus + E
| E + minus + E
| E + by + E
| E + divided + E
| E + power + E
| E + doubleEqual + E
| E + different + E
| E + lessThan + E
| E + greaterThan + E
| E + lessThanEqual + E
| E + greaterThanEqual + E
| E + or + E
| E + and + E
| not + E
| ESINGLE
| ToTerm("(") + E + ")"
| minus + E;
ESINGLE.Rule = NATIVE | ID | ToTerm("new") + iden + "(" + CFUNCLIST + ")";
INDEX.Rule = INDEX + ToTerm("[") + E + "]" | Empty;
ID.Rule = iden + IDPLUS;
IDPLUS.Rule = INDEX | Empty | "(" + CFUNCLIST + ")" | "." + ID;
NATIVE.Rule = integer | caracter | String | boolean | tdouble;
this.Root = START;
}
public UIGrammar()
: base(caseSensitive: false)
{
LanguageFlags = LanguageFlags.CreateAst;
StringLiteral STRING = new StringLiteral("STRING", "\"", StringOptions.None);
NumberLiteral NUMBER = new NumberLiteral("NUMBER", NumberOptions.None);
//ints that are too long for int32 are converted to int64
NUMBER.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
STRING.AstConfig.NodeType = typeof(StringValueNode);
NUMBER.AstConfig.NodeType = typeof(NumberValueNode);
CommentTerminal LINE_COMMENT = new CommentTerminal("LINE_COMMENT", "#", "\n", "\r\n", "\u0009", "\u2028",
"\u2028", "\r");
NonGrammarTerminals.Add(LINE_COMMENT);
NonTerminal BEGIN = new NonTerminal("BEGIN", typeof(BeginNode));
NonTerminal START_STATEMENT = new NonTerminal("START_STATEMENT", typeof(StartStatementNode)); //< LINE_CONTENT >
NonTerminal LINE_CONTENT = new NonTerminal("LINE_CONTENT", typeof(LineContentNode)); //Any of the below.
NonTerminal BEGIN_STATEMENT = new NonTerminal("BEGIN_STATEMENT", typeof(BeginStatementNode)); //<Begin>
NonTerminal ANYASSIGNMENT = new NonTerminal("ANYASSIGNMENT", typeof(AnyAssignmentNode));
NonTerminal ASSIGNMENT = new NonTerminal("ASSIGNMENT", typeof(UIParser.Nodes.AssignmentNode)); //Argument = STRING | NUMBER
NonTerminal ASSIGNMENTBLOCK = new NonTerminal("ASSIGNMENTBLOCK", typeof(AssignmentBlockNode));
NonTerminal DEFINEIMAGE_STATEMENT = new NonTerminal("DEFINEIMAGE_STATEMENT", typeof(DefineImageNode)); //<DefineImage>
NonTerminal DEFINESTRING_STATEMENT = new NonTerminal("DEFINESTRING_STATEMENT", typeof(DefineStringNode)); //<DefineString>
NonTerminal SETSHAREDPROPS_STATEMENT = new NonTerminal("SETSHAREDPROPS_STATEMENT", typeof(SetSharedPropsNode)); //<SetSharedProperties>
NonTerminal ADDBUTTON_STATEMENT = new NonTerminal("ADDBUTTON_STATEMENT", typeof(AddButtonNode)); //<AddButton>
NonTerminal ADDTEXT_STATEMENT = new NonTerminal("ADDTEXT_STATEMENT", typeof(AddTextNode)); //<AddText>
NonTerminal ADDTEXTEDIT_STATEMENT = new NonTerminal("ADDTEXTEDIT_STATEMENT", typeof(AddTextEditNode)); //<AddTextEdit>
NonTerminal ADDSLIDER_STATEMENT = new NonTerminal("ADDSLIDER_STATEMENT", typeof(AddSliderNode)); //<AddSlider>
NonTerminal ADDPROGRESSBAR_STATEMENT = new NonTerminal("ADDPROGRESSBAR_STATEMENT", typeof(AddProgressBarNode)); //<AddProgressBar>
NonTerminal ADDLISTBOX_STATEMENT = new NonTerminal("ADDLISTBOX_STATEMENT", typeof(AddListboxNode)); //<AddListBox>
NonTerminal ADDFORMATEDTEXT_STATEMENT = new NonTerminal("ADDFORMATEDTEXT", typeof(AddFormatedTextNode)); //<AddFormattedText>
NonTerminal SETCONTROLPROPS_STATEMENT = new NonTerminal("SETCONTROLPROPS_STATEMENT", typeof(SetControlPropsNode)); //<SetControlProperties>
NonTerminal ARRAY = new NonTerminal("ARRAY", typeof(ArrayNode));
NonTerminal ARRAYLIST = new NonTerminal("ARRAYLIST", typeof(ArrayListNode)); //(1,2,3,4)
NonTerminal END_IDENTIFIER = new NonTerminal("END_IDENTIFIER", typeof(EndNode)); //<End>
KeyTerm COMMA = new KeyTerm(",", "COMMA");
COMMA.AstConfig.NodeType = typeof(CommaNode);
//Rules
START_STATEMENT.Rule = Empty | ToTerm("<") + LINE_CONTENT + ToTerm(">");
LINE_CONTENT.Rule = Empty | BEGIN_STATEMENT | DEFINEIMAGE_STATEMENT | SETSHAREDPROPS_STATEMENT |
SETCONTROLPROPS_STATEMENT | ADDBUTTON_STATEMENT | ADDTEXT_STATEMENT | ADDTEXTEDIT_STATEMENT |
ADDSLIDER_STATEMENT | ADDPROGRESSBAR_STATEMENT | ADDLISTBOX_STATEMENT | ADDFORMATEDTEXT_STATEMENT |
DEFINESTRING_STATEMENT | END_IDENTIFIER;
BEGIN_STATEMENT.Rule = "Begin";
DEFINEIMAGE_STATEMENT.Rule = ToTerm("DefineImage") + STRING + ASSIGNMENTBLOCK;
DEFINESTRING_STATEMENT.Rule = ToTerm("DefineString") + STRING + ASSIGNMENTBLOCK;
ASSIGNMENT.Rule = ToTerm("stringDir") + ToTerm("=") + STRING | ToTerm("stringTable") + ToTerm("=") + NUMBER |
ToTerm("leftArrowImage") + ToTerm("=") + STRING | ToTerm("rightArrowImage") + ToTerm("=") + STRING |
ToTerm("tracking") + ToTerm("=") + NUMBER | ToTerm("trigger") + ToTerm("=") + NUMBER |
ToTerm("image") + ToTerm("=") + STRING | ToTerm("position") + ToTerm("=") + ARRAY |
ToTerm("size") + ToTerm("=") + ARRAY | ToTerm("tooltip") + ToTerm("=") + STRING |
ToTerm("toolTip") + ToTerm("=") + STRING | ToTerm("id") + ToTerm("=") + NUMBER |
ToTerm("orientation") + ToTerm("=") + NUMBER | ToTerm("opaque") + ToTerm("=") + NUMBER |
ToTerm("assetID") + ToTerm("=") + STRING | ToTerm("stringIndex") + ToTerm("=") + NUMBER |
ToTerm("text") + ToTerm("=") + STRING | ToTerm("font") + ToTerm("=") + NUMBER |
ToTerm("textColor") + ToTerm("=") + ARRAY | ToTerm("textColorSelected") + ToTerm("=") + ARRAY |
ToTerm("textColorHighlighted") + ToTerm("=") + ARRAY | ToTerm("textColorDisabled") + ToTerm("=") + ARRAY |
ToTerm("textButton") + ToTerm("=") + NUMBER | ToTerm("color") + ToTerm("=") + ARRAY |
ToTerm("alignment") + ToTerm("=") + NUMBER | ToTerm("backColor") + ToTerm("=") + ARRAY |
ToTerm("frameOnFocus") + ToTerm("=") + NUMBER | ToTerm("cursorColor") + ToTerm("=") + ARRAY |
ToTerm("transparent") + ToTerm("=") + NUMBER | ToTerm("frameColor") + ToTerm("=") + ARRAY |
ToTerm("capacity") + ToTerm("=") + NUMBER | ToTerm("lines") + ToTerm("=") + NUMBER |
ToTerm("flashOnEmpty") + ToTerm("=") + NUMBER | ToTerm("thumbSize") + ToTerm("=") + ARRAY |
ToTerm("thumbMargins") + ToTerm("=") + ARRAY | ToTerm("thumbImageSize") + ToTerm("=") + ARRAY |
ToTerm("thumbImageOffsets") + ToTerm("=") + ARRAY | ToTerm("thumbButtonImage") + ToTerm("=") + STRING |
ToTerm("wrapped") + ToTerm("=") + NUMBER | ToTerm("textColor") + ToTerm("=") + ARRAY |
ToTerm("mode") + ToTerm("=") + STRING | ToTerm("scrollBarImage") + ToTerm("=") + STRING |
ToTerm("scrollBarGutter") + ToTerm("=") + NUMBER | ToTerm("scrollBarType") + ToTerm("=") + NUMBER |
ToTerm("enableIME") + ToTerm("=") + NUMBER | ToTerm("highlighted") + ToTerm("=") + NUMBER |
ToTerm("minValue") + ToTerm("=") + NUMBER | ToTerm("maxValue") + ToTerm("=") + NUMBER |
ToTerm("pageSize") + ToTerm("=") + NUMBER | ToTerm("MouseTransparent") + ToTerm("=") + NUMBER |
ToTerm("backgroundColor") + ToTerm("=") + ARRAY | ToTerm("alignments") + ToTerm("=") + NUMBER |
ToTerm("visibleRows") + ToTerm("=") + NUMBER | ToTerm("columns") + ToTerm("=") + NUMBER |
ToTerm("rowHeight") + ToTerm("=") + NUMBER | ToTerm("fillColor") + ToTerm("=") + ARRAY |
ToTerm("selectionFillColor") + ToTerm("=") + ARRAY | ToTerm("cursor") + ToTerm("=") + NUMBER |
ToTerm("lineHeight") + ToTerm("=") + NUMBER | ToTerm("edgeOffsetL") + ToTerm("=") + NUMBER |
ToTerm("edgeOffsetR") + ToTerm("=") + NUMBER | ToTerm("edgeoffsetT") + ToTerm("=") + NUMBER |
ToTerm("edgeOffsetB") + ToTerm("=") + NUMBER | ToTerm("foregroundImage") + ToTerm("=") + STRING |
ToTerm("backgroundImage") + ToTerm("=") + STRING | ToTerm("value") + ToTerm("=") + NUMBER |
ToTerm("useBackgroundImage") + ToTerm("=") + NUMBER | ToTerm("enabled") + ToTerm("=") + NUMBER;
ANYASSIGNMENT.Rule = MakeStarRule(ANYASSIGNMENT, ASSIGNMENT);
//This means "assignmentblock is assignment followed by n assignments".
ASSIGNMENTBLOCK.Rule = MakePlusRule(ASSIGNMENTBLOCK, ANYASSIGNMENT);
SETSHAREDPROPS_STATEMENT.Rule = ToTerm("SetSharedProperties") + ASSIGNMENTBLOCK;
SETCONTROLPROPS_STATEMENT.Rule = ToTerm("SetControlProperties") + STRING + ASSIGNMENTBLOCK |
ToTerm("SetControlProperties") + STRING;
ADDBUTTON_STATEMENT.Rule = ToTerm("AddButton") + STRING + ASSIGNMENTBLOCK;
ADDTEXT_STATEMENT.Rule = ToTerm("AddText") + STRING + ASSIGNMENTBLOCK;
ADDTEXTEDIT_STATEMENT.Rule = ToTerm("AddTextEdit") + STRING + ASSIGNMENTBLOCK;
ADDSLIDER_STATEMENT.Rule = ToTerm("AddSlider") + STRING + ASSIGNMENTBLOCK;
ADDPROGRESSBAR_STATEMENT.Rule = ToTerm("AddProgressBar") + STRING + ASSIGNMENTBLOCK;
ADDLISTBOX_STATEMENT.Rule = ToTerm("AddListBox") + STRING + ASSIGNMENTBLOCK;
ADDFORMATEDTEXT_STATEMENT.Rule = ToTerm("AddFormatedText") + STRING + ASSIGNMENTBLOCK;
ARRAY.Rule = ToTerm("(") + ARRAYLIST + ")";
ARRAYLIST.Rule = MakeStarRule(ARRAYLIST, COMMA, NUMBER);
END_IDENTIFIER.Rule = "End";
BEGIN.Rule = MakePlusRule(BEGIN, START_STATEMENT);
this.Root = BEGIN;
}
public KeyTerm ToTerm(string text, string name)
{
KeyTerm term;
if (KeyTerms.TryGetValue(text, out term)) {
//update name if it was specified now and not before
if (string.IsNullOrEmpty(term.Name) && !string.IsNullOrEmpty(name))
term.Name = name;
return term;
}
//create new term
if (!CaseSensitive)
text = text.ToLower(CultureInfo.InvariantCulture);
string.Intern(text);
term = new KeyTerm(text, name);
KeyTerms[text] = term;
return term;
}
public Gramatica() : base(caseSensitive: true)
{
//Prueba
#region er
StringLiteral CADENA = new StringLiteral("cadena", "\"");
RegexBasedTerminal letras = new RegexBasedTerminal("letras", "[(a-z)*(A-Z)*(0-9)*]+");
var ENTERO = new RegexBasedTerminal("Entero", "[0-9]+");
var DECIMAL = new RegexBasedTerminal("Decimal", "[0-9]+[.]+[0-9]+");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("ID");
//CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/", "/");
CommentTerminal comentarioLinea = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal comentarioBloque = new CommentTerminal("DelimitedComment", "/*", "*/");
//var whiteSpace = new
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
#endregion
#region KeyWords de Puntuacion
KeyTerm dosPuntos = ToTerm(":", "dosPuntos");
KeyTerm puntoComa = ToTerm(";", "puntoComa");
KeyTerm punto = ToTerm(".", "punto");
KeyTerm coma = ToTerm(",", "coma");
KeyTerm parentesisIzq = ToTerm("(", "parentesisIzq");
KeyTerm parentesisDer = ToTerm(")", "parentesisDer");
KeyTerm llaveIzq = ToTerm("{", "llaveIzq");
KeyTerm llaveDer = ToTerm("}", "llaveDer");
#endregion
#region KeyWords Operadores, Comparadores, nombre variables,
KeyTerm plus = ToTerm("+", "plus");
KeyTerm minus = ToTerm("-", "minus");
KeyTerm por = ToTerm("*", "por");
KeyTerm div = ToTerm("/", "div");
KeyTerm plusPlus = ToTerm("++", "plusPlus");
KeyTerm minusMinus = ToTerm("--", "menosMenos");
//Comparadores
KeyTerm mayorQue = ToTerm(">", "mayorQue");
KeyTerm menorQue = ToTerm("<", "menorQue");
KeyTerm igual = ToTerm("=", "igual");
KeyTerm mayorIgual = ToTerm(">=", "mayorIgual");
KeyTerm menorIgual = ToTerm("<=", "menorIgual");
KeyTerm diferente = ToTerm("!=", "diferente");
KeyTerm igualIgual = ToTerm("==", "igualIgual");
//Variables
KeyTerm varInt = ToTerm("int");
KeyTerm varFloat = ToTerm("float");
KeyTerm varString = ToTerm("string");
KeyTerm varBoolean = ToTerm("bool");
//Ciclos y condicionales
KeyTerm condIf = ToTerm("if");
KeyTerm condElif = ToTerm("elif");
KeyTerm condElse = ToTerm("else");
KeyTerm kwBreack = ToTerm("break");
KeyTerm kwCase = ToTerm("case");
KeyTerm kwClass = ToTerm("class");
KeyTerm kwTry = ToTerm("Try");
KeyTerm kwCatch = ToTerm("Catch");
KeyTerm kwWhile = ToTerm("while");
KeyTerm kwDowhile = ToTerm("do while");
KeyTerm kwFor = ToTerm("for");
KeyTerm kwPublic = ToTerm("public");
KeyTerm kwThrow = ToTerm("Throw");
KeyTerm kwVoid = ToTerm("Void");
KeyTerm kwSwitch = ToTerm("Switch");
KeyTerm kwTrue = ToTerm("true");
KeyTerm kwFalse = ToTerm("false");
#endregion
#region Terminales
NonTerminal ini = new NonTerminal("ini");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal expresion_numerica = new NonTerminal("expresion_numerica");
NonTerminal expresion_cadena = new NonTerminal("expresion_cadena");
NonTerminal expresion_logica = new NonTerminal("expresion_logica");
//No terminales para declarar variables
NonTerminal declararVar = new NonTerminal("decVar");
NonTerminal decInt = new NonTerminal("decInt");
NonTerminal decFloat = new NonTerminal("decFloat");
NonTerminal decString = new NonTerminal("decString");
NonTerminal decBool = new NonTerminal("decBool");
var entradaID = new NonTerminal("entradaID");
#endregion
#region No terminales
#endregion
#region Gramatica
ini.Rule = instrucciones;
//Declarar varibles
declararVar.Rule = decInt | decFloat | decString | decBool | declararVar;
decInt.Rule = varInt + entradaID + igual + ENTERO + puntoComa;
decFloat.Rule = (varFloat + entradaID + igual + DECIMAL + puntoComa);
decString.Rule = (varString + entradaID + igual + (CADENA) + puntoComa);
decBool.Rule = (varBoolean + entradaID + igual + (kwTrue | kwFalse) + puntoComa);
entradaID.Rule = MakePlusRule(entradaID, ToTerm(","), IDENTIFICADOR);
#endregion
#region Jesus IF
//----------------------IF------------------
//En estos if solo se podran hacer 2 condiciones maximo por ejemplo if(a==2 && b=false){}
//No terminales para condicional if
NonTerminal condicionIF = new NonTerminal("condicionIF");
NonTerminal condicionIFELSE = new NonTerminal("condicionIFELSE");
NonTerminal condicionalIFELSEIF = new NonTerminal("condicionIFELSEIF");
NonTerminal condicionELSE = new NonTerminal("condicionELSE");
NonTerminal condicionELSEIF = new NonTerminal("condicionELSEIF");
NonTerminal expComparacion = new NonTerminal("expComparacion");
NonTerminal nuevaCondicion = new NonTerminal("nuevaCondicion");
NonTerminal nuevaCondicion2 = new NonTerminal("nuevaCondicion2");
NonTerminal compIgualDiferente = new NonTerminal("compIgualDiferente");
NonTerminal compMayorMenor = new NonTerminal("comMayorMenor");
NonTerminal compMayorMenorIgual = new NonTerminal("comMayorMenor");
NonTerminal compBool = new NonTerminal("comBool");
KeyTerm signoOR = ToTerm("|");
KeyTerm signoAND = ToTerm("&&");
//Nota: El Ciclo if que se presenta se modificara para poder poner mas codigo dentro del ciclo if
//Declarar un if
condicionIF.Rule = condIf + parentesisIzq + (expComparacion | (expComparacion + nuevaCondicion)) + parentesisDer + llaveIzq + llaveDer;
expComparacion.Rule = (parentesisIzq + (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool) + parentesisDer) | (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool);
compIgualDiferente.Rule = ((DECIMAL + igualIgual + DECIMAL) | (ENTERO + igualIgual + ENTERO) | (entradaID + igualIgual + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + diferente + DECIMAL) | (ENTERO + diferente + ENTERO) | (entradaID + diferente + (ENTERO | DECIMAL | CADENA)));
compMayorMenor.Rule = ((DECIMAL + mayorQue + DECIMAL) | (ENTERO + mayorQue + ENTERO) | (entradaID + mayorQue + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + menorQue + DECIMAL) | (ENTERO + menorQue + ENTERO) | (entradaID + menorQue + (ENTERO | DECIMAL | CADENA)));
compMayorMenorIgual.Rule = ((DECIMAL + mayorIgual + DECIMAL) | (ENTERO + mayorIgual + ENTERO) | (entradaID + mayorIgual + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + menorIgual + DECIMAL) | (ENTERO + menorIgual + ENTERO) | (entradaID + menorIgual + (ENTERO | DECIMAL | CADENA)));
compBool.Rule = entradaID + igual + (kwTrue | kwFalse);
nuevaCondicion.Rule = ((signoAND | signoOR) + expComparacion) | ((signoAND | signoOR) + expComparacion + nuevaCondicion2);
nuevaCondicion2.Rule = nuevaCondicion;
//Declarar un if else
condicionIFELSE.Rule = condicionIF + condicionELSE;
condicionELSE.Rule = condElse + llaveIzq + llaveDer;
//Declarar un if else if
condicionalIFELSEIF.Rule = condicionIF + condicionELSEIF;
condicionELSEIF.Rule = condElse + (condicionIF | condicionELSE | condicionalIFELSEIF);
#endregion
#region ADRI SWITCH
NonTerminal condicionSwitch = new NonTerminal("condicionSwitch");
NonTerminal switchOpcion = new NonTerminal("switchOpcion");
NonTerminal opcionCase = new NonTerminal("opcionCase");
NonTerminal opcionDefault = new NonTerminal("opcionDefault");
//poner con las keyterm
KeyTerm kwDefault = ToTerm("default");
opcionDefault.Rule = kwDefault + dosPuntos + kwBreack + puntoComa;
opcionCase.Rule = kwCase + switchOpcion + dosPuntos + kwBreack + puntoComa + (opcionCase | opcionDefault);
switchOpcion.Rule = DECIMAL | ENTERO | CADENA | entradaID;
condicionSwitch.Rule = kwSwitch + parentesisIzq + switchOpcion + parentesisDer + llaveIzq
+ opcionCase + llaveDer; //cierre de Switch
#endregion
#region Jesus Imprimir
//-----------------------Print
KeyTerm kwConsole = ToTerm("Console");
KeyTerm kwWrite = ToTerm("Write");
KeyTerm kwWriteLn = ToTerm("WriteLine");
NonTerminal imprimir = new NonTerminal("imprimir");
NonTerminal imprimirWrite = new NonTerminal("imprimirWrite");
NonTerminal imprimirWriteLn = new NonTerminal("imprimirWriteLn");
NonTerminal textoOVariable = new NonTerminal("textoOVariable");
imprimir.Rule = kwConsole + punto + (imprimirWrite | imprimirWriteLn) + puntoComa;
imprimirWrite.Rule = kwWrite + parentesisIzq + textoOVariable + parentesisDer;
imprimirWriteLn.Rule = kwWriteLn + parentesisIzq + textoOVariable + parentesisDer;
textoOVariable.Rule = (CADENA | entradaID) | ((CADENA | entradaID) + plus + textoOVariable);
#endregion
#region Jesus Operaciones
//-------------------------Operaciones
NonTerminal operaciones = new NonTerminal("operaciones");
NonTerminal opeSuma = new NonTerminal("opeSuma");
NonTerminal opeResta = new NonTerminal("opeResta");
NonTerminal opeMultiplicacion = new NonTerminal("opeMultiplicacion");
NonTerminal opeDivision = new NonTerminal("opeDivision");
NonTerminal opeCompuesta = new NonTerminal("opeCompuesta");
NonTerminal datoEntradaOpe = new NonTerminal("datoEntradaOpe");
operaciones.Rule = ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + puntoComa) | (opeCompuesta + puntoComa);
opeSuma.Rule = datoEntradaOpe | (datoEntradaOpe + plus + opeSuma) | (parentesisIzq + opeSuma + parentesisDer) | (plus + datoEntradaOpe);
opeResta.Rule = datoEntradaOpe | (datoEntradaOpe + minus + opeResta) | (parentesisIzq + opeResta + parentesisDer) | (minus + datoEntradaOpe);
opeMultiplicacion.Rule = datoEntradaOpe | (datoEntradaOpe + por + opeMultiplicacion) | (parentesisIzq + opeMultiplicacion + parentesisDer) | (por + datoEntradaOpe) | (parentesisIzq + opeMultiplicacion + parentesisDer);
opeDivision.Rule = datoEntradaOpe | (datoEntradaOpe + div + opeDivision) | (parentesisIzq + opeDivision + parentesisDer) | (div + datoEntradaOpe);
opeCompuesta.Rule = (opeSuma | opeResta | opeMultiplicacion | opeDivision) | ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + opeCompuesta);
datoEntradaOpe.Rule = (ENTERO | DECIMAL | entradaID) | (parentesisIzq + datoEntradaOpe + parentesisDer) | (parentesisIzq + (opeSuma | opeResta | opeMultiplicacion | opeDivision) + parentesisDer);
#endregion
#region Jesus funciones y clases
//------------------funciones de clases
NonTerminal nameSpace = new NonTerminal("nameSpace");
NonTerminal ntClass = new NonTerminal("ntClass");
NonTerminal ntMain = new NonTerminal("ntMain");
NonTerminal ntPublic = new NonTerminal("ntPublic");
nameSpace.Rule = "namespace" + entradaID + llaveIzq + ntClass + llaveDer;
ntClass.Rule = kwClass + entradaID + llaveIzq + (ntPublic | ntMain) + llaveDer;
ntMain.Rule = "static void Main" + parentesisIzq + varString + "[] args" + parentesisDer + llaveIzq + llaveDer;
ntPublic.Rule = kwPublic + entradaID + "()" + llaveIzq + llaveDer;
#endregion
#region Preferencias
#endregion
}
public TotemGrammar()
{
#region Lexical structure
var @string = CreateStringLiteral("string");
var number = CreateNumberLiteral("number");
var identifier = CreateIdentifier("identifier");
var singleLineComment = new CommentTerminal("singleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("delimitedComment", "/*", "*/");
this.NonGrammarTerminals.Add(singleLineComment);
this.NonGrammarTerminals.Add(delimitedComment);
//Temporarily, treat preprocessor instructions like comments
CommentTerminal ppInstruction = new CommentTerminal("ppInstruction", "#", "\n");
this.NonGrammarTerminals.Add(ppInstruction);
// Symbols
#region Terminals
var @is = ToTerm("is");
var dot = ToTerm(".");
var lt = ToTerm("<");
var gt = ToTerm(">");
var lte = ToTerm("<=");
var gte = ToTerm(">=");
var lsbr = ToTerm("[");
var rsbr = ToTerm("]");
var lpr = ToTerm("(");
var rpr = ToTerm(")");
var lcbr = ToTerm("{");
var rcbr = ToTerm("}");
var comma = ToTerm(",");
var qmark = ToTerm("?");
semi = ToTerm(";");
var colon = ToTerm(":");
var fatArrow = ToTerm("=>");
var @true = ToTerm("true");
var @false = ToTerm("false");
var @null = ToTerm("null");
var undefined = ToTerm("undefined");
var var = ToTerm("var");
var @new = ToTerm("new");
@return = ToTerm("return");
var @throw = ToTerm("throw");
var function = ToTerm("function");
var @if = ToTerm("if");
var @else = ToTerm("else");
var @for = ToTerm("for");
var @break = ToTerm("break");
var @continue = ToTerm("continue");
#endregion
#region 2. Non Terminals
#region 2.0 Optional Terminals
var identifierOpt = new NonTerminal("identifierOpt", Empty | identifier);
#endregion
#region 2.1 Expressions
var Expr = new NonTerminal("Expr"/*, typeof(Expr)*/);
var ExprOpt = new NonTerminal("ExprOpt");
var ParenExpr = new NonTerminal("ParenExpr");
var MemberExpr = new NonTerminal("MemberExpr");
var ArrOpExpr = new NonTerminal("ArrOpExpr");
var QualifiedName = new NonTerminal("QualifiedName");
var ConstExpr = new NonTerminal("ConstExpr"/*, typeof(ConstExpr)*/);
var BinExpr = new NonTerminal("BinExpr"/*, typeof(BinExpr)*/);
var TerExpr = new NonTerminal("TerExpr"/*, typeof(TerExpr)*/);
var ObjLitExpr = new NonTerminal("ObjLitExpr"/*, typeof(ObjLitExpr)*/);
var ArrLitExpr = new NonTerminal("ArrLitExpr"/*, typeof(ArrLitExpr)*/);
var UnaryExpr = new NonTerminal("UnaryExpr"/*, typeof(UnaryExpr)*/);
var AssignExpr = new NonTerminal("AssignExpr"/*, typeof(AssignExpr)*/);
var FuncDefExpr = new NonTerminal("FuncDefExpr"/*, typeof(FuncDefExpr)*/);
var VarExpr = new NonTerminal("VarExpr"/*, typeof(VarExpr)*/);
var VarExprList = new NonTerminal("VarExprList"/*, typeof(VarExprList)*/);
var Initializer = new NonTerminal("Initializer"/*, typeof(Initializer)*/);
var InitializerOpt = new NonTerminal("InitializerOpt");
var ObjLitProps = new NonTerminal("ObjLitProps");
var ObjLitProp = new NonTerminal("ObjLitProp");
var FunctionCall = new NonTerminal("FunctionCall"/*, typeof(FunctionCall)*/);
var FunctionCallExpr = new NonTerminal("FunctionCallExpr");
var Argument = new NonTerminal("Argument"/*, typeof(Argument)*/);
var ArgumentList = new NonTerminal("ArgumentList"/*, typeof(ArgumentList)*/);
Parameter = new NonTerminal("Parameter"/*, typeof(Parameter)*/);
var ParameterList = new NonTerminal("ParameterList"/* typeof(ParameterList)*/);
var AssignOp = new NonTerminal("AssignOp");
var PostOp = new NonTerminal("PostOp");
var BinOp = new NonTerminal("BinOp");
var LUnOp = new NonTerminal("LUnOp");
var RUnOp = new NonTerminal("RUnOp");
#endregion
#region 2.2 Qualified Names
var ExprList = new NonTerminal("ExprList"/*, typeof(ExprList)*/);
var NewExpr = new NonTerminal("NewExpr"/*, typeof(NewExpr)*/);
#endregion
#region 2.3 Statement
var Condition = new NonTerminal("Condition"/*, typeof(Condition)*/);
var Statement = new NonTerminal("Statement"/*, typeof(Statement)*/);
var VarStmt = new NonTerminal("VarStmt");
var ExprStmt = new NonTerminal("ExprStmt"/*, typeof(ExprStmt)*/);
var Block = new NonTerminal("Block"/*, typeof(Block)*/);
var StmtList = new NonTerminal("StmtList"/*, typeof(StmtList)*/);
var FuncDefStmt = new NonTerminal("FuncDefStmt"/*, typeof(FuncDefStmt)*/);
FlowControlStmt = new NonTerminal("FlowControlStmt"/*, typeof(FlowControlStmt)*/);
var IfElseStmt = new NonTerminal("IfElseStmt");
var ForStmt = new NonTerminal("ForStmt");
var ForInitializer = new NonTerminal("ForInitializer");
var ForInitializerOpt = new NonTerminal("ForInitializerOpt");
#endregion
#region 2.4 Program and Functions
var Prog = new NonTerminal("Prog");
var Element = new NonTerminal("Element");
var ElementList = new NonTerminal("ElementList");
#endregion
#endregion
#region 3. BNF Rules
#region 3.1 Expressions
ConstExpr.Rule = @true | @false | undefined | @null | @string | number;
ObjLitProp.Rule = identifier + colon + Expr |
@string + colon + Expr;
ObjLitProps.Rule = MakeStarRule(ObjLitProps, comma, ObjLitProp);
ExprList.Rule = MakeStarRule(ExprList, comma, Expr);
BinExpr.Rule = Expr + BinOp + Expr;
TerExpr.Rule = Expr + qmark + Expr + colon + Expr;
ObjLitExpr.Rule = lcbr + ObjLitProps + rcbr;
ArrLitExpr.Rule = lsbr + ExprList + rsbr;
UnaryExpr.Rule = LUnOp + Expr;
QualifiedName.Rule = MemberExpr | ArrOpExpr | identifier;
AssignExpr.Rule = QualifiedName + AssignOp + Expr
| QualifiedName + PostOp;
FuncDefExpr.Rule = function + identifierOpt + lpr + ParameterList + rpr + Block
| identifier + fatArrow + Expr
| identifier + fatArrow + Statement
| lpr + ParameterList + rpr + fatArrow + Expr
| lpr + ParameterList + rpr + fatArrow + Statement;
ParameterList.Rule = MakeStarRule(ParameterList, comma, Parameter);
Parameter.Rule = identifier + InitializerOpt;
Expr.Rule = ConstExpr | TerExpr | BinExpr | UnaryExpr | identifier | AssignExpr | FuncDefExpr | ParenExpr | FunctionCallExpr | MemberExpr | ArrOpExpr | ObjLitExpr | ArrLitExpr;// | NewExpr;
ExprOpt.Rule = Empty | Expr;
ParenExpr.Rule = lpr + Expr + rpr;
MemberExpr.Rule = Expr + dot + identifier;
VarStmt.Rule = var + VarExprList + semi;
VarExprList.Rule = MakePlusRule(VarExprList, comma, VarExpr);
VarExpr.Rule = identifier + InitializerOpt;
Initializer.Rule = ToTerm("=", "equals") + Expr;
InitializerOpt.Rule = Empty | Initializer;
NewExpr.Rule = @new + Expr + FunctionCall;
BinOp.Rule = ToTerm("+") | "-" | lt | gt | lte | gte | "==" | "!=" | "*" | "/";
LUnOp.Rule = ToTerm("-") | "!" | @new;
AssignOp.Rule = ToTerm("=") | "+=" | "-=";
PostOp.Rule = ToTerm("--") | "++";
FunctionCallExpr.Rule = Expr + FunctionCall;
#endregion
#region 3.2 Qualified Names
FunctionCall.Rule = lpr + ArgumentList + rpr;
ArgumentList.Rule = MakeStarRule(ArgumentList, comma, Argument);
Argument.Rule = Expr | identifier + colon + Expr | @string + colon + Expr;
MemberExpr.Rule = Expr + dot + identifier;
ArrOpExpr.Rule = Expr + lsbr + Expr + rsbr;
#endregion
#region 3.3 Statement
Condition.Rule = lpr + Expr + rpr;
ExprStmt.Rule = AssignExpr + semi
| FunctionCallExpr + semi;
FlowControlStmt.Rule = @return + semi
| @return + Expr + semi
| @throw + Expr + semi
| @break + semi
| @continue + semi;
Statement.Rule = semi // Empty statement
| Block
| ExprStmt
| VarStmt
| IfElseStmt
| ForStmt
| FlowControlStmt;
IfElseStmt.Rule = @if + Condition + Statement
| @if + Condition + Statement + @else + Statement;
ForStmt.Rule = @for + lpr + ForInitializerOpt + semi + ExprOpt + semi + ExprOpt + rpr + Statement;
ForInitializer.Rule = var + VarExprList | Expr;
ForInitializerOpt.Rule = Empty | ForInitializer;
StmtList.Rule = MakeStarRule(StmtList, null, Statement);
FuncDefStmt.Rule = function + identifier + lpr + ParameterList + rpr + Block;
Block.Rule = lcbr + StmtList + rcbr;
#endregion
#region 3.4 Program and Functions
Element.Rule = Statement | FuncDefStmt;
ElementList.Rule = MakeStarRule(ElementList, null, Element);
Prog.Rule = ElementList + Eof;
#endregion
#endregion
#region 4. Set root
Root = Prog;
#endregion
#region 5. Operators precedence
RegisterOperators(1, "||");
RegisterOperators(2, "&&");
RegisterOperators(3, "|");
RegisterOperators(4, "^");
RegisterOperators(5, "&");
RegisterOperators(6, "==", "!=");
RegisterOperators(7, "<", ">", "<=", ">=", "is");
RegisterOperators(8, "<<", ">>");
RegisterOperators(9, "+", "-");
RegisterOperators(10, "*", "/", "%");
RegisterOperators(-1, "?");
RegisterOperators(-2, "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
#endregion
#region 6. Punctuation Symbols
Delimiters = "{}[](),:;+-*/%&|^!~<>=";
MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
#endregion
MarkTransient(Element, Statement, InitializerOpt, Expr, ParenExpr, BinOp, LUnOp, AssignOp, PostOp, FunctionCall, QualifiedName, ObjLitProps, ExprList);
//LanguageFlags = Irony.Parsing.LanguageFlags.CreateAst;
#endregion
}
public SonesGQLGrammar(IGraphDB iGraphDb)
: base(false)
{
_iGraphDB = iGraphDb;
#region SetLanguageFlags
base.LanguageFlags |= LanguageFlags.CreateAst;
//this.SetLanguageFlags(LanguageFlags.CreateAst);
//this.SetLanguageFlags(LanguageFlags.AutoDetectTransient, false);
#endregion
#region Terminals
#region Comments
//Terminals
var comment = new CommentTerminal("comment", "/*", "*/");
var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n");
//TODO: remove block comment, added for testing LUA-style comments
var blockComment = new CommentTerminal("block_comment", "--[[", "]]");
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(lineComment);
NonGrammarTerminals.Add(blockComment);
#endregion
#region Available value defs: Number, String, Name
var number = new NumberLiteral("number", NumberOptions.AllowSign | NumberOptions.DisableQuickParse);
number.DefaultIntTypes = new TypeCode[] { TypeCode.UInt64, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var string_literal = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak);
var location_literal = new StringLiteral("file", "'", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak | StringOptions.NoEscapes);
var name = new IdentifierTerminal("name", "ִײ�הצ��0123456789_", "ִײ�הצ�0123456789$_");
#endregion
//var name_ext = TerminalFactory.CreateSqlExtIdentifier("name_ext"); //removed, because we do not want to hav types or sth else with whitespaces, otherwise it conflicts with tupleSet
#region Symbols
S_CREATE = ToTerm("CREATE");
S_comma = ToTerm(",");
S_dot = ToTerm(".");
S_ASTERISK = ToTerm("*");
S_EQUALS = ToTerm("=");
S_QUESTIONMARK_EQUALS = ToTerm("?=");
S_colon = ToTerm(":");
S_BRACKET_LEFT = ToTerm(TERMINAL_BRACKET_LEFT);
S_BRACKET_RIGHT = ToTerm(TERMINAL_BRACKET_RIGHT);
S_TUPLE_BRACKET_LEFT = ToTerm("[");
S_TUPLE_BRACKET_RIGHT = ToTerm("]");
S_edgeInformationDelimiterSymbol = ToTerm(SonesGQLConstants.EdgeInformationDelimiterSymbol);
S_edgeTraversalDelimiter = ToTerm(SonesGQLConstants.EdgeTraversalDelimiterSymbol);
S_NULL = ToTerm("NULL");
S_NOT = ToTerm("NOT");
S_UNIQUE = ToTerm("UNIQUE");
S_WITH = ToTerm("WITH");
S_ALTER = ToTerm("ALTER");
S_ADD = ToTerm("ADD");
S_TO = ToTerm("TO");
S_COLUMN = ToTerm("COLUMN");
S_DROP = ToTerm("DROP");
S_RENAME = ToTerm("RENAME");
S_CONSTRAINT = ToTerm("CONSTRAINT");
S_INDEX = ToTerm("INDEX");
S_INDICES = ToTerm("INDICES");
S_ON = ToTerm("ON");
S_KEY = ToTerm("KEY");
S_INSERT = ToTerm("INSERT");
S_INTO = ToTerm("INTO");
S_UPDATE = ToTerm("UPDATE");
S_INSERTORUPDATE = ToTerm("INSERTORUPDATE");
S_INSERTORREPLACE = ToTerm("INSERTORREPLACE");
S_REPLACE = ToTerm("REPLACE");
S_SET = ToTerm(TERMINAL_SET);
S_REMOVE = ToTerm("REMOVE");
S_VALUES = ToTerm("VALUES");
S_DELETE = ToTerm("DELETE");
S_SELECT = ToTerm("SELECT");
S_FROM = ToTerm("FROM");
S_AS = ToTerm("AS");
S_COUNT = ToTerm("COUNT");
S_JOIN = ToTerm("JOIN");
S_BY = ToTerm("BY");
S_WHERE = ToTerm("WHERE");
S_TYPE = ToTerm("TYPE");
S_TYPES = ToTerm("TYPES");
S_VERTEX = ToTerm("VERTEX");
S_VERTICES = ToTerm("VERTICES");
S_EDITION = ToTerm("EDITION");
S_INDEXTYPE = ToTerm("INDEXTYPE");
S_LIST = ToTerm(TERMINAL_LIST);
S_ListTypePrefix = ToTerm(TERMINAL_LT);
S_ListTypePostfix = ToTerm(TERMINAL_GT);
S_EXTENDS = ToTerm("EXTENDS");
S_ATTRIBUTES = ToTerm("ATTRIBUTES");
S_LIMIT = ToTerm("LIMIT");
S_DEPTH = ToTerm("DEPTH");
S_REFERENCE = ToTerm("REFERENCE");
S_REF = ToTerm("REF");
S_REFUUID = ToTerm("REFUUID");
S_REFERENCEUUID = ToTerm("REFERENCEUUID");
S_LISTOF = ToTerm(SonesGQLConstants.LISTOF);
S_SETOF = ToTerm(SonesGQLConstants.SETOF);
S_SETOFUUIDS = ToTerm(SonesGQLConstants.SETOFUUIDS);
S_UUID = ToTerm("VertexID");
S_OFFSET = ToTerm("OFFSET");
S_TRUNCATE = ToTerm("TRUNCATE");
S_TRUE = ToTerm(TERMINAL_TRUE);
S_FALSE = ToTerm(TERMINAL_FALSE);
S_ASC = ToTerm(TERMINAL_ASC);
S_DESC = ToTerm(TERMINAL_DESC);
S_QUEUESIZE = ToTerm(TERMINAL_QUEUESIZE);
S_WEIGHTED = ToTerm(TERMINAL_WEIGHTED);
S_GET = ToTerm("GET");
S_ATTRIBUTE = ToTerm("ATTRIBUTE");
S_DEFAULT = ToTerm("DEFAULT");
S_INCOMINGEDGE = ToTerm(SonesGQLConstants.INCOMINGEDGE);
S_INCOMINGEDGES = ToTerm(SonesGQLConstants.INCOMINGEDGES);
S_DESCRIBE = ToTerm("DESCRIBE");
S_FUNCTION = ToTerm("FUNCTION");
S_FUNCTIONS = ToTerm("FUNCTIONS");
S_AGGREGATE = ToTerm("AGGREGATE");
S_AGGREGATES = ToTerm("AGGREGATES");
S_INDICES = ToTerm("INDICES");
S_EDGE = ToTerm("EDGE");
S_EDGES = ToTerm("EDGES");
S_MANDATORY = ToTerm("MANDATORY");
S_ABSTRACT = ToTerm("ABSTRACT");
S_BEGIN = ToTerm("BEGIN");
S_TRANSACTION = ToTerm("TRANSACTION");
S_TRANSACTDISTRIBUTED = ToTerm(SonesGQLConstants.TRANSACTION_DISTRIBUTED);
S_TRANSACTLONGRUNNING = ToTerm(SonesGQLConstants.TRANSACTION_LONGRUNNING);
S_TRANSACTISOLATION = ToTerm(SonesGQLConstants.TRANSACTION_ISOLATION);
S_TRANSACTNAME = ToTerm(SonesGQLConstants.TRANSACTION_NAME);
S_TRANSACTTIMESTAMP = ToTerm(SonesGQLConstants.TRANSACTION_TIMESTAMP);
S_TRANSACTROLLBACK = ToTerm(SonesGQLConstants.TRANSACTION_ROLLBACK);
S_TRANSACTCOMMIT = ToTerm(SonesGQLConstants.TRANSACTION_COMMIT);
S_TRANSACTCOMROLLASYNC = ToTerm(SonesGQLConstants.TRANSACTION_COMROLLASYNC);
S_ADDTOLIST = ToTerm("+=");
S_REMOVEFROMLIST = ToTerm("-=");
S_DUMP = ToTerm("DUMP");
S_EXPORT = ToTerm("EXPORT");
S_ALL = ToTerm("ALL");
S_GDDL = ToTerm("GDDL");
S_GDML = ToTerm("GDML");
S_GQL = ToTerm("GQL");
S_CSV = ToTerm("CSV");
S_COMMENT = ToTerm("COMMENT");
S_REBUILD = ToTerm("REBUILD");
S_DEFINE = ToTerm("DEFINE");
S_UNDEFINE = ToTerm("UNDEFINE");
S_VIA = ToTerm("VIA");
S_LINK = ToTerm("LINK");
S_UNLINK = ToTerm("UNLINK");
S_USE = ToTerm("USE");
#region IMPORT
S_IMPORT = ToTerm("IMPORT");
S_COMMENTS = ToTerm("COMMENTS");
S_PARALLELTASKS = ToTerm("PARALLELTASKS");
S_VERBOSITY = ToTerm("VERBOSITY");
S_FORMAT = ToTerm("FORMAT");
#endregion
#region options
S_OPTIONS = ToTerm("OPTIONS");
#endregion
#endregion
#endregion
#region Non-Terminals
#region ID related
NT_Id = new NonTerminal("Id", CreateIDNode);
var Id_simple = new NonTerminal("id_simple", typeof(AstNode));
var id_typeAndAttribute = new NonTerminal("id_typeAndAttribute");
var idlist = new NonTerminal("idlist");
var id_simpleList = new NonTerminal("id_simpleList");
var id_simpleDotList = new NonTerminal("id_simpleDotList");
var IdOrFunc = new NonTerminal("IdOrFunc");
var IdOrFuncList = new NonTerminal("IdOrFuncList", CreateIDNode);
var IDOrFuncDelimiter = new NonTerminal("IDOrFuncDelimiter");
var dotWrapper = new NonTerminal("dotWrapper", CreateDotDelimiter);
var edgeAccessorWrapper = new NonTerminal("edgeAccessorWrapper", CreateEdgeAccessorDelimiter);
var EdgeInformation = new NonTerminal("EdgeInformation", CreateEdgeInformation);
var EdgeTraversalWithFunctions = new NonTerminal("EdgeTraversalWithFunctions", CreateEdgeTraversal);
var EdgeTraversalWithOutFunctions = new NonTerminal("EdgeTraversalWithOutFunctions", CreateEdgeTraversal);
#endregion
#region AStatements
var singlestmt = new NonTerminal("singlestmt");
var createIndexStmt = new NonTerminal("createIndexStmt", CreateCreateIndexStatementNode);
var alterVertexTypeStmt = new NonTerminal("alterVertexTypeStmt", CreateAlterVertexTypeStmNode);
var alterEdgeTypeStmt = new NonTerminal("alterEdgeTypeStmt", CreateAlterEdgeTypeStmNode);
var dropVertexTypeStmt = new NonTerminal("dropVertexTypeStmt", CreateDropVertexTypeStmNode);
var dropEdgeTypeStmt = new NonTerminal("dropEdgeTypeStmt", CreateDropEdgeTypeStmNode);
var dropIndexStmt = new NonTerminal("dropIndexStmt", CreateDropIndexStmNode);
var InsertStmt = new NonTerminal("InsertStmt", CreateInsertStatementNode);
var updateStmt = new NonTerminal("updateStmt", CreateUpdateStatementNode);
var updateEdgesStmt = new NonTerminal("updateStmt", CreateUpdateEdgesStatementNode);
var deleteStmt = new NonTerminal("deleteStmt", CreateDeleteStatementNode);
var SelectStmtGraph = new NonTerminal("SelectStmtGraph", CreateSelectStatementNode);
var parSelectStmt = new NonTerminal("parSelectStmt", CreatePartialSelectStmtNode);
var createTypesStmt = new NonTerminal("createTypesStmt", CreateCreateVertexTypesStatementNode);
var createEdgeTypesStmt = new NonTerminal("createEdgeTypeStmt", CreateCreateEdgeTypesStatementNode);
var insertorupdateStmt = new NonTerminal("insertorupdateStmt", CreateInsertOrUpdateStatementNode);
var insertorreplaceStmt = new NonTerminal("insertorreplaceStmt", CreateInsertOrReplaceStatementNode);
var replaceStmt = new NonTerminal("replaceStmt", CreateReplaceStatementNode);
var transactStmt = new NonTerminal("transactStmt", CreateTransActionStatementNode);
var commitRollBackTransactStmt = new NonTerminal("commitRollBackTransactStmt", CreateCommitRollbackTransActionNode);
var linkStmt = new NonTerminal("linkStmt", CreateLinkStmtNode);
var unlinkStmt = new NonTerminal("unlinkStmt", CreateUnlinkStmt);
#endregion
var deleteStmtMember = new NonTerminal("deleteStmtMember");
var uniqueOpt = new NonTerminal("uniqueOpt", typeof(UniqueOptNode));
var IndexAttributeList = new NonTerminal("IndexAttributeList", typeof(IndexAttributeListNode));
var IndexAttributeMember = new NonTerminal("IndexAttributeMember", typeof(IndexAttributeNode));
var IndexAttributeType = new NonTerminal("IndexAttributeType");
var orderByAttributeList = new NonTerminal("orderByAttributeList");
var orderByAttributeListMember = new NonTerminal("orderByAttributeListMember");
var AttributeOrderDirectionOpt = new NonTerminal("AttributeOrderDirectionOpt");
NT_IndexTypeOpt = new NonTerminal("indexTypeOpt", typeof(IndexTypeOptNode));
var indexNameOpt = new NonTerminal("indextNameOpt", typeof(IndexNameOptNode));
var editionOpt = new NonTerminal("editionOpt", typeof(EditionOptNode));
var alterVertexTypeCmd = new NonTerminal("alterVertexTypeCmd", typeof(AlterVertexTypeCommandNode));
var alterVertexTypeCmdList = new NonTerminal("alterVertexTypeCmdList");
var alterEdgeTypeCmd = new NonTerminal("alterEdgeTypeCmd", typeof(AlterEdgeTypeCommandNode));
var alterEdgeTypeCmdList = new NonTerminal("alterEdgeTypeCmdList");
var insertData = new NonTerminal("insertData");
var intoOpt = new NonTerminal("intoOpt");
var assignList = new NonTerminal("assignList");
NT_whereClauseOpt = new NonTerminal("whereClauseOpt", CreateWhereExpressionNode);
var extendsOpt = new NonTerminal("extendsOpt");
var abstractOpt = new NonTerminal("abstractOpt");
var commentOpt = new NonTerminal("CommentOpt");
var bulkVertexTypeList = new NonTerminal("bulkVertexTypeList");
var bulkEdgeTypeList = new NonTerminal("bulkEdgeTypeList");
var vertexTypeAttributesOpt = new NonTerminal("vertexTypeAttributesOpt");
var edgeTypeAttributesOpt = new NonTerminal("edgeTypeAttributesOpt");
var insertValuesOpt = new NonTerminal("insertValuesOpt");
NT_UseIndex = new NonTerminal("useIndexOpt", CreateUseIndexNode);
#region Expression
NT_Expression = new NonTerminal("expression", typeof(ExpressionNode));
var expressionOfAList = new NonTerminal("expressionOfAList", typeof(ExpressionOfAListNode));
var BNF_ExprList = new NonTerminal("exprList");
var unExpr = new NonTerminal("unExpr", CreateUnExpressionNode);
var unOp = new NonTerminal("unOp");
var binExpr = new NonTerminal("binExpr", CreateBinaryExpressionNode);
var binOp = new NonTerminal("binOp");
var inExpr = new NonTerminal("inExpr");
#endregion
#region Select
var selList = new NonTerminal("selList");
var fromClauseOpt = new NonTerminal("fromClauseOpt");
var groupClauseOpt = new NonTerminal("groupClauseOpt");
var havingClauseOpt = new NonTerminal("havingClauseOpt", typeof(HavingExpressionNode));
var orderClauseOpt = new NonTerminal("orderClauseOpt", typeof(OrderByNode));
var selectionList = new NonTerminal("selectionList");
var selectionListElement = new NonTerminal("selectionListElement", typeof(SelectionListElementNode));
var aliasOpt = new NonTerminal("aliasOpt");
var aliasOptName = new NonTerminal("aliasOptName");
var selectOutputOpt = new NonTerminal("selectOutputOpt", typeof(SelectOutputOptNode));
#endregion
#region Aggregates & Functions
NT_Aggregate = new NonTerminal("aggregate", CreateAggregateNode);
NT_AggregateArg = new NonTerminal("aggregateArg");
var function = new NonTerminal("function", CreateFunctionCallNode);
var functionName = new NonTerminal("functionName");
NT_FunArgs = new NonTerminal("funArgs");
NT_FuncCall = new NonTerminal("funCall", CreateFunctionCallNode);
#endregion
#region Tuple
var tuple = new NonTerminal("tuple", typeof(TupleNode));
var bracketLeft = new NonTerminal(SonesGQLConstants.BracketLeft);
var bracketRight = new NonTerminal(SonesGQLConstants.BracketRight);
#endregion
var term = new NonTerminal("term");
var notOpt = new NonTerminal("notOpt");
var VertexType = new NonTerminal(SonesGQLConstants.VertexType, CreateVertexTypeNode);
var EdgeType = new NonTerminal(SonesGQLConstants.EdgeType, CreateEdgeTypeNode);
var VertexTypeAttributeList = new NonTerminal("VertexTypeAttributeList");
var VertexTypeAttrDefinition = new NonTerminal("VertexTypeAttrDefinition", CreateVertexTypeAttributeDefinitionNode);
var EdgeTypeAttributeList = new NonTerminal("EdgeTypeAttributeList");
var EdgeTypeAttrDefinition = new NonTerminal("EdgeTypeAttrDefinition", CreateEdgeTypeAttributeDefinitionNode);
var ResultObject = new NonTerminal("ResultObject");
var ResultList = new NonTerminal("ResultList");
var PrefixOperation = new NonTerminal("PrefixOperation");
var ParameterList = new NonTerminal("ParameterList");
var VertexTypeList = new NonTerminal("TypeList", CreateVertexTypeListNode);
NT_AType = new NonTerminal("AType", CreateATypeNode);
NT_VertexType = new NonTerminal("AType", CreateATypeNode);
var VertexTypeWrapper = new NonTerminal("TypeWrapper");
#region Attribute changes
var AttrAssignList = new NonTerminal("AttrAssignList", CreateAttrAssignListNode);
var AttrUpdateList = new NonTerminal("AttrUpdateList", typeof(AttributeUpdateOrAssignListNode));
var EdgeAttrUpdateList = new NonTerminal("EdgeAttrUpdateList", typeof(EdgeAttributeUpdateListNode));
var AttrAssign = new NonTerminal("AttrAssign", typeof(AttributeAssignNode));
var AttrRemove = new NonTerminal("AttrRemove", typeof(AttributeRemoveNode));
var ListAttrUpdate = new NonTerminal("AttrUpdate");
var AddToListAttrUpdate = new NonTerminal("AddToListAttrUpdate", typeof(AddToListAttrUpdateNode));
var AddToListAttrUpdateAddTo = new NonTerminal("AddToListAttrUpdateAddTo", CreateAddToListAttrUpdateAddToNode);
var AddToListAttrUpdateOperator = new NonTerminal("AddToListAttrUpdateOperator", CreateAddToListAttrUpdateOperatorNode);
var RemoveFromListAttrUpdateAddToRemoveFrom = new NonTerminal("RemoveFromListAttrUpdateAddToRemoveFrom", CreateRemoveFromListAttrUpdateAddToRemoveFromNode);
var RemoveFromListAttrUpdateAddToOperator = new NonTerminal("RemoveFromListAttrUpdateAddToOperator", CreateRemoveFromListAttrUpdateAddToOperatorNode);
var RemoveFromListAttrUpdateScope = new NonTerminal("RemoveFromListAttrUpdateScope", CreateRemoveFromListAttrUpdateScope);
var EdgeAttrUpdate = new NonTerminal("EdgeAttrUpdate", typeof(EdgeAttributeUpdateNode));
var AttrUpdateOrAssign = new NonTerminal("AttrUpdateOrAssign");
var CollectionOfDBObjects = new NonTerminal("ListOfDBObjects", typeof(CollectionOfDBObjectsNode));
var CollectionOfEdges = new NonTerminal("ListOfEdges", typeof(CollectionOfEdgesNode));
var CollectionOfBasicDBObjects = new NonTerminal("ListOfBasicDBObjects", typeof(CollectionOfBasicDBObjectsNode));
var VertexTypeVertexIDCollection = new NonTerminal("VertexTypeVertexIDCollection", CreateVertexTypeVertexIDCollection);
var VertexTypeVertexElement = new NonTerminal("VertexTypeVertexElement", CreateVertexTypeVertexElement);
var CollectionTuple = new NonTerminal("CollectionTuple", typeof(TupleNode));
var ExtendedExpressionList = new NonTerminal("ExtendedExpressionList");
var ExtendedExpression = new NonTerminal("ExtendedExpression", typeof(ExpressionOfAListNode));
#endregion
var Reference = new NonTerminal("REFERENCE", typeof(SetRefNode));
var offsetOpt = new NonTerminal("offsetOpt", typeof(OffsetNode));
var resolutionDepthOpt = new NonTerminal("resolutionDepthOpt");
var limitOpt = new NonTerminal("limitOpt", typeof(LimitNode));
var SimpleIdList = new NonTerminal("SimpleIdList");
var bulkVertexTypeListMember = new NonTerminal("bulkVertexTypeListMember", CreateBulkVertexTypeListMemberNode);
var bulkEdgeTypeListMember = new NonTerminal("bulkEdgeTypeListMember", CreateBulkEdgeTypeListMemberNode);
var bulkVertexType = new NonTerminal("bulVertexkType", CreateBulkVertexTypeNode);
var bulkEdgeType = new NonTerminal("bulkEdgeType", CreateBulkEdgeTypeNode);
var truncateStmt = new NonTerminal("truncateStmt", CreateTruncateStmNode);
var uniquenessOpt = new NonTerminal("UniquenessOpt", typeof(UniqueAttributesOptNode));
var mandatoryOpt = new NonTerminal("MandatoryOpt", typeof(MandatoryOptNode));
#region Transactions
var TransactOptions = new NonTerminal("TransactOptions");
var TransactAttributes = new NonTerminal("TransactAttributes");
var TransactIsolation = new NonTerminal("TransactIsolation");
var TransactName = new NonTerminal("TransactName");
var TransactTimestamp = new NonTerminal("TransactTimestamp");
var TransactCommitRollbackOpt = new NonTerminal("TransactCommitRollbackOpt");
var TransactCommitRollbackType = new NonTerminal("TransactCommitRollbackType");
#endregion
var KeyValuePair = new NonTerminal("KeyValuePair", CreateKeyValuePairNode);
NT_KeyValueList = new NonTerminal("ValueList", CreateKeyValueListNode);
var BooleanVal = new NonTerminal("BooleanVal");
var Values = new NonTerminal("Values");
NT_Options = new NonTerminal("Options", CreateOptionsNode);
var ExtKeyValuePair = new NonTerminal("ExtKeyValuePair", CreateExtendedKeyValuePairNode);
NT_ExtKeyValueList = new NonTerminal("ExtValueList", CreateExtendedKeyValueListNode);
var ListType = new NonTerminal("ListType");
var ListParametersForExpression = new NonTerminal("ListParametersForExpression", typeof(ParametersNode));
var LinkCondition = new NonTerminal("LinkCondition");
#region EdgeType
var EdgeTypeDef = new NonTerminal("EdgeTypeDef", CreateEdgeTypeDefNode);
var SingleEdgeTypeDef = new NonTerminal("EdgeTypeDef", CreateSingleEdgeTypeDefNode);
var DefaultValueDef = new NonTerminal("DefaultValueDef", typeof(DefaultValueDefNode));
var EdgeTypeParams = new NonTerminal("EdgeTypeParams", typeof(EdgeTypeParamsNode));
var EdgeTypeParam = new NonTerminal("EdgeTypeParamNode", typeof(EdgeTypeParamNode));
var EdgeType_Sorted = new NonTerminal("ListPropertyAssign_Sorted", typeof(EdgeType_SortedNode));
var EdgeType_SortedMember = new NonTerminal("ListPropertyAssign_SortedMember");
var AttrDefaultOpValue = new NonTerminal("AttrDefaultOpValue", CreateAttrDefaultValueNode);
#endregion
#region IncomingEdges
var incomingEdgesOpt = new NonTerminal("IncomingEdges", CreateIncomingEdgesNode);
var IncomingEdgesSingleDef = new NonTerminal("IncomingEdgesSingleDef", CreateBackwardEdgeNode);
var IncomingEdgesList = new NonTerminal("IncomingEdgesList");
#endregion
#region Index
var indexOptOnCreateType = new NonTerminal("IndexOptOnCreateType");
var indexOnCreateType = new NonTerminal("indexOnCreateType", CreateIndexOnCreateType);
var IndexOptOnCreateTypeMember = new NonTerminal("IndexOptOnCreateTypeMember", CreateIndexOptOnCreateTypeMemberNode);
var IndexOptOnCreateTypeMemberList = new NonTerminal("IndexOptOnCreateTypeMemberList");
var IndexDropOnAlterType = new NonTerminal("IndexDropOnAlterType", CreateDropIndicesNode);
var IndexDropOnAlterTypeMember = new NonTerminal("IndexDropOnAlterTypeMember");
var IndexDropOnAlterTypeMemberList = new NonTerminal("IndexDropOnAlterTypeMemberList");
#endregion
#region Dump/Export
var dumpStmt = new NonTerminal("Dump", CreateDumpNode);
var dumpType = new NonTerminal("dumpType", CreateDumpTypeNode);
var dumpFormat = new NonTerminal("dumpFormat", CreateDumpFormatNode);
var typeOptionalList = new NonTerminal("typeOptionalList");
var dumpDestination = new NonTerminal("dumpDestination");
#endregion
#region Describe
var DescrInfoStmt = new NonTerminal("DescrInfoStmt", CreateDescribeNode);
var DescrArgument = new NonTerminal("DescrArgument");
var DescrFuncStmt = new NonTerminal("DescrFuncStmt", CreateDescrFunc);
var DescrFunctionsStmt = new NonTerminal("DescrFunctionsStmt", CreateDescrFunctions);
var DescrAggrStmt = new NonTerminal("DescrAggrStmt", CreateDescrAggr);
var DescrAggrsStmt = new NonTerminal("DescrAggrsStmt", CreateDescrAggrs);
var DescrTypeStmt = new NonTerminal("DescrTypeStmt", CreateDescrType);
var DescrTypesStmt = new NonTerminal("DescrTypesStmt", CreateDescrTypes);
var DescrIdxStmt = new NonTerminal("DescrIdxStmt", CreateDescrIdx);
var DescrIdxsStmt = new NonTerminal("DescrIdxsStmt", CreateDescrIdxs);
var DescrIdxEdtStmt = new NonTerminal("DescrIdxEdtStmt");
var DescrDedicatedIdxStmt = new NonTerminal("DescrDedicatedIdxStmt");
var DescrEdgeStmt = new NonTerminal("DescrEdgeStmt", CreateDescrEdge);
var DescrEdgesStmt = new NonTerminal("DescrEdgesStmt", CreateDescrEdges);
#endregion
#region REBUILD INDICES
var rebuildIndicesStmt = new NonTerminal("rebuildIndicesStmt", CreateRebuildIndicesNode);
var rebuildIndicesTypes = new NonTerminal("rebuildIndiceTypes");
#endregion
#region Import
NT_ImportFormat = new NonTerminal("importFormat");
NT_ImportStmt = new NonTerminal("import", CreateImportNode);
var paramParallelTasks = new NonTerminal("parallelTasks", CreateParallelTaskNode);
var paramComments = new NonTerminal("comments", CreateCommentsNode);
var verbosity = new NonTerminal("verbosity", CreateVerbosityNode);
var verbosityTypes = new NonTerminal("verbosityTypes");
#endregion
#endregion
#region Statements
#region GQL root
//BNF Rules
this.Root = singlestmt;
singlestmt.Rule = SelectStmtGraph
| InsertStmt
| alterVertexTypeStmt
| alterEdgeTypeStmt
| updateStmt
| updateEdgesStmt
| dropVertexTypeStmt
| dropEdgeTypeStmt
| dropIndexStmt
| createIndexStmt
| createTypesStmt
| createEdgeTypesStmt
| deleteStmt
| truncateStmt
| DescrInfoStmt
| insertorupdateStmt
| insertorreplaceStmt
| replaceStmt
| dumpStmt
| transactStmt
| commitRollBackTransactStmt
| rebuildIndicesStmt
| NT_ImportStmt
| linkStmt
| unlinkStmt;
#endregion
#region misc
#region ID
#region wo functions
Id_simple.Rule = name;
EdgeTraversalWithOutFunctions.Rule = dotWrapper + Id_simple;
NT_Id.SetFlag(TermFlags.IsList);
NT_Id.Rule = Id_simple
| NT_Id + EdgeTraversalWithOutFunctions;
//old
//Id.Rule = MakePlusRule(Id, dotWrapper, Id_simple);
idlist.Rule = MakePlusRule(idlist, S_comma, NT_Id);
id_simpleList.Rule = MakePlusRule(id_simpleList, S_comma, Id_simple);
id_simpleDotList.Rule = MakePlusRule(id_simpleDotList, S_dot, Id_simple);
id_typeAndAttribute.Rule = VertexTypeWrapper + S_dot + NT_Id;
#endregion
#region ID_or_Func
IdOrFunc.Rule = name
| NT_FuncCall;
dotWrapper.Rule = S_edgeTraversalDelimiter;
edgeAccessorWrapper.Rule = S_edgeInformationDelimiterSymbol;
//IDOrFuncDelimiter.Rule = dotWrapper
// | edgeAccessorWrapper;
EdgeTraversalWithFunctions.Rule = dotWrapper + IdOrFunc;
EdgeInformation.Rule = edgeAccessorWrapper + Id_simple;
IdOrFuncList.SetFlag(TermFlags.IsList);
IdOrFuncList.Rule = IdOrFunc
| IdOrFuncList + EdgeInformation
| IdOrFuncList + EdgeTraversalWithFunctions;
//old
//IdOrFuncList.Rule = MakePlusRule(IdOrFuncList, IDOrFuncDelimiter, IdOrFunc);
#endregion
#endregion
#region typeList
VertexTypeList.Rule = MakePlusRule(VertexTypeList, S_comma, NT_AType);
NT_AType.Rule = Id_simple + Id_simple
| Id_simple;
NT_VertexType.Rule = Id_simple;
//AType.Rule = Id + Id_simple
// | Id;
VertexTypeWrapper.Rule = NT_AType;
#endregion
#region CreateIndexAttribute
IndexAttributeList.Rule = MakePlusRule(IndexAttributeList, S_comma, IndexAttributeMember);
IndexAttributeMember.Rule = IndexAttributeType;// + AttributeOrderDirectionOpt;
IndexAttributeType.Rule = IdOrFuncList;// Id_simple | id_typeAndAttribute;
#endregion
#region OrderDirections
AttributeOrderDirectionOpt.Rule = Empty
| S_ASC
| S_DESC;
#endregion
#region Boolean
BooleanVal.Rule = S_TRUE | S_FALSE;
#endregion
#region KeyValue
KeyValuePair.Rule = Id_simple + "=" + string_literal
| Id_simple + "=" + number
| Id_simple + "=" + BooleanVal;
NT_KeyValueList.Rule = MakePlusRule(NT_KeyValueList, S_comma, KeyValuePair);
#endregion
#region ExtendedKeyValue
ExtKeyValuePair.Rule = Id_simple + "=" + string_literal
| Id_simple + "=" + number
| Id_simple + "=" + BooleanVal
| Id_simple + "=" + CollectionOfBasicDBObjects;
NT_ExtKeyValueList.Rule = MakePlusRule(NT_ExtKeyValueList, S_comma, ExtKeyValuePair);
CollectionOfBasicDBObjects.Rule = Empty
| S_SETOF + CollectionTuple
| S_LISTOF + CollectionTuple;
#endregion
#region ListType
ListType.Rule = S_LIST;
ListParametersForExpression.Rule = Empty
| S_colon + S_BRACKET_LEFT + NT_ExtKeyValueList + S_BRACKET_RIGHT;
EdgeType_SortedMember.Rule = S_ASC | S_DESC;
EdgeType_Sorted.Rule = S_SORTED + "=" + EdgeType_SortedMember;
#endregion
#region GraphType
// SET< WEIGHTED (Double, DEFAULT=2, SORTED=DESC)< [idsimple] >>
//EdgeTypeDef.Rule = S_SET + S_ListTypePrefix + Id_simple + S_BRACKET_LEFT + EdgeTypeParams + S_BRACKET_RIGHT + S_ListTypePrefix + Id_simple + S_ListTypePostfix + S_ListTypePostfix;
// SET < USER ( WEIGHTED ) >
EdgeTypeDef.Rule = S_SET + S_ListTypePrefix + Id_simple + S_BRACKET_LEFT + Id_simple + S_BRACKET_RIGHT + S_ListTypePostfix;
// COUNTED (Integer, DEFAULT=2) < [idsimple] >
//SingleEdgeTypeDef.Rule = Id_simple + S_BRACKET_LEFT + EdgeTypeParams + S_BRACKET_RIGHT + S_ListTypePrefix + Id_simple + S_ListTypePostfix;
// USER ( COUNTED )
SingleEdgeTypeDef.Rule = Id_simple + S_BRACKET_LEFT + Id_simple + S_BRACKET_RIGHT;
EdgeTypeParams.Rule = MakeStarRule(EdgeTypeParams, S_comma, EdgeTypeParam);
EdgeTypeParam.Rule = Id_simple
| DefaultValueDef
| EdgeType_Sorted
| string_literal;
EdgeTypeParam.SetFlag(TermFlags.IsTransient, false);
DefaultValueDef.Rule = S_DEFAULT + "=" + KeyValuePair;
VertexType.Rule = Id_simple
| S_LIST + S_ListTypePrefix + Id_simple + S_ListTypePostfix
| S_SET + S_ListTypePrefix + Id_simple + S_ListTypePostfix
| EdgeTypeDef
| SingleEdgeTypeDef;
EdgeType.Rule = Id_simple
| S_LIST + S_ListTypePrefix + Id_simple + S_ListTypePostfix
| S_SET + S_ListTypePrefix + Id_simple + S_ListTypePostfix;
#endregion
#region TypeAttributeList
VertexTypeAttributeList.Rule = MakePlusRule(VertexTypeAttributeList, S_comma, VertexTypeAttrDefinition);
VertexTypeAttrDefinition.Rule = VertexType + Id_simple + AttrDefaultOpValue;
EdgeTypeAttributeList.Rule = MakePlusRule(EdgeTypeAttributeList, S_comma, EdgeTypeAttrDefinition);
EdgeTypeAttrDefinition.Rule = EdgeType + Id_simple + AttrDefaultOpValue;
#endregion
#region IncomingEdgesList
IncomingEdgesList.Rule = MakePlusRule(IncomingEdgesList, S_comma, IncomingEdgesSingleDef);
IncomingEdgesSingleDef.Rule = Id_simple + S_dot + Id_simple + Id_simple;
//| Id_simple + S_dot + Id_simple + S_ListTypePrefix + Id_simple + S_BRACKET_LEFT + EdgeTypeParams + S_BRACKET_RIGHT + S_ListTypePostfix + Id_simple;
#endregion
#region id_simple list
SimpleIdList.Rule = MakePlusRule(SimpleIdList, S_comma, Id_simple);
#endregion
#region expression
//Expression
BNF_ExprList.Rule = MakeStarRule(BNF_ExprList, S_comma, NT_Expression);
NT_Expression.Rule = term
| unExpr
| binExpr;
expressionOfAList.Rule = NT_Expression + ListParametersForExpression;
term.Rule = IdOrFuncList //d.Name
| string_literal //'lala'
| number //10
//| funcCall //EXISTS ( SelectStatement )
| NT_Aggregate //COUNT ( SelectStatement )
| tuple //(d.Name, 'Henning', (SelectStatement))
| parSelectStmt //(FROM User u Select u.Name)
| S_TRUE
| S_FALSE;
#region Tuple
tuple.Rule = bracketLeft + expressionOfAList + bracketRight;
bracketLeft.Rule = S_BRACKET_LEFT | S_TUPLE_BRACKET_LEFT;
bracketRight.Rule = S_BRACKET_RIGHT | S_TUPLE_BRACKET_RIGHT;
#endregion
parSelectStmt.Rule = S_BRACKET_LEFT + SelectStmtGraph + S_BRACKET_RIGHT;
unExpr.Rule = unOp + term;
unOp.Rule = S_NOT
| "+"
| "-"
| "~";
binExpr.Rule = NT_Expression + binOp + NT_Expression
| NT_Expression + binOp + NT_Expression + PreferShiftHere() + S_USE + Id_simple;
NT_UseIndex.Rule = S_USE + Id_simple;
binOp.Rule = ToTerm("+")
| "-"
| "*"
| "/"
| "%" //arithmetic
| "&"
| "|"
| "="
| ">"
| "<"
| ">="
| "<="
| "<>"
| "!="
| "AND"
| "OR"
| "INRANGE"
| "LIKE";
notOpt.Rule = Empty
| S_NOT;
#endregion
#region Functions & Aggregates
//funcCall covers some psedo-operators and special forms like ANY(...), SOME(...), ALL(...), EXISTS(...), IN(...)
//funcCall.Rule = BNF_FuncCallName + S_BRACKET_LEFT + funArgs + S_BRACKET_RIGHT;
// The grammar will be created by IExtendableGrammer methods
//BNF_Aggregate.Rule = Empty;
//BNF_FuncCall.Rule = Empty;
NT_FunArgs.Rule = SelectStmtGraph
| BNF_ExprList;
#endregion
#region operators
//Operators
RegisterOperators(10, "*", "/", "%");
RegisterOperators(9, "+", "-");
RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "!=", "INRANGE", "LIKE");
RegisterOperators(7, "^", "&", "|");
RegisterOperators(6, "NOT");
RegisterOperators(5, "AND", "OR");
#region operators
// Why this definition was twice in the GraphQL???
//RegisterOperators(1, Associativity.Neutral, "AND", "OR");
//RegisterOperators(2, Associativity.Neutral, "=", "!=", ">", ">=", "<", "<=", "<>", "!<", "!>", "IN", "NOTIN", "INRANGE");
//RegisterOperators(3, "+", "-");
//RegisterOperators(4, "*", "/");
RegisterOperators(5, Associativity.Right, "**");
#endregion
#endregion
#region prefixOperation
PrefixOperation.Rule = Id_simple + S_BRACKET_LEFT + ParameterList + S_BRACKET_RIGHT;
ParameterList.Rule = ParameterList + S_comma + NT_Expression
| NT_Expression;
#endregion
#region options
NT_Options.Rule = Empty
| S_OPTIONS + S_BRACKET_LEFT + NT_KeyValueList + S_BRACKET_RIGHT;
#endregion
#endregion
#region CREATE INDEX
createIndexStmt.Rule = S_CREATE + S_INDEX + indexNameOpt + editionOpt + S_ON + S_VERTEX + S_TYPE + VertexTypeWrapper + S_BRACKET_LEFT + IndexAttributeList + S_BRACKET_RIGHT + NT_IndexTypeOpt + NT_Options
| S_CREATE + S_INDEX + indexNameOpt + editionOpt + S_ON + VertexTypeWrapper + S_BRACKET_LEFT + IndexAttributeList + S_BRACKET_RIGHT + NT_IndexTypeOpt + NT_Options; // due to compatibility the + S_TYPE is optional
uniqueOpt.Rule = Empty | S_UNIQUE;
editionOpt.Rule = Empty
| S_EDITION + Id_simple;
NT_IndexTypeOpt.Rule = Empty
| S_INDEXTYPE + Id_simple;
indexNameOpt.Rule = Empty
| Id_simple;
#endregion
#region REBUILD INDICES
rebuildIndicesStmt.Rule = S_REBUILD + S_INDICES + rebuildIndicesTypes;
rebuildIndicesTypes.Rule = Empty | VertexTypeList;
#endregion
#region CREATE VERTEX TYPE(S)
createTypesStmt.Rule = S_CREATE + S_VERTEX + S_TYPES + bulkVertexTypeList
| S_CREATE + S_ABSTRACT + S_VERTEX + S_TYPE + bulkVertexType
| S_CREATE + S_VERTEX + S_TYPE + bulkVertexType;
bulkVertexTypeList.Rule = MakePlusRule(bulkVertexTypeList, S_comma, bulkVertexTypeListMember);
bulkVertexTypeListMember.Rule = abstractOpt + bulkVertexType;
bulkVertexType.Rule = Id_simple + extendsOpt + vertexTypeAttributesOpt + incomingEdgesOpt + uniquenessOpt + mandatoryOpt + indexOptOnCreateType + commentOpt;
commentOpt.Rule = Empty
| S_COMMENT + "=" + string_literal;
abstractOpt.Rule = S_ABSTRACT
| Empty;
extendsOpt.Rule = Empty
| S_EXTENDS + Id_simple;
vertexTypeAttributesOpt.Rule = Empty
| S_ATTRIBUTES + S_BRACKET_LEFT + VertexTypeAttributeList + S_BRACKET_RIGHT;
incomingEdgesOpt.Rule = Empty
| S_INCOMINGEDGES + S_BRACKET_LEFT + IncomingEdgesList + S_BRACKET_RIGHT;
uniquenessOpt.Rule = Empty
| S_UNIQUE + S_BRACKET_LEFT + id_simpleList + S_BRACKET_RIGHT;
mandatoryOpt.Rule = Empty
| S_MANDATORY + S_BRACKET_LEFT + id_simpleList + S_BRACKET_RIGHT;
indexOptOnCreateType.Rule = Empty
| indexOnCreateType;
indexOnCreateType.Rule = S_INDICES + S_BRACKET_LEFT + IndexOptOnCreateTypeMemberList + S_BRACKET_RIGHT
| S_INDICES + IndexOptOnCreateTypeMember;
IndexOptOnCreateTypeMemberList.Rule = MakePlusRule(IndexOptOnCreateTypeMemberList, S_comma, IndexOptOnCreateTypeMember);
IndexOptOnCreateTypeMember.Rule = S_BRACKET_LEFT + indexNameOpt + editionOpt + NT_IndexTypeOpt + S_ON + S_ATTRIBUTES + IndexAttributeList + NT_Options + S_BRACKET_RIGHT
| S_BRACKET_LEFT + indexNameOpt + editionOpt + NT_IndexTypeOpt + S_ON + IndexAttributeList + NT_Options + S_BRACKET_RIGHT // due to compatibility the + S_ATTRIBUTES is optional
| S_BRACKET_LEFT + IndexAttributeList + NT_Options + S_BRACKET_RIGHT;
Values.Rule = BooleanVal | number | string_literal;
AttrDefaultOpValue.Rule = Empty
| "=" + Values;
#endregion
#region CREATE EDGE TYPE(s)
createEdgeTypesStmt.Rule = S_CREATE + S_EDGE + S_TYPE + bulkEdgeType
| S_CREATE + S_EDGE + S_TYPES + bulkEdgeTypeList;
bulkEdgeType.Rule = Id_simple + extendsOpt + edgeTypeAttributesOpt + commentOpt;
edgeTypeAttributesOpt.Rule = Empty
| S_ATTRIBUTES + S_BRACKET_LEFT + EdgeTypeAttributeList + S_BRACKET_RIGHT;
bulkEdgeTypeList.Rule = MakePlusRule(bulkEdgeTypeList, S_comma, bulkEdgeTypeListMember);
bulkEdgeTypeListMember.Rule = abstractOpt + bulkVertexType;
#endregion
#region ALTER VERTEX TYPE
alterVertexTypeStmt.Rule = S_ALTER + S_VERTEX + S_TYPE + Id_simple + alterVertexTypeCmdList + uniquenessOpt + mandatoryOpt;
alterVertexTypeCmd.Rule = Empty
| S_ADD + S_ATTRIBUTES + S_BRACKET_LEFT + VertexTypeAttributeList + S_BRACKET_RIGHT
| S_DROP + S_ATTRIBUTES + S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT
| S_ADD + S_INCOMINGEDGES + S_BRACKET_LEFT + IncomingEdgesList + S_BRACKET_RIGHT
| S_DROP + S_INCOMINGEDGES + S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT
| S_ADD + indexOnCreateType
| S_DROP + IndexDropOnAlterType
| S_RENAME + S_ATTRIBUTE + Id_simple + S_TO + Id_simple
| S_RENAME + S_INCOMINGEDGE + Id_simple + S_TO + Id_simple
| S_RENAME + S_TO + Id_simple
| S_DEFINE + S_ATTRIBUTES + S_BRACKET_LEFT + VertexTypeAttributeList + S_BRACKET_RIGHT
| S_UNDEFINE + S_ATTRIBUTES + S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT
| S_DROP + S_UNIQUE + S_ON + Id_simple
| S_DROP + S_MANDATORY + S_ON + Id_simple
| S_COMMENT + "=" + string_literal;
alterVertexTypeCmdList.Rule = MakePlusRule(alterVertexTypeCmdList, S_comma, alterVertexTypeCmd);
IndexDropOnAlterTypeMember.Rule = S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT;
IndexDropOnAlterTypeMemberList.Rule = MakePlusRule(IndexDropOnAlterTypeMemberList, S_comma, IndexDropOnAlterTypeMember);
IndexDropOnAlterType.Rule = S_INDICES + IndexDropOnAlterTypeMember;
#endregion
#region ALTER EDGE TYPE
alterEdgeTypeStmt.Rule = S_ALTER + S_EDGE + S_TYPE + Id_simple + alterEdgeTypeCmdList;
alterEdgeTypeCmd.Rule = Empty
| S_ADD + S_ATTRIBUTES + S_BRACKET_LEFT + EdgeTypeAttributeList + S_BRACKET_RIGHT
| S_DROP + S_ATTRIBUTES + S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT
| S_RENAME + S_ATTRIBUTE + Id_simple + S_TO + Id_simple
| S_RENAME + S_TO + Id_simple
//| S_DEFINE + S_ATTRIBUTES + S_BRACKET_LEFT + EdgeTypeAttributeList + S_BRACKET_RIGHT
//| S_UNDEFINE + S_ATTRIBUTES + S_BRACKET_LEFT + SimpleIdList + S_BRACKET_RIGHT
| S_COMMENT + "=" + string_literal;
alterEdgeTypeCmdList.Rule = MakePlusRule(alterEdgeTypeCmdList, S_comma, alterEdgeTypeCmd);
#endregion
#region SELECT
SelectStmtGraph.Rule = S_FROM +
VertexTypeList +
S_SELECT +
selList +
NT_whereClauseOpt +
groupClauseOpt +
havingClauseOpt +
orderClauseOpt +
offsetOpt +
limitOpt +
resolutionDepthOpt +
selectOutputOpt;
resolutionDepthOpt.Rule = Empty
| S_DEPTH + number;
selectOutputOpt.Rule = Empty
| "OUTPUT" + name;
offsetOpt.Rule = Empty
| S_OFFSET + number;
limitOpt.Rule = Empty
| S_LIMIT + number;
selList.Rule = selectionList;
selectionList.Rule = MakePlusRule(selectionList, S_comma, selectionListElement);
selectionListElement.Rule = S_ASTERISK
| NT_Aggregate + aliasOpt
| IdOrFuncList + aliasOpt;
aliasOptName.Rule = Id_simple | string_literal;
aliasOpt.Rule = Empty
| S_AS + aliasOptName;
#region Aggregate
//BNF_Aggregate.Rule = BNF_AggregateName + S_BRACKET_LEFT + name + S_BRACKET_RIGHT;
NT_AggregateArg.Rule = NT_Id
| S_ASTERISK;
/*
aggregateName.Rule = S_COUNT
| "AVG"
| "MIN"
| "MAX"
| "STDEV"
| "STDEVP"
| "SUM"
| "VAR"
| "VARP";
*/
#endregion
#region Functions
//function.Rule = functionName + S_BRACKET_LEFT + term + S_BRACKET_RIGHT;
//functionName.Rule = FUNC_WEIGHT;
#endregion
NT_whereClauseOpt.Rule = Empty
| S_WHERE + NT_Expression;
groupClauseOpt.Rule = Empty
| "GROUP" + S_BY + idlist;
havingClauseOpt.Rule = Empty
| "HAVING" + NT_Expression;
orderByAttributeListMember.Rule = NT_Id
| string_literal;
orderByAttributeList.Rule = MakePlusRule(orderByAttributeList, S_comma, orderByAttributeListMember);
orderClauseOpt.Rule = Empty
| "ORDER" + S_BY + orderByAttributeList + AttributeOrderDirectionOpt;
#endregion
#region INSERT
InsertStmt.Rule = S_INSERT + S_INTO + Id_simple + insertValuesOpt;
insertValuesOpt.Rule = Empty
| S_VALUES + S_BRACKET_LEFT + AttrAssignList + S_BRACKET_RIGHT;
AttrAssignList.Rule = MakePlusRule(AttrAssignList, S_comma, AttrAssign);
AttrAssign.Rule = NT_Id + "=" + NT_Expression
| NT_Id + "=" + Reference
| NT_Id + "=" + CollectionOfDBObjects;
CollectionOfDBObjects.Rule = S_SETOF + CollectionTuple
| S_LISTOF + CollectionTuple
| S_SETOFUUIDS + VertexTypeVertexIDCollection
| S_SETOFUUIDS + "()"
| S_SETOF + "()";
VertexTypeVertexIDCollection.Rule = MakeStarRule(VertexTypeVertexIDCollection, VertexTypeVertexElement);
VertexTypeVertexElement.Rule = TERMINAL_LT + Id_simple + TERMINAL_GT + CollectionTuple;
CollectionTuple.Rule = S_BRACKET_LEFT + ExtendedExpressionList + S_BRACKET_RIGHT;
ExtendedExpressionList.Rule = MakePlusRule(ExtendedExpressionList, S_comma, ExtendedExpression);
ExtendedExpression.Rule = NT_Expression + ListParametersForExpression;
Reference.Rule = S_REFERENCE + tuple + ListParametersForExpression
| S_REF + tuple + ListParametersForExpression
| S_REFUUID + TERMINAL_LT + Id_simple + TERMINAL_GT + tuple + ListParametersForExpression
| S_REFERENCEUUID + TERMINAL_LT + Id_simple + TERMINAL_GT + tuple + ListParametersForExpression;
//| S_SETREF + tupleRangeSet + ListParametersForExpression;
#endregion
#region UPDATE
updateStmt.Rule = S_UPDATE + Id_simple + S_SET + S_BRACKET_LEFT + AttrUpdateList + S_BRACKET_RIGHT + NT_whereClauseOpt;
AttrUpdateList.Rule = MakePlusRule(AttrUpdateList, S_comma, AttrUpdateOrAssign);
AttrUpdateOrAssign.Rule = AttrAssign
| AttrRemove
| ListAttrUpdate;
AttrRemove.Rule = S_REMOVE + S_ATTRIBUTES + S_BRACKET_LEFT + id_simpleList + S_BRACKET_RIGHT;
ListAttrUpdate.Rule = AddToListAttrUpdate
| RemoveFromListAttrUpdateAddToRemoveFrom
| RemoveFromListAttrUpdateAddToOperator;
AddToListAttrUpdate.Rule = AddToListAttrUpdateAddTo
| AddToListAttrUpdateOperator;
AddToListAttrUpdateAddTo.Rule = S_ADD + S_TO + NT_Id + CollectionOfDBObjects;
AddToListAttrUpdateOperator.Rule = NT_Id + S_ADDTOLIST + CollectionOfDBObjects;
RemoveFromListAttrUpdateAddToRemoveFrom.Rule = S_REMOVE + S_FROM + NT_Id + tuple;
RemoveFromListAttrUpdateAddToOperator.Rule = NT_Id + RemoveFromListAttrUpdateScope;
RemoveFromListAttrUpdateScope.Rule = S_REMOVEFROMLIST + tuple | S_REMOVEFROMLIST + CollectionOfDBObjects;
#endregion
#region UPDATE EDGES
// UPDATE EDGES ON User
updateEdgesStmt.Rule = S_UPDATE + S_EDGES + S_ON + Id_simple +
// ( Friends = (), Fiends = () ) WHERE Name = 'Hans'
S_BRACKET_LEFT + EdgeAttrUpdateList + S_BRACKET_RIGHT + NT_whereClauseOpt;
// Friends = (), Fiends = ()
EdgeAttrUpdateList.Rule = MakePlusRule(EdgeAttrUpdateList, S_comma, EdgeAttrUpdate);
// Friends = (Name = 'Hans' : (Weight = 1.5))
EdgeAttrUpdate.Rule = NT_Id + "=" + CollectionOfEdges;
// Name = 'Hans' : (Weight = 1.5)
CollectionOfEdges.Rule = CollectionTuple;
#endregion
#region DROP VertexType
dropVertexTypeStmt.Rule = S_DROP + S_VERTEX + S_TYPE + Id_simple;
#endregion
#region DROP EdgeType
dropEdgeTypeStmt.Rule = S_DROP + S_EDGE + S_TYPE + Id_simple;
#endregion
#region DROP INDEX
dropIndexStmt.Rule = S_FROM + VertexTypeWrapper + S_DROP + S_INDEX + Id_simple + editionOpt;
#endregion
#region TRUNCATE
truncateStmt.Rule = S_TRUNCATE + S_VERTEX + S_TYPE + Id_simple;
#endregion
#region DELETE
deleteStmtMember.Rule = Empty | idlist;
deleteStmt.Rule = S_FROM + Id_simple + S_DELETE + deleteStmtMember + NT_whereClauseOpt;
#endregion
#region DESCRIBE
DescrInfoStmt.Rule = S_DESCRIBE + DescrArgument;
DescrArgument.Rule = DescrAggrStmt
| DescrAggrsStmt
| DescrEdgeStmt
| DescrEdgesStmt
| DescrTypeStmt
| DescrTypesStmt
| DescrFuncStmt
| DescrFunctionsStmt
| DescrIdxStmt
| DescrIdxsStmt;
DescrAggrStmt.Rule = S_AGGREGATE + string_literal;
DescrAggrsStmt.Rule = S_AGGREGATES;
DescrEdgeStmt.Rule = S_EDGE + Id_simple;
DescrEdgesStmt.Rule = S_EDGES;
DescrTypeStmt.Rule = S_VERTEX + S_TYPE + Id_simple;
DescrTypesStmt.Rule = S_VERTEX + S_TYPES;
DescrFuncStmt.Rule = S_FUNCTION + string_literal;
DescrFunctionsStmt.Rule = S_FUNCTIONS;
// User [IndexName] [EDITION default]
DescrIdxStmt.Rule = S_INDEX + NT_VertexType + DescrDedicatedIdxStmt + DescrIdxEdtStmt;
DescrDedicatedIdxStmt.Rule = Empty | Id_simple;
DescrIdxEdtStmt.Rule = Empty
| S_EDITION + Id_simple;
DescrIdxsStmt.Rule = S_INDICES;
#endregion
#region INSERTORUPDATE
insertorupdateStmt.Rule = S_INSERTORUPDATE + Id_simple + S_VALUES + S_BRACKET_LEFT + AttrUpdateList + S_BRACKET_RIGHT + NT_whereClauseOpt;
#endregion
#region INSERTORREPLACE
insertorreplaceStmt.Rule = S_INSERTORREPLACE + Id_simple + S_VALUES + S_BRACKET_LEFT + AttrAssignList + S_BRACKET_RIGHT + NT_whereClauseOpt;
#endregion
#region REPLACE
replaceStmt.Rule = S_REPLACE + Id_simple + S_VALUES + S_BRACKET_LEFT + AttrAssignList + S_BRACKET_RIGHT + S_WHERE + NT_Expression;
#endregion
#region TRANSACTION
#region BeginTransAction
transactStmt.Rule = S_BEGIN + TransactOptions + S_TRANSACTION + TransactAttributes;
TransactOptions.Rule = Empty |
S_TRANSACTDISTRIBUTED + S_TRANSACTLONGRUNNING |
S_TRANSACTDISTRIBUTED |
S_TRANSACTLONGRUNNING;
TransactAttributes.Rule = Empty |
TransactIsolation |
TransactName |
TransactTimestamp |
TransactIsolation + TransactName |
TransactIsolation + TransactTimestamp |
TransactName + TransactTimestamp |
TransactIsolation + TransactName + TransactTimestamp;
TransactIsolation.Rule = S_TRANSACTISOLATION + "=" + string_literal;
TransactName.Rule = S_TRANSACTNAME + "=" + string_literal;
TransactTimestamp.Rule = S_TRANSACTTIMESTAMP + "=" + string_literal;
#endregion
#region CommitRollbackTransAction
commitRollBackTransactStmt.Rule = TransactCommitRollbackType + S_TRANSACTION + TransactCommitRollbackOpt;
TransactCommitRollbackType.Rule = S_TRANSACTCOMMIT | S_TRANSACTROLLBACK;
TransactCommitRollbackOpt.Rule = Empty |
TransactName |
S_TRANSACTCOMROLLASYNC |
TransactName + S_TRANSACTCOMROLLASYNC;
#endregion
#endregion
#region EXPORT/DUMP
dumpType.Rule = Empty | S_ALL | S_GDDL | S_GDML; // If empty => create both
dumpFormat.Rule = Empty | S_AS + S_GQL; // If empty => create GQL
typeOptionalList.Rule = Empty | S_VERTEX + S_TYPES + id_simpleList;
dumpDestination.Rule = Empty | S_INTO + location_literal | S_TO + location_literal;
dumpStmt.Rule = S_DUMP + typeOptionalList + dumpType + dumpFormat + dumpDestination
| S_EXPORT + typeOptionalList + dumpType + dumpFormat + dumpDestination;
#endregion
#region IMPORT
paramComments.Rule = S_COMMENTS + tuple | Empty;
paramParallelTasks.Rule = S_PARALLELTASKS + "(" + number + ")" | Empty;
verbosityTypes.Rule = ToTerm(VerbosityTypes.Silent.ToString()) | ToTerm(VerbosityTypes.Errors.ToString()) | ToTerm(VerbosityTypes.Full.ToString());
verbosity.Rule = S_VERBOSITY + verbosityTypes | Empty;
//BNF_ImportFormat.Rule = Empty;
NT_ImportStmt.Rule = S_IMPORT + S_FROM + location_literal + S_FORMAT + NT_ImportFormat + paramParallelTasks + paramComments + offsetOpt + limitOpt + verbosity + NT_Options;
#endregion
#region LINK
// Semantic Web Yoda-Style and human language style
linkStmt.Rule = S_LINK + VertexTypeWrapper + CollectionTuple + S_VIA + NT_Id + S_TO + LinkCondition |
S_LINK + VertexTypeWrapper + CollectionTuple + S_TO + LinkCondition + S_VIA + NT_Id;
LinkCondition.Rule = VertexTypeWrapper + CollectionTuple;
#endregion
#region UNLINK
unlinkStmt.Rule = S_UNLINK + VertexTypeWrapper + CollectionTuple + S_VIA + NT_Id + S_FROM + LinkCondition |
S_UNLINK + VertexTypeWrapper + CollectionTuple + S_FROM + LinkCondition + S_VIA + NT_Id;
#endregion
#endregion
#region Misc
#region punctuation
MarkPunctuation(",", S_BRACKET_LEFT.ToString(), S_BRACKET_RIGHT.ToString(), "[", "]");
//RegisterPunctuation(",", S_BRACKET_LEFT.Symbol, S_BRACKET_RIGHT.Symbol, S_TUPLE_BRACKET_LEFT.Symbol, S_TUPLE_BRACKET_RIGHT.Symbol);
//RegisterPunctuation(",");
//RegisterBracePair(_S_BRACKET_LEFT.Symbol, S_BRACKET_RIGHT.Symbol);
//RegisterBracePair(_S_TUPLE_BRACKET_LEFT.Symbol, S_TUPLE_BRACKET_RIGHT.Symbol);
//RegisterBracePair(_S_TUPLE_BRACKET_LEFT_EXCLUSIVE.Symbol, S_TUPLE_BRACKET_RIGHT.Symbol);
//RegisterBracePair(_S_TUPLE_BRACKET_LEFT.Symbol, S_TUPLE_BRACKET_RIGHT_EXCLUSIVE.Symbol);
//RegisterBracePair(_S_TUPLE_BRACKET_LEFT_EXCLUSIVE.Symbol, S_TUPLE_BRACKET_RIGHT_EXCLUSIVE.Symbol);
#endregion
base.MarkTransient(
singlestmt, Id_simple, selList, /* selectionSource, */NT_Expression, term, NT_FunArgs
, unOp, /*binOp, */ /*aliasOpt, */ aliasOptName, orderByAttributeListMember
//, KeyValuePair
//, EdgeTypeParam
, EdgeType_SortedMember, AttrUpdateOrAssign, ListAttrUpdate, DescrArgument,
VertexTypeWrapper //is used as a wrapper for AType
, IdOrFunc //, IdOrFuncList
, BNF_ExprList, NT_AggregateArg,
//ExtendedExpressionList,
NT_ImportFormat, NT_FuncCall, NT_Aggregate, verbosityTypes/*,
vertexType, BNF_VertexTypes*/);
#endregion
}
TerminalSet _skipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution
public AsmGrammar()
{
this.GrammarComments = "Asm grammar.\r\n";
#region Lexical structure
NumberLiteral number = new NumberLiteral("NUMBER", NumberOptions.Default);
IdentifierTerminal label = new IdentifierTerminal("LABEL", IdOptions.IsNotKeyword | IdOptions.AllowsEscapes | IdOptions.CanStartWithEscape);
//RegexBasedTerminal label = new RegexBasedTerminal("LABEL", "[A-Za-z_][A-Za-z_0-9]+");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", ";", "#");
NonGrammarTerminals.Add(SingleLineComment);
KeyTerm COMMA = ToTerm(",", "COMMA");
KeyTerm PLUS = ToTerm("+", "PLUS");
KeyTerm MINUS = ToTerm("-", "MINUS");
KeyTerm TIMES = ToTerm("*", "TIMES");
///<remarks>Bracket Square Left</remarks>
KeyTerm BSL = ToTerm("[");
///<remarks>Bracket Square Right</remarks>
KeyTerm BSR = ToTerm("]");
///<remarks>Bracket Left</remarks>
KeyTerm BL = ToTerm("(");
///<remarks>Bracket Right</remarks>
KeyTerm BR = ToTerm(")");
MarkPunctuation("(", ")", "[", "]");
#endregion Lexical structure
#region NonTerminals
var line = new NonTerminal("line");
var directive = new NonTerminal("directive");
var label_def = new NonTerminal("label_def");
var label_def_opt = new NonTerminal("label_def_opt");
var instruction = new NonTerminal("instruction");
var instruction_opt = new NonTerminal("instruction_opt");
#region Registers
var r8 = new NonTerminal("Reg8");
var r16 = new NonTerminal("Reg16");
var r32 = new NonTerminal("Reg32");
var r64 = new NonTerminal("Reg64");
#endregion Registers
var m8 = new NonTerminal("Mem8");
var m16 = new NonTerminal("Mem16");
var m32 = new NonTerminal("Mem32");
var m64 = new NonTerminal("Mem64");
var mem_op = new NonTerminal("MemOp");
//var mem_scale_index_32 = new NonTerminal("ScaleIdx32");
var mem_scale_index_64 = new NonTerminal("ScaleIdx64");
//var mem_scale_index_bracket_32 = new NonTerminal("ScaleIdxBrac32");
var mem_scale_index_bracket_64 = new NonTerminal("ScaleIdxBrac64");
// var mem_base_32 = new NonTerminal("Base32");
var mem_base_64 = new NonTerminal("Base64");
var mem_scale = new NonTerminal("Scale");
var mem_index_32 = new NonTerminal("Idx32");
var mem_index_64 = new NonTerminal("Idx64");
var mem_ptr = new NonTerminal("ptr");
var mem_disp = new NonTerminal("Disp");
var mnemomic_add = new NonTerminal("add");
var mnemomic_jmp = new NonTerminal("jmp");
#endregion NonTerminals
#region operators, punctuation and delimiters
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*");
#endregion
#region comments
this.MarkPunctuation(";", ",", "(", ")", "[", "]", ":");
//this.MarkTransient(namespace_member_declaration, member_declaration);
//this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
//this.AddToNoReportGroup("var", "const", "new");
#endregion
#region Rules
this.Root = line;
line.Rule = directive;
line.Rule |= label_def_opt + instruction_opt;
label_def_opt.Rule = Empty;
label_def_opt.Rule |= label_def;
label_def.Rule = label + ":";
label_def.Rule |= label + "::";
instruction_opt.Rule = Empty;
instruction_opt.Rule |= instruction;
#region Memory Operand
m8.Rule = "byte" + mem_ptr + BSL + mem_op + BSR;
m16.Rule = "word" + mem_ptr + BSL + mem_op + BSR;
m32.Rule = "dword" + mem_ptr + BSL + mem_op + BSR;
m64.Rule = "qword" + mem_ptr + BSL + mem_op + BSR;
mem_ptr.Rule = Empty;
mem_ptr.Rule |= "ptr";
mem_op.Rule = mem_base_64 + PLUS + mem_scale_index_bracket_64 + mem_disp; //ABC
mem_op.Rule |= mem_base_64 + mem_disp + PLUS + mem_scale_index_bracket_64; //ACB
//mem_op.Rule |= mem_disp + PLUS + mem_base_64 + PLUS + mem_scale_index_bracket_64; //CAB
//mem_op.Rule |= mem_disp + PLUS + mem_scale_index_bracket_64 + PLUS + mem_base_64; //CBA
//PreferShiftHere() +
//mem_op.Rule |= mem_scale_index_bracket_64; //B
//mem_op.Rule |= mem_base_64; not needed
//mem_op.Rule |= mem_disp; //C
//mem_op.Rule |= mem_base_64 + PLUS + mem_scale_index_bracket_64; //AB
//mem_op.Rule |= mem_scale_index_bracket_64 + PLUS + mem_base_64; //BA
//mem_op.Rule |= mem_base_64 + PLUS + mem_disp; //AC
//mem_op.Rule |= mem_disp + PLUS + mem_base_64; //CA
mem_scale_index_bracket_64.Rule = BL + mem_scale_index_64 + BR;
mem_scale_index_bracket_64.Rule |= mem_scale_index_64;
mem_scale_index_64.Rule = mem_scale + TIMES + mem_index_64;
mem_scale_index_64.Rule |= mem_index_64 + TIMES + mem_scale;
mem_scale_index_64.Rule |= mem_index_64;
mem_base_64.Rule = r64;
mem_scale.Rule = ToTerm("0");
mem_scale.Rule |= "1";
mem_scale.Rule |= "2";
mem_scale.Rule |= "4";
mem_scale.Rule |= "8";
mem_index_32.Rule = r32;
mem_index_64.Rule = r64;
mem_disp.Rule = PLUS + CustomActionHere(this.findTimesChar) + number;
mem_disp.Rule |= MINUS + CustomActionHere(this.findTimesChar) + number;
#endregion Memory Operand
r8.Rule = ToTerm("al");
r8.Rule |= "ah";
r16.Rule = ToTerm("ax");
r32.Rule = ToTerm("eax");
r64.Rule = ToTerm("rax") | "rbx" | "rcx" | "rdx";
#region Mnemonics
instruction.Rule = mnemomic_add;
instruction.Rule |= mnemomic_jmp;
mnemomic_add.Rule = "add" + r8 + COMMA + r8;
mnemomic_add.Rule |= "add" + r16 + COMMA + r16;
mnemomic_add.Rule |= "add" + m16 + COMMA + r16;
mnemomic_add.Rule |= "add" + r16 + COMMA + m16;
mnemomic_jmp.Rule = "jmp" + r8;
mnemomic_jmp.Rule |= "jmp" + label;
mnemomic_jmp.Rule |= "jmp" + m32;
#endregion Mnemonics
#region Directive
directive.Rule = ToTerm("align");
directive.Rule |= "proc";
#endregion Directive
#endregion Rules
label.ValidateToken += label_ValidateToken;
}
public VASLGrammar()
: base(true)
{
var string_lit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
number.Options |= NumberOptions.AllowSign;
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(single_line_comment);
NonGrammarTerminals.Add(delimited_comment);
var state = new KeyTerm("state", "state");
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var version = new NonTerminal("version");
var state_def = new NonTerminal("stateDef");
var state_list = new NonTerminal("stateList");
var method_list = new NonTerminal("methodList");
var var_list = new NonTerminal("varList");
var module = new NonTerminal("module");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var offset_list = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var method_type = new NonTerminal("methodType");
root.Rule = state_list + method_list;
version.Rule = (comma + string_lit) | Empty;
state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}";
state_list.Rule = MakeStarRule(state_list, state_def);
method_list.Rule = MakeStarRule(method_list, method);
var_list.Rule = MakeStarRule(var_list, semi, var);
module.Rule = (string_lit + comma) | Empty;
var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty;
method.Rule = (method_type + "{" + code + "}") | Empty;
offset_list.Rule = MakePlusRule(offset_list, comma, offset);
offset.Rule = number;
method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown;
Root = root;
MarkTransient(var_list, method_list, offset, method_type);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public GramaticaCQL() : base(false)
{
CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/");
CommentTerminal lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
/* Reserved Words */
KeyTerm
null_ = ToTerm("null"),
true_ = ToTerm("true"),
false_ = ToTerm("false"),
type_ = ToTerm("type"),
if_ = ToTerm("if"),
not_ = ToTerm("not"),
exists_ = ToTerm("exists"),
int_ = ToTerm("int"),
double_ = ToTerm("double"),
string_ = ToTerm("string"),
boolean_ = ToTerm("boolean"),
date_ = ToTerm("date"),
time_ = ToTerm("time"),
use_ = ToTerm("use"),
create_ = ToTerm("create"),
database_ = ToTerm("database"),
drop_ = ToTerm("drop"),
table_ = ToTerm("table"),
counter_ = ToTerm("counter"),
primary_ = ToTerm("primary"),
key_ = ToTerm("key"),
alter_ = ToTerm("alter"),
add_ = ToTerm("add"),
truncate_ = ToTerm("truncate"),
commit_ = ToTerm("commit"),
rollback_ = ToTerm("rollback"),
user_ = ToTerm("user"),
with_ = ToTerm("with"),
password_ = ToTerm("password"),
grant_ = ToTerm("grant"),
on_ = ToTerm("on"),
revoke_ = ToTerm("revoke"),
insert_ = ToTerm("insert"),
into_ = ToTerm("into"),
values_ = ToTerm("values"),
update_ = ToTerm("update"),
set_ = ToTerm("set"),
where_ = ToTerm("where"),
delete_ = ToTerm("delete"),
from_ = ToTerm("from"),
select_ = ToTerm("select"),
order_ = ToTerm("order"),
by_ = ToTerm("by"),
asc_ = ToTerm("asc"),
desc_ = ToTerm("desc"),
limit_ = ToTerm("limit"),
begin_ = ToTerm("begin"),
batch_ = ToTerm("batch"),
apply_ = ToTerm("apply"),
count_ = ToTerm("count"),
min_ = ToTerm("min"),
max_ = ToTerm("max"),
sum_ = ToTerm("sum"),
avg_ = ToTerm("avg"),
in_ = ToTerm("in"),
else_ = ToTerm("else"),
switch_ = ToTerm("switch"),
case_ = ToTerm("case"),
default_ = ToTerm("default"),
while_ = ToTerm("while"),
do_ = ToTerm("do"),
for_ = ToTerm("for"),
new_ = ToTerm("new"),
map_ = ToTerm("map"),
list_ = ToTerm("list"),
procedure_ = ToTerm("procedure"),
call_ = ToTerm("call"),
break_ = ToTerm("break"),
continue_ = ToTerm("continue"),
return_ = ToTerm("return"),
cursor_ = ToTerm("cursor"),
is_ = ToTerm("is"),
each_ = ToTerm("each"),
open_ = ToTerm("open"),
close_ = ToTerm("close"),
log_ = ToTerm("log"),
throw_ = ToTerm("throw"),
try_ = ToTerm("try"),
catch_ = ToTerm("catch"),
as_ = ToTerm("as");
MarkReservedWords("null", "true", "false", "type", "if", "not", "exists", "int", "double", "string", "boolean",
"date", "time", "use", "create", "database", "drop", "table", "counter", "primary", "key", "alter", "add",
"truncate", "commit", "rollback", "user", "with", "password", "grant", "on", "revoke", "insert", "into",
"values", "update", "set", "where", "delete", "from", "select", "order", "by", "asc", "desc", "limit",
"begin", "batch", "apply", "count", "min", "max", "sum", "avg", "in", "else", "switch", "case", "default",
"while", "do", "for", "new", "map", "list", "procedure", "call", "break", "continue", "return", "cursor",
"is", "each", "open", "close", "log", "throw", "try", "catch", "as");
/* Relational operators */
KeyTerm
menorigual = ToTerm("<="),
mayorigual = ToTerm(">="),
menorque = ToTerm("<"),
mayorque = ToTerm(">"),
igual = ToTerm("=="),
diferente = ToTerm("!=");
/* Logic operators */
KeyTerm
or = ToTerm("||"),
and = ToTerm("&&"),
xor = ToTerm("^"),
not = ToTerm("!");
/* Shift operators */
KeyTerm
leftShift = ToTerm("--"),
rightShift = ToTerm("++");
/* Arithmetic Operators*/
KeyTerm
mas = ToTerm("+"),
menos = ToTerm("-"),
por = ToTerm("*"),
division = ToTerm("/"),
modulo = ToTerm("%"),
potencia = ToTerm("**");
/* Symbols*/
KeyTerm
equal = ToTerm("="),
semicolon = ToTerm(";"),
leftPar = ToTerm("("),
rightPar = ToTerm(")"),
dot = ToTerm("."),
comma = ToTerm(","),
questionmark = ToTerm("?"),
colon = ToTerm(":"),
leftCor = ToTerm("["),
rightCor = ToTerm("]"),
leftLla = ToTerm("{"),
rightLla = ToTerm("}"),
masEqual = ToTerm("+="),
menosEqual = ToTerm("-="),
porEqual = ToTerm("*="),
divisionEqual = ToTerm("/="),
menormenor = ToTerm("<<"),
mayormayor = ToTerm(">>");
MarkPunctuation(";");
var number = new NumberLiteral("number");
//var identifier = new IdentifierTerminal("identifier");
RegexBasedTerminal identifier = new RegexBasedTerminal("identifier", "([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*");
RegexBasedTerminal identifier2 = new RegexBasedTerminal("identifier2", "@([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*");
//RegexBasedTerminal date = new RegexBasedTerminal("date", "\'([0-2][0-9]{3}|[0-9][0-9]{0,2})-([0]?[0-9]|[1][0-2])-([0]?[0-9]|[1-2][0-9]|[3][0-1])\'");
//RegexBasedTerminal time = new RegexBasedTerminal("time", "\'([0]?[0-9]|[1][0-9]|[2][0-4]):([0]?[0-9]|[1-5][0-9]):([0]?[0-9]|[1-5][0-9])\'");
RegexBasedTerminal date = new RegexBasedTerminal("date", "\'[0-9]+-[0-9]+-[0-9]+\'");
RegexBasedTerminal time = new RegexBasedTerminal("time", "\'[0-9]+:[0-9]+:[0-9]+\'");
var stringliteral = new StringLiteral("stringliteral", "\"", StringOptions.IsTemplate);
NonTerminal
INICIO = new NonTerminal("INICIO"),
INSTRUCCIONES = new NonTerminal("INSTRUCCIONES"),
INSTRUCCION = new NonTerminal("INSTRUCCION"),
TYPE = new NonTerminal("TYPE"),
TYPE_PRIMITIVE = new NonTerminal("TYPE_PRIMITIVE"),
TYPE_COLLECTION = new NonTerminal("TYPE_COLLECTION"),
TYPEDEF = new NonTerminal("TYPEDEF"),
IFNOTEXIST = new NonTerminal("IFNOTEXIST"),
IFEXIST = new NonTerminal("IFEXIST"),
ATTRIBUTE_LIST = new NonTerminal("ATTRIBUTE_LIST"),
ATTRIBUTEREF = new NonTerminal("ATTRIBUTEREF"),
ATTRIBUTE = new NonTerminal("ATTRIBUTE"),
USE = new NonTerminal("USE"),
DATABASEDEF = new NonTerminal("DATABASEDEF"),
DROP = new NonTerminal("DROP"),
TABLEDEF = new NonTerminal("TABLEDEF"),
COLUMN_LIST = new NonTerminal("COLUMN_LIST"),
COLUMN = new NonTerminal("COLUMN"),
ID_LIST = new NonTerminal("ID_LIST"),
TABLEALTER = new NonTerminal("TABLEALTER"),
TABLEDROP = new NonTerminal("TABLEDROP"),
TABLETRUNCATE = new NonTerminal("TABLETRUNCATE"),
COMMIT = new NonTerminal("COMMIT"),
ROLLBACK = new NonTerminal("ROLLBACK"),
USERDEF = new NonTerminal("USERDEF"),
GRANT = new NonTerminal("GRANT"),
REVOKE = new NonTerminal("REVOKE"),
WHERE = new NonTerminal("WHERE"),
INSERT = new NonTerminal("INSERT"),
UPDATE = new NonTerminal("UPDATE"),
DELETE = new NonTerminal("DELETE"),
SELECT = new NonTerminal("SELECT"),
SELECT_EXP = new NonTerminal("SELECT_EXP"),
ORDER_LIST = new NonTerminal("ORDER_LIST"),
ORDER = new NonTerminal("ORDER"),
BATCH = new NonTerminal("BATCH"),
DML_LIST = new NonTerminal("DML_LIST"),
DML = new NonTerminal("DML"),
TARGET_LIST = new NonTerminal("TARGET_LIST"),
TARGET = new NonTerminal("TARGET"),
EXPRESSION_STMT = new NonTerminal("EXPRESSION_STMT"),
ASSIGNMENT_STMT = new NonTerminal("ASSIGNMENT_STMT"),
ASSIGNMENTS = new NonTerminal("ASSIGNMENTS"),
ASSIGNMENT_CALL = new NonTerminal("ASSIGNMENT_CALL"),
ASSIGNMENT_LIST = new NonTerminal("ASSIGNMENT_LIST"),
DECLARATION_STMT = new NonTerminal("DECLARATION_STMT"),
AUGMENTED_ASSIGNMENT_STMT = new NonTerminal("AUGMENTED_ASSIGNMENT_STMT"),
//AUGTARGET = new NonTerminal("AUGTARGET"),
AUG_OPERATOR = new NonTerminal("AUG_OPERATOR"),
IF_STMT = new NonTerminal("IF_STMT"),
IF_LIST = new NonTerminal("IF_LIST"),
SWITCH_STMT = new NonTerminal("SWITCH_STMT"),
CASES = new NonTerminal("CASES"),
WHILE_STMT = new NonTerminal("WHILE_STMT"),
DOWHILE_STMT = new NonTerminal("DOWHILE_STMT"),
FOR_STMT = new NonTerminal("FOR_STMT"),
FOR_INIT = new NonTerminal("FOR_INIT"),
FOR_UPDATE = new NonTerminal("FOR_UPDATE"),
FUNDEF = new NonTerminal("FUNDEF"),
PARAMETER_LIST = new NonTerminal("PARAMETER_LIST"),
PROCDEF = new NonTerminal("PROCDEF"),
BREAK_STMT = new NonTerminal("BREAK_STMT"),
CONTINUE_STMT = new NonTerminal("CONTINUE_STMT"),
RETURN_STMT = new NonTerminal("RETURN_STMT"),
CURSOR_STMT = new NonTerminal("CURSOR_STMT"),
FOREACH_STMT = new NonTerminal("FOREACH_STMT"),
OPEN_STMT = new NonTerminal("OPEN_STMT"),
CLOSE_STMT = new NonTerminal("CLOSE_STMT"),
LOG_STMT = new NonTerminal("LOG_STMT"),
THROW_STMT = new NonTerminal("THROW_STMT"),
TRYCATCH_STMT = new NonTerminal("TRYCATCH_STMT"),
BLOQUE = new NonTerminal("BLOQUE"),
SENTENCIAS = new NonTerminal("SENTENCIAS"),
SENTENCIA = new NonTerminal("SENTENCIA"),
/*STARRED_EXPRESSION = new NonTerminal("STARRED_EXPRESSION"),
* STARRED_LIST = new NonTerminal("STARRED_LIST"),
* STARRED_ITEM = new NonTerminal("STARRED_ITEM"),*/
AGGREGATION = new NonTerminal("AGGREGATION"),
AGGREGATION_FUN = new NonTerminal("AGGREGATION_FUN"),
EXPRESSION_LIST = new NonTerminal("EXPRESSION_LIST"),
EXPRESSION = new NonTerminal("EXPRESSION"),
CONDITIONAL_EXPRESSION = new NonTerminal("CONDITIONAL_EXPRESSION"),
INSTANCE = new NonTerminal("INSTANCE"),
OR_EXPR = new NonTerminal("OR_EXPR"),
AND_EXPR = new NonTerminal("AND_EXPR"),
XOR_EXPR = new NonTerminal("XOR_EXPR"),
NOT_EXPR = new NonTerminal("NOT_EXPR"),
COMPARISON = new NonTerminal("COMPARISON"),
COMPARISON_EQ = new NonTerminal("COMPARISON_EQ"),
COMP_OPERATOR = new NonTerminal("COMP_OPERATOR"),
SHIFT_EXPR = new NonTerminal("SHIFT_EXPR"),
A_EXPR = new NonTerminal("A_EXPR"),
M_EXPR = new NonTerminal("M_EXPR"),
U_EXPR = new NonTerminal("U_EXPR"),
POWER = new NonTerminal("POWER"),
PRIMARY = new NonTerminal("PRIMARY"),
ATOM = new NonTerminal("ATOM"),
FUNCALL = new NonTerminal("FUNCALL"),
CALL = new NonTerminal("CALL"),
ACCESS = new NonTerminal("ACCESS"),
ENCLOSURE = new NonTerminal("ENCLOSURE"),
LITERAL = new NonTerminal("LITERAL"),
PARENTH_FORM = new NonTerminal("PARENTH_FORM"),
MAP_DISPLAY = new NonTerminal("MAP_DISPLAY"),
MAP_LIST = new NonTerminal("MAP_LIST"),
LIST_DISPLAY = new NonTerminal("LIST_DISPLAY"),
SET_DISPLAY = new NonTerminal("SET_DISPLAY");
this.Root = INICIO;
INICIO.Rule = INSTRUCCIONES;
INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION);
INSTRUCCION.Rule = TYPEDEF + semicolon
| USE + semicolon
| DATABASEDEF + semicolon
| DROP + semicolon
| TABLEDEF + semicolon
| TABLEALTER + semicolon
| TABLEDROP + semicolon
| TABLETRUNCATE + semicolon
| COMMIT + semicolon
| ROLLBACK + semicolon
| USERDEF + semicolon
| GRANT + semicolon
| REVOKE + semicolon
| INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon
| SELECT + semicolon
| BATCH + semicolon
| EXPRESSION_STMT + semicolon
| DECLARATION_STMT + semicolon
| ASSIGNMENT_STMT + semicolon
| ASSIGNMENT_CALL + semicolon
| AUGMENTED_ASSIGNMENT_STMT + semicolon
| IF_STMT
| SWITCH_STMT
| WHILE_STMT
| DOWHILE_STMT + semicolon
| FOR_STMT
| FUNDEF
| PROCDEF
| BREAK_STMT + semicolon
| CONTINUE_STMT + semicolon
| RETURN_STMT + semicolon
| CURSOR_STMT + semicolon
| FOREACH_STMT
| OPEN_STMT + semicolon
| CLOSE_STMT + semicolon
| LOG_STMT + semicolon
| THROW_STMT + semicolon
| TRYCATCH_STMT;
//INSTRUCCION.ErrorRule = SyntaxError + semicolon;
TYPE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_ | map_ | list_ | set_;
TYPE_PRIMITIVE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_;
TYPE_COLLECTION.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_
| map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque
| list_ + menorque + TYPE_COLLECTION + mayorque
| set_ + menorque + TYPE_COLLECTION + mayorque;
IFNOTEXIST.Rule = if_ + not_ + exists_;
IFEXIST.Rule = if_ + exists_;
TYPEDEF.Rule = create_ + type_ + identifier + leftPar + ATTRIBUTE_LIST + rightPar
| create_ + type_ + IFNOTEXIST + identifier + leftPar + ATTRIBUTE_LIST + rightPar;
ATTRIBUTE_LIST.Rule = MakePlusRule(ATTRIBUTE_LIST, comma, ATTRIBUTE);
ATTRIBUTE.Rule = identifier + TYPE_COLLECTION;
USE.Rule = use_ + identifier;
DATABASEDEF.Rule = create_ + database_ + identifier
| create_ + database_ + IFNOTEXIST + identifier;
DROP.Rule = drop_ + database_ + identifier
| drop_ + database_ + IFNOTEXIST + identifier;
TABLEDEF.Rule = create_ + table_ + identifier + leftPar + COLUMN_LIST + rightPar
| create_ + table_ + IFNOTEXIST + identifier + leftPar + COLUMN_LIST + rightPar;
COLUMN_LIST.Rule = MakePlusRule(COLUMN_LIST, comma, COLUMN);
COLUMN.Rule = identifier + TYPE_COLLECTION
| identifier + TYPE_COLLECTION + primary_ + key_
| primary_ + key_ + leftPar + ID_LIST + rightPar;
ID_LIST.Rule = MakePlusRule(ID_LIST, comma, identifier);
TABLEALTER.Rule = alter_ + table_ + identifier + add_ + ATTRIBUTE_LIST
| alter_ + table_ + identifier + drop_ + ID_LIST;
TABLEDROP.Rule = drop_ + table_ + identifier
| drop_ + table_ + IFEXIST + identifier;
TABLETRUNCATE.Rule = truncate_ + table_ + identifier;
COMMIT.Rule = commit_;
ROLLBACK.Rule = rollback_;
USERDEF.Rule = create_ + user_ + identifier + with_ + password_ + stringliteral;
GRANT.Rule = grant_ + identifier + on_ + identifier;
REVOKE.Rule = revoke_ + identifier + on_ + identifier;
WHERE.Rule = where_ + EXPRESSION
| where_ + EXPRESSION + in_ + EXPRESSION_LIST
| where_ + EXPRESSION + in_ + leftPar + EXPRESSION_LIST + rightPar;
INSERT.Rule = insert_ + into_ + identifier + values_ + leftPar + EXPRESSION_LIST + rightPar
| insert_ + into_ + identifier + leftPar + ID_LIST + rightPar + values_ + leftPar + EXPRESSION_LIST + rightPar;
UPDATE.Rule = update_ + identifier + set_ + ASSIGNMENT_LIST
| update_ + identifier + set_ + ASSIGNMENT_LIST + WHERE;
DELETE.Rule = delete_ + from_ + identifier
| delete_ + from_ + identifier + WHERE
| delete_ + TARGET + from_ + identifier
| delete_ + TARGET + from_ + identifier + WHERE;
SELECT.Rule = select_ + SELECT_EXP + from_ + identifier
| select_ + SELECT_EXP + from_ + identifier + WHERE
| select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST
| select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST
| select_ + SELECT_EXP + from_ + identifier + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + WHERE + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION;
SELECT_EXP.Rule = EXPRESSION_LIST | por;
ORDER_LIST.Rule = MakePlusRule(ORDER_LIST, comma, ORDER);
ORDER.Rule = identifier
| identifier + asc_
| identifier + desc_; //TARGET*
BATCH.Rule = begin_ + batch_ + DML_LIST + apply_ + batch_;
DML_LIST.Rule = MakePlusRule(DML_LIST, DML);
DML.Rule = INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon;
////////////////////////////////////////////////////////////////
BLOQUE.Rule = leftLla + SENTENCIAS + rightLla
| leftLla + rightLla;
SENTENCIAS.Rule = MakePlusRule(SENTENCIAS, SENTENCIA);
SENTENCIA.Rule = TYPEDEF + semicolon /****/
| USE + semicolon
| DATABASEDEF + semicolon
| DROP + semicolon
| TABLEDEF + semicolon
| TABLEALTER + semicolon
| TABLEDROP + semicolon
| TABLETRUNCATE + semicolon
| COMMIT + semicolon
| ROLLBACK + semicolon
| USERDEF + semicolon
| GRANT + semicolon
| REVOKE + semicolon
| INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon
| SELECT + semicolon
| BATCH + semicolon
| EXPRESSION_STMT + semicolon
| DECLARATION_STMT + semicolon
| ASSIGNMENT_STMT + semicolon
| ASSIGNMENT_CALL + semicolon
| AUGMENTED_ASSIGNMENT_STMT + semicolon
| IF_STMT
| SWITCH_STMT
| WHILE_STMT
| DOWHILE_STMT + semicolon
| FOR_STMT
| BREAK_STMT + semicolon
| CONTINUE_STMT + semicolon
| RETURN_STMT + semicolon
| CURSOR_STMT + semicolon
| FOREACH_STMT
| OPEN_STMT + semicolon
| CLOSE_STMT + semicolon
| LOG_STMT + semicolon
| THROW_STMT + semicolon
| TRYCATCH_STMT;
TARGET_LIST.Rule = MakePlusRule(TARGET_LIST, comma, TARGET);
TARGET.Rule = identifier //*
| identifier2
| ATTRIBUTEREF //*
| ACCESS;
EXPRESSION_STMT.Rule = SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift | FUNCALL | CALL | ATTRIBUTEREF;
DECLARATION_STMT.Rule = TYPE + TARGET_LIST
| TYPE + TARGET_LIST + equal + EXPRESSION;
ASSIGNMENT_STMT.Rule = TARGET + equal + EXPRESSION
| TARGET + equal + CALL;
ASSIGNMENT_CALL.Rule = TARGET_LIST + equal + CALL;
ASSIGNMENT_LIST.Rule = MakePlusRule(ASSIGNMENT_LIST, comma, ASSIGNMENTS);
ASSIGNMENTS.Rule = ASSIGNMENT_STMT | AUGMENTED_ASSIGNMENT_STMT;
AUGMENTED_ASSIGNMENT_STMT.Rule = TARGET + AUG_OPERATOR + EXPRESSION;
//AUGTARGET.Rule = identifier | identifier2 | ATTRIBUTEREF; //*
AUG_OPERATOR.Rule = masEqual | menosEqual | porEqual | divisionEqual;
IF_STMT.Rule = IF_LIST + else_ + BLOQUE
| IF_LIST;
IF_LIST.Rule = IF_LIST + else_ + if_ + leftPar + EXPRESSION + rightPar + BLOQUE
| if_ + leftPar + EXPRESSION + rightPar + BLOQUE;
SWITCH_STMT.Rule = switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + rightLla
| switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + default_ + colon + BLOQUE + rightLla;
CASES.Rule = CASES + case_ + EXPRESSION + colon + BLOQUE
| case_ + EXPRESSION + colon + BLOQUE;
WHILE_STMT.Rule = while_ + leftPar + EXPRESSION + rightPar + BLOQUE;
DOWHILE_STMT.Rule = do_ + BLOQUE + while_ + leftPar + EXPRESSION + rightPar;
FOR_STMT.Rule = for_ + leftPar + FOR_INIT + semicolon + EXPRESSION + semicolon + FOR_UPDATE + rightPar + BLOQUE;
FOR_INIT.Rule = DECLARATION_STMT | ASSIGNMENT_STMT;
FOR_UPDATE.Rule = AUGMENTED_ASSIGNMENT_STMT | ASSIGNMENT_STMT | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift;
FUNDEF.Rule = TYPE + identifier + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| TYPE + identifier + leftPar + rightPar + BLOQUE;
PARAMETER_LIST.Rule = PARAMETER_LIST + comma + TYPE + identifier2
| TYPE + identifier2;
PROCDEF.Rule = procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| procedure_ + identifier + leftPar + rightPar + comma + leftPar + rightPar + BLOQUE
| procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + rightPar + BLOQUE
| procedure_ + identifier + leftPar + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE;
BREAK_STMT.Rule = break_;
CONTINUE_STMT.Rule = continue_;
RETURN_STMT.Rule = return_
| return_ + EXPRESSION_LIST;
CURSOR_STMT.Rule = cursor_ + identifier2 + is_ + SELECT;
FOREACH_STMT.Rule = for_ + each_ + leftPar + PARAMETER_LIST + rightPar + in_ + identifier2 + BLOQUE
| for_ + each_ + leftPar + rightPar + in_ + identifier2 + BLOQUE;
OPEN_STMT.Rule = open_ + identifier2;
CLOSE_STMT.Rule = close_ + identifier2;
LOG_STMT.Rule = log_ + leftPar + EXPRESSION + rightPar;
THROW_STMT.Rule = throw_ + new_ + identifier;
TRYCATCH_STMT.Rule = try_ + BLOQUE + catch_ + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| try_ + BLOQUE + catch_ + leftPar + rightPar + BLOQUE;;
EXPRESSION_LIST.Rule = MakePlusRule(EXPRESSION_LIST, comma, EXPRESSION);
EXPRESSION.Rule = CONDITIONAL_EXPRESSION | INSTANCE;
INSTANCE.Rule = new_ + identifier
| new_ + map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque
| new_ + list_ + menorque + TYPE_COLLECTION + mayorque
| new_ + set_ + menorque + TYPE_COLLECTION + mayorque;
CONDITIONAL_EXPRESSION.Rule = OR_EXPR | OR_EXPR + questionmark + EXPRESSION + colon + EXPRESSION;
OR_EXPR.Rule = AND_EXPR | OR_EXPR + or + AND_EXPR;
AND_EXPR.Rule = XOR_EXPR | AND_EXPR + and + XOR_EXPR;
XOR_EXPR.Rule = COMPARISON_EQ | XOR_EXPR + xor + COMPARISON_EQ;
COMPARISON_EQ.Rule = COMPARISON | COMPARISON_EQ + igual + COMPARISON
| COMPARISON_EQ + diferente + COMPARISON;
COMPARISON.Rule = A_EXPR | COMPARISON + COMP_OPERATOR + A_EXPR;
COMP_OPERATOR.Rule = menorque | mayorque | mayorigual | menorigual;
A_EXPR.Rule = M_EXPR | A_EXPR + mas + A_EXPR | A_EXPR + menos + M_EXPR;
M_EXPR.Rule = U_EXPR | M_EXPR + por + U_EXPR | M_EXPR + division + U_EXPR
| M_EXPR + modulo + U_EXPR;
U_EXPR.Rule = NOT_EXPR | POWER | menos + U_EXPR | mas + U_EXPR;
NOT_EXPR.Rule = not + U_EXPR;
POWER.Rule = SHIFT_EXPR | SHIFT_EXPR + potencia + U_EXPR;
SHIFT_EXPR.Rule = PRIMARY | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift;
PRIMARY.Rule = ATOM | ATTRIBUTEREF | AGGREGATION | FUNCALL | ACCESS;
ATOM.Rule = identifier | identifier2 | LITERAL | ENCLOSURE;
LITERAL.Rule = number | stringliteral | true_ | false_ | date | time | null_;
ATTRIBUTEREF.Rule = PRIMARY + dot + identifier
| PRIMARY + dot + FUNCALL;
AGGREGATION.Rule = AGGREGATION_FUN + leftPar + menormenor + SELECT + mayormayor + rightPar;
AGGREGATION_FUN.Rule = count_ | min_ | max_ | sum_ | avg_;
ENCLOSURE.Rule = PARENTH_FORM | MAP_DISPLAY | LIST_DISPLAY | SET_DISPLAY;
PARENTH_FORM.Rule = leftPar + EXPRESSION + rightPar
| leftPar + TYPE + rightPar + EXPRESSION;
MAP_DISPLAY.Rule = leftCor + MAP_LIST + rightCor;
MAP_LIST.Rule = MAP_LIST + comma + EXPRESSION + colon + EXPRESSION
| EXPRESSION + colon + EXPRESSION;
LIST_DISPLAY.Rule = leftCor + EXPRESSION_LIST + rightCor;
SET_DISPLAY.Rule = leftLla + EXPRESSION_LIST + rightLla
| leftLla + EXPRESSION_LIST + rightLla + as_ + identifier;
FUNCALL.Rule = identifier + leftPar + rightPar
| identifier + leftPar + EXPRESSION_LIST + rightPar;
CALL.Rule = call_ + identifier + leftPar + rightPar
| call_ + identifier + leftPar + EXPRESSION_LIST + rightPar;
ACCESS.Rule = PRIMARY + leftCor + EXPRESSION + rightCor;
}
public NTerminal(string key)
{
this.keyTerm = new NonTerminal(key);
this.term = PowerPCGrammar.CurrentGrammar.ToTerm(key);
termList.Add(this);
}
