FilterStringGrammar()
{
var propertyName = new IdentifierTerminal("propertyName");
var compareOp = new NonTerminal("compareOp");
compareOp.Rule = ToTerm(QueryComparisons.Equal) | ToTerm(QueryComparisons.NotEqual)
| ToTerm(QueryComparisons.LessThan) | ToTerm(QueryComparisons.LessThanOrEqual)
| ToTerm(QueryComparisons.GreaterThan) | ToTerm(QueryComparisons.GreaterThanOrEqual);
var stringLiteral = new StringLiteral("stringLiteral", "'", StringOptions.AllowsDoubledQuote);
var booleanLiteral = new ConstantTerminal("booleanLiteral");
booleanLiteral.Add("true", true);
booleanLiteral.Add("false", false);
var literal = new NonTerminal("literal");
literal.Rule = stringLiteral | booleanLiteral;
comparison = new NonTerminal("comparison");
comparison.Rule = propertyName + compareOp + literal;
var booleanOp = new NonTerminal("booleanOp");
booleanOp.Rule = ToTerm(TableOperators.And) | ToTerm(TableOperators.Or);
var booleanExpr = new NonTerminal("booleanExpr");
booleanOpExpr = new NonTerminal("booleanOpExpr");
booleanOpExpr.Rule = "(" + booleanExpr + ")" + booleanOp + "(" + booleanExpr + ")";
booleanExpr.Rule = comparison | booleanOpExpr;
Root = booleanExpr;
}
public MainGrammar() : base(false)
{
#region Terminals
var lK = ToTerm("[");
var rK = ToTerm("]");
var lP = ToTerm("(");
var rP = ToTerm(")");
var equal = ToTerm("=");
var dollar = ToTerm("$");
var comma = ToTerm(",");
var div = ToTerm("/");
var plus = ToTerm("+");
var less = ToTerm("-");
var times = ToTerm("*");
#endregion Terminals
#region SpecialTerminals
var ids = new IdentifierTerminal("id", "_");
var strs = new StringLiteral("string", "\"");
var nums = new NumberLiteral("int", NumberOptions.NoDotAfterInt, typeof(Int32));
#endregion
}
protected virtual void ConstructNameAndTypeRules()
{
Name = new IdentifierTerminal("Name");
Name.StartCharCategories.AddRange(new[] {
UnicodeCategory.UppercaseLetter,
UnicodeCategory.LowercaseLetter,
UnicodeCategory.TitlecaseLetter,
UnicodeCategory.ModifierLetter,
UnicodeCategory.OtherLetter,
UnicodeCategory.LetterNumber
});
Name.CharCategories.AddRange(Name.StartCharCategories);
Name.CharCategories.AddRange(new[] {
UnicodeCategory.DecimalDigitNumber,
UnicodeCategory.ConnectorPunctuation,
UnicodeCategory.SpacingCombiningMark,
UnicodeCategory.NonSpacingMark,
UnicodeCategory.Format
});
DotSeparatedName = NonTerminalThatIsNotAstElement("DotSeparatedName", n => new CompositeName(n.ChildNodes.Select(c => c.Token.Text).ToArray()));
TypeReference = NonTerminalWithSpecificType("TypeReference", n => (IAstTypeReference) new AstUnknownType(n.Child(Name).Token.Text)); // WIP
TypeReferenceListPlus = new NonTerminal("TypeReferenceListPlus");
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionGrammar"/> class.
/// </summary>
public ExpressionGrammar() : base(false)
{
var number = new NumberLiteral("Number");
number.DefaultIntTypes = new TypeCode[] { TypeCode.Int16, TypeCode.Int32, TypeCode.Int64 };
number.DefaultFloatType = TypeCode.Single;
var identifier = new IdentifierTerminal("Identifier");
var comma = ToTerm(",");
var BinOp = new NonTerminal("BinaryOperator", "operator");
var ParExpr = new NonTerminal("ParenthesisExpression");
var BinExpr = new NonTerminal("BinaryExpression", typeof(BinaryOperationNode));
var Expr = new NonTerminal("Expression");
var Term = new NonTerminal("Term");
var Program = new NonTerminal("Program", typeof(StatementListNode));
Expr.Rule = Term | ParExpr | BinExpr;
Term.Rule = number | identifier;
ParExpr.Rule = "(" + Expr + ")";
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = ToTerm("+") | "-" | "*" | "/";
RegisterOperators(10, "+", "-");
RegisterOperators(20, "*", "/");
MarkPunctuation("(", ")");
RegisterBracePair("(", ")");
MarkTransient(Expr, Term, BinOp, ParExpr);
this.Root = Expr;
}
static IdentifierTerminal createConstIdentifier()
{
var Id = new IdentifierTerminal("identifier");
Id.CaseRestriction = CaseRestriction.FirstUpper;
return(Id);
}
public ExpressionGrammar()
{
var Number = new NumberLiteral("Number");
var Var = new IdentifierTerminal("Var");
var conditional_expression = new NonTerminal("conditional_expression");
//conditional_expression.Rule = expression + PreferShiftHere() + qmark + expression + colon + expression;
//NonTerminal DataType = new NonTerminal("DataType");
NonTerminal DecSt = new NonTerminal("DecSt");
DecSt.Rule = "int" + Var + "=" + Number + ";" | "int" + Var + ";";
NonTerminal PrintSt = new NonTerminal("PrintSt");
PrintSt.Rule = "cout <<" + Var;
//NonTerminal IF = new NonTerminal("IF");
//IF.Rule = "if( + ;
NonTerminal stmt = new NonTerminal("stmt");
stmt.Rule = PrintSt | DecSt;
NonTerminal stmt1 = new NonTerminal("stmt");
stmt1.Rule = "begin{" + stmt + "}end;";
this.Root = DecSt;
}
public static IdentifierTerminal CreateNounId(string name)
{
IdentifierTerminal id = new IdentifierTerminal(name, IdOptions.AllowsEscapes | IdOptions.CanStartWithEscape);
id.CaseRestriction = CaseRestriction.FirstUpper;
//id.AddPrefix(":", IdOptions.IsNotKeyword | IdOptions.NameIncludesPrefix);
//From spec:
//Start char is "_" or letter-character, which is a Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
id.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
//UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber //Nl
});
//Internal chars
/* From spec:
* identifier-part-character: letter-character | decimal-digit-character | connecting-character | combining-character |
* formatting-character
*/
id.CharCategories.AddRange(id.StartCharCategories); //letter-character categories
id.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//Chars to remove from final identifier
id.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return(id);
}
public static IdentifierTerminal CreateCSharpIdentifier(String name)
{
IdentifierTerminal id = new IdentifierTerminal(name, IdFlags.AllowsEscapes | IdFlags.CanStartWithEscape);
id.AddPrefix("@", IdFlags.IsNotKeyword);
//From spec:
//Start char is "_" or letter-character, which is a Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
id.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber //Nl
});
//Internal chars
/* From spec:
identifier-part-character: letter-character | decimal-digit-character | connecting-character | combining-character |
formatting-character
*/
id.CharCategories.AddRange(id.StartCharCategories); //letter-character categories
id.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//Chars to remove from final identifier
id.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return id;
}
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 GramaticaUSQL() : base(caseSensitive: false)
{
#region EXPRESIONES REGULARES
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
#endregion
#region TERMINALES
var plus = ToTerm("+");
var minus = ToTerm("-");
var mult = ToTerm("*");
var div = ToTerm("/");
#endregion
#region NO TERMINALES
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E");
#endregion
#region GRAMATICA
S.Rule = E;
E.Rule = E + plus + E
| E + minus + E
| E + mult + E
| E + div + E
| numero
| id;
#endregion
#region PREFERENCIAS
this.Root = S;
#endregion
}
public TuringGrammar()
{
//Expr -> n | v | Expr BinOp Expr | UnOP Expr | ( Expr )
//BinOp -> + | - | * | / | **
//UnOp -> -
//ExprLine -> Expr EOF
//1. Terminals
Terminal n = new NumberLiteral("number");
Terminal v = new IdentifierTerminal("variable");
//2. Non-Terminals
NonTerminal Expr = new NonTerminal("Expr");
NonTerminal BinOp = new NonTerminal("BinOp");
NonTerminal UnOp = new NonTerminal("UnOp");
NonTerminal ExprLine = new NonTerminal("ExprLine");
//3. BNF rules
Expr.Rule = n | v | Expr + BinOp + Expr | UnOp + Expr | "(" + Expr + ")";
BinOp.Rule = new ImpliedSymbolTerminal("+") | "-" | "*" | "/" | "**";
UnOp.Rule = "-";
ExprLine.Rule = Expr + Eof;
this.Root = ExprLine;
//4. Set operator precenednce and associativity
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "**");
//5. Register Parenthesis as punctuation symbols so they will not appear in the syntax tree
MarkPunctuation("(", ")");
}
public UmbracoQueryGrammar() : base(false)
{
var contentTypeAlias = new IdentifierTerminal("contentType");
var route = new StringLiteral("route", "'");
var number = new NumberLiteral("number");
var query = new NonTerminal("query");
var limitModifier = new NonTerminal("limitModifier", typeof(LimitModifierNode));
var orderModifier = new NonTerminal("orderModifier", typeof(OrderModifierNode));
var contentType = new NonTerminal("contentType");
var content = new NonTerminal("content", typeof(ContentNode));
var limitedContent = new NonTerminal("limitedContent", typeof(LimitedContentNode));
var orderedContent = new NonTerminal("orderedContent", typeof(OrderedContentNode));
var source = new NonTerminal("source", typeof(SourceNode));
orderedContent.Rule = orderModifier + content | orderModifier + limitedContent;
limitedContent.Rule = limitModifier + content;
source.Rule = "from" + route;
content.Rule = contentType | contentType + source;
contentType.Rule = contentTypeAlias;
limitModifier.Rule = number;
query.Rule = content | limitedContent | orderedContent;
orderModifier.Rule = ToTerm("latest");
Root = query;
MarkTransient(contentType, query);
}
public XmlGrammar()
: base(false)
{
//Terminals
Terminal comment = new CommentTerminal("comment", "<!--", "-->");
NonGrammarTerminals.Add(comment);
StringLiteral stringLiteral = new StringLiteral("string", "\"", StringOptions.None);
Terminal stringContent = new ToTerminatorTerminal("StringContent", '<');
KeyTerm elementOpener = ToTerm("<");
KeyTerm closeElementOpener = ToTerm("</");
KeyTerm elementCloser = ToTerm(">");
KeyTerm openCloseElementCloser = ToTerm("/>");
KeyTerm equals = ToTerm("=");
KeyTerm xmlDeclOpen = ToTerm("<?");
KeyTerm xmlDeclClose = ToTerm("?>");
IdentifierTerminal attributeIdentifier = new IdentifierTerminal(AttributeIdentifier, ".", ".");
IdentifierTerminal elementIdentifier = new IdentifierTerminal(ElementIdentifier, ".-", ".-");
KeyTerm xmlDeclarationIdentifier = ToTerm("xml");
//Non Terminals
NonTerminal document = new NonTerminal("document");
NonTerminal elementStart = new NonTerminal("ElementStart");
NonTerminal elementEnd = new NonTerminal("ElementEnd");
NonTerminal openCloseElement = new NonTerminal("OpenCloseElement");
NonTerminal element = new NonTerminal("Element");
NonTerminal requiredElements = new NonTerminal("RequiredElements");
NonTerminal innerContent = new NonTerminal("InnerContent");
NonTerminal content = new NonTerminal("Content");
NonTerminal attribute = new NonTerminal("Attribute");
NonTerminal optionalAttribute = new NonTerminal("OptionalAttribute");
NonTerminal xmlDeclaration = new NonTerminal("XmlDeclaration");
NonTerminal optionalXmlDeclaration = new NonTerminal("OptionalXmlDeclaration");
//Rules
this.Root = document;
innerContent.Rule = element | stringContent;
content.Rule = MakeStarRule(content, innerContent);
attribute.Rule = attributeIdentifier + equals + stringLiteral;
optionalAttribute.Rule = MakeStarRule(optionalAttribute, attribute);
elementStart.Rule = elementOpener + elementIdentifier + optionalAttribute + elementCloser;
elementEnd.Rule = closeElementOpener + elementIdentifier + elementCloser;
openCloseElement.Rule = elementOpener + elementIdentifier + optionalAttribute + openCloseElementCloser;
element.Rule = (elementStart + content + elementEnd) | openCloseElement;
requiredElements.Rule = MakePlusRule(requiredElements, element);
xmlDeclaration.Rule = xmlDeclOpen + xmlDeclarationIdentifier + optionalAttribute + xmlDeclClose;
optionalXmlDeclaration.Rule = MakeStarRule(optionalXmlDeclaration, xmlDeclaration);
document.Rule = optionalXmlDeclaration + requiredElements;
MarkPunctuation(elementOpener, elementCloser, closeElementOpener, openCloseElementCloser, equals, xmlDeclOpen, xmlDeclClose);
MarkTransient(innerContent);
}
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;
}
/// <summary>
/// Class constructor and grammar definition
/// </summary>
public FtpGrammar()
: base(false)
{
// declare keywords
var openKeyword = ToTerm("open");
var changeDirKeyword = ToTerm("cd");
var dirKeyword = ToTerm("dir");
var listKeyword = ToTerm("ls");
var closeKeyword = ToTerm("close");
var getKeyword = ToTerm("get");
var byeKeyword = ToTerm("bye");
var backfolderKeyword = ToTerm("..");
var rootfolderKeyword = ToTerm(@"\");
// declare non-terminals
var program = new NonTerminal("program");
var commandList = new NonTerminal("commandList");
var command = new NonTerminal("command");
var openCommand = new NonTerminal("open");
var changeDirCommand = new NonTerminal("cd");
var dirCommand = new NonTerminal("dir");
var closeCommand = new NonTerminal("close");
var getCommand = new NonTerminal("get");
var byeCommand = new NonTerminal("byeCommand");
var url = new NonTerminal("url");
var folderName = new NonTerminal("folderName");
var quotedUrl = new StringLiteral("quotedUrl", "\"");
var unquotedUrl = new IdentifierTerminal("unquotedUrl");
var quotedIdentifier = new StringLiteral("quotedIdentifier", "\"");
var unquotedIdentifier = new IdentifierTerminal("unquotedIdentifier");
var filename = new RegexBasedTerminal("filename", @"[a-zA-Z0-9\.\-_]+"); // note: space not allowed.
// grammar rules
program.Rule = commandList;
commandList.Rule = this.MakePlusRule(commandList, null, command);
command.Rule = openCommand | changeDirCommand | dirCommand | closeCommand | getCommand | byeCommand;
openCommand.Rule = openKeyword + url + this.NewLine; // string_literal + string_literal +
changeDirCommand.Rule = changeDirKeyword + rootfolderKeyword + this.NewLine | changeDirKeyword + backfolderKeyword + this.NewLine | changeDirKeyword + folderName + this.NewLine;
dirCommand.Rule = (dirKeyword | listKeyword) + this.NewLine;
closeCommand.Rule = closeKeyword + this.NewLine;
getCommand.Rule = getKeyword + unquotedIdentifier + this.NewLine; // vai ser preciso usar uma regex para o nome do ficheiro
byeCommand.Rule = byeKeyword + this.NewLine;
//// string regex = @"^[a-zA-Z0-9\.-_ ]+$" (cuidado com ., .., ...) e os espaços
//// inválidos: \/:*?"<>|
url.Rule = quotedUrl | unquotedUrl;
folderName.Rule = quotedIdentifier | filename;
// remove these notes as children in the AST
this.MarkPunctuation("open", "dir", "ls", "close", "get", "cd", "bye");
this.Root = program;
// LanguageFlags |= LanguageFlags.CreateAst;
}
static IdentifierTerminal createClassInstanceVarName()
{
var ClassInstanceVarName = new IdentifierTerminal("ClassInstanceVarName");
ClassInstanceVarName.AllFirstChars = "@@";
ClassInstanceVarName.AddPrefix("@", IdOptions.NameIncludesPrefix);
return(ClassInstanceVarName);
}
static IdentifierTerminal createSymbolId()
{
var SymbolId = new IdentifierTerminal("SymbolId");
SymbolId.AllFirstChars = ":";
SymbolId.AddPrefix(":", IdOptions.NameIncludesPrefix);
return(SymbolId);
}
static IdentifierTerminal createIdentifier()
{
var Id = new IdentifierTerminal("identifier");
Id.CaseRestriction = CaseRestriction.FirstLower;
Id.AddSuffix("?");
Id.AddSuffix("!");
return(Id);
}
private void MakeSimpleId()
{
Identifier = new IdentifierTerminal("simple_id");
var idStringLiteral = new StringLiteral("simple_id_quoted");
idStringLiteral.AddStartEnd("\"", StringOptions.NoEscapes);
idStringLiteral.AstConfig.NodeType = typeof(IdentifierNode);
idStringLiteral.SetOutputTerminal(this, Identifier);
}
/// <summary>
/// Create the term that represents an Entity identifier.
/// </summary>
public IdentifierTerminal CreateIdentifierTerm(string name)
{
var id = new IdentifierTerminal(name, IdOptions.IsNotKeyword);
var term = new StringLiteral(name + "_quoted");
term.AddStartEnd("[", "]", StringOptions.AllowsDoubledQuote);
term.SetOutputTerminal(this, id);
return(id);
}
/*public static IdentifierTerminal CreatePropertyId(string name)
* {
* IdentifierTerminal id = CreateId(name);
* //id.AddPrefix(":", IdOptions.IsNotKeyword | IdOptions.NameIncludesPrefix);
* id.AllFirstChars = ":";
* return id;
* }*/
public static IdentifierTerminal CreateVariableId(string name)
{
IdentifierTerminal id = CreateId(name);
//id.AddPrefix("$", IdOptions.IsNotKeyword | IdOptions.NameIncludesPrefix);
//id.AddPrefix("$", IdOptions.None);
id.AllFirstChars = "$";
return(id);
}
/// <summary>
/// Class constructor and grammar definition
/// </summary>
public FtpGrammar() : base(false)
{
// declare keywords
var openKeyword = ToTerm("open");
var changeDirKeyword = ToTerm("cd");
var dirKeyword = ToTerm("dir");
var listKeyword = ToTerm("ls");
var closeKeyword = ToTerm("close");
var getKeyword = ToTerm("get");
var byeKeyword = ToTerm("bye");
var backfolderKeyword = ToTerm("..");
var rootfolderKeyword = ToTerm(@"\");
// declare non-terminals
var program = new NonTerminal("program");
var commandList = new NonTerminal("commandList");
var command = new NonTerminal("command");
var openCommand = new NonTerminal("open");
var changeDirCommand = new NonTerminal("cd");
var dirCommand = new NonTerminal("dir");
var closeCommand = new NonTerminal("close");
var getCommand = new NonTerminal("get");
var byeCommand = new NonTerminal("byeCommand");
var url = new NonTerminal("url");
var folderName = new NonTerminal("folderName");
var quotedUrl = new StringLiteral("quotedUrl", "\"");
var unquotedUrl = new IdentifierTerminal("unquotedUrl");
var quotedIdentifier = new StringLiteral("quotedIdentifier", "\"");
var unquotedIdentifier = new IdentifierTerminal("unquotedIdentifier");
var filename = new RegexBasedTerminal("filename", @"[a-zA-Z0-9\.\-_]+"); // note: space not allowed.
// grammar rules
program.Rule = commandList;
commandList.Rule = this.MakePlusRule(commandList, null, command);
command.Rule = openCommand | changeDirCommand | dirCommand | closeCommand | getCommand | byeCommand;
openCommand.Rule = openKeyword + url + this.NewLine; // string_literal + string_literal +
changeDirCommand.Rule = changeDirKeyword + rootfolderKeyword + this.NewLine | changeDirKeyword + backfolderKeyword + this.NewLine | changeDirKeyword + folderName + this.NewLine;
dirCommand.Rule = (dirKeyword | listKeyword) + this.NewLine;
closeCommand.Rule = closeKeyword + this.NewLine;
getCommand.Rule = getKeyword + unquotedIdentifier + this.NewLine; // vai ser preciso usar uma regex para o nome do ficheiro
byeCommand.Rule = byeKeyword + this.NewLine;
//// string regex = @"^[a-zA-Z0-9\.-_ ]+$" (cuidado com ., .., ...) e os espaços
//// inválidos: \/:*?"<>|
url.Rule = quotedUrl | unquotedUrl;
folderName.Rule = quotedIdentifier | filename;
// remove these notes as children in the AST
this.MarkPunctuation("open", "dir", "ls", "close", "get", "cd", "bye");
this.Root = program;
// LanguageFlags |= LanguageFlags.CreateAst;
}
public ExpressionEvaluatorGrammar()
{
// 1. Terminals
var number = new NumberLiteral("number");
//Let's allow big integers (with unlimited number of digits):
number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var identifier = new IdentifierTerminal("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);
// 2. Non-terminals
var Expr = new NonTerminal("Expr");
var Term = new NonTerminal("Term");
var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
var ParExpr = new NonTerminal("ParExpr");
var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
var UnOp = new NonTerminal("UnOp");
var BinOp = new NonTerminal("BinOp", "operator");
var PostFixExpr = new NonTerminal("PostFixExpr", typeof(UnExprNode));
var PostFixOp = new NonTerminal("PostFixOp");
var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator");
var Statement = new NonTerminal("Statement");
var ProgramLine = new NonTerminal("ProgramLine");
var Program = new NonTerminal("Program", typeof(StatementListNode));
// 3. BNF rules
Expr.Rule = Term | UnExpr | BinExpr | PostFixExpr;
Term.Rule = number | ParExpr | identifier;
ParExpr.Rule = "(" + Expr + ")";
UnExpr.Rule = UnOp + Term;
UnOp.Rule = ToTerm("+") | "-" | "++" | "--";
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
PostFixExpr.Rule = Term + PostFixOp;
PostFixOp.Rule = ToTerm("++") | "--";
AssignmentStmt.Rule = identifier + AssignmentOp + Expr;
AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=";
Statement.Rule = AssignmentStmt | Expr | Empty;
ProgramLine.Rule = Statement + NewLine;
Program.Rule = MakeStarRule(Program, ProgramLine);
this.Root = Program; // Set grammar root
// 4. Operators precedence
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "**");
// 5. Punctuation and transient terms
RegisterPunctuation("(", ")");
RegisterBracePair("(", ")");
MarkTransient(Term, Expr, Statement, BinOp, UnOp, PostFixOp, AssignmentOp, ProgramLine, ParExpr);
//automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
this.LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample;
}
private BnfTerm CreateSqlExtIdentifier(string name)
{
var identifierTerminal = new IdentifierTerminal(name, null, "@");
var stringLiteral = new StringLiteral(name + "_quoted");
stringLiteral.AddStartEnd("[", "]", StringOptions.NoEscapes);
stringLiteral.AddStartEnd("\"", StringOptions.NoEscapes);
stringLiteral.SetOutputTerminal(this, identifierTerminal);
return(identifierTerminal);
}
public SearchGrammar()
{
// Terminals
var Term = new IdentifierTerminal("Term", "!@#$%^*_'.?", "!@#$%^*_'.?0123456789");
// The following is not very imporant, but makes scanner recognize "or" and "and" as operators, not Terms
// The "or" and "and" operator symbols found in grammar get higher priority in scanning and are checked
// first, before the Term terminal, so Scanner produces operator token, not Term. For our purposes it does
// not matter, we get around without it.
Term.Priority = Terminal.LowestPriority;
var Phrase = new StringLiteral("Phrase");
// NonTerminals
var OrExpression = new NonTerminal("OrExpression");
var OrOperator = new NonTerminal("OrOperator");
var AndExpression = new NonTerminal("AndExpression");
var AndOperator = new NonTerminal("AndOperator");
var ExcludeOperator = new NonTerminal("ExcludeOperator");
var PrimaryExpression = new NonTerminal("PrimaryExpression");
var ThesaurusExpression = new NonTerminal("ThesaurusExpression");
var ThesaurusOperator = new NonTerminal("ThesaurusOperator");
var ExactOperator = new NonTerminal("ExactOperator");
var ExactExpression = new NonTerminal("ExactExpression");
var ParenthesizedExpression = new NonTerminal("ParenthesizedExpression");
var ProximityExpression = new NonTerminal("ProximityExpression");
var ProximityList = new NonTerminal("ProximityList");
this.Root = OrExpression;
OrExpression.Rule = AndExpression
| OrExpression + OrOperator + AndExpression;
OrOperator.Rule = Symbol("or") | "|";
AndExpression.Rule = PrimaryExpression
| AndExpression + AndOperator + PrimaryExpression;
AndOperator.Rule = Empty
| "and"
| "&"
| ExcludeOperator;
ExcludeOperator.Rule = Symbol("-");
PrimaryExpression.Rule = Term
| ThesaurusExpression
| ExactExpression
| ParenthesizedExpression
| Phrase
| ProximityExpression;
ThesaurusExpression.Rule = ThesaurusOperator + Term;
ThesaurusOperator.Rule = Symbol("~");
ExactExpression.Rule = ExactOperator + Term
| ExactOperator + Phrase;
ExactOperator.Rule = Symbol("+");
ParenthesizedExpression.Rule = "(" + OrExpression + ")";
ProximityExpression.Rule = "<" + ProximityList + ">";
MakePlusRule(ProximityList, Term);
RegisterPunctuation("<", ">", "(", ")");
}
public ErrorRecoveryGrammar() {
var id = new IdentifierTerminal("id");
var expr = new NonTerminal("expr");
var stmt = new NonTerminal("stmt");
var stmtList = new NonTerminal("stmt");
base.Root = stmtList;
stmtList.Rule = MakeStarRule(stmtList, stmt);
stmt.Rule = id + "=" + expr + ";";
stmt.ErrorRule = SyntaxError + ";";
expr.Rule = id | id + "+" + id;
}
public GrammarEx446() {
// A' is augmented root
NonTerminal S = new NonTerminal("S");
NonTerminal L = new NonTerminal("L");
NonTerminal R = new NonTerminal("R");
Terminal id = new IdentifierTerminal("id");
S.Rule = L + "=" + R | R;
L.Rule = "*" + R | id;
R.Rule = L;
this.Root = S;
}//method
public Gramatica2() : base(caseSensitive: false)
{
#region ER
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
#endregion
#region Terminales
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
T = new NonTerminal("T"),
F = new NonTerminal("F");
#endregion
#region Gramatica
S.Rule = E;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + div + E
| ToTerm("(") + E + ToTerm(")")
| ToTerm("(") + E + ToTerm(")") + ToTerm("^") + E
| numero + ToTerm("^") + E
| numero
| id;
/* //Gramatica no ambigua
* S.Rule = E;
* E.Rule = E + mas + T
| E + menos + T
| T;
| T.Rule = T + por + F
| T + div + F
| F;
| F.Rule = id
| numero;*/
#endregion
#region Preferencias
this.Root = S;
#endregion
}
public ErrorRecoveryGrammar()
{
var id = new IdentifierTerminal("id");
var expr = new NonTerminal("expr");
var stmt = new NonTerminal("stmt");
var stmtList = new NonTerminal("stmt");
base.Root = stmtList;
stmtList.Rule = MakeStarRule(stmtList, stmt);
stmt.Rule = id + "=" + expr + ";";
stmt.ErrorRule = SyntaxError + ";";
expr.Rule = id | id + "+" + id;
}
public GrammarEx446()
{
// A' is augmented root
NonTerminal S = new NonTerminal("S");
NonTerminal L = new NonTerminal("L");
NonTerminal R = new NonTerminal("R");
Terminal id = new IdentifierTerminal("id");
S.Rule = L + "=" + R | R;
L.Rule = "*" + R | id;
R.Rule = L;
this.Root = S;
}//method
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 Portugol()
: base(false)
{
LanguageFlags = LanguageFlags.CreateAst;
var numero = new NumberLiteral("Numero", NumberOptions.AllowSign);
var identificador = new IdentifierTerminal("Identificador");
var expressao = new NonTerminal("Expressao", typeof (AstNode));
var termo = new NonTerminal("Termo", typeof (AstNode));
var chamadaFuncao = new NonTerminal("Chamada funcao", typeof (ChamadaDeFuncao));
var operacaoBinaria = new NonTerminal("Operacao binaria", typeof (OperacaoBinaria));
var operacaoComParentese = new NonTerminal("Operacao com parentese", typeof (AstNode));
var se = new NonTerminal("Se", typeof (CondicaoSe));
var operador = new NonTerminal("Operador", typeof(AstNode));
var operadorLogico = new NonTerminal("Operador logico", typeof (AstNode));
var argumentos = new NonTerminal("Argumentos", typeof (AstNode));
var sePart = new NonTerminal("Se parte", typeof (AstNode));
var entaoPart = new NonTerminal("Entao parte", typeof (AstNode));
var senaoPart = new NonTerminal("Senao parte", typeof (AstNode));
NonGrammarTerminals.Add(new CommentTerminal("comment1", "/*", "*/"));
expressao.Rule = operacaoBinaria | operacaoComParentese | se | chamadaFuncao | termo;
termo.Rule = numero;
operacaoComParentese.Rule = ToTerm("(") + expressao + ")";
operacaoBinaria.Rule = expressao + operador + expressao;
operador.Rule = ToTerm("+") | "-" | "*" | "/" | "^" | "%" | "=" | "<" | ">" | "<=" | ">=" | "<>" | "E" | "OU";
sePart.Rule = ToTerm("Se");
entaoPart.Rule = ToTerm("Entao");
senaoPart.Rule = ToTerm("Senao");
se.Rule = sePart + expressao + entaoPart + expressao + senaoPart + expressao;
argumentos.Rule = MakePlusRule(argumentos, ToTerm(","), expressao);
chamadaFuncao.Rule = identificador | identificador + "(" + argumentos + ")";
RegisterOperators(1, "E", "OU");
RegisterOperators(5, "=", "<", ">", "<=", ">=", "<>");
RegisterOperators(10, "+", "-");
RegisterOperators(20, "*", "/", "%", "^");
MarkPunctuation("(", ")");
RegisterBracePair("(", ")");
MarkTransient(expressao, operador, termo, operadorLogico, operacaoComParentese);
Root = expressao;
LanguageFlags = LanguageFlags.CreateAst;
}
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 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 ExpressionEvaluatorGrammar()
{
// 1. Terminals
var number = new NumberLiteral("number");
var identifier = new IdentifierTerminal("identifier");
var comment = new CommentTerminal("comment", "#", "\n", "\r");
base.NonGrammarTerminals.Add(comment);
// 2. Non-terminals
var Variable = new NonTerminal("Variable", typeof(VarRefNode));
var Expr = new NonTerminal("Expr");
var Term = new NonTerminal("Term");
var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
var ParExpr = new NonTerminal("ParExpr");
var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
var UnOp = new NonTerminal("UnOp");
var BinOp = new NonTerminal("BinOp");
var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
var Statement = new NonTerminal("Statement");
var ProgramLine = new NonTerminal("ProgramLine");
var Program = new NonTerminal("Program", typeof(StatementListNode));
// 3. BNF rules
Variable.Rule = identifier;
Expr.Rule = Term | UnExpr | BinExpr;
Term.Rule = number | ParExpr | Variable;
ParExpr.Rule = "(" + Expr + ")";
UnExpr.Rule = UnOp + Term;
UnOp.Rule = Symbol("+") | "-";
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = Symbol("+") | "-" | "*" | "/" | "**";
AssignmentStmt.Rule = Variable + "=" + Expr;
Statement.Rule = AssignmentStmt | Expr | Empty;
ProgramLine.Rule = Statement + NewLine;
Program.Rule = MakeStarRule(Program, ProgramLine);
this.Root = Program; // Set grammar root
// 4. Operators precedence
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "**");
RegisterPunctuation( "(", ")");
MarkTransient(Term, Expr, Statement);
//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 | LanguageFlags.SupportsInterpreter;
}
/// <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);
}
public WikiText_Template_Grammar()
{
// Terminals
//var text = new WikiTextTerminal("text");
var pipeChar = ToTerm("|");
var identifier = new IdentifierTerminal("identifier"); //,"","");
var variableName = new DsvLiteral("variableName", TypeCode.String, "=");
var variableValue = new DsvLiteral("variableValue", TypeCode.String, "\n");
// Non-terminals
var wikiTemplate = new NonTerminal("wikiElement");
var templateData = new NonTerminal("templateData");
var includeOnly = new WikiBlockTerminal("includeOnly", WikiBlockType.EscapedText, "<includeonly>", "</includeonly>", "includeOnly");
var noInclude = new WikiBlockTerminal("includeOnly", WikiBlockType.EscapedText, "<noinclude>", "</noinclude>", "includeOnly");
//var wikiText = new NonTerminal("wikiText");
var templateDetails = new NonTerminal("templateDetails");
var row = new NonTerminal("row");
var emptyRow = new NonTerminal("emptyRow");
var dataRow = new NonTerminal("dataRow");
var rows = new NonTerminal("rows");
//var drive = new NonTerminal("drive");
// BNF rules
templateDetails.Rule = identifier + ":" + includeOnly + noInclude;
dataRow.Rule = pipeChar + variableName + variableValue;
row.Rule = emptyRow | dataRow;
emptyRow.Rule = ToTerm("|-") + NewLine;
rows.Rule = MakePlusRule(rows, row);
templateData.Rule = templateDetails + NewLine + rows;
wikiTemplate.Rule = ToTerm("{{") + templateData + "}}"; // + ToTerm("}}");
//wikiText.Rule = "{{ " + MakeStarRule(wikiText, wikiElement) + "}}" ;
//wikiText.Rule = MakeStarRule(wikiText, wikiElement) ;
// config
//this.Root = wikiText;
this.Root = wikiTemplate;
//this.WhitespaceChars = string.Empty;
MarkTransient(row);
MarkPunctuation(pipeChar);
//NewLine.SetFlag(TermFlags.IsPunctuation, true);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
//this.LanguageFlags |= LanguageFlags.DisableScannerParserLink | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample
// | LanguageFlags.CreateAst ;
}
public Kbtter3QueryGrammar() : base(false)
{
//コメント
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);
}
private NonTerminal Identifier()
{
var idSimple = new IdentifierTerminal("Identifier")
{
AllFirstChars = validChars,
AllChars = validChars + "1234567890"
};
idSimple.SetFlag(TermFlags.NoAstNode);
var id = NonTerminal("identifier", null, n => new Identifier
{
Value = n.ChildNodes.Select(x => x.Token.ValueString).JoinStrings(".")
});
id.Rule = MakePlusRule(id, ToTerm("."), idSimple);
return(id);
}
public ConflictResolutionTestGrammar2() : base(true)
{
var name = new IdentifierTerminal("id");
var definition = new NonTerminal("definition");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
definition.Rule = fieldDef | propDef;
fieldDef.Rule = fieldModifier + name + name + ";";
propDef.Rule = propModifier + name + name + "{" + "}";
fieldModifier.Rule = ToTerm("public") + ReduceIf(";", comesBefore: "{") | "private" + ReduceIf(";", comesBefore: "{") | "readonly";
propModifier.Rule = ToTerm("public") | "private" | "override";
Root = definition;
}
public ConflictGrammarWithHintsInRules() : base(true) {
var name = new IdentifierTerminal("id");
var definition = new NonTerminal("definition");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
definition.Rule = fieldDef | propDef;
fieldDef.Rule = fieldModifier + name + name + ";";
propDef.Rule = propModifier + name + name + "{" + "}";
var fieldHint = ReduceIf(";", comesBefore: "{");
fieldModifier.Rule = "public" + fieldHint | "private" + fieldHint | "readonly";
propModifier.Rule = ToTerm("public") | "private" | "override";
Root = definition;
}
public ExpressionGrammar()
{
this.GrammarComments = @"Arithmetical expressions for dynamic geometry.";
// 1. Terminals
var number = new NumberLiteral("number");
var identifier = new IdentifierTerminal("identifier");
// 2. Non-terminals
var Expr = new NonTerminal("Expr");
var Term = new NonTerminal("Term");
var BinExpr = new NonTerminal("BinExpr");
var ParExpr = new NonTerminal("ParExpr");
var UnExpr = new NonTerminal("UnExpr");
var UnOp = new NonTerminal("UnOp");
var BinOp = new NonTerminal("BinOp", "operator");
var PropertyAccess = new NonTerminal("PropertyAccess");
var FunctionCall = new NonTerminal("FunctionCall");
var CommaSeparatedIdentifierList = new NonTerminal("PointArgumentList");
var ArgumentList = new NonTerminal("ArgumentList");
// 3. BNF rules
Expr.Rule = Term | UnExpr | BinExpr;
Term.Rule = number | identifier | ParExpr | FunctionCall | PropertyAccess;
UnExpr.Rule = UnOp + Term;
UnOp.Rule = ToTerm("-");
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "^";
PropertyAccess.Rule = identifier + "." + identifier;
FunctionCall.Rule = identifier + "(" + ArgumentList + ")";
ArgumentList.Rule = Expr | CommaSeparatedIdentifierList;
ParExpr.Rule = "(" + Expr + ")";
CommaSeparatedIdentifierList.Rule = MakePlusRule(CommaSeparatedIdentifierList, ToTerm(","), identifier);
this.Root = Expr;
// 4. Operators precedence
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "^");
MarkPunctuation("(", ")", ".", ",");
MarkTransient(Term, Expr, BinOp, UnOp, ParExpr, ArgumentList, CommaSeparatedIdentifierList);
}
public ExpressionGrammar()
{
this.GrammarComments = @"Arithmetical expressions for dynamic geometry.";
// 1. Terminals
var number = new NumberLiteral("number");
var identifier = new IdentifierTerminal("identifier");
// 2. Non-terminals
var Expr = new NonTerminal("Expr");
var Term = new NonTerminal("Term");
var BinExpr = new NonTerminal("BinExpr");
var ParExpr = new NonTerminal("ParExpr");
var UnExpr = new NonTerminal("UnExpr");
var UnOp = new NonTerminal("UnOp");
var BinOp = new NonTerminal("BinOp", "operator");
var PropertyAccess = new NonTerminal("PropertyAccess");
var FunctionCall = new NonTerminal("FunctionCall");
var CommaSeparatedIdentifierList = new NonTerminal("PointArgumentList");
var ArgumentList = new NonTerminal("ArgumentList");
// 3. BNF rules
Expr.Rule = Term | UnExpr | BinExpr;
Term.Rule = number | identifier | ParExpr | FunctionCall | PropertyAccess;
UnExpr.Rule = UnOp + Term;
UnOp.Rule = ToTerm("-");
BinExpr.Rule = Expr + BinOp + Expr;
BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "^";
PropertyAccess.Rule = identifier + "." + identifier;
FunctionCall.Rule = identifier + "(" + ArgumentList + ")";
ArgumentList.Rule = Expr | CommaSeparatedIdentifierList;
ParExpr.Rule = "(" + Expr + ")";
CommaSeparatedIdentifierList.Rule = MakePlusRule(CommaSeparatedIdentifierList, ToTerm(","), identifier);
this.Root = Expr;
// 4. Operators precedence
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/");
RegisterOperators(3, Associativity.Right, "^");
MarkPunctuation("(", ")", ".", ",");
MarkTransient(Term, Expr, BinOp, UnOp, ParExpr, ArgumentList, CommaSeparatedIdentifierList);
}
public ConflictGrammarWithHintsOnTerms()
: base(true)
{
var name = new IdentifierTerminal("id");
var stmt = new NonTerminal("Statement");
var stmtList = new NonTerminal("StatementList");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
var methodModifier = new NonTerminal("methodModifier");
var fieldModifierList = new NonTerminal("fieldModifierList");
var propModifierList = new NonTerminal("propModifierList");
var methodModifierList = new NonTerminal("methodModifierList");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var methodDef = new NonTerminal("methodDef");
//Rules
Root = stmtList;
stmtList.Rule = MakePlusRule(stmtList, stmt);
stmt.Rule = fieldDef | propDef | methodDef;
fieldDef.Rule = fieldModifierList + name + name + ";";
propDef.Rule = propModifierList + name + name + "{" + "}";
methodDef.Rule = methodModifierList + name + name + "(" + ")" + "{" + "}";
fieldModifierList.Rule = MakeStarRule(fieldModifierList, fieldModifier);
propModifierList.Rule = MakeStarRule(propModifierList, propModifier);
methodModifierList.Rule = MakeStarRule(methodModifierList, methodModifier);
fieldModifier.Rule = ToTerm("public") | "private" | "readonly" | "volatile";
propModifier.Rule = ToTerm("public") | "private" | "readonly" | "override";
methodModifier.Rule = ToTerm("public") | "private" | "override";
// conflict resolution
var fieldHint = new TokenPreviewHint(PreferredActionType.Reduce, ";", "(", "{");
fieldModifier.AddHintToAll(fieldHint);
fieldModifierList.AddHintToAll(fieldHint);
var propHint = new TokenPreviewHint(PreferredActionType.Reduce, "{", ";", "(");
propModifier.AddHintToAll(propHint);
propModifierList.AddHintToAll(propHint);
MarkReservedWords("public", "private", "readonly", "volatile", "override");
}
public FreightGrammar()
: base(caseSensitive: false)
{
// define all the non-terminals
var program = new NonTerminal("program");
var statementList = new NonTerminal("statementList");
var statement = new NonTerminal("statement");
var ifStatement = new NonTerminal("ifStatement",typeof(FreightLanguage.code_generation.IfStatementNode));
var freightDeclaration = new NonTerminal("freightDeclaration");
var setVariable = new NonTerminal("setVariable");
var orderLoop = new NonTerminal("orderLoop");
var expression = new NonTerminal("expression",typeof(FreightLanguage.code_generation.ExpressionNode));
var variable = new IdentifierTerminal("variable");
//variable.AddKeywords("set", "to", "if", "freight", "cost", "is", "loop", "through", "order");
var binaryOperator = new NonTerminal("binaryOperator");
// define the grammar
//<BinaryOperator> ::= "+" | "-" | "*" | "/" | "<" | ">" | "<=" | ">=" | "is"
binaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "<" | ">" | "<=" | ">=" | "is";
//<Program> ::= <StatementList> <FreightDeclaration>
program.Rule = statementList + freightDeclaration;
//<StatementList> ::= <Statement>*
statementList.Rule = MakeStarRule(statementList, null, statement);
//<Statement> ::= <SetVariable> ";" | <IfStatement> | <OrderLoop> | <Expression> ";"
statement.Rule = setVariable + ";" | ifStatement | orderLoop | expression + ";";
//<SetVariable> ::= "set" <variable> "to" <Expression>
setVariable.Rule = ToTerm("set") + variable + "to" + expression;
//<IfStatement> ::= "if" <Expression> "[" <StatementList> "]"
ifStatement.Rule = ToTerm("if") + expression + "[" + statementList + "]";
//<OrderLoop> ::= "loop" "through" "order" "[" <StatementList> "]"
orderLoop.Rule = ToTerm("loop") + "through" + "order" + "[" + statementList + "]";
//<FreightDeclaration> ::= "freight" "cost" "is" <Expression> ";"
freightDeclaration.Rule = ToTerm("freight") + "cost" + "is" + expression + ";";
//<Expression> ::= <number> | <variable> | <string> |<Expression> <BinaryOperator> <Expression> | "(" <Expression> ")"
var number = new NumberLiteral("number");
//TEST
number.DefaultIntTypes = number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var stringLiteral = new StringLiteral("stringType", "\"");
expression.Rule = number | variable | stringLiteral | expression + binaryOperator + expression | "(" + expression + ")";
this.Root = program;
MarkPunctuation("[", "]", ";");
}
//Creates extended identifier terminal that allows international characters
// Following the pattern used for c# identifier terminal in TerminalFactory.CreateCSharpIdentifier method;
private IdentifierTerminal CreateTerm(string name) {
IdentifierTerminal term = new IdentifierTerminal(name, "!@#$%^*_'.?-", "!@#$%^*_'.?0123456789");
term.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber, //Nl
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//StartCharCategories are the same
term.StartCharCategories.AddRange(term.CharCategories);
return term;
}
public ConflictResolutionTestGrammar4() : base(true)
{
var name = new IdentifierTerminal("id");
var stmt = new NonTerminal("Statement");
var stmtList = new NonTerminal("StatementList");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
var methodModifier = new NonTerminal("methodModifier");
var fieldModifierList = new NonTerminal("fieldModifierList");
var propModifierList = new NonTerminal("propModifierList");
var methodModifierList = new NonTerminal("methodModifierList");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var methodDef = new NonTerminal("methodDef");
//Rules
this.Root = stmtList;
stmtList.Rule = MakePlusRule(stmtList, stmt);
stmt.Rule = fieldDef | propDef | methodDef;
fieldDef.Rule = fieldModifierList + name + name + ";";
propDef.Rule = propModifierList + name + name + "{" + "}";
methodDef.Rule = methodModifierList + name + name + "(" + ")" + "{" + "}";
fieldModifierList.Rule = MakeStarRule(fieldModifierList, fieldModifier);
propModifierList.Rule = MakeStarRule(propModifierList, propModifier);
methodModifierList.Rule = MakeStarRule(methodModifierList, methodModifier);
// That's the key of the problem: 3 modifiers have common members
// so parser automaton has hard time deciding which modifiers list to produce -
// is it a field, prop or method we are beginning to parse?
fieldModifier.Rule = ToTerm("public") | "private" | "readonly" | "volatile";
propModifier.Rule = ToTerm("public") | "private" | "readonly" | "override";
methodModifier.Rule = ToTerm("public") | "private" | "override";
// conflict resolution
fieldModifier.ReduceIf(thisSymbol: ";", comesBefore: new string[] { "(", "{" });
propModifier.ReduceIf(thisSymbol: "{", comesBefore: new string[] { ";", "(" });
fieldModifierList.ReduceIf(thisSymbol: ";", comesBefore: new string[] { "(", "{" });
propModifierList.ReduceIf(thisSymbol: "{", comesBefore: new string[] { ";", "(" });
MarkReservedWords("public", "private", "readonly", "volatile", "override");
}
public OperatorGrammar() {
var id = new IdentifierTerminal("id");
var binOp = new NonTerminal("binOp");
var unOp = new NonTerminal("unOp");
var expr = new NonTerminal("expr");
var binExpr = new NonTerminal("binExpr");
var unExpr = new NonTerminal("unExpr");
base.Root = expr;
expr.Rule = id | binExpr | unExpr;
binExpr.Rule = expr + binOp + expr;
binOp.Rule = ToTerm("+") | "-" | "*" | "/";
unExpr.Rule = unOp + expr;
unOp.Rule = ToTerm("+") | "-";
RegisterOperators(10, "+", "-");
RegisterOperators(20, "*", "/");
MarkTransient(expr, binOp, unOp);
}
public ConflictResolutionTestGrammar4()
: base(true)
{
var name = new IdentifierTerminal("id");
var stmt = new NonTerminal("Statement");
var stmtList = new NonTerminal("StatementList");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
var methodModifier = new NonTerminal("methodModifier");
var fieldModifierList = new NonTerminal("fieldModifierList");
var propModifierList = new NonTerminal("propModifierList");
var methodModifierList = new NonTerminal("methodModifierList");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var methodDef = new NonTerminal("methodDef");
//Rules
this.Root = stmtList;
stmtList.Rule = MakePlusRule(stmtList, stmt);
stmt.Rule = fieldDef | propDef | methodDef;
fieldDef.Rule = fieldModifierList + name + name + ";";
propDef.Rule = propModifierList + name + name + "{" + "}";
methodDef.Rule = methodModifierList + name + name + "(" + ")" + "{" + "}";
fieldModifierList.Rule = MakeStarRule(fieldModifierList, fieldModifier);
propModifierList.Rule = MakeStarRule(propModifierList, propModifier);
methodModifierList.Rule = MakeStarRule(methodModifierList, methodModifier);
// That's the key of the problem: 3 modifiers have common members
// so parser automaton has hard time deciding which modifiers list to produce -
// is it a field, prop or method we are beginning to parse?
fieldModifier.Rule = ToTerm("public") | "private" | "readonly" | "volatile";
propModifier.Rule = ToTerm("public") | "private" | "readonly" | "override";
methodModifier.Rule = ToTerm("public") | "private" | "override";
// conflict resolution
fieldModifier.ReduceIf(thisSymbol: ";", comesBefore: new string[] { "(", "{"});
propModifier.ReduceIf(thisSymbol: "{", comesBefore: new string[] { ";", "(" });
fieldModifierList.ReduceIf(thisSymbol: ";", comesBefore: new string[] { "(", "{" });
propModifierList.ReduceIf(thisSymbol: "{", comesBefore: new string[] { ";", "(" });
MarkReservedWords("public", "private", "readonly", "volatile", "override");
}
public OperatorGrammarHintsOnNonTerms() {
var id = new IdentifierTerminal("id");
var binOp = new NonTerminal("binOp");
var unOp = new NonTerminal("unOp");
var expr = new NonTerminal("expr");
var binExpr = new NonTerminal("binExpr");
var unExpr = new NonTerminal("unExpr");
base.Root = expr;
expr.Rule = id | binExpr | unExpr;
binExpr.Rule = expr + binOp + expr;
binOp.Rule = ToTerm("+") | "-" | "*" | "/";
var unOpHint = ImplyPrecedenceHere(30); // Force higher precedence than multiplication precedence
unExpr.Rule = unOpHint + unOp + expr;
unOp.Rule = ToTerm("+") | "-";
RegisterOperators(10, "+", "-");
RegisterOperators(20, "*", "/");
MarkTransient(expr, binOp, unOp);
}
public ConflictResolutionTestGrammar1()
: base(true)
{
var name = new IdentifierTerminal("id");
var definition = new NonTerminal("definition");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
definition.Rule = fieldDef | propDef;
fieldDef.Rule = fieldModifier + name + name + ";";
propDef.Rule = propModifier + name + name + "{" + "}";
fieldModifier.Rule = ToTerm("public") | "private" | "readonly";
propModifier.Rule = ToTerm("public") | "private" | "override";
Root = definition;
}
public ConflictGrammarWithHintsOnTerms()
: base(true)
{
var name = new IdentifierTerminal("id");
var stmt = new NonTerminal("Statement");
var stmtList = new NonTerminal("StatementList");
var fieldModifier = new NonTerminal("fieldModifier");
var propModifier = new NonTerminal("propModifier");
var methodModifier = new NonTerminal("methodModifier");
var fieldModifierList = new NonTerminal("fieldModifierList");
var propModifierList = new NonTerminal("propModifierList");
var methodModifierList = new NonTerminal("methodModifierList");
var fieldDef = new NonTerminal("fieldDef");
var propDef = new NonTerminal("propDef");
var methodDef = new NonTerminal("methodDef");
//Rules
this.Root = stmtList;
stmtList.Rule = MakePlusRule(stmtList, stmt);
stmt.Rule = fieldDef | propDef | methodDef;
fieldDef.Rule = fieldModifierList + name + name + ";";
propDef.Rule = propModifierList + name + name + "{" + "}";
methodDef.Rule = methodModifierList + name + name + "(" + ")" + "{" + "}";
fieldModifierList.Rule = MakeStarRule(fieldModifierList, fieldModifier);
propModifierList.Rule = MakeStarRule(propModifierList, propModifier);
methodModifierList.Rule = MakeStarRule(methodModifierList, methodModifier);
fieldModifier.Rule = ToTerm("public") | "private" | "readonly" | "volatile";
propModifier.Rule = ToTerm("public") | "private" | "readonly" | "override";
methodModifier.Rule = ToTerm("public") | "private" | "override";
// conflict resolution
var fieldHint = new TokenPreviewHint(PreferredActionType.Reduce, thisSymbol: ";", comesBefore: new string[] { "(", "{" });
fieldModifier.AddHintToAll(fieldHint);
fieldModifierList.AddHintToAll(fieldHint);
var propHint = new TokenPreviewHint(PreferredActionType.Reduce, thisSymbol: "{", comesBefore: new string[] { ";", "(" });
propModifier.AddHintToAll(propHint);
propModifierList.AddHintToAll(propHint);
MarkReservedWords("public", "private", "readonly", "volatile", "override");
}
public ZestGrammar()
{
this.GrammarComments = "A grammar for Zest";
//Terminals
StringLiteral stringTerm = new StringLiteral("<String>", "\"");
IdentifierTerminal identifier = new IdentifierTerminal("<Identifier>");
RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+");
//Non terminals
NonTerminal program = new NonTerminal("<Program>");
NonTerminal testSpecification = new NonTerminal("<TestSpecification>");
NonTerminal definition = new NonTerminal("<Definition>");
NonTerminal specificationDeclaration = new NonTerminal("<SpecificationDeclaration>");
NonTerminal testDeclaration = new NonTerminal("<TestDeclaration>");
NonTerminal end = new NonTerminal("<End>");
NonTerminal testHeader = new NonTerminal("<TestHeader>");
NonTerminal testBody = new NonTerminal("<TestBody>");
NonTerminal becauseStatement = new NonTerminal("<BecauseStatement>");
NonTerminal shouldStatement = new NonTerminal("<ShouldStatement>", typeof(ShouldNode));
NonTerminal identifierList = new NonTerminal("<IdentifierList>");
NonTerminal returnExpr = new NonTerminal("<ReturnExpr>");
NonTerminal valueList = new NonTerminal("<valueList>");
NonTerminal op = new NonTerminal("<Operator>");
//bnf rules
program.Rule = testSpecification;
testSpecification.Rule = definition + ToTerm("sut") + specificationDeclaration + MakeStarRule(testDeclaration, testDeclaration) + end;//not sure the makeplus rule is correct
definition.Rule = ToTerm("def");
specificationDeclaration.Rule = identifier | identifier + ToTerm(":") + identifier;
testDeclaration.Rule = definition + testHeader + MakePlusRule(testBody, testBody) + end;
end.Rule = ToTerm("end");
testHeader.Rule = ToTerm("when") + stringTerm;
testBody.Rule = "because" + becauseStatement | "should" + shouldStatement;
becauseStatement.Rule = identifier + ToTerm("(") + identifierList + ")" | "csut" + "(" + MakeStarRule(identifierList, identifier) + ")" | identifier + ToTerm("(") + valueList + ")";
shouldStatement.Rule = ToTerm("return") + returnExpr | "throw" + identifier;
identifierList.Rule = identifier | MakePlusRule(identifierList, ToTerm(","), identifier);
valueList.Rule = MakeStarRule(valueList, ToTerm(","), number) | MakeStarRule(valueList, ToTerm(","), stringTerm);
returnExpr.Rule = number | stringTerm | identifier + op + identifier;
op.Rule = ToTerm("*") | "+" | "-" | "/";
this.Root = program;
this.LanguageFlags = LanguageFlags.CreateAst;
MarkPunctuation("def", "when", "sut", "(", ")", "csut", "because", "should", "throw", "return", "end", ":");
}
public static IdentifierTerminal CreateCSharpIdentifier(string name)
{
IdentifierTerminal id = new IdentifierTerminal(name);
id.SetOption(TermOptions.CanStartWithEscape);
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";
id.AddKeywordList(strKeywords);
id.AddPrefixFlag("@", ScanFlags.IsNotKeyword | ScanFlags.DisableEscapes);
//From spec:
//Start char is "_" or letter-character, which is a Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
id.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber //Nl
});
//Internal chars
/* From spec:
identifier-part-character: letter-character | decimal-digit-character | connecting-character | combining-character |
formatting-character
*/
id.CharCategories.AddRange(id.StartCharCategories); //letter-character categories
id.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//Chars to remove from final identifier
id.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return id;
}
private IdentifierTerminal CreateIdentifier(string name)
{
var term = new IdentifierTerminal(name);
term.AddPrefix("@", IdOptions.IsNotKeyword);
term.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.LowercaseLetter,
UnicodeCategory.UppercaseLetter,
UnicodeCategory.TitlecaseLetter,
UnicodeCategory.ModifierLetter,
UnicodeCategory.OtherLetter,
UnicodeCategory.LetterNumber
});
term.CharCategories.AddRange(term.StartCharCategories);
term.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber
});
term.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return term;
}
public void TestIdentifier_CaseRestrictions()
{
Parser parser; Token token;
var id = new IdentifierTerminal("identifier");
id.CaseRestriction = CaseRestriction.None;
parser = TestHelper.CreateParser(id);
token = parser.ParseInput("aAbB");
Assert.True(token != null, "Failed to scan an identifier aAbB.");
id.CaseRestriction = CaseRestriction.FirstLower;
parser = TestHelper.CreateParser(id);
token = parser.ParseInput("BCD");
Assert.True(token.IsError(), "Erroneously recognized an identifier BCD with FirstLower restriction.");
token = parser.ParseInput("bCd ");
Assert.True(token != null && token.ValueString == "bCd", "Failed to scan identifier bCd with FirstLower restriction.");
id.CaseRestriction = CaseRestriction.FirstUpper;
parser = TestHelper.CreateParser(id);
token = parser.ParseInput("cDE");
Assert.True(TokenCategory.Error == token.Category, "Erroneously recognized an identifier cDE with FirstUpper restriction.");
token = parser.ParseInput("CdE");
Assert.True(token != null && token.ValueString == "CdE", "Failed to scan identifier CdE with FirstUpper restriction.");
id.CaseRestriction = CaseRestriction.AllLower;
parser = TestHelper.CreateParser(id);
token = parser.ParseInput("DeF");
Assert.True(token.IsError(), "Erroneously recognized an identifier DeF with AllLower restriction.");
token = parser.ParseInput("def");
Assert.True(token != null && token.ValueString == "def", "Failed to scan identifier def with AllLower restriction.");
id.CaseRestriction = CaseRestriction.AllUpper;
parser = TestHelper.CreateParser(id);
token = parser.ParseInput("EFg ");
Assert.True(token.IsError(), "Erroneously recognized an identifier EFg with AllUpper restriction.");
token = parser.ParseInput("EFG");
Assert.True(token != null && token.ValueString == "EFG", "Failed to scan identifier EFG with AllUpper restriction.");
}//method
public void TestIdentifierCaseRestrictions()
{
var id = new IdentifierTerminal("identifier");
id.CaseRestriction = CaseRestriction.None;
SetTerminal(id);
TryMatch("aAbB");
Assert.IsTrue(_token != null, "Failed to scan an identifier aAbB.");
id.CaseRestriction = CaseRestriction.FirstLower;
SetTerminal(id);
TryMatch("BCD");
Assert.IsTrue(_token == null, "Erroneously recognized an identifier BCD with FirstLower restriction.");
TryMatch("bCd ");
Assert.IsTrue(_token != null && _token.ValueString == "bCd", "Failed to scan identifier bCd with FirstLower restriction.");
id.CaseRestriction = CaseRestriction.FirstUpper;
SetTerminal(id);
TryMatch("cDE");
Assert.IsTrue(_token == null, "Erroneously recognized an identifier cDE with FirstUpper restriction.");
TryMatch("CdE");
Assert.IsTrue(_token != null && _token.ValueString == "CdE", "Failed to scan identifier CdE with FirstUpper restriction.");
id.CaseRestriction = CaseRestriction.AllLower;
SetTerminal(id);
TryMatch("DeF");
Assert.IsTrue(_token == null, "Erroneously recognized an identifier DeF with AllLower restriction.");
TryMatch("def");
Assert.IsTrue(_token != null && _token.ValueString == "def", "Failed to scan identifier def with AllLower restriction.");
id.CaseRestriction = CaseRestriction.AllUpper;
SetTerminal(id);
TryMatch("EFg ");
Assert.IsTrue(_token == null, "Erroneously recognized an identifier EFg with AllUpper restriction.");
TryMatch("EFG");
Assert.IsTrue(_token != null && _token.ValueString == "EFG", "Failed to scan identifier EFG with AllUpper restriction.");
}
/// <summary>
/// 使うな
/// </summary>
public Kbtter4CommandlineGrammar()
: base()
{
var Number = new NumberLiteral("Number");
Number.DefaultIntTypes = new[] { TypeCode.Int32, TypeCode.Int64 };
Number.DefaultFloatType = TypeCode.Double;
var String = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var Identifer = new IdentifierTerminal("Identifer");
var Value = new NonTerminal("Value");
var Parameter = new NonTerminal("Parameter");
var Parameters = new NonTerminal("Parameters");
var Command = new NonTerminal("Command");
Value.Rule = Number | String | "true" | "false";
Parameter.Rule = Identifer + "=>" + Value;
Parameters.Rule = MakeStarRule(Parameters, ToTerm(","), Parameter);
Command.Rule = Identifer + Parameters;
Root = Command;
MarkTransient(Parameters, Value);
MarkPunctuation("=>");
}
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 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
}
