public E2Grammar()
{
LineTerminators = "\r\n";
var program = new NonTerminal("Program");
var directiveList = new NonTerminal("DirectiveList");
var directive = new NonTerminal("Directive");
var directiveName = new IdentifierTerminal("DirectiveName");
var directiveBody = new NonTerminal("DirectiveBody");
var statementList = new NonTerminal("StatementList");
var statement = new NonTerminal("Statement");
var assignment = new NonTerminal("Assignment");
var expression = new NonTerminal("Expression");
var parenExpression = new NonTerminal("ParenExpression");
var methodCall = new NonTerminal("MethodCall");
var argumentList = new NonTerminal("ArgumentList");
var argumentTail = new NonTerminal("ArgumentTail");
var @operator = new NonTerminal("Operator");
var operation = new NonTerminal("Operation");
var identifier = new IdentifierTerminal("Identifier");
var @string = new StringLiteral("String", "\"");
var number = new NumberLiteral("Number");
var ifStatement = new NonTerminal("IfStatement");
var whileStatement = new NonTerminal("WhileStatement");
var comment = new CommentTerminal("comment", "#", new[] {"\n"});
var dcom = new CommentTerminal("commentCheat", "@", new[] {"\n"});
Root = program;
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(dcom);
RegisterBracePair("{", "}");
program.Rule = /* directiveList + */statementList;
//directiveList.Rule = MakePlusRule(directiveList, null, directive);
//directiveBody.Rule = new CommentTerminal()
//directive.Rule = ToTerm("@") + directiveName + directiveBody;
statementList.Rule = MakePlusRule(statementList, null, statement);
statement.Rule = methodCall | assignment;
expression.Rule = operation | @string | number | methodCall | identifier;
parenExpression.Rule = ToTerm("(") + expression + ")";
methodCall.Rule = expression + ":" + identifier + "(" + argumentList + ")";
argumentList.Rule = MakeStarRule(argumentList, ToTerm(","), expression);
operation.Rule = expression + @operator + expression;
@operator.Rule = ToTerm("+") | "-" | "*" | "/" | "&" | "|";
assignment.Rule = identifier + "=" + expression;
ifStatement.Rule = ToTerm("if") + parenExpression + "{" + statementList + "}";
whileStatement.Rule = ToTerm("while") + parenExpression + "{" + statementList + "}";
}
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;
}
public KISGrammer()
{
var number = new NumberLiteral("number");
var text = new StringLiteral("string", "\"");
number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var identifier = new IdentifierTerminal("identifier");
var comment = new CommentTerminal("comment", "#", "\n", "\r");
base.NonGrammarTerminals.Add(comment);
var Code = new NonTerminal("code");
var Statments = new NonTerminal("statments");
var Value = new NonTerminal("value");
var ValueString = TerminalFactory.CreateCSharpString("valuestring");
var SetStmt = new NonTerminal("setstmt");
var CallStmt = new NonTerminal("callstmt");
var FnStmt = new NonTerminal("fnstmt");
var CallPath = new NonTerminal("callpath");
var CallPerams = new NonTerminal("callperams");
var fullstop = new NonTerminal("fullstop");
var comma = new NonTerminal("comma");
var openb = new NonTerminal("openb");
var closeb = new NonTerminal("closeb");
openb.Rule = "{";
closeb.Rule = "}";
fullstop.Rule = ".";
comma.Rule = ",";
CallPath.Rule = MakePlusRule(CallPath, fullstop, identifier);
CallPerams.Rule = MakePlusRule(CallPerams, comma, Value);
var Semicolon = ToTerm(";");
//StateMents:
SetStmt.Rule = identifier + "=" + Value + Semicolon;
CallStmt.Rule = (CallPath | identifier) + "(" + (CallPerams | Empty) + ")" + Semicolon;
FnStmt.Rule = "function" + identifier + "(" + (CallPerams | Empty) + ")";
Statments.Rule = SetStmt | CallStmt | FnStmt | openb | closeb | Empty;
var Exspr = new NonTerminal("exspr");
var Operator = new NonTerminal("operator");
var ExsprStmt = new NonTerminal("exsprstmt");
Operator.Rule = ToTerm("/") | "*" | "-" | "+";
ExsprStmt.Rule = Value + Operator + Value;
Exspr.Rule = MakePlusRule(Exspr, Operator, ExsprStmt);
Value.Rule = number | ValueString | identifier | "true" | "false" | Exspr /* | text */;
Code.Rule = MakePlusRule(Code, NewLine, Statments);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
//code := Statment {statment}
this.Root = Code;
}
public IntegrationTestGrammar() {
var comment = new CommentTerminal("comment", "/*", "*/");
base.NonGrammarTerminals.Add(comment);
var str = new StringLiteral("str", "'", StringOptions.AllowsLineBreak);
var stmt = new NonTerminal("stmt");
stmt.Rule = str | Empty;
this.Root = stmt;
}
private readonly TerminalSet mSkipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution
#endregion Fields
#region Constructors
public JavaGrammar()
{
GrammarComments = "NOTE: This grammar does not parse hex floating point literals.";
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":", "@");
InitializeSyntax();
}
public LinearProgrammingGrammar()
{
var comment = new CommentTerminal("comment", "#", "\n", "\r");
NonGrammarTerminals.Add(comment);
var identifier = new IdentifierTerminal("appIdentifier");
var variable = new IdentifierTerminal("variable");
var number = new NumberLiteral("number", NumberOptions.AllowSign);
var lpProgram = new NonTerminal("lpApp");
var lpAppName = new NonTerminal("lpAppName");
var lpModel = new NonTerminal("lpModel");
var lpGoal = new NonTerminal("lpGoal");
var lpPolynomial = new NonTerminal("lpPolynomial");
var lpConstraints = new NonTerminal("lpConstraints");
var lpConstraint = new NonTerminal("lpConstraints");
var lpOperator = new NonTerminal("lpOperator", "lp Operation symbol");
var lpBinOp = new NonTerminal("lpBinOp", "lp Binary Operation symbol");
var lpMonomial = new NonTerminal("Monomial");
var lpNumber = new NonTerminal("lpNumber");
lpProgram.Rule = lpAppName + "{" + lpModel + "}" + ";";
lpAppName.Rule = ToTerm("lpmodel") + identifier;
lpModel.Rule = lpGoal + ToTerm("subject to") +":" + lpConstraints;
lpGoal.Rule = ToTerm("max") + lpPolynomial | ToTerm("min") + lpPolynomial;
lpConstraints.Rule = MakePlusRule(lpConstraints, null, lpConstraint);
//ReduceHere();
lpConstraint.Rule = lpPolynomial + lpOperator + lpPolynomial + ";";
lpOperator.Rule = ToTerm("<") | "==" | ">" | "<=" | ">=";
lpPolynomial.Rule = lpMonomial | lpMonomial + lpBinOp + lpPolynomial | lpNumber |
lpNumber + lpBinOp + lpPolynomial;
lpMonomial.Rule = variable | lpNumber + ToTerm("*") + variable;
lpBinOp.Rule = ToTerm("+") | "-";
lpNumber.Rule = number | lpBinOp + number;
MarkReservedWords("max", "min", "lpmodel", "subject to");
// ReduceIf("");
Root = lpProgram;
}
public NumericalSchemeGrammar()
{
this.GrammarComments = "";
//Symbols
var whitespace = new NonTerminal("WhiteSpace", Empty | " " | "\t");
// Comments
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var multiLineComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(multiLineComment);
//Terminals
var semicolon = ToTerm(";", "Semicolon");
var ofString = new StringLiteral("String", "\"");
var ofNumber = new NumberLiteral("Number", NumberOptions.AllowSign);
var ofIdentifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
var ofArrayTerm = new IdentifierTerminal("SchemeTerm", "(),|*.+-/%^~!&");
//Non-terminals
var ofValue = new NonTerminal("Value");
var ofDictionary = new NonTerminal("Dictionary");
var ofDictionaryContent = new NonTerminal("DictionaryContent");
var ofDictionaryContentWrapper = new NonTerminal("DictionaryContentWrapper");
var ofDictEntry = new NonTerminal("DictEntry");
var ofArrayEntry = new NonTerminal("ArrayEntry");
var ofArray = new NonTerminal("Array");
var ofArrayWrapper = new NonTerminal("ArrayWrapper");
//BNF
ofValue.Rule = ofIdentifier | ofArrayTerm | ofString | ofNumber;
ofDictEntry.Rule = ofArrayWrapper | ofDictionary;
ofDictionaryContent.Rule = MakeStarRule(ofDictionaryContent, whitespace, ofDictEntry);
ofDictionaryContentWrapper.Rule = "{" + ofDictionaryContent + "}";
ofDictionary.Rule = ofIdentifier + whitespace + ofDictionaryContentWrapper;
ofArrayEntry.Rule = ofValue;
ofArray.Rule = MakeStarRule(ofArray, whitespace, ofArrayEntry);
ofArrayWrapper.Rule = ofArray + semicolon;
//Set grammar root
this.Root = ofDictionaryContent;
MarkPunctuation("{", "}");
MarkTransient(ofValue, ofDictionaryContentWrapper);
}
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;
}
/// <summary>
/// 使うな
/// </summary>
public Kbtter3QueryGrammar()
: base()
{
//コメント
var comment = new CommentTerminal("Comment", "/*", "*/");
NonGrammarTerminals.Add(comment);
//リテラル
var number = new NumberLiteral("Number", NumberOptions.AllowSign | NumberOptions.AllowStartEndDot);
var str = new StringLiteral("String", "\"");
var regex = new RegexLiteral("Regex", '/', '\\');
var ident = new IdentifierTerminal("Identifer");
//非終端
var Value = new NonTerminal("Value");
var Term = new NonTerminal("Term");
var Expression = new NonTerminal("Expression");
var BinExpression = new NonTerminal("BinExpression");
var ParExpression = new NonTerminal("ParExpression");
var PostfixExpression = new NonTerminal("PostfixExpression");
var Operator = new NonTerminal("Operator");
//非終端定義
Value.Rule = number | str | ident | regex | "null" | "true" | "false";
Term.Rule = Value | ParExpression;
Operator.Rule = ToTerm("==") | "!=" | ">" | "<" | ">=" | "<=" | "match" | "&&" | "||" | "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | ".";
BinExpression.Rule = Expression + Operator + Expression;
PostfixExpression.Rule = (ToTerm("+") + Term) | ("-" + Term) | ("!" + Term);
Expression.Rule = BinExpression | Term | PostfixExpression;
ParExpression.Rule = ToTerm("(") + Expression + ")";
RegisterOperators(10, ".");
RegisterOperators(9, "*", "/", "%");
RegisterOperators(8, "+", "-");
RegisterOperators(7, ">", "<", ">=", "<=", "match");
RegisterOperators(6, "==", "!=");
RegisterOperators(5, "&");
RegisterOperators(4, "^");
RegisterOperators(3, "|");
RegisterOperators(2, "&&");
RegisterOperators(1, "||");
Root = Expression;
MarkPunctuation("(", ")");
MarkTransient(Expression, ParExpression, Value, Operator, Term);
}
/// <summary>
/// 新しいインスタンスを以下略
/// </summary>
public Kb10uyConfigGrammar()
: base()
{
var Number = new NumberLiteral("Number");
var String = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var CommentLine = new CommentTerminal("Comment", "#", "\n", "\r");
var CommentBlock = new CommentTerminal("Comment", "#<", ">");
//数値設定
Number.DefaultIntTypes = new[] { TypeCode.Int32 };
Number.DefaultFloatType = TypeCode.Double;
String.EscapeChar = '\\';
NonGrammarTerminals.Add(CommentBlock);
NonGrammarTerminals.Add(CommentLine);
var Value = new NonTerminal("Value");
var Values = new NonTerminal("Value\'s\'");
var ValueSet = new NonTerminal("Array");
var Property = new NonTerminal("Property");
var Prefix = new NonTerminal("Prefix");
var Node = new NonTerminal("Node");
var Nodes = new NonTerminal("Nodes");
//var PropertySet = new NonTerminal("PropertySet");
var Group = new NonTerminal("Group");
var ConfigRoot = new NonTerminal("Root");
Value.Rule = Number | String | ValueSet;
Values.Rule = MakeStarRule(Values, ToTerm(","), Value);
ValueSet.Rule = ToTerm("[") + Values + "]";
Prefix.Rule = ToTerm("Number") | "String" | "Array" ;
Property.Rule = Prefix + ":" + String + "=" + Value + ";";
Node.Rule = Property | Group;
Nodes.Rule = MakeStarRule(Nodes, Node);
Group.Rule = String + ":" + "{" +Nodes+ "}";
ConfigRoot.Rule = MakeStarRule(ConfigRoot, Group);
Root = ConfigRoot;
MarkPunctuation("[", "]", ",", "{", "}",":",";","=");
}
// It is loosely based on R6RS specs.
// See Grammar Errors tab in GrammarExplorer for remaining conflicts.
public SchemeGrammar() {
#region Terminals
ConstantTerminal Constant = new ConstantTerminal("Constant");
Constant.Add("#T", 1);
Constant.Add("#t", 1);
Constant.Add("#F", null);
Constant.Add("#f", null);
Constant.Add("'()", null);
Constant.Add(@"#\nul", '\u0000');
Constant.Add(@"#\alarm", '\u0007');
Constant.Add(@"#\backspace", '\b');
Constant.Add(@"#\tab", '\t');
Constant.Add(@"#\linefeed", '\n');
Constant.Add(@"#\vtab", '\v');
Constant.Add(@"#\page", '\f');
Constant.Add(@"#\return", '\r');
Constant.Add(@"#\esc", '\u001B');
Constant.Add(@"#\space", ' ');
Constant.Add(@"#\delete", '\u007F');
// TODO: build SchemeCharLiteral
// the following is nonsense, just to put something there
var charLiteral = new StringLiteral("Char", "'", StringOptions.None);
var stringLiteral = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
//Identifiers. Note: added "-", just to allow IDs starting with "->"
var SimpleIdentifier = new IdentifierTerminal("SimpleIdentifier", "_+-*/.@?!<>=", "_+-*/.@?!<>=$%&:^~");
// name extraChars extraFirstChars
var Number = TerminalFactory.CreateSchemeNumber("Number");
var Byte = new NumberLiteral("Byte", NumberOptions.IntOnly);
//Comments
Terminal Comment = new CommentTerminal("Comment", "#|", "|#");
Terminal LineComment = new CommentTerminal("LineComment", ";", "\n");
NonGrammarTerminals.Add(Comment); //add comments explicitly to this list as it is not reachable from Root
NonGrammarTerminals.Add(LineComment);
#endregion
#region NonTerminals
var Module = new NonTerminal("Module");
var Library = new NonTerminal("Library");
var LibraryList = new NonTerminal("Library+");
var Script = new NonTerminal("Script");
var Abbreviation = new NonTerminal("Abbreviation");
var Vector = new NonTerminal("Vector");
var ByteList = new NonTerminal("ByteList");
var ByteVector = new NonTerminal("ByteVector");
var Datum = new NonTerminal("Datum"); //Datum in R6RS terms
var DatumOpt = new NonTerminal("DatumOpt"); //Datum in R6RS terms
var DatumList = new NonTerminal("Datum+");
var DatumListOpt = new NonTerminal("Datum*");
var Statement = new NonTerminal("Statement");
var Atom = new NonTerminal("Atom");
var CompoundDatum = new NonTerminal("CompoundDatum");
var AbbrevPrefix = new NonTerminal("AbbrevPrefix");
var LibraryName = new NonTerminal("LibraryName");
var LibraryBody = new NonTerminal("LibraryBody");
var ImportSection = new NonTerminal("ImportSection");
var ExportSection = new NonTerminal("ExportSection");
var ImportSpec = new NonTerminal("ImportSpec");
var ImportSpecList = new NonTerminal("ImportSpecList");
var ExportSpec = new NonTerminal("ExportSpec");
var ExportSpecList = new NonTerminal("ExportSpecList");
var LP = new NonTerminal("LP"); //"(" or "["
var RP = new NonTerminal("RP"); // ")" or "]"
var Identifier = new NonTerminal("Identifier");
var IdentifierList = new NonTerminal("IdentifierList");
var IdentifierListOpt = new NonTerminal("IdentifierListOpt");
var PeculiarIdentifier = new NonTerminal("PeculiarIdentifier");
var LibraryVersion = new NonTerminal("LibraryVersion");
var VersionListOpt = new NonTerminal("VersionListOpt");
var FunctionCall = new NonTerminal("FunctionCall");
var FunctionRef = new NonTerminal("FunctionRef");
var SpecialForm = new NonTerminal("SpecialForm");
var DefineVarForm = new NonTerminal("DefineVarForm");
var DefineFunForm = new NonTerminal("DefineFunForm");
var LambdaForm = new NonTerminal("LambdaForm");
var IfForm = new NonTerminal("IfForm");
var CondForm = new NonTerminal("CondForm");
var CondClause = new NonTerminal("CondClause");
var CondClauseList = new NonTerminal("CondClauseList");
var CondElseOpt = new NonTerminal("CondElseOpt");
var BeginForm = new NonTerminal("BeginForm");
var LetForm = new NonTerminal("LetForm"); //not implemented
var LetRecForm = new NonTerminal("LetRecForm"); //not implemented
var LetPair = new NonTerminal("LetPair");
var LetPairList = new NonTerminal("LetPairList");
#endregion
#region Rules
base.Root = Module;
LP.Rule = ToTerm("(") | "["; //R6RS allows mix & match () and []
RP.Rule = ToTerm(")") | "]";
// Module.Rule = LibraryListOpt + Script; -- this brings conflicts
Module.Rule = LibraryList + Script | Script;
LibraryList.Rule = MakePlusRule(LibraryList, Library);
Script.Rule = ImportSection + DatumList | DatumList;
//Library
// the following doesn't work - brings conflicts that incorrectly resolved by default shifting
//Library.Rule = LP + "library" + LibraryName + ExportSectionOpt + ImportSectionOpt + DatumListOpt + RP;
Library.Rule = LP + "library" + LibraryName + LibraryBody + RP;
//Note - we should be using DatumListOpt, but that brings 2 conflicts, so for now it is just DatumList
//Note that the following style of BNF expressions is strongly discouraged - all productions should be of the same length,
// so that the process of mapping child nodes to parent's properties is straightforward.
LibraryBody.Rule = ExportSection + ImportSection + DatumList
| ExportSection + DatumList
| ImportSection + DatumList
| DatumList;
LibraryName.Rule = LP + IdentifierList + LibraryVersion.Q() + RP;
LibraryVersion.Rule = LP + VersionListOpt + RP; //zero or more subversion numbers
VersionListOpt.Rule = MakeStarRule(VersionListOpt, Number);
ExportSection.Rule = LP + "export" + ExportSpecList + RP;
ImportSection.Rule = LP + "import" + ImportSpecList + RP;
ExportSpecList.Rule = MakePlusRule(ExportSpecList, ExportSpec);
ImportSpecList.Rule = MakePlusRule(ImportSpecList, ImportSpec);
ExportSpec.Rule = Identifier | LP + "rename" + LP + Identifier + Identifier + RP + RP;
ImportSpec.Rule = LP + Identifier + RP; // - much more complex in R6RS
//Datum
Datum.Rule = Atom | CompoundDatum;
DatumOpt.Rule = Empty | Datum;
DatumList.Rule = MakePlusRule(DatumList, Datum);
DatumListOpt.Rule = MakeStarRule(DatumListOpt, Datum);
Atom.Rule = Number | Identifier | stringLiteral | Constant | charLiteral | ".";
CompoundDatum.Rule = Statement | Abbreviation | Vector | ByteVector;
Identifier.Rule = SimpleIdentifier | PeculiarIdentifier;
IdentifierList.Rule = MakePlusRule(IdentifierList, Identifier);
IdentifierListOpt.Rule = MakeStarRule(IdentifierListOpt, Identifier);
//TODO: create PeculiarIdentifier custom terminal instead of var
// or just custom SchemeIdentifier terminal
PeculiarIdentifier.Rule = ToTerm("+") | "-" | "..."; // |"->" + subsequent; (should be!)
Abbreviation.Rule = AbbrevPrefix + Datum;
AbbrevPrefix.Rule = ToTerm("'") | "`" | ",@" | "," | "#'" | "#`" | "#,@" | "#,";
Vector.Rule = "#(" + DatumListOpt + ")";
ByteVector.Rule = "#vu8(" + ByteList + ")";
ByteList.Rule = MakeStarRule(ByteList, Byte);
Statement.Rule = FunctionCall | SpecialForm;
FunctionCall.Rule = LP + FunctionRef + DatumListOpt + RP;
FunctionRef.Rule = Identifier | Statement;
SpecialForm.Rule = DefineVarForm | DefineFunForm | LambdaForm | IfForm | CondForm | BeginForm | LetForm | LetRecForm;
DefineVarForm.Rule = LP + "define" + Identifier + Datum + RP;
DefineFunForm.Rule = LP + "define" + LP + Identifier + IdentifierListOpt + RP + DatumList + RP;
LambdaForm.Rule = LP + "lambda" + LP + IdentifierListOpt + RP + DatumList + RP;
IfForm.Rule = LP + "if" + Datum + Datum + DatumOpt + RP;
CondForm.Rule = LP + "cond" + CondClauseList + CondElseOpt + RP;
CondClauseList.Rule = MakePlusRule(CondClauseList, CondClause);
CondClause.Rule = LP + Datum + DatumList + RP;
CondElseOpt.Rule = Empty | LP + "else" + DatumList + RP;
LetForm.Rule = LP + "let" + LP + LetPairList + RP + DatumList + RP;
LetRecForm.Rule = LP + "letrec" + LP + LetPairList + RP + DatumList + RP;
BeginForm.Rule = LP + "begin" + DatumList + RP;
LetPairList.Rule = MakePlusRule(LetPairList, LetPair);
LetPair.Rule = LP + Identifier + Datum + RP;
#endregion
//Register brace pairs
RegisterBracePair("(", ")");
RegisterBracePair("[", "]");
MarkPunctuation(LP, RP);
MarkTransient(Datum, CompoundDatum, Statement, SpecialForm, Atom);
//Scheme is tail-recursive language
base.LanguageFlags |= LanguageFlags.TailRecursive;
}//constructor
// BASIC is not case sensitive...
public GWBasicGrammar()
: base(false)
{
this.GrammarComments = "This grammar uses one new Irony feature - Scanner-Parser link. Parser helps Scanner to disambiguate " +
"similar but different token types when more than one terminal matches the current input char.\r\n" +
"See comments in GwBasicGrammar.cs file.";
/*
Scanner-Parser link.
The grammar defines 3 terminals for numbers: number, lineNumber and fileNumber. All three return decimal
digits in GetFirsts() method. So when current input is a digit, the scanner has 3 potential candidate terminals
to match the input. However, because each of the 3 terminals can appear in specific "places" in grammar,
the parser is able to assist scanner to pick the correct terminal, depending on the current parser state.
The disambiguation happens in Scanner.SelectTerminals method. When the terminal list for current input char
has more than 1 terminal, the scanner code gets the current parser state from core parser (through compilerContext),
and then checks the terminals agains the ExpectedTerms set in the parser state.
As you might see in Grammar Explorer, the conflict is resolved successfully.
*/
//Terminals
var lineNumber = new NumberLiteral("LINE_NUMBER", NumberOptions.IntOnly);
var fileNumber = new NumberLiteral("FILE_NUMBER", NumberOptions.IntOnly);
var number = new NumberLiteral("NUMBER", NumberOptions.AllowStartEndDot);
//ints that are too long for int32 are converted to int64
number.DefaultIntTypes = new TypeCode[] {TypeCode.Int32, TypeCode.Int64};
number.AddExponentSymbols("eE", TypeCode.Single);
number.AddExponentSymbols("dD", TypeCode.Double);
number.AddSuffix("!", TypeCode.Single);
number.AddSuffix("#", TypeCode.Double);
var variable = new IdentifierTerminal("Identifier");
variable.AddSuffix("$", TypeCode.String);
variable.AddSuffix("%", TypeCode.Int32);
variable.AddSuffix("!", TypeCode.Single);
variable.AddSuffix("#", TypeCode.Double);
var stringLiteral = new StringLiteral("STRING", "\"", StringOptions.None);
//Important: do not add comment term to base.NonGrammarTerminals list - we do use this terminal in grammar rules
var userFunctionName = variable;
var comment = new CommentTerminal("Comment", "REM", "\n");
var short_comment = new CommentTerminal("ShortComment", "'", "\n");
var line_cont = new LineContinuationTerminal("LineContinuation", "_");
var comma = ToTerm(",", "comma");
var colon = ToTerm(":", "colon");
var comma_opt = new NonTerminal("comma_opt");
comma_opt.Rule = Empty | ",";
var semi_opt = new NonTerminal("semi_opt");
semi_opt.Rule = Empty | ";";
var pound_opt = new NonTerminal("pound_opt");
pound_opt.Rule = Empty | "#";
// Non-terminals
var PROGRAM = new NonTerminal("PROGRAM");
var LINE = new NonTerminal("LINE");
var LINE_CONTENT_OPT = new NonTerminal("LINE_CONTENT_OPT");
var COMMENT_OPT = new NonTerminal("COMMENT_OPT");
var STATEMENT_LIST = new NonTerminal("STATEMENT_LIST");
var STATEMENT = new NonTerminal("STATEMENT");
var PRINT_STMT = new NonTerminal("PRINT_STMT");
var PRINT_LIST = new NonTerminal("PRINT_LIST");
var PRINT_ARG = new NonTerminal("PRINT_ARG");
var OPEN_STMT = new NonTerminal("OPEN_STMT");
var OPEN_STMT_MODE = new NonTerminal("OPEN_STMT_MODE");
var OPEN_STMT_ACCESS = new NonTerminal("OPEN_STMT_ACCESS");
var CLOSE_STMT = new NonTerminal("CLOSE_STMT");
var INPUT_STMT = new NonTerminal("INPUT_STMT");
var VARIABLES = new NonTerminal("VARIABLES");
var IF_STMT = new NonTerminal("IF_STMT");
var THEN_CLAUSE = new NonTerminal("THEN_CLAUSE");
var ELSE_CLAUSE_OPT = new NonTerminal("ELSE_CLAUSE_OPT"); //, typeof(AstNode));
var EXPR = new NonTerminal("EXPRESSION");
var EXPR_LIST = new NonTerminal("EXPRESSION_LIST");
var BINARY_OP = new NonTerminal("BINARY_OP", "operator");
var BINARY_EXPR = new NonTerminal("BINARY_EXPR");
var UNARY_EXPR = new NonTerminal("UNARY_EXPR");
var SIGN = new NonTerminal("SIGN");
var ASSIGN_STMT = new NonTerminal("ASSIGN_STMT");
var FOR_STMT = new NonTerminal("FOR_STMT");
var STEP_OPT = new NonTerminal("STEP_OPT");
var NEXT_STMT = new NonTerminal("NEXT_STMT");
var LOCATE_STMT = new NonTerminal("LOCATE_STMT");
var WHILE_STMT = new NonTerminal("WHILE_STMT");
var WEND_STMT = new NonTerminal("WEND_STMT");
var SWAP_STMT = new NonTerminal("SWAP_STMT");
var FUN_CALL = new NonTerminal("FUN_CALL");
var VARIABLE_OR_FUNCTION_EXPR = new NonTerminal("VARIABLE_OR_FUNCTION_EXPR");
var ARG_LIST = new NonTerminal("ARG_LIST");
var LINE_INPUT_STMT = new NonTerminal("LINE_INPUT_STMT");
var LINE_INPUT_POUND_STMT = new NonTerminal("LINE_INPUT_POUND_STMT");
var END_STMT = new NonTerminal("END_STMT");
var CLS_STMT = new NonTerminal("CLS_STMT");
var CLEAR_STMT = new NonTerminal("CLEAR_STMT");
var DIM_STMT = new NonTerminal("DIM_STMT");
var DEF_FN_STMT = new NonTerminal("DEF_FN_STMT");
var GOTO_STMT = new NonTerminal("GOTO_STMT");
var GOSUB_STMT = new NonTerminal("GOSUB_STMT");
var RETURN_STMT = new NonTerminal("RETURN_STMT");
var ON_STMT = new NonTerminal("ON_STMT");
var LINE_NUMBERS = new NonTerminal("LINE_NUMBERS");
var RANDOMIZE_STMT = new NonTerminal("RANDOMIZE_STMT");
// set the PROGRAM to be the root node of BASIC programs.
this.Root = PROGRAM;
// BNF Rules
PROGRAM.Rule = MakePlusRule(PROGRAM, LINE);
// A line can be an empty line, or it's a number followed by a statement list ended by a new-line.
LINE.Rule = NewLine | lineNumber + LINE_CONTENT_OPT + COMMENT_OPT + NewLine | SyntaxError + NewLine;
LINE.NodeCaptionTemplate = "Line #{0}";
// A statement list is 1 or more statements separated by the ':' character
LINE_CONTENT_OPT.Rule = Empty | IF_STMT | STATEMENT_LIST;
STATEMENT_LIST.Rule = MakePlusRule(STATEMENT_LIST, colon, STATEMENT);
COMMENT_OPT.Rule = short_comment | comment | Empty;
// A statement can be one of a number of types
STATEMENT.Rule = ASSIGN_STMT | PRINT_STMT | INPUT_STMT | OPEN_STMT | CLOSE_STMT
| LINE_INPUT_POUND_STMT | LINE_INPUT_STMT
| LOCATE_STMT | CLS_STMT
| END_STMT | CLEAR_STMT | DIM_STMT | DEF_FN_STMT
| SWAP_STMT | RANDOMIZE_STMT
| GOSUB_STMT | RETURN_STMT | GOTO_STMT | ON_STMT
| FOR_STMT | NEXT_STMT | WHILE_STMT | WEND_STMT;
// The different statements are defined here
PRINT_STMT.Rule = "print" + PRINT_LIST;
PRINT_LIST.Rule = MakeStarRule(PRINT_LIST, null, PRINT_ARG);
PRINT_ARG.Rule = EXPR + semi_opt;
INPUT_STMT.Rule = "input" + semi_opt + stringLiteral + ";" + VARIABLES;
OPEN_STMT.Rule = "open" + EXPR + (Empty | "for" + OPEN_STMT_MODE) +
(Empty | "access" + OPEN_STMT_ACCESS) + "as" + pound_opt + fileNumber;
OPEN_STMT_ACCESS.Rule = "read" + (Empty | "write") | "write";
OPEN_STMT_MODE.Rule = ToTerm("o") | "i" | "a" | "output" | "input" | "append";
CLOSE_STMT.Rule = "close" + pound_opt + fileNumber;
LINE_INPUT_STMT.Rule = ToTerm("line") + "input" + semi_opt + stringLiteral + ";" + VARIABLE_OR_FUNCTION_EXPR;
LINE_INPUT_POUND_STMT.Rule = ToTerm("line") + "input" + ToTerm("#") + fileNumber + comma + VARIABLE_OR_FUNCTION_EXPR;
DIM_STMT.Rule = "dim" + VARIABLES;
DEF_FN_STMT.Rule = "def" + userFunctionName + (Empty | "(" + ARG_LIST + ")") + "=" + EXPR;
VARIABLES.Rule = VARIABLE_OR_FUNCTION_EXPR | VARIABLE_OR_FUNCTION_EXPR + "," + VARIABLES;
IF_STMT.Rule = "if" + EXPR + THEN_CLAUSE + ELSE_CLAUSE_OPT;
THEN_CLAUSE.Rule = "then" + STATEMENT_LIST | GOTO_STMT;
//Inject PreferShift hint here to explicitly set shift as preferred action. Suppresses warning message about conflict.
ELSE_CLAUSE_OPT.Rule = Empty | PreferShiftHere() + "else" + STATEMENT_LIST;
GOTO_STMT.Rule = "goto" + lineNumber;
GOSUB_STMT.Rule = "gosub" + lineNumber;
RETURN_STMT.Rule = "return";
ON_STMT.Rule = "on" + EXPR + (ToTerm("goto") | "gosub") + LINE_NUMBERS;
LINE_NUMBERS.Rule = MakePlusRule(LINE_NUMBERS, comma, lineNumber);
ASSIGN_STMT.Rule = VARIABLE_OR_FUNCTION_EXPR + "=" + EXPR;
LOCATE_STMT.Rule = "locate" + EXPR + comma + EXPR;
SWAP_STMT.Rule = "swap" + EXPR + comma + EXPR;
END_STMT.Rule = "end";
CLS_STMT.Rule = "cls";
CLEAR_STMT.Rule = ToTerm("clear") + comma + (Empty | number) + (Empty | comma + number) | "clear" + number | "clear";
RANDOMIZE_STMT.Rule = "randomize" + EXPR;
// An expression is a number, or a variable, a string, or the result of a binary comparison.
EXPR.Rule = number | variable | FUN_CALL | stringLiteral | BINARY_EXPR
| "(" + EXPR + ")" | UNARY_EXPR;
BINARY_EXPR.Rule = EXPR + BINARY_OP + EXPR;
UNARY_EXPR.Rule = SIGN + EXPR;
SIGN.Rule = ToTerm("-") | "+";
//Inject PreferShift hint here to explicitly set shift as preferred action. Suppresses warning message about conflict.
//The conflict arises from PRINT statement, when there may be ambigous interpretations for expression like
// PRINT F (X) -- either function call or identifier followed by expression
FUN_CALL.Rule = variable + PreferShiftHere() + "(" + ARG_LIST + ")";
VARIABLE_OR_FUNCTION_EXPR.Rule = variable | FUN_CALL;
BINARY_OP.Rule = ToTerm("+") | "^" | "-" | "*" | "/" | "=" | "<=" | ">=" | "<" | ">" | "<>" | "and" | "or";
//let's do operator precedence right here
RegisterOperators(60, "^");
RegisterOperators(50, "*", "/");
RegisterOperators(40, "+", "-");
RegisterOperators(30, "=", "<=", ">=", "<", ">", "<>");
RegisterOperators(20, "and", "or");
EXPR_LIST.Rule = MakeStarRule(EXPR_LIST, EXPR);
FOR_STMT.Rule = "for" + ASSIGN_STMT + "to" + EXPR + STEP_OPT;
STEP_OPT.Rule = Empty | "step" + EXPR;
NEXT_STMT.Rule = "next" + VARIABLES | "next";
WHILE_STMT.Rule = "while" + EXPR;
WEND_STMT.Rule = "wend";
//TODO: check number of arguments for particular function in node constructor
ARG_LIST.Rule = MakePlusRule(ARG_LIST, comma, EXPR);
//Punctuation and Transient elements
MarkPunctuation("(", ")", ",");
MarkTransient(EXPR, STATEMENT, LINE_CONTENT_OPT, VARIABLE_OR_FUNCTION_EXPR, COMMENT_OPT);
NonGrammarTerminals.Add(line_cont);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
lineNumber.ValidateToken += lineNumber_ValidateToken;
}
public KinectitudeGrammar()
{
Number.DefaultFloatType = TypeCode.Double;
Number.DefaultIntTypes = new TypeCode [] { TypeCode.Int64 };
CommentTerminal lineComment = new CommentTerminal("Line Comment", "//", "\r\n", "\n");
CommentTerminal blockComment = new CommentTerminal("Block Comment", "/*", "*/");
NonGrammarTerminals.Add(lineComment);
NonGrammarTerminals.Add(blockComment);
#region constants
Constants.Add("true", ConstantReader.TrueValue);
Constants.Add("false",ConstantReader.FalseValue);
Constants.Add("True", ConstantReader.TrueValue);
Constants.Add("False", ConstantReader.FalseValue);
Constants.Add("Pi", new ConstantReader(Math.PI));
Constants.Add("E", new ConstantReader(Math.E));
#endregion
Constants.Priority = Identifier.Priority + 1;
#region operator terminals
Terminal openBrace = ToTerm("{");
Terminal closeBrace = ToTerm("}");
Terminal colon = ToTerm(":");
Terminal comma = ToTerm(",");
Terminal openBrac = ToTerm("(");
Terminal closeBrac = ToTerm(")");
Becomes = ToTerm("=", "Becomes");
Eql = ToTerm("==", "Eql");
Lt = ToTerm("<", "Lt");
Gt = ToTerm(">", "Gt");
Le = ToTerm("<=", "Le");
Ge = ToTerm(">=", "Ge");
Neq = ToTerm("!=", "ne");
Plus = ToTerm("+", "Plus");
Minus = ToTerm("-", "Minus");
Mult = ToTerm("*", "Mult");
Div = ToTerm("/", "Div");
Rem = ToTerm("%", "Rem");
Pow = ToTerm("**", "Pow");
And = new RegexBasedTerminal("And", @"(&&)|(and)");
Or = new RegexBasedTerminal("Or", @"(\|\|)|(or)");
Not = new RegexBasedTerminal("Not", @"!|(not)");
LeftShift = ToTerm("<<", "leftShitf");
RightShift = ToTerm(">>", "RightShift");
BPlus = ToTerm("+=", "Plus Equals");
BMinus = ToTerm("-=", "Minus Equals");
BMult = ToTerm("*=", "Mult Equals");
BDiv = ToTerm("/=", "Div Equals");
BRem = ToTerm("%=", "Rem Equals");
BPow = ToTerm("^=", "Pow Equals");
BAnd = ToTerm("&=", "And Equals");
BOr = ToTerm("|=", "Or Equals");
BLeftShift = ToTerm("<<=", "LShift Equals");
BRightShift = ToTerm(">>=", "RShift Equals");
NonTerminal becomesExpr = new NonTerminal("Becomes expr");
becomesExpr.Rule = BPlus | BMinus | BDiv | BMult | BRem | BPow | BAnd | BOr | BLeftShift | BRightShift | Becomes;
OpLookup[Plus] = OpLookup[BPlus] = OpCode.Plus;
OpLookup[Minus] = OpLookup[BMinus] = OpCode.Minus;
OpLookup[Div] = OpLookup[BDiv] = OpCode.Div;
OpLookup[Mult] = OpLookup[BMult] = OpCode.Mult;
OpLookup[Rem] = OpLookup[BRem] = OpCode.Rem;
OpLookup[Pow] = OpLookup[BPow] = OpCode.Pow;
OpLookup[And] = OpLookup[BAnd] = OpCode.And;
OpLookup[Or] = OpLookup[BOr] = OpCode.Or;
OpLookup[LeftShift] = OpLookup[BLeftShift] = OpCode.LeftShift;
OpLookup[RightShift] = OpLookup[BRightShift] = OpCode.RightShift;
OpLookup[Becomes] = OpCode.Becomes;
OpLookup[Lt] = OpCode.Lt;
OpLookup[Le] = OpCode.Le;
OpLookup[Gt] = OpCode.Gt;
OpLookup[Ge] = OpCode.Ge;
OpLookup[Neq] = OpCode.Neq;
OpLookup[Eql] = OpCode.Eql;
#endregion
#region values
//NonTerminal value = new NonTerminal("value");
NonTerminal exactValue = new NonTerminal("exactValue", "exactValue");
#endregion
#region value rules
ThreeVal.Rule = Identifier + "." + Identifier + "." + Identifier;
TwoVal.Rule = Identifier + "." + Identifier;
IsType.Rule = "$" + Identifier;
RegisterBracePair("(", ")");
RegisterBracePair("{", "}");
IsExactType.Rule = "#" + Identifier;
ParentVal.Rule = "^" + Identifier + "." + Identifier | "^" + Identifier + "." + Identifier + "." + Identifier;
exactValue.Rule = Identifier | TwoVal | ThreeVal | ParentVal;
TypeMatcher.Rule = IsType | IsExactType| IsType + Plus + TypeMatcher | IsExactType + Plus + TypeMatcher;
Argument.Rule = Expr | Expr + "," + Argument;
Function.Rule = Identifier + ToTerm("(") +")" | Identifier + "(" + Argument + ")";
#endregion
#region expressions
NonTerminal term = new NonTerminal("term");
Expr.Rule = Expr + BinOp + Expr | UniOp + Expr | term;
BinOp.Rule = Plus | Minus | Div | Mult | Rem | Pow | And | Or | Eql | Neq | Gt | Ge | Lt | Le | LeftShift | RightShift;
UniOp.Rule = Not | Minus;
term.Rule = Number | Str | openBrac + Expr + closeBrac | exactValue | Constants | Function;
#endregion
#region operator precedence
/* NOTE: Order is taken from C++/C# order with power added in.
* Higher number = more important
* Increments are by 10 to allow easy adding of new terms
* Power is not in C++/C#, but has been added where is seems to fit
*/
RegisterOperators(10, Associativity.Right, Becomes);
RegisterOperators(20, Associativity.Left, Or);
RegisterOperators(30, Associativity.Left, And);
RegisterOperators(40, Associativity.Left, Eql, Neq);
RegisterOperators(50, Associativity.Left, Eql, Neq);
RegisterOperators(60, Associativity.Left, Ge, Le, Lt, Gt);
RegisterOperators(70, Associativity.Left, LeftShift, RightShift);
RegisterOperators(70, Associativity.Left, Plus, Minus);
RegisterOperators(80, Associativity.Left, Div, Mult, Rem);
RegisterOperators(90, Associativity.Left, Pow);
RegisterOperators(100, Associativity.Left, Not);
#endregion
#region game creation rules
NonTerminal IsPrototype = new NonTerminal("IsPrototype", "IsPrototype");
value.Rule = TypeMatcher | Expr;
Names.Rule = Identifier + comma + Names | Identifier;
IsPrototype.Rule = colon + Names | Empty;
NonTerminal optionalProperties = new NonTerminal("optionalProperties", "optionalProperties");
optionalProperties.Rule = Properties | Empty;
Properties.Rule = Identifier + Becomes + value | Identifier + Becomes + value + comma + optionalProperties;
BasicDefinition.Rule = openBrac + optionalProperties + closeBrac;
NonTerminal optionalComponent = new NonTerminal("optionalComponent", "optionalComponent");
optionalComponent.Rule = Component | Empty;
Component.Rule = "Component" + Identifier + BasicDefinition + optionalComponent;
NonTerminal optionalPrototype = new NonTerminal("optionalPrototype", "optionalPrototype");
optionalPrototype.Rule = Prototype | Empty;
Prototype.Rule = "Prototype" + Identifier + EntityDefinition + optionalPrototype;
NonTerminal optionalManager = new NonTerminal("optionalManager", "optionalManager");
optionalManager.Rule = Manager | Empty;
Manager.Rule = "Manager" + Identifier + BasicDefinition + optionalManager;
NonTerminal optionalService = new NonTerminal("optionalService", "optionalService");
optionalService.Rule = Service | Empty;
Service.Rule = "Service" + Identifier + BasicDefinition + optionalService;
Else.Rule = ToTerm("else") + "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace + Else |
ToTerm("else") + "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace |
"else" + openBrace + Actions + closeBrace + Else |
"else" + openBrace + Actions + closeBrace;
Condition.Rule = "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace + Else |
"if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace;
NonTerminal optionalAssignment = new NonTerminal("optionalAssignment", "optionalAssignment");
optionalAssignment.Rule = Assignment | Empty;
Loop.Rule = "while" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace |
"for" + openBrac + optionalAssignment + ";" + Expr + ";" + Assignment + closeBrac + openBrace + Actions + closeBrace;
NonTerminal optionalActions = new NonTerminal("OptionalActions", "OptionalActions");
Action.Rule = Identifier + BasicDefinition;
Assignment.Rule = exactValue + becomesExpr + Expr;
Actions.Rule = Condition + optionalActions | Action + optionalActions | Assignment + optionalActions | Loop + optionalActions;
optionalActions.Rule = Actions | Empty;
NonTerminal optionalEvt = new NonTerminal("optionalEvt", "optionalEvt");
optionalEvt.Rule = Evt | Empty;
Evt.Rule = "Event" + Identifier + BasicDefinition + openBrace + optionalActions + closeBrace + optionalEvt;
EntityDefinition.Rule = IsPrototype + BasicDefinition + openBrace + optionalComponent + optionalEvt + closeBrace;
NonTerminal optionalEntity = new NonTerminal("optionalEntity", "optionalEntity");
optionalEntity.Rule = Entity | Empty;
NonTerminal optionalIdentifier = new NonTerminal("optionalIdentifier", "optionalIdentifier");
optionalIdentifier.Rule = Identifier | Empty;
Entity.Rule = "Entity" + optionalIdentifier + EntityDefinition + optionalEntity;
NonTerminal optionalScene = new NonTerminal("optionalScene", "optionalScene");
optionalScene.Rule = Scene | Empty;
Scene.Rule = "Scene" + Identifier + BasicDefinition + openBrace + optionalManager + optionalEntity + closeBrace + optionalScene;
NonTerminal optionalDefinitions = new NonTerminal("optionalDefinitions", "optionalDefinitions");
optionalDefinitions.Rule = Definitions | Empty;
Definitions.Rule = "define" + Identifier + "as" + ClassName + optionalDefinitions;
NonTerminal optionalUses = new NonTerminal("optionalUses", "optionalUses");
optionalUses.Rule = Uses | Empty;
Uses.Rule = "using" + ClassName + openBrace + Definitions + closeBrace + optionalUses;
Game.Rule = optionalUses + "Game" + BasicDefinition + openBrace + optionalPrototype + optionalService + Scene + closeBrace;
#endregion
Root = Game;
//Removes from the tree, we don't care about having these there
MarkPunctuation("{", "}", "(", ")", ":", "$", "@", "#", "^", "Game", "using", "define", "Scene", "Entity",
",", "if", "Component", "Manager", "Prototype", "=", ".", "as", "Event", "else", "Service", ";", "while", "for");
MarkReservedWords("using", "define", "if", "else", "while", "for");
MarkTransient(BasicDefinition, value, IsPrototype, term, exactValue, optionalActions, optionalEvt, optionalComponent,
optionalProperties, optionalManager, optionalPrototype, optionalService, optionalUses, optionalDefinitions,
optionalEntity, optionalScene, optionalIdentifier, optionalAssignment, becomesExpr);
}
//case-sensitive
public CoffeescriptGrammar()
: base(false)
{
// ReSharper disable InconsistentNaming
//Terminals
var NUMBER = new NumberLiteral("Number");
var IDENTIFIER = new IdentifierTerminal("Identifier");
var STATEMENT = ToTerm("break") | "continue" | "debugger";
var STRING = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var comment = new CommentTerminal("comment", "#", "\n", "\r");
NonGrammarTerminals.Add(comment);
var BOOL = ToTerm("true") | "false" | "null" | "undefined";
var CLASS = ToTerm("class");
var EXTENDS = ToTerm("extends");
var PARAM_START = ToTerm("(") | Empty;
var PARAM_END = ToTerm(")") | Empty;
var FUNC_GLYPH = ToTerm("=>") | ToTerm("->");
var COMMA = ToTerm(",");
var OPT_COMMA = ToTerm(",") | Empty;
var INDEX_START = ToTerm("[");
var INDEX_END = ToTerm("]");
var INDEX_SOAK = ToTerm("?");
var INDEX_PROTO = ToTerm("::");
var SUPER = ToTerm("super");
var FUNC_EXIST = ToTerm("?");
var CALL_START = ToTerm("(");
var CALL_END = ToTerm(")");
var THIS = ToTerm("this");
var TRY = ToTerm("try");
var FINALLY = ToTerm("finally");
var CATCH = ToTerm("catch");
var THROW = ToTerm("throw");
var WHILE = ToTerm("while");
var WHEN = ToTerm("when");
var UNTIL = ToTerm("until");
var LOOP = ToTerm("loop");
var FOR = ToTerm("for");
var OWN = ToTerm("own");
var FORIN = ToTerm("in");
var FOROF = ToTerm("of");
var BY = ToTerm("by");
var SWITCH = ToTerm("switch");
var ELSE = ToTerm("else");
var LEADING_WHEN = ToTerm("When");
var IF = ToTerm("IF");
var POST_IF = ToTerm("if");
#region Non Terminals
var Body = new NonTerminal("Body", CreateBlock);
var UnaryOp = new NonTerminal("UnaryOp");
var Statement = new NonTerminal("Statement");
var Expression = new NonTerminal("Expression");
var Line = new NonTerminal("Line");
var Return = new NonTerminal("Return");
var Throw = new NonTerminal("Throw");
var Comment = new NonTerminal("Comment");
var Value = new NonTerminal("Value");
var Invocation = new NonTerminal("Invocation");
var Code = new NonTerminal("Code");
var Operation = new NonTerminal("Operation");
var Assign = new NonTerminal("Assign",typeof(AssignmentNode));
var If = new NonTerminal("If");
var Try = new NonTerminal("Try");
var While = new NonTerminal("While");
var For = new NonTerminal("For");
var Switch = new NonTerminal("Switch");
var Class = new NonTerminal("Class");
var Block = new NonTerminal("Block",CreateBlock);
var AlphaNumeric = new NonTerminal("AlphaNumeric");
var Literal = new NonTerminal("Literal");
var Assignable = new NonTerminal("Assignable");
var AssignObj = new NonTerminal("AssignObj");
var ObjAssignable = new NonTerminal("ObjAssignable");
var ThisProperty = new NonTerminal("ThisProperty");
var ParamList = new NonTerminal("ParamList");
var Param = new NonTerminal("Param");
var ParamVar = new NonTerminal("ParamVar");
var ArrayNonTerm = new NonTerminal("Array");
var ObjectNonTerm = new NonTerminal("Object");
var Splat = new NonTerminal("Splat");
var SimpleAssignable = new NonTerminal("SimpleAssignable");
var Accessor = new NonTerminal("Accessor");
var Parenthetical = new NonTerminal("Parenthetical");
var This = new NonTerminal("This");
var Range = new NonTerminal("Range");
var Index = new NonTerminal("Index");
var Slice = new NonTerminal("Slice");
var AssignList = new NonTerminal("AssignList");
var OptFuncExist = new NonTerminal("OptFuncExist");
var Arguments = new NonTerminal("Arguments");
var ArgList = new NonTerminal("ArgList");
var RangeDots = new NonTerminal("RangeDots");
var Arg = new NonTerminal("Arg");
var SimpleArgs = new NonTerminal("SimpleArgs");
var Catch = new NonTerminal("Catch");
var WhileSource = new NonTerminal("WhileSource");
var Loop = new NonTerminal("Loop");
var ForBody = new NonTerminal("ForBody");
var ForStart = new NonTerminal("ForStart");
var ForSource = new NonTerminal("ForSource");
var ForVariables = new NonTerminal("ForVariables");
var ForValue = new NonTerminal("ForValue");
var Whens = new NonTerminal("Whens");
var When = new NonTerminal("When");
var IfBlock = new NonTerminal("IfBlock");
var BinaryOp = new NonTerminal("BinaryOp");
var BinExpr = new NonTerminal("BinExpr",typeof(BinaryOperationNode));
var CompoundAssignOp = new NonTerminal("CompoundAssign");
#endregion
#region Production rules
BinaryOp.Rule = ToTerm("+") | "-" | "*";
Body.Rule = MakePlusRule(Body, Line);
Line.Rule = Expression + Eos | Statement + Eos;
Statement.Rule = STATEMENT;
Expression.Rule = Value | BinExpr | Assign;
BinExpr.Rule = Value + BinaryOp + Value;
Assign.Rule = (Assignable + "=" + Expression)
| (Assignable + "=" + Indent + Expression + Dedent);
SimpleAssignable.Rule = IDENTIFIER;
Assignable.Rule = SimpleAssignable;
Value.Rule = Assignable | Literal;
AlphaNumeric.Rule = NUMBER | STRING;
Literal.Rule = AlphaNumeric;
#endregion
MarkTransient(Line);
Root = Body;
LanguageFlags = LanguageFlags.CreateAst;
// ReSharper enable InconsistentNaming
}
public MiniPythonGrammar() : base(caseSensitive: true) {
// 1. Terminals
var number = TerminalFactory.CreatePythonNumber("number");
var identifier = TerminalFactory.CreatePythonIdentifier("identifier");
var comment = new CommentTerminal("comment", "#", "\n", "\r");
//comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
// so we add it to this list to let Scanner know that it is also a valid terminal.
base.NonGrammarTerminals.Add(comment);
var comma = ToTerm(",");
var colon = ToTerm(":");
// 2. Non-terminals
var Expr = new NonTerminal("Expr");
var Term = new NonTerminal("Term");
var BinExpr = new NonTerminal("BinExpr", typeof(BinaryOperationNode));
var ParExpr = new NonTerminal("ParExpr");
var UnExpr = new NonTerminal("UnExpr", typeof(UnaryOperationNode));
var UnOp = new NonTerminal("UnOp", "operator");
var BinOp = new NonTerminal("BinOp", "operator");
var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssignmentNode));
var Stmt = new NonTerminal("Stmt");
var ExtStmt = new NonTerminal("ExtStmt");
//Just as a test for NotSupportedNode
var ReturnStmt = new NonTerminal("return", typeof(NotSupportedNode));
var Block = new NonTerminal("Block");
var StmtList = new NonTerminal("StmtList", typeof(StatementListNode));
var ParamList = new NonTerminal("ParamList", typeof(ParamListNode));
var ArgList = new NonTerminal("ArgList", typeof(ExpressionListNode));
var FunctionDef = new NonTerminal("FunctionDef", typeof(FunctionDefNode));
var FunctionCall = new NonTerminal("FunctionCall", typeof(FunctionCallNode));
// 3. BNF rules
Expr.Rule = Term | UnExpr | BinExpr;
Term.Rule = number | ParExpr | identifier | FunctionCall;
ParExpr.Rule = "(" + Expr + ")";
UnExpr.Rule = UnOp + Term;
UnOp.Rule = ToTerm("+") | "-";
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
AssignmentStmt.Rule = identifier + "=" + Expr;
Stmt.Rule = AssignmentStmt | Expr | ReturnStmt | Empty;
ReturnStmt.Rule = "return" + Expr; //Not supported for execution! - we associate NotSupportedNode with ReturnStmt
//Eos is End-Of-Statement token produced by CodeOutlineFilter
ExtStmt.Rule = Stmt + Eos | FunctionDef;
Block.Rule = Indent + StmtList + Dedent;
StmtList.Rule = MakePlusRule(StmtList, ExtStmt);
ParamList.Rule = MakeStarRule(ParamList, comma, identifier);
ArgList.Rule = MakeStarRule(ArgList, comma, Expr);
FunctionDef.Rule = "def" + identifier + "(" + ParamList + ")" + colon + Eos + Block;
FunctionDef.NodeCaptionTemplate = "def #{1}(...)";
FunctionCall.Rule = identifier + "(" + ArgList + ")";
FunctionCall.NodeCaptionTemplate = "call #{0}(...)";
this.Root = StmtList; // Set grammar root
// 4. Token filters - created in a separate method CreateTokenFilters
// we need to add continuation symbol to NonGrammarTerminals because it is not used anywhere in grammar
NonGrammarTerminals.Add(ToTerm(@"\"));
// 5. Operators precedence
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "**");
// 6. Miscellaneous: punctuation, braces, transient nodes
MarkPunctuation("(", ")", ":");
RegisterBracePair("(", ")");
MarkTransient(Term, Expr, Stmt, ExtStmt, UnOp, BinOp, ExtStmt, ParExpr, Block);
// 7. Error recovery rule
ExtStmt.ErrorRule = SyntaxError + Eos;
FunctionDef.ErrorRule = SyntaxError + Dedent;
// 8. Syntax error reporting
AddToNoReportGroup("(");
AddToNoReportGroup(Eos);
AddOperatorReportGroup("operator");
// 9. Initialize console attributes
ConsoleTitle = "Mini-Python Console";
ConsoleGreeting =
@"Irony Sample Console for mini-Python.
Supports a small sub-set of Python: assignments, arithmetic operators,
function declarations with 'def'. Supports big integer arithmetics.
Supports Python indentation and line-joining rules, including '\' as
a line joining symbol.
Press Ctrl-C to exit the program at any time.
";
ConsolePrompt = ">>>";
ConsolePromptMoreInput = "...";
// 10. Language flags
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF | LanguageFlags.CreateAst | LanguageFlags.SupportsBigInt;
}//constructor
public MyCGrammarExtended() {
#region Declare Terminals Here
CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/");
CommentTerminal lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
NumberLiteral number = new NumberLiteral("number");
IdentifierTerminal identifier = new IdentifierTerminal("identifier");
#endregion
#region Declare NonTerminals Here
NonTerminal program = new NonTerminal("program");
NonTerminal declarations = new NonTerminal("declaration");
NonTerminal declaration = new NonTerminal("declaration");
NonTerminal simpleDeclarations = new NonTerminal("simple-declarations");
NonTerminal simpleDeclaration = new NonTerminal("simple-declaration");
NonTerminal semiDeclaration = new NonTerminal("semi-declaration");
NonTerminal parenParameters = new NonTerminal("paren-parameters");
NonTerminal parameters = new NonTerminal("parameters");
NonTerminal classOption = new NonTerminal("class-option");
NonTerminal variableType = new NonTerminal("variable-type");
NonTerminal block = new NonTerminal("block");
NonTerminal blockContent = new NonTerminal("block-content");
NonTerminal statements = new NonTerminal("statements");
NonTerminal statement = new NonTerminal("statement");
NonTerminal parenExpressionAlways = new NonTerminal("paren-expression-always");
NonTerminal parenExpression = new NonTerminal("paren-expression");
NonTerminal forHeader = new NonTerminal("for-header");
NonTerminal forBlock = new NonTerminal("for-block");
NonTerminal semiStatement = new NonTerminal("semi-statement");
NonTerminal arguments = new NonTerminal("arguments");
NonTerminal parenArguments = new NonTerminal("paren-arguments");
NonTerminal assignExpression = new NonTerminal("assign-expression");
NonTerminal expression = new NonTerminal("expression");
NonTerminal booleanOperator = new NonTerminal("boolean-operator");
NonTerminal relationalExpression = new NonTerminal("relational-expression");
NonTerminal relationalOperator = new NonTerminal("relational-operator");
NonTerminal bitExpression = new NonTerminal("bit-expression");
NonTerminal bitOperator = new NonTerminal("bit-operator");
NonTerminal addExpression = new NonTerminal("add-expression");
NonTerminal addOperator = new NonTerminal("add-operator");
NonTerminal multiplyExpression = new NonTerminal("multiply");
NonTerminal multiplyOperator = new NonTerminal("multiply-operator");
NonTerminal prefixExpression = new NonTerminal("prefix-expression");
NonTerminal prefixOperator = new NonTerminal("prefix-operator");
NonTerminal factor = new NonTerminal("factor");
NonTerminal identifierExpression = new NonTerminal("identifier-expression");
#endregion
#region Place Rules Here
this.Root = program;
program.Rule = declarations;
declarations.Rule = MakeStarRule(declarations, declaration);
declaration.Rule
= classOption + variableType + identifier + parameters + block
| classOption + identifier + parenParameters + block
| variableType + identifier + parenParameters + block
| identifier + parenParameters + block
| simpleDeclaration;
simpleDeclarations.Rule = MakePlusRule(simpleDeclarations, simpleDeclaration);
simpleDeclaration.Rule = semiDeclaration + ";";
semiDeclaration.Rule
= semiDeclaration + "," + identifier
| classOption + variableType + identifier
| variableType + identifier;
parameters.Rule
= parameters + "," + variableType + identifier
| variableType + identifier;
parenParameters.Rule
= ToTerm("(") + ")"
| "(" + parameters + ")";
classOption.Rule
= ToTerm("static")
| "auto"
| "extern";
variableType.Rule
= ToTerm("int")
| "void";
block.Rule
= ToTerm("{") + "}"
| "{" + blockContent + "}";
blockContent.Rule
= simpleDeclarations + statements
| simpleDeclarations
| statements;
statements.Rule = MakePlusRule(statements, statement);
statement.Rule
= semiStatement + ";"
| block
| "while" + parenExpressionAlways + statement
| "for" + forHeader + statement
| "if" + parenExpressionAlways + statement
| "if" + parenExpressionAlways + statement + PreferShiftHere() + "else" + statement;
parenExpressionAlways.Rule = parenExpression;
parenExpression.Rule = ToTerm("(") + expression + ")";
forHeader.Rule = "(" + forBlock + ")";
forBlock.Rule = assignExpression + ";" + expression + ";" + assignExpression;
semiStatement.Rule
= assignExpression
| "return" + expression
| "break"
| "continue";
arguments.Rule
= expression + "," + arguments
| expression;
parenArguments.Rule
= ToTerm("(") + ")"
| "(" + arguments + ")";
assignExpression.Rule
= identifier + "=" + expression
| expression;
expression.Rule
= relationalExpression + booleanOperator + expression
| relationalExpression;
booleanOperator.Rule
= ToTerm("&&")
| "||";
relationalExpression.Rule
= bitExpression + relationalOperator + bitExpression
| bitExpression;
relationalOperator.Rule
= ToTerm(">")
| ">="
| "<"
| "<="
| "=="
| "!=";
bitExpression.Rule
= addExpression + bitOperator + bitExpression
| addExpression;
bitOperator.Rule
= ToTerm("|")
| "&"
| "^";
addExpression.Rule
= multiplyExpression + addOperator + addExpression
| prefixExpression;
addOperator.Rule
= ToTerm("+") | "-";
multiplyExpression.Rule
= prefixExpression + multiplyOperator + multiplyExpression
| prefixExpression;
multiplyOperator.Rule
= ToTerm("*")
| "/";
prefixExpression.Rule
= prefixOperator + factor
| factor;
prefixOperator.Rule = ToTerm("!");
factor.Rule
= identifierExpression + parenArguments
| identifierExpression
| number
| parenExpression;
identifierExpression.Rule
= identifier
| identifierExpression + "." + identifier;
#endregion
#region Define Keywords
this.MarkReservedWords("break", "continue", "else", "extern", "for",
"if", "int", "return", "static", "void", "while");
#endregion
}
public MtGrammar()
: base(true)
{
// Terminals
var stringLiteral = new StringLiteral("stringLiteral", "\"", StringOptions.AllowsLineBreak | StringOptions.AllowsAllEscapes);
var nbrLiteral = new NumberLiteral("nbrLiteral");
var identifier = new IdentifierTerminal("identifier", IdOptions.IsNotKeyword);
var comment = new CommentTerminal("comment", "/*", "*/");
// Punctuation terminals; these shouldn't appear on the tree
var pipe = ToTerm("|", "pipe");
var semicomma = ToTerm(";", "semicomma");
var openparen = ToTerm("(", "openparen");
var closeparen = ToTerm(")", "closeparen");
var openbrace = ToTerm("{", "openbrace");
var closebrace = ToTerm("}", "closebrace");
var openbracket = ToTerm("[", "openbracket");
var closebracket = ToTerm("]", "closebracket");
var bind = ToTerm("<=", "bind");
var argsBodySeparator = ToTerm("=>", "argsBodySeparator");
var comma = ToTerm(",", "comma");
var lambda = ToTerm("L", "lambda");
var ift = ToTerm("if", "if");
var dot = ToTerm(".", "dot");
var flowRightToLeft = ToTerm("<-", "flowRightToLeft");
var listenerOp = ToTerm("on", "listenerOp");
MarkPunctuation(pipe, semicomma, openparen, closeparen,
openbrace, closebrace,
openbracket, closebracket, bind,
argsBodySeparator, comma, lambda,
ift, dot, flowRightToLeft, listenerOp);
//--
// Non Terminals
AstNodeCreator MakeExpressionNode = delegate(AstContext context, ParseTreeNode treeNode)
{
if (treeNode == null)
throw new Exception("treeNode cant be null at MakeExpressionNode");
if (treeNode.ChildNodes.Count != 1)
throw new Exception("Expression expects 1 child (received {0}.)".SafeFormat(treeNode.ChildNodes.Count));
// Check child term name
var possibleValid = treeNode.ChildNodes[0];
if (possibleValid == null)
throw new Exception("Only child cant be null at MakeExpressionNode");
var tag = possibleValid.Term.Name;
if (string.IsNullOrWhiteSpace(tag))
throw new Exception("tag cant be null or empty at MakeExpressionNode");
if (tag == "APPLICATION")
{
treeNode.AstNode = _.NewAndInit<MtApplication>(context, possibleValid);
}
else if (tag == "ATOM")
{
treeNode.AstNode = _.NewAndInit<MtAtom>(context, possibleValid);
}
else if (tag == "FORK")
{
treeNode.AstNode = _.NewAndInit<MtFork>(context, possibleValid);
}
else if (tag == "BIND")
{
treeNode.AstNode = _.NewAndInit<MtBind>(context, possibleValid);
}
else if (tag == "IF")
{
treeNode.AstNode = _.NewAndInit<MtIf>(context, possibleValid);
}
else if (tag == "FUNCTION_LITERAL")
{
treeNode.AstNode = _.NewAndInit<MtFunctionLiteral>(context, possibleValid);
}
else if (tag == "FLOW_RIGHT_TO_LEFT")
{
treeNode.AstNode = _.NewAndInit<MtFlowRightToLeft>(context, possibleValid);
}
else if (tag == "ARRAY")
{
treeNode.AstNode = _.NewAndInit<MtArray>(context, possibleValid);
}
else if (tag == "LISTENER_STATEMENT")
{
treeNode.AstNode = _.NewAndInit<MtListenerStatement>(context, possibleValid);
}
else if (tag == "identifier")
{
// Do nothing here ...
treeNode.AstNode = _.NewAndInit<Irony.Interpreter.Ast.IdentifierNode>(context, possibleValid);
}
else
{
throw new Exception("Unexpected tag in Expression child: {0}".SafeFormat(tag));
}
};
var TOP_CHAIN = new NonTerminal("TOP_CHAIN", delegate(AstContext context, ParseTreeNode treeNode)
{
if (treeNode.ChildNodes.Count != 1)
throw new Exception("Top chain expects 1 child (received {0}.)".SafeFormat(treeNode.ChildNodes.Count));
// Check child term name
var possibleValid = treeNode.ChildNodes[0];
var tag = possibleValid.Term.Name;
if (tag == "CHAIN")
{
treeNode.AstNode = _.NewAndInit<MtChain>(context, possibleValid);
}
else if (tag == "EXPRESSION")
{
// HACK
MakeExpressionNode(context, possibleValid);
treeNode.AstNode = possibleValid.AstNode;
}
else
{
throw new Exception("Unexpected tag in TOP_CHAIN child: {0}".SafeFormat(tag));
}
});
var ARRAY = new NonTerminal("ARRAY", typeof(MtArray));
var IF = new NonTerminal("IF", typeof(MtIf));
var CHAIN = new NonTerminal("CHAIN", typeof(MtChain));
var ATOM = new NonTerminal("ATOM", typeof(MtAtom));
var NCHAINS = new NonTerminal("NCHAINS", typeof(MtFork));
var APPLICATION = new NonTerminal("APPLICATION", typeof(MtApplication));
var BIND = new NonTerminal("BIND", typeof(MtBind));
var FORK = new NonTerminal("FORK", typeof(MtFork));
var ARG_LIST_FOR_DECL = new NonTerminal("ARG_LIST_FOR_DECL", typeof(MtArgListForDecl));
var FUNCTION_LITERAL = new NonTerminal("FUNCTION_LITERAL", typeof(MtFunctionLiteral));
var EXPRESSION_LIST = new NonTerminal("EXPRESSION_LIST", typeof(MtExpressionList));
var DOTTED_EXPRESSION = new NonTerminal("DOTTED_EXPRESSION", typeof(MtDottedExpression));
var FLOW_RIGHT_TO_LEFT = new NonTerminal("FLOW_RIGHT_TO_LEFT", typeof(MtFlowRightToLeft));
var LISTENER_STATEMENT = new NonTerminal("LISTENER_STATEMENT", typeof(MtListenerStatement));
var FUNCTION = new NonTerminal("FUNCTION", delegate(AstContext context, ParseTreeNode treeNode)
{
if (treeNode.ChildNodes.Count != 1)
throw new Exception("Function expects 1 child (received {0}.)".SafeFormat(treeNode.ChildNodes.Count));
// Check child term name
var possibleValid = treeNode.ChildNodes[0];
var tag = possibleValid.Term.Name;
if (tag == "APPLICATION")
{
treeNode.AstNode = _.NewAndInit<MtApplication>(context, possibleValid);
}
else if (tag == "identifier")
{
// This is ugly as f**k, but works
Type t = identifier.AstConfig.NodeType;
treeNode.AstNode = t.GetConstructors()[0].Invoke(new object[]{ });
(treeNode.AstNode as AstNode).Init(context, possibleValid);
// _.NewAndInit<t>(context, possibleValid);
}
else if (tag == "FUNCTION_LITERAL")
{
treeNode.AstNode = _.NewAndInit<MtFunctionLiteral>(context, possibleValid);
}
else
{
throw new Exception("Unexpected tag in FUNCTION child: {0}".SafeFormat(tag));
}
});
var EXPRESSION = new NonTerminal("EXPRESSION", MakeExpressionNode);
Root = NCHAINS;
/*
* RULES
*/
// TODO: FUNCTION LITERALS / LAMBDAS
// TODO: SWITCH
NCHAINS.Rule = MakePlusRule(NCHAINS, TOP_CHAIN);
TOP_CHAIN.Rule = CHAIN + semicomma |
EXPRESSION + semicomma;
CHAIN.Rule = EXPRESSION + pipe + EXPRESSION |
EXPRESSION + pipe + CHAIN;
EXPRESSION.Rule = ARRAY | FORK | IF | BIND |
FUNCTION_LITERAL | APPLICATION |
LISTENER_STATEMENT | FLOW_RIGHT_TO_LEFT |
ATOM | identifier;
FORK.Rule = openbrace + NCHAINS + closebrace;
LISTENER_STATEMENT.Rule = identifier + listenerOp + identifier + FUNCTION;
ATOM.Rule =
nbrLiteral |
stringLiteral /*|
identifier*/;
FLOW_RIGHT_TO_LEFT.Rule = identifier + flowRightToLeft + identifier;
APPLICATION.Rule = FUNCTION + openparen + EXPRESSION_LIST + closeparen;
EXPRESSION_LIST.Rule = MakeStarRule(EXPRESSION_LIST, comma, EXPRESSION);
FUNCTION.Rule = identifier | FUNCTION_LITERAL | APPLICATION;
BIND.Rule = identifier + bind + EXPRESSION;
IF.Rule = ift + EXPRESSION + TOP_CHAIN + TOP_CHAIN;
ARRAY.Rule = openbracket + EXPRESSION_LIST + closebracket;
// For function literals
ARG_LIST_FOR_DECL.Rule = MakeStarRule(ARG_LIST_FOR_DECL, comma, identifier);
FUNCTION_LITERAL.Rule = lambda + openparen + ARG_LIST_FOR_DECL + closeparen + argsBodySeparator + TOP_CHAIN;
}
public IdlGrammar()
{
#region Initial setup of the grammar
// 1. define all the non-terminals
var tDocument = new NonTerminal(NTNAME_TDOCUMENT);
var tHeader = new NonTerminal(NTNAME_THEADER);
var tInclude = new NonTerminal(NTNAME_TINCLUDE);
var tNamespace = new NonTerminal(NTNAME_TNAMESPACE);
var tNamespaceScope = new NonTerminal(NTNAME_TNAMESPACE_SCOPE);
var tDefinition = new NonTerminal(NTNAME_TDEFINITION);
var tEnum = new NonTerminal(NTNAME_TENUM);
var tStruct = new NonTerminal(NTNAME_TSTRUCT);
var tService = new NonTerminal(NTNAME_TSERVICE);
var tField = new NonTerminal(NTNAME_TFIELD);
var tFieldId = new NonTerminal(NTNAME_TFIELD_ID);
var tFieldReq = new NonTerminal(NTNAME_TFIELD_REQ);
var tFunction = new NonTerminal(NTNAME_TFUNCTION);
var tFieldType = new NonTerminal(NTNAME_TFIELD_TYPE);
var tBaseType = new NonTerminal(NTNAME_TBASE_TYPE);
var tContainerType = new NonTerminal(NTNAME_TCONTAINER_TYPE);
var tMapType = new NonTerminal(NTNAME_TMAP_TYPE);
var tSetType = new NonTerminal(NTNAME_TSET_TYPE);
var tListType = new NonTerminal(NTNAME_TLIST_TYPE);
var tListSeparator = new NonTerminal("TListSeparator");
// 2. define all the terminals
var tSingleQuoteLiteral = new StringLiteral(TNAME_TSINGLE_QUOTE_LITERAL, "\'");
var tDoubleQuoteLiteral = new StringLiteral(TNAME_TDOUBLE_QUOTE_LITERAL, "\"");
// Identifier ::= ( Letter | '_' ) ( Letter | Digit | '.' | '_' )*
var tIdentifier = new IdentifierTerminal(TNAME_TIDENTIFIER, "._", "_");
var tIntNumber = new NumberLiteral("TIntNumber", NumberOptions.AllowSign | NumberOptions.IntOnly);
CommentTerminal WELL_LINE_COMMENT = new CommentTerminal("WELL_LINE_COMMENT", "#", "\n", "\r\n");
CommentTerminal SLASH_LINE_COMMENT = new CommentTerminal("SLASH_LINE_COMMENT", "//", "\n", "\r\n");
CommentTerminal BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "/*", "*/");
NonGrammarTerminals.Add(WELL_LINE_COMMENT);
NonGrammarTerminals.Add(SLASH_LINE_COMMENT);
NonGrammarTerminals.Add(BLOCK_COMMENT);
#endregion
#region Define the grammar
// 3. define BNF rules
// Document ::= Header* Definition*
var headers = new NonTerminal(NTNAME_HEADERS);
var definitions = new NonTerminal(NTNAME_DEFINITIONS);
headers.Rule = MakeStarRule(headers, tHeader);
definitions.Rule = MakeStarRule(definitions, tDefinition);
tDocument.Rule = headers + definitions;
// Header ::= Include | Namespace
tHeader.Rule = tInclude | tNamespace;
// Include ::= 'include' Literal
var literal = (tSingleQuoteLiteral | tDoubleQuoteLiteral);
var includeValue = new NonTerminal(NTNAME_INCLUDE_VALUE);
includeValue.Rule = (tSingleQuoteLiteral | tDoubleQuoteLiteral);
tInclude.Rule = "include" + includeValue;
// Namespace ::= 'namespace' NamespaceScope Identifier
var namespaceValue = new NonTerminal(NTNAME_NAMESPACE_VALUE);
namespaceValue.Rule = tIdentifier | literal;
tNamespace.Rule = "namespace" + tNamespaceScope + namespaceValue;
// NamespaceScope ::= 'java' | 'csharp' | 'objc'
tNamespaceScope.Rule = ToTerm("*") | tIdentifier;
// Definition ::= Enum | Struct | Service
tDefinition.Rule = tEnum | tStruct | tService;
var listSeparatorOrEmpty = new NonTerminal("ListSeparatorOrEmpty");
listSeparatorOrEmpty.Rule = tListSeparator | Empty;
// Enum ::= 'enum' Identifier '{' (Identifier ('=' IntConstant)? ListSeparator?)* '}'
var enumValue = new NonTerminal(NTNAME_ENUM_VALUE);
enumValue.Rule = ("=" + tIntNumber) | Empty;
var enumField = new NonTerminal(NTNAME_ENUM_FIELD);
enumField.Rule = tIdentifier + enumValue;
var enumFields = new NonTerminal(NTNAME_ENUM_FIELDS);
enumFields.Rule = MakeListRule(enumFields, tListSeparator, enumField, TermListOptions.StarList | TermListOptions.AllowTrailingDelimiter);
tEnum.Rule = "enum" + tIdentifier + "{" + enumFields + "}";
// Struct ::= 'struct' Identifier '{' Field* '}'
var structFields = new NonTerminal(NTNAME_STRUCT_FIELDS);
structFields.Rule = MakeStarRule(structFields, null, tField);
tStruct.Rule = "struct" + tIdentifier + "{" + structFields + "}";
// Service ::= 'service' Identifier '{' Function* '}'
var functions = new NonTerminal(NTNAME_FUNCTIONS);
functions.Rule = MakeStarRule(functions, null, tFunction);
tService.Rule = "service" + tIdentifier + "{" + functions + "}";
// Field ::= FieldID FieldReq? FieldType Identifier ('=' ConstValue)? ListSeparator?
var fieldReq = new NonTerminal(NTNAME_FIELD_REQ);
fieldReq.Rule = tFieldReq | Empty;
tField.Rule = tFieldId + fieldReq + tFieldType + tIdentifier + listSeparatorOrEmpty;
// FieldID ::= IntConstant ':'
tFieldId.Rule = tIntNumber + ":";
// FieldReq ::= 'required' | 'optional'
tFieldReq.Rule = ToTerm("required") | "optional";
// Function ::= Identifier Identifier '(' Identifier Identifier ')' ListSeparator?
tFunction.Rule = tIdentifier + tIdentifier + "(" + tIdentifier + tIdentifier + ")" + listSeparatorOrEmpty;
// FieldType ::= Identifier | BaseType | ContainerType
tFieldType.Rule = tIdentifier | tBaseType | tContainerType;
// BaseType ::= 'bool' | 'byte' | 'i16' | 'i32' | 'i64' | 'double' | 'string' | 'binary'
tBaseType.Rule = ToTerm("bool") | "byte" | "i16" | "i32" | "i64" | "double" | "string" | "binary";
// ContainerType ::= MapType | SetType | ListType
tContainerType.Rule = tMapType | tSetType | tListType;
// MapType ::= 'map' '<' FieldType ',' FieldType '>'
tMapType.Rule = ToTerm("map") + "<" + tFieldType + "," + tFieldType + ">";
// SetType ::= 'set' '<' + FieldType '>'
tSetType.Rule = ToTerm("set") + "<" + tFieldType + ">";
// ListType ::= 'list' '<' FieldType '>'
tListType.Rule = ToTerm("list") + "<" + tFieldType + ">";
// ListSeparator ::= ',' | ';'
tListSeparator.Rule = ToTerm(",") | ";";
#endregion
// Set grammar root
this.Root = tDocument;
// 4. Punctuation and transient terms
MarkPunctuation("include", "namespace", "=", "enum", "struct", "{", "}", "(", ")",
"service", "map", "set", "list", "<", ">", ",", "[", "]", ":");
RegisterBracePair("(", ")");
RegisterBracePair("{", "}");
RegisterBracePair("[", "]");
RegisterBracePair("<", ">");
//automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
private void Comments()
{
var comment = new CommentTerminal("multiline_comment", "/*", "*/");
var lineComment = new CommentTerminal("singleline_comment", "--", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(lineComment);
}
public SchematraGrammer()
: base(false)
{
const string dotNotationWordPattern = @"[\w\._]+";
const string singleWordPattern = @"[\w_]+";
const string integerNumberPattern = "[0-9]+";
// ******** //
// Comments //
// ******** //
var SingleLineComment = new CommentTerminal("single-line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var DelimitedComment = new CommentTerminal("multi-line-comment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
// ************* //
// Scalar values //
// ************* //
RegexBasedTerminal word = new RegexBasedTerminal("word", singleWordPattern),
identifier = new RegexBasedTerminal("identifier", dotNotationWordPattern);
StringLiteral stringValue = TerminalFactory.CreateCSharpString("string-value");
NumberLiteral numberValue = TerminalFactory.CreateCSharpNumber("number-value");
NonTerminal value = new NonTerminal("value");
value.Rule = (numberValue | stringValue);
// **************** //
// Field grammer //
// **************** //
RegexBasedTerminal fieldIndex = new RegexBasedTerminal(term_field_index, integerNumberPattern),
fieldName = new RegexBasedTerminal(term_field_name, singleWordPattern),
fieldSchema = new RegexBasedTerminal(term_field_schema, dotNotationWordPattern);
NonTerminal field = new NonTerminal(term_field),
fieldNullable = new NonTerminal(term_field_nullable),
fieldInitValue = new NonTerminal(term_field_init_value),
fieldQualifier = new NonTerminal(term_field_qualifier);
fieldNullable.Rule = ToTerm("nullable") | Empty;
field.Rule = fieldIndex + ":" + fieldQualifier + fieldNullable + fieldSchema +
fieldName + fieldInitValue + ";";
fieldInitValue.Rule = (ToTerm("=") + value) | Empty;
fieldQualifier.Rule = ToTerm("optional") | "required";
// ************** //
// Schema grammer //
// ************** //
StringLiteral schemaDefTag = TerminalFactory.CreateCSharpString(term_schema_def_tag);
RegexBasedTerminal schemaDefExtends = new RegexBasedTerminal(term_schema_def_extends, dotNotationWordPattern);
RegexBasedTerminal schemaDefName = new RegexBasedTerminal(term_schema_def_name, singleWordPattern);
NonTerminal schemaDef = new NonTerminal(term_schema_def),
schemaDefOption = new NonTerminal(term_schema_def_option),
schemaDefTaggedOption = new NonTerminal(term_schema_def_tagged_option),
schemaDefExtendsOption = new NonTerminal(term_schema_def_extends_option),
schemaDefOptions = new NonTerminal(term_schema_def_options),
schemaDefBody = new NonTerminal(term_schema_def_body);
schemaDefTaggedOption.Rule = ToTerm("tagged") + schemaDefTag;
schemaDefExtendsOption.Rule = ToTerm("extends") + schemaDefExtends;
schemaDefOption.Rule = schemaDefTaggedOption | schemaDefExtendsOption;
schemaDefOptions.Rule = MakeStarRule(schemaDefOptions, schemaDefOption);
schemaDef.Rule = ToTerm("record") + schemaDefName + schemaDefOptions + "{" + schemaDefBody + "}";
schemaDefBody.Rule = MakeStarRule(schemaDefBody, field);
// ************* //
// Using grammer //
// ************* //
RegexBasedTerminal usingDefName = new RegexBasedTerminal(term_using_def_name, dotNotationWordPattern);
NonTerminal usingDefs = new NonTerminal(term_using_defs),
usingDef = new NonTerminal(term_using_def);
usingDef.Rule = ToTerm("using") + usingDefName + ";";
usingDefs.Rule = MakeStarRule(usingDefs, usingDef);
// *************** //
// Unit grammer //
// *************** //
RegexBasedTerminal namespaceDefName = new RegexBasedTerminal(term_namespace_def_name, dotNotationWordPattern);
NonTerminal unit = new NonTerminal(term_unit),
def = new NonTerminal(term_def),
defs = new NonTerminal(term_defs),
namespaceDef = new NonTerminal(term_namespace_def);
unit.Rule = usingDefs + defs;
defs.Rule = MakeStarRule(defs, def);
def.Rule = schemaDef | namespaceDef;
namespaceDef.Rule = ToTerm("namespace") + namespaceDefName + "{" + defs + "}";
this.Root = unit;
MarkPunctuation("enum", "a", "=", "[", "]", "record", "{", "}", ",", ";", ":", "namespace", "tagged", "extends", "schema", "using");
}
TerminalSet _skipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution
#endregion Fields
#region Constructors
public CSharpGrammar()
{
this.GrammarComments = "NOTE: This grammar is just a demo, and it is a broken demo.\r\n" +
"Demonstrates token preview technique to help parser resolve conflicts.\r\n";
#region Lexical structure
StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
StringLiteral CharLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
NumberLiteral Number = TerminalFactory.CreateCSharpNumber("Number");
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//Temporarily, treat preprocessor instructions like comments
CommentTerminal ppInstruction = new CommentTerminal("ppInstruction", "#", "\n");
NonGrammarTerminals.Add(ppInstruction);
//Symbols
KeyTerm colon = ToTerm(":", "colon");
KeyTerm semi = ToTerm(";", "semi");
NonTerminal semi_opt = new NonTerminal("semi?");
semi_opt.Rule = Empty | semi;
KeyTerm dot = ToTerm(".", "dot");
KeyTerm comma = ToTerm(",", "comma");
NonTerminal comma_opt = new NonTerminal("comma_opt", Empty | comma);
NonTerminal commas_opt = new NonTerminal("commas_opt");
commas_opt.Rule = MakeStarRule(commas_opt, null, comma);
KeyTerm qmark = ToTerm("?", "qmark");
NonTerminal qmark_opt = new NonTerminal("qmark_opt", Empty | qmark);
KeyTerm Lbr = ToTerm("{");
KeyTerm Rbr = ToTerm("}");
KeyTerm Lpar = ToTerm("(");
KeyTerm Rpar = ToTerm(")");
KeyTerm tgoto = ToTerm("goto");
KeyTerm yld = ToTerm("yield");
KeyTerm Lparx = ToTerm("(*");
#endregion
#region NonTerminals
//B.2.1. Basic concepts
var qual_name_with_targs = new NonTerminal("qual_name_with_targs");
var base_type_list = new NonTerminal("base_type_list");
var generic_dimension_specifier = new NonTerminal("generic_dimension_specifier");
var qual_name_segment = new NonTerminal("qual_name_segment");
var qual_name_segments_opt = new NonTerminal("qual_name_segments_opt");
var type_or_void = new NonTerminal("type_or_void", "type or void");
var builtin_type = new NonTerminal("builtin_type", "built-in type");
var type_ref_list = new NonTerminal("type_ref_list");
var identifier_ext = new NonTerminal("identifier_ext");
var identifier_or_builtin = new NonTerminal("identifier_or_builtin");
//B.2.2. Types
var type_ref = new NonTerminal("type_ref");
var new_type_ref = new NonTerminal("new_type_ref");
var type_argument_list = new NonTerminal("type_argument_list");
var typearg_or_gendimspec_list = new NonTerminal("typearg_or_gendimspec_list");
var type_argument_list_opt = new NonTerminal("type_argument_list_opt");
var integral_type = new NonTerminal("integral_type");
//B.2.4. Expressions
var argument = new NonTerminal("argument");
var argument_list = new NonTerminal("argument_list");
var argument_list_opt = new NonTerminal("argument_list_opt");
var expression = new NonTerminal("expression", "expression");
var expression_list = new NonTerminal("expression_list");
var expression_opt = new NonTerminal("expression_opt");
var conditional_expression = new NonTerminal("conditional_expression");
var lambda_expression = new NonTerminal("lambda_expression");
var query_expression = new NonTerminal("query_expression");
var unary_operator = new NonTerminal("unary_operator");
var assignment_operator = new NonTerminal("assignment_operator");
var primary_expression = new NonTerminal("primary_expression");
var unary_expression = new NonTerminal("unary_expression");
var pre_incr_decr_expression = new NonTerminal("pre_incr_decr_expression");
var post_incr_decr_expression = new NonTerminal("post_incr_decr_expression");
var primary_no_array_creation_expression = new NonTerminal("primary_no_array_creation_expression");
var literal = new NonTerminal("literal");
var parenthesized_expression = new NonTerminal("parenthesized_expression");
var member_access = new NonTerminal("member_access");
var member_access_segment = new NonTerminal("member_access_segment");
var member_access_segments_opt = new NonTerminal("member_access_segments_opt");
var array_indexer = new NonTerminal("array_indexer");
var argument_list_par = new NonTerminal("argument_list_par");
var argument_list_par_opt = new NonTerminal("argument_list_par_opt");
var incr_or_decr = new NonTerminal("incr_or_decr");
var incr_or_decr_opt = new NonTerminal("incr_or_decr_opt");
var creation_args = new NonTerminal("creation_args");
var object_creation_expression = new NonTerminal("object_creation_expression");
// delegate creation is syntactically equiv to object creation
//var delegate_creation_expression = new NonTerminal("delegate_creation_expression");
var anonymous_object_creation_expression = new NonTerminal("anonymous_object_creation_expression");
var typeof_expression = new NonTerminal("typeof_expression");
var checked_expression = new NonTerminal("checked_expression");
var unchecked_expression = new NonTerminal("unchecked_expression");
var default_value_expression = new NonTerminal("default_value_expression");
var anonymous_method_expression = new NonTerminal("anonymous_method_expression");
var elem_initializer = new NonTerminal("elem_initializer");
var elem_initializer_list = new NonTerminal("elem_initializer_list");
var elem_initializer_list_ext = new NonTerminal("elem_initializer_list_ext");
var initializer_value = new NonTerminal("initializer_value");
var anonymous_object_initializer = new NonTerminal("anonymous_object_initializer");
var member_declarator = new NonTerminal("member_declarator");
var member_declarator_list = new NonTerminal("member_declarator_list");
var unbound_type_name = new NonTerminal("unbound_type_name");
var generic_dimension_specifier_opt = new NonTerminal("generic_dimension_specifier_opt");
var anonymous_function_signature = new NonTerminal("anonymous_function_signature");
var anonymous_function_signature_opt = new NonTerminal("anonymous_function_signature_opt");
var anonymous_function_parameter = new NonTerminal("anonymous_function_parameter");
var anonymous_function_parameter_decl = new NonTerminal("anonymous_function_parameter_decl");
var anonymous_function_parameter_list_opt = new NonTerminal("anonymous_function_parameter_list_opt");
var anonymous_function_parameter_modifier_opt = new NonTerminal("anonymous_function_parameter_modifier_opt");
var anonymous_function_body = new NonTerminal("anonymous_function_body");
var lambda_function_signature = new NonTerminal("lambda_function_signature");
var bin_op_expression = new NonTerminal("bin_op_expression");
var typecast_expression = new NonTerminal("typecast_expression");
var bin_op = new NonTerminal("bin_op", "operator symbol");
//B.2.5. Statements
var statement = new NonTerminal("statement", "statement");
var statement_list = new NonTerminal("statement_list");
var statement_list_opt = new NonTerminal("statement_list_opt");
var labeled_statement = new NonTerminal("labeled_statement");
var declaration_statement = new NonTerminal("declaration_statement");
var embedded_statement = new NonTerminal("embedded_statement");
var selection_statement = new NonTerminal("selection_statement");
var iteration_statement = new NonTerminal("iteration_statement");
var jump_statement = new NonTerminal("jump_statement");
var try_statement = new NonTerminal("try_statement");
var checked_statement = new NonTerminal("checked_statement");
var unchecked_statement = new NonTerminal("unchecked_statement");
var lock_statement = new NonTerminal("lock_statement");
var using_statement = new NonTerminal("using_statement");
var yield_statement = new NonTerminal("yield_statement");
var block = new NonTerminal("block");
var statement_expression = new NonTerminal("statement_expression");
var statement_expression_list = new NonTerminal("statement_expression_list");
var local_variable_declaration = new NonTerminal("local_variable_declaration");
var local_constant_declaration = new NonTerminal("local_constant_declaration");
var local_variable_type = new NonTerminal("local_variable_type");
var local_variable_declarator = new NonTerminal("local_variable_declarator");
var local_variable_declarators = new NonTerminal("local_variable_declarators");
var if_statement = new NonTerminal("if_statement");
var switch_statement = new NonTerminal("switch_statement");
var else_clause_opt = new NonTerminal("else_clause_opt");
var switch_section = new NonTerminal("switch_section");
var switch_sections_opt = new NonTerminal("switch_sections_opt");
var switch_label = new NonTerminal("switch_label");
var switch_labels = new NonTerminal("switch_labels");
var while_statement = new NonTerminal("while_statement");
var do_statement = new NonTerminal("do_statement");
var for_statement = new NonTerminal("for_statement");
var foreach_statement = new NonTerminal("foreach_statement");
var for_initializer_opt = new NonTerminal("for_initializer_opt");
var for_condition_opt = new NonTerminal("for_condition_opt");
var for_iterator_opt = new NonTerminal("for_iterator_opt");
var break_statement = new NonTerminal("break_statement");
var continue_statement = new NonTerminal("continue_statement");
var goto_statement = new NonTerminal("goto_statement");
var return_statement = new NonTerminal("return_statement");
var throw_statement = new NonTerminal("throw_statement");
var try_clause = new NonTerminal("try_clause");
var try_clauses = new NonTerminal("try_clauses");
var catch_clause = new NonTerminal("catch_clause");
var finally_clause = new NonTerminal("finally_clause");
var catch_specifier_opt = new NonTerminal("catch_specifier_opt");
var identifier_opt = new NonTerminal("identifier_opt");
var resource_acquisition = new NonTerminal("resource_acquisition");
//namespaces, compilation units
var compilation_unit = new NonTerminal("compilation_unit");
var extern_alias_directive = new NonTerminal("extern_alias_directive");
var extern_alias_directives_opt = new NonTerminal("extern_alias_directives_opt");
var using_directive = new NonTerminal("using_directive");
var using_directives = new NonTerminal("using_directives");
var using_directives_opt = new NonTerminal("using_directives_opt");
var namespace_declaration = new NonTerminal("namespace_declaration");
var namespace_declarations_opt = new NonTerminal("namespace_declarations_opt");
var qualified_identifier = new NonTerminal("qualified_identifier");
var namespace_body = new NonTerminal("namespace_body");
var namespace_member_declaration = new NonTerminal("namespace_member_declaration");
var namespace_member_declarations = new NonTerminal("namespace_member_declarations");
var using_alias_directive = new NonTerminal("using_alias_directive");
var using_ns_directive = new NonTerminal("using_ns_directive");
var type_declaration = new NonTerminal("type_declaration");
var class_declaration = new NonTerminal("class_declaration");
var delegate_declaration = new NonTerminal("delegate_declaration");
var qualified_alias_member = new NonTerminal("qualified_alias_member");
var class_body = new NonTerminal("class_body");
//B.2.7 Classes
Terminal partial = ToTerm("partial");
var type_parameter_list_opt = new NonTerminal("type_parameter_list_opt");
var type_parameter = new NonTerminal("type_parameter");
var type_parameters = new NonTerminal("type_parameters");
var bases_opt = new NonTerminal("bases_opt");
var type_parameter_constraints_clause = new NonTerminal("type_parameter_constraints_clause");
var type_parameter_constraints_clauses_opt = new NonTerminal("type_parameter_constraints_clauses");
var type_parameter_constraint = new NonTerminal("type_parameter_constraint");
var type_parameter_constraints = new NonTerminal("type_parameter_constraints");
var member_declaration = new NonTerminal("member_declaration");
var member_declarations_opt = new NonTerminal("member_declarations_opt");
var constant_declaration = new NonTerminal("constant_declaration");
var field_declaration = new NonTerminal("field_declaration");
var method_declaration = new NonTerminal("method_declaration");
var property_declaration = new NonTerminal("property_declaration");
var event_declaration = new NonTerminal("event_declaration");
var indexer_declaration = new NonTerminal("indexer_declaration");
var constructor_declaration = new NonTerminal("constructor_declaration");
var destructor_declaration = new NonTerminal("destructor_declaration");
var constant_declarator = new NonTerminal("constant_declarator");
var constant_declarators = new NonTerminal("constant_declarators");
var modifier = new NonTerminal("modifier");
var modifiers_opt = new NonTerminal("modifiers_opt");
var member_header = new NonTerminal("member_header");
var accessor_name = new NonTerminal("accessor_name");
var accessor_declaration = new NonTerminal("accessor_declaration");
var accessor_declarations = new NonTerminal("accessor_declarations");
var accessor_modifier_opt = new NonTerminal("accessor_modifier_opt");
var event_body = new NonTerminal("event_body");
var event_accessor_declarations = new NonTerminal("event_accessor_declarations");
var add_accessor_declaration = new NonTerminal("add_accessor_declaration");
var remove_accessor_declaration = new NonTerminal("remove_accessor_declaration");
var indexer_name = new NonTerminal("indexer_name");
var operator_declaration = new NonTerminal("operator_declaration");
var conversion_operator_declaration = new NonTerminal("conversion_operator_declaration");
var overloadable_operator = new NonTerminal("overloadable_operator");
var operator_parameter = new NonTerminal("operator_parameter");
var operator_parameters = new NonTerminal("operator_parameters");
var conversion_operator_kind = new NonTerminal("conversion_operator_kind");
var constructor_initializer_opt = new NonTerminal("constructor_initializer_opt");
var constructor_base = new NonTerminal("constructor_base");
var variable_declarator = new NonTerminal("variable_declarator");
var variable_declarators = new NonTerminal("variable_declarators");
var method_body = new NonTerminal("method_body");
var formal_parameter_list = new NonTerminal("formal_parameter_list");
var formal_parameter_list_par = new NonTerminal("formal_parameter_list_par");
var fixed_parameter = new NonTerminal("fixed_parameter");
var fixed_parameters = new NonTerminal("fixed_parameters");
var parameter_modifier_opt = new NonTerminal("parameter_modifier_opt");
var parameter_array = new NonTerminal("parameter_array");
//B.2.8 struct
var struct_declaration = new NonTerminal("struct_declaration");
var struct_body = new NonTerminal("struct_body");
//B.2.9. Arrays
var rank_specifier = new NonTerminal("rank_specifier");
var rank_specifiers = new NonTerminal("rank_specifiers");
var rank_specifiers_opt = new NonTerminal("rank_specifiers_opt");
var dim_specifier = new NonTerminal("dim_specifier");
var dim_specifier_opt = new NonTerminal("dim_specifier_opt");
var list_initializer = new NonTerminal("array_initializer");
var list_initializer_opt = new NonTerminal("array_initializer_opt");
//B.2.10 Interfaces
var interface_declaration = new NonTerminal("interface_declaration");
var interface_body = new NonTerminal("interface_body");
var interface_member_declaration = new NonTerminal("interface_member_declaration");
var interface_member_declarations = new NonTerminal("interface_member_declarations");
var interface_method_declaration = new NonTerminal("interface_method_declaration");
var interface_property_declaration = new NonTerminal("interface_property_declaration");
var interface_event_declaration = new NonTerminal("interface_event_declaration");
var interface_indexer_declaration = new NonTerminal("interface_indexer_declaration");
var new_opt = new NonTerminal("new_opt");
var interface_accessor = new NonTerminal("interface_get_accessor");
var interface_accessors = new NonTerminal("interface_accessors");
//B.2.11 Enums
var enum_declaration = new NonTerminal("enum_declaration");
var enum_base_opt = new NonTerminal("enum_base_opt");
var enum_member_declaration = new NonTerminal("enum_member_declaration");
var enum_member_declarations = new NonTerminal("enum_member_declarations");
//B.2.13 Attributes
var attribute_section = new NonTerminal("attribute_section");
var attributes_opt = new NonTerminal("attributes_opt");
var attribute_target_specifier_opt = new NonTerminal("attribute_target_specifier_opt");
var attribute_target = new NonTerminal("attribute_target");
var attribute = new NonTerminal("attribute");
var attribute_list = new NonTerminal("attribute_list");
var attribute_arguments_opt = new NonTerminal("attribute_arguments");
var named_argument = new NonTerminal("named_argument");
var attr_arg = new NonTerminal("attr_arg");
var attribute_arguments_par_opt = new NonTerminal("attribute_arguments_par_opt");
#endregion
#region operators, punctuation and delimiters
RegisterOperators(1, "||");
RegisterOperators(2, "&&");
RegisterOperators(3, "|");
RegisterOperators(4, "^");
RegisterOperators(5, "&");
RegisterOperators(6, "==", "!=");
RegisterOperators(7, "<", ">", "<=", ">=", "is", "as");
RegisterOperators(8, "<<", ">>");
RegisterOperators(9, "+", "-");
RegisterOperators(10, "*", "/", "%");
//RegisterOperators(11, ".");
// RegisterOperators(12, "++", "--");
#region comments
//The following makes sense, if you think about "?" in context of operator precedence.
// What we say here is that "?" has the lowest priority among arithm operators.
// Therefore, the parser should prefer reduce over shift when input symbol is "?".
// For ex., when seeing ? in expression "a + b?...", the parser will perform Reduce:
// (a + b)->expr
// and not shift the "?" symbol.
// Same goes for ?? symbol
#endregion
RegisterOperators(-3, "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
RegisterOperators(-2, "?");
RegisterOperators(-1, "??");
this.Delimiters = "{}[](),:;+-*/%&|^!~<>=";
this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
this.MarkTransient(namespace_member_declaration, member_declaration, type_declaration, statement, embedded_statement, expression,
literal, bin_op, primary_expression, expression);
this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
this.AddTermsReportGroup("typename", "bool", "decimal", "float", "double", "string", "object",
"sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "char");
this.AddTermsReportGroup("statement", "if", "switch", "do", "while", "for", "foreach", "continue", "goto", "return", "try", "yield",
"break", "throw", "unchecked", "using");
this.AddTermsReportGroup("type declaration", "public", "private", "protected", "static", "internal", "sealed", "abstract", "partial",
"class", "struct", "delegate", "interface", "enum");
this.AddTermsReportGroup("member declaration", "virtual", "override", "readonly", "volatile", "extern");
this.AddTermsReportGroup("constant", Number, StringLiteral, CharLiteral);
this.AddTermsReportGroup("constant", "true", "false", "null");
this.AddTermsReportGroup("unary operator", "+", "-", "!", "~");
this.AddToNoReportGroup(comma, semi);
this.AddToNoReportGroup("var", "const", "new", "++", "--", "this", "base", "checked", "lock", "typeof", "default",
"{", "}", "[");
//
#endregion
#region "<" conflict resolution
var gen_lt = new NonTerminal("gen_lt");
gen_lt.Rule = CustomActionHere(this.ResolveLessThanConflict) + "<";
#endregion
/*
#region Keywords
string strKeywords =
"abstract as base bool break byte case catch char checked " +
"class const continue decimal default delegate do double else enum event explicit extern false finally " +
"fixed float for foreach goto if implicit in int interface internal is lock long namespace " +
"new null object operator out override params private protected public " +
"readonly ref return sbyte sealed short sizeof stackalloc static string " +
"struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void " +
"volatile while";
AddKeywordList(strKeywords);
#endregion
*/
// RULES
//B.2.1. Basic concepts
//qual_name_with_targs is an alias for namespace-name, namespace-or-type-name, type-name,
generic_dimension_specifier.Rule = gen_lt + commas_opt + ">";
qual_name_segments_opt.Rule = MakeStarRule(qual_name_segments_opt, null, qual_name_segment);
identifier_or_builtin.Rule = identifier | builtin_type;
identifier_ext.Rule = identifier_or_builtin | "this" | "base";
qual_name_segment.Rule = dot + identifier
| "::" + identifier
| type_argument_list;
//generic_dimension_specifier.Rule = lt + commas_opt + ">";
generic_dimension_specifier.Rule = gen_lt + commas_opt + ">";
qual_name_with_targs.Rule = identifier_or_builtin + qual_name_segments_opt;
type_argument_list.Rule = gen_lt + type_ref_list + ">";
type_argument_list_opt.Rule = Empty | type_argument_list;
typearg_or_gendimspec_list.Rule = type_argument_list | generic_dimension_specifier_opt;
//B.2.2. Types
type_or_void.Rule = qual_name_with_targs | "void";
builtin_type.Rule = integral_type | "bool" | "decimal" | "float" | "double" | "string" | "object";
type_ref.Rule = type_or_void + qmark_opt + rank_specifiers_opt + typearg_or_gendimspec_list;
type_ref_list.Rule = MakePlusRule(type_ref_list, comma, type_ref);
var comma_list_opt = new NonTerminal("comma_list_opt");
comma_list_opt.Rule = MakeStarRule(comma_list_opt, comma);
rank_specifier.Rule = "[" + comma_list_opt + "]";
rank_specifiers.Rule = MakePlusRule(rank_specifiers, null, rank_specifier);
rank_specifiers_opt.Rule = rank_specifiers.Q();
integral_type.Rule = ToTerm("sbyte") | "byte" | "short" | "ushort" | "int" | "uint" | "long" | "ulong" | "char";
//B.2.4. Variables
//Quite strange in specs -
// variable-reference:
// expression
// Is that case it would be possible to do the following:
// GetMyStuff(out (a+b));
// but MS c# rejects it
//B.2.4. Expressions
argument.Rule = expression | "ref" + identifier | "out" + identifier;
argument_list.Rule = MakePlusRule(argument_list, comma, argument);
argument_list_opt.Rule = Empty | argument_list;
expression.Rule = conditional_expression
| bin_op_expression
| typecast_expression
| primary_expression;
expression_opt.Rule = Empty | expression;
expression_list.Rule = MakePlusRule(expression_list, comma, expression);
unary_operator.Rule = ToTerm("+") | "-" | "!" | "~" | "*";
assignment_operator.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=";
conditional_expression.Rule = expression + PreferShiftHere() + qmark + expression + colon + expression;// + ReduceThis();
bin_op_expression.Rule = expression + bin_op + expression;
typecast_expression.Rule = parenthesized_expression + primary_expression;
primary_expression.Rule =
literal
| unary_expression
| parenthesized_expression
| member_access
| pre_incr_decr_expression
| post_incr_decr_expression
| object_creation_expression
| anonymous_object_creation_expression
| typeof_expression
| checked_expression
| unchecked_expression
| default_value_expression
| anonymous_method_expression;
unary_expression.Rule = unary_operator + primary_expression;
dim_specifier.Rule = "[" + expression_list + "]";
dim_specifier_opt.Rule = dim_specifier.Q();
literal.Rule = Number | StringLiteral | CharLiteral | "true" | "false" | "null";
parenthesized_expression.Rule = Lpar + expression + Rpar;
pre_incr_decr_expression.Rule = incr_or_decr + member_access;
post_incr_decr_expression.Rule = member_access + incr_or_decr;
//joined invocation_expr and member_access; for member access left the most general variant
member_access.Rule = identifier_ext + member_access_segments_opt;
member_access_segments_opt.Rule = MakeStarRule(member_access_segments_opt, null, member_access_segment);
member_access_segment.Rule = dot + identifier
| array_indexer
| argument_list_par
| type_argument_list;
array_indexer.Rule = "[" + expression_list + "]";
argument_list_par.Rule = Lpar + argument_list_opt + Rpar;
argument_list_par_opt.Rule = Empty | argument_list_par;
list_initializer.Rule = Lbr + elem_initializer_list_ext + Rbr;
list_initializer_opt.Rule = list_initializer.Q();
elem_initializer.Rule = initializer_value | identifier + "=" + initializer_value;
elem_initializer_list.Rule = MakePlusRule(elem_initializer_list, comma, elem_initializer);
elem_initializer_list_ext.Rule = Empty | elem_initializer_list + comma_opt;
initializer_value.Rule = expression | list_initializer;
//delegate, anon-object, object
object_creation_expression.Rule = "new" + qual_name_with_targs + qmark_opt + creation_args + list_initializer_opt;
creation_args.Rule = dim_specifier | rank_specifier | argument_list_par;
anonymous_object_creation_expression.Rule = "new" + anonymous_object_initializer;
anonymous_object_initializer.Rule = Lbr + Rbr | Lbr + member_declarator_list + comma_opt + Rbr;
member_declarator.Rule = expression | identifier + "=" + expression;
member_declarator_list.Rule = MakePlusRule(member_declarator_list, comma, member_declarator);
//typeof
typeof_expression.Rule = "typeof" + Lpar + type_ref + Rpar;
generic_dimension_specifier_opt.Rule = Empty | gen_lt + commas_opt + ">";
//checked, unchecked
checked_expression.Rule = "checked" + parenthesized_expression;
unchecked_expression.Rule = "unchecked" + parenthesized_expression;
//default-value
default_value_expression.Rule = "default" + Lpar + type_ref + Rpar;
//note: we treat ?? as bin-operation, so null-coalesce-expr used in spec as first (condition) component is replaced with expression
// we resolve all this expr hierarchies of binary expressions using precedence
//anonymous method and lambda - we join explicit and implicit param definitions, making 'type' element optional
// TODO: add after-parse check for this
anonymous_method_expression.Rule = "delegate" + anonymous_function_signature_opt + block;
lambda_expression.Rule = lambda_function_signature + "=>" + anonymous_function_body;
lambda_function_signature.Rule = anonymous_function_signature | identifier;
anonymous_function_signature.Rule = Lpar + anonymous_function_parameter_list_opt + Rpar;
anonymous_function_signature_opt.Rule = anonymous_function_signature.Q();
anonymous_function_parameter_modifier_opt.Rule = Empty | "ref" | "out";
anonymous_function_parameter.Rule = anonymous_function_parameter_modifier_opt + anonymous_function_parameter_decl;
anonymous_function_parameter_decl.Rule = identifier | type_ref + identifier;
anonymous_function_parameter_list_opt.Rule = MakeStarRule(anonymous_function_parameter_list_opt, comma, anonymous_function_parameter_decl);
anonymous_function_body.Rule = expression | block;
//we don't use grammar expressions to specify operator precedence, so we combine all these grammar elements together
// and define just bin_op_expression. Where to put it?
// In spec: non_assignment_expression.Rule = conditional_expression | lambda_expression | query_expression;
//I think it's a mistake; there must be additional entry here for arithm expressions, so we put them here.
// We also have to add "is" and "as" expressions here, as we don't build entire hierarchy of elements for expressing
// precedence (where they appear in original spec); so we put them here
bin_op.Rule = ToTerm("<")
| "||" | "&&" | "|" | "^" | "&" | "==" | "!=" | ">" | "<=" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%"
| "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>="
| "is" | "as" | "??";
//type_check_expression.Rule = expression + "is" + type_ref | expression + "as" + type_ref;
//Queries
query_expression.Rule = "from";
//B.2.5. Statements
statement.Rule = labeled_statement | declaration_statement | embedded_statement;
statement.ErrorRule = SyntaxError + semi; //skip all until semicolon
statement_list.Rule = MakePlusRule(statement_list, null, statement);
statement_list_opt.Rule = Empty | statement_list;
//labeled_statement
labeled_statement.Rule = identifier + colon + embedded_statement;
//declaration_statement
declaration_statement.Rule = local_variable_declaration + semi | local_constant_declaration + semi;
local_variable_declaration.Rule = local_variable_type + local_variable_declarators; //!!!
local_variable_type.Rule = member_access | "var"; // | builtin_type; //to fix the conflict, changing to member-access here
local_variable_declarator.Rule = identifier | identifier + "=" + initializer_value;
local_variable_declarators.Rule = MakePlusRule(local_variable_declarators, comma, local_variable_declarator);
local_constant_declaration.Rule = "const" + type_ref + constant_declarators;
//embedded_statement
embedded_statement.Rule = block | semi /*empty_statement*/ | statement_expression + semi | selection_statement
| iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement
| lock_statement | using_statement | yield_statement;
block.Rule = Lbr + statement_list_opt + Rbr;
//selection (if and switch)
selection_statement.Rule = if_statement | switch_statement;
if_statement.Rule = ToTerm("if") + Lpar + expression + Rpar + embedded_statement + else_clause_opt;
else_clause_opt.Rule = Empty | PreferShiftHere() + "else" + embedded_statement;
switch_statement.Rule = "switch" + parenthesized_expression + Lbr + switch_sections_opt + Rbr;
switch_section.Rule = switch_labels + statement_list;
switch_sections_opt.Rule = MakeStarRule(switch_sections_opt, null, switch_section);
switch_label.Rule = "case" + expression + colon | "default" + colon;
switch_labels.Rule = MakePlusRule(switch_labels, null, switch_label);
//iteration statements
iteration_statement.Rule = while_statement | do_statement | for_statement | foreach_statement;
while_statement.Rule = "while" + parenthesized_expression + embedded_statement;
do_statement.Rule = "do" + embedded_statement + "while" + parenthesized_expression + semi;
for_statement.Rule = "for" + Lpar + for_initializer_opt + semi + for_condition_opt + semi + for_iterator_opt + Rpar + embedded_statement;
for_initializer_opt.Rule = Empty | local_variable_declaration | statement_expression_list;
for_condition_opt.Rule = Empty | expression;
for_iterator_opt.Rule = Empty | statement_expression_list;
foreach_statement.Rule = "foreach" + Lpar + local_variable_type + identifier + "in" + expression + Rpar + embedded_statement;
//jump-statement
jump_statement.Rule = break_statement | continue_statement | goto_statement | return_statement | throw_statement;
break_statement.Rule = "break" + semi;
continue_statement.Rule = "continue" + semi;
goto_statement.Rule = tgoto + identifier + semi | tgoto + "case" + expression + semi | tgoto + "default" + semi;
return_statement.Rule = "return" + expression_opt + semi;
throw_statement.Rule = "throw" + expression_opt + semi;
//try-statement
//changed to avoid conflicts; need to check correct ordering of catch/finally clause in after-parse validation
try_statement.Rule = "try" + block + try_clauses;
try_clause.Rule = catch_clause | finally_clause;
try_clauses.Rule = MakePlusRule(try_clauses, null, try_clause);
catch_clause.Rule = "catch" + catch_specifier_opt + block;
finally_clause.Rule = "finally" + block;
catch_specifier_opt.Rule = Empty | Lpar + qual_name_with_targs + identifier_opt + Rpar;
identifier_opt.Rule = Empty | identifier;
//checked, unchecked, locked, using
checked_statement.Rule = "checked" + block;
unchecked_statement.Rule = "unchecked" + block;
lock_statement.Rule = "lock" + parenthesized_expression + embedded_statement;
using_statement.Rule = "using" + Lpar + resource_acquisition + Rpar + embedded_statement;
resource_acquisition.Rule = local_variable_declaration | expression;
//yield statement
yield_statement.Rule = yld + "return" + expression + semi | yld + "break" + semi;
//expression statement
// expression_statement.Rule = statement_expression + semi;
statement_expression.Rule = object_creation_expression
| member_access | member_access + assignment_operator + expression
| pre_incr_decr_expression | post_incr_decr_expression
;
statement_expression_list.Rule = MakePlusRule(statement_expression_list, comma, statement_expression);
incr_or_decr_opt.Rule = Empty | ToTerm("++") | "--";
incr_or_decr.Rule = ToTerm("++") | "--";
//B.2.6. Namespaces
this.Root = compilation_unit;
compilation_unit.Rule = extern_alias_directives_opt
+ using_directives_opt
+ attributes_opt + namespace_declarations_opt;
extern_alias_directive.Rule = PreferShiftHere() + ToTerm("extern") + "alias" + identifier + semi;
extern_alias_directives_opt.Rule = MakeStarRule(extern_alias_directives_opt, null, extern_alias_directive);
namespace_declaration.Rule = "namespace" + qualified_identifier + namespace_body + semi_opt;
namespace_declarations_opt.Rule = MakeStarRule(namespace_declarations_opt, null, namespace_declaration);
qualified_identifier.Rule = MakePlusRule(qualified_identifier, dot, identifier);
namespace_body.Rule = "{" + extern_alias_directives_opt + using_directives_opt + namespace_member_declarations + "}";
using_directive.Rule = using_alias_directive | using_ns_directive;
using_directives.Rule = MakePlusRule(using_directives, null, using_directive);
using_directives_opt.Rule = Empty | using_directives;
using_alias_directive.Rule = "using" + identifier + "=" + qual_name_with_targs + semi;
using_ns_directive.Rule = "using" + qual_name_with_targs + semi;
namespace_member_declaration.Rule = namespace_declaration | type_declaration;
namespace_member_declarations.Rule = MakePlusRule(namespace_member_declarations, null, namespace_member_declaration);
type_declaration.Rule = class_declaration | struct_declaration | interface_declaration | enum_declaration | delegate_declaration;
//B.2.7. Classes
class_declaration.Rule = member_header + "class" + identifier + type_parameter_list_opt +
bases_opt + type_parameter_constraints_clauses_opt + class_body;
class_body.Rule = Lbr + member_declarations_opt + Rbr;
bases_opt.Rule = Empty | colon + base_type_list;
base_type_list.Rule = MakePlusRule(base_type_list, comma, qual_name_with_targs);
//Type parameters
type_parameter.Rule = attributes_opt + identifier;
type_parameters.Rule = MakePlusRule(type_parameters, comma, type_parameter);
type_parameter_list_opt.Rule = Empty | gen_lt + type_parameters + ">";
type_parameter_constraints_clause.Rule = "where" + type_parameter + colon + type_parameter_constraints;
type_parameter_constraints.Rule = MakePlusRule(type_parameter_constraints, comma, type_parameter_constraint);
type_parameter_constraints_clauses_opt.Rule = MakeStarRule(type_parameter_constraints_clauses_opt, null, type_parameter_constraints_clause);
//Note for post-processing - make sure the order is correct: new() is always last, etc. See p.503 of the spec
type_parameter_constraint.Rule = qual_name_with_targs | "class" | "struct" | ToTerm("new") + Lpar + Rpar;
//Class members
//Note: we split operator-declaration into two separate operator elements: bin/unary and conversion operators
// to avoid possible ambiguities and conflicts
member_declaration.Rule = constant_declaration | field_declaration | method_declaration
| property_declaration | event_declaration | indexer_declaration
| operator_declaration | conversion_operator_declaration
| constructor_declaration | destructor_declaration | type_declaration;
member_declaration.ErrorRule = SyntaxError + ";" | SyntaxError + "}" ;
member_declarations_opt.Rule = MakeStarRule(member_declarations_opt, null, member_declaration);
//Modifiers - see note #1 in Notes.txt file
modifier.Rule = ToTerm("new") | "public" | "protected" | "internal" | "private" | "static" | "virtual" | "sealed" |
"override" | "abstract" | "readonly" | "volatile" | "partial" | "extern"; //!!!
modifiers_opt.Rule = MakeStarRule(modifiers_opt, null, modifier);
//Joined member header - see note #2
member_header.Rule = attributes_opt + modifiers_opt;
constant_declaration.Rule = member_header + "const" + type_ref + constant_declarators + semi;
constant_declarator.Rule = identifier + "=" + expression;
constant_declarators.Rule = MakePlusRule(constant_declarators, comma, constant_declarator);
field_declaration.Rule = member_header + type_ref + variable_declarators + semi;
variable_declarator.Rule = identifier | identifier + "=" + elem_initializer;
variable_declarators.Rule = MakePlusRule(variable_declarators, comma, variable_declarator);
//See note #3 about merging type_parameter_list into type_arguments of the preceding qual_name.
method_declaration.Rule = member_header + type_ref + qual_name_with_targs // + type_parameter_list.Q()
+ formal_parameter_list_par + type_parameter_constraints_clauses_opt + method_body;
formal_parameter_list.Rule = fixed_parameters | fixed_parameters + comma + parameter_array | parameter_array;
formal_parameter_list_par.Rule = Lpar + Rpar | Lpar + formal_parameter_list + Rpar;
fixed_parameter.Rule = attributes_opt + parameter_modifier_opt + type_ref + identifier;
fixed_parameters.Rule = MakePlusRule(fixed_parameters, comma, fixed_parameter);
parameter_modifier_opt.Rule = Empty | "ref" | "out" | "this";
parameter_array.Rule = attributes_opt + "params" + type_ref + /*"[" + "]" + */ identifier;
method_body.Rule = block | semi;
// See note #4 about member-name
//TODO: add after-parse validation that no more than one accessor of each type is there.
property_declaration.Rule = member_header + type_ref + qual_name_with_targs/*member-name*/ + Lbr + accessor_declarations + Rbr;
accessor_declaration.Rule = attributes_opt + accessor_modifier_opt + accessor_name + block;
accessor_declarations.Rule = MakePlusRule(accessor_declarations, null, accessor_declaration);
accessor_name.Rule = ToTerm("get") | "set";
accessor_modifier_opt.Rule = Empty | "protected" | "internal" | "private" |
ToTerm("protected") + "internal" | ToTerm("internal") + "protected";
event_declaration.Rule = member_header + "event" + type_ref + event_body;
event_body.Rule = variable_declarators + semi | qual_name_with_targs + Lbr + event_accessor_declarations + Rbr;
event_accessor_declarations.Rule = add_accessor_declaration + remove_accessor_declaration |
remove_accessor_declaration + add_accessor_declaration;
add_accessor_declaration.Rule = attributes_opt + "add" + block;
remove_accessor_declaration.Rule = attributes_opt + "remove" + block;
//indexer
indexer_declaration.Rule = member_header + type_ref + indexer_name + "[" + formal_parameter_list + "]" +
Lbr + accessor_declarations + Rbr;
indexer_name.Rule = "this" | qual_name_with_targs + dot + "this";
//operator
// note: difference with specs - we separate unary/binary operators from conversion operator,
// and join binary and unary operator definitions, see note #5
operator_declaration.Rule = member_header + type_ref + "operator" + overloadable_operator + Lpar + operator_parameters + Rpar + block;
overloadable_operator.Rule = ToTerm("+") | "-" | "!" | "~" | "++" | "--" | "true" | "false" //unary operators
| "*" | "/" | "%" | "&" | "|" | "^" | "<<" | ">>" | "==" | "!=" | ">" | "<" | ">=" | "<=";
operator_parameters.Rule = operator_parameter | operator_parameter + comma + operator_parameter;
operator_parameter.Rule = type_ref + identifier;
conversion_operator_declaration.Rule = member_header + conversion_operator_kind +
"operator" + type_ref + Lpar + operator_parameter + Rpar + block;
conversion_operator_kind.Rule = ToTerm("implicit") | "explicit";
//constructor - also covers static constructor; the only difference is the word static
constructor_declaration.Rule = member_header + identifier + formal_parameter_list_par +
constructor_initializer_opt + block;
constructor_initializer_opt.Rule = Empty | colon + constructor_base + argument_list_par;
constructor_base.Rule = ToTerm("this") | "base";
destructor_declaration.Rule = member_header + // changed from Symbol("extern").Q()
"~" + identifier + Lpar + Rpar + block;
//B.2.8
struct_declaration.Rule = member_header + "struct" + identifier + type_parameter_list_opt + bases_opt
+ type_parameter_constraints_clauses_opt + struct_body;
struct_body.Rule = Lbr + member_declarations_opt + Rbr;
//B.2.9. Arrays
//B.2.10 Interface
interface_declaration.Rule = member_header + "interface" + identifier + type_parameter_list_opt + bases_opt
+ type_parameter_constraints_clauses_opt + interface_body;
interface_body.Rule = Lbr + interface_member_declarations + Rbr;
interface_member_declaration.Rule = interface_method_declaration | interface_property_declaration
| interface_event_declaration | interface_indexer_declaration;
interface_member_declarations.Rule = MakePlusRule(interface_member_declarations, null, interface_member_declaration);
interface_method_declaration.Rule = attributes_opt + new_opt + type_ref + identifier + type_parameter_list_opt +
formal_parameter_list_par + type_parameter_constraints_clauses_opt + semi;
//NOte: changing type to type_ref to fix the conflict
//Note: add after-parse validation that no more than one accessor of each type is there.
interface_property_declaration.Rule = attributes_opt + new_opt + type_ref + identifier + Lbr + interface_accessors + Rbr;
interface_accessor.Rule = attributes_opt + accessor_name + semi;
interface_accessors.Rule = MakePlusRule(interface_accessors, null, interface_accessor);
interface_event_declaration.Rule = attributes_opt + new_opt + "event" + type_ref + identifier;
interface_indexer_declaration.Rule = attributes_opt + new_opt + type_ref + "this" +
"[" + formal_parameter_list + "]" + Lbr + interface_accessors + Rbr;
new_opt.Rule = Empty | "new";
//B.2.11 Enums
enum_declaration.Rule = member_header + "enum" + identifier + enum_base_opt + Lbr + enum_member_declarations + Rbr + semi_opt;
enum_base_opt.Rule = Empty | colon + integral_type;
enum_member_declaration.Rule = attributes_opt + identifier | attributes_opt + identifier + "=" + expression;
enum_member_declarations.Rule = MakeListRule(enum_member_declarations, comma, enum_member_declaration, TermListOptions.PlusList | TermListOptions.AllowTrailingDelimiter);
//B.2.12 Delegates
delegate_declaration.Rule = member_header + "delegate" + type_ref + identifier +
type_parameter_list_opt + formal_parameter_list_par + type_parameter_constraints_clauses_opt + semi;
//B.2.13. Attributes
attributes_opt.Rule = MakeStarRule(attributes_opt, null, attribute_section);
attribute_section.Rule = "[" + attribute_target_specifier_opt + attribute_list + comma_opt + "]";
attribute_list.Rule = MakePlusRule(attribute_list, comma, attribute);
attribute.Rule = qual_name_with_targs + attribute_arguments_par_opt;
attribute_target_specifier_opt.Rule = Empty | attribute_target + colon;
attribute_target.Rule = ToTerm("field") | "event" | "method" | "param" | "property" | "return" | "type";
attribute_arguments_par_opt.Rule = Empty | Lpar + attribute_arguments_opt + Rpar;
attribute_arguments_opt.Rule = MakeStarRule(attribute_arguments_opt, comma, attr_arg);
attr_arg.Rule = identifier + "=" + expression | expression;
//Prepare term set for conflict resolution
_skipTokensInPreview.UnionWith(new Terminal[] { dot, identifier, comma, ToTerm("::"), comma, ToTerm("["), ToTerm("]") });
}
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
}
public SpecParser()
{
//Expr -> n | v | Expr BinOp Expr | UnOP Expr | ( Expr )
//BinOp -> + | - | * | / | **
//UnOp -> -
//ExprLine -> Expr EOF
//1. Terminals
//Terminal num = new NumberLiteral("number");
Terminal id = new IdentifierTerminal("id");
//Terminal stringLiteral = TerminalFactory.CreateCSharpString("stringLiteral");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "%", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//2. Non-Terminals
//Programs and declarations
var program = new NonTerminal("program");
var declarationOrStatementsInMainProgram = new NonTerminal("declarationOrStatementsInMainProgram");
var declaration = new NonTerminal("declaration");
var constantDeclaration = new NonTerminal("constantDeclaration");
var initializingValue = new NonTerminal("initializingValue");
var variableDeclaration = new NonTerminal("variableDeclaration");
//Types
var typeDeclaration = new NonTerminal("typeDeclaration");
var typeSpec = new NonTerminal("typeSpec");
var standardType = new NonTerminal("standardType");
var subrangeType = new NonTerminal("subrangeType");
var arrayType = new NonTerminal("arrayType");
var indexType = new NonTerminal("indexType");
var recordType = new NonTerminal("recordType");
var namedType = new NonTerminal("namedType");
//subprograms
var subprogramDeclaration = new NonTerminal("subprogramDeclaration");
var subprogramHeader = new NonTerminal("subprogramHeader");
var parameterDeclaration = new NonTerminal("parameterDeclaration");
var parameterType = new NonTerminal("parameterType");
var subprogramBody = new NonTerminal("subprogramBody");
//statements and input/output
var declarationsAndStatements = new NonTerminal("declarationsAndStatements");
var declarationOrStatement = new NonTerminal("declarationOrStatement");
var statement = new NonTerminal("statement");
var procedureCall = new NonTerminal("procedureCall");
var ifStatement = new NonTerminal("ifStatement");
var loopStatement = new NonTerminal("loopStatement");
var caseStatement = new NonTerminal("caseStatement");
var forStatement = new NonTerminal("forStatement");
var putStatement = new NonTerminal("putStatement");
var putItem = new NonTerminal("putItem");
var getStatement = new NonTerminal("getStatement");
var getItem = new NonTerminal("getItem");
var openStatement = new NonTerminal("openStatement");
var capability = new NonTerminal("capability");
var closeStatement = new NonTerminal("closeStatement");
var streamNumber = new NonTerminal("streamNumber");
var widthExpn = new NonTerminal("widthExpn");
var fractionWidth = new NonTerminal("fractionWidth");
var exponentWidth = new NonTerminal("exponentWidth");
var fileNumber = new NonTerminal("fileNumber");
var fileNumberVariable = new NonTerminal("fileNumberVariable");//this was not defined in the spec. The behaviour should conform to how the language works, but it's not guaranteed
var fileName = new NonTerminal("fileName"); //above is a variable declared of int type, and this is either string constant or variable
//References and Expressions
var variableReference = new NonTerminal("variableReference");
var reference = new NonTerminal("reference");
var componentSelector = new NonTerminal("componentSelector");
var booleanExpr = new NonTerminal("booleanExpr");
var compileTimeExpn = new NonTerminal("compileTimeExpn");
var expn = new NonTerminal("expn");
var explicitConstant = new NonTerminal("explicitConstant");
var infixOperator = new NonTerminal("infixOperator");
var prefixOperator = new NonTerminal("prefixOperator");
var substring = new NonTerminal("substring");
var substringPosition = new NonTerminal("substringPosition");
//Explicit Constants
Terminal explicitStringConstant = TerminalFactory.CreateCSharpString("explicitStringConstant");//new StringLiteral("explicitStringConstant");//new NonTerminal("explicitStringConstant");
Terminal explicitUnsignedRealConstant = new NumberLiteral("explicitUnsignedRealConstant", NumberOptions.Default);//new NonTerminal("explicitUnsignedRealConstant");
Terminal explicitUnsignedIntegerConstant = new NumberLiteral("explicitUnsignedIntegerConstant", NumberOptions.IntOnly | NumberOptions.NoDotAfterInt);//new NonTerminal("explicitUnsignedIntegerConstant");
//3. BNF Rules
//Programs and declarations
program.Rule = MakeStarRule(program, declarationOrStatementsInMainProgram);
declarationOrStatementsInMainProgram.Rule = declaration | statement | subprogramDeclaration;
declaration.Rule = constantDeclaration | variableDeclaration | typeDeclaration;
constantDeclaration.Rule = ToTerm("const") + id + ":=" + expn
| "const" + id + ":" + typeSpec + ":=" + initializingValue;
initializingValue.Rule = expn | "init" + "(" + MakePlusRule(initializingValue, ToTerm(","), initializingValue) + ")";
variableDeclaration.Rule = ToTerm("var") + MakePlusRule(variableDeclaration, ToTerm(","), id) + ":=" + expn
| "var" + MakePlusRule(variableDeclaration, ToTerm(","), id) + ":" + typeSpec + (":=" + initializingValue | Empty);
//Types
typeDeclaration.Rule = ToTerm("type") + id + ":" + typeSpec;
typeSpec.Rule = standardType | subrangeType | arrayType | recordType | namedType;
standardType.Rule = ToTerm("int") | "real" | "boolean" | "string" + ("(" + compileTimeExpn + ")" | Empty);
subrangeType.Rule = compileTimeExpn + ".." + expn;
arrayType.Rule = ToTerm("array") + MakePlusRule(arrayType, ToTerm(","), indexType) + "of" + typeSpec;
indexType.Rule = subrangeType | namedType;
recordType.Rule = ToTerm("record") + MakePlusRule(recordType, MakePlusRule(recordType, ToTerm(","), id) + ":" + typeSpec) + "end" + "record";
namedType.Rule = id;
//Subprograms
subprogramDeclaration.Rule = subprogramHeader + subprogramBody;
subprogramHeader.Rule = ToTerm("procedure") + id + ("(" + MakePlusRule(subprogramHeader, ToTerm(","), parameterDeclaration) + ")" | Empty)
| "function" + id + ("(" + MakePlusRule(subprogramHeader, ToTerm(","), parameterDeclaration) + ")" | Empty) + ":" + typeSpec;
parameterDeclaration.Rule = (ToTerm("var") | Empty) + MakePlusRule(parameterDeclaration, ToTerm(","), id) + ":" + parameterType;
parameterType.Rule = typeSpec | "string" + "(" + "*" + ")"
| "array" + MakePlusRule(parameterType, ToTerm(","), compileTimeExpn + ".." + "*") + "of" + typeSpec
| "array" + MakePlusRule(parameterType, ToTerm(","), compileTimeExpn + ".." + "*") + "of" + "string" + "(" + "*" + ")";
subprogramBody.Rule = declarationsAndStatements + "end" + id;
//Statements and Input/Output
declarationsAndStatements.Rule = MakePlusRule(declarationsAndStatements, declarationOrStatement);
declarationOrStatement.Rule = declaration | statement;
statement.Rule = variableReference + ":=" + expn
| procedureCall
| "assert" + booleanExpr
| "result" + expn
| ifStatement
| loopStatement
| "exit" + ("when" + booleanExpr | Empty)
| caseStatement
| forStatement
| putStatement
| getStatement
| openStatement
| closeStatement;
procedureCall.Rule = reference;
ifStatement.Rule = ToTerm("if") + booleanExpr + "then" + declarationsAndStatements + MakeStarRule(ifStatement, ToTerm("elsif") + booleanExpr + "then" + declarationsAndStatements) + ("else" + declarationsAndStatements | Empty) + "end" + "if";
loopStatement.Rule = ToTerm("loop") + declarationsAndStatements + "end" + "loop";
caseStatement.Rule = ToTerm("case") + expn + "of" + MakePlusRule(caseStatement, ToTerm("label") + MakePlusRule(caseStatement, ToTerm(","), compileTimeExpn) + ":" + declarationsAndStatements) + ("label" + ":" + declarationsAndStatements | Empty) + "end" + "case";
forStatement.Rule = ToTerm("for") + (id | Empty) + ":" + expn + ".." + expn + ("by" + expn | Empty) + declarationsAndStatements + "end" + "for"
| "for" + "decreasing" + (id | Empty) + ":" + expn + ".." + expn + ("by" + expn | Empty) + declarationsAndStatements + "end" + "for";
putStatement.Rule = ToTerm("put") + (":" + streamNumber + "," | Empty) + MakePlusRule(putStatement, ToTerm(","), putItem) + (".." | Empty);
putItem.Rule = expn + (":" + widthExpn + (":" + fractionWidth + (":" + exponentWidth | Empty) | Empty) | Empty) | "skip";
getStatement.Rule = ToTerm("get") + (":" + streamNumber + "," | Empty) + MakePlusRule(getStatement, ToTerm(","), getItem);
getItem.Rule = variableReference | "skip" | variableReference + ":" + "*" | variableReference + ":" + widthExpn;
openStatement.Rule = ToTerm("open") + ":" + fileNumberVariable + "," + fileName + "," + MakePlusRule(openStatement, ToTerm(","), capability);
capability.Rule = ToTerm("put") | "get";
closeStatement.Rule = ToTerm("close") + ":" + fileNumber;
streamNumber.Rule = widthExpn.Rule = fractionWidth.Rule = exponentWidth.Rule = fileNumber.Rule = expn;
//Following are guesses as to the rules, since the spec does not state the rules for them
fileNumberVariable.Rule = variableReference;
fileName.Rule = explicitStringConstant | variableReference;
//References and Expressions
variableReference.Rule = reference;
reference.Rule = id | reference + componentSelector;
componentSelector.Rule = "(" + MakePlusRule(componentSelector, ToTerm(","), expn) + ")" | "." + id;
booleanExpr.Rule = compileTimeExpn.Rule = expn;
expn.Rule = reference | explicitConstant | substring | expn + infixOperator + expn | prefixOperator + expn | "(" + expn + ")";
expn.SetFlag(TermFlags.InheritPrecedence);
explicitConstant.Rule = explicitUnsignedIntegerConstant | explicitUnsignedRealConstant | explicitStringConstant | "true" | "false";
infixOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "div" | "mod" | "**" | "<" | ">" | "=" | "<=" | ">=" | "not=" | "and" | "or";
//prefixOperator.Precedence = 70;
prefixOperator.Rule = ToTerm("+") | "-" | "not";
substring.Rule = reference + "(" + substringPosition + (".." + substringPosition | Empty) + ")";
substringPosition.Rule = expn | "*" + ("-" + expn | Empty);
this.Root = program;
//4. Set operator precendence and associativity
RegisterOperators(80, Associativity.Left, "**");//this is VERY odd, but Turing simplifies associativity by saying it's all left associative
RegisterOperators(60, "*","/","div","mod");
RegisterOperators(50, "+", "-");
RegisterOperators(40, "<", ">", "=", "<=", ">=", "not=");
RegisterOperators(30, "not");
RegisterOperators(20, "and");
RegisterOperators(10, "or");
//5. Register Parenthesis as punctuation symbols so they will not appear in the syntax tree
MarkPunctuation("(", ")", ",");
RegisterBracePair("(", ")");
//MarkTransient(Expr, BinOp, ParExpr);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
void InitializeComments()
{
//// comment:
//// single_line_comment
//// requires_comment
//// delimited_comment
//// single_line_comment:
//// # input_characters_opt
//// input_characters:
//// input_character
//// input_characters input_character
//// input_character:
//// Any Unicode character except a new_line_character
CommentTerminal comment = new CommentTerminal("comment", "#", "\r", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
}
public SqlGrammar()
: base(false)
{
//SQL is case insensitive
//Terminals
var comment = new CommentTerminal("comment", "/*", "*/");
var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(lineComment);
var number = new NumberLiteral("number");
var string_literal = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote);
var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple"); //covers normal identifiers (abc) and quoted id's ([abc d], "abc d")
var comma = ToTerm(",");
var dot = ToTerm(".");
var CREATE = ToTerm("CREATE");
var NULL = ToTerm("NULL");
var NOT = ToTerm("NOT");
var UNIQUE = ToTerm("UNIQUE");
var WITH = ToTerm("WITH");
var TABLE = ToTerm("TABLE");
var ALTER = ToTerm("ALTER");
var ADD = ToTerm("ADD");
var COLUMN = ToTerm("COLUMN");
var DROP = ToTerm("DROP");
var CONSTRAINT = ToTerm("CONSTRAINT");
var INDEX = ToTerm("INDEX");
var ON = ToTerm("ON");
var KEY = ToTerm("KEY");
var PRIMARY = ToTerm("PRIMARY");
var INSERT = ToTerm("INSERT");
var INTO = ToTerm("INTO");
var UPDATE = ToTerm("UPDATE");
var SET = ToTerm("SET");
var VALUES = ToTerm("VALUES");
var DELETE = ToTerm("DELETE");
var SELECT = ToTerm("SELECT");
var FROM = ToTerm("FROM");
var AS = ToTerm("AS");
var COUNT = ToTerm("COUNT");
var JOIN = ToTerm("JOIN");
var BY = ToTerm("BY");
//Non-terminals
var Id = new NonTerminal("Id");
var stmt = new NonTerminal("stmt");
var createTableStmt = new NonTerminal("createTableStmt");
var createIndexStmt = new NonTerminal("createIndexStmt");
var alterStmt = new NonTerminal("alterStmt");
var dropTableStmt = new NonTerminal("dropTableStmt");
var dropIndexStmt = new NonTerminal("dropIndexStmt");
var selectStmt = new NonTerminal("selectStmt");
var insertStmt = new NonTerminal("insertStmt");
var updateStmt = new NonTerminal("updateStmt");
var deleteStmt = new NonTerminal("deleteStmt");
var fieldDef = new NonTerminal("fieldDef");
var fieldDefList = new NonTerminal("fieldDefList");
var nullSpecOpt = new NonTerminal("nullSpecOpt");
var typeName = new NonTerminal("typeName");
var typeSpec = new NonTerminal("typeSpec");
var typeParamsOpt = new NonTerminal("typeParams");
var constraintDef = new NonTerminal("constraintDef");
var constraintListOpt = new NonTerminal("constraintListOpt");
var constraintTypeOpt = new NonTerminal("constraintTypeOpt");
var idlist = new NonTerminal("idlist");
var idlistPar = new NonTerminal("idlistPar");
var uniqueOpt = new NonTerminal("uniqueOpt");
var orderList = new NonTerminal("orderList");
var orderMember = new NonTerminal("orderMember");
var orderDirOpt = new NonTerminal("orderDirOpt");
var withClauseOpt = new NonTerminal("withClauseOpt");
var alterCmd = new NonTerminal("alterCmd");
var insertData = new NonTerminal("insertData");
var intoOpt = new NonTerminal("intoOpt");
var assignList = new NonTerminal("assignList");
var whereClauseOpt = new NonTerminal("whereClauseOpt");
var assignment = new NonTerminal("assignment");
var expression = new NonTerminal("expression");
var exprList = new NonTerminal("exprList");
var selRestrOpt = new NonTerminal("selRestrOpt");
var selList = new NonTerminal("selList");
var intoClauseOpt = new NonTerminal("intoClauseOpt");
var fromClauseOpt = new NonTerminal("fromClauseOpt");
var groupClauseOpt = new NonTerminal("groupClauseOpt");
var havingClauseOpt = new NonTerminal("havingClauseOpt");
var orderClauseOpt = new NonTerminal("orderClauseOpt");
var columnItemList = new NonTerminal("columnItemList");
var columnItem = new NonTerminal("columnItem");
var columnSource = new NonTerminal("columnSource");
var asOpt = new NonTerminal("asOpt");
var aliasOpt = new NonTerminal("aliasOpt");
var aggregate = new NonTerminal("aggregate");
var aggregateArg = new NonTerminal("aggregateArg");
var aggregateName = new NonTerminal("aggregateName");
var tuple = new NonTerminal("tuple");
var joinChainOpt = new NonTerminal("joinChainOpt");
var joinKindOpt = new NonTerminal("joinKindOpt");
var term = new NonTerminal("term");
var unExpr = new NonTerminal("unExpr");
var unOp = new NonTerminal("unOp");
var binExpr = new NonTerminal("binExpr");
var binOp = new NonTerminal("binOp");
var betweenExpr = new NonTerminal("betweenExpr");
var inExpr = new NonTerminal("inExpr");
var parSelectStmt = new NonTerminal("parSelectStmt");
var notOpt = new NonTerminal("notOpt");
var funCall = new NonTerminal("funCall");
var stmtLine = new NonTerminal("stmtLine");
var semiOpt = new NonTerminal("semiOpt");
var stmtList = new NonTerminal("stmtList");
var funArgs = new NonTerminal("funArgs");
var inStmt = new NonTerminal("inStmt");
//BNF Rules
this.Root = stmtList;
stmtLine.Rule = stmt + semiOpt;
semiOpt.Rule = Empty | ";";
stmtList.Rule = MakePlusRule(stmtList, stmtLine);
//ID
Id.Rule = MakePlusRule(Id, dot, Id_simple);
stmt.Rule = createTableStmt | createIndexStmt | alterStmt
| dropTableStmt | dropIndexStmt
| selectStmt | insertStmt | updateStmt | deleteStmt
| "GO" ;
//Create table
createTableStmt.Rule = CREATE + TABLE + Id + "(" + fieldDefList + ")" + constraintListOpt;
fieldDefList.Rule = MakePlusRule(fieldDefList, comma, fieldDef);
fieldDef.Rule = Id + typeName + typeParamsOpt + nullSpecOpt;
nullSpecOpt.Rule = NULL | NOT + NULL | Empty;
typeName.Rule = ToTerm("BIT") | "DATE" | "TIME" | "TIMESTAMP" | "DECIMAL" | "REAL" | "FLOAT" | "SMALLINT" | "INTEGER"
| "INTERVAL" | "CHARACTER"
// MS SQL types:
| "DATETIME" | "INT" | "DOUBLE" | "CHAR" | "NCHAR" | "VARCHAR" | "NVARCHAR"
| "IMAGE" | "TEXT" | "NTEXT";
typeParamsOpt.Rule = "(" + number + ")" | "(" + number + comma + number + ")" | Empty;
constraintDef.Rule = CONSTRAINT + Id + constraintTypeOpt;
constraintListOpt.Rule = MakeStarRule(constraintListOpt, constraintDef );
constraintTypeOpt.Rule = PRIMARY + KEY + idlistPar | UNIQUE + idlistPar | NOT + NULL + idlistPar
| "Foreign" + KEY + idlistPar + "References" + Id + idlistPar;
idlistPar.Rule = "(" + idlist + ")";
idlist.Rule = MakePlusRule(idlist, comma, Id);
//Create Index
createIndexStmt.Rule = CREATE + uniqueOpt + INDEX + Id + ON + Id + orderList + withClauseOpt;
uniqueOpt.Rule = Empty | UNIQUE;
orderList.Rule = MakePlusRule(orderList, comma, orderMember);
orderMember.Rule = Id + orderDirOpt;
orderDirOpt.Rule = Empty | "ASC" | "DESC";
withClauseOpt.Rule = Empty | WITH + PRIMARY | WITH + "Disallow" + NULL | WITH + "Ignore" + NULL;
//Alter
alterStmt.Rule = ALTER + TABLE + Id + alterCmd;
alterCmd.Rule = ADD + COLUMN + fieldDefList + constraintListOpt
| ADD + constraintDef
| DROP + COLUMN + Id
| DROP + CONSTRAINT + Id;
//Drop stmts
dropTableStmt.Rule = DROP + TABLE + Id;
dropIndexStmt.Rule = DROP + INDEX + Id + ON + Id;
//Insert stmt
insertStmt.Rule = INSERT + intoOpt + Id + idlistPar + insertData;
insertData.Rule = selectStmt | VALUES + "(" + exprList + ")";
intoOpt.Rule = Empty | INTO; //Into is optional in MSSQL
//Update stmt
updateStmt.Rule = UPDATE + Id + SET + assignList + whereClauseOpt;
assignList.Rule = MakePlusRule(assignList, comma, assignment);
assignment.Rule = Id + "=" + expression;
//Delete stmt
deleteStmt.Rule = DELETE + FROM + Id + whereClauseOpt;
//Select stmt
selectStmt.Rule = SELECT + selRestrOpt + selList + intoClauseOpt + fromClauseOpt + whereClauseOpt +
groupClauseOpt + havingClauseOpt + orderClauseOpt;
selRestrOpt.Rule = Empty | "ALL" | "DISTINCT";
selList.Rule = columnItemList | "*";
columnItemList.Rule = MakePlusRule(columnItemList, comma, columnItem);
columnItem.Rule = columnSource + aliasOpt;
aliasOpt.Rule = Empty | asOpt + Id;
asOpt.Rule = Empty | AS;
columnSource.Rule = aggregate | Id;
aggregate.Rule = aggregateName + "(" + aggregateArg + ")";
aggregateArg.Rule = expression | "*";
aggregateName.Rule = COUNT | "Avg" | "Min" | "Max" | "StDev" | "StDevP" | "Sum" | "Var" | "VarP";
intoClauseOpt.Rule = Empty | INTO + Id;
fromClauseOpt.Rule = Empty | FROM + idlist + joinChainOpt;
joinChainOpt.Rule = Empty | joinKindOpt + JOIN + idlist + ON + Id + "=" + Id;
joinKindOpt.Rule = Empty | "INNER" | "LEFT" | "RIGHT";
whereClauseOpt.Rule = Empty | "WHERE" + expression;
groupClauseOpt.Rule = Empty | "GROUP" + BY + idlist;
havingClauseOpt.Rule = Empty | "HAVING" + expression;
orderClauseOpt.Rule = Empty | "ORDER" + BY + orderList;
//Expression
exprList.Rule = MakePlusRule(exprList, comma, expression);
expression.Rule = term | unExpr | binExpr;// | betweenExpr; //-- BETWEEN doesn't work - yet; brings a few parsing conflicts
term.Rule = Id | string_literal | number | funCall | tuple | parSelectStmt;// | inStmt;
tuple.Rule = "(" + exprList + ")";
parSelectStmt.Rule = "(" + selectStmt + ")";
unExpr.Rule = unOp + term;
unOp.Rule = NOT | "+" | "-" | "~";
binExpr.Rule = expression + binOp + expression;
binOp.Rule = ToTerm("+") | "-" | "*" | "/" | "%" //arithmetic
| "&" | "|" | "^" //bit
| "=" | ">" | "<" | ">=" | "<=" | "<>" | "!=" | "!<" | "!>"
| "AND" | "OR" | "LIKE" | NOT + "LIKE" | "IN" | NOT + "IN" ;
betweenExpr.Rule = expression + notOpt + "BETWEEN" + expression + "AND" + expression;
notOpt.Rule = Empty | NOT;
//funCall covers some psedo-operators and special forms like ANY(...), SOME(...), ALL(...), EXISTS(...), IN(...)
funCall.Rule = Id + "(" + funArgs + ")";
funArgs.Rule = selectStmt | exprList;
inStmt.Rule = expression + "IN" + "(" + exprList + ")";
//Operators
RegisterOperators(10, "*", "/", "%");
RegisterOperators(9, "+", "-");
RegisterOperators(8, "=" , ">" , "<" , ">=" , "<=" , "<>" , "!=" , "!<" , "!>");
RegisterOperators(7, "^", "&", "|");
RegisterOperators(6, "NOT");
RegisterOperators(5, "AND");
RegisterOperators(4, "OR", "LIKE", "IN");
MarkPunctuation(",", "(", ")");
MarkPunctuation(asOpt, semiOpt);
//Note: we cannot declare binOp as transient because it includes operators "NOT LIKE", "NOT IN" consisting of two tokens.
// Transient non-terminals cannot have more than one non-punctuation child nodes.
base.MarkTransient(stmt, term, asOpt, aliasOpt, stmtLine, expression);
}
void InitializeComments()
{
//// comment:
//// single_line_comment
//// requires_comment
//// delimited_comment
//// single_line_comment:
//// # input_characters_opt
//// input_characters:
//// input_character
//// input_characters input_character
//// input_character:
//// Any Unicode character except a new_line_character
CommentTerminal comment = new CommentTerminal("comment", "#", "\r", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
//// delimited_comment:
//// <# delimited_comment_text_opt hashes >
//// delimited_comment_text:
//// delimited_comment_section
//// delimited_comment_text delimited_comment_section
//// delimited_comment_section:
//// >
//// hashes_opt not_greater_than_or_hash
//// hashes:
//// #
//// hashes #
//// not_greater_than_or_hash:
//// Any Unicode character except > or #
CommentTerminal delimited_comment = new CommentTerminal("delimited_comment", "<#", "#>");
NonGrammarTerminals.Add(delimited_comment);
}
public RefalGrammar() : base(true) // case sensitive
{
GrammarComments = "Refal-5 language interpreter based on Irony toolkit.";
// Terminals
var Number = new NumberLiteral("Number");
Number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
Number.AddPrefix("0x", NumberOptions.Hex);
Number.AddSuffix("u", TypeCode.UInt32);
Number.AddSuffix("l", TypeCode.Int64);
Number.AddSuffix("ul", TypeCode.UInt64);
Number.Options |= NumberOptions.IntOnly;
var CharLiteral = new StringLiteral("Char", "'", StringOptions.AllowsAllEscapes);
var StringLiteral = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var Identifier = new IdentifierTerminal("Identifier", "_-", "");
var LineComment = new CommentTerminal("LineComment", "*", "\n", "\r");
LineComment.ValidateToken += LineComment_ValidateToken;
var BlockComment = new CommentTerminal("BlockComment", "/*", "*/");
NonGrammarTerminals.Add(LineComment);
NonGrammarTerminals.Add(BlockComment);
// Non-terminals
var Program = new NonTerminal("Program", typeof(Program));
var Definition = new NonTerminal("Definition");
var Function = new NonTerminal("Function", typeof(DefinedFunction));
var External = new NonTerminal("External", typeof(AuxiliaryNode));
var IdentifierList = new NonTerminal("Identifier+", typeof(AuxiliaryNode));
var Block = new NonTerminal("Block", typeof(Block));
var Sentence = new NonTerminal("Sentence", typeof(Sentence));
var RSentence = new NonTerminal("RSentence", typeof(AuxiliaryNode));
var SentenceList = new NonTerminal("Sentence+", typeof(AuxiliaryNode));
var Pattern = new NonTerminal("Pattern", typeof(Pattern));
var PatternItem = new NonTerminal("PatternItem");
var PatternInParentheses = new NonTerminal("(Pattern)", typeof(ExpressionInBraces));
var Expression = new NonTerminal("Expression", typeof(Expression));
var ExpressionItem = new NonTerminal("ExpressionItem");
var ExpressionInParentheses = new NonTerminal("(Expression)", typeof(ExpressionInBraces));
var Var = new NonTerminal("Variable", Variable.CreateVariableNode);
var VarPrefix = new NonTerminal("VariablePrefix");
var VarIndex = new NonTerminal("VariableIndex");
var Symbol = new NonTerminal("Symbol", LiteralValueNodeHelper.InitNode);
var Call = new NonTerminal("Call", typeof(FunctionCall));
var FunctionName = new NonTerminal("FunctionName", typeof(AuxiliaryNode));
var WhereOrWithClause = new NonTerminal("WhereOrWithClause", typeof(Conditions));
var CommaOrAmpersand = new NonTerminal("CommaOrAmpersand");
var RWhereOrWithClause = new NonTerminal("RWhereOrWithClause", typeof(AuxiliaryNode));
var RExpressionOrWhereOrWithClause = new NonTerminal("RExpressionOrWhereOrWithClause");
var SemicolonOpt = new NonTerminal("[;]", Empty | ";");
var EntryOpt = new NonTerminal("[ENTRY]", Empty | "$ENTRY");
var Extern = new NonTerminal("Extern", ToTerm("$EXTRN") | "$EXTERN" | "$EXTERNAL");
// Rules
Root = Program;
Program.Rule = MakePlusRule(Program, Definition);
Definition.Rule = Function | External;
External.Rule = Extern + IdentifierList + ";";
IdentifierList.Rule = MakePlusRule(IdentifierList, ToTerm(","), Identifier);
Function.Rule = EntryOpt + Identifier + Block + SemicolonOpt;
Block.Rule = "{" + SentenceList + SemicolonOpt + "}";
SentenceList.Rule = MakePlusRule(SentenceList, ToTerm(";"), Sentence);
Sentence.Rule = Pattern + RSentence;
RSentence.Rule = "=" + Expression | WhereOrWithClause;
Pattern.Rule = MakeStarRule(Pattern, PatternItem);
PatternItem.Rule = Var | Symbol | PatternInParentheses;
PatternInParentheses.Rule = "(" + Pattern + ")";
Expression.Rule = MakeStarRule(Expression, ExpressionItem);
ExpressionItem.Rule = Call | Var | Symbol | ExpressionInParentheses;
ExpressionInParentheses.Rule = "(" + Expression + ")";
Var.Rule = VarPrefix + "." + VarIndex;
VarPrefix.Rule = ToTerm("e") | "s" | "t";
VarIndex.Rule = Number | Identifier;
Symbol.Rule = StringLiteral | CharLiteral | Number | "True" | "False" | Identifier;
Call.Rule = "<" + FunctionName + Expression + ">";
FunctionName.Rule = Identifier | "+" | "-" | "*" | "/";
WhereOrWithClause.Rule = CommaOrAmpersand + Expression + ":" + RWhereOrWithClause;
CommaOrAmpersand.Rule = ToTerm(",") | "&";
RWhereOrWithClause.Rule = Block // with-clause
| Pattern + RExpressionOrWhereOrWithClause; // where-clause
RExpressionOrWhereOrWithClause.Rule = ToTerm("=") + Expression | WhereOrWithClause;
// Punctuation, braces, transient terms, options
MarkPunctuation("(", ")");
MarkPunctuation("{", "}");
MarkPunctuation("<", ">");
MarkPunctuation("=", ",", "&", ";");
RegisterBracePair("(", ")");
RegisterBracePair("<", ">");
RegisterBracePair("{", "}");
MarkTransient(Definition, PatternItem, ExpressionItem, SemicolonOpt, EntryOpt, Extern, CommaOrAmpersand, VarPrefix, VarIndex, RExpressionOrWhereOrWithClause);
LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.SupportsBigInt | LanguageFlags.TailRecursive;
}
public STLGrammar()
: base(false)
{
#region Letters and Digits
/*
letter A | B | .. | Z | a | b | .. |z
digit 0 | 1 | .. | 9
bit digit 0|1| .. |7
binary digit 0 | 1 | _
hex digit digit | A | .. | F | a | .. | f | _
character letter | ASCII 128 | .. | ASCII 255 | _
first identifier character character | space
other identifier character character | digit | space
Local Variables (Local ToTerms) [ # ] identifier
*/
var semi = ToTerm(";", "semi");
var semi_opt = new NonTerminal("semi?", Empty | semi);
var dot = ToTerm(".", "dot");
var comma = ToTerm(",", "comma");
var comma_opt = new NonTerminal("comma_opt", Empty | comma);
var equal = ToTerm("=", "equal");
var digits = new NumberLiteral("decimal", NumberOptions.IntOnly | NumberOptions.DisableQuickParse);
var binarys = new NumberLiteral("binary", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Binary | NumberOptions.AllowUnderscore);
var octals = new NumberLiteral("octal", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Octal);
var hexs = new NumberLiteral("hex", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Hex | NumberOptions.AllowUnderscore);
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var global_variable = new NonTerminal("global_variable", typeof(Variable));
var local_variable = new NonTerminal("local_variable", typeof(Variable));
KeyTerm colon = ToTerm(":", "colon");
binarys.AddPrefix("2#", NumberOptions.Binary);
hexs.AddPrefix("16#", NumberOptions.Hex);
global_variable.SetFlag(TermFlags.IsConstant);
local_variable.SetFlag(TermFlags.IsConstant);
global_variable.Rule = identifier;
local_variable.Rule = "#" + identifier;
#endregion
#region Program Comments
/*
comment characters printable character CR
comment // { comment characters } CR
*/
var comment = new CommentTerminal("comment", "//", "\r", "\n");
var comment_opt = new NonTerminal("comment?");
var line_comment = new NonTerminal("line_comment");
var multi_line_comment = new NonTerminal("multi_line_comment");
var empty_line = new NonTerminal("empty_line");
var empty_lines = new NonTerminal("empty_line+");
var empty_lines_opt = new NonTerminal("empty_line*");
multi_line_comment.SetFlag(TermFlags.IsList);
empty_lines.SetFlag(TermFlags.IsList);
empty_lines_opt.SetFlag(TermFlags.IsListContainer);
comment_opt.Rule = comment | Empty;
line_comment.Rule = comment + NewLine;
multi_line_comment.Rule = multi_line_comment + line_comment | line_comment;
empty_line.Rule = NewLine | line_comment;
empty_lines.Rule = empty_lines + empty_line | empty_line;
empty_lines_opt.Rule = empty_lines | Empty;
#endregion
#region Instruction mnemonic terminal
// Bit logic
var bit_logic_mnemonic = new NonTerminal("bit_logic_mnemonic");
var clock_mnemonic = new NonTerminal("clock_mnemonic");
var communication_mnemonic = new NonTerminal("communication_mnemonic");
var compare_mnemonic = new NonTerminal("compare_mnemonic");
var convert_mnemonic = new NonTerminal("convert_mnemonic");
var counter_mnemonic = new NonTerminal("counter_mnemonic");
var floatpoint_math_mnemonic = new NonTerminal("floatpoint_math_mnemonic");
var integer_math_mnemonic = new NonTerminal("integer_math_mnemonic");
var logical_mnemonic = new NonTerminal("logical_mnemonic");
var move_mnemonic = new NonTerminal("move_mnemonic");
var program_control_mnemonic = new NonTerminal("program_control_mnemonic");
var shift_rotate_mnemonic = new NonTerminal("shift_rotate_mnemonic");
var string_mnemonic = new NonTerminal("string_mnemonic");
var table_mnemonic = new NonTerminal("table_mnemonic");
var timer_mnemonic = new NonTerminal("timer_mnemonic");
var subroutine_mnemonic = new NonTerminal("subroutine_mnemonic");
bit_logic_mnemonic.Rule =
ToTerm("LD") | "A" | "O" |
"LDN" | "AN" | "ON" |
"LDI" | "AI" | "OI" |
"LDNI" | "ANI" | "ONI" |
"NOT" | "EU" | "ED" | "ALD" | "OLD" |
"LPS" | "LDS" | "LRD" | "LPP" | "=" | "=I" |
"S" | "SI" | "R" | "RI" | "AENO" | "NOP";
clock_mnemonic.Rule =
ToTerm("TODR") | "TODW" | "TODRX" | "TODWX";
communication_mnemonic.Rule =
ToTerm("XMT") | "RCV" | "NETR" | "NETW" | "GPA" | "SPA";
compare_mnemonic.Rule =
ToTerm("LDB=") | "AB=" | "OB=" |
"LDB<>" | "AB<>" | "OB<>" |
"LDB>=" | "AB>=" | "OB>=" |
"LDB<=" | "AB<=" | "OB<=" |
"LDB>" | "AB>" | "OB>" |
"LDB<" | "AB<" | "OB<" |
"LDW=" | "AW=" | "OW=" |
"LDW<>" | "AW<>" | "OW<>" |
"LDW>=" | "AW>=" | "OW>=" |
"LDW<=" | "AW<=" | "OW<=" |
"LDW>" | "AW>" | "OW>" |
"LDW<" | "AW<" | "OW<" |
"LDD=" | "AD=" | "OD=" |
"LDD<>" | "AD<>" | "OD<>" |
"LDD>=" | "AD>=" | "OD>=" |
"LDD<=" | "AD<=" | "OD<=" |
"LDD>" | "AD>" | "OD>" |
"LDD<" | "AD<" | "OD<" |
"LDR=" | "AR=" | "OR=" |
"LDR<>" | "AR<>" | "OR<>" |
"LDR>=" | "AR>=" | "OR>=" |
"LDR<=" | "AR<=" | "OR<=" |
"LDR>" | "AR>" | "OR>" |
"LDR<" | "AR<" | "OR<" |
"LDS=" | "AS=" | "OS=" |
"LDS<>" | "AS<>" | "OS<>";
convert_mnemonic.Rule =
ToTerm("BTI") | "ITB" | "ITD" | "ITS" |
"DTI" | "DTR" | "DTS" |
"ROUND" | "TRUNC" | "RTS" |
"BCDI" | "IBCD" |
"ITA" | "DTA" | "RTA" | "ATH" | "HTA" |
"STI" | "STD" | "STR" |
"DECO" | "Encoder" | "SEG";
counter_mnemonic.Rule =
ToTerm("CTU") | "CTD" | "CTUD" | "HDEF" | "HSC" | "PLS";
floatpoint_math_mnemonic.Rule =
ToTerm("+R") | "-R" | "*R" | "/R" |
"SQRT" | "SIN" | "COS" | "TAN" | "LN" | "EXP" | "PID";
integer_math_mnemonic.Rule =
ToTerm("+I") | "-I" | "*I" | "/I" |
"+D" | "-D" | "*D" | "/D" |
"MUL" | "DIV" |
"INCB" | "INCW" | "INCD" |
"DECB" | "DECW" | "DECD";
logical_mnemonic.Rule =
ToTerm("INVB") | "INVW" | "INVD" |
"ANDB" | "ANDW" | "ANDD" |
"ORB" | "ORW" | "ORD" |
"XORB" | "XORW" | "XORD";
move_mnemonic.Rule =
ToTerm("MOVB") | "MOVW" | "MOVD" | "MOVR" |
"BMB" | "BMW" | "BMD" |
"SWAP" | "BIR" | "BIW";
program_control_mnemonic.Rule =
ToTerm("FOR") | "NEXT" | "JMP" | "LBL" |
"LSCR" | "SCRT" | "SCRE" | "CSCRE" |
"END" | "STOP" | "WDR" | "DLED";
shift_rotate_mnemonic.Rule =
ToTerm("SLB") | "SLW" | "SLD" |
"SRB" | "SRW" | "SRD" |
"RLB" | "RLW" | "RLD" |
"RRB" | "RRW" | "RRD" | "SHRB";
string_mnemonic.Rule =
ToTerm("SLEN") | "SCPY" | "SSCPY" | "SCAT" | "SFND" | "CFND";
table_mnemonic.Rule =
ToTerm("FILL") | "ATT" | "FND=" | "FND<>" | "FND<" | "FND>" | "LIFO" | "FIFO";
timer_mnemonic.Rule =
ToTerm("TON") | "TONR" | "TOF" | "BITIM" | "CITIM";
subroutine_mnemonic.Rule =
ToTerm("CALL") | "ENI" | "ENS";
#endregion
#region Constants
/*
Boolean constant TRUE | FALSE | ON | OFF Note: Case insensitive
constant descriptor B# | BYTE# | W# | WORD# | DW# | DWORD# Note: Case insensitive
unsigned integer [constant descriptor]digit {digit}
number digit {digit}
signed number [ + | - ] number
signed integer [constant descriptor]signed number
binary integer [constant descriptor]2# binary digit { binary digit }
hex integer [constant descriptor]16# hex digit { hex digit }
exponent ( E | e ) signed number
real constant signed number . {exponent}
real constant number {exponent}
real constant signed number . number {exponent}
printable character ASCII 32 | .. | ASCII 255 excluding DEL and ?
two character hex hex digit hex digit
character representation printable character | $$ | $ | $L | $l | $N | $n | $P | $p | $R | $r | $T | $t | $?| $"
$two character hex
Note: The leading $ sign is a control character (Also known as an escape code)
Escape Code Interpretation
$$ Single dollar sign
$? Single quotation mark character
$" Double quotation mark character
$L or $l A line feed character
$N or $n A new line character
$P or $p Form feed, new page
$R or $r Carriage return character
$T or $t Tab character
ASCII character constant [constant descriptor]'character representation'
ASCII string constant "character representation"
constant Boolean constant | binary digit | unsigned integer |
signed integer | binary integer | hex integer |
real constant | ASCII constant
*/
var real = new NumberLiteral("Real", NumberOptions.AllowSign);
var bool_constant = new NonTerminal("bool_constant", typeof(BoolConstrant));
var constant_descriptor = new NonTerminal("constant_descriptor", typeof(Descriptor));
var unsigned_integer = new NonTerminal("unsigned_integer", typeof(NumberConstrant));
var signed_number = new NumberLiteral("decimal", NumberOptions.IntOnly|NumberOptions.AllowSign);
var signed_integer = new NonTerminal("signed_integer", typeof(NumberConstrant));
var binary_integer = new NonTerminal("binary_integer", typeof(NumberConstrant));
var hex_integer = new NonTerminal("hex_integer", typeof(NumberConstrant));
var real_constant = new NonTerminal("real_constant", typeof(NumberConstrant));
var character_representation = new StringLiteral("character_representation", "'");
var ascii_constant = new NonTerminal("ascii_constant");
var string_constant = new StringLiteral("string_constant", "\"");
var constant = new NonTerminal("Constant");
bool_constant.Rule = ToTerm("TRUE") | "FALSE" | "ON" | "OFF";
constant_descriptor.Rule = (ToTerm("B") | "BYTE" | "W" | "WORD" | "D" | "DWORD") + "#" | Empty;
unsigned_integer.Rule = constant_descriptor + digits;
signed_integer.Rule = constant_descriptor + signed_number;
binary_integer.Rule = constant_descriptor + binarys;
hex_integer.Rule = constant_descriptor + hexs;
real_constant.Rule = real;
ascii_constant.Rule = constant_descriptor + character_representation;
constant.Rule = bool_constant | unsigned_integer | signed_integer |
binary_integer | hex_integer | real_constant |
ascii_constant | string_constant;
#endregion
#region Addressing
/*Addressing
discrete input I | E Note: Case insensitive
discrete output Q | A Note: Case insensitive
analog input AI | AE Note: Case insensitive
analog output AQ | AA Note: Case insensitive
db memory DB Note: Case insensitive
variable memory V Note: Case insensitive
flag memory M Note: Case insensitive
system memory SM Note: Case insensitive
Stage memory S Note: Case insensitive
accumulator AC Note: Case insensitive
Timer T Note: Case insensitive
counter C | Z Note: Case insensitive
high speed counter HC | HZ Note: Case insensitive
data block DB Note: Case insensitive
local memory L Note: Case insensitive
bit point unsigned number . 0 | 1 | ?| 7
size prefix B | W | D Note: Case insensitive
Direct prefix discrete input | discrete output | variable memory | flag memory | system memory | stage memory
peripheral prefix analog input | analog output
timer counter prefix timer | counter
bit address direct prefix [X] bit point
byte word dword address direct prefix size prefix unsigned number
peripheral address peripheral prefix [W] unsigned number
timer counter address timer counter prefix ((X unsigned number) | unsigned number)
high speed counter address high speed counter unsigned number
accumulator address accumulator [size prefix] unsigned number
db number DB unsigned number
db address [db number .] data block ([X] bit point) | (size prefix unsigned number)
Direct address bit address | byte word dword address | peripheral address |timer counter address | high speed counter address | accumulator address |db address
indirect address * ((accumulator [ D| d ]) | (variable memory D | d ) | (local memory D | d) | ([db number .] data block D | d)) unsigned number
address of & (variable memory | discrete input | discrete output | timer | counter | flag memory | system memory ([db number.] data block) size prefix unsigned number
*/
var address_term = new AddressTerm("address_term");
var address = new NonTerminal("address", typeof(Address));
address.Rule = address_term;
#endregion
#region Local Variable Declaration
/*
ob declaration [var declaration]
int declaration [var declaration]
sbr declaration [io var declaration] ob declarations
io var declaration [var input declaration] [var in out declaration] [var output declaration]
var input declaration VAR_INPUT CR decl_list END_VAR CR
var output declaration VAR_OUTPUT CR decl_list END_VAR CR
var in out declaration VAR_IN_OUT CR decl_list END_VAR CR
var declaration VAR CR decl_list END_VAR CR
decl list {identifier : complex type }; {comment}
Type Base type | user type | string type
complex type Base type | array type | struct type | user type | string type
init value constant | integer ( init value ) | init value , init value
base type BOOL | BYTE | WORD | DWORD | CHAR | INT | DINT | REAL |
*/
var base_type = new NonTerminal("base_type");
var init_value = new NonTerminal("init_value");
var complex_type = new NonTerminal("complex_type");
var type = new NonTerminal("type");
var decl = new NonTerminal("decl", typeof(Declaration));
var decl_line = new NonTerminal("decl_line");
var decl_list = new NonTerminal("decl+");
var decl_list_opt = new NonTerminal("decl*");
var var_input_decl = new NonTerminal("var_input_decl", typeof(VarDecl));
var var_output_decl = new NonTerminal("var_output_decl", typeof(VarDecl));
var var_in_out_decl = new NonTerminal("var_in_out_decl", typeof(VarDecl));
var var_decl = new NonTerminal("var_decl", typeof(VarDecl));
var var_input_decl_opt = new NonTerminal("var_input_decl?");
var var_output_decl_opt = new NonTerminal("var_output_decl?");
var var_in_out_decl_opt = new NonTerminal("var_in_out_decl?");
var var_decl_opt = new NonTerminal("var_decl?");
var var_decl_suffix = new NonTerminal("var_decl_suffix");
var io_var_decl = new NonTerminal("io_var_decl");
decl_list.SetFlag(TermFlags.IsList);
decl_list_opt.SetFlag(TermFlags.IsListContainer);
MarkTransient(decl_line, complex_type, base_type,
var_input_decl_opt, var_output_decl_opt, var_in_out_decl_opt);
base_type.Rule = ToTerm("BOOL") | "BYTE" | "WORD" | "DWORD" | "CHAR" | "INT" | "DINT" | "REAL";
init_value.Rule = init_value + comma + constant | constant | ToTerm("integer") + "(" + constant + ")";
complex_type.Rule = base_type;
type.Rule = base_type;
decl.Rule = identifier + ":" + complex_type + ";" + comment_opt + NewLine;
decl_line.Rule = decl | empty_line;
decl_list.Rule = decl_list + decl_line | decl_line;
decl_list_opt.Rule = decl_list | Empty;
var_decl_suffix.Rule = NewLine + decl_list_opt + "END_VAR" + NewLine;
var_input_decl.Rule = "VAR_INPUT" + var_decl_suffix;
var_output_decl.Rule = "VAR_OUTPUT" + var_decl_suffix;
var_in_out_decl.Rule = "VAR_IN_OUT" + var_decl_suffix;
var_decl.Rule = "VAR" + var_decl_suffix;
var_input_decl_opt.Rule = var_input_decl | Empty;
var_output_decl_opt.Rule = var_output_decl | Empty;
var_in_out_decl_opt.Rule = var_in_out_decl | Empty;
var_decl_opt.Rule = var_decl | Empty;
io_var_decl.Rule = var_input_decl_opt + var_output_decl_opt + var_in_out_decl_opt;
#endregion
#region Program Structure
/*Note:
Keywords are case insensitive unless otherwise noted.
Block title { white space } (TITLE = comment characters CR | comment)
Block comment {comment}
network title { white space } (TITLE = comment characters CR | comment)
network comment {comment}
line comment {comment}
code comment {comment}
network number { space | unsigned number }
operand { white space } global variable | local variable | constant | direct address | indirect address | address of
instruction mnemonic (letter | digit | _ ) { letter | digit | _ }
instruction instruction mnemonic [(white space) { white space } operand {(,| white space) { white space } operand}] ; code comment
statement list {instruction | line comment}
network NETWORK network number (CR | [network title] [network comment]) statement list
ob number OB unsigned number
organization block ORGANIZATION_BLOCK (ob number) (CR | [block title] [block comment])ob declarations BEGIN [network] END_ORGANIZATION_BLOCK CR
sbr number SBR unsigned number
subroutine block SUBROUTINE_BLOCK (sbr number) (CR [block title] [block comment])sbr declarations BEGIN [network] END_SUBROUTINE_BLOCK CR
int number INT unsigned_number
interrupt block INTERRUPT_BLOCK (int number) (CR [block title] [block comment]) int declarations BEGIN [network] END_INTERRUPT_BLOCK CR
*/
var title_content = new FreeTextLiteral("Title", "\r", "\n");
var title = new NonTerminal("title");
var title_opt = new NonTerminal("title?");
var network_number = new NonTerminal("network_number");
var mnemonic = new NonTerminal("mnemonic");
var operand = new NonTerminal("operand");
var operand_list = new NonTerminal("operand+");
var operand_list_opt = new NonTerminal("operand*");
var instruction = new NonTerminal("instruction", typeof(Instruction));
var statement = new NonTerminal("statement");
var statement_list = new NonTerminal("statement_list");
var statement_list_opt = new NonTerminal("statement*");
var network = new NonTerminal("network", typeof(Network));
var network_list = new NonTerminal("network+");
var network_list_opt = new NonTerminal("network*", typeof(NodeList));
var ob_number = new NonTerminal("ob_number");
var block_1 = new NonTerminal("block_1");
var block_2 = new NonTerminal("block_2");
var organization_block = new NonTerminal("organization_block", typeof(POU));
var sbr_number = new NonTerminal("sbr_number");
var subroutine_block = new NonTerminal("subroutine_block", typeof(POU));
var int_number = new NonTerminal("int_number");
var interrupt_block = new NonTerminal("interrupt_block", typeof(POU));
var subroutine_block_list = new NonTerminal("subroutine_block+");
var interrupt_block_list = new NonTerminal("interrupt_block+");
var subroutine_block_list_opt = new NonTerminal("subroutine_block*", typeof(NodeList));
var interrupt_block_list_opt = new NonTerminal("interrupt_block*", typeof(NodeList));
var program = new NonTerminal("program", typeof(Block));
operand_list.SetFlag(TermFlags.IsList);
statement_list.SetFlag(TermFlags.IsList);
network_list.SetFlag(TermFlags.IsList);
subroutine_block_list.SetFlag(TermFlags.IsList);
interrupt_block_list.SetFlag(TermFlags.IsList);
operand_list_opt.SetFlag(TermFlags.IsListContainer);
statement_list_opt.SetFlag(TermFlags.IsListContainer);
network_list_opt.SetFlag(TermFlags.IsListContainer);
subroutine_block_list_opt.SetFlag(TermFlags.IsListContainer);
interrupt_block_list_opt.SetFlag(TermFlags.IsListContainer);
MarkTransient(constant, mnemonic, operand, statement);
mnemonic.Rule = bit_logic_mnemonic | clock_mnemonic | communication_mnemonic |
compare_mnemonic | convert_mnemonic | counter_mnemonic | floatpoint_math_mnemonic |
integer_math_mnemonic | logical_mnemonic | move_mnemonic | program_control_mnemonic |
shift_rotate_mnemonic | string_mnemonic | table_mnemonic | timer_mnemonic | subroutine_mnemonic;
title.Rule = ToTerm("TITLE") + "=" + title_content + NewLine;
title_opt.Rule = title | Empty;
operand.Rule = global_variable | local_variable | constant | address;
operand_list.Rule = operand_list + comma + operand | operand;
operand_list_opt.Rule = operand_list | Empty;
instruction.Rule = mnemonic + operand_list_opt + semi_opt + comment_opt + NewLine;
statement.Rule = instruction | line_comment | NewLine;
statement_list.Rule = statement_list + statement | statement;
statement_list_opt.Rule = statement_list | Empty;
network_number.Rule = digits | Empty;
network.Rule = "NETWORK" + network_number + comment_opt + NewLine + title_opt + statement_list_opt;
network_list.Rule = network_list + network | network;
network_list_opt.Rule = network_list | Empty;
block_1.Rule = identifier + ":" + identifier + NewLine + title_opt + empty_lines_opt;
block_2.Rule = "BEGIN" + NewLine + network_list_opt;
organization_block.Rule =
"ORGANIZATION_BLOCK" + block_1 + var_decl_opt + block_2 + "END_ORGANIZATION_BLOCK" + NewLine;
subroutine_block.Rule =
"SUBROUTINE_BLOCK" + block_1 + io_var_decl + var_decl_opt + block_2 + "END_SUBROUTINE_BLOCK" + NewLine;
interrupt_block.Rule =
"INTERRUPT_BLOCK" + block_1 + var_decl_opt + block_2 + "END_INTERRUPT_BLOCK" + NewLine;
subroutine_block_list.Rule = subroutine_block_list + subroutine_block | subroutine_block;
interrupt_block_list.Rule = interrupt_block_list + interrupt_block | interrupt_block;
subroutine_block_list_opt.Rule = subroutine_block_list | Empty;
interrupt_block_list_opt.Rule = interrupt_block_list | Empty;
program.Rule = organization_block + subroutine_block_list_opt + interrupt_block_list_opt;
#endregion
//Set grammar root
this.Root = program;
this.WhitespaceChars = " \t\v";
MarkPunctuation("(", ")", ":", ";", ".", ",");
MarkPunctuation(semi_opt, comma_opt,
comment, comment_opt, line_comment, empty_line, empty_lines, empty_lines_opt);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF |
LanguageFlags.CreateAst;
}
public SLAngGrammer()
: base() {
StringLiteral stringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
StringLiteral charLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
NumberLiteral number = TerminalFactory.CreateCSharpNumber("Number");
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
CommentTerminal delimitedComment = new CommentTerminal("DelimitedComment", "/[", "]/");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "--", "\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(delimitedComment);
#region Terminals
KeyTerm colon = ToTerm(":");
KeyTerm dot = ToTerm(".");
KeyTerm comma = ToTerm(",");
KeyTerm propertyIs = ToTerm("->");
KeyTerm lbr = ToTerm("{");
KeyTerm rbr = ToTerm("}");
KeyTerm lpar = ToTerm("(");
KeyTerm rpar = ToTerm(")");
KeyTerm scopeIn = ToTerm("::");
KeyTerm suchThat = ToTerm("|");
KeyTerm _package = ToTerm("package");
KeyTerm context = ToTerm("context");
KeyTerm body = ToTerm("body");
KeyTerm def = ToTerm("def");
KeyTerm derive = ToTerm("derive");
KeyTerm In = ToTerm("in");
KeyTerm inv = ToTerm("inv");
KeyTerm let = ToTerm("let");
KeyTerm post = ToTerm("post");
KeyTerm pre = ToTerm("pre");
KeyTerm Static = ToTerm("static");
KeyTerm self = ToTerm("self");
KeyTerm result = ToTerm("result");
KeyTerm equalsTo = ToTerm("=");
KeyTerm _null = ToTerm("null");
KeyTerm invalid = ToTerm("invalid");
KeyTerm not = ToTerm("not");
KeyTerm and = ToTerm("and");
KeyTerm or = ToTerm("or");
KeyTerm xor = ToTerm("xor");
#endregion
#region NonTerminal
var specification = new NonTerminal("specification");
var specificationBody = new NonTerminal("specificationBody");
var package = new NonTerminal("package");
var packages = new NonTerminal("packages");
var oclPackage = new NonTerminal("oclPackage");
var emofOclPackage = new NonTerminal("emofOclPackage");
var packageBody = new NonTerminal("packageBody");
var packageBodyItem = new NonTerminal("packageBodyItem");
var contextExp = new NonTerminal("contextExp");
var classType = new NonTerminal("classType");
var enumeration = new NonTerminal("enumeration");
var primitive = new NonTerminal("primitive");
var primitiveType = new NonTerminal("primitiveType");
var primitiveTypes = new NonTerminal("primitiveTypes");
var delimitedIdentifier = new NonTerminal("delimitedIdentifier");
var classSignature = new NonTerminal("classSignature");
var classBody = new NonTerminal("classBody");
var classBodyItem = new NonTerminal("classBodyItem");
var invExp = new NonTerminal("invExp");
var functionDefination = new NonTerminal("functionDefination");
var attributeDiclaration = new NonTerminal("attributeDiclaration");
var emofAttributeDiclaration = new NonTerminal("emofAttributeDiclaration");
var oclAttributeDiclaration = new NonTerminal("oclAttributeDiclaration");
var type = new NonTerminal("type");
var expression = new NonTerminal("expression");
var customType = new NonTerminal("customType");
var collectionTpye = new NonTerminal("collectionTpye");
var fullType = new NonTerminal("fullType");
var globalType = new NonTerminal("globalType");
var setType = new NonTerminal("setType");
var orderedSetType = new NonTerminal("orderedSetType");
var sequenceType = new NonTerminal("sequenceType");
var bagType = new NonTerminal("bagType");
var functionSignature = new NonTerminal("functionSignature");
var functionSignatureBody = new NonTerminal("functionSignatureBody");
var functionBody = new NonTerminal("functionBody");
var oclFunctionSignature = new NonTerminal("oclFunctionSignature");
var emofFunctionSignature = new NonTerminal("emofFunctionSignature");
var argumentList = new NonTerminal("argumentList");
var variableDiclaration = new NonTerminal("variableDiclaration");
var emofFunctionBody = new NonTerminal("emofFunctionBody");
var oclFunctionBody = new NonTerminal("oclFunctionBody");
var singleValueCollectionMember = new NonTerminal("singleValueCollectionMember");
var booleanValueCollection = new NonTerminal("booleanValueCollection");
var letExp = new NonTerminal("letExp");
var ifThenElseExp = new NonTerminal("ifThenElseExp");
var collectionValueExp = new NonTerminal("collectionValueExp");
var sum = new NonTerminal("sum");
var size = new NonTerminal("size");
var first = new NonTerminal("first");
var last = new NonTerminal("last");
var at = new NonTerminal("at");
var indexOf = new NonTerminal("indexOf");
var countOperation = new NonTerminal("countOperation");
var maxOperation = new NonTerminal("maxOperation");
var minOperation = new NonTerminal("minOperation");
var valueExp = new NonTerminal("valueExp");
var includesOperation = new NonTerminal("includesOperation");
var includesAllOperation = new NonTerminal("includesAllOperation");
var excludesOperation = new NonTerminal("excludesOperation");
var excludesAllOperation = new NonTerminal("excludesAllOperation");
var isEmptyOperation = new NonTerminal("isEmptyOperation");
var notEmptyOperation = new NonTerminal("notEmptyOperation");
var specialIteratorBodyExp = new NonTerminal("specialIteratorBodyExp");
var existsExp = new NonTerminal("existsExp");
var forAllExp = new NonTerminal("forAllExp");
var isUniqueExp = new NonTerminal("isUniqueExp");
var anyExp = new NonTerminal("anyExp");
var oneExp = new NonTerminal("oneExp");
var selectExp = new NonTerminal("selectExp");
var includingOperation = new NonTerminal("includingOperation");
var excludingOperation = new NonTerminal("excludingOperation");
var collect = new NonTerminal("collect");
var subOrderedSet = new NonTerminal("subOrderedSet");
var symmetricDifference = new NonTerminal("symmetricDifference");
var prepend = new NonTerminal("prepend");
var append = new NonTerminal("append");
var insertAt = new NonTerminal("insertAt");
var intersection = new NonTerminal("intersection");
var union = new NonTerminal("union");
var asBag = new NonTerminal("asBag");
var asSequence = new NonTerminal("asSequence");
var asOrderdSet = new NonTerminal("asOrderdSet");
var asSet = new NonTerminal("asSet");
var flatten = new NonTerminal("flatten");
var subSequence = new NonTerminal("subSequence");
var andExp = new NonTerminal("andExp");
var orExp = new NonTerminal("orExp");
var notExp = new NonTerminal("notExp");
var xorExp = new NonTerminal("xorExp");
var impliesExp = new NonTerminal("impliesExp");
var comparisonOperator = new NonTerminal("comparisonOperator");
var arithmaticOperator = new NonTerminal("arithmaticOperator");
var oclInvExp = new NonTerminal("oclInvExp");
var emofInvExp = new NonTerminal("emofInvExp");
var operationContextExp = new NonTerminal("operationContextExp");
var attributeContextExp = new NonTerminal("attributeContextExp");
var classContextExp = new NonTerminal("classContextExp");
var classContextSignature = new NonTerminal("classContextSignature");
var attributeContextbody = new NonTerminal("attributeContextbody");
var attributeContextbodyItem = new NonTerminal("attributeContextbodyItem");
var deriveExp = new NonTerminal("deriveExp");
var initExp = new NonTerminal("initExp");
var operationContextBodyExps = new NonTerminal("operationContextBodyExps");
var operationContextSignature = new NonTerminal("operationContextSignature");
var operationContextBodyItem = new NonTerminal("operationContextBodyItem");
var preCondition = new NonTerminal("preCondition");
var postCondition = new NonTerminal("postCondition");
var bodyExp = new NonTerminal("bodyExp");
var iterateExp = new NonTerminal("iterateExp");
var productExp = new NonTerminal("productExp");
var tupleExp = new NonTerminal("tupleExp");
var rejectExp = new NonTerminal("rejectExp");
var collection = new NonTerminal("collection");
var tuplElementList = new NonTerminal("tuplElementList");
var tupleElement = new NonTerminal("tupleElement");
var binaryOperator = new NonTerminal("binaryOperator");
var parameterList = new NonTerminal("parameterList");
var structuralExp = new NonTerminal("structuralExp");
var setLiteral = new NonTerminal("setLiteral");
var bagLiteral = new NonTerminal("orderedSetLiteral");
var orderedSetLiteral = new NonTerminal("");
var sequenceLiteral = new NonTerminal("sequenceLiteral");
var tupleLiteral = new NonTerminal("tupleLiteral");
var literalList = new NonTerminal("literalList");
var iteratorList = new NonTerminal("iteratorList");
var iteratorInitializationList = new NonTerminal("iteratorInitializationList");
var iteratorInitialization = new NonTerminal("iteratorInitialization");
var collectionValue = new NonTerminal("collectionValue");
var ArrayType = new NonTerminal("ArrayType");
var binaryBooleanOperator = new NonTerminal("binaryBooleanOperator");
var oclIsTypeOf = new NonTerminal("oclIsTypeOf");
var ValueExp = new NonTerminal("ValueExp");
var unValueExp = new NonTerminal("unValueExp");
var instanceMemberAccess = new NonTerminal("instanceMemberAccess");
var instanceMathodAccess = new NonTerminal("instanceMathodAccess");
#endregion
#region Rules
#region specification
specification.Rule = "specification" + identifier + lbr + specificationBody + rbr;
specificationBody.Rule = MakePlusRule(packages, package);
#endregion
#region package
package.Rule = oclPackage | emofOclPackage;
oclPackage.Rule = _package + identifier + packageBody + "endpackage";
emofOclPackage.Rule = _package + identifier + lbr + packageBody + rbr;
packageBody.Rule = MakeStarRule(packageBody, null, packageBodyItem);
packageBodyItem.Rule = primitive | enumeration | classType | contextExp | package;
#endregion
#region primitive
primitive.Rule = "primitive" + primitiveTypes + identifier + "IDENTICAL";
primitiveTypes.Rule = ToTerm("Real") | ToTerm("Integer") | ToTerm("String") | ToTerm("Boolean");
#endregion
#region enumeration
enumeration.Rule = "enumeration" + identifier + lbr + delimitedIdentifier + rbr;
delimitedIdentifier.Rule = MakePlusRule(delimitedIdentifier, comma, identifier);
#endregion
#region class
classType.Rule = classSignature + lbr + classBody + rbr;
classSignature.Rule = ToTerm("class") + identifier
| ToTerm("abstract") + ToTerm("class") + identifier
| ToTerm("abstract") + ToTerm("class") + identifier + ToTerm("extends") + identifier
| ToTerm("class") + identifier + ToTerm("extends") + type;
classBody.Rule = MakeStarRule(classBody, classBodyItem);
classBodyItem.Rule = attributeDiclaration | functionDefination | invExp;
#endregion
#region attribute
attributeDiclaration.Rule = oclAttributeDiclaration | emofAttributeDiclaration;
oclAttributeDiclaration.Rule = def + colon + identifier + type + ReduceHere()
| def + colon + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere()
| def + colon + "attr" + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere()
| def + colon + "attr" + identifier + type + ReduceHere();
emofAttributeDiclaration.Rule = identifier + colon + type + ReduceHere()
| ToTerm("component") + identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere()
| ToTerm("component") + identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + equalsTo + expression + ReduceHere()
| identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + ToTerm("unique") + ReduceHere();
#endregion
#region type
type.Rule = primitiveTypes | customType;
customType.Rule = fullType | globalType | ArrayType | collectionTpye | tupleExp;
fullType.Rule = identifier + scopeIn + fullType | identifier + ReduceHere();
globalType.Rule = PreferShiftHere() + scopeIn + fullType
| PreferShiftHere() + scopeIn + ArrayType;
ArrayType.Rule = fullType + "[" + "*" + "]"
| fullType + "[" + identifier + "]"
| fullType + "[" + number + "]"
| fullType + "[" + number + comma + number + "]"
| fullType + "[" + number + comma + "*" + "]";
collectionTpye.Rule = setType | orderedSetType | sequenceType | bagType | collection;
setType.Rule = "Set(" + customType + ")";
orderedSetType.Rule = "OrderedSet(" + customType + ")";
sequenceType.Rule = "Sequence(" + customType + ")";
bagType.Rule = "Bag(" + customType + ")";
collection.Rule = "Collection(" + customType + ")";
tupleExp.Rule = "Tuple" + lbr + argumentList + rbr;
#endregion
#region function
functionDefination.Rule = functionSignature + functionBody;
functionSignature.Rule = oclFunctionSignature | emofFunctionSignature;
oclFunctionSignature.Rule = def + colon + functionSignatureBody;
functionSignatureBody.Rule = identifier + lpar + argumentList + rpar + colon + type
| identifier + lpar + argumentList + rpar + colon + type + ToTerm("ordered") + ToTerm("unique")
| identifier + lpar + argumentList + rpar + colon;
argumentList.Rule = MakeStarRule(argumentList, comma, variableDiclaration);
variableDiclaration.Rule = identifier + PreferShiftHere() + colon + type;
emofFunctionSignature.Rule = functionSignatureBody;
functionBody.Rule = oclFunctionBody | emofFunctionBody;
oclFunctionBody.Rule = equalsTo + expression;
emofFunctionBody.Rule = equalsTo + lbr + expression + rbr;
#endregion
#region expression
expression.Rule = valueExp | structuralExp;
#endregion
#region valueExp
valueExp.Rule = // ValueExp + ReduceHere() |
unValueExp + ReduceHere()
| valueExp + PreferShiftHere() + binaryOperator + valueExp
| ToTerm("not") + valueExp
| lpar + valueExp + rpar;
#endregion
#region unValueExp
unValueExp.Rule = booleanValueCollection
| ToTerm("false") | ToTerm("true")
| collectionValue
| tupleLiteral
| singleValueCollectionMember
| collectionValueExp
| iterateExp
| stringLiteral
| charLiteral
| number
| self
| oclIsTypeOf
| unValueExp + lpar + parameterList + rpar
| instanceMemberAccess
| instanceMathodAccess
| ToTerm("-") + number;
#endregion
#region ValueExp
ValueExp.Rule = fullType + dot + instanceMemberAccess
| globalType + dot + instanceMemberAccess
| ValueExp + dot + identifier + lpar + parameterList + rpar;
#endregion
#region instanceMemberAccess
instanceMemberAccess.Rule = MakePlusRule(instanceMemberAccess, dot, identifier);
instanceMathodAccess.Rule = unValueExp + dot + identifier + lpar + parameterList + rpar;
#endregion
#region parameterList
parameterList.Rule = MakeStarRule(parameterList, comma, expression);
#endregion
#region booleanExp
booleanValueCollection.Rule = includesOperation | includesAllOperation | excludesOperation | excludesAllOperation
| isEmptyOperation | notEmptyOperation | existsExp | forAllExp | isUniqueExp | anyExp | oneExp;
#endregion
#region oclBuildInMethods
oclIsTypeOf.Rule = valueExp + dot + ToTerm("oclIsTypeOf") + lpar + type + rpar;
#endregion
#region binaryOperator
binaryOperator.Rule = comparisonOperator | arithmaticOperator | binaryBooleanOperator;
arithmaticOperator.Rule = ToTerm("/") | ToTerm("div") | ToTerm("*") | ToTerm("+") | ToTerm("-");
comparisonOperator.Rule = ToTerm(">") | ToTerm("<") | ToTerm(">=") | ToTerm("<=") | ToTerm("<>") | equalsTo;
binaryBooleanOperator.Rule = ToTerm("and") | ToTerm("or") | ToTerm("xor") | ToTerm("implies");
#endregion
#region booleanValueCollection
includesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includes") + lpar + valueExp + rpar;
includesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includesAll") + lpar + identifier + rpar;
excludesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludes") + lpar + identifier + rpar;
excludesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludesAll") + lpar + identifier + rpar;
isEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isEmpty") + lpar + rpar;
notEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("notEmpty") + lpar + rpar;
existsExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("exists") + lpar + specialIteratorBodyExp + rpar;
forAllExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("forAll") + lpar + specialIteratorBodyExp + rpar;
isUniqueExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isUnique") + lpar + specialIteratorBodyExp + rpar;
anyExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("any") + lpar + specialIteratorBodyExp + rpar;
oneExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("one") + lpar + specialIteratorBodyExp + rpar;
specialIteratorBodyExp.Rule = delimitedIdentifier + colon + type + suchThat + valueExp
| argumentList + suchThat + valueExp
| valueExp;
#endregion
#region collectionValue
collectionValue.Rule = setLiteral | bagLiteral | orderedSetLiteral | sequenceLiteral;
setLiteral.Rule = "Set" + lbr + literalList + rbr
| "Set" + lpar + type + rpar + lbr + literalList + rbr;
bagLiteral.Rule = "Bag" + lbr + literalList + rbr
| "Bag" + lpar + type + rpar + lbr + literalList + rbr;
orderedSetLiteral.Rule = "OrderedSet" + lbr + literalList + rbr
| "OrderedSet" + lpar + type + rpar + lbr + literalList + rbr;
sequenceLiteral.Rule = "Sequence" + lbr + literalList + rbr
| "Sequence" + lpar + type + rpar + lbr + literalList + rbr;
literalList.Rule = MakeStarRule(literalList, comma, valueExp);
tupleLiteral.Rule = "Tuple" + lbr + tuplElementList + rbr;
tuplElementList.Rule = MakePlusRule(tuplElementList, comma, tupleElement);
tupleElement.Rule = variableDiclaration + equalsTo + valueExp | identifier + equalsTo + valueExp;
collectionValueExp.Rule = includingOperation | excludingOperation | selectExp | rejectExp
| union | intersection | insertAt | append | prepend | symmetricDifference | subOrderedSet | collect | productExp
| subSequence | flatten | asSet | asOrderdSet | asSequence | asBag;
includingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("including") + lpar + identifier + rpar;
excludingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excluding") + lpar + identifier + rpar;
selectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("select") + lpar + specialIteratorBodyExp + rpar;
rejectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("reject") + lpar + specialIteratorBodyExp + rpar;
union.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("union") + lpar + valueExp + rpar;
intersection.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("intersection") + lpar + identifier + rpar;
insertAt.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("insertAt") + lpar + number + comma + identifier + rpar;
append.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("append") + lpar + identifier + rpar;
prepend.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("prepend") + lpar + identifier + rpar;
symmetricDifference.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("symmetricDifference") + lpar + identifier + rpar;
subOrderedSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subOrderedSet") + lpar + number + comma + number + rpar;
collect.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + specialIteratorBodyExp + rpar
| valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + identifier + rpar
| valueExp + dot + identifier + lpar + argumentList + rpar
| valueExp + PreferShiftHere() + propertyIs + identifier + lpar + argumentList + rpar;
productExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("product") + lpar + identifier + rpar;
subSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subSequence") + lpar + number + comma + number + rpar;
flatten.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("flatten") + lpar + rpar;
asSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSet") + lpar + rpar;
asOrderdSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asOrderdSet") + lpar + rpar;
asSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSequence") + lpar + rpar;
asBag.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asBag") + lpar + rpar;
#endregion
#region singleValueCollectionMember
singleValueCollectionMember.Rule = maxOperation | minOperation | countOperation | at | indexOf | first | last | sum | size;
maxOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "max" + lpar + rpar;
minOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "min" + lpar + rpar;
countOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "count" + lpar + identifier + rpar;
at.Rule = valueExp + PreferShiftHere() + propertyIs + "at" + lpar + identifier + rpar;
indexOf.Rule = valueExp + PreferShiftHere() + propertyIs + "indexOf" + lpar + identifier + rpar;
first.Rule = valueExp + PreferShiftHere() + propertyIs + "first" + lpar + rpar;
last.Rule = valueExp + PreferShiftHere() + propertyIs + "last" + lpar + rpar;
sum.Rule = valueExp + PreferShiftHere() + propertyIs + "sum" + lpar + rpar;
size.Rule = valueExp + PreferShiftHere() + propertyIs + "size" + lpar + rpar;
#endregion
#region iterateExp
iterateExp.Rule = valueExp + PreferShiftHere() + propertyIs + "iterate" + lpar + iteratorList + ";"
+ iteratorInitializationList + suchThat + expression + rpar;
iteratorList.Rule = MakePlusRule(iteratorList, comma, variableDiclaration);
iteratorInitializationList.Rule = MakePlusRule(iteratorInitializationList, comma, iteratorInitialization);
iteratorInitialization.Rule = variableDiclaration + equalsTo + valueExp;
#endregion
#region structuralExp
structuralExp.Rule = ifThenElseExp | letExp;
#endregion
#region ifThenElseExp
ifThenElseExp.Rule = "if" + valueExp + "then" + expression + "endif"
| "if" + valueExp + "then" + expression + "else" + expression + "endif";
#endregion
#region letExp
letExp.Rule = let + variableDiclaration + equalsTo + valueExp + In + expression
| let + identifier + equalsTo + valueExp + In + expression;
#endregion
#region invExp
invExp.Rule = oclInvExp | emofInvExp;
oclInvExp.Rule = inv + identifier + colon + expression
| inv + colon + expression;
emofInvExp.Rule = "invariant" + lbr + expression + rbr;
#endregion
#region contextExp
contextExp.Rule = classContextExp | attributeContextExp | operationContextExp;
#endregion
#region classContextExp
classContextExp.Rule = classContextSignature + classBody;
classContextSignature.Rule = context + type
| context + identifier + colon + type;
classBody.Rule = MakePlusRule(classBody, null, classBodyItem);
classBodyItem.Rule = invExp | attributeDiclaration | functionDefination;
#endregion
#region attributeContextExp
attributeContextExp.Rule = context + type + colon + type + attributeContextbody;
attributeContextbody.Rule = MakePlusRule(attributeContextbody, null, attributeContextbodyItem);
attributeContextbodyItem.Rule = initExp | deriveExp;
#endregion
#region initExp
initExp.Rule = ToTerm("init") + colon + equalsTo + valueExp;
#endregion
#region deriveExp
deriveExp.Rule = ToTerm("derive") + colon + expression;
#endregion
#region operationContextExp
operationContextExp.Rule = operationContextSignature + invExp + operationContextBodyExps;
operationContextSignature.Rule = context + customType + PreferShiftHere() + scopeIn + functionSignature;
operationContextBodyExps.Rule = MakePlusRule(operationContextBodyExps, null, operationContextBodyItem);
operationContextBodyItem.Rule = preCondition | bodyExp | postCondition;
#endregion
#region preCondition
preCondition.Rule = pre + identifier + colon + valueExp
| pre + colon + valueExp;
#endregion
#region bodyExp
bodyExp.Rule = body + colon + expression;
#endregion
#region postCondition
postCondition.Rule = post + colon + valueExp
| post + identifier + colon + valueExp;
#endregion
#endregion
#region Operator,punctuation
MarkPunctuation(",", "(", ")", "{", "}", "[", "]", ":");
MarkMemberSelect(".", "->"); //dot, propertyIs);
RegisterOperators(1, lpar, rpar);
RegisterOperators(2, "let", "in");
RegisterOperators(3, letExp, In);
RegisterOperators(4, dot, scopeIn);
RegisterOperators(5, not);
RegisterOperators(6, "*", "/");
RegisterOperators(7, letExp, In);
RegisterOperators(8, dot, scopeIn);
RegisterOperators(9, "+", "-");
RegisterOperators(10, "<", ">", "<=", ">=");
RegisterOperators(11, "=", "<>");
RegisterOperators(12, and);
RegisterOperators(12, "div", "implies");
RegisterOperators(13, or);
RegisterOperators(14, xor);
RegisterOperators(15, "=", "<>");
#endregion
this.Root = specification;
}
/// <summary>
///
/// </summary>
public MrtGrammar()
: base(true)
{
NonGrammarTerminals.Add (NewLine);
#region Numbers Strings Identifiers
var comment = new CommentTerminal ("comment", "#", "\n", "\r");
var number = new NumberLiteral ("number", NumberOptions.AllowSign | NumberOptions.AllowStartEndDot);
var str = new StringLiteral ("path", "\"");
#endregion
#region Transformations
var lookAt = new NonTerminal ("look-at", typeof (Nodes.LookAtNode));
var scale = new NonTerminal ("scale", typeof(Nodes.ScaleNode));
var translate = new NonTerminal ("translate", typeof(Nodes.TranslateNode));
var rotate = new NonTerminal ("rotate", typeof(Nodes.RotateNode));
var reverseOrientation = new NonTerminal ("reverse-orientation", typeof(Nodes.ReverseOrientationNode));
var coordSysTransform = new NonTerminal ("coord-sys-transform", typeof(Nodes.CoordSysTransformNode));
var concatTransform = new NonTerminal ("concat-transform", typeof(Nodes.ConcatTransformNode));
var transformations = new NonTerminal ("translate", typeof(StatementListNode));
#endregion
var include = new NonTerminal ("include", typeof(Nodes.IncludeNode));
var attributeBegin = new NonTerminal ("attribute-begin", typeof(Nodes.AttributeBeginNode));
var attributeEnd = new NonTerminal ("attribute-end", typeof(Nodes.AttributeEndNode));
var worldBegin = new NonTerminal ("world-begin", typeof (Nodes.WorldBeginNode));
var worldEnd = new NonTerminal ("world-end", typeof(Nodes.WorldEndNode));
var transformBegin = new NonTerminal ("transform-begin", typeof(Nodes.TransformBeginNode));
var transformEnd = new NonTerminal ("transform-end", typeof(Nodes.TransformEndNode));
var paramList = new NonTerminal ("param-list");
var paramListContents = new NonTerminal ("param-list-contents", typeof(Nodes.ParamListContentNode));
var paramListEntry = new NonTerminal ("param-list-entry", typeof(Nodes.ParamListEntryNode));
var array = new NonTerminal ("array", typeof(Nodes.ArrayNode));
var stringArray = new NonTerminal ("string-array", typeof(Nodes.StringArrayNode));
var numArray = new NonTerminal ("num-array", typeof(Nodes.NumberArrayNode));
var camera = new NonTerminal ("camera", typeof(Nodes.CameraNode));
var film = new NonTerminal ("film", typeof(Nodes.FilmNode));
var sampler = new NonTerminal ("sampler", typeof(Nodes.SamplerNode));
var surfaceIntegrator = new NonTerminal ("surface-integrator", typeof(Nodes.SurfaceIntegratorNode));
var volumeIntegrator = new NonTerminal ("volume-integrator", typeof(Nodes.VolumeIntegratorNode));
var texture = new NonTerminal ("texture", typeof(Nodes.TextureNode));
var shape = new NonTerminal ("shape", typeof(Nodes.ShapeNode));
var pixelFilter = new NonTerminal ("pixel-filter", typeof(Nodes.PixelFilterNode));
var material = new NonTerminal ("material", typeof(Nodes.MaterialNode));
var namedMaterial = new NonTerminal ("named-material", typeof(Nodes.NamedMaterialNode));
var lightSource = new NonTerminal ("light", typeof(Nodes.LightNode));
var areaLightSource = new NonTerminal ("area-light", typeof(Nodes.AreaLightSourceNode));
var plugin = new NonTerminal ("plugin", typeof(StatementListNode));
var statements = new NonTerminal ("statements", typeof(StatementListNode));
var scene = new NonTerminal ("scene", typeof(StatementListNode));
NonGrammarTerminals.Add (comment);
#region Rules
lookAt.Rule = "LookAt" + number + number + number + number + number + number + number + number + number;
scale.Rule = "Scale" + number + number + number;
translate.Rule = "Translate" + number + number + number;
rotate.Rule = "Rotate" + number + number + number + number;
reverseOrientation.Rule = "ReverseOrientation";
coordSysTransform.Rule = "CoordSysTransform" + str;
concatTransform.Rule = "ConcatTransform" + number + number + number + number + number + number + number + number + number + number + number + number + number + number + number + number;
transformations.Rule = scale | translate | rotate | lookAt | coordSysTransform | concatTransform;
include.Rule = "Include" + str;
attributeBegin.Rule = "AttributeBegin";
attributeEnd.Rule = "AttributeEnd";
worldBegin.Rule = "WorldBegin";
worldEnd.Rule = "WorldEnd";
paramList.Rule = paramListContents;
paramListContents.Rule = MakeStarRule (paramListContents, paramListEntry);
paramListEntry.Rule = str + array;
stringArray.Rule = MakeStarRule (stringArray, str);
numArray.Rule = MakeStarRule (numArray, number);
array.Rule = "[" + (stringArray | numArray) + "]";
transformBegin.Rule = "TransformBegin";
transformEnd.Rule = "TransformEnd";
camera.Rule = "Camera" + str + paramListContents;
film.Rule = "Film" + str + paramListContents;
sampler.Rule = "Sampler" + str + paramListContents;
surfaceIntegrator.Rule = "SurfaceIntegrator" + str + paramListContents;
volumeIntegrator.Rule = "VolumeIntegrator" + str + paramListContents;
shape.Rule = "Shape" + str + paramListContents;
pixelFilter.Rule = "PixelFilter" + str + paramListContents;
texture.Rule = "Texture" + str + str + str + paramListContents;
material.Rule = "Material" + str + paramListContents;
namedMaterial.Rule = "NamedMaterial" + str + str + paramListContents;
lightSource.Rule = "LightSource" + str + paramListContents;
areaLightSource.Rule = "AreaLightSource" + str + paramListContents;
plugin.Rule = camera | film | sampler | surfaceIntegrator | volumeIntegrator | shape | pixelFilter | texture | material | namedMaterial | lightSource | areaLightSource;
statements.Rule = transformations | include | attributeBegin | attributeEnd | paramListContents | plugin | statements | worldBegin | worldEnd | comment;
scene.Rule = MakePlusRule (scene, statements);
#endregion
#region Config
this.Root = scene;
this.LanguageFlags = LanguageFlags.CreateAst;
#endregion
}