private Expr ParseExpr()
{
if (this.index == this.tokens.Count)
{
throw new System.Exception("expected expression, got EOF");
}
if (this.tokens[this.index] is Text.StringBuilder)
{
string value = ((Text.StringBuilder)this.tokens[this.index++]).ToString();
StringLiteral stringLiteral = new StringLiteral();
stringLiteral.Value = value;
return stringLiteral;
}
else if (this.tokens[this.index] is int)
{
int intValue = (int)this.tokens[this.index++];
IntLiteral intLiteral = new IntLiteral();
intLiteral.Value = intValue;
return intLiteral;
}
else if (this.tokens[this.index] is string)
{
string ident = (string)this.tokens[this.index++];
Variable var = new Variable();
var.Ident = ident;
return var;
}
else
{
throw new System.Exception("expected string literal, int literal, or variable");
}
}
public static StringLiteral CreateCSharpString(string name)
{
var term = new StringLiteral(name, "\"", StringOptions.AllowsAllEscapes);
term.AddPrefix("@",
StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote);
return term;
}
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 OpenxmlColumn(ColumnName columnName, TypeName columnType, StringLiteral columnPattern) {
Debug.Assert(columnName != null);
Debug.Assert(columnType != null);
this.columnName = columnName;
this.columnType = columnType;
this.columnPattern = columnPattern;
}
public static StringLiteral CreateZodiacString(string name)
{
StringLiteral term = new StringLiteral(name);
//term.AddStartEnd("'", StringOptions.AllowsAllEscapes);// AllowLineBreak??
term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);// AllowLineBreak??
return term;
}
public JsonGrammar() {
//Terminals
var jstring = new StringLiteral("string", "\"");
var jnumber = new NumberLiteral("number");
var comma = ToTerm(",");
//Nonterminals
var jobject = new NonTerminal("Object");
var jobjectBr = new NonTerminal("ObjectBr");
var jarray = new NonTerminal("Array");
var jarrayBr = new NonTerminal("ArrayBr");
var jvalue = new NonTerminal("Value");
var jprop = new NonTerminal("Property");
//Rules
jvalue.Rule = jstring | jnumber | jobjectBr | jarrayBr | "true" | "false" | "null";
jobjectBr.Rule = "{" + jobject + "}";
jobject.Rule = MakeStarRule(jobject, comma, jprop);
jprop.Rule = jstring + ":" + jvalue;
jarrayBr.Rule = "[" + jarray + "]";
jarray.Rule = MakeStarRule(jarray, comma, jvalue);
//Set grammar root
this.Root = jvalue;
MarkPunctuation("{", "}", "[", "]", ":", ",");
this.MarkTransient(jvalue, jarrayBr, jobjectBr);
}//constructor
public static StringLiteral CreateVbString(string name) {
StringLiteral term = new StringLiteral(name);
term.AddStartEnd("\"", StringOptions.NoEscapes | StringOptions.AllowsDoubledQuote);
term.AddSuffix("$", TypeCode.String);
term.AddSuffix("c", TypeCode.Char);
return term;
}
public JsonGrammar()
{
//Terminals
var jstring = new StringLiteral("string", "\"");
var jnumber = new NumberLiteral("number");
var comma = Symbol(",");
//Nonterminals
var jobject = new NonTerminal("Object");
var jarray = new NonTerminal("Array");
var jvalue = new NonTerminal("Value");
var jprop = new NonTerminal("Property");
var jproplist = new NonTerminal("PropertyList");
var jlist = new NonTerminal("List");
//Rules
jvalue.Rule = jstring | jnumber | jobject | jarray | "true" | "false" | "null";
jobject.Rule = "{" + jproplist + "}";
jproplist.Rule = MakeStarRule(jproplist, comma, jprop);
jprop.Rule = jstring + ":" + jvalue;
jarray.Rule = "[" + jlist + "]";
jlist.Rule = MakeStarRule(jlist, comma, jvalue);
//Set grammar root
this.Root = jvalue;
RegisterPunctuation("{", "}", "[", "]", ":", ",");
this.MarkTransient(jvalue, jlist, jproplist);
this.LanguageFlags = LanguageFlags.None; //.BubbleNodes;
}
protected PredicateLike(Expression valueExpression, bool not, Expression pattern, StringLiteral escape): base(not) {
Debug.Assert(valueExpression != null);
Debug.Assert(pattern != null);
this.valueExpression = valueExpression;
this.pattern = pattern;
this.escape = escape;
}
private StringLiteral CreateStringLiteral(string name)
{
var term = new StringLiteral(name);
term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);
term.AddStartEnd("'", StringOptions.AllowsDoubledQuote | StringOptions.AllowsOctalEscapes | StringOptions.AllowsUEscapes | StringOptions.AllowsXEscapes);
return term;
}
public KISGrammer()
{
var number = new NumberLiteral("number");
var text = new StringLiteral("string", "\"");
number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var identifier = new IdentifierTerminal("identifier");
var comment = new CommentTerminal("comment", "#", "\n", "\r");
base.NonGrammarTerminals.Add(comment);
var Code = new NonTerminal("code");
var Statments = new NonTerminal("statments");
var Value = new NonTerminal("value");
var ValueString = TerminalFactory.CreateCSharpString("valuestring");
var SetStmt = new NonTerminal("setstmt");
var CallStmt = new NonTerminal("callstmt");
var FnStmt = new NonTerminal("fnstmt");
var CallPath = new NonTerminal("callpath");
var CallPerams = new NonTerminal("callperams");
var fullstop = new NonTerminal("fullstop");
var comma = new NonTerminal("comma");
var openb = new NonTerminal("openb");
var closeb = new NonTerminal("closeb");
openb.Rule = "{";
closeb.Rule = "}";
fullstop.Rule = ".";
comma.Rule = ",";
CallPath.Rule = MakePlusRule(CallPath, fullstop, identifier);
CallPerams.Rule = MakePlusRule(CallPerams, comma, Value);
var Semicolon = ToTerm(";");
//StateMents:
SetStmt.Rule = identifier + "=" + Value + Semicolon;
CallStmt.Rule = (CallPath | identifier) + "(" + (CallPerams | Empty) + ")" + Semicolon;
FnStmt.Rule = "function" + identifier + "(" + (CallPerams | Empty) + ")";
Statments.Rule = SetStmt | CallStmt | FnStmt | openb | closeb | Empty;
var Exspr = new NonTerminal("exspr");
var Operator = new NonTerminal("operator");
var ExsprStmt = new NonTerminal("exsprstmt");
Operator.Rule = ToTerm("/") | "*" | "-" | "+";
ExsprStmt.Rule = Value + Operator + Value;
Exspr.Rule = MakePlusRule(Exspr, Operator, ExsprStmt);
Value.Rule = number | ValueString | identifier | "true" | "false" | Exspr /* | text */;
Code.Rule = MakePlusRule(Code, NewLine, Statments);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
//code := Statment {statment}
this.Root = Code;
}
public IntegrationTestGrammar() {
var comment = new CommentTerminal("comment", "/*", "*/");
base.NonGrammarTerminals.Add(comment);
var str = new StringLiteral("str", "'", StringOptions.AllowsLineBreak);
var stmt = new NonTerminal("stmt");
stmt.Rule = str | Empty;
this.Root = stmt;
}
/// <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 SearchGrammar()
: base(false)
{
this.GrammarComments =
"Google-to-SQL full-text query format converter. Based on original project by Michael Coles.\r\n" +
"http://www.sqlservercentral.com/articles/Full-Text+Search+(2008)/64248/ \r\n" +
"Slightly revised to work with latest version of Irony. ";
// Terminals
var Term = CreateTerm("Term");
var Phrase = new StringLiteral("Phrase", "\"");
var ImpliedAnd = new ImpliedSymbolTerminal("ImpliedAnd");
// NonTerminals
var BinaryExpression = new NonTerminal("BinaryExpression");
var BinaryOp = new NonTerminal("BinaryOp");
var Expression = new NonTerminal("Expression");
var PrimaryExpression = new NonTerminal("PrimaryExpression");
var ThesaurusExpression = new NonTerminal("ThesaurusExpression");
var ThesaurusOperator = new NonTerminal("ThesaurusOperator");
var ExactExpression = new NonTerminal("ExactExpression");
var ParenthesizedExpression = new NonTerminal("ParenthesizedExpression");
var ProximityExpression = new NonTerminal("ProximityExpression");
var ProximityList = new NonTerminal("ProximityList");
this.Root = Expression;
Expression.Rule = PrimaryExpression | BinaryExpression;
BinaryExpression.Rule = Expression + BinaryOp + Expression;
BinaryOp.Rule = ImpliedAnd | "and" | "&" | "-" | "or" | "|";
PrimaryExpression.Rule = Term
| ThesaurusExpression
| ExactExpression
| ParenthesizedExpression
| Phrase
| ProximityExpression;
ThesaurusExpression.Rule = "~" + Term;
ExactExpression.Rule = "+" + Term | "+" + Phrase;
ParenthesizedExpression.Rule = "(" + Expression + ")";
ProximityExpression.Rule = "<" + ProximityList + ">";
MakePlusRule(ProximityList, Term);
MarkTransient(PrimaryExpression, Expression, ProximityExpression, ParenthesizedExpression, BinaryOp);
MarkPunctuation("<", ">", "(", ")");
RegisterOperators(10, "or", "|");
RegisterOperators(20, "and", "&", "-");
RegisterOperators(20, ImpliedAnd);
//Register brace pairs to improve error reporting
RegisterBracePair("(", ")");
RegisterBracePair("<", ">");
//Do not report ImpliedAnd as expected symbol - it is not really a symbol
this.AddToNoReportGroup(ImpliedAnd);
//also do not report braces as expected
this.AddToNoReportGroup("(", ")", "<", ">");
LanguageFlags |= LanguageFlags.CanRunSample;
}
public void AllowStringEqualityAndInequalityComparison(string op)
{
var left = new StringLiteral ("foobar");
var right = new StringLiteral ("baz");
var compared = new BinaryOperation (op, left, right);
var type = compared.Walk (new TypeChecker ());
Assert.AreEqual (SpecType.Boolean, type.Type);
}
public static StringLiteral CreatePythonString(string name) {
StringLiteral term = new StringLiteral(name);
term.AddStartEnd("'", StringOptions.AllowsAllEscapes);
term.AddStartEnd("'''", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);
term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);
term.AddStartEnd("\"\"\"", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);
term.AddPrefix("u", StringOptions.AllowsAllEscapes);
term.AddPrefix("r", StringOptions.NoEscapes );
term.AddPrefix("ur", StringOptions.NoEscapes);
return term;
}
public void InvalidRange()
{
var stringlit = new StringLiteral("foo", 0);
var range = new Range(stringlit, stringlit, 0);
var variabledecl = new VariableDeclaration("foo", "int", 0);
var variable = new VariableReference("foo", 0);
var loop = new Loop(variable, range, new List<Statement>(), 0);
statementlist.Add(variabledecl);
statementlist.Add(loop);
var parsetree = new Program(statementlist);
Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
public HereDocTestGrammar()
: base(true) {
var heredoc = new HereDocTerminal("HereDoc", "<<", HereDocOptions.None);
heredoc.AddSubType("<<-", HereDocOptions.AllowIndentedEndToken);
var @string = new StringLiteral("string", "\"");
var program = new NonTerminal("program");
program.Rule = heredoc + @"+" + @string + this.NewLine + @"+" + @string
| heredoc + @"+" + heredoc + @"+" + @string + this.NewLine
| heredoc + @"+" + @string + this.NewLine
| heredoc + @"+" + @string + @"+" + heredoc
| heredoc + @"+" + heredoc
| heredoc;
this.Root = program;
this.MarkPunctuation("+");
}
public static StringLiteral CreateStringLiteral(string value, bool isNational = true)
{
StringLiteral ast = null;
if (value != null)
{
ast = new StringLiteral()
{
Value = value,
IsNational = isNational
};
}
return ast;
}
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);
}
/// <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);
}
static string Example1()
{
Pirate p = new Pirate();
StringLiteral s1 = new StringLiteral("H\ae\bl\fl\vo\0 \'P\"arrot!\n");
Call c1 = new Call("print", s1);
StmtList sl = new StmtList();
CallStmt cs1 = new CallStmt(c1);
sl.Add(cs1);
Sub main = new Sub("main", sl);
p.Add(main);
StringWriter sw = new StringWriter();
PirateWriter pv = new PirateWriter(sw);
DynamicVisitor.accept(p, pv);
return sw.ToString();
}
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("[", "]", ";");
}
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 LiteralRules(PieGrammar grammar)
{
this.grammar = grammar;
NumberLiteral = new NumberLiteral("number_literal", NumberOptions.AllowStartEndDot)
{
// Define types to assign if the parser can't determine.
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Double
};
// The pre and post fixes for different number types and formats.
NumberLiteral.AddPrefix("0x", NumberOptions.Hex);
NumberLiteral.AddSuffix("b", TypeCode.Byte);
NumberLiteral.AddSuffix("B", TypeCode.Byte);
NumberLiteral.AddSuffix("s", TypeCode.Int16);
NumberLiteral.AddSuffix("S", TypeCode.Int16);
NumberLiteral.AddSuffix("u", TypeCode.UInt32);
NumberLiteral.AddSuffix("U", TypeCode.UInt32);
NumberLiteral.AddSuffix("us", TypeCode.UInt16);
NumberLiteral.AddSuffix("US", TypeCode.UInt16);
NumberLiteral.AddSuffix("l", TypeCode.Int64);
NumberLiteral.AddSuffix("L", TypeCode.Int64);
NumberLiteral.AddSuffix("ul", TypeCode.UInt64);
NumberLiteral.AddSuffix("UL", TypeCode.UInt64);
NumberLiteral.AddSuffix("F", TypeCode.Single);
NumberLiteral.AddSuffix("f", TypeCode.Single);
NumberLiteral.AddSuffix("d", TypeCode.Double);
NumberLiteral.AddSuffix("D", TypeCode.Double);
NumberLiteral.AddSuffix("m", TypeCode.Decimal);
NumberLiteral.AddSuffix("M", TypeCode.Decimal);
StringLiteral = new StringLiteral("string_literal", "\"", StringOptions.AllowsAllEscapes);
CharLiteral = new StringLiteral("char_literal", "'", StringOptions.IsChar);
BoolLiteral = new NonTerminal("bool_literal");
BoolLiteral.Rule = grammar.Keywords.True | grammar.Keywords.False;
Null = grammar.ToTerm("null", "null_literal");
}
/// <summary>
/// 新しいインスタンスを以下略
/// </summary>
public Kb10uyConfigGrammar()
: base()
{
var Number = new NumberLiteral("Number");
var String = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var CommentLine = new CommentTerminal("Comment", "#", "\n", "\r");
var CommentBlock = new CommentTerminal("Comment", "#<", ">");
//数値設定
Number.DefaultIntTypes = new[] { TypeCode.Int32 };
Number.DefaultFloatType = TypeCode.Double;
String.EscapeChar = '\\';
NonGrammarTerminals.Add(CommentBlock);
NonGrammarTerminals.Add(CommentLine);
var Value = new NonTerminal("Value");
var Values = new NonTerminal("Value\'s\'");
var ValueSet = new NonTerminal("Array");
var Property = new NonTerminal("Property");
var Prefix = new NonTerminal("Prefix");
var Node = new NonTerminal("Node");
var Nodes = new NonTerminal("Nodes");
//var PropertySet = new NonTerminal("PropertySet");
var Group = new NonTerminal("Group");
var ConfigRoot = new NonTerminal("Root");
Value.Rule = Number | String | ValueSet;
Values.Rule = MakeStarRule(Values, ToTerm(","), Value);
ValueSet.Rule = ToTerm("[") + Values + "]";
Prefix.Rule = ToTerm("Number") | "String" | "Array" ;
Property.Rule = Prefix + ":" + String + "=" + Value + ";";
Node.Rule = Property | Group;
Nodes.Rule = MakeStarRule(Nodes, Node);
Group.Rule = String + ":" + "{" +Nodes+ "}";
ConfigRoot.Rule = MakeStarRule(ConfigRoot, Group);
Root = ConfigRoot;
MarkPunctuation("[", "]", ",", "{", "}",":",";","=");
}
private NonTerminal WhenGrammar()
{
var starOperator = _("StarOperator", ToTerm("*"));
var stringOperator = _("StringOperator", ToTerm("=") | "!=");
var numberOperator = _("NumberOperator", ToTerm("=") | "!=" | ">" | ">=" | "<" | "<=");
var headerName = new StringLiteral("Header ExpressionExtensions", "'", StringOptions.NoEscapes);
var headerValue = new StringLiteral("Header Value", "'", StringOptions.NoEscapes);
var headerCondition = _("HeaderCondition", ToTerm("HEADER") + headerName + stringOperator + headerValue);
var requestHeaderCondition = _("RequestHeaderCondition", ToTerm("REQUEST") + headerCondition);
var responseHeaderCondition = _("ResponseHeaderCondition", ToTerm("RESPONSE") + headerCondition);
var statusCodeValue = new NumberLiteral("Status Code Value", NumberOptions.IntOnly);
var statusCodeCondition = _("StatusCodeCondition", ToTerm("STATUS") + "CODE" + numberOperator + statusCodeValue);
var requestSizeValue = new NumberLiteral("Request Size Value", NumberOptions.IntOnly);
var requestSizeCondition = _("RequestSizeCondition", ToTerm("REQUEST") + "SIZE" + numberOperator + requestSizeValue);
var responseSizeValue = new NumberLiteral("Response Size Value", NumberOptions.IntOnly);
var responseSizeCondition = _("ResponseSizeCondition", ToTerm("RESPONSE") + "SIZE" + numberOperator + responseSizeValue);
var urlValue = new StringLiteral("Url Value", "'", StringOptions.NoEscapes);
var urlCondition = _("UrlCondition", ToTerm("URL") + stringOperator + urlValue);
var machineValue = new StringLiteral("Machine Value", "'", StringOptions.NoEscapes);
var machineCondition = _("MachineCondition", ToTerm("MACHINE") + stringOperator + machineValue);
var expression = _("Expression");
var logicalOperator = _("LogicalOperator", ToTerm("AND") | ToTerm("OR"));
var logicalOperation = _("LogicalOperation", expression + logicalOperator + expression);
var parentheses = _("Parentheses", "(" + logicalOperation + ")");
_(expression, responseSizeCondition | requestSizeCondition | statusCodeCondition | requestHeaderCondition | responseHeaderCondition | urlCondition | machineCondition | logicalOperation | parentheses);
return _("When", ToTerm("WHEN") + expression | ToTerm("WHEN") + starOperator);
}
/// <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 virtual void Visit(StringLiteral literal)
{
}
public SqlGrammar() : base(false)
{
var comment = new CommentTerminal("comment", "/*", "*/");
var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(lineComment);
var number = new NumberLiteral("number");
number.AstConfig.NodeType = typeof(NumberNode);
var stringLiteral = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote);
stringLiteral.AstConfig.NodeType = typeof(StringLiteralNode);
var simpleId = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple");
simpleId.AstConfig.NodeType = typeof(SimpleIdNode);
var dateTime = new RegexBasedTerminal("date time", @"\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d.\d\d\d\d\d\d\d");
dateTime.AstConfig.NodeType = typeof(DateTimeNode);
var comma = ToTerm(",");
var dot = ToTerm(".");
var CREATE = ToTerm("CREATE");
var SHOW = ToTerm("SHOW");
var NULL = ToTerm("NULL");
var NOT = ToTerm("NOT");
var UNIQUE = ToTerm("UNIQUE");
var TABLE = ToTerm("TABLE");
var ALTER = ToTerm("ALTER");
var ADD = ToTerm("ADD");
var COLUMN = ToTerm("COLUMN");
var DROP = ToTerm("DROP");
var CONSTRAINT = ToTerm("CONSTRAINT");
var KEY = ToTerm("KEY");
var PRIMARY = ToTerm("PRIMARY");
var SELECT = ToTerm("SELECT");
var FROM = ToTerm("FROM");
var AS = ToTerm("AS");
var COUNT = ToTerm("COUNT");
var BY = ToTerm("BY");
var INTO = ToTerm("INTO");
var ON = ToTerm("ON");
var BEGIN_TRANSACTION = ToTerm("BEGIN TRANSACTION");
var COMMIT = ToTerm("COMMIT");
var ROLLBACK = ToTerm("ROLLBACK");
var SET = ToTerm("SET");
var UPDATE = ToTerm("UPDATE");
var INSERT = ToTerm("INSERT");
var VALUES = ToTerm("VALUES");
var STAR = ToTerm("*");
var ALL = ToTerm("ALL");
var UNION = ToTerm("UNION");
var INTERSECT = ToTerm("INTERSECT");
var EXCEPT = ToTerm("EXCEPT");
var JOIN = ToTerm("JOIN");
var DELETE = ToTerm("DELETE");
var FOR = ToTerm("FOR");
var SYSTEM_TIME = ToTerm("SYSTEM_TIME");
var BETWEEN = ToTerm("BETWEEN");
var AND = ToTerm("AND");
var OF = ToTerm("OF");
var TO = ToTerm("TO");
var OR = ToTerm("OR");
var stmtList = new NonTerminal("stmtList", typeof(StmtListNode));
var stmtLine = new NonTerminal("stmtLine", typeof(StmtLineNode));
var semiOpt = new NonTerminal("semiOpt", typeof(SqlNode));
var sqlCommand = new NonTerminal("sqlSequence", typeof(SqlCommandNode));
var transaction = new NonTerminal("transaction", typeof(TransactionNode));
var transactionList = new NonTerminal("transactionList", typeof(TransactionListNode));
var transactionBeginOpt = new NonTerminal("transactionBeginOp", typeof(TransactionBeginOptNode));
var transactionEndOpt = new NonTerminal("transactionEndOp", typeof(TransactionEndOptNode));
var transactionName = new NonTerminal("transactionName", typeof(TransactionNameNode));
var id = new NonTerminal("id", typeof(IdNode));
var createTableStmt = new NonTerminal("CreateTableStmt", typeof(CreateTableCommandNode));
var showTableStmt = new NonTerminal("ShowTableStmt", typeof(ShowTableCommandNode));
var dropTableStmt = new NonTerminal("DropTableStmt", typeof(DropTableCommandNode));
var fieldDef = new NonTerminal("fieldDef", typeof(FieldDefNode));
var fieldDefList = new NonTerminal("fieldDefList", typeof(FieldDefListNode));
var nullSpecOpt = new NonTerminal("nullSpecOpt", typeof(NullSpectOptNode));
var typeName = new NonTerminal("typeName", typeof(TypeNameNode));
var typeParamsOpt = new NonTerminal("typeParams", typeof(TypeParamsOptNode));
var constraintDef = new NonTerminal("constraintDef", typeof(ConstraintDefNode));
var constraintListOpt = new NonTerminal("constraintListOpt", typeof(ConstraintListOptNodes));
var alterStmt = new NonTerminal("AlterStmt", typeof(SqlNode));
var alterCmd = new NonTerminal("alterCmd", typeof(SqlNode));
//var expressionWithoutBrackets = new NonTerminal("expression", typeof(ExpressionNode));
var asOpt = new NonTerminal("asOpt", typeof(SqlNode));
var aliasOpt = new NonTerminal("aliasOpt", typeof(SqlNode));
var tuple = new NonTerminal("tuple", typeof(SqlNode));
var term = new NonTerminal("term", typeof(TermNode));
var unOp = new NonTerminal("unOp", typeof(UnOpNode));
var binOp = new NonTerminal("binOp", typeof(BinOpNode));
var selectStmt = new NonTerminal("SelectStmt", typeof(SelectCommandNode));
var expressionList = new NonTerminal("exprList", typeof(ExpressionListNode));
var selRestrOpt = new NonTerminal("selRestrOpt", typeof(SqlNode));
var selList = new NonTerminal("selList", typeof(SelListNode));
var intoClauseOpt = new NonTerminal("intoClauseOpt", typeof(SqlNode));
var forClauseOpt = new NonTerminal("forClauseOpt", typeof(ForClauseOptNode));
var systemTimeOpt = new NonTerminal("systemTimeOpt", typeof(SystemTimeOptNode));
var fromClauseOpt = new NonTerminal("fromClauseOpt", typeof(FromClauseNode));
var betweenTimeSelector = new NonTerminal("betweenSelector", typeof(BetweenTimeSelectorNode));
var fromToTimeSelector = new NonTerminal("fromToSelector", typeof(FromToTimeSelectorNode));
var asOfTimeSelector = new NonTerminal("asOfSelector", typeof(AsOfTimeSelectorNode));
var groupClauseOpt = new NonTerminal("groupClauseOpt", typeof(SqlNode));
var havingClauseOpt = new NonTerminal("havingClauseOpt", typeof(SqlNode));
var orderClauseOpt = new NonTerminal("orderClauseOpt", typeof(SqlNode));
var whereClauseOpt = new NonTerminal("whereClauseOpt", typeof(WhereClauseNode));
var columnItemList = new NonTerminal("columnItemList", typeof(ColumnItemListNode));
var columnItem = new NonTerminal("columnItem", typeof(ColumnItemNode));
var columnSource = new NonTerminal("columnSource", typeof(ColumnSourceNode));
var idList = new NonTerminal("idList", typeof(IdListNode));
var idlistPar = new NonTerminal("idlistPar", typeof(SqlNode));
var aggregate = new NonTerminal("aggregate", typeof(SqlNode));
var aggregateArg = new NonTerminal("aggregateArg", typeof(SqlNode));
var aggregateName = new NonTerminal("aggregateName", typeof(SqlNode));
var orderList = new NonTerminal("orderList", typeof(SqlNode));
var orderMember = new NonTerminal("orderMember", typeof(SqlNode));
var orderDirOpt = new NonTerminal("orderDirOpt", typeof(SqlNode));
var unExpr = new NonTerminal("unExpr", typeof(UnExprNode));
var binExpr = new NonTerminal("binExpr", typeof(BinExprNode));
var funCall = new NonTerminal("funCall", typeof(SqlNode));
var parSelectStmt = new NonTerminal("parSelectStmt", typeof(SqlNode));
var betweenExpr = new NonTerminal("betweenExpr", typeof(SqlNode));
var notOpt = new NonTerminal("notOpt", typeof(SqlNode));
var funArgs = new NonTerminal("funArgs", typeof(SqlNode));
var inStmt = new NonTerminal("inStmt", typeof(SqlNode));
var updateStmt = new NonTerminal("UpdateStmt", typeof(UpdateCommandNode));
var insertStmt = new NonTerminal("InsertStmt", typeof(InsertCommandNode));
var intoOpt = new NonTerminal("intoOpt", typeof(SqlNode));
var insertDataList = new NonTerminal("insertDataList", typeof(InsertDataListNode));
var insertObject = new NonTerminal("insertObject", typeof(InsertObjectNode));
var insertData = new NonTerminal("InsertData", typeof(InsertDataNode));
var assignList = new NonTerminal("assignList", typeof(AssignmentListNode));
var assignment = new NonTerminal("assignment", typeof(AssignmentNode));
var columnNames = new NonTerminal("columnNames", typeof(ColumnNamesNode));
var expression = new NonTerminal("expression", typeof(ExpressionNode));
var idOperator = new NonTerminal("idOperator", typeof(IdOperatorNode));
var idLink = new NonTerminal("idLink", typeof(IdLinkNode));
var joinChainOpt = new NonTerminal("joinChainOpt", typeof(JoinChainOptNode));
var joinKindOpt = new NonTerminal("joinKindOpt", typeof(JoinKindOptNode));
var joinStatement = new NonTerminal("joinStatement", typeof(JoinStatementNode));
var unionChainOpt = new NonTerminal("unionChainOpt", typeof(UnionChainOptNode));
var unionKindOpt = new NonTerminal("unionKindOpt", typeof(UnionKindOptNode));
var intersectChainOpt = new NonTerminal("intersectChainOpt", typeof(InsertCommandNode));
var exceptChainOpt = new NonTerminal("exceptChainOpt", typeof(ExceptChainOptNode));
var deleteStmt = new NonTerminal("DeleteStmt", typeof(DeleteCommandNode));
//BNF Rules
Root = transactionList;
transactionName.Rule = id | Empty;
transactionBeginOpt.Rule = BEGIN_TRANSACTION + transactionName;
transactionEndOpt.Rule = COMMIT | ROLLBACK;
transaction.Rule = transactionBeginOpt + stmtList + transactionEndOpt | stmtLine;
transactionList.Rule = MakePlusRule(transactionList, transaction);
stmtList.Rule = MakePlusRule(stmtList, stmtLine);
stmtLine.Rule = sqlCommand + semiOpt;
sqlCommand.Rule = createTableStmt | alterStmt | deleteStmt
| dropTableStmt | showTableStmt | selectStmt | updateStmt | insertStmt;
semiOpt.Rule = Empty | ";";
//ID link node
idOperator.Rule = joinChainOpt | unionChainOpt | intersectChainOpt | exceptChainOpt | selectStmt;
idLink.Rule = "(" + idOperator + ")" | id;
//Join
joinChainOpt.Rule = idLink + joinKindOpt + JOIN + idLink + ON + joinStatement;
joinKindOpt.Rule = Empty | "INNER" | "LEFT" | "RIGHT" | "Full";
joinStatement.Rule = expression;//"(" + id + "=" + id + ")" | id + "=" + id;
//Union
unionChainOpt.Rule = idLink + UNION + unionKindOpt + idLink;
unionKindOpt.Rule = Empty | ALL;
//Intersect
intersectChainOpt.Rule = idLink + INTERSECT + idLink;
//Except
exceptChainOpt.Rule = idLink + EXCEPT + idLink;
//ID
id.Rule = MakePlusRule(id, dot, simpleId);
idlistPar.Rule = "(" + idList + ")";
idList.Rule = MakePlusRule(idList, comma, id);
//Create table
createTableStmt.Rule = CREATE + TABLE + id + "(" + fieldDefList + ")";
fieldDefList.Rule = MakePlusRule(fieldDefList, comma, fieldDef);
fieldDef.Rule = id + typeName + typeParamsOpt + constraintListOpt + nullSpecOpt;
nullSpecOpt.Rule = NULL | NOT + NULL | Empty;
typeName.Rule = ToTerm("DATETIME") | "INT" | "DOUBLE" | "CHAR" | "NCHAR" | "VARCHAR" | "NVARCHAR"
| "IMAGE" | "TEXT" | "NTEXT";
typeParamsOpt.Rule = "(" + number + ")" | "(" + number + comma + number + ")" | Empty;
constraintListOpt.Rule = MakeStarRule(constraintListOpt, constraintDef);
constraintDef.Rule = (UNIQUE) | (PRIMARY + KEY) | ("FOREIGN" + KEY + "REFERENCES" + id) | ("DEFAULT" + stringLiteral) | ("INDEX" + id);
//Delete stmt
deleteStmt.Rule = DELETE + FROM + id + whereClauseOpt;
//Alter
alterStmt.Rule = ALTER + TABLE + id + alterCmd;
alterCmd.Rule = ADD + simpleId + "(" + fieldDefList + ")" | DROP + COLUMN + id
| ALTER + COLUMN + id + typeName + (ADD + CONSTRAINT + constraintListOpt
| DROP + CONSTRAINT + constraintListOpt);
//Drop stmts
dropTableStmt.Rule = DROP + TABLE + id;
//Show table
showTableStmt.Rule = SHOW + TABLE + id;
//Select stmt
selectStmt.Rule = SELECT + selRestrOpt + selList + intoClauseOpt + fromClauseOpt + forClauseOpt + whereClauseOpt +
groupClauseOpt + havingClauseOpt + orderClauseOpt;
selRestrOpt.Rule = Empty | ALL | "DISTINCT";
selList.Rule = columnItemList | STAR;
columnItemList.Rule = MakePlusRule(columnItemList, comma, columnItem);
columnItem.Rule = columnSource + aliasOpt;
aliasOpt.Rule = Empty | asOpt + id;
asOpt.Rule = Empty | AS;
columnSource.Rule = aggregate | id;
aggregate.Rule = aggregateName + "(" + aggregateArg + ")";
aggregateArg.Rule = expression | STAR;
aggregateName.Rule = COUNT | "Avg" | "Min" | "Max" | "StDev" | "StDevP" | "Sum" | "Var" | "VarP";
intoClauseOpt.Rule = Empty | INTO + id;
forClauseOpt.Rule = Empty | FOR + systemTimeOpt;
systemTimeOpt.Rule = SYSTEM_TIME + betweenTimeSelector | SYSTEM_TIME + fromToTimeSelector | SYSTEM_TIME + asOfTimeSelector;
betweenTimeSelector.Rule = BETWEEN + dateTime + AND + dateTime;
fromToTimeSelector.Rule = FROM + dateTime + TO + dateTime;
asOfTimeSelector.Rule = AS + OF + dateTime;
fromClauseOpt.Rule = Empty | FROM + idLink;
whereClauseOpt.Rule = Empty | "WHERE" + expression;
groupClauseOpt.Rule = Empty | "GROUP" + BY + idList;
havingClauseOpt.Rule = Empty | "HAVING" + expression;
orderClauseOpt.Rule = Empty | "ORDER" + BY + orderList;
orderList.Rule = MakePlusRule(orderList, comma, orderMember);
orderMember.Rule = id + orderDirOpt;
orderDirOpt.Rule = Empty | "ASC" | "DESC";
//Insert stmt
insertStmt.Rule = INSERT + intoOpt + id + columnNames + insertData;
insertDataList.Rule = MakePlusRule(insertDataList, comma, insertObject);
insertObject.Rule = "(" + expressionList + ")";
columnNames.Rule = idlistPar | Empty;
insertData.Rule = selectStmt | VALUES + insertDataList;
intoOpt.Rule = Empty | INTO; //Into is optional in MSSQL
//Update stmt
updateStmt.Rule = UPDATE + id + SET + assignList + whereClauseOpt;
assignList.Rule = MakePlusRule(assignList, comma, assignment);
assignment.Rule = id + "=" + expression;
//Expression
expressionList.Rule = MakePlusRule(expressionList, comma, expression);
//expression.Rule = /*"(" + expressionWithoutBrackets + ")" |*/ expressionWithoutBrackets;
expression.Rule = "(" + expression + ")" | binExpr | unExpr | term; // Add betweenExpr
term.Rule = id | stringLiteral | number; //| funCall | tuple | parSelectStmt;// | inStmt;
tuple.Rule = "(" + expressionList + ")";
parSelectStmt.Rule = "(" + selectStmt + ")";
unExpr.Rule = unOp + "(" + expression + ")" | unOp + term;
unOp.Rule = NOT | "+" | "-" | "~";
binExpr.Rule = expression + binOp + expression;
binOp.Rule = ToTerm("+") | "-" | "*" | "/" | "%" | "&" | "|" | "^"
| "=" | ">" | "<" | ">=" | "<=" | "<>" | "!=" | "!<" | "!>"
| "AND" | "OR" | "LIKE" | NOT + "LIKE" | "IN" | NOT + "IN";
betweenExpr.Rule = expression + notOpt + BETWEEN + expression + AND + expression;
notOpt.Rule = Empty | NOT;
funCall.Rule = id + "(" + funArgs + ")";
funArgs.Rule = selectStmt | expressionList;
inStmt.Rule = expression + "IN" + "(" + expressionList + ")";
//Operators
RegisterOperators(10, "*", "/", "%");
RegisterOperators(10, JOIN, UNION, INTERSECT, EXCEPT);
RegisterOperators(9, "+", "-");
RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "!=", "!<", "!>", "LIKE", "IN");
RegisterOperators(7, "^", "&", "|");
RegisterOperators(6, NOT);
RegisterOperators(5, AND);
RegisterOperators(4, OR);
MarkPunctuation(",", "(", ")");
MarkPunctuation(asOpt, semiOpt);
MarkTransient(sqlCommand, term, asOpt, aliasOpt, stmtLine, tuple, /*expression,*/ idlistPar, idOperator);
//LanguageFlags = LanguageFlags.CreateAst;
binOp.SetFlag(TermFlags.InheritPrecedence);
}
public virtual T Visit(StringLiteral node)
{
return(Visit((Literal)node));
}
public Gramatica() : base(false)
{
var ID = new IdentifierTerminal("ID", "_", "_");
var ComentarioLinea = new CommentTerminal("ComentarioLinea", "//", "\n", "\r\n");
var ComentarioMultilinea = new CommentTerminal("ComentarioMultilinea", "/*", "*/");
var ENTERO = new RegexBasedTerminal("ENTERO", "[0-9]+");
var DECIMAL = new RegexBasedTerminal("DECIMAL", "[0-9]+[.][0-9]+");
var CADENA = new StringLiteral("CADENA", "\"");
var DATE = new RegexBasedTerminal("DATE", "['][0-2][0-9][0-9][0-9][-][0-1][0-9][-][0-3][0-9][']");
var TIME = new RegexBasedTerminal("TIME", "['][0-2][0-9][:][0-6][0-9][:][0-6][0-9][']");
MarkReservedWords("null");
MarkReservedWords("int");
MarkReservedWords("double");
MarkReservedWords("string");
MarkReservedWords("boolean");
MarkReservedWords("true");
MarkReservedWords("false");
MarkReservedWords("date");
MarkReservedWords("time");
MarkReservedWords("create");
MarkReservedWords("type");
MarkReservedWords("new");
MarkReservedWords("alter");
MarkReservedWords("add");
MarkReservedWords("delete");
MarkReservedWords("create");
MarkReservedWords("database");
MarkReservedWords("use");
MarkReservedWords("drop");
MarkReservedWords("table");
MarkReservedWords("counter");
MarkReservedWords("primary");
MarkReservedWords("key");
MarkReservedWords("truncate");
MarkReservedWords("commit");
MarkReservedWords("rollback");
MarkReservedWords("user");
MarkReservedWords("with");
MarkReservedWords("password");
MarkReservedWords("grant");
MarkReservedWords("on");
MarkReservedWords("in");
MarkReservedWords("revoke");
//MarkReservedWords("insert");
MarkReservedWords("into");
MarkReservedWords("values");
MarkReservedWords("update");
//MarkReservedWords("set");
MarkReservedWords("where");
MarkReservedWords("from");
MarkReservedWords("select");
MarkReservedWords("order");
MarkReservedWords("by");
MarkReservedWords("limit");
MarkReservedWords("begin");
MarkReservedWords("apply");
MarkReservedWords("batch");
MarkReservedWords("count");
MarkReservedWords("min");
MarkReservedWords("max");
MarkReservedWords("sum");
MarkReservedWords("avg");
MarkReservedWords("map");
MarkReservedWords("list");
MarkReservedWords("if");
MarkReservedWords("else");
MarkReservedWords("switch");
MarkReservedWords("case");
MarkReservedWords("default");
MarkReservedWords("detener");
MarkReservedWords("while");
MarkReservedWords("do");
MarkReservedWords("for");
MarkReservedWords("cursor");
MarkReservedWords("procedure");
MarkReservedWords("call");
MarkReservedWords("break");
MarkReservedWords("return");
MarkReservedWords("continue");
MarkReservedWords("is");
MarkReservedWords("each");
MarkReservedWords("open");
MarkReservedWords("close");
MarkReservedWords("throw");
MarkReservedWords("try");
MarkReservedWords("catch");
MarkReservedWords("as");
NonGrammarTerminals.Add(ComentarioLinea);
NonGrammarTerminals.Add(ComentarioMultilinea);
var s = new NonTerminal("s");
var sentencias = new NonTerminal("sentencias");
var sentencia = new NonTerminal("sentencia");
var create_type = new NonTerminal("create_type");
var alter_add_type = new NonTerminal("add_type");
var alter_delete_type = new NonTerminal("add_type");
var if_not_exists = new NonTerminal("if_not_exists");
var if_exists = new NonTerminal("if_exists");
var declaracion_type = new NonTerminal("declaracion_type");
var delete_type = new NonTerminal("delete_type");
var declaraciones_type = new NonTerminal("declaraciones_type");
var lista_ids = new NonTerminal("lista_ids");
var condiciones = new NonTerminal("condiciones");
var condiciones_insert = new NonTerminal("condiciones_insert");
var primitivo = new NonTerminal("tipo_primitivo");
var tipo_variable = new NonTerminal("tipo_variable");
var condicion = new NonTerminal("condicion");
var condicion_insert = new NonTerminal("condicion_insert");
var comparacion = new NonTerminal("comparacion");
var expresion = new NonTerminal("expresion");
var id = new NonTerminal("id");
var tipo_id = new NonTerminal("tipo_id");
var casteo = new NonTerminal("casteo");
var create_database = new NonTerminal("create_database");
var use_database = new NonTerminal("use_database");
var drop_database = new NonTerminal("drop_database");
var create_table = new NonTerminal("create_table");
var definicion_columnas = new NonTerminal("definicion_columnas");
var columna = new NonTerminal("columna");
var tipo_columna = new NonTerminal("tipo_columna");
var llave_primaria = new NonTerminal("llave_primaria");
var alter_table_add = new NonTerminal("alter_table_add");
var alter_table_drop = new NonTerminal("alter_table_drop");
var drop_table = new NonTerminal("drop_table");
var truncate_table = new NonTerminal("truncate_table");
var commit = new NonTerminal("commit");
var rollback = new NonTerminal("rollback");
var create_user = new NonTerminal("create_user");
var grant = new NonTerminal("grant");
var revoke = new NonTerminal("revoke");
var insert_normal = new NonTerminal("insert_normal");
var insert_especial = new NonTerminal("insert_especial");
var update = new NonTerminal("update");
var op_unaria = new NonTerminal("op_unaria");
var asignacion_tabla = new NonTerminal("asignacion_tabla");
var asignaciones_tabla = new NonTerminal("asignaciones_tabla");
var where = new NonTerminal("where");
var delete = new NonTerminal("delete");
var select = new NonTerminal("select");
var lista_campos = new NonTerminal("lista_campos");
var order_by = new NonTerminal("order_by");
var limit = new NonTerminal("limit");
var asc_desc = new NonTerminal("asc_desc");
var order_by_order = new NonTerminal("order_by_order");
var order_by_campos = new NonTerminal("order_by_campos");
var batch = new NonTerminal("batch");
var sentencias_batch = new NonTerminal("sentencias_batch");
var sentencia_batch = new NonTerminal("sentencia_batch");
var funcion_agregacion = new NonTerminal("funcion_agregacion");
var tipo_agregacion = new NonTerminal("tipo_agregacion");
var pto_coma = new NonTerminal("pto_coma");
var collection = new NonTerminal("collection");
var asignacion_collection = new NonTerminal("tipo_collection");
var map_init = new NonTerminal("map");
var list_init = new NonTerminal("list");
var set_init = new NonTerminal("set");
var insert_map = new NonTerminal("insert_map");
var tipo_asignacion = new NonTerminal("tipo_asignacion");
var args = new NonTerminal("args");
var bloque = new NonTerminal("bloque");
var operacion_unaria = new NonTerminal("operacion_unaria");
var sentencias_bloque = new NonTerminal("sentencias_bloque");
var sentencia_bloque = new NonTerminal("sentencia_bloque");
var declaracion_variable = new NonTerminal("declaracion_variable");
var lista_variables = new NonTerminal("lista_variables");
var nombre_variable = new NonTerminal("nombre_variable");
var variable = new NonTerminal("variable");
var asignacion = new NonTerminal("asignacion");
var asignacion_variable = new NonTerminal("asignacion_variable");
var asignacion_operacion = new NonTerminal("asignacion_operacion");
var operador_asignador = new NonTerminal("operador_asignador");
var sentencia_if = new NonTerminal("sentencia_if");
var sentencia_else = new NonTerminal("sentencia_else");
var sentencia_switch = new NonTerminal("sentencia_switch");
var sentencias_case = new NonTerminal("sentencias_case");
var sentencia_case = new NonTerminal("sentencia_case");
var case_break = new NonTerminal("case_break");
var sentencia_while = new NonTerminal("sentencia_while");
var sentencia_do_while = new NonTerminal("sentencia_do_while");
var sentencia_for = new NonTerminal("sentencia_for");
var sentencia_for_each = new NonTerminal("sentencia_for_each");
var inicializacion_for = new NonTerminal("inicializacion_for");
var actualizacion_for = new NonTerminal("actualizacion_for");
var funcion = new NonTerminal("funcion");
var tipo_funcion = new NonTerminal("tipo_funcion");
var parametros = new NonTerminal("parametros");
var parametro = new NonTerminal("parametro");
var llamada_funcion = new NonTerminal("llamada_funcion");
var procedimiento = new NonTerminal("procedimiento");
var call = new NonTerminal("call");
var sentencia_return = new NonTerminal("sentencia_return");
var sentencia_continue = new NonTerminal("sentencia_continue");
var sentencia_break = new NonTerminal("sentencia_break");
var cursor = new NonTerminal("cursor");
var open_cursor = new NonTerminal("open_cursor");
var close_cursor = new NonTerminal("close_cursor");
var sentencia_throw = new NonTerminal("sentencia_throw");
var sentencia_try_catch = new NonTerminal("sentencia_try_catch");
var asignacion_user_type_set = new NonTerminal("valor_user_type");
var condiciones_asignacion = new NonTerminal("condiciones_asignacion");
var condicion_asignacion = new NonTerminal("condicion_asignacion");
this.Root = s;
RegisterOperators(12, Associativity.Left, ToTerm("("), ToTerm(")"));
RegisterOperators(11, ToTerm("++"), ToTerm("--"));
RegisterOperators(10, Associativity.Right, ToTerm("-"), ToTerm("!"));
RegisterOperators(9, Associativity.Left, ToTerm("/"), ToTerm("*"), ToTerm("%"), ToTerm("**"));
RegisterOperators(8, Associativity.Left, ToTerm("+"), ToTerm("-"));
RegisterOperators(7, ToTerm("<"), ToTerm("<="), ToTerm(">"), ToTerm(">="));
RegisterOperators(6, Associativity.Left, ToTerm("=="), ToTerm("!=="));
RegisterOperators(5, Associativity.Left, ToTerm("^"));
RegisterOperators(4, Associativity.Left, ToTerm("&&"));
RegisterOperators(3, Associativity.Left, ToTerm("||"));
RegisterOperators(2, Associativity.Right, ToTerm("?"), ToTerm(":"));
RegisterOperators(1, Associativity.Right, ToTerm("="));
s.Rule = sentencias;
sentencias.Rule = MakeStarRule(sentencias, sentencia);
sentencia.Rule =
create_type
| alter_add_type
| alter_delete_type
| delete_type
// DDL
| create_database
| use_database
| drop_database
| create_table
| alter_table_add
| alter_table_drop
| drop_table
| truncate_table
// TCL
| commit
| rollback
// DCL
| create_user
| grant
| revoke
// DML
| insert_normal
| insert_especial
| update
| delete
| select
| batch
| funcion_agregacion
// FCL
| bloque
| operacion_unaria
| declaracion_variable
| asignacion_variable
| asignacion_operacion
| sentencia_if
| sentencia_switch
| sentencia_while
| sentencia_do_while
| sentencia_for
| sentencia_for_each
| funcion
| llamada_funcion
| procedimiento
| call
| sentencia_break
| sentencia_return
| sentencia_continue
| cursor
| open_cursor
| close_cursor
| sentencia_throw
| sentencia_try_catch
;
// CQL general
create_type.Rule =
ToTerm("create") + ToTerm("type") + if_not_exists + ID + ToTerm("(") + declaraciones_type + ToTerm(")") + ToTerm(";")
;
if_not_exists.Rule =
ToTerm("if") + ToTerm("not") + ToTerm("exists")
| Empty;
if_exists.Rule =
ToTerm("if") + ToTerm("exists")
| Empty;
declaraciones_type.Rule =
MakePlusRule(declaraciones_type, ToTerm(","), declaracion_type);
declaracion_type.Rule =
condicion + primitivo
| condicion + asignacion_collection
| condicion + ID
;
alter_add_type.Rule =
ToTerm("alter") + ToTerm("type") + ID + ToTerm("add") + ToTerm("(") + declaraciones_type + ToTerm(")") + ToTerm(";")
;
alter_delete_type.Rule =
ToTerm("alter") + ToTerm("type") + ID + ToTerm("delete") + ToTerm("(") + lista_ids + ToTerm(")") + ToTerm(";")
;
lista_ids.Rule =
MakePlusRule(lista_ids, ToTerm(","), ID)
;
delete_type.Rule =
ToTerm("delete") + ToTerm("type") + ID + ToTerm(";")
;
primitivo.Rule =
ToTerm("int")
| ToTerm("double")
| ToTerm("string")
| ToTerm("boolean")
| ToTerm("date")
| ToTerm("time")
;
collection.Rule =
ToTerm("map")
| ToTerm("set")
| ToTerm("list")
;
asignacion_collection.Rule =
map_init
| set_init
| list_init
;
tipo_asignacion.Rule =
asignacion_collection
| primitivo
| ID
;
map_init.Rule =
ToTerm("map") + ToTerm("<") + tipo_variable + ToTerm(",") + tipo_asignacion + ToTerm(">")
;
set_init.Rule =
ToTerm("set") + ToTerm("<") + tipo_asignacion + ToTerm(">")
;
list_init.Rule =
ToTerm("list") + ToTerm("<") + tipo_asignacion + ToTerm(">")
;
// expresiones
condicion.Rule =
condicion + ToTerm("?") + condicion + ToTerm(":") + condicion
| condicion + ToTerm("&&") + condicion
| condicion + ToTerm("||") + condicion
| condicion + ToTerm("^") + condicion
| ToTerm("!") + condicion
| expresion + comparacion + expresion
| expresion
;
comparacion.Rule =
ToTerm("==")
| ToTerm("!=")
| ToTerm("<")
| ToTerm("<=")
| ToTerm(">")
| ToTerm(">=")
;
expresion.Rule =
expresion + ToTerm("+") + expresion
| expresion + ToTerm("-") + expresion
| expresion + ToTerm("*") + expresion
| expresion + ToTerm("/") + expresion
| expresion + ToTerm("**") + expresion
| expresion + ToTerm("%") + expresion
| ToTerm("-") + expresion
| id + op_unaria
//| ID + ToTerm("(") + args + ToTerm(")")
| ToTerm("@") + id + op_unaria
| ENTERO
| DECIMAL
| CADENA
| DATE
| TIME
| ToTerm("null")
| ToTerm("true")
| ToTerm("false")
| ToTerm("(") + condicion + ToTerm(")")
;
op_unaria.Rule =
ToTerm("++")
| ToTerm("--")
| Empty
;
id.Rule =
MakePlusRule(id, ToTerm("."), tipo_id)
;
tipo_id.Rule =
ID
| ID + ToTerm("(") + args + ToTerm(")")
| ID + ToTerm("[") + args + ToTerm("]")
;
args.Rule =
MakeStarRule(args, ToTerm(","), condicion | asignacion_user_type_set)
;
casteo.Rule =
ToTerm("(") + primitivo + ToTerm(")")
;
condiciones.Rule =
MakePlusRule(condiciones, ToTerm(","), condicion)
;
condiciones_insert.Rule =
MakePlusRule(condiciones_insert, ToTerm(","), condicion_insert)
;
condicion_insert.Rule =
condicion
| ToTerm("{") + insert_map + ToTerm("}")
| ToTerm("{") + condiciones + ToTerm("}")
| ToTerm("[") + condiciones + ToTerm("]")
;
insert_map.Rule =
MakePlusRule(insert_map, ToTerm(","), condicion + ToTerm(":") + condicion)
;
// DDL
create_database.Rule =
ToTerm("create") + ToTerm("database") + if_not_exists + ID + ToTerm(";")
;
use_database.Rule =
ToTerm("use") + ID + ToTerm(";")
;
drop_database.Rule =
ToTerm("drop") + ToTerm("database") + ID + ToTerm(";")
;
create_table.Rule =
ToTerm("create") + ToTerm("table") + if_not_exists + ID + ToTerm("(") + definicion_columnas + ToTerm(")") + ToTerm(";")
;
definicion_columnas.Rule =
MakePlusRule(definicion_columnas, ToTerm(","), columna)
;
columna.Rule =
ID + tipo_columna + llave_primaria
| llave_primaria + ToTerm("(") + lista_ids + ToTerm(")")
;
llave_primaria.Rule =
ToTerm("primary") + ToTerm("key")
| Empty
;
tipo_columna.Rule =
ToTerm("counter")
| primitivo
| asignacion_collection
| ID
;
alter_table_add.Rule =
ToTerm("alter") + ToTerm("table") + ID + ToTerm("add") + declaraciones_type + ToTerm(";")
;
alter_table_drop.Rule =
ToTerm("alter") + ToTerm("table") + ID + ToTerm("drop") + lista_ids + ToTerm(";")
;
drop_table.Rule =
ToTerm("drop") + ToTerm("table") + if_exists + ID + ToTerm(";")
;
truncate_table.Rule =
ToTerm("truncate") + ToTerm("table") + ID + ToTerm(";")
;
// TCL
commit.Rule =
ToTerm("commit") + ToTerm(";")
;
rollback.Rule =
ToTerm("rollback") + ToTerm(";")
;
// DCL
create_user.Rule =
ToTerm("create") + ToTerm("user") + ID + ToTerm("with") + ToTerm("password") + condicion + ToTerm(";")
;
grant.Rule =
ToTerm("grant") + ID + ToTerm("on") + ID + ToTerm(";")
;
revoke.Rule =
ToTerm("revoke") + ID + ToTerm("on") + ID + ToTerm(";")
;
// DML
insert_normal.Rule =
ToTerm("insert") + ToTerm("into") + ID + ToTerm("values") + ToTerm("(") + condiciones_insert + ToTerm(")") + ToTerm(";")
;
insert_especial.Rule =
ToTerm("insert") + ToTerm("into") + ID + ToTerm("(") + lista_ids + ToTerm(")") + ToTerm("values") + ToTerm("(") + condiciones_insert + ToTerm(")") + ToTerm(";")
;
update.Rule =
ToTerm("update") + ID + ToTerm("set") + asignaciones_tabla + where + ToTerm(";")
;
asignaciones_tabla.Rule =
MakePlusRule(asignaciones_tabla, ToTerm(","), asignacion_tabla)
;
asignacion_tabla.Rule =
id + ToTerm("=") + condicion
| id + ToTerm("=") + condiciones_insert
| id + ToTerm("=") + ID + ToTerm("+") + condiciones_insert
| id + ToTerm("=") + ID + ToTerm("-") + condiciones_insert
;
where.Rule =
ToTerm("where") + condicion
| ToTerm("where") + condicion + ToTerm("in") + condicion
| ToTerm("where") + condicion + ToTerm("in") + ToTerm("(") + condiciones + ToTerm(")")
| Empty
;
delete.Rule =
ToTerm("delete") + ToTerm("from") + ID + where + ToTerm(";")
| ToTerm("delete") + id + ToTerm("from") + ID + where + ToTerm(";")
;
select.Rule =
ToTerm("select") + lista_campos + ToTerm("from") + ID + where + order_by + limit + pto_coma
;
pto_coma.Rule =
ToTerm(";")
| Empty
;
lista_campos.Rule =
ToTerm("*")
| condiciones
;
order_by.Rule =
ToTerm("order") + ToTerm("by") + order_by_order
| Empty
;
order_by_order.Rule =
MakePlusRule(order_by_order, ToTerm(","), order_by_campos)
;
order_by_campos.Rule =
ID + asc_desc
;
asc_desc.Rule =
ToTerm("asc")
| ToTerm("desc")
| Empty
;
limit.Rule =
ToTerm("limit") + condicion
| Empty
;
batch.Rule =
ToTerm("begin") + ToTerm("batch") + sentencias_batch + ToTerm("apply") + ToTerm("batch") + ToTerm(";")
;
sentencias_batch.Rule =
MakePlusRule(sentencias_batch, sentencia_batch)
;
sentencia_batch.Rule =
insert_normal
| insert_especial
| delete
| update
;
funcion_agregacion.Rule =
tipo_agregacion + ToTerm("(") + ToTerm("<<") + select + ToTerm(">>") + ToTerm(")") + ToTerm(";")
;
tipo_agregacion.Rule =
ToTerm("count")
| ToTerm("min")
| ToTerm("max")
| ToTerm("sum")
| ToTerm("avg")
;
// FCL
bloque.Rule =
ToTerm("{") + sentencias_bloque + ToTerm("}")
;
sentencias_bloque.Rule =
MakeStarRule(sentencias_bloque, sentencia_bloque)
;
sentencia_bloque.Rule =
// DDL
create_database
| use_database
| drop_database
| create_table
| alter_table_add
| alter_table_drop
| drop_table
| truncate_table
// DML
| insert_normal
| insert_especial
| update
| delete
| select
| batch
| funcion_agregacion
// FCL
| bloque
| operacion_unaria
| declaracion_variable
| asignacion_variable
| asignacion_operacion
| sentencia_if
| sentencia_switch
| sentencia_while
| sentencia_do_while
| sentencia_for
| sentencia_for_each
| funcion
| llamada_funcion
| procedimiento
| call
| sentencia_break
| sentencia_return
| sentencia_continue
| cursor
| open_cursor
| close_cursor
| sentencia_throw
| sentencia_try_catch
;
operacion_unaria.Rule =
ToTerm("@") + id + op_unaria + ToTerm(";")
;
declaracion_variable.Rule =
tipo_variable + lista_variables + asignacion + ToTerm(";")
| tipo_variable + lista_variables + ToTerm(";")
;
tipo_variable.Rule =
primitivo
| collection
| ID
;
lista_variables.Rule =
MakePlusRule(lista_variables, ToTerm(","), nombre_variable)
;
nombre_variable.Rule =
ToTerm("@") + ID
;
variable.Rule =
ToTerm("@") + id
;
asignacion.Rule =
ToTerm("=") + condicion
| ToTerm("=") + casteo + condicion
| ToTerm("=") + asignacion_user_type_set
| ToTerm("=") + ToTerm("new") + ID
| ToTerm("=") + ToTerm("new") + asignacion_collection
| ToTerm("=") + ToTerm("[") + insert_map + ToTerm("]")
;
asignacion_user_type_set.Rule =
ToTerm("{") + condiciones_asignacion + ToTerm("}") + ToTerm("as") + ID
| ToTerm("{") + condiciones_asignacion + ToTerm("}")
| ToTerm("[") + condiciones_asignacion + ToTerm("]")
;
condiciones_asignacion.Rule =
MakePlusRule(condiciones_asignacion, ToTerm(","), condicion_asignacion)
;
condicion_asignacion.Rule =
condicion
| asignacion_user_type_set
;
asignacion_variable.Rule =
variable + asignacion + ToTerm(";")
;
asignacion_operacion.Rule =
variable + operador_asignador + ENTERO + ToTerm(";")
;
operador_asignador.Rule =
ToTerm("+=")
| ToTerm("*=")
| ToTerm("-=")
| ToTerm("/=")
;
sentencia_if.Rule =
ToTerm("if") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
| ToTerm("if") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}") + sentencia_else
;
sentencia_else.Rule =
ToTerm("else") + ToTerm("if") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
| ToTerm("else") + ToTerm("if") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}") + sentencia_else
| ToTerm("else") + ToTerm("{") + sentencias + ToTerm("}")
;
sentencia_switch.Rule =
ToTerm("switch") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias_case + ToTerm("}")
;
sentencias_case.Rule =
MakePlusRule(sentencias_case, sentencia_case)
;
sentencia_case.Rule =
ToTerm("case") + condicion + ToTerm(":") + sentencias + case_break
| ToTerm("default") + ToTerm(":") + sentencias + case_break
;
case_break.Rule =
sentencia_break
| Empty;
sentencia_while.Rule =
ToTerm("while") + ToTerm("(") + condicion + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
;
sentencia_do_while.Rule =
ToTerm("do") + ToTerm("{") + sentencias + ToTerm("}") + ToTerm("while") + ToTerm("(") + condicion + ToTerm(")") + ToTerm(";")
;
sentencia_for.Rule =
ToTerm("for") + ToTerm("(") + inicializacion_for + ToTerm(";") + condicion + ToTerm(";") + actualizacion_for + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
;
inicializacion_for.Rule =
tipo_variable + nombre_variable + asignacion
| variable + asignacion
;
actualizacion_for.Rule =
variable + asignacion
| ToTerm("@") + id + op_unaria
;
sentencia_for_each.Rule =
ToTerm("for") + ToTerm("each") + ToTerm("(") + parametros + ToTerm(")") + ToTerm("in") + variable + ToTerm("{") + sentencias + ToTerm("}")
;
funcion.Rule =
tipo_funcion + ID + ToTerm("(") + parametros + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
;
tipo_funcion.Rule =
ToTerm("cursor")
| primitivo
| collection
| ID
;
parametros.Rule =
MakeStarRule(parametros, ToTerm(","), parametro)
;
parametro.Rule =
tipo_variable + variable
;
llamada_funcion.Rule =
ID + ToTerm("(") + args + ToTerm(")") + ToTerm(";")
;
procedimiento.Rule =
ToTerm("procedure") + ID + ToTerm("(") + parametros + ToTerm(")") + ToTerm(",") + ToTerm("(") + parametros + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
;
call.Rule =
ToTerm("call") + ID + ToTerm("(") + args + ToTerm(")") + ToTerm(";")
| lista_variables + ToTerm("=") + ToTerm("call") + ID + ToTerm("(") + args + ToTerm(")") + ToTerm(";")
;
sentencia_break.Rule =
ToTerm("break") + ToTerm(";")
;
sentencia_return.Rule =
ToTerm("return") + ToTerm(";")
| ToTerm("return") + condiciones + ToTerm(";")
;
sentencia_continue.Rule =
ToTerm("continue") + ToTerm(";")
;
cursor.Rule =
ToTerm("cursor") + variable + ToTerm("is") + select
;
open_cursor.Rule =
ToTerm("open") + variable + ToTerm(";")
;
close_cursor.Rule =
ToTerm("close") + variable + ToTerm(";")
;
sentencia_throw.Rule =
ToTerm("throw") + ToTerm("new") + ID + ToTerm(";")
;
sentencia_try_catch.Rule =
ToTerm("try") + ToTerm("{") + sentencias + ToTerm("}") + ToTerm("catch") + ToTerm("(") + ID + variable + ToTerm(")") + ToTerm("{") + sentencias + ToTerm("}")
;
}
public gramaticaCHISON() : base(caseSensitive: false)
{
#region TERMINAL
var inicio = ToTerm("$<");
var fin = ToTerm(">$");
var importini = ToTerm("${");
var importfin = ToTerm("}$");
var bdds = ToTerm("DATABASES");
var usr = ToTerm("USERS");
var name = ToTerm("NAME");
var dato = ToTerm("DATA");
var pass = ToTerm("PASSWORD");
var perm = ToTerm("PERMISSIONS");
var cqltype = ToTerm("CQL-TYPE");
var table = ToTerm("TABLE");
var col = ToTerm("COLUMNS");
var type = ToTerm("TYPE");
var pk = ToTerm("PK");
var verdad = ToTerm("TRUE");
var falso = ToTerm("FALSE");
var obj = ToTerm("OBJECT");
var attr = ToTerm("ATTRS");
var proc = ToTerm("PROCEDURE");
var param = ToTerm("PARAMETERS");
var instr = ToTerm("INSTR");
var ass = ToTerm("AS");
var dentro = ToTerm("IN");
var fuera = ToTerm("OUT");
var datoint = ToTerm("Int");
var datodouble = ToTerm("Double");
var datostring = ToTerm("String");
var datodate = ToTerm("Date");
var datotime = ToTerm("Time");
var datobool = ToTerm("Boolean");
var datocounter = ToTerm("Counter");
var lista = ToTerm("List");
var mapa = ToTerm("Map");
var set = ToTerm("Set");
#endregion
#region ER
//RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
//RegexBasedTerminal ID = new RegexBasedTerminal("ID", "[A-Za-z_@][A-Za-z0-9_@]*");
NumberLiteral number = new NumberLiteral("number");
IdentifierTerminal id = new IdentifierTerminal("ID");
StringLiteral tcadena = new StringLiteral("cadena", "$");
/* se indica que la cadena va a empezar con " (comillas dobles) y con
* esto acepta cualquier cosa que venga despues de las comillas dobles */
#endregion
#region NO TERMINAL
NonTerminal S = new NonTerminal("S");
NonTerminal CHISON = new NonTerminal("CHISON");
NonTerminal INFO = new NonTerminal("INFO");
NonTerminal LDBS = new NonTerminal("LDBS");
NonTerminal LDB = new NonTerminal("LDB");
NonTerminal LOTHERDB = new NonTerminal("LOTHERDB");
NonTerminal LUSRS = new NonTerminal("LUSRS");
NonTerminal LUSR = new NonTerminal("LUSR");
NonTerminal LIDS = new NonTerminal("LIDS");
NonTerminal LOTHERUSR = new NonTerminal("LOTHERUSR");
NonTerminal LPERMS = new NonTerminal("LPERMS");
NonTerminal LPERM = new NonTerminal("LPERM");
NonTerminal LOTHERPERM = new NonTerminal("LOTHERPERM");
NonTerminal LDATADBS = new NonTerminal("LDATADBS");
NonTerminal LDATADB = new NonTerminal("LDATADB");
NonTerminal LDATA = new NonTerminal("LDATA");
NonTerminal TABLES = new NonTerminal("TABLES");
NonTerminal LCOLS = new NonTerminal("LCOLS");
NonTerminal LCOL = new NonTerminal("LCOL");
NonTerminal LCOLUM = new NonTerminal("LCOLUM");
NonTerminal LDATATABS = new NonTerminal("LDATATABS");
NonTerminal LDATATAB = new NonTerminal("LDATATAB");
NonTerminal OBJECTS = new NonTerminal("OBJECTS");
NonTerminal LATTRS = new NonTerminal("LATTRS");
NonTerminal LATTR = new NonTerminal("LATTR");
NonTerminal LATT = new NonTerminal("LATT");
NonTerminal PROCEDURES = new NonTerminal("PROCEDURES");
NonTerminal LPARMS = new NonTerminal("LPARMS");
NonTerminal LPARM = new NonTerminal("LPARM");
NonTerminal LPROC = new NonTerminal("LPROC");
NonTerminal FORM = new NonTerminal("FORM");
NonTerminal VALUES = new NonTerminal("VALUES");
NonTerminal TIPOS = new NonTerminal("TIPOS");
NonTerminal BOOLS = new NonTerminal("BOOLS");
NonTerminal DATATAB = new NonTerminal("DATATAB");
NonTerminal VAL = new NonTerminal("VAL");
NonTerminal EXP = new NonTerminal("EXP");
#endregion
#region COMMENT
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n", "\r\n"); //si viene una nueva linea se termina de reconocer el comentario.
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/*", "*/");
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
#endregion
#region GRAMATICA
S.Rule = CHISON;
CHISON.Rule = inicio + "\"" + bdds + "\"" + "=" + "[" + LDBS + "," + "\"" + usr + "\""
+ "=" + "[" + LUSRS + fin;
LDBS.Rule = "]"
| LDB + "]";
LDB.Rule = MakePlusRule(LDB, ToTerm(","), LOTHERDB);
LOTHERDB.Rule = "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" + dato
+ "\"" + "=" + "[" + LDATADBS + ">"
| importini + LIDS + importfin;
LIDS.Rule = MakePlusRule(LIDS, ToTerm("."), id);
LUSRS.Rule = LUSR + "]"
| "]";
LUSR.Rule = MakePlusRule(LUSR, ToTerm(","), LOTHERUSR);
LOTHERUSR.Rule = "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" + pass + "\""
+ VALUES + "," + "\"" + perm + "\"" + "=" + "[" + LPERMS + ">"
| importini + LIDS + importfin;
LPERMS.Rule = LPERM + "]"
| "]";
LPERM.Rule = MakePlusRule(LPERM, ToTerm(","), LOTHERPERM);
LOTHERPERM.Rule = "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + ">"
| importini + LIDS + importfin;
LDATADBS.Rule = LDATADB + "]"
| "]";
LDATADB.Rule = MakePlusRule(LDATADB, ToTerm(","), LDATA);
LDATA.Rule = importini + LIDS + importfin
| "<" + "\"" + cqltype + "\"" + "=" + "\"" + INFO;
INFO.Rule = TABLES
| OBJECTS
| PROCEDURES;
TABLES.Rule = table + "\"" + "," + "\"" + name + "\""
+ "=" + "\"" + id + "\"" + "," + "\"" + col + "\"" + "=" + "[" + LCOLS + "," + "\"" + dato
+ "\"" + "=" + "[" + LDATATABS + ">";
LCOLS.Rule = LCOLUM + "]"
| "]";
LCOLUM.Rule = MakePlusRule(LCOLUM, ToTerm(","), LCOL);
LCOL.Rule = "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" + type + "\"" + "="
+ "\"" + TIPOS + "\"" + "," + "\"" + pk + "\"" + "=" + BOOLS + ">"
| importini + LIDS + importfin;
LDATATABS.Rule = "<" + LDATATAB + ">" + "]"
| "]";
LDATATAB.Rule = MakePlusRule(LDATATAB, ToTerm(","), DATATAB);
DATATAB.Rule = "\"" + id + "\"" + "=" + EXP
| importini + LIDS + importfin;
OBJECTS.Rule = obj + "\"" + "," + "\"" + name + "\""
+ "=" + "\"" + id + "\"" + "," + "\"" + attr + "\"" + "=" + "[" + LATTRS + ">";
LATTRS.Rule = LATTR + "]"
| "]";
LATTR.Rule = MakePlusRule(LATTR, ToTerm(","), LATT);
LATT.Rule = "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" + type + "\"" + "="
+ "\"" + TIPOS + "\"" + ">"
| importini + LIDS + importfin;
PROCEDURES.Rule = proc + "\"" + "," + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" +
param + "\"" + "=" + "[" + LPARMS + "," + "\"" + instr + "\"" + "=" + tcadena + ">";
LPARMS.Rule = LPARM + "]"
| "]";
LPARM.Rule = MakePlusRule(LPARM, ToTerm(","), LPROC);
LPROC.Rule = importini + LIDS + importfin
| "<" + "\"" + name + "\"" + "=" + "\"" + id + "\"" + "," + "\"" + type + "\"" + "=" + "\"" + TIPOS + "\"" + ","
+ "\"" + ass + "\"" + "=" + FORM + ">";
FORM.Rule = dentro
| fuera;
VALUES.Rule = MakePlusRule(VALUES, EXP);
EXP.Rule = EXP + "||" + EXP
| EXP + "&&" + EXP
| EXP + "^" + EXP
| EXP + "<>" + EXP
| EXP + "==" + EXP
| EXP + "<" + EXP
| EXP + ">" + EXP
| EXP + ">=" + EXP
| EXP + "<=" + EXP
| EXP + "+" + EXP
| EXP + "-" + EXP
| EXP + "*" + EXP
| EXP + "/" + EXP
| EXP + "%" + EXP
| EXP + "**" + EXP
| "not" + EXP
| "-" + EXP
| EXP + "++"
| EXP + "--"
| ToTerm("(") + EXP + ToTerm(")")
| VAL;
VAL.Rule = number
| id
| tcadena
| BOOLS;
TIPOS.Rule = datoint
| datostring
| datodouble
| datodate
| datotime
| datobool
| datocounter;
BOOLS.Rule = verdad
| falso;
#endregion
#region PREFERENCIA
this.Root = S;
this.MarkPunctuation("[", "]", "<", ">", ",", "=", "\"", ".");
#endregion
}
public Gramatica() : base(caseSensitive: false)
{
#region TERMINALES
#region Reservadas
KeyTerm
RVAR = ToTerm("var", "RVAR"),
RNULL = ToTerm("null", "RNULL"),
RLOG = ToTerm("log", "RLOG"),
RALERT = ToTerm("alert", "RALERT"),
RGRAPH = ToTerm("graph", "RGRAPH"),
RIF = ToTerm("if", "RIF"),
RELSE = ToTerm("else", "RELSE"),
RDO = ToTerm("do", "RDO"),
RWHILE = ToTerm("while", "RWHILE"),
RFOR = ToTerm("for", "RFOR"),
RSWITCH = ToTerm("switch", "RSWITCH"),
RCASE = ToTerm("case", "RCASE"),
RDEFAULT = ToTerm("default", "RDEFAULT"),
RBREAK = ToTerm("break", "RBREAK"),
RCONTINUE = ToTerm("continue", "RCONTINUE"),
RRETURN = ToTerm("return", "RRETURN"),
RIMPORTAR = ToTerm("importar", "RIMPORTAR"),
RTRUE = ToTerm("true", "RTRUE"),
RFALSE = ToTerm("false", "RFALSE"),
RCLASS = ToTerm("class", "RCLASS"),
RNEW = ToTerm("new", "RNEW"),
RFUNCTION = ToTerm("function", "RFUNCTION"),
RVOID = ToTerm("void", "RVOID");
MarkReservedWords("var", "null", "log", "alert", "graph", "if", "else", "do", "while", "for", "switch",
"case", "default", "break", "continue", "return", "importar", "true", "false", "class",
"new", "function", "void");
#endregion
#region Operadores
Terminal
PARENTA = ToTerm("(", "PARENTA"),
PARENTC = ToTerm(")", "PARENTC"),
CORCHETEA = ToTerm("[", "CORCHETEA"),
CORCHETEC = ToTerm("]", "CORCHETEC"),
LLAVEA = ToTerm("{", "LLAVEA"),
LLAVEC = ToTerm("}", "LLAVEC"),
SIGNOIGUAL = ToTerm("=", "SIGNOIGUAL"),
IGUALQUE = ToTerm("==", "IGUALQUE"),
DISTINTOQUE = ToTerm("<>", "DISTINTOQUE"),
MENORQUE = ToTerm("<", "MENORQUE"),
MENORIGUALQUE = ToTerm("<=", "MENORIGUALQUE"),
MAYORQUE = ToTerm(">", "MAYORQUE"),
MAYORIGUALQUE = ToTerm(">=", "MAYORIGUALQUE"),
AND = ToTerm("&&", "AND"),
OR = ToTerm("||", "OR"),
XOR = ToTerm("^", "XOR"),
NOT = ToTerm("!", "NOT"),
SIGNOMAS = ToTerm("+", "SIGNOMAS"),
AUMENTO = ToTerm("++", "AUMENTO"),
SIGNOMENOS = ToTerm("-", "SIGNOMENOS"),
DECREMENTO = ToTerm("--", "DECREMENTO"),
SIGNOPOR = ToTerm("*", "SIGNOPOR"),
SIGNODIVIDIDO = ToTerm("/", "SIGNODIVIDIDO"),
SIGNOPOTENCIA = ToTerm("pow", "SIGNOPOTENCIA"),
PUNTO = ToTerm(".", "PUNTO"),
COMA = ToTerm(",", "COMA"),
PYCOMA = ToTerm(";", "PYCOMA"),
DOSPUNTOS = ToTerm(":", "DOSPUNTOS");
#endregion
#region ER
NumberLiteral NUMERO = new NumberLiteral("NUMERO");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("IDENTIFICADOR");
StringLiteral CADENA = new StringLiteral("CADENA", "\"", StringOptions.AllowsAllEscapes);
StringLiteral CHAR = new StringLiteral("CHAR", "\'", StringOptions.IsChar);
#endregion
#region Comentarios
CommentTerminal comentarioMultilinea = new CommentTerminal("comentarioMultiLinea", "/*", "*/");
CommentTerminal comentario = new CommentTerminal("comentarioUniLinea", "//", "\n", "\r\n");
Terminal espacio = ToTerm(" ");
Terminal tab = ToTerm("\t");
base.NonGrammarTerminals.Add(comentarioMultilinea);
base.NonGrammarTerminals.Add(comentario);
base.NonGrammarTerminals.Add(espacio);
base.NonGrammarTerminals.Add(tab);
#endregion
#endregion
#region NoTerminales
NonTerminal inicio = new NonTerminal("inicio");
NonTerminal instrucciones_global = new NonTerminal("instrucciones_global");
NonTerminal instruccion_global = new NonTerminal("instruccion_global");
NonTerminal declaracion_clase = new NonTerminal("declaracion_clase");
NonTerminal miembros_clase = new NonTerminal("miembros_clase");
NonTerminal miembro_clase = new NonTerminal("miembro_clase");
NonTerminal definicion_metodo = new NonTerminal("definicion_metodo");
NonTerminal definicion_metodo_global = new NonTerminal("definicion_metodo_global");
NonTerminal decl_lista_parametros = new NonTerminal("decl_lista_parametros");
NonTerminal decl_parametro = new NonTerminal("decl_parametro");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instruccion_for = new NonTerminal("instruccion_for");
NonTerminal instruccion_while = new NonTerminal("instruccion_while");
NonTerminal instruccion_dowhile = new NonTerminal("instruccion_dowhile");
NonTerminal instruccion_switch = new NonTerminal("instruccion_switch");
NonTerminal lista_casos = new NonTerminal("lista_casos");
NonTerminal caso = new NonTerminal("caso");
NonTerminal caso_default = new NonTerminal("caso_default");
NonTerminal identificadores = new NonTerminal("identificadores");
NonTerminal declaracion_asignacion = new NonTerminal("declaracion_asignacion");
NonTerminal asignacion = new NonTerminal("asignacion");
NonTerminal asig_acceso_celda = new NonTerminal("asig_acceso_celda");
NonTerminal declaracion = new NonTerminal("declaracion");
NonTerminal declaraciones_con_valor = new NonTerminal("declaraciones_con_valor");
NonTerminal declaracion_con_valor = new NonTerminal("declaracion_con_valor");
NonTerminal declaracion_global = new NonTerminal("declaracion_global");
NonTerminal declaraciones_con_valor_global = new NonTerminal("declaraciones_con_valor_global");
NonTerminal declaracion_con_valor_global = new NonTerminal("declaracion_con_valor_global");
NonTerminal decl_celdas = new NonTerminal("decl_celdas");
NonTerminal arr_una_dimension = new NonTerminal("arr_una_dimension");
NonTerminal arr_dos_dimension = new NonTerminal("arr_dos_dimension");
NonTerminal arr_dos_dimension_aux = new NonTerminal("arr_dos_dimension_aux");
NonTerminal arr_tres_dimension = new NonTerminal("arr_tres_dimension");
NonTerminal arr_tres_dimension_aux = new NonTerminal("arr_tres_dimension_aux");
NonTerminal bloque_if_elseif_else = new NonTerminal("bloque_if_elseif_else");
NonTerminal instruccion_if = new NonTerminal("instruccion_if");
NonTerminal instrucciones_elseif = new NonTerminal("instrucciones_elseif");
NonTerminal instruccion_elseif = new NonTerminal("instruccion_elseif");
NonTerminal instruccion_else = new NonTerminal("instruccion_else");
NonTerminal expresion_full = new NonTerminal("expresion_full");
NonTerminal expresion = new NonTerminal("expresion");
NonTerminal id = new NonTerminal("id");
NonTerminal llamada_metodo = new NonTerminal("llamada_metodo");
NonTerminal lista_expresiones = new NonTerminal("lista_expresiones");
NonTerminal expresion_array = new NonTerminal("expresion_array");
#endregion
#region Gramatica
inicio.Rule =//skip
/*1*/ instrucciones_global;
instrucciones_global.Rule =//
/*N*/ MakePlusRule(instrucciones_global, instruccion_global);
instruccion_global.Rule =//
/*1*/ declaracion_clase
/*1*/ | declaracion_global + PYCOMA
/*1*/ | asignacion + PYCOMA
/*4*/ | RIMPORTAR + PARENTA + expresion + PARENTC + PYCOMA
/*3*/ | RLOG + PARENTA + PARENTC + PYCOMA
/*4*/ | RLOG + PARENTA + expresion_full + PARENTC + PYCOMA
/*3*/ | RALERT + PARENTA + PARENTC + PYCOMA
/*4*/ | RALERT + PARENTA + expresion_full + PARENTC + PYCOMA
/*5*/ | RGRAPH + PARENTA + expresion + COMA + expresion + PARENTC + PYCOMA
/*1*/ | bloque_if_elseif_else
/*1*/ | instruccion_for
/*1*/ | instruccion_while
/*1*/ | instruccion_dowhile
/*1*/ | instruccion_switch
/*1*/ | RBREAK + PYCOMA
/*1*/ | RCONTINUE + PYCOMA
/*2*/ | RRETURN + expresion_full + PYCOMA
/*1*/ | expresion_full + PYCOMA
/*3*/ | IDENTIFICADOR + PARENTA + PARENTC + LLAVEA + LLAVEC
/*4*/ | IDENTIFICADOR + PARENTA + PARENTC + LLAVEA + instrucciones + LLAVEC
/*1*/ | definicion_metodo_global + LLAVEA + LLAVEC
/*2*/ | definicion_metodo_global + LLAVEA + instrucciones + LLAVEC;
declaracion_clase.Rule =//
/*1*/ RCLASS + IDENTIFICADOR + LLAVEA + LLAVEC
/*2*/ | RCLASS + IDENTIFICADOR + LLAVEA + miembros_clase + LLAVEC;
miembros_clase.Rule =//
/*N*/ MakePlusRule(miembros_clase, miembro_clase);
miembro_clase.Rule =//
/*1*/ declaracion_asignacion + PYCOMA
/*1*/ | definicion_metodo + LLAVEA + LLAVEC
/*2*/ | definicion_metodo + LLAVEA + instrucciones + LLAVEC;
definicion_metodo.Rule =//
/*3*/ RFUNCTION + IDENTIFICADOR + PARENTA + PARENTC
/*4*/ | RFUNCTION + IDENTIFICADOR + PARENTA + decl_lista_parametros + PARENTC
/*4*/ | RFUNCTION + RVOID + IDENTIFICADOR + PARENTA + PARENTC
/*5*/ | RFUNCTION + RVOID + IDENTIFICADOR + PARENTA + decl_lista_parametros + PARENTC;
definicion_metodo_global.Rule =//
/*3*/ RFUNCTION + IDENTIFICADOR + PARENTA + PARENTC
/*4*/ | RFUNCTION + IDENTIFICADOR + PARENTA + decl_lista_parametros + PARENTC
/*4*/ | RFUNCTION + RVOID + IDENTIFICADOR + PARENTA + PARENTC
/*5*/ | RFUNCTION + RVOID + IDENTIFICADOR + PARENTA + decl_lista_parametros + PARENTC;
decl_lista_parametros.Rule =//
/*N*/ MakePlusRule(decl_lista_parametros, COMA, decl_parametro);
decl_parametro.Rule =//skip
/*1*/ RVAR + IDENTIFICADOR;
instrucciones.Rule =//
/*N*/ MakePlusRule(instrucciones, instruccion);
instruccion.Rule =//
/*1*/ declaracion_asignacion + PYCOMA
/*3*/ | RLOG + PARENTA + PARENTC + PYCOMA
/*4*/ | RLOG + PARENTA + expresion_full + PARENTC + PYCOMA
/*3*/ | RALERT + PARENTA + PARENTC + PYCOMA
/*4*/ | RALERT + PARENTA + expresion_full + PARENTC + PYCOMA
/*5*/ | RGRAPH + PARENTA + expresion + COMA + expresion + PARENTC + PYCOMA
/*1*/ | bloque_if_elseif_else
/*1*/ | instruccion_for
/*1*/ | instruccion_while
/*1*/ | instruccion_dowhile
/*1*/ | instruccion_switch
/*1*/ | RBREAK + PYCOMA
/*1*/ | RCONTINUE + PYCOMA
/*2*/ | RRETURN + expresion_full + PYCOMA
/*1*/ | expresion_full + PYCOMA;
instruccion_for.Rule =//
/*5*/ RFOR + PARENTA + declaracion_asignacion + PYCOMA + expresion + PYCOMA + expresion + PARENTC + LLAVEA + LLAVEC
/*6*/ | RFOR + PARENTA + declaracion_asignacion + PYCOMA + expresion + PYCOMA + expresion + PARENTC + LLAVEA + instrucciones + LLAVEC
/*5*/ | RFOR + PARENTA + declaracion_asignacion + PYCOMA + expresion + PYCOMA + asignacion + PARENTC + LLAVEA + LLAVEC
/*6*/ | RFOR + PARENTA + declaracion_asignacion + PYCOMA + expresion + PYCOMA + asignacion + PARENTC + LLAVEA + instrucciones + LLAVEC;
instruccion_while.Rule =//
/*3*/ RWHILE + PARENTA + expresion + PARENTC + LLAVEA + LLAVEC
/*4*/ | RWHILE + PARENTA + expresion + PARENTC + LLAVEA + instrucciones + LLAVEC;
instruccion_dowhile.Rule =//
/*3*/ RDO + LLAVEA + LLAVEC + RWHILE + PARENTA + expresion + PARENTC + PYCOMA
/*4*/ | RDO + LLAVEA + instrucciones + LLAVEC + RWHILE + PARENTA + expresion + PARENTC + PYCOMA;
instruccion_switch.Rule =//
/*3*/ RSWITCH + PARENTA + expresion + PARENTC + LLAVEA + LLAVEC
/*4*/ | RSWITCH + PARENTA + expresion + PARENTC + LLAVEA + caso_default + LLAVEC
/*4*/ | RSWITCH + PARENTA + expresion + PARENTC + LLAVEA + lista_casos + LLAVEC
/*5*/ | RSWITCH + PARENTA + expresion + PARENTC + LLAVEA + lista_casos + caso_default + LLAVEC;
lista_casos.Rule =//
/*N*/ MakePlusRule(lista_casos, caso);
caso.Rule =//
/*1*/ RCASE + expresion + DOSPUNTOS
/*2*/ | RCASE + expresion + DOSPUNTOS + instrucciones;
caso_default.Rule =//
/*0*/ RDEFAULT + DOSPUNTOS
/*1*/ | RDEFAULT + DOSPUNTOS + instrucciones;
identificadores.Rule =//
/*N*/ MakePlusRule(identificadores, COMA, IDENTIFICADOR);
declaracion_asignacion.Rule =//
/*1*/ declaracion
/*1*/ | asignacion;
asignacion.Rule =//
/*1*/ id + SIGNOIGUAL + expresion;
asig_acceso_celda.Rule =//cv
/*1*/ CORCHETEA + expresion + CORCHETEC;
declaracion.Rule =//
/*1*/ RVAR + identificadores
/*2*/ | RVAR + identificadores + decl_celdas
/*1*/ | RVAR + declaraciones_con_valor
/*2*/ | RVAR + declaraciones_con_valor + COMA + identificadores
/*3*/ | RVAR + declaraciones_con_valor + COMA + identificadores + decl_celdas;
declaraciones_con_valor.Rule =//
/*N*/ MakePlusRule(declaraciones_con_valor, COMA, declaracion_con_valor);
declaracion_con_valor.Rule =//
/*2*/ identificadores + SIGNOIGUAL + expresion_full
/*3*/ | identificadores + decl_celdas + SIGNOIGUAL + expresion_full;
declaracion_global.Rule =//
/*1*/ RVAR + identificadores
/*2*/ | RVAR + identificadores + decl_celdas
/*1*/ | RVAR + declaraciones_con_valor_global
/*2*/ | RVAR + declaraciones_con_valor_global + COMA + identificadores
/*3*/ | RVAR + declaraciones_con_valor_global + COMA + identificadores + decl_celdas;
declaraciones_con_valor_global.Rule =//
/*N*/ MakePlusRule(declaraciones_con_valor_global, COMA, declaracion_con_valor_global);
declaracion_con_valor_global.Rule =//
/*2*/ identificadores + SIGNOIGUAL + expresion_full
/*3*/ | identificadores + decl_celdas + SIGNOIGUAL + expresion_full;
decl_celdas.Rule =//
/*1*/ CORCHETEA + expresion + CORCHETEC
/*2*/ | CORCHETEA + expresion + CORCHETEC + CORCHETEA + expresion + CORCHETEC
/*3*/ | CORCHETEA + expresion + CORCHETEC + CORCHETEA + expresion + CORCHETEC + CORCHETEA + expresion + CORCHETEC;
arr_una_dimension.Rule =//
/*N*/ MakePlusRule(arr_una_dimension, COMA, expresion);
arr_dos_dimension.Rule = //
/*N*/ MakePlusRule(arr_dos_dimension, COMA, arr_dos_dimension_aux);
arr_dos_dimension_aux.Rule = //skip
/*skip*/ LLAVEA + arr_una_dimension + LLAVEC;
arr_tres_dimension.Rule = //
/*N*/ MakePlusRule(arr_tres_dimension, COMA, arr_tres_dimension_aux);
arr_tres_dimension_aux.Rule = //skip
/*skip*/ LLAVEA + arr_dos_dimension + LLAVEC;
bloque_if_elseif_else.Rule =//
/*1*/ instruccion_if
/*2*/ | instruccion_if + instrucciones_elseif
/*2*/ | instruccion_if + instruccion_else
/*3*/ | instruccion_if + instrucciones_elseif + instruccion_else;
instruccion_if.Rule =//
/*3*/ RIF + PARENTA + expresion + PARENTC + LLAVEA + LLAVEC
/*4*/ | RIF + PARENTA + expresion + PARENTC + LLAVEA + instrucciones + LLAVEC;
instrucciones_elseif.Rule =//
/*N*/ MakePlusRule(instrucciones_elseif, instruccion_elseif);
instruccion_elseif.Rule =//
/*3*/ RELSE + RIF + PARENTA + expresion + PARENTC + LLAVEA + LLAVEC
/*4*/ | RELSE + RIF + PARENTA + expresion + PARENTC + LLAVEA + instrucciones + LLAVEC;
instruccion_else.Rule =//
/*0*/ RELSE + LLAVEA + LLAVEC
/*1*/ | RELSE + LLAVEA + instrucciones + LLAVEC;
expresion_full.Rule =//
/*1*/ expresion
/*1*/ | expresion_array;
expresion.Rule =//
/*3*/ expresion + SIGNOMAS + expresion
/*3*/ | expresion + SIGNOMENOS + expresion
/*3*/ | expresion + SIGNODIVIDIDO + expresion
/*3*/ | expresion + SIGNOPOR + expresion
/*3*/ | expresion + SIGNOPOTENCIA + expresion
/*3*/ | expresion + MAYORQUE + expresion
/*3*/ | expresion + MENORQUE + expresion
/*3*/ | expresion + MAYORIGUALQUE + expresion
/*3*/ | expresion + MENORIGUALQUE + expresion
/*3*/ | expresion + IGUALQUE + expresion
/*3*/ | expresion + DISTINTOQUE + expresion
/*3*/ | expresion + OR + expresion
/*3*/ | expresion + AND + expresion
/*3*/ | expresion + XOR + expresion
/*2*/ | expresion + AUMENTO
/*2*/ | expresion + DECREMENTO
/*2*/ | NOT + expresion
/*2*/ | SIGNOMENOS + expresion
/*3*/ | PARENTA + expresion + PARENTC
/*1*/ | id
/*1*/ | CADENA
/*1*/ | NUMERO
/*1*/ | CHAR
/*1*/ | RTRUE
/*1*/ | RFALSE
/*1*/ | RNULL
/*4*/ | RNEW + IDENTIFICADOR + PARENTA + PARENTC
/*5*/ | RNEW + IDENTIFICADOR + PARENTA + PARENTC + PUNTO + id;
id.Rule =//
/*2*/ id + PUNTO + id
/*2*/ | id + asig_acceso_celda
/*1*/ | IDENTIFICADOR
/*2*/ | IDENTIFICADOR + llamada_metodo;
llamada_metodo.Rule =//
/*2*/ PARENTA + PARENTC
/*3*/ | PARENTA + lista_expresiones + PARENTC;
lista_expresiones.Rule =//
/*N*/ MakePlusRule(lista_expresiones, COMA, expresion_full);
expresion_array.Rule =//
/*1*/ LLAVEA + arr_una_dimension + LLAVEC
/*1*/ | LLAVEA + arr_dos_dimension + LLAVEC
/*1*/ | LLAVEA + arr_tres_dimension + LLAVEC;
#endregion
#region Precedencia
RegisterOperators(1, Associativity.Left, OR);
RegisterOperators(2, Associativity.Left, AND);
RegisterOperators(3, Associativity.Left, XOR);
RegisterOperators(4, Associativity.Left, DISTINTOQUE, IGUALQUE);
RegisterOperators(5, Associativity.Neutral, MENORQUE, MAYORQUE, MENORIGUALQUE, MAYORIGUALQUE);
RegisterOperators(6, Associativity.Left, SIGNOMAS, SIGNOMENOS);
RegisterOperators(7, Associativity.Left, SIGNOPOR, SIGNODIVIDIDO);
RegisterOperators(8, Associativity.Right, SIGNOPOTENCIA);
RegisterOperators(9, Associativity.Right, NOT);
RegisterOperators(10, Associativity.Neutral, AUMENTO, DECREMENTO);
RegisterOperators(11, Associativity.Left, PUNTO, CORCHETEA, CORCHETEC, PARENTA, PARENTC);
#endregion
MarkPunctuation(RVAR, PYCOMA, COMA, DOSPUNTOS, PUNTO, LLAVEA, LLAVEC, CORCHETEA, CORCHETEC, SIGNOIGUAL, RCLASS, RFUNCTION, RIF, RELSE, RFOR, RDO, RWHILE, RSWITCH, RCASE, RDEFAULT);
MarkTransient(arr_dos_dimension_aux, arr_tres_dimension_aux, decl_parametro, inicio);
this.Root = inicio;
}
/**
* @fn public Gramatica() : base(false)
*
* @brief Constructor de la gramatica, hereda de Grammar, por lo que recibe una
* bandera booleana para definir si hara diferencia entre minusculas y
* mayusculas (Case sensitive).
* true: Diferencia entre mayusculas y minusculas JAviEr != javier
* false: No hay diferencia entre mayusculas y minusculas JAviEr = javier
*
* @author Javier Estuardo Navarro
* @date 26/08/2018
*/
public Gramatica() : base(false)
{
#region Declaracion de TERMINALES
/* En esta region se declararan los terminales, es decir, los nodos hoja del AST,
* esta región contendrá:
* 1. Palabras reservadas
* 2. Operadores y simbolos
* 3. Terminales definidos con una expresion regular
* 4. Comentarios
*/
#region Palabras reservadas
// Se procede a declarar todas las palabras reservadas que pertenezcan al lenguaje.
KeyTerm pr_int = ToTerm("int"),
pr_double = ToTerm("double"),
pr_char = ToTerm("char"),
pr_bool = ToTerm("bool"),
pr_String = ToTerm("String"),
pr_void = ToTerm("void"),
pr_return = ToTerm("return"),
pr_main = ToTerm("main", "pr_main"),
pr_break = ToTerm("break"),
pr_continue = ToTerm("continue"),
pr_if = ToTerm("if"),
pr_else = ToTerm("else"),
pr_while = ToTerm("while"),
pr_Struct = ToTerm("Struct"),
pr_print = ToTerm("print");
/* El metodo "MarkReservedWords" le dice al parser que Terminales seran palabras reservadas,
* esto para que tengan prioridad sobre los identificadores, de lo contrario las palabras reservadas,
* se tomarian como identificadores.
*/
MarkReservedWords("int", "double", "char", "bool", "String", "void", "return", "main",
"break", "continue", "if", "else", "while", "Struct", "print");
#endregion
#region Operadores y simbolos
Terminal ptcoma = ToTerm(";"),
coma = ToTerm(","),
punto = ToTerm("."),
dospts = ToTerm(":"),
parizq = ToTerm("("),
parder = ToTerm(")"),
llaizq = ToTerm("{"),
llader = ToTerm("}"),
signo_mas = ToTerm("+"),
signo_menos = ToTerm("-"),
signo_por = ToTerm("*"),
signo_div = ToTerm("/"),
signo_pot = ToTerm("^"),
igual_que = ToTerm("=="),
diferente_que = ToTerm("!="),
menor_que = ToTerm("<"),
mayor_que = ToTerm(">"),
pr_or = ToTerm("||"),
pr_and = ToTerm("&&"),
pr_not = ToTerm("!"),
pr_true = ToTerm("true", "true"),
pr_false = ToTerm("false", "false"),
igual = ToTerm("=");
#endregion
#region Terminales definidos con una expresion regular
/* Tipo de literal que reconoce numeros equivalente a
* RegexBasedTerminal entero = new RegexBasedTerminal("entero", "[0-9]+");
* RegexBasedTerminal decimal = new RegexBasedTerminal("decimal", "[0-9]+(.[0-9]+)?");
* Pero mas completo porque reconoce gran variedad de tipos de números,
* desde enteros simples (por ejemplo, 1) hasta decimales (por ejemplo, 1.0)
* hasta números expresados en notación científica (por ejemplo, 1.1e2).
*/
NumberLiteral numero = new NumberLiteral("numero");
/*
* Este terminal identificará esos tokens en el código fuente que representan las variables
* expresadas de la manera estándar normal (es decir, comienza con un guión bajo o letra
* y contiene solo letras, números y guiones bajos) pero puede configurarse para identificar
* otros métodos no estándar de expresión variables.
*/
IdentifierTerminal identificador = new IdentifierTerminal("identificador");
/*
* Este terminal puede identificar literales de cadena y caracter
* ya que es posible configurar los caracteres de inicio/finalización.
* Verificar el enum stringOptions, para mas informacion
*/
StringLiteral cadena = new StringLiteral("cadena", "\"", StringOptions.AllowsAllEscapes);
StringLiteral caracter = new StringLiteral("caracter", "\'", StringOptions.IsChar);
#endregion
#region Comentarios
/* Se procede a definir los comentarios, los mismos seran ignorados por el analizador.
* Constructor: CommentTerminal(<nombre>,<SimboloInicial>,<Simbolo(s)Final(es)>)
* Un comentario podria terminar con uno o mas simbolos.
* Luego de definirlo es necesario agregar a la lista de terminales que seran ignorados,
* es decir, que no formaran parte de la gramatica con el metodo: NonGrammarTerminals.Add(<terminal>)
*/
CommentTerminal comentarioMultilinea = new CommentTerminal("comentarioMultiLinea", "/*", "*/");
base.NonGrammarTerminals.Add(comentarioMultilinea);
CommentTerminal comentarioUnilinea = new CommentTerminal("comentarioUniLinea", "//", "\n", "\r\n");
base.NonGrammarTerminals.Add(comentarioUnilinea);
#endregion
#endregion
#region Declaracion de NO TERMINALES
// En esta region se declararan los no terminales, es decir, los nodos intermedios del AST,
NonTerminal INI = new NonTerminal("INI");
NonTerminal FIELD_DECLARATION = new NonTerminal("FIELD_DECLARATION");
NonTerminal FIELD = new NonTerminal("FIELD");
NonTerminal METHOD_DECLARATION = new NonTerminal("METHOD_DECLARATION");
NonTerminal BLOQUE_SENTENCIAS = new NonTerminal("BLOQUE_SENTENCIAS");
NonTerminal DECLARACION = new NonTerminal("DECLARACION");
NonTerminal ASIGNACION = new NonTerminal("ASIGNACION");
NonTerminal LISTA_SIM = new NonTerminal("LISTA_SIM");
NonTerminal LISTA_PARAMETROS = new NonTerminal("LISTA_PARAMETROS");
NonTerminal PARAMETRO = new NonTerminal("PARAMETRO");
NonTerminal LISTA_ATRIBUTOS = new NonTerminal("LISTA_ATRIBUTOS");
NonTerminal ATRIBUTO = new NonTerminal("ATRIBUTO");
NonTerminal SENTENCIA = new NonTerminal("SENTENCIA");
NonTerminal STATEMENTS = new NonTerminal("STATEMENTS");
NonTerminal SENTENCIA_IF = new NonTerminal("SENTENCIA_IF");
NonTerminal SENTENCIA_WHILE = new NonTerminal("SENTENCIA_WHILE");
NonTerminal SENTENCIA_BREAK = new NonTerminal("SENTENCIA_BREAK");
NonTerminal SENTENCIA_CONTINUE = new NonTerminal("SENTENCIA_CONTINUE");
NonTerminal SENTENCIA_RETURN = new NonTerminal("SENTENCIA_RETURN");
NonTerminal SENTENCIA_PRINT = new NonTerminal("SENTENCIA_PRINT");
NonTerminal SENTENCIA_STRUCT = new NonTerminal("SENTENCIA_STRUCT");
NonTerminal SENTENCIA_LLAMADA = new NonTerminal("SENTENCIA_LLAMADA");
NonTerminal SENTENCIA_ACCESO = new NonTerminal("SENTENCIA_ACCESO");
NonTerminal EXPRESION = new NonTerminal("EXPRESION");
NonTerminal EXPRESION_ARITMETICA = new NonTerminal("EXPRESION_ARITMETICA");
NonTerminal EXPRESION_RELACIONAL = new NonTerminal("EXPRESION_RELACIONAL");
NonTerminal EXPRESION_LOGICA = new NonTerminal("EXPRESION_LOGICA");
NonTerminal PRIMITIVO = new NonTerminal("PRIMITIVO");
NonTerminal LISTA_ARGUMENTOS = new NonTerminal("LISTA_ARGUMENTOS");
NonTerminal TIPO = new NonTerminal("TIPO");
#endregion
#region Gramatica
INI.Rule = FIELD_DECLARATION;
FIELD_DECLARATION.Rule = MakePlusRule(FIELD_DECLARATION, FIELD);
FIELD.Rule = METHOD_DECLARATION
| DECLARACION + ptcoma
| SENTENCIA_STRUCT + ptcoma;
METHOD_DECLARATION.Rule = TIPO + identificador + parizq + LISTA_PARAMETROS + parder + BLOQUE_SENTENCIAS
| identificador + identificador + parizq + LISTA_PARAMETROS + parder + BLOQUE_SENTENCIAS
| TIPO + identificador + parizq + parder + BLOQUE_SENTENCIAS
| identificador + identificador + parizq + parder + BLOQUE_SENTENCIAS
| TIPO + pr_main + parizq + parder + BLOQUE_SENTENCIAS;
LISTA_PARAMETROS.Rule = MakeStarRule(LISTA_PARAMETROS, coma, PARAMETRO);
PARAMETRO.Rule = TIPO + identificador;
LISTA_ATRIBUTOS.Rule = MakePlusRule(LISTA_ATRIBUTOS, coma, ATRIBUTO);
ATRIBUTO.Rule = TIPO + identificador;
BLOQUE_SENTENCIAS.Rule = llaizq + STATEMENTS + llader;
STATEMENTS.Rule = MakeStarRule(STATEMENTS, SENTENCIA);
SENTENCIA.Rule = DECLARACION + ptcoma
| ASIGNACION + ptcoma
| SENTENCIA_ACCESO + ptcoma
| SENTENCIA_LLAMADA + ptcoma
| SENTENCIA_IF
| SENTENCIA_WHILE
| SENTENCIA_RETURN + ptcoma
| SENTENCIA_BREAK + ptcoma
| SENTENCIA_CONTINUE + ptcoma
| SENTENCIA_PRINT + ptcoma
| SENTENCIA_STRUCT + ptcoma;
DECLARACION.Rule = TIPO + LISTA_SIM + igual + EXPRESION
| TIPO + LISTA_SIM
| identificador + identificador;
ASIGNACION.Rule = LISTA_SIM + igual + EXPRESION
| identificador + punto + identificador + igual + EXPRESION;
LISTA_SIM.Rule = MakePlusRule(LISTA_SIM, coma, identificador);
SENTENCIA_IF.Rule = pr_if + parizq + EXPRESION + parder + BLOQUE_SENTENCIAS
| pr_if + parizq + EXPRESION + parder + BLOQUE_SENTENCIAS + pr_else + BLOQUE_SENTENCIAS;
SENTENCIA_WHILE.Rule = pr_while + parizq + EXPRESION + parder + BLOQUE_SENTENCIAS;
SENTENCIA_RETURN.Rule = pr_return + EXPRESION
| pr_return;
SENTENCIA_BREAK.Rule = pr_break;
SENTENCIA_CONTINUE.Rule = pr_continue;
SENTENCIA_PRINT.Rule = pr_print + parizq + EXPRESION + parder;
SENTENCIA_STRUCT.Rule = pr_Struct + identificador + parizq + LISTA_ATRIBUTOS + parder;
SENTENCIA_LLAMADA.Rule = identificador + parizq + LISTA_ARGUMENTOS + parder
| identificador + parizq + parder;
SENTENCIA_ACCESO.Rule = identificador + punto + identificador;
EXPRESION.Rule = EXPRESION_ARITMETICA
| EXPRESION_LOGICA
| EXPRESION_RELACIONAL
| PRIMITIVO
| SENTENCIA_ACCESO
| parizq + EXPRESION + parder
| SENTENCIA_LLAMADA;
EXPRESION_ARITMETICA.Rule = signo_menos + EXPRESION
| EXPRESION + signo_mas + EXPRESION
| EXPRESION + signo_menos + EXPRESION
| EXPRESION + signo_por + EXPRESION
| EXPRESION + signo_div + EXPRESION
| EXPRESION + signo_pot + EXPRESION;
EXPRESION_RELACIONAL.Rule = EXPRESION + mayor_que + EXPRESION
| EXPRESION + menor_que + EXPRESION
| EXPRESION + igual_que + EXPRESION
| EXPRESION + diferente_que + EXPRESION;
EXPRESION_LOGICA.Rule = EXPRESION + pr_or + EXPRESION
| EXPRESION + pr_and + EXPRESION
| pr_not + EXPRESION;
PRIMITIVO.Rule = numero
| cadena
| caracter
| pr_true
| pr_false
| identificador;
LISTA_ARGUMENTOS.Rule = MakeStarRule(LISTA_ARGUMENTOS, coma, EXPRESION);
TIPO.Rule = pr_bool
| pr_char
| pr_String
| pr_int
| pr_double
| pr_void;
#endregion
#region precedencia
/*
* En esta region se define la precedencia y asociatividad para remover la ambiguedad
* de la gramatica de expresiones.
*/
RegisterOperators(1, Associativity.Right, igual);
RegisterOperators(2, Associativity.Left, pr_or);
RegisterOperators(4, Associativity.Left, pr_and);
RegisterOperators(5, Associativity.Left, igual_que, diferente_que);
RegisterOperators(6, Associativity.Left, mayor_que, menor_que);
RegisterOperators(7, Associativity.Left, signo_mas, signo_menos);
RegisterOperators(8, Associativity.Left, signo_por, signo_div);
RegisterOperators(9, Associativity.Right, signo_pot);
RegisterOperators(10, Associativity.Right, pr_not);
RegisterOperators(11, Associativity.Left, punto);
RegisterOperators(12, Associativity.Neutral, parizq, parder);
#endregion
/* Se define la raiz del AST es decir el simbolo inicial de la gramatica,
* este debe ser un No Terminal
*/
/*
* Otros metodos que podrian ser utiles son los siguientes:
*
* Marcar signos de puntuacion, esto para no tener nodos inutiles en el AST, ignora terminales.
* MarkPunctuation(llaizq, llader, ptcoma, dospts, coma);
*
* Marcar trascendentes Nodos No terminales, esto para no tener nodos inutiles en el AST, ignora No terminales.
* MarkTransient(NoTerminal1, NoTerminal2,...,NoTerminalN);
* Es util cuando se tienen nodos de listas por ejemplo. L->L Elemento |Elemento
* Se podrian marcar trascendentes los nodos L, y asi tener el nodo padre con n hijos Elemento.
*/
MarkPunctuation(parizq, parder, llaizq, llader, ptcoma, dospts, coma, igual, punto);
this.Root = INI;
}
public Gramatica() : base(caseSensitive: false)
{
#region ER
StringLiteral CADENA = new StringLiteral("cadena", "\"");
var ENTERO = new NumberLiteral("entero");
var DECIMAL = new RegexBasedTerminal("Decimal", "[0-9]+'.'[0-9]+");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("ID");
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n", "\r\n"); //si viene una nueva linea se termina de reconocer el comentario.
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/*", "*/");
#endregion
#region Terminales
var RIMPRIMIR = ToTerm("imprimir");
var RNUMERO = ToTerm("numero");
var RMIENTRAS = ToTerm("mientras");
var RIF = ToTerm("if");
var RELSE = ToTerm("else");
var PTCOMA = ToTerm(";");
var LLAVIZQ = ToTerm("{");
var LLAVDER = ToTerm("}");
var PARIZQ = ToTerm("(");
var PARDER = ToTerm(")");
var MAS = ToTerm("+");
var MENOS = ToTerm("-");
var POR = ToTerm("*");
var DIVIDIDO = ToTerm("/");
var CONCAT = ToTerm("&");
var MENQUE = ToTerm("<");
var MAYQUE = ToTerm(">");
var IGUAL = ToTerm("=");
var OO = ToTerm("||");
var YY = ToTerm("&&");
var AUMENTO = ToTerm("++");
var DECREMENTO = ToTerm("--");
RegisterOperators(1, CONCAT);
RegisterOperators(2, MAS, MENOS);
RegisterOperators(3, POR, DIVIDIDO);
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
#endregion
#region No Terminales
NonTerminal ini = new NonTerminal("ini");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal expresion_numerica = new NonTerminal("expresion_numerica");
NonTerminal expresion_cadena = new NonTerminal("expresion_cadena");
NonTerminal expresion_logica = new NonTerminal("expresion_logica");
#endregion
#region Gramatica
ini.Rule = instrucciones;
;
instrucciones.Rule = instrucciones + instruccion
| instruccion;
instruccion.Rule = RIMPRIMIR + PARIZQ + expresion_cadena + PARDER + PTCOMA
| RMIENTRAS + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER
| RNUMERO + IDENTIFICADOR + PTCOMA
| IDENTIFICADOR + IGUAL + expresion_numerica + PTCOMA
| IDENTIFICADOR + AUMENTO + PTCOMA
| IDENTIFICADOR + DECREMENTO + PTCOMA
| RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER
| RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER + RELSE + LLAVIZQ + instrucciones + LLAVDER;
expresion_numerica.Rule = MENOS + expresion_numerica
| expresion_numerica + MAS + expresion_numerica
| expresion_numerica + MENOS + expresion_numerica
| expresion_numerica + POR + expresion_numerica
| expresion_numerica + DIVIDIDO + expresion_numerica
| PARIZQ + expresion_numerica + PARDER
| ENTERO
| DECIMAL
| IDENTIFICADOR;
expresion_cadena.Rule = expresion_cadena + CONCAT + expresion_cadena
| CADENA
| expresion_numerica;
expresion_logica.Rule = expresion_numerica + MAYQUE + expresion_numerica
| expresion_numerica + MENQUE + expresion_numerica
| expresion_logica + OO + expresion_logica
| expresion_logica + YY + expresion_logica;
#endregion
#region Preferencias
this.Root = ini;
#endregion
}
public static BnfiTermConversion <string> IntroStringLiteral(StringLiteral stringLiteral)
{
return(Intro <string>(stringLiteral, (context, parseNode) => (string)parseNode.FindToken().Value, IdentityFunction, astForChild: false));
}
public CompsciSpecParser()
{
//Expr -> n | v | Expr BinOp Expr | UnOP Expr | ( Expr )
//BinOp -> + | - | * | / | **
//UnOp -> -
//ExprLine -> Expr EOF
//1. Terminals
//Terminal num = new NumberLiteral("number");
Terminal id = new IdentifierTerminal("id");
Terminal explicitStringConstant = TerminalFactory.CreateCSharpString("explicitStringConstant");
Terminal explicitIntegerConstant = new NumberLiteral("explicitIntegerConstant", NumberOptions.IntOnly);
Terminal explicitRealConstant = new NumberLiteral("explicitRealConstant", NumberOptions.None);
Terminal explicitCharConstant = new StringLiteral("Terminal explicitCharConstant", "'", StringOptions.IsChar);
//Terminal stringLiteral = TerminalFactory.CreateCSharpString("stringLiteral");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "%", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//2. Non-Terminals
var variableId = new NonTerminal("variableId");
var variableReference = new NonTerminal("variableReference");
var constantId = new NonTerminal("constantId");
var constantReference = new NonTerminal("constantReference");
var explicitTrueFalseConstant = new NonTerminal("explicitTrueFalseConstant");
var explicitConstant = new NonTerminal("explicitConstant");
var infixOperator = new NonTerminal("infixOperator");
var prefixOperator = new NonTerminal("prefixOperator");
var leftPosition = new NonTerminal("leftPosition");
var rightPosition = new NonTerminal("rightPosition");
var charPosition = new NonTerminal("charPosition");
var stringReference = new NonTerminal("stringReference");
var substring = new NonTerminal("substring");
var functionId = new NonTerminal("functionId");
var moduleId = new NonTerminal("moduleId");
var classId = new NonTerminal("classId");
var pointerId = new NonTerminal("pointerId");
var functionRefence = new NonTerminal("functionReference");
var functionCall = new NonTerminal("functionCall");
var setTypeId = new NonTerminal("setTypeId");
var membersOfSet = new NonTerminal("membersOfSet");
var setConstructor = new NonTerminal("setConstructor");
var enumeratedTypeId = new NonTerminal("enumeratedTypeId");
var enumeratedId = new NonTerminal("enumeratedId");
var enumeratedValue = new NonTerminal("enumeratedValue");
var expn = new NonTerminal("expn");
var expnList = new NonTerminal("expnList");
var fieldId = new NonTerminal("fieldId");
var componentSelector = new NonTerminal("componentSelector");
var maximumLength = new NonTerminal("maximumLength");
var numberOfCharacters = new NonTerminal("numberOfCharacters");
var standardType = new NonTerminal("standardType");
var subrangeType = new NonTerminal("subrangeType");
var typeDeclaration = new NonTerminal("typeDeclaration");
var stringType = new NonTerminal("stringType");
var idList = new NonTerminal("idList");
var enumeratedType = new NonTerminal("enumeratedType");
var indexType = new NonTerminal("indexType");
var indexTypeList = new NonTerminal("indexTypeList");
var arrayFlexible = new NonTerminal("arrayFlexible");
var arrayType = new NonTerminal("arrayType");
var setType = new NonTerminal("setType");
var recordField = new NonTerminal("recordField");
var recordFieldList = new NonTerminal("recordFieldList");
var recordType = new NonTerminal("recordType");
var labelExpn = new NonTerminal("labelExpn");
var labelExpnList = new NonTerminal("labelExpnList");
var unionLabelList = new NonTerminal("unionLabelList");
var unionEndList = new NonTerminal("unionEndList");
var unionEndLabel = new NonTerminal("unionEndLabel");
var unionType = new NonTerminal("unionType");
var collectionId = new NonTerminal("collectionId");
var pointerType = new NonTerminal("pointerType");
var namedType = new NonTerminal("namedType");
var typeSpec = new NonTerminal("typeSpec");
var subprogramType = new NonTerminal("subprogramType");
var paramDeclaration = new NonTerminal("paramDeclaration");
var paramList = new NonTerminal("paramList");
var subParams = new NonTerminal("subParams");
var subPervasive = new NonTerminal("subPervasive");
var subDevice = new NonTerminal("subDevice");
var subprogramHeader = new NonTerminal("subprogramHeader");
var subBody = new NonTerminal("subBody");
var trueFalseExpn = new NonTerminal("trueFalseExpn");
var subPre = new NonTerminal("subPre");
var initList = new NonTerminal("initList");
var subInit = new NonTerminal("subInit");
var subPost = new NonTerminal("subPost");
var subExcept = new NonTerminal("subExcept");
var subprogramDeclaration = new NonTerminal("subprogramDeclaration");
var assignmentOp = new NonTerminal("assignmentOp");
var assignmentStatement = new NonTerminal("assignmentStatement");
var beginStatement = new NonTerminal("beginStatement");
var bindList = new NonTerminal("bindList");
var bindDeclaration = new NonTerminal("bindDeclaration");
var compileTimeExpn = new NonTerminal("compileTimeExpn");
var compileTimeExpnList = new NonTerminal("compileTimeExpnList");
var caseLabel = new NonTerminal("caseLabel");
var caseLabelList = new NonTerminal("caseLabelList");
var caseLabels = new NonTerminal("caseLabels");
var caseDefaultLabel = new NonTerminal("caseDefaultLabel");
var caseStatement = new NonTerminal("caseStatement");
var typeId = new NonTerminal("typeId");
var targetType = new NonTerminal("targetType");
var compileTimeIntExpn = new NonTerminal("compileTimeIntExpn");
var sizeSpec = new NonTerminal("sizeSpec");
var typeCheat = new NonTerminal("typeCheat");
var classMonitor = new NonTerminal("classMonitor");
var inheritItem = new NonTerminal("inheritItem");
var classInherit = new NonTerminal("classInherit");
var implementItem = new NonTerminal("implementItem");
var classImplement = new NonTerminal("classImplement");
var implementByItem = new NonTerminal("implementByItem");
var classBy = new NonTerminal("classBy");
var howImport = new NonTerminal("howImport");
var importItem = new NonTerminal("importItem");
var importList = new NonTerminal("importList");
var classImport = new NonTerminal("classImport");
var exportMethod = new NonTerminal("exportMethod");
var howExport = new NonTerminal("howExport");
var exportItem = new NonTerminal("exportItem");
var exportList = new NonTerminal("exportList");
var classExport = new NonTerminal("classExport");
var classDeclaration = new NonTerminal("classDeclaration");
var fileNumber = new NonTerminal("fileNumber");
var closeStatement = new NonTerminal("closeStatement");
var collectionCheck = new NonTerminal("collectionCheck");
var collectionDeclaration = new NonTerminal("collectionDeclaration");
var comparisonOperator = new NonTerminal("comparisonOperator");
var conditionArray = new NonTerminal("conditionArray");
var conditionOption = new NonTerminal("conditionOption");
var conditionDeclaration = new NonTerminal("conditionDeclaration");
var constTypeSpec = new NonTerminal("constTypeSpec");
var initializingValue = new NonTerminal("initializingValue");
var constPervasive = new NonTerminal("constPervasive");
var constRegister = new NonTerminal("constRegister");
var constantDeclaration = new NonTerminal("constantDeclaration");
var declaration = new NonTerminal("declaration");
var deferredDeclaration = new NonTerminal("deferredDeclaration");
var exitStatement = new NonTerminal("exitStatement");
var externalOverrideName = new NonTerminal("externalOverrideName");
var externalAddressSpec = new NonTerminal("externalAddressSpec");
var externalTypeSpec = new NonTerminal("externalTypeSpec");
var externalExpn = new NonTerminal("externalExpn");
var externalDeclaration = new NonTerminal("externalDeclaration");
var increment = new NonTerminal("increment");
var forIncrement = new NonTerminal("forIncrement");
var integerExpn = new NonTerminal("integerExpn");
var rangeId = new NonTerminal("rangeId");
var forRange = new NonTerminal("forRange");
var forId = new NonTerminal("forId");
var forDecreasing = new NonTerminal("forDecreasing");
var forStatement = new NonTerminal("forStatement");
var forExpnLIst = new NonTerminal("forExpnList");
var forkParams = new NonTerminal("forParams");
var forkRefExpnRef = new NonTerminal("forkRefExpnRef");
var forkRefExpn = new NonTerminal("forkRefExpn");
var forkReference = new NonTerminal("forReference");
var addressReference = new NonTerminal("addressReference");
var booleanVariableReference = new NonTerminal("booleanVariableReference");
var processId = new NonTerminal("processId");
var forkStatement = new NonTerminal("forkStatement");
//new rules
var deviceSpecification = new NonTerminal("deviceSpecification");
var exceptionHandler = new NonTerminal("exceptionHandler");
var statementsAndDeclarations = new NonTerminal("statementsAndDeclarations");
var fileName = new NonTerminal("fileName");
var procedureDeclaration = new NonTerminal("procedureDeclaration");
var functionDeclaration = new NonTerminal("functionDeclaration");
//var moduleDeclaration = new NonTerminal("moduleDeclaration");
//var monitorDeclaration = new NonTerminal("monitorDeclaration");
//var processDeclaration = new NonTerminal("processDeclaration");
var variableDeclaration = new NonTerminal("variableDeclaration");
var overrideName = new NonTerminal("overrideName");
var addressSpec = new NonTerminal("addressSpec");
var forkExpnList = new NonTerminal("forkExpnList");
var statements = new NonTerminal("statements");
var putStatement = new NonTerminal("putStatement");
var putItem = new NonTerminal("putItem");
var getStatement = new NonTerminal("getStatement");
var getItem = new NonTerminal("getItem");
var openStatement = new NonTerminal("openStatement");
var capability = new NonTerminal("capability");
var streamNumber = new NonTerminal("streamNumber");
var widthExpn = new NonTerminal("widthExpn");
var fractionWidth = new NonTerminal("fractionWidth");
var exponentWidth = new NonTerminal("exponentWidth");
var fileNumberVariable = new NonTerminal("fileNumberVariable");
var loopStatement = new NonTerminal("loopStatement");
var functionHeader = new NonTerminal("functionHeader");
var procedureHeader = new NonTerminal("procedureHeader");
//3. BNF Rules
variableId.Rule = id;
variableReference.Rule = variableId | variableId + PreferShiftHere() + componentSelector;
constantId.Rule = id;
constantReference.Rule = constantId | constantId + PreferShiftHere() + componentSelector;
explicitTrueFalseConstant.Rule = ToTerm("true") | "false";
explicitConstant.Rule = explicitStringConstant | explicitIntegerConstant | explicitRealConstant | explicitTrueFalseConstant | explicitCharConstant;
infixOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "div" | "mod" | "rem" | "**" | "<" | ">" | "=" | "<=" | ">=" | "not=" | "and" | "or" | "=>" | "in" | "not" + "in" | "shr" | "shl" | "xor";
prefixOperator.Rule = ToTerm("+") | "-" | "not" | "#" | "^";
leftPosition.Rule = expn | "*" | "*" + "-" + expn;
rightPosition.Rule = expn | "*" | "*" + "-" + expn;
charPosition.Rule = expn | "*" | "*" + "-" + expn;
stringReference.Rule = variableReference;
substring.Rule = stringReference + "(" + leftPosition + ".." + rightPosition + ")"
| stringReference + "(" + charPosition + ")";
functionId.Rule = variableReference;
moduleId.Rule = variableReference;
classId.Rule = variableReference;
pointerId.Rule = variableReference;
functionRefence.Rule = moduleId + "." + functionId | functionId
| classId + "(" + pointerId + ")" + "." + functionId
| pointerId + "->" + functionId;
functionCall.Rule = functionRefence | functionRefence + "(" + ")" | functionRefence + "(" + expnList + ")";
setTypeId.Rule = variableReference;
membersOfSet.Rule = expnList | "all";
setConstructor.Rule = setTypeId + "(" + membersOfSet + ")" | setTypeId + "(" + ")";
enumeratedTypeId.Rule = variableReference;
enumeratedId.Rule = id;
enumeratedValue.Rule = enumeratedTypeId + "." + enumeratedId;
expn.Rule = explicitConstant | variableReference | constantReference
| expn + infixOperator + expn
| prefixOperator + expn
| "(" + expn + ")"
| substring | functionCall | setConstructor | enumeratedValue;
expnList.Rule = expn | expn + "," + expn;
fieldId.Rule = id;
componentSelector.Rule = "(" + expnList + ")" | "." + fieldId;
maximumLength.Rule = expn;
numberOfCharacters.Rule = expn;
standardType.Rule = ToTerm("int") | "real" | stringType | "boolean" | "nat"
| "int1" | "int2" | "int4" | "nat1" | "nat2" | "nat4"
| "real4" | "real8" | "char" | "char" + "(" + numberOfCharacters + ")";
subrangeType.Rule = expn + ".." + expn;
typeDeclaration.Rule = "type" + id + ":" + typeSpec | "type" + id + ":" + "forward";
stringType.Rule = "string" | "string" + PreferShiftHere() + "(" + maximumLength + ")";
idList.Rule = id | id + PreferShiftHere() + "," + idList;
enumeratedType.Rule = "enum" + "(" + idList + ")";
indexType.Rule = subrangeType | enumeratedType | namedType | "char" | "boolean";
indexTypeList.Rule = indexType | indexType + "," + indexTypeList;
arrayFlexible.Rule = "flexible" | Empty;
arrayType.Rule = arrayFlexible + "array" + indexTypeList + "of" + typeSpec;
setType.Rule = "set" + "of" + typeSpec;
recordField.Rule = idList + ":" + typeSpec;
recordFieldList.Rule = recordField | recordField + recordFieldList;
recordType.Rule = "record" + recordFieldList + "end" + "record";
labelExpn.Rule = expn;
labelExpnList.Rule = labelExpn | labelExpn + "," + labelExpnList;
unionLabelList.Rule = "label" + labelExpnList + ":" + idList + ":" + typeSpec
| "label" + labelExpnList + ":";
unionEndLabel.Rule = "label" + ":" + idList + ":" + typeSpec | "label" + ":";
unionType.Rule = "union" + ":" + indexType + "of" + unionLabelList + "end" + "union"
| "union" + id + ":" + indexType + "of" + unionLabelList + "end" + "union"
| "union" + ":" + indexType + "of" + unionLabelList + unionEndLabel + "end" + "union"
| "union" + id + ":" + indexType + "of" + unionLabelList + unionEndLabel + "end" + "union";
collectionId.Rule = variableReference;
pointerType.Rule = "pointer" + "to" + collectionId
| "unchecked" + "pointer" + "to" + collectionId
| "^" + collectionId
| "pointer" + "to" + classId
| "unchecked" + "pointer" + "to" + classId
| "^" + classId
| "pointer" + "to" + typeSpec
| "unchecked" + "pointer" + "to" + typeSpec
| "^" + typeSpec;
namedType.Rule = variableReference;
typeSpec.Rule = ToTerm("int") | "real" | "boolean" | stringType | subrangeType
| enumeratedType | arrayType | setType | recordType | unionType
| pointerType | namedType | "nat" | "int1" | "int2" | "int4"
| "nat1" | "nat2" | "nat4" | "real4" | "real8" | "char"
| "char" + "(" + numberOfCharacters + ")" | subprogramType;
subprogramType.Rule = subprogramHeader;
paramDeclaration.Rule = idList + ":" + typeSpec
| "var" + idList + ":" + typeSpec
| subprogramHeader;
paramList.Rule = paramDeclaration | paramDeclaration + "," + paramList;
subParams.Rule = "(" + paramList + ")" | "(" + ")" | Empty;
subPervasive.Rule = "pervasive" | Empty;
subDevice.Rule = ":" + deviceSpecification | Empty;
//subprogramHeader.Rule = "procedure" + subPervasive + id + subParams + subDevice
// | "function" + subPervasive + id + subParams + ":" + typeSpec
// | "function" + subPervasive + id + subParams + id + ":" + typeSpec;
subBody.Rule = "body" | Empty;
trueFalseExpn.Rule = expn;
subPre.Rule = "pre" + trueFalseExpn | Empty;
initList.Rule = id + ":=" + expn | id + ":=" + expn + "," + initList;
subInit.Rule = "init" + initList | Empty;
subPost.Rule = "post" + trueFalseExpn | Empty;
subExcept.Rule = exceptionHandler | Empty;
//subprogramDeclaration.Rule = subBody + subprogramHeader + subPre + subInit + subPost + subExcept + statementsAndDeclarations + "end" + id
// | "body" + id + statementsAndDeclarations + "end" + id;
assignmentOp.Rule = ToTerm(":=") | "+=" | "-=" | "*=" | "/=" | "div="
| "mod=" | "rem=" | "shl=" | "shr=" | "xor=";
assignmentStatement.Rule = variableReference + assignmentOp + expn;
beginStatement.Rule = "begin" + statementsAndDeclarations + "end";
bindList.Rule = id + "to" + variableReference
| "var" + id + "to" + variableReference
| id + "to" + variableReference + "," + bindList
| "var" + id + "to" + variableReference + "," + bindList
| "register" + id + "to" + variableReference
| "var" + "register" + id + "+to" + variableReference
| "register" + id + "to" + variableReference + "," + bindList
| "var" + "register" + id + "to" + variableReference + "," + bindList;
bindDeclaration.Rule = "bind" + bindList;
compileTimeExpn.Rule = expn;
compileTimeExpnList.Rule = compileTimeExpn | compileTimeExpn + "," + compileTimeExpnList;
caseLabel.Rule = "label" + compileTimeExpnList + ":" + statementsAndDeclarations;
caseLabelList.Rule = caseLabel | caseLabel + "," + caseLabelList;
caseLabels.Rule = caseLabelList | Empty;
caseDefaultLabel.Rule = "label" + ":" + statementsAndDeclarations | Empty;
caseStatement.Rule = "case" + expn + "of" + caseLabels + caseDefaultLabel + "end" + "case";
typeId.Rule = variableId | id + ":" + variableReference;
targetType.Rule = typeId | "int" | "int1" | "int2" | "int4" | "nat" | "nat1"
| "nat2" | "nat4" | "boolean" | "char" | "string"
| "char" + "(" + numberOfCharacters + ")"
| "string" + "(" + maximumLength + ")"
| "addressint";
compileTimeIntExpn.Rule = expn;
sizeSpec.Rule = ":" + compileTimeIntExpn | Empty;
typeCheat.Rule = "cheat" + "(" + targetType + "," + expn + sizeSpec + ")"
| "#" + expn | id + ":" + "cheat" + typeSpec;
classMonitor.Rule = "monitor" | Empty;
inheritItem.Rule = id;
classInherit.Rule = "inherit" + inheritItem | Empty;
implementItem.Rule = id;
classImplement.Rule = "implement" + implementItem | Empty;
implementByItem.Rule = id;
classBy.Rule = "implement" + "by" + implementByItem | Empty;
howImport.Rule = ToTerm("var") | "const" | "forward" | Empty;
importItem.Rule = howImport + id | howImport + id + "in" + fileName
| "(" + howImport + id + ")"
| "(" + howImport + id + "in" + fileNumber + ")";
importList.Rule = importItem | importItem + "," + importList;
classImport.Rule = "import" + importList | Empty;
exportMethod.Rule = ToTerm("var") | "unqualified" | "pervasive" | "opaque";
howExport.Rule = exportMethod + howExport | Empty;
exportItem.Rule = howExport + id;
exportList.Rule = exportItem | exportItem + "," + exportList;
classExport.Rule = "export" + exportList | "export" + "all" | Empty;
classDeclaration.Rule = classMonitor + "class" + id + classInherit + classImplement + classBy + classImport + classExport + statementsAndDeclarations + "end" + id;
fileNumber.Rule = expn;
closeStatement.Rule = "close" + ":" + fileNumber
| "close" + "(" + fileNumber + ":" + "int" + ")";
collectionCheck.Rule = "unchecked" | Empty;
collectionDeclaration.Rule = "var" + idList + ":" + collectionCheck + "collection" + "of" + typeSpec
| "var" + idList + ":" + collectionCheck + "collection" + "of" + "forward" + typeId;
comparisonOperator.Rule = ToTerm("<") | ">" | "=" | "<=" | ">=" | "not=";
conditionArray.Rule = "array" + indexTypeList + "of" | Empty;
conditionOption.Rule = ToTerm("priority") | "deferred" | "timeout" | Empty;
conditionDeclaration.Rule = "var" + idList + ":" + conditionArray + conditionOption + "condition";
constTypeSpec.Rule = ":" + typeSpec | Empty;
initializingValue.Rule = expn | "init" + "(" + initializingValue + "," + initializingValue + ")";
constPervasive.Rule = "pervasive" | Empty;
constRegister.Rule = "register" | Empty;
constantDeclaration.Rule = "const" + constPervasive + constRegister + id + constTypeSpec + ":=" + initializingValue;
declaration.Rule = constantDeclaration | typeDeclaration | bindDeclaration
| procedureDeclaration | functionDeclaration
| variableDeclaration | conditionDeclaration
//| monitorDeclaration | moduleDeclaration| processDeclaration
| classDeclaration;
deferredDeclaration.Rule = "deferred" + subprogramHeader;
exitStatement.Rule = "exit" + "when" + trueFalseExpn;// | "exit";
externalOverrideName.Rule = overrideName | Empty;
externalAddressSpec.Rule = addressSpec | Empty;
externalTypeSpec.Rule = ":" + typeSpec | Empty;
externalExpn.Rule = ":=" + expn | Empty;
externalDeclaration.Rule = "external" + externalOverrideName + subprogramHeader
| "external" + externalAddressSpec + "var" + id + externalTypeSpec + externalExpn;
increment.Rule = expn;
forIncrement.Rule = "by" + increment | Empty;
integerExpn.Rule = expn;
rangeId.Rule = variableDeclaration;
forRange.Rule = integerExpn + ".." + integerExpn | rangeId;
forId.Rule = id | Empty;
forDecreasing.Rule = "decreasing" | Empty;
forStatement.Rule = "for" + forDecreasing + forId + ":" + forRange + forIncrement + statementsAndDeclarations + "end" + "for";
forkExpnList.Rule = expnList | Empty;
forkParams.Rule = "(" + forkExpnList + ")" | Empty;
forkRefExpnRef.Rule = "," + addressReference | Empty;
forkRefExpn.Rule = "," + expn + forkRefExpnRef | Empty;
forkReference.Rule = ":" + booleanVariableReference + forkRefExpn | Empty;
addressReference.Rule = variableReference;
booleanVariableReference.Rule = variableReference;
processId.Rule = variableReference;
forkStatement.Rule = "fork" + processId + forkParams + forkReference;
//new rules
deviceSpecification.Rule = explicitIntegerConstant;
exceptionHandler.Rule = "handler" + "(" + id + ")" + statementsAndDeclarations + "end" + "handler";
fileName.Rule = explicitStringConstant;
overrideName.Rule = explicitStringConstant;
addressSpec.Rule = compileTimeExpn;
procedureDeclaration.Rule = subprogramDeclaration;//seems a little redudant
functionDeclaration.Rule = subprogramDeclaration;
//processDeclaration.Rule = forkStatement;
statementsAndDeclarations.Rule = declaration + statementsAndDeclarations | statements + statementsAndDeclarations | Empty;
statements.Rule = forStatement | forkStatement | exitStatement | closeStatement | assignmentStatement | caseStatement | beginStatement | putStatement | getStatement | loopStatement;
variableDeclaration.Rule = ToTerm("var") + MakePlusRule(variableDeclaration, ToTerm(","), id) + ":=" + expn
| "var" + MakePlusRule(variableDeclaration, ToTerm(","), id) + ":" + typeSpec + (":=" + initializingValue | Empty);
putStatement.Rule = ToTerm("put") + (":" + streamNumber + "," | Empty) + MakePlusRule(putStatement, ToTerm(","), putItem) + (".." | Empty);
putItem.Rule = expn + (":" + widthExpn + (":" + fractionWidth + (":" + exponentWidth | Empty) | Empty) | Empty) | "skip";
getStatement.Rule = ToTerm("get") + (":" + streamNumber + "," | Empty) + MakePlusRule(getStatement, ToTerm(","), getItem);
getItem.Rule = variableReference | "skip" | variableReference + ":" + "*" | variableReference + ":" + widthExpn;
openStatement.Rule = ToTerm("open") + ":" + fileNumberVariable + "," + fileName + "," + MakePlusRule(openStatement, ToTerm(","), capability);
capability.Rule = ToTerm("put") | "get";
closeStatement.Rule = ToTerm("close") + ":" + fileNumber;
streamNumber.Rule = widthExpn.Rule = fractionWidth.Rule = exponentWidth.Rule = fileNumber.Rule = expn;
loopStatement.Rule = ToTerm("loop") + statementsAndDeclarations + "end" + "loop";
functionDeclaration.Rule = subBody + functionHeader + subPre + subInit + subPost + subExcept + statementsAndDeclarations + "end" + id
| "body" + id + statementsAndDeclarations + "end" + id;
procedureDeclaration.Rule = subBody + procedureHeader + subPre + subInit + subPost + subExcept + statementsAndDeclarations + "end" + id
| "body" + id + statementsAndDeclarations + "end" + id;
subprogramDeclaration.Rule = functionDeclaration | procedureDeclaration;
functionHeader.Rule = "function" + subPervasive + id + subParams + ":" + typeSpec
| "function" + subPervasive + id + subParams + id + ":" + typeSpec;
procedureHeader.Rule = "procedure" + subPervasive + id + subParams + subDevice;
subprogramHeader.Rule = functionHeader | procedureHeader;
//Following are guesses as to the rules, since the spec does not state the rules for them
fileNumberVariable.Rule = variableReference;
fileName.Rule = explicitStringConstant | variableReference;
//variableDeclaration.Rule = collectionDeclaration;
//moduleDeclaration.Rule = variableDeclaration;
//monitorDeclaration.Rule = variableDeclaration;
this.Root = statementsAndDeclarations;
//procedureDeclaration = new NonTerminal("procedureDeclaration");
//functionDeclaration = new NonTerminal("functionDeclaration");
//moduleDeclaration = new NonTerminal("moduleDeclaration");
//monitorDeclaration = new NonTerminal("monitorDeclaration");
//processDeclaration = new NonTerminal("processDeclaration");
//variableDeclaration = new NonTerminal("variableDeclaration");
//this.Root = program;
//4. Set operator precendence and associativity
RegisterOperators(80, Associativity.Left, "**");//this is VERY odd, but Turing simplifies associativity by saying it's all left associative
RegisterOperators(60, "*", "/", "div", "mod");
RegisterOperators(50, "+", "-");
RegisterOperators(40, "<", ">", "=", "<=", ">=", "not=");
RegisterOperators(30, "not");
RegisterOperators(20, "and");
RegisterOperators(10, "or");
//5. Register Parenthesis as punctuation symbols so they will not appear in the syntax tree
MarkPunctuation("(", ")", ",");
RegisterBracePair("(", ")");
//MarkTransient(Expr, BinOp, ParExpr);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public EntropyGrammar() : base(false) // turns off case-sensitivity
{
#region definitions
#region literals
// Str
StringLiteral stringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
// Char
StringLiteral charLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
// Real
NumberLiteral number = CreateRealNumber("Number");
#endregion
#region non-terminals
NonTerminal program = new NonTerminal("program"); //, typeof(ProgramNode));
this.Root = program; // specify the non-terminal which is the root of the AST
NonTerminal programDeclaration = new NonTerminal("programDeclaration");
NonTerminal statementList = new NonTerminal("statementList"); //, typeof(StatementListNode));
NonTerminal emptyStatement = new NonTerminal("emptyStatement");
NonTerminal statement = new NonTerminal("statement"); //, typeof(StatementNode));
NonTerminal printStatement = new NonTerminal("printStatement");
NonTerminal ifStatement = new NonTerminal("ifStatement"); //, typeof(IfStatementNode));
NonTerminal whileLoop = new NonTerminal("whileLoop");
NonTerminal expression = new NonTerminal("expression"); //, typeof(ExpressionNode));
NonTerminal binaryOperator = new NonTerminal("binaryOperator"); //, typeof(BinaryOperatorNode));
NonTerminal assignment = new NonTerminal("assignmentOperator");
NonTerminal localVariableDeclaration = new NonTerminal("localVariableDeclaration");
NonTerminal conditionalExpression = new NonTerminal("conditionalExpression");
NonTerminal functionDeclaration = new NonTerminal("functionDeclaration");
#endregion
#region terminals
CommentTerminal singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(singleLineComment);
CommentTerminal delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(delimitedComment);
IdentifierTerminal variable_id = TerminalFactory.CreateCSharpIdentifier("variable_id");
IdentifierTerminal namespace_id = TerminalFactory.CreateCSharpIdentifier("namespace_id");
IdentifierTerminal function_id = TerminalFactory.CreateCSharpIdentifier("function_id");
IdentifierTerminal program_id = TerminalFactory.CreateCSharpIdentifier("program_id");
IdentifierTerminal identifier_id = CreateCSharpIdentifier("identifier_id");
NonTerminal datatype = new NonTerminal("datatype");
//identifierTerminal.("set", "to", "if", "freight", "cost", "is", "loop", "through", "order");
this.MarkPunctuation(";", "[", "]", "(", ")");
#endregion
#endregion
#region grammar
//<Program> ::= "Program" <ProgramName> <StatementList> <FunctionList> "End" "Program"
programDeclaration.Rule = ToTerm("Program") + namespace_id + program_id + "[" + statementList + "]";
program.Rule = programDeclaration; // +Symbol("End") + Symbol("Program");
datatype.Rule = ToTerm("char") | "real" | "string";
#region statements
//<StatementList> ::= <Statement>*
statementList.Rule = MakeStarRule(statementList, null, statement);
statement.Rule = emptyStatement | printStatement | ifStatement
| whileLoop
| localVariableDeclaration | assignment;
emptyStatement.Rule = ToTerm(";"); //setVariable + ";" | ifStatement | orderLoop | expression + ";";
// printStatement.Rule = ToTerm("print") + (stringLiteral | charLiteral) + ";";
printStatement.Rule = ToTerm("print") + expression + ";";
//<IfStatement> ::= "if" <Expression> "[" <StatementList> "]"
ifStatement.Rule = ToTerm("if") + expression + "[" + statementList + "]";
whileLoop.Rule = ToTerm("while") + expression + "[" + statementList + "]";
assignment.Rule = "let" + identifier_id + (ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=") + expression + ";";
//functionDeclaration.Rule = "function" + identifier_id + "(" +
localVariableDeclaration.Rule = ToTerm("declare") + identifier_id + datatype + ";"; // identifier_id
#endregion
#region expressions
//<Expression> ::= <number> | <variable> | <string>
// | <Expression> <BinaryOperator> <Expression>
// | "(" <Expression> ")"
expression.Rule = number | variable_id | stringLiteral | charLiteral
| expression + binaryOperator + expression
| conditionalExpression
| "(" + expression + ")";
//<BinaryOperator> ::= "+" | "-" | "*" | "/" | "<" | ">" | "<=" | ">=" | "is"
binaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "%";
// "=="
conditionalExpression.Rule = expression + (ToTerm("<") | ">" | "<=" | ">=") + expression;
#endregion
#endregion
}
public void Visit(StringLiteral literal, CommonTree tree)
{
Parent(tree).Children.Add(literal);
SetLine(literal, tree);
literal.Value = ParseLiteral(tree.Text);
}
public virtual void Exit(StringLiteral stringLiteral)
{
}
public GSCGrammar()
{
#region Lexical structure
//Comments
var blockComment = new CommentTerminal("block-comment", "/*", "*/");
var lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
//Literals
var numberLiteral = new NumberLiteral("numberLiteral", NumberOptions.AllowSign);
var stringLiteral = new StringLiteral("stringLiteral", "\"");
var identifier = new IdentifierTerminal("identifier", @"_/\", "_");
MarkPunctuation("(", ")", "{", "}", "[", "]", ",", ".", ";", "::", "[[", "]]", "#include", "#using_animtree");
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/", "%");
RegisterOperators(3, "|", "&", "^");
RegisterOperators(4, "&&", "||");
RegisterBracePair("(", ")");
#endregion
var program = new NonTerminal("program");
var functions = new NonTerminal("functions");
var function = new NonTerminal("function");
var declarations = new NonTerminal("declarations");
var declaration = new NonTerminal("declaration");
var includes = new NonTerminal("includes");
var include = new NonTerminal("include");
var gscForFunction = new NonTerminal("gscForFunction");
var baseCall = new NonTerminal("baseCall");
var baseCallPointer = new NonTerminal("baseCallPointer");
var scriptFunctionCall = new NonTerminal("scriptFunctionCall");
var scriptFunctionCallPointer = new NonTerminal("scriptFunctionCallPointer");
var scriptMethodCall = new NonTerminal("scriptMethodCall");
var scriptMethodCallPointer = new NonTerminal("scriptMethodCallPointer");
var scriptThreadCall = new NonTerminal("scriptThreadCall");
var scriptThreadCallPointer = new NonTerminal("scriptThreadCallPointer");
var scriptMethodThreadCall = new NonTerminal("scriptMethodThreadCall");
var scriptMethodThreadCallPointer = new NonTerminal("scriptMethodThreadCallPointer");
var call = new NonTerminal("call");
var simpleCall = new NonTerminal("simpleCall");
var parenParameters = new NonTerminal("parenParameters");
var parameters = new NonTerminal("parameters");
var expr = new NonTerminal("expr");
var setVariableField = new NonTerminal("setVariableField");
var array = new NonTerminal("array");
var vector = new NonTerminal("vector");
var _operator = new NonTerminal("operator");
var relationalOperator = new NonTerminal("relationalOperator");
var expression = new NonTerminal("expression");
var relationalExpression = new NonTerminal("relationalExpression");
var directAccess = new NonTerminal("directAccess");
var boolNot = new NonTerminal("boolNot");
var wait = new NonTerminal("wait");
var size = new NonTerminal("size");
var isString = new NonTerminal("isString");
var hashedString = new NonTerminal("hashedString");
var statement = new NonTerminal("statement");
var ifStatement = new NonTerminal("ifStatement");
var elseStatement = new NonTerminal("elseStatement");
var whileStatement = new NonTerminal("whileStatement");
var forStatement = new NonTerminal("forStatement");
var forBody = new NonTerminal("forBody");
var switchStatement = new NonTerminal("switchStatement");
var switchLabel = new NonTerminal("switchLabel");
var switchContents = new NonTerminal("switchContents");
var switchContent = new NonTerminal("switchContent");
var foreachStatement = new NonTerminal("foreachStatement");
var booleanExpression = new NonTerminal("booleanExpression");
var block = new NonTerminal("block");
var blockContent = new NonTerminal("blockContent");
var statementBlock = new NonTerminal("statementBlock");
var shortExprOperator = new NonTerminal("shortExprOperator");
var forIterate = new NonTerminal("forIterate");
var conditionalStatement = new NonTerminal("conditionalStatement");
var _return = new NonTerminal("return");
var getFunction = new NonTerminal("getFunction");
var developerScript = new NonTerminal("developerScript");
var animTree = new NonTerminal("animTree");
var usingAnimTree = new NonTerminal("usingAnimTree");
var getAnimation = new NonTerminal("getAnimation");
var waitTillFrameEnd = new NonTerminal("waitTillFrameEnd");
var jumpStatement = new NonTerminal("jumpStatement");
var parenExpr = new NonTerminal("parenExpr");
waitTillFrameEnd.Rule = identifier + ";";
usingAnimTree.Rule = ToTerm("#using_animtree") + "(" + stringLiteral + ")" + ";";
getAnimation.Rule = ToTerm("%") + identifier;
animTree.Rule = ToTerm("#animtree");
program.Rule = includes + usingAnimTree + functions | usingAnimTree + functions | includes + functions | functions;
functions.Rule = MakePlusRule(functions, function);
function.Rule = identifier + parenParameters + block;
declarations.Rule = MakePlusRule(declarations, declaration);
declaration.Rule = simpleCall | statement | setVariableField | wait | _return | waitTillFrameEnd | jumpStatement;
block.Rule = ToTerm("{") + blockContent + "}" | ToTerm("{") + "}";
blockContent.Rule = declarations;
parenExpr.Rule = ToTerm("(") + expr + ")";
expr.Rule = directAccess | call | identifier | stringLiteral | array | numberLiteral | vector | expression |
relationalExpression | conditionalStatement | boolNot | size |
isString | getFunction | hashedString | getAnimation | animTree | parenExpr;
parameters.Rule = MakeStarRule(parameters, ToTerm(","), expr) | expr;
parenParameters.Rule = ToTerm("(") + parameters + ")" | "(" + ")";
includes.Rule = MakePlusRule(includes, include);
include.Rule = ToTerm("#include") + identifier + ";";
array.Rule = expr + "[" + expr + "]" | ToTerm("[]");
vector.Rule = ToTerm("(") + expr + "," + expr + "," + expr + ")";
shortExprOperator.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "++" | "--";
setVariableField.Rule = expr + shortExprOperator + expr + ";" | expr + shortExprOperator + ";";
_operator.Rule = ToTerm("+") | "-" | "/" | "*" | "%" | "&" | "|";
relationalOperator.Rule = ToTerm(">") | ">=" | "<" | "<=" | "==" | "!=";
expression.Rule = expr + _operator + expr | "(" + expr + _operator + expr + ")";
relationalExpression.Rule = expr + relationalOperator + expr;
booleanExpression.Rule = expr + "&&" + expr
| booleanExpression + "&&" + booleanExpression
| ToTerm("(") + expr + "&&" + expr + ")"
| expr + "||" + expr
| ToTerm("(") + expr + "||" + expr + ")"
| booleanExpression + "||" + booleanExpression
| expr;
directAccess.Rule = expr + "." + identifier;
boolNot.Rule = ToTerm("!") + expr | ToTerm("!") + "(" + booleanExpression + ")";
wait.Rule = ToTerm("wait") + expr + ";";
size.Rule = expr + ".size";
_return.Rule = ToTerm("return") + expr + ";" | ToTerm("return") + booleanExpression + ";" | ToTerm("return") + ";";
jumpStatement.Rule = ToTerm("break") + ";" | ToTerm("continue") + ";";
isString.Rule = ToTerm("&") + stringLiteral;
hashedString.Rule = ToTerm("#") + stringLiteral;
getFunction.Rule = ToTerm("::") + expr | gscForFunction + expr;
gscForFunction.Rule = identifier + "::";
baseCall.Rule = gscForFunction + identifier + parenParameters | identifier + parenParameters;
baseCallPointer.Rule = ToTerm("[[") + expr + "]]" + parenParameters;
scriptFunctionCall.Rule = baseCall;
scriptFunctionCallPointer.Rule = baseCallPointer;
scriptMethodCall.Rule = expr + baseCall;
scriptMethodCallPointer.Rule = expr + baseCallPointer;
scriptThreadCall.Rule = ToTerm("thread") + baseCall;
scriptThreadCallPointer.Rule = ToTerm("thread") + baseCallPointer;
scriptMethodThreadCall.Rule = expr + "thread" + baseCall;
scriptMethodThreadCallPointer.Rule = expr + "thread" + baseCallPointer;
call.Rule = scriptFunctionCall | scriptFunctionCallPointer | scriptMethodCall | scriptMethodCallPointer |
scriptThreadCall | scriptThreadCallPointer | scriptMethodThreadCall |
scriptMethodThreadCallPointer;
simpleCall.Rule = call + ";";
statementBlock.Rule = block | declaration;
statement.Rule = ifStatement | whileStatement | forStatement | switchStatement | foreachStatement | developerScript;
ifStatement.Rule = ToTerm("if") + "(" + booleanExpression + ")" + statementBlock |
ToTerm("if") + "(" + booleanExpression + ")" + statementBlock + elseStatement;
elseStatement.Rule = ToTerm("else") + statementBlock | ToTerm("else") + ifStatement;
whileStatement.Rule = ToTerm("while") + "(" + booleanExpression + ")" + statementBlock;
forIterate.Rule = expr + shortExprOperator + expr | expr + shortExprOperator;
forBody.Rule = setVariableField + booleanExpression + ";" + forIterate
| ToTerm(";") + booleanExpression + ";" + forIterate
| ToTerm(";") + ";" + forIterate
| ToTerm(";") + ";"
| setVariableField + ";" + forIterate
| setVariableField + ";"
| ToTerm(";") + booleanExpression + ";"
| setVariableField + booleanExpression + ";";
forStatement.Rule = ToTerm("for") + "(" + forBody + ")" + statementBlock;
foreachStatement.Rule = ToTerm("foreach") + "(" + identifier + "in" + expr + ")" + statementBlock;
switchLabel.Rule = ToTerm("case") + expr + ":" | ToTerm("default") + ":";
switchContents.Rule = MakePlusRule(switchContents, switchContent);
switchContent.Rule = switchLabel + blockContent | switchLabel;
switchStatement.Rule = ToTerm("switch") + parenExpr + "{" + switchContents + "}";
conditionalStatement.Rule = expr + "?" + expr + ":" + expr;
developerScript.Rule = ToTerm("/#") + blockContent + "#/";
Root = program;
}
public GSCGrammar()
{
#region Lexical structure
//Comments
var blockComment = new CommentTerminal("block-comment", "/*", "*/");
var lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
//Literals
var numberLiteral = new NumberLiteral("numberLiteral", NumberOptions.AllowSign);
var stringLiteral = new StringLiteral("stringLiteral", "\"");
var identifier = new IdentifierTerminal("identifier", @"_/\", "_");
MarkPunctuation("(", ")", "{", "}", "[", "]", ",", ".", ";", "::", "[[", "]]", "#include", "#using_animtree");
RegisterOperators(1, "+", "-");
RegisterOperators(2, "*", "/", "%");
RegisterOperators(3, "|", "&", "^");
RegisterOperators(4, "&&", "||");
RegisterBracePair("(", ")");
#endregion
var program = new NonTerminal("program");
var functions = new NonTerminal("functions");
var function = new NonTerminal("function");
var declarations = new NonTerminal("declarations");
var declaration = new NonTerminal("declaration");
var baseCall = new NonTerminal("baseCall");
var scriptFunctionCall = new NonTerminal("scriptFunctionCall");
var call = new NonTerminal("call");
var simpleCall = new NonTerminal("simpleCall");
var parenParameters = new NonTerminal("parenParameters");
var parameters = new NonTerminal("parameters");
var expr = new NonTerminal("expr");
var expression = new NonTerminal("expression");
var isString = new NonTerminal("isString");
var block = new NonTerminal("block");
var blockContent = new NonTerminal("blockContent");
var parenExpr = new NonTerminal("parenExpr");
program.Rule = functions | functions | functions;
functions.Rule = MakePlusRule(functions, function);
function.Rule = identifier + parenParameters + block;
declarations.Rule = MakePlusRule(declarations, declaration);
declaration.Rule = simpleCall;
block.Rule = ToTerm("{") + blockContent + "}" | ToTerm("{") + "}";
blockContent.Rule = declarations;
parenExpr.Rule = ToTerm("(") + expr + ")";
expr.Rule = call | identifier | stringLiteral | numberLiteral | expression | isString | parenExpr;
parameters.Rule = MakeStarRule(parameters, ToTerm(","), expr) | expr;
parenParameters.Rule = ToTerm("(") + parameters + ")" | "(" + ")";
expression.Rule = expr + expr | "(" + expr + expr + ")";
isString.Rule = ToTerm("&") + stringLiteral;
baseCall.Rule = identifier + parenParameters | identifier + parenParameters;
scriptFunctionCall.Rule = baseCall;
call.Rule = scriptFunctionCall;
simpleCall.Rule = call + ";";
Root = program;
}
public Gramatica_CQL() : base(caseSensitive: false)
{
#region Expresiones_Regulares
StringLiteral CADENA = new StringLiteral("cadena", "\"");
StringLiteral CADENA_ESPECIAL = new StringLiteral("cadena_especial", "\'");
var ENTERO = new NumberLiteral("entero");
var DECIMAL = new RegexBasedTerminal("decimal", "[0-9]+'.'[0-9]+");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("Identificador");
CommentTerminal comentariosimple = new CommentTerminal("comentariosimple", "//", "\n", "\r\n"); //si viene una nueva linea se termina de reconocer el comentario.
CommentTerminal comentariomulti = new CommentTerminal("comentariomulti", "/*", "*/");
#endregion
#region Terminales
var ARROBA = ToTerm("@");
var LOG = ToTerm("log");
var NULO = ToTerm("null");
var VERDADERO = ToTerm("true");
var FALSO = ToTerm("false");
var CREAR = ToTerm("create");
var TYPE = ToTerm("type");
var SI = ToTerm("if");
var NO = ToTerm("not");
var EXISTE = ToTerm("exists");
var ALTERAR = ToTerm("alter");
var AGREGAR = ToTerm("add");
var ELIMINAR = ToTerm("delete");
var DATABASE = ToTerm("database");
var USAR = ToTerm("use");
var BORRAR = ToTerm("drop");
var TABLA = ToTerm("table");
var CONTADOR = ToTerm("counter");
var TIPOSTRING = ToTerm("string");
var TIPOENTERO = ToTerm("int");
var TIPODOUBLE = ToTerm("double");
var TIPOTIME = ToTerm("time");
var TIPODATE = ToTerm("date");
var TIPOBOOLEAN = ToTerm("boolean");
var PRIMARY = ToTerm("primary");
var KEY = ToTerm("key");
var TRUNCAR = ToTerm("truncate");
var COMMIT = ToTerm("commit");
var ROOLBACK = ToTerm("roolback");
var USUARIO = ToTerm("user");
var CON = ToTerm("with");
var PASS = ToTerm("password");
var PERMITIR = ToTerm("grant");
var DENEGAR = ToTerm("revoke");
var ON = ToTerm("on");
var INSERT = ToTerm("insert");
var INTO = ToTerm("into");
var ACTUALIZAR = ToTerm("update");
var DONDE = ToTerm("where");
var DESDE = ToTerm("from");
var CONSULTA = ToTerm("select");
var IN = ToTerm("in");
var ASC = ToTerm("asc");
var DESC = ToTerm("desc");
var LIMIT = ToTerm("limit");
var ORDER = ToTerm("order");
var BY = ToTerm("by");
var BEGIN = ToTerm("begin");
var APPLY = ToTerm("apply");
var BATCH = ToTerm("batch");
var COUNT = ToTerm("count");
var MIN = ToTerm("min");
var MAX = ToTerm("max");
var AVG = ToTerm("avg");
var SUM = ToTerm("sum");
var SET = ToTerm("set");
var MAP = ToTerm("map");
var LIST = ToTerm("list");
var MAS = ToTerm("+");
var MENOS = ToTerm("-");
var POTENCIA = ToTerm("**");
var MUL = ToTerm("*");
var DIV = ToTerm("/");
var MOD = ToTerm("%");
var INC = ToTerm("++");
var DEC = ToTerm("--");
var IGUAL = ToTerm("=");
var MASIGUAL = ToTerm("+=");
var MENOSIGUAL = ToTerm("-=");
var PORIGUAL = ToTerm("*=");
var DIVIGUAL = ToTerm("/=");
var MENOR = ToTerm("<");
var MAYOR = ToTerm(">");
var MAYORIGUAL = ToTerm(">=");
var MENORIGUAL = ToTerm("<=");
var IGUALIGUAL = ToTerm("==");
var DIFERENTE = ToTerm("!=");
var SUMALOGICA = ToTerm("||");
var MULLOGICA = ToTerm("&&");
var SUMALOGICAEXCLUSIVA = ToTerm("^");
var NEGACION = ToTerm("!");
var PREGUNTA = ToTerm("?");
var SINO = ToTerm("else");
var SELECCIONA = ToTerm("switch");
var CASO = ToTerm("case");
var DEFECTO = ToTerm("default");
var MIENTRAS = ToTerm("while");
var HACER = ToTerm("do");
var PARA = ToTerm("for");
var NUEVO = ToTerm("new");
var GET = ToTerm("get");
var REMOVE = ToTerm("remove");
var SIZE = ToTerm("size");
var CLEAR = ToTerm("clear");
var CONTAINS = ToTerm("contains");
var PROCEDURE = ToTerm("procedure");
var CALL = ToTerm("call");
var LENGTH = ToTerm("length");
var TOUPPER = ToTerm("touppercase");
var TOLOWER = ToTerm("tolowercase");
var STARTSWITH = ToTerm("startswith");
var ENDSWITH = ToTerm("endswith");
var SUBSTRING = ToTerm("substring");
var GETYEAR = ToTerm("getyear");
var GETMONTH = ToTerm("getmonth");
var GETDAY = ToTerm("getday");
var GETHOUR = ToTerm("gethour");
var GETMINUTE = ToTerm("getminuts");
var GETSECOND = ToTerm("getseconds");
var TODAY = ToTerm("today");
var NOW = ToTerm("now");
var BREAK = ToTerm("break");
var VALUES = ToTerm("values");
var CONTINUE = ToTerm("break");
var RETURN = ToTerm("return");
var CURSOR = ToTerm("cursor");
var IS = ToTerm("is");
var EACH = ToTerm("each");
var OPEN = ToTerm("open");
var CLOSE = ToTerm("close");
var THROW = ToTerm("throw");
var TRY = ToTerm("try");
var CATCH = ToTerm("catch");
var MESSAGE = ToTerm("message");
var COMA = ToTerm(",");
var PUNTO = ToTerm(".");
var PUNTOCOMA = ToTerm(";");
var DOSPUNTOS = ToTerm(":");
var ABRIRCOR = ToTerm("[");
var CERRARCOR = ToTerm("]");
var ABRIRPARENTESIS = ToTerm("(");
var CERRARPARENTESIS = ToTerm(")");
var ABRIRPARENTESIS_E = ToTerm("(<");
var CERRARPARENTESIS_E = ToTerm(">)");
var ABRIRLLAVE = ToTerm("{");
var CERRARLLAVE = ToTerm("}");
var EXCEPCION1 = ToTerm("TypeAlreadyExists");
var EXCEPCION2 = ToTerm("TypeDontExists");
var EXCEPCION3 = ToTerm("BDAlreadyExists");
var EXCEPCION4 = ToTerm("BDDontExists");
var EXCEPCION5 = ToTerm("UseBDException");
var EXCEPCION6 = ToTerm("TableAlreadyExists");
var EXCEPCION7 = ToTerm("TableDontExists");
var EXCEPCION8 = ToTerm("CounterTypeException");
var EXCEPCION9 = ToTerm("UserAlreadyExists");
var EXCEPCION10 = ToTerm("UserDontExists");
var EXCEPCION11 = ToTerm("ValuesException");
var EXCEPCION12 = ToTerm("ColumnException");
var EXCEPCION13 = ToTerm("BatchException");
var EXCEPCION14 = ToTerm("IndexOutException");
var EXCEPCION15 = ToTerm("ArithmeticException");
var EXCEPCION16 = ToTerm("NullPointerException");
var EXCEPCION17 = ToTerm("NumberReturnsException");
var EXCEPCION18 = ToTerm("FunctionAlreadyExists");
var EXCEPCION19 = ToTerm("ProcedureAlreadyExists");
var EXCEPCION20 = ToTerm("ObjectAlreadyExists");
RegisterOperators(1, Associativity.Right, IGUAL);
RegisterOperators(2, Associativity.Right, PREGUNTA, DOSPUNTOS);
RegisterOperators(3, Associativity.Right, PUNTO);
RegisterOperators(4, Associativity.Left, SUMALOGICA);
RegisterOperators(5, Associativity.Left, MULLOGICA);
RegisterOperators(6, Associativity.Left, SUMALOGICAEXCLUSIVA);
RegisterOperators(7, Associativity.Left, DIFERENTE, IGUALIGUAL);
RegisterOperators(8, Associativity.Neutral, MAYORIGUAL, MENORIGUAL, MENOR, MAYOR);
RegisterOperators(9, Associativity.Left, MAS, MENOS);
RegisterOperators(10, Associativity.Left, MUL, DIV, MOD);
RegisterOperators(11, Associativity.Left, POTENCIA);
RegisterOperators(12, Associativity.Right, NEGACION);
RegisterOperators(13, Associativity.Neutral, INC, DEC);
RegisterOperators(14, Associativity.Right, ABRIRPARENTESIS, CERRARPARENTESIS);
NonGrammarTerminals.Add(comentariosimple);
NonGrammarTerminals.Add(comentariomulti);
#endregion
#region No Terminales
NonTerminal inicial = new NonTerminal("S");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal sentenciadeclaracion = new NonTerminal("declaracion");
NonTerminal declaracion_funcion = new NonTerminal("declaracion_funcion");
NonTerminal declaracion_procedimiento = new NonTerminal("declaracion_procedimiento");
NonTerminal sentenciaasignacion = new NonTerminal("sentenciaasignacion");
NonTerminal sentenciaimprimir = new NonTerminal("sentenciaimprimir");
NonTerminal sentenciadetener = new NonTerminal("sentenciadetener");
NonTerminal sentenciaretornar = new NonTerminal("sentenciaretornar");
NonTerminal sentenciacontinuar = new NonTerminal("sentenciacontinuar");
NonTerminal sentenciasi = new NonTerminal("sentenciaSI");
NonTerminal sentenciaselecciona = new NonTerminal("sentenciaselecciona");
NonTerminal sentenciacaso = new NonTerminal("sentenciacaso");
NonTerminal sentenciamientras = new NonTerminal("sentenciamientras");
NonTerminal sentenciafor = new NonTerminal("sentenciafor");
NonTerminal sentenciaforeach = new NonTerminal("sentenciaforeach");
NonTerminal sentenciahacermientras = new NonTerminal("sentenciahacermientras");
NonTerminal sentenciacrearbd = new NonTerminal("sentenciacrearbd");
NonTerminal sentenciausarbd = new NonTerminal("sentenciausarbd");
NonTerminal sentenciaborrarbd = new NonTerminal("sentenciaborrarbd");
NonTerminal sentenciaalterartabla = new NonTerminal("sentenciaalterarbd");
NonTerminal sentenciatruncartabla = new NonTerminal("sentenciatruncartabla");
NonTerminal sentenciacreartabla = new NonTerminal("sentenciacreartabla");
NonTerminal sentenciaborrartabla = new NonTerminal("sentenciaborrartabla");
NonTerminal sentenciacommit = new NonTerminal("sentenciacommit");
NonTerminal sentenciarollback = new NonTerminal("sentenciarollback");
NonTerminal sentenciacrearusuario = new NonTerminal("sentenciacrearusuario");
NonTerminal sentenciapermitir = new NonTerminal("sentenciapermitir");
NonTerminal sentenciadenegar = new NonTerminal("sentenciadenegar");
NonTerminal sentenciainsertar = new NonTerminal("sentenciainsertar");
NonTerminal sentenciaactualizar = new NonTerminal("sentenciaactualizar");
NonTerminal sentenciaeliminar = new NonTerminal("sentenciaeliminar");
NonTerminal sentenciaconsulta = new NonTerminal("sentenciaconsulta");
NonTerminal sentenciabatch = new NonTerminal("sentenciabatch");
NonTerminal sentenciaagregacion = new NonTerminal("sentenciaagregacion");
NonTerminal sentenciathrow = new NonTerminal("sentenciathrow");
NonTerminal sentenciatrycatch = new NonTerminal("sentenciatrycatch");
NonTerminal tipo = new NonTerminal("tipo");
NonTerminal sentenciacrearusertype = new NonTerminal("sentenciacrearusertype");
NonTerminal listavariables = new NonTerminal("listavariables");
NonTerminal declaracion = new NonTerminal("declaracion");
NonTerminal expresion = new NonTerminal("expresion");
NonTerminal listaatributos = new NonTerminal("listaatributos");
NonTerminal declaracionesusertypes = new NonTerminal("declaracionesusertypes");
NonTerminal Listavalores = new NonTerminal("Listavalores");
NonTerminal LISTAINSTRUCCIONES = new NonTerminal("LISTAINSTRUCCIONES");
NonTerminal Listacasos = new NonTerminal("Listacasos");
NonTerminal Lista_acceso = new NonTerminal("Lista_acceso");
NonTerminal Acceso = new NonTerminal("Acceso");
NonTerminal operacionesunariomenos = new NonTerminal("operacionesunariomenos");
NonTerminal operacionesunarionegacion = new NonTerminal("operacionesunarionegacion");
NonTerminal verificacionExiste = new NonTerminal("verificacionExiste");
NonTerminal lista_declaraciones_tabla = new NonTerminal("lista_declaraciones_tabla");
NonTerminal declaracion_tabla = new NonTerminal("declaracion_tabla");
NonTerminal llave_primaria = new NonTerminal("llave_primaria");
NonTerminal llave_primaria_compuesta = new NonTerminal("llave_primaria_compuesta");
NonTerminal MODIFICADOR = new NonTerminal("MODIFICADOR");
NonTerminal TIPOEXCEPCION = new NonTerminal("TIPOEXCEPCION");
NonTerminal lista_identificadores = new NonTerminal("lista_identificadores");
NonTerminal sentencia_alterar_user_type = new NonTerminal("sentencia_alterar_user_type");
NonTerminal sentencia_eliminar_user_type = new NonTerminal("sentencia_eliminar_user_type");
NonTerminal Lista_parametros = new NonTerminal("Lista_parametros");
NonTerminal declaracion_parametro = new NonTerminal("declaracion_parametro");
NonTerminal sentenciacursor = new NonTerminal("sentenciacursor");
NonTerminal sentenciaabrircursor = new NonTerminal("sentenciabrircursor");
NonTerminal sentenciacerrarcursor = new NonTerminal("sentenciacerrarcursor");
NonTerminal Lista_campos = new NonTerminal("Lista_campos");
NonTerminal campo = new NonTerminal("campo");
NonTerminal TIPOORDENAMIENTO = new NonTerminal("TIPOORDENAMIENTO");
NonTerminal TIPOAGREGACION = new NonTerminal("TIPOAGREGACION");
NonTerminal ASIGNACIONES = new NonTerminal("ASIGNACIONES");
NonTerminal sentenciawhere = new NonTerminal("sentenciawhere");
NonTerminal LISTA_SELECCION = new NonTerminal("LISTA_SELECCION");
NonTerminal llamada = new NonTerminal("llamada");
NonTerminal OPERACIONPOST = new NonTerminal("OPERACIONPOST");
NonTerminal instanciaobjeto = new NonTerminal("instanciaobjeto");
NonTerminal llamada_a_nativas = new NonTerminal("llamada_a_nativas");
NonTerminal Lista_clave_valor = new NonTerminal("Lista_clave_valor");
NonTerminal clave_valor = new NonTerminal("clave_valor");
NonTerminal extras_where = new NonTerminal("extras_where");
NonTerminal extra = new NonTerminal("extra");
NonTerminal Tipo_enciclado = new NonTerminal("Tipo_enciclado");
NonTerminal Asignacion_Multiple = new NonTerminal("Asignacion_Multiple");
NonTerminal Asignacion_Multiple_Lista = new NonTerminal("Asignacion_Multiple_Lista");
#endregion
#region Gramatica
inicial.Rule = instrucciones;
LISTAINSTRUCCIONES.Rule = ABRIRLLAVE + instrucciones + CERRARLLAVE
| ABRIRLLAVE + CERRARLLAVE;
instrucciones.Rule = instrucciones + instruccion
| instrucciones + declaracion_funcion
| instrucciones + declaracion_procedimiento
| declaracion_funcion
| declaracion_procedimiento
| instruccion;
tipo.Rule = TIPOBOOLEAN
| TIPODATE
| TIPODOUBLE
| TIPOENTERO
| TIPOEXCEPCION
| TIPOSTRING
| TIPOTIME
| IDENTIFICADOR
| CONTADOR
| MAP
| LIST
| SET
;
declaracion_funcion.Rule = tipo + IDENTIFICADOR + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + LISTAINSTRUCCIONES
| tipo + IDENTIFICADOR + ABRIRPARENTESIS + CERRARPARENTESIS + LISTAINSTRUCCIONES;
declaracion_procedimiento.Rule = PROCEDURE + IDENTIFICADOR + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + COMA + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + LISTAINSTRUCCIONES
| PROCEDURE + IDENTIFICADOR + ABRIRPARENTESIS + CERRARPARENTESIS + COMA + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + LISTAINSTRUCCIONES
| PROCEDURE + IDENTIFICADOR + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + COMA + ABRIRPARENTESIS + CERRARPARENTESIS + LISTAINSTRUCCIONES
| PROCEDURE + IDENTIFICADOR + ABRIRPARENTESIS + CERRARPARENTESIS + COMA + ABRIRPARENTESIS + CERRARPARENTESIS + LISTAINSTRUCCIONES;
Lista_parametros.Rule = MakePlusRule(Lista_parametros, COMA, declaracion_parametro);
declaracion_parametro.Rule = tipo + ARROBA + IDENTIFICADOR;
instruccion.Rule = sentenciacrearusertype //
| sentencia_eliminar_user_type //
| sentencia_alterar_user_type //
| sentenciadeclaracion //
| sentenciaasignacion + PUNTOCOMA
| Asignacion_Multiple_Lista
| sentenciaimprimir //
| sentenciadetener //
| sentenciaretornar //
| sentenciacontinuar //
| sentenciasi //
| sentenciaselecciona //
| sentenciafor //
| sentenciacursor //
| sentenciaabrircursor //
| sentenciacerrarcursor //
| sentenciaforeach //
| sentenciamientras //
| sentenciahacermientras //
| sentenciacrearbd //
| sentenciausarbd //
| sentenciaborrarbd //
| sentenciacreartabla //
| sentenciaalterartabla //
| sentenciatruncartabla //
| sentenciaborrartabla //
| sentenciacommit //
| sentenciarollback //
| sentenciacrearusuario //
| sentenciapermitir //
| sentenciadenegar //
| sentenciainsertar //
| sentenciaactualizar //
| sentenciaeliminar //
| sentenciaconsulta + PUNTOCOMA //
| sentenciaagregacion + PUNTOCOMA //
| sentenciabatch //
| sentenciathrow //
| sentenciatrycatch; //
sentenciaasignacion.Rule = Lista_acceso + IGUAL + expresion
| Lista_acceso + MASIGUAL + expresion
| Lista_acceso + MENOSIGUAL + expresion
| Lista_acceso + PORIGUAL + expresion
| Lista_acceso + DIVIGUAL + expresion
| Lista_acceso;
verificacionExiste.Rule = SI + NO + EXISTE
| SI + EXISTE
| Empty;
sentenciacrearusertype.Rule = CREAR + TYPE + verificacionExiste + IDENTIFICADOR + ABRIRPARENTESIS + listaatributos + CERRARPARENTESIS + PUNTOCOMA
;
listaatributos.Rule = MakePlusRule(listaatributos, COMA, declaracionesusertypes)
;
declaracionesusertypes.Rule = IDENTIFICADOR + Tipo_enciclado
;
Tipo_enciclado.Rule = tipo
| tipo + MENOR + Tipo_enciclado + MAYOR
| tipo + MENOR + tipo + COMA + Tipo_enciclado + MAYOR;
sentencia_alterar_user_type.Rule = ALTERAR + TYPE + IDENTIFICADOR + MODIFICADOR + ABRIRPARENTESIS + lista_identificadores + CERRARPARENTESIS + PUNTOCOMA;
sentencia_eliminar_user_type.Rule = ELIMINAR + TYPE + IDENTIFICADOR + PUNTOCOMA;
lista_identificadores.Rule = lista_identificadores + COMA + IDENTIFICADOR
| lista_identificadores + COMA + IDENTIFICADOR + Tipo_enciclado
| IDENTIFICADOR
| IDENTIFICADOR + Tipo_enciclado//////////////////////////////////// falta los map list y set
;
sentenciacrearbd.Rule = CREAR + DATABASE + verificacionExiste + IDENTIFICADOR + PUNTOCOMA
| CREAR + DATABASE + IDENTIFICADOR + PUNTOCOMA;
sentenciausarbd.Rule = USAR + IDENTIFICADOR + PUNTOCOMA;
sentenciaborrarbd.Rule = BORRAR + DATABASE + IDENTIFICADOR + PUNTOCOMA;
sentenciabatch.Rule = BEGIN + BATCH + PUNTOCOMA + instrucciones + APPLY + BATCH + PUNTOCOMA;
sentenciacreartabla.Rule = CREAR + TABLA + verificacionExiste + IDENTIFICADOR + ABRIRPARENTESIS + lista_declaraciones_tabla + CERRARPARENTESIS + PUNTOCOMA;
lista_declaraciones_tabla.Rule = lista_declaraciones_tabla + COMA + declaracion_tabla + llave_primaria
| lista_declaraciones_tabla + COMA + declaracion_tabla
| declaracion_tabla + llave_primaria
| declaracion_tabla
;
llave_primaria.Rule = PRIMARY + KEY;
declaracion_tabla.Rule = IDENTIFICADOR + tipo
| IDENTIFICADOR + LIST + MENOR + tipo + MAYOR
| IDENTIFICADOR + SET + MENOR + tipo + MAYOR
| IDENTIFICADOR + MAP + MENOR + tipo + COMA + tipo + MAYOR
| PRIMARY + KEY + ABRIRPARENTESIS + llave_primaria_compuesta + CERRARPARENTESIS;
llave_primaria_compuesta.Rule = MakePlusRule(llave_primaria_compuesta, COMA, IDENTIFICADOR)
;
sentenciaalterartabla.Rule = ALTERAR + TABLA + IDENTIFICADOR + MODIFICADOR + ABRIRPARENTESIS + lista_identificadores + CERRARPARENTESIS + PUNTOCOMA;
MODIFICADOR.Rule = AGREGAR | ELIMINAR;
sentenciaborrartabla.Rule = BORRAR + TABLA + verificacionExiste + IDENTIFICADOR + PUNTOCOMA;
sentenciatruncartabla.Rule = TRUNCAR + TABLA + IDENTIFICADOR + PUNTOCOMA;
sentenciacrearusuario.Rule = CREAR + USUARIO + IDENTIFICADOR + CON + PASS + expresion + PUNTOCOMA;
sentenciapermitir.Rule = PERMITIR + IDENTIFICADOR + ON + IDENTIFICADOR + PUNTOCOMA;
sentenciadenegar.Rule = DENEGAR + IDENTIFICADOR + ON + IDENTIFICADOR + PUNTOCOMA;
sentenciacursor.Rule = CURSOR + ARROBA + IDENTIFICADOR + IS + sentenciaconsulta + PUNTOCOMA;
sentenciaabrircursor.Rule = OPEN + ARROBA + IDENTIFICADOR + PUNTOCOMA;
sentenciacerrarcursor.Rule = CLOSE + ARROBA + IDENTIFICADOR + PUNTOCOMA;
sentenciaforeach.Rule = PARA + EACH + ABRIRPARENTESIS + Lista_parametros + CERRARPARENTESIS + IN + ARROBA + IDENTIFICADOR + LISTAINSTRUCCIONES;
sentenciainsertar.Rule = INSERT + INTO + IDENTIFICADOR + VALUES + ABRIRPARENTESIS + Listavalores + CERRARPARENTESIS + PUNTOCOMA
| INSERT + INTO + IDENTIFICADOR + ABRIRPARENTESIS + lista_identificadores + CERRARPARENTESIS + VALUES + ABRIRPARENTESIS + Listavalores + CERRARPARENTESIS + PUNTOCOMA;
sentenciaactualizar.Rule = ACTUALIZAR + IDENTIFICADOR + SET + ASIGNACIONES + sentenciawhere + PUNTOCOMA
| ACTUALIZAR + IDENTIFICADOR + SET + ASIGNACIONES + PUNTOCOMA;
sentenciaeliminar.Rule = ELIMINAR + DESDE + IDENTIFICADOR + sentenciawhere + PUNTOCOMA
| ELIMINAR + expresion + DESDE + IDENTIFICADOR + sentenciawhere + PUNTOCOMA
| ELIMINAR + DESDE + IDENTIFICADOR + PUNTOCOMA
| ELIMINAR + expresion + DESDE + IDENTIFICADOR + PUNTOCOMA;
sentenciaconsulta.Rule = CONSULTA + LISTA_SELECCION + DESDE + IDENTIFICADOR + sentenciawhere
| CONSULTA + LISTA_SELECCION + DESDE + IDENTIFICADOR;
LISTA_SELECCION.Rule = MakePlusRule(LISTA_SELECCION, COMA, Lista_acceso)
| MUL;
ASIGNACIONES.Rule = MakePlusRule(ASIGNACIONES, COMA, sentenciaasignacion)
;
sentenciawhere.Rule = DONDE + expresion
| DONDE + expresion + extras_where
;
extras_where.Rule = MakePlusRule(extras_where, extra);
extra.Rule = ORDER + BY + Lista_campos
| LIMIT + expresion
| IN + ABRIRPARENTESIS + Listavalores + CERRARPARENTESIS;
sentenciaagregacion.Rule = TIPOAGREGACION + ABRIRPARENTESIS_E + sentenciaconsulta + CERRARPARENTESIS_E;
TIPOAGREGACION.Rule = AVG
| COUNT
| MIN
| MAX
| SUM;
Lista_campos.Rule = MakePlusRule(Lista_campos, COMA, campo)
;
campo.Rule = IDENTIFICADOR + TIPOORDENAMIENTO
| IDENTIFICADOR;
TIPOORDENAMIENTO.Rule = ASC | DESC;
sentenciaimprimir.Rule = LOG + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + PUNTOCOMA;
sentenciasi.Rule = SI + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES
| SI + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES + SINO + sentenciasi
| SI + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES + SINO + LISTAINSTRUCCIONES;
sentenciadetener.Rule = BREAK + PUNTOCOMA;
sentenciaselecciona.Rule = SELECCIONA + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + ABRIRLLAVE + Listacasos + CERRARLLAVE;
Listacasos.Rule = MakePlusRule(Listacasos, sentenciacaso);
sentenciacaso.Rule = CASO + expresion + DOSPUNTOS + instrucciones
| DEFECTO + DOSPUNTOS + instrucciones
;
sentenciafor.Rule = PARA + ABRIRPARENTESIS + sentenciadeclaracion + expresion + PUNTOCOMA + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES;
sentenciamientras.Rule = MIENTRAS + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES;
sentenciahacermientras.Rule = HACER + LISTAINSTRUCCIONES + MIENTRAS + ABRIRPARENTESIS + expresion + CERRARPARENTESIS + LISTAINSTRUCCIONES;
sentenciacontinuar.Rule = CONTINUE + PUNTOCOMA;
sentenciaretornar.Rule = RETURN + Listavalores + PUNTOCOMA;
sentenciathrow.Rule = THROW + NUEVO + TIPOEXCEPCION + PUNTOCOMA;
sentenciatrycatch.Rule = TRY + LISTAINSTRUCCIONES + CATCH + ABRIRPARENTESIS + tipo + ARROBA + IDENTIFICADOR + CERRARPARENTESIS + LISTAINSTRUCCIONES;
TIPOEXCEPCION.Rule = EXCEPCION1
| EXCEPCION2
| EXCEPCION3
| EXCEPCION4
| EXCEPCION5
| EXCEPCION6
| EXCEPCION7
| EXCEPCION8
| EXCEPCION9
| EXCEPCION10
| EXCEPCION11
| EXCEPCION12
| EXCEPCION13
| EXCEPCION14
| EXCEPCION15
| EXCEPCION16
| EXCEPCION17
| EXCEPCION18
| EXCEPCION19
| EXCEPCION20
;
sentenciacommit.Rule = COMMIT + PUNTOCOMA;
sentenciarollback.Rule = ROOLBACK + PUNTOCOMA;
Listavalores.Rule = MakePlusRule(Listavalores, COMA, expresion)
;
sentenciadeclaracion.Rule = tipo + listavariables + PUNTOCOMA;
listavariables.Rule = MakePlusRule(listavariables, COMA, declaracion)
;
declaracion.Rule = ARROBA + IDENTIFICADOR + IGUAL + expresion
| ARROBA + IDENTIFICADOR;
expresion.Rule = expresion + SUMALOGICA + expresion
| expresion + SUMALOGICAEXCLUSIVA + expresion
| expresion + MULLOGICA + expresion
| operacionesunarionegacion
| expresion + IGUALIGUAL + expresion
| expresion + MAYORIGUAL + expresion
| expresion + MENORIGUAL + expresion
| expresion + DIFERENTE + expresion
| expresion + MAYOR + expresion
| expresion + MENOR + expresion
| expresion + MOD + expresion
| expresion + POTENCIA + expresion
| expresion + DIV + expresion
| expresion + MUL + expresion
| operacionesunariomenos
| expresion + MAS + expresion
| expresion + MENOS + expresion
| ABRIRPARENTESIS + expresion + CERRARPARENTESIS
| ABRIRCOR + Listavalores + CERRARCOR
| ABRIRLLAVE + Listavalores + CERRARLLAVE//modificacion
| ABRIRLLAVE + Lista_clave_valor + CERRARLLAVE
| ABRIRCOR + Lista_clave_valor + CERRARCOR
| expresion + PREGUNTA + expresion + DOSPUNTOS + expresion
| OPERACIONPOST
| NULO
| CADENA
| CADENA_ESPECIAL
| VERDADERO
| FALSO
| DECIMAL
| ENTERO
| ABRIRPARENTESIS + tipo + CERRARPARENTESIS + expresion
| Lista_acceso
| NUEVO + instanciaobjeto
/////List @hola= new List<List<String>>;
//@hola.get(0).insert("hola")
//Map @var = new Map<String,Map<String,SET<List<String>>>>;
;
Lista_clave_valor.Rule = MakePlusRule(Lista_clave_valor, COMA, clave_valor);
clave_valor.Rule = expresion + DOSPUNTOS + expresion;
instanciaobjeto.Rule = tipo
| tipo + MENOR + instanciaobjeto + MAYOR
| tipo + MENOR + tipo + COMA + instanciaobjeto + MAYOR;
OPERACIONPOST.Rule = Lista_acceso + INC
| Lista_acceso + DEC
;
operacionesunariomenos.Rule = MENOS + expresion + ReduceHere();
operacionesunarionegacion.Rule = NEGACION + expresion;
llamada.Rule = IDENTIFICADOR + ABRIRPARENTESIS + CERRARPARENTESIS
| IDENTIFICADOR + ABRIRPARENTESIS + Listavalores + CERRARPARENTESIS
| CALL + IDENTIFICADOR + ABRIRPARENTESIS + CERRARPARENTESIS
| CALL + IDENTIFICADOR + ABRIRPARENTESIS + Listavalores + CERRARPARENTESIS
| llamada_a_nativas;
llamada_a_nativas.Rule = LENGTH + ABRIRPARENTESIS + CERRARPARENTESIS
| STARTSWITH + ABRIRPARENTESIS + CERRARPARENTESIS
| TOUPPER + ABRIRPARENTESIS + CERRARPARENTESIS
| TOLOWER + ABRIRPARENTESIS + CERRARPARENTESIS
| ENDSWITH + ABRIRPARENTESIS + CERRARPARENTESIS
| SUBSTRING + ABRIRPARENTESIS + expresion + COMA + expresion + CERRARPARENTESIS
| GETYEAR + ABRIRPARENTESIS + CERRARPARENTESIS
| GETMONTH + ABRIRPARENTESIS + CERRARPARENTESIS
| GETDAY + ABRIRPARENTESIS + CERRARPARENTESIS
| GETHOUR + ABRIRPARENTESIS + CERRARPARENTESIS
| GETMINUTE + ABRIRPARENTESIS + CERRARPARENTESIS
| GETSECOND + ABRIRPARENTESIS + CERRARPARENTESIS
| TODAY + ABRIRPARENTESIS + CERRARPARENTESIS
| NOW + ABRIRPARENTESIS + CERRARPARENTESIS
| INSERT + ABRIRPARENTESIS + expresion + CERRARPARENTESIS
| GET + ABRIRPARENTESIS + expresion + CERRARPARENTESIS
| SET + ABRIRPARENTESIS + expresion + COMA + expresion + CERRARPARENTESIS
| REMOVE + ABRIRPARENTESIS + expresion + CERRARPARENTESIS
| SIZE + ABRIRPARENTESIS + CERRARPARENTESIS
| CLEAR + ABRIRPARENTESIS + CERRARPARENTESIS
| CONTAINS + ABRIRPARENTESIS + expresion + CERRARPARENTESIS
| MESSAGE + ABRIRPARENTESIS + CERRARPARENTESIS
;
Asignacion_Multiple_Lista.Rule = Asignacion_Multiple + IGUAL + llamada + PUNTOCOMA;
Asignacion_Multiple.Rule = MakePlusRule(Asignacion_Multiple, COMA, Lista_acceso);
Lista_acceso.Rule = MakePlusRule(Lista_acceso, PUNTO, Acceso);
Acceso.Rule = ARROBA + IDENTIFICADOR
| IDENTIFICADOR
| IDENTIFICADOR + ABRIRCOR + expresion + CERRARCOR
| llamada
;
#endregion
#region Preferencias
this.Root = inicial;
#endregion
}
public LuaGrammar() : base(true)
{
#region Declare Terminals Here
StringLiteral STRING = CreateLuaString("string");
NumberLiteral NUMBER = CreateLuaNumber("number");
var LONGSTRING = new LuaLongStringTerminal("string block");
// This includes both single-line and block comments
var COMMENT = new LuaCommentTerminal("comment");
NonGrammarTerminals.Add(COMMENT);
// Regular Operators
// Member Select Operators
KeyTerm DOT = Operator(".");
DOT.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Text, TokenTriggers.MemberSelect);
KeyTerm COLON = Operator(":");
COLON.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Text, TokenTriggers.MemberSelect);
// Standard Operators
KeyTerm EQ = Operator("=");
KeyTerm MINUS = Operator("-");
KeyTerm PLUS = Operator("+");
KeyTerm UMINUS = Operator("-");
KeyTerm CONCAT = Operator("..");
KeyTerm GETN = Operator("#");
KeyTerm NOT = Keyword("not");
KeyTerm AND = Keyword("and");
KeyTerm OR = Keyword("or");
KeyTerm keyTermBigBraceLeft = Brace("{");
KeyTerm keyTermBigBraceRight = Brace("}");
#region Keywords
KeyTerm LOCAL = Keyword("local");
KeyTerm DO = Keyword("do");
KeyTerm END = Keyword("end");
KeyTerm WHILE = Keyword("while");
KeyTerm REPEAT = Keyword("repeat");
KeyTerm UNTIL = Keyword("until");
KeyTerm IF = Keyword("if");
KeyTerm THEN = Keyword("then");
KeyTerm ELSEIF = Keyword("elseif");
KeyTerm ELSE = Keyword("else");
KeyTerm FOR = Keyword("for");
KeyTerm IN = Keyword("in");
KeyTerm FUNCTION = Keyword("function");
KeyTerm RETURN = Keyword("return");
KeyTerm BREAK = Keyword("break");
//KeyTerm NIL = Keyword("nil");
//KeyTerm FALSE = Keyword("false");
//KeyTerm TRUE = Keyword("true");
KeyTerm ELLIPSIS = Keyword("...");
#endregion
var IDENTIFIER = new IdentifierTerminal("identifier");
#endregion
#region Declare Transient NonTerminals Here
// Organize the transient non-terminals so they are easier to find. None of these
// will have an AST type by definition
var Statement = new NonTerminal("statment");
var LastStatement = new NonTerminal("last statment", typeof(LuaFunctionReturnNode));
var Statements = new NonTerminal("statement list");
var StatementsEnd = new NonTerminal("statement list end");
var SingleStatementWithTermOpt = new NonTerminal("single statement", Statement | Statement + ";");
var LastStatementWithTermOpt = new NonTerminal("last statement", LastStatement | LastStatement + ";");
var BinOp = new NonTerminal("bin op");
var PrefixExpr = new NonTerminal("prefix expression");
var Var = new NonTerminal("var");
var Args = new NonTerminal("args");
var EllipsisOpt = new NonTerminal("optional ellipsis");
var ParentheicalExpression = new NonTerminal("parentheical expression");
var ArgsParameters = new NonTerminal("parentheical arguments");
var ColonCallOpt = new NonTerminal("colon call");
var FunctionParameters = new NonTerminal("function parameters");
MarkTransient(Statement, Statements, StatementsEnd, SingleStatementWithTermOpt, /*ColonCallOpt,*/
FunctionParameters,
LastStatementWithTermOpt, BinOp, PrefixExpr, Var, Args, EllipsisOpt, ArgsParameters,
ParentheicalExpression);
#endregion
#region Declare NonTerminals Here
// These non-terminals will all require AST types. Anything that isnt really a language construct should be
// refactored into a transient
NonTerminal Expr = new NonTerminal("expression", typeof(LuaExpressionNode));
NonTerminal Chunk = new NonTerminal("chunk", typeof(LuaChunkNode));
NonTerminal Block = new NonTerminal("block", typeof(BlockNode)); // probably should be transient
NonTerminal FunctionName = new NonTerminal("function name", typeof(LuaFunctionIdentifierNode));
NonTerminal VarList = new NonTerminal("var list", typeof(LuaIdentifierListNode));
NonTerminal NameList = new NonTerminal("name list", typeof(LuaIdentifierListNode));
NonTerminal ExprList = new NonTerminal("expression list", typeof(LuaExpressionListNode));
NonTerminal FunctionCall = new NonTerminal("function call", typeof(LuaFunctionCallNode));
NonTerminal Function = new NonTerminal("anonymous function definition", typeof(LuaFunctionDefNode));
NonTerminal FunctionBody = new NonTerminal("function body", typeof(LuaFunctionBodyNode));
NonTerminal ParamList = new NonTerminal("parlist", typeof(LuaParamListNode));
NonTerminal LocalVariableDeclaration = new NonTerminal("local variable declaration", typeof(LuaLocalVariableNode));
NonTerminal LocalVariableDeclarationWithAssignment = new NonTerminal("local variable declaration with assignment", typeof(LuaLocalAssignmentNode));
NonTerminal TableConstructor = new NonTerminal("table construct", typeof(LuaTableNode));
NonTerminal FieldList = new NonTerminal("field list", typeof(LuaExpressionListNode));
NonTerminal Field = new NonTerminal("field", typeof(LuaFieldNode));
NonTerminal FieldSep = new NonTerminal("field sep");
NonTerminal IdentifierWithOptNamespace = new NonTerminal("identifier including namespace");
NonTerminal BinExp = new NonTerminal("binexp", typeof(BinaryOperationNode))
{
Rule = Expr + BinOp + Expr
};
NonTerminal UnOp = new NonTerminal("unary op", typeof(LuaUnaryOperatorNode));
NonTerminal UniExp = new NonTerminal("uniexp", typeof(LuaUnaryOperationNode))
{
Rule = UnOp + Expr
};
NonTerminal VariableAssignment = new NonTerminal("variable assign", typeof(LuaAssignmentNode));
NonTerminal IfBlock = new NonTerminal("if block", typeof(LuaIfNode));
NonTerminal ElseIfBlock = new NonTerminal("ElseIfClause", typeof(LuaIfNode));
NonTerminal ElseIfBlockList = new NonTerminal("ElseIfClause*");
NonTerminal ElseBlockOpt = new NonTerminal("ElseClause");
NonTerminal DoBlock = new NonTerminal("do block", typeof(LuaDoNode));
NonTerminal WhileBlock = new NonTerminal("while block", typeof(LuaWhileNode));
NonTerminal RepeatBlock = new NonTerminal("repeat block", typeof(LuaRepeatNode));
NonTerminal NumForCondition = new NonTerminal("num for condition");
NonTerminal NumForBlock = new NonTerminal("num for block", typeof(LuaForNode));
NonTerminal GenericForCondition = new NonTerminal("generic for condition");
NonTerminal GenericForBlock = new NonTerminal("generic for block", typeof(LuaForNode));
NonTerminal LocalFunctionDeclaration = new NonTerminal("local function declaration", typeof(LuaFunctionLocalDefNode));
NonTerminal FunctionDeclaration = new NonTerminal("function declaration", typeof(LuaFunctionDefNode));
NonTerminal TableAccess = new NonTerminal("table access", typeof(LuaTableAccessNode));
#endregion
#region Place Rules Here
//Using Lua 5.1 grammar as defined in
//http://www.lua.org/manual/5.1/manual.html#8
Root = Chunk;
//chunk ::= {stat [`;´]} [laststat [`;´]]
Statements.Rule = SingleStatementWithTermOpt.Star();
StatementsEnd.Rule = Empty | LastStatementWithTermOpt;
Chunk.Rule = Statements + StatementsEnd;
//block ::= chunk
Block = Chunk;
VariableAssignment.Rule = VarList + EQ + ExprList;
FunctionDeclaration.Rule = FUNCTION + FunctionName + FunctionParameters + FunctionBody;
LocalFunctionDeclaration.Rule = LOCAL + FunctionDeclaration;
LocalVariableDeclaration.Rule = LOCAL + NameList;
LocalVariableDeclarationWithAssignment.Rule = LocalVariableDeclaration + EQ + ExprList;
DoBlock.Rule = DO + Block + END;
WhileBlock.Rule = WHILE + Expr + DO + Block + END;
RepeatBlock.Rule = REPEAT + Block + UNTIL + Expr;
ElseBlockOpt.Rule = Empty | ELSE + Block;
ElseIfBlock.Rule = ELSEIF + Expr + THEN + Block;
ElseIfBlockList.Rule = MakeStarRule(ElseIfBlockList, null, ElseIfBlock);
IfBlock.Rule = IF + Expr + THEN + Block + ElseIfBlockList + ElseBlockOpt + END;
NumForCondition.Rule = IDENTIFIER + EQ + Expr + "," + Expr + ("," + Expr).Q();
NumForBlock.Rule = FOR + NumForCondition + DO + Block + END;
GenericForCondition.Rule = NameList + IN + ExprList;
GenericForBlock.Rule = FOR + GenericForCondition + DO + Block + END;
//stat ::= varlist `=´ explist |
// functioncall |
// do block end |
// while exp do block end |
// repeat block until exp |
// if exp then block {elseif exp then block} [else block] end |
// for Name `=´ exp `,´ exp [`,´ exp] do block end |
// for namelist in explist do block end |
// function funcname funcbody |
// local function Name funcbody |
// local namelist [`=´ explist]
Statement.Rule = VariableAssignment |
FunctionCall |
DoBlock |
WhileBlock |
RepeatBlock |
IfBlock |
NumForBlock |
GenericForBlock |
FunctionDeclaration |
LocalFunctionDeclaration |
LocalVariableDeclaration |
LocalVariableDeclarationWithAssignment;
//laststat ::= return [explist] | break
LastStatement.Rule = RETURN + ExprList | RETURN | BREAK;
//funcname ::= Name {`.´ Name} [`:´ Name]
//FuncName.Rule = Name + (DOT + Name).Star() + (COLON + Name).Q();
ColonCallOpt.Rule = Empty | COLON + IDENTIFIER;
IdentifierWithOptNamespace.Rule = MakePlusRule(IdentifierWithOptNamespace, DOT, IDENTIFIER);
FunctionName.Rule = IdentifierWithOptNamespace + ColonCallOpt;
//varlist ::= var {`,´ var}
VarList.Rule = MakePlusRule(VarList, ToTerm(","), Var);
//namelist ::= Name {`,´ Name}
NameList.Rule = MakePlusRule(NameList, ToTerm(","), IDENTIFIER);
//explist ::= {exp `,´} exp
ExprList.Rule = MakePlusRule(ExprList, ToTerm(","), Expr);
//exp ::= nil | false | true | Number | String | `...´ | function |
// prefixexp | tableconstructor | exp binop exp | unop exp
Expr.Rule = /*NIL | FALSE | TRUE |*/ NUMBER | STRING | LONGSTRING | ELLIPSIS | Function |
PrefixExpr | TableConstructor | BinExp | UniExp;
//var ::= Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name
TableAccess.Rule = PrefixExpr + "[" + Expr + "]" | PrefixExpr + DOT + IDENTIFIER;
Var.Rule = IDENTIFIER | TableAccess;
//prefixexp ::= var | functioncall | `(´ exp `)´
ParentheicalExpression.Rule = ToTerm("(") + Expr + ToTerm(")");
PrefixExpr.Rule = Var | FunctionCall | ParentheicalExpression;
//functioncall ::= prefixexp args | prefixexp `:´ Name args
FunctionCall.Rule = PrefixExpr + Args | PrefixExpr + COLON + IDENTIFIER + Args;
//args ::= `(´ [explist] `)´ | tableconstructor | String
ArgsParameters.Rule = ToTerm("(") + ExprList + ToTerm(")") | ToTerm("(") + ToTerm(")");
Args.Rule = ArgsParameters | TableConstructor | STRING | LONGSTRING;
//function ::= function funcbody
Function.Rule = FUNCTION + FunctionParameters + FunctionBody;
//funcbody ::= `(´ [parlist] `)´ block end
FunctionParameters.Rule = ToTerm("(") + ParamList + ToTerm(")");
FunctionBody.Rule = Block + END;
//parlist ::= namelist [`,´ `...´] | `...´
EllipsisOpt.Rule = Empty | ToTerm(",") + ELLIPSIS;
ParamList.Rule = NameList + EllipsisOpt | ELLIPSIS | Empty;
//tableconstructor ::= `{´ [fieldlist] `}´
//TableConstructor.Rule = "{" + FieldList.Q() + "}";
TableConstructor.Rule = keyTermBigBraceLeft + FieldList + keyTermBigBraceRight;
//fieldlist ::= field {fieldsep field} [fieldsep]
//FieldList.Rule = Field + (FieldSep + Field).Star() + FieldSep.Q();
FieldList.Rule = MakeStarRule(FieldList, FieldSep, Field, TermListOptions.AllowTrailingDelimiter);
//field ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp
Field.Rule = "[" + Expr + "]" + "=" + Expr | IDENTIFIER + "=" + Expr | Expr;
//fieldsep ::= `,´ | `;´
FieldSep.Rule = (ToTerm(",") | ";");
//binop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ |
// `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ |
// and | or
BinOp.Rule = PLUS | MINUS | "*" | "/" | "^" | "%" | CONCAT |
"<" | "<=" | ">" | ">=" | "==" | "~=" |
AND | OR;
//unop ::= `-´ | not | `#´
UnOp.Rule = UMINUS | NOT | GETN;
#endregion
#region Define Keywords and Register Symbols
RegisterBracePair("(", ")");
RegisterBracePair("{", "}");
RegisterBracePair("[", "]");
MarkPunctuation(",", ";");
MarkPunctuation("(", ")");
MarkPunctuation("{", "}");
MarkPunctuation("[", "]");
RegisterOperators(1, OR);
RegisterOperators(2, AND);
RegisterOperators(3, "<", ">", "<=", ">=", "~=", "==");
RegisterOperators(4, Associativity.Right, CONCAT);
RegisterOperators(5, MINUS, PLUS);
RegisterOperators(6, "*", "/", "%");
RegisterOperators(7, NOT, UMINUS);
RegisterOperators(8, Associativity.Right, "^");
#endregion
LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.SupportsCommandLine | LanguageFlags.TailRecursive;
}
public SerializedType VisitStringLiteral(StringLiteral str)
{
throw new NotImplementedException();
}
public Gramatica() : base(caseSensitive: true)
{
#region Expresiones Regulares
//Expresion regular para ids con terminacion .sbs, cadena y numero
RegexBasedTerminal idsbs = new RegexBasedTerminal("[a-zA-Z]([a-zA-Z0-9])*.sbs");
IdentifierTerminal id = new IdentifierTerminal("identificador");
StringLiteral cadena = new StringLiteral(Constantes.T_STR, "\"", StringOptions.AllowsLineBreak);
NumberLiteral numero = new NumberLiteral(Constantes.T_NUM);
//Expresion regular para comentarios
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "#*", "*#");
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "#", "\n");
//Con esto se omiten los comentarios
base.NonGrammarTerminals.Add(comentarioBloque);
base.NonGrammarTerminals.Add(comentarioLinea);
KeyTerm t_number = ToTerm("Number", Constantes.T_NUM),
t_str = ToTerm("String", Constantes.T_STR),
t_bool = ToTerm("Bool", Constantes.T_BOOL),
t_void = ToTerm("Void", Constantes.T_VOID),
define = ToTerm("Define"),
incluye = ToTerm("Incluye"),
principal = ToTerm("Principal"),
mas = ToTerm("+", Constantes.OP_SUM),
menos = ToTerm("-", Constantes.OP_RES),
por = ToTerm("*", Constantes.OP_MUL),
div = ToTerm("/", Constantes.OP_DIV),
mod = ToTerm("%", Constantes.OP_MOD),
pot = ToTerm("^", Constantes.OP_POT),
igual = ToTerm("==", Constantes.OP_IGUAL),
diferente = ToTerm("!=", Constantes.OP_DIF),
menor = ToTerm("<", Constantes.OP_MENOR),
mayor = ToTerm(">", Constantes.OP_MAYOR),
menor_igual = ToTerm("<=", Constantes.OP_MEN_Q),
mayor_igual = ToTerm(">=", Constantes.OP_MAY_Q),
comparacion = ToTerm("~", Constantes.OP_COMP),
and = ToTerm("&&", Constantes.OP_AND),
or = ToTerm("||", Constantes.OP_OR),
xor = ToTerm("|&", Constantes.OP_XOR),
not = ToTerm("!", Constantes.OP_NOT),
fun_dibujar_exp = ToTerm("DibujarEXP"),
fun_dibujar_ast = ToTerm("DibujarAST"),
fun_mostrar = ToTerm("Mostrar"),
mientras = ToTerm("Mientras"),
detener = ToTerm("Detener"),
continuar = ToTerm("Continuar"),
retorno = ToTerm("Retorno"),
para = ToTerm("Para"),
incremento = ToTerm("++", Constantes.INCREMENTO),
decremento = ToTerm("--", Constantes.DECREMENTO),
hasta = ToTerm("Hasta"),
v_true = ToTerm("True", Constantes.TRUE),
v_false = ToTerm("False", Constantes.FALSE),
si = ToTerm("Si"),
sino = ToTerm("Sino"),
selecciona = ToTerm("Selecciona"),
defecto = ToTerm("Defecto"),
pyc = ToTerm(";"),
dp = ToTerm(":"),
parA = ToTerm("("),
parC = ToTerm(")"),
llaveA = ToTerm("{"),
llaveC = ToTerm("}")
;
#endregion
#region No Terminales
NonTerminal
START = new NonTerminal(Constantes.INICIO),
HEADER = new NonTerminal(Constantes.ENCABEZADO),
LISTA_HEADER = new NonTerminal("Lista Header"),
INCLUYE = new NonTerminal(Constantes.INCLUYE),
DEFINE_INCERTEZA = new NonTerminal(Constantes.INCERTEZA),
DEFINE_RUTA = new NonTerminal(Constantes.RUTA),
BODY = new NonTerminal(Constantes.CUERPO_PROGRAMA),
DECLARACION = new NonTerminal(Constantes.DECLARACION),
TIPO_VARIABLE = new NonTerminal("Tipo Variable"),
ASIG_VARIABLE = new NonTerminal("Asignacion Variable"),
L_ID = new NonTerminal(Constantes.LISTA_ID),
FUNCION = new NonTerminal(Constantes.FUNCION),
TIPO_FUNCION = new NonTerminal("Tipo Funcion"),
ELEMENTO_BODY = new NonTerminal("Elemento Body"),
LISTA_BODY = new NonTerminal("Lista Body"),
PRINCIPAL = new NonTerminal(Constantes.PRINCIPAL),
EXP = new NonTerminal(Constantes.EXPRESION),
LOG = new NonTerminal(Constantes.LOGICA),
ARIT = new NonTerminal(Constantes.ARITMETICA),
REL = new NonTerminal(Constantes.RELACIONAL),
VAL = new NonTerminal(Constantes.VALOR),
PRIMITIVO = new NonTerminal(Constantes.PRIMITIVO),
L_PARAM = new NonTerminal("Lista Parametros"),
L_PARAM_2 = new NonTerminal(Constantes.LISTA_PARAMETRO),
CUERPO_FUNC = new NonTerminal(Constantes.CUERPO_FUNCION),
CUERPO_FUNC_CONT = new NonTerminal(Constantes.CUERPO_FUNCION),
CUERPO_FUNC_DET = new NonTerminal(Constantes.CUERPO_FUNCION),
INSTRUCCION = new NonTerminal("Instruccion"),
INSTRUCCION_CONT = new NonTerminal("Instruccion con Continuar"),
INSTRUCCION_DET = new NonTerminal("Instruccion con Detener"),
LLAMADA = new NonTerminal(Constantes.LLAMADA),
VALORES_LLAMADA_T = new NonTerminal("Val llamada"),
VALORES_LLAMADA = new NonTerminal(Constantes.LISTA_VAL),
RETORNO = new NonTerminal(Constantes.RETORNO),
SI = new NonTerminal(Constantes.SI),
SELECCIONA = new NonTerminal(Constantes.SELECCIONA),
PARA = new NonTerminal(Constantes.PARA),
HASTA = new NonTerminal(Constantes.HASTA),
MIENTRAS = new NonTerminal(Constantes.MIENTRAS),
DETENER = new NonTerminal(Constantes.DETENER),
CONTINUAR = new NonTerminal(Constantes.CONTINUAR),
MOSTRAR = new NonTerminal(Constantes.MOSTRAR),
PARAM_MOSTRAR = new NonTerminal("Parametros Mostrar TEMP"),
DIBUJAR_AST = new NonTerminal(Constantes.DIBUJARAST),
DIBUJAR_EXP = new NonTerminal(Constantes.DIBUJAREXP),
EXP_RETORNO = new NonTerminal("EXP Retorno"),
OP = new NonTerminal("Op"),
SI_SINO = new NonTerminal(Constantes.SI_SINO),
SINO = new NonTerminal(Constantes.SINO),
CUERPO_SELECCIONA = new NonTerminal("Cuerpo Selecciona"),
VALOR_N = new NonTerminal("Valor N"),
DEFECTO = new NonTerminal(Constantes.DEFECTO),
TIPO_VALOR = new NonTerminal("Tipo Valor"),
VALOR_ANIDADO = new NonTerminal("Valor Anidado"),
ASIGNACION = new NonTerminal(Constantes.ASIGNACION),
LLAMADA_ENTRE_EXP = new NonTerminal("Llamada Entre EXP"),
NUMBER = new NonTerminal(Constantes.T_NUM),
STRING = new NonTerminal(Constantes.T_STR),
BOOLEAN = new NonTerminal(Constantes.T_BOOL),
VOID = new NonTerminal(Constantes.T_VOID),
INCREMENTO = new NonTerminal(Constantes.INCREMENTO),
DECREMENTO = new NonTerminal(Constantes.DECREMENTO),
TRUE = new NonTerminal(Constantes.TRUE),
FALSE = new NonTerminal(Constantes.FALSE),
ID = new NonTerminal(Constantes.ID)
;
#endregion
#region Gramatica
// START -> HEADER BODY
START.Rule = HEADER + BODY;
#region HEADER
/*
* HEADER -> HEADER ELEMENTO
|ELEMENTO
|null
* ;
*/
HEADER.Rule = MakeStarRule(HEADER, LISTA_HEADER);
/*
* ELEMENTO -> INCLUYE
|DEFINE_INCERTEZA
|DEFINE_RUTA
* ;
*/
LISTA_HEADER.Rule = INCLUYE
| DEFINE_INCERTEZA
| DEFINE_RUTA
;
// INCLUYE -> 'Incluye' idsbs
INCLUYE.Rule = incluye + idsbs;
// DEFINE_INCERTEZA -> 'Define' numero
DEFINE_INCERTEZA.Rule = define + numero;
// DEFINE_RUTA -> 'Define' cadena
DEFINE_RUTA.Rule = define + cadena;
#endregion
#region BODY
/*
* BODY -> BODY LISTA_BODY
| LISTA_BODY
|
*/
BODY.Rule = MakePlusRule(BODY, ELEMENTO_BODY);
/*
* LISTA_BODY = VARIABLE
| FUNCION
| PRINCIPAL
| ;
*/
ELEMENTO_BODY.Rule = PRINCIPAL
| FUNCION
| DECLARACION
;
#region Principal
PRINCIPAL.Rule = principal + "(" + ")" + "{" + CUERPO_FUNC + "}";
#endregion
#region Funcion
FUNCION.Rule = VOID + id + "(" + L_PARAM + ")" + "{" + CUERPO_FUNC + "}"
| TIPO_VARIABLE + id + "(" + L_PARAM + ")" + "{" + CUERPO_FUNC + "}"
;
TIPO_FUNCION.Rule = t_void | TIPO_VARIABLE;
L_PARAM.Rule = MakeStarRule(L_PARAM, ToTerm(","), L_PARAM_2);
L_PARAM_2.Rule = TIPO_VARIABLE + id;
#endregion
/*
* Con las instrucciones me heche una buena fumada
* y separe en varios cuerpos de funciones ya que una funcion void puede tener un retorno
* pero deberia de ir vacio, ahora las funciones tipo string, bool y number tiene que obligatoriamente
* retornar un valor de su tipo de funcion.
* el cuerpo de funciones void tambien es para el metodo principal
*/
#region Instrucciones
CUERPO_FUNC.Rule = MakeStarRule(CUERPO_FUNC, INSTRUCCION);
CUERPO_FUNC_CONT.Rule = MakeStarRule(CUERPO_FUNC_CONT, INSTRUCCION_CONT);
CUERPO_FUNC_DET.Rule = MakeStarRule(CUERPO_FUNC_DET, INSTRUCCION_DET);
INSTRUCCION_DET.Rule = INSTRUCCION
| DETENER
;
INSTRUCCION_CONT.Rule = INSTRUCCION_DET
| CONTINUAR
;
INSTRUCCION.Rule =
LLAMADA + pyc
| DIBUJAR_AST
| DIBUJAR_EXP
| MOSTRAR
| MIENTRAS
| SI_SINO
| SELECCIONA
| PARA
| HASTA
| DECLARACION
| RETORNO
| ASIGNACION
;
#region Llamada
LLAMADA.Rule = id + parA + VALORES_LLAMADA_T + parC;
VALORES_LLAMADA_T.Rule = VALORES_LLAMADA | Empty;
VALORES_LLAMADA.Rule = MakeStarRule(VALORES_LLAMADA, ToTerm(","), EXP);
#endregion
#region Dibujar AST
DIBUJAR_AST.Rule = fun_dibujar_ast + parA + id + parC + pyc;
#endregion
#region Dibujar EXP
DIBUJAR_EXP.Rule = fun_dibujar_exp + parA + EXP + parC + pyc;
#endregion
#region Mostrar
MOSTRAR.Rule = fun_mostrar + parA + cadena + PARAM_MOSTRAR + parC + pyc;
PARAM_MOSTRAR.Rule = "," + VALORES_LLAMADA
| Empty
;
#endregion
#region Detener
DETENER.Rule = detener + pyc;
#endregion
#region Continuar
CONTINUAR.Rule = continuar + pyc;
#endregion
#region Retorno
RETORNO.Rule = retorno + EXP_RETORNO + pyc;
EXP_RETORNO.Rule = EXP | Empty;
#endregion
#region Mientras
MIENTRAS.Rule = mientras + parA + EXP + parC + llaveA + CUERPO_FUNC_CONT + llaveC;
#endregion
#region Para
PARA.Rule = para + parA + t_number + id + "=" + EXP + ";" + EXP + ";" + OP + parC + llaveA + CUERPO_FUNC_CONT + llaveC;
OP.Rule = INCREMENTO | DECREMENTO;
INCREMENTO.Rule = incremento;
DECREMENTO.Rule = decremento;
#endregion
#region Hasta
HASTA.Rule = hasta + parA + EXP + parC + llaveA + CUERPO_FUNC_CONT + llaveC;
#endregion
#region Si
SI_SINO.Rule = SI + SINO;
SI.Rule = si + parA + EXP + parC + llaveA + CUERPO_FUNC_CONT + llaveC;
SINO.Rule = Empty | sino + llaveA + CUERPO_FUNC_CONT + llaveC;
#endregion
#region Seleccion
SELECCIONA.Rule = selecciona + parA + EXP + parC + CUERPO_SELECCIONA;
CUERPO_SELECCIONA.Rule = VALOR_ANIDADO + DEFECTO;
VALOR_ANIDADO.Rule = MakePlusRule(VALOR_ANIDADO, VALOR_N);
VALOR_N.Rule = TIPO_VALOR + dp + llaveA + CUERPO_FUNC_DET + llaveC;
TIPO_VALOR.Rule = numero | cadena;
DEFECTO.Rule = defecto + dp + llaveA + CUERPO_FUNC_DET + llaveC
| Empty;
#endregion
#region Asignacion
ASIGNACION.Rule = id + "=" + EXP + pyc;
#endregion
#endregion
#region Declaracion
DECLARACION.Rule = TIPO_VARIABLE + L_ID + ASIG_VARIABLE + pyc;
TIPO_VARIABLE.Rule = NUMBER | STRING | BOOLEAN;
NUMBER.Rule = t_number;
STRING.Rule = t_str;
BOOLEAN.Rule = t_bool;
VOID.Rule = t_void;
L_ID.Rule = MakePlusRule(L_ID, ToTerm(","), id);
ASIG_VARIABLE.Rule = "=" + EXP
| Empty
;
#endregion
#endregion
#region Expresion
EXP.Rule = LOG
;
LOG.Rule = LOG + and + LOG
| LOG + or + LOG
| LOG + xor + LOG
| not + LOG
| REL
;
REL.Rule = REL + igual + REL
| REL + diferente + REL
| REL + menor + REL
| REL + mayor + REL
| REL + mayor_igual + REL
| REL + menor_igual + REL
| REL + comparacion + REL
| ARIT
;
ARIT.Rule = ARIT + mas + ARIT
| ARIT + menos + ARIT
| ARIT + por + ARIT
| ARIT + div + ARIT
| ARIT + mod + ARIT
| ARIT + pot + ARIT
| menos + ARIT
| VAL
;
VAL.Rule = PRIMITIVO | parA + LOG + parC | ID | LLAMADA;
ID.Rule = id;
PRIMITIVO.Rule = numero | cadena | TRUE | FALSE;
TRUE.Rule = v_true;
FALSE.Rule = v_false;
#endregion
#endregion
this.Root = START;
#region Recuperacion de Errores
MOSTRAR.ErrorRule = SyntaxError + pyc;
VALOR_N.ErrorRule = SyntaxError + llaveC;
INSTRUCCION.ErrorRule = SyntaxError + pyc | SyntaxError + llaveC | SyntaxError + parC;
/*
* DEFINE_INCERTEZA.ErrorRule = SyntaxError + Eof;
* DEFINE_RUTA.ErrorRule = SyntaxError + Eof;
* INCLUYE.ErrorRule = SyntaxError + Eof;
* MOSTRAR.ErrorRule = SyntaxError + ";";
* BODY.ErrorRule = SyntaxError + ";" | SyntaxError + "}" | SyntaxError + ")";
*/
#endregion
RegisterOperators(100, Associativity.Right, pot);
RegisterOperators(95, Associativity.Left, por, div, mod);
RegisterOperators(90, Associativity.Left, mas, menos);
RegisterOperators(85, igual, diferente, menor, mayor, menor_igual, mayor_igual, comparacion);
RegisterOperators(80, not);
RegisterOperators(75, and);
RegisterOperators(70, xor);
RegisterOperators(65, or);
RegisterBracePair("{", "}");
RegisterBracePair("(", ")");
MarkPunctuation("{", "}", "(", ")", ";", ",", "Mostrar", "Define", "Incluye", "Principal", "=", "Retorno", "Si",
"Sino", "Selecciona", "Defecto", ":", "Para", "Mientras", "Hasta", "Number", "Void", "String", "Bool", "Detener"
, "Continuar", "Retorno", "++", "--", "DibujarEXP", "DibujarAST");
MarkTransient(LISTA_HEADER, ELEMENTO_BODY, TIPO_VARIABLE, TIPO_FUNCION, ASIG_VARIABLE, L_PARAM, PARAM_MOSTRAR
, INSTRUCCION, INSTRUCCION_DET, INSTRUCCION_CONT, TIPO_VALOR, EXP_RETORNO, OP, VALORES_LLAMADA_T);
//AddToNoReportGroup(Eos);
}
public ExcelFormulaGrammar() : base(false)
{
#region 1-Terminals
#region Symbols and operators
var comma = ToTerm(",");
var colon = ToTerm(":");
var semicolon = ToTerm(";");
var OpenParen = ToTerm("(");
var CloseParen = ToTerm(")");
var CloseSquareParen = ToTerm("]");
var OpenSquareParen = ToTerm("[");
var exclamationMark = ToTerm("!");
var CloseCurlyParen = ToTerm("}");
var OpenCurlyParen = ToTerm("{");
var mulop = ToTerm("*");
var plusop = ToTerm("+");
var divop = ToTerm("/");
var minop = ToTerm("-");
var concatop = ToTerm("&");
var expop = ToTerm("^");
// Intersect op is a single space, which cannot be parsed normally so we need an ImpliedSymbolTerminal
// Attention: ImpliedSymbolTerminal seems to break if you assign it a priority, and it's default priority is low
var intersectop = new ImpliedSymbolTerminal(GrammarNames.TokenIntersect);
var percentop = ToTerm("%");
var gtop = ToTerm(">");
var eqop = ToTerm("=");
var ltop = ToTerm("<");
var neqop = ToTerm("<>");
var gteop = ToTerm(">=");
var lteop = ToTerm("<=");
#endregion
#region Literals
var BoolToken = new RegexBasedTerminal(GrammarNames.TokenBool, "TRUE|FALSE");
BoolToken.Priority = TerminalPriority.Bool;
var NumberToken = new NumberLiteral(GrammarNames.TokenNumber, NumberOptions.None);
NumberToken.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var TextToken = new StringLiteral(GrammarNames.TokenText, "\"", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak);
var ErrorToken = new RegexBasedTerminal(GrammarNames.TokenError, "#NULL!|#DIV/0!|#VALUE!|#NAME\\?|#NUM!|#N/A");
var RefErrorToken = ToTerm("#REF!", GrammarNames.TokenRefError);
#endregion
#region Functions
var UDFToken = new RegexBasedTerminal(GrammarNames.TokenUDF, "(_xll\\.)?[a-zA-Z0-9_.]+\\(");
UDFToken.Priority = TerminalPriority.UDF;
var ExcelRefFunctionToken = new RegexBasedTerminal(GrammarNames.TokenExcelRefFunction, "(INDEX|OFFSET|INDIRECT)\\(");
ExcelRefFunctionToken.Priority = TerminalPriority.ExcelRefFunction;
var ExcelConditionalRefFunctionToken = new RegexBasedTerminal(GrammarNames.TokenExcelConditionalRefFunction, "(IF|CHOOSE)\\(");
ExcelConditionalRefFunctionToken.Priority = TerminalPriority.ExcelRefFunction;
var ExcelFunction = new RegexBasedTerminal(GrammarNames.ExcelFunction, "(" + String.Join("|", excelFunctionList) +")\\(");
ExcelFunction.Priority = TerminalPriority.ExcelFunction;
// Using this instead of Empty allows a more accurate trees
var EmptyArgumentToken = new ImpliedSymbolTerminal(GrammarNames.TokenEmptyArgument);
#endregion
#region References and names
var VRangeToken = new RegexBasedTerminal(GrammarNames.TokenVRange, "[$]?[A-Z]{1,4}:[$]?[A-Z]{1,4}");
var HRangeToken = new RegexBasedTerminal(GrammarNames.TokenHRange, "[$]?[1-9][0-9]*:[$]?[1-9][0-9]*");
const string CellTokenRegex = "[$]?[A-Z]{1,4}[$]?[1-9][0-9]*";
var CellToken = new RegexBasedTerminal(GrammarNames.TokenCell, CellTokenRegex);
CellToken.Priority = TerminalPriority.CellToken;
const string NamedRangeRegex = @"[A-Za-z\\_][\w\.]*";
var NamedRangeToken = new RegexBasedTerminal(GrammarNames.TokenNamedRange, NamedRangeRegex);
NamedRangeToken.Priority = TerminalPriority.NamedRange;
// To prevent e.g. "A1A1" being parsed as 2 celltokens
var NamedRangeCombinationToken = new RegexBasedTerminal(GrammarNames.TokenNamedRangeCombination, "(TRUE|FALSE|" + CellTokenRegex + ")" + NamedRangeRegex);
NamedRangeCombinationToken.Priority = TerminalPriority.NamedRangeCombination;
const string singleQuotedContent = @"\w !@#$%^&*()\-\+={}|:;<>,\./\?" + "\\\"";
const string sheetRegEx = @"(([\w\.]+)|('([" + singleQuotedContent + @"]|'')+'))!";
var SheetToken = new RegexBasedTerminal(GrammarNames.TokenSheet, sheetRegEx);
SheetToken.Priority = TerminalPriority.SheetToken;
const string firstSheetName = "[a-zA-Z0-9]+:";
var MultipleSheetsToken = new RegexBasedTerminal(GrammarNames.TokenMultipleSheets, firstSheetName + sheetRegEx);
MultipleSheetsToken.Priority = TerminalPriority.MultipleSheetsToken;
var FileToken = new RegexBasedTerminal(GrammarNames.TokenFileNameNumeric, "[0-9]+");
FileToken.Priority = TerminalPriority.FileToken;;
var QuotedFileSheetToken = new RegexBasedTerminal(GrammarNames.TokenFileSheetQuoted, @"'\[\d+\]([" + singleQuotedContent + @"]|'')+'!");
QuotedFileSheetToken.Priority = TerminalPriority.QuotedFileToken;
var ReservedNameToken = new RegexBasedTerminal(GrammarNames.TokenReservedName, @"_xlnm\.[a-zA-Z_]+");
ReservedNameToken.Priority = TerminalPriority.ReservedName;
var DDEToken = new RegexBasedTerminal(GrammarNames.TokenDDE, @"'([\[\]" + singleQuotedContent + @"]|'')+'");
#endregion
#region Punctuation
MarkPunctuation(exclamationMark);
MarkPunctuation(OpenParen, CloseParen);
MarkPunctuation(OpenSquareParen, CloseSquareParen);
MarkPunctuation(OpenCurlyParen, CloseCurlyParen);
#endregion
#endregion
#region 2-NonTerminals
// Most nonterminals are first defined here, so they can be used anywhere in the rules
// Otherwise you can only use nonterminals that have been defined previously
var Argument = new NonTerminal(GrammarNames.Argument);
var Arguments = new NonTerminal(GrammarNames.Arguments);
var ArrayColumns = new NonTerminal(GrammarNames.ArrayColumns);
var ArrayConstant = new NonTerminal(GrammarNames.ArrayConstant);
var ArrayFormula = new NonTerminal(GrammarNames.ArrayFormula);
var ArrayRows = new NonTerminal(GrammarNames.ArrayRows);
var Bool = new NonTerminal(GrammarNames.Bool);
var Cell = new NonTerminal(GrammarNames.Cell);
var Constant = new NonTerminal(GrammarNames.Constant);
var ConstantArray = new NonTerminal(GrammarNames.ConstantArray);
var DynamicDataExchange = new NonTerminal(GrammarNames.DynamicDataExchange);
var EmptyArgument = new NonTerminal(GrammarNames.EmptyArgument);
var Error = new NonTerminal(GrammarNames.Error);
var File = new NonTerminal(GrammarNames.File);
var Formula = new NonTerminal(GrammarNames.Formula);
var FormulaWithEq = new NonTerminal(GrammarNames.FormulaWithEq);
var FunctionCall = new NonTerminal(GrammarNames.FunctionCall);
var FunctionName = new NonTerminal(GrammarNames.FunctionName);
var HRange = new NonTerminal(GrammarNames.HorizontalRange);
var InfixOp = new NonTerminal(GrammarNames.TransientInfixOp);
var MultipleSheets = new NonTerminal(GrammarNames.MultipleSheets);
var NamedRange = new NonTerminal(GrammarNames.NamedRange);
var Number = new NonTerminal(GrammarNames.Number);
var PostfixOp = new NonTerminal(GrammarNames.TransientPostfixOp);
var Prefix = new NonTerminal(GrammarNames.Prefix);
var PrefixOp = new NonTerminal(GrammarNames.TransientPrefixOp);
var QuotedFileSheet = new NonTerminal(GrammarNames.QuotedFileSheet);
var Reference = new NonTerminal(GrammarNames.Reference);
//var ReferenceFunction = new NonTerminal(GrammarNames.ReferenceFunction);
var ReferenceItem = new NonTerminal(GrammarNames.TransientReferenceItem);
var ReferenceFunctionCall = new NonTerminal(GrammarNames.ReferenceFunctionCall);
var RefError = new NonTerminal(GrammarNames.RefError);
var RefFunctionName = new NonTerminal(GrammarNames.RefFunctionName);
var ReservedName = new NonTerminal(GrammarNames.ReservedName);
var Sheet = new NonTerminal(GrammarNames.Sheet);
var Start = new NonTerminal(GrammarNames.TransientStart);
var Text = new NonTerminal(GrammarNames.Text);
var UDFName = new NonTerminal(GrammarNames.UDFName);
var UDFunctionCall = new NonTerminal(GrammarNames.UDFunctionCall);
var Union = new NonTerminal(GrammarNames.Union);
var VRange = new NonTerminal(GrammarNames.VerticalRange);
#endregion
#region 3-Rules
#region Base rules
Root = Start;
Start.Rule = FormulaWithEq
| Formula
| ArrayFormula
;
MarkTransient(Start);
ArrayFormula.Rule = OpenCurlyParen + eqop + Formula + CloseCurlyParen;
FormulaWithEq.Rule = eqop + Formula;
Formula.Rule =
Reference
| Constant
| FunctionCall
| ConstantArray
| OpenParen + Formula + CloseParen
| ReservedName
;
//MarkTransient(Formula);
ReservedName.Rule = ReservedNameToken;
Constant.Rule = Number
| Text
| Bool
| Error
;
Text.Rule = TextToken;
Number.Rule = NumberToken;
Bool.Rule = BoolToken;
Error.Rule = ErrorToken;
RefError.Rule = RefErrorToken;
#endregion
#region Functions
FunctionCall.Rule =
FunctionName + Arguments + CloseParen
| PrefixOp + Formula
| Formula + PostfixOp
| Formula + InfixOp + Formula
;
FunctionName.Rule = ExcelFunction;
Arguments.Rule = MakeStarRule(Arguments, comma, Argument);
//Arguments.Rule = Argument | Argument + comma + Arguments;
EmptyArgument.Rule = EmptyArgumentToken;
Argument.Rule = Formula | EmptyArgument;
//MarkTransient(Argument);
PrefixOp.Rule =
ImplyPrecedenceHere(Precedence.UnaryPreFix) + plusop
| ImplyPrecedenceHere(Precedence.UnaryPreFix) + minop;
MarkTransient(PrefixOp);
InfixOp.Rule =
expop
| mulop
| divop
| plusop
| minop
| concatop
| gtop
| eqop
| ltop
| neqop
| gteop
| lteop;
MarkTransient(InfixOp);
//PostfixOp.Rule = ImplyPrecedenceHere(Precedence.UnaryPostFix) + percentop;
// ImplyPrecedenceHere doesn't seem to work for this rule, but postfix has such a high priority shift will nearly always be the correct action
PostfixOp.Rule = PreferShiftHere() + percentop;
MarkTransient(PostfixOp);
#endregion
#region References
Reference.Rule = ReferenceItem
| ReferenceFunctionCall
| OpenParen + Reference + PreferShiftHere() + CloseParen
| Prefix + ReferenceItem
| DynamicDataExchange
;
ReferenceFunctionCall.Rule =
Reference + colon + Reference
| Reference + intersectop + Reference
| OpenParen + Union + CloseParen
| RefFunctionName + Arguments + CloseParen
//| ConditionalRefFunctionName + Arguments + CloseParen
;
RefFunctionName.Rule = ExcelRefFunctionToken | ExcelConditionalRefFunctionToken;
Union.Rule = MakePlusRule(Union, comma, Reference);
ReferenceItem.Rule =
Cell
| NamedRange
| VRange
| HRange
| RefError
| UDFunctionCall
;
MarkTransient(ReferenceItem);
UDFunctionCall.Rule = UDFName + Arguments + CloseParen;
UDFName.Rule = UDFToken;
VRange.Rule = VRangeToken;
HRange.Rule = HRangeToken;
//ConditionalRefFunctionName.Rule = ExcelConditionalRefFunctionToken;
QuotedFileSheet.Rule = QuotedFileSheetToken;
Sheet.Rule = SheetToken;
MultipleSheets.Rule = MultipleSheetsToken;
Cell.Rule = CellToken;
File.Rule = OpenSquareParen + FileToken + CloseSquareParen;
DynamicDataExchange.Rule = File + exclamationMark + DDEToken;
NamedRange.Rule = NamedRangeToken | NamedRangeCombinationToken;
Prefix.Rule =
Sheet
| File + Sheet
| File + exclamationMark
| QuotedFileSheet
| MultipleSheets
| File + MultipleSheets;
#endregion
#region Arrays
ConstantArray.Rule = OpenCurlyParen + ArrayColumns + CloseCurlyParen;
ArrayColumns.Rule = MakePlusRule(ArrayColumns, semicolon, ArrayRows);
ArrayRows.Rule = MakePlusRule(ArrayRows, comma, ArrayConstant);
ArrayConstant.Rule = Constant | PrefixOp + Number | RefError;
#endregion
#endregion
#region 5-Operator Precedence
// Some of these operators are neutral associative instead of left associative,
// but this ensures a consistent parse tree. As a lot of code is "hardcoded" onto the specific
// structure of the parse tree, we like consistency.
RegisterOperators(Precedence.Comparison, Associativity.Left, eqop, ltop, gtop, lteop, gteop, neqop);
RegisterOperators(Precedence.Concatenation, Associativity.Left, concatop);
RegisterOperators(Precedence.Addition, Associativity.Left, plusop, minop);
RegisterOperators(Precedence.Multiplication, Associativity.Left, mulop, divop);
RegisterOperators(Precedence.Exponentiation, Associativity.Left, expop);
RegisterOperators(Precedence.UnaryPostFix, Associativity.Left, percentop);
RegisterOperators(Precedence.Union, Associativity.Left, comma);
RegisterOperators(Precedence.Intersection, Associativity.Left, intersectop);
RegisterOperators(Precedence.Range, Associativity.Left, colon);
//RegisterOperators(Precedence.ParameterSeparator, comma);
#endregion
}
public void Visit(StringLiteral node)
{
return;
}
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 PyUsacGrammar() : base(false)
{
#region Properties and Flags
//Case sensitive = false. Setted by constructor
LanguageFlags = LanguageFlags.NewLineBeforeEOF;//No deberia de ser necesario, pero no estoy 100% seguron :(
#endregion
#region Terminals
//Non grammar
var LINE_COMMENT = new CommentTerminal("LINE_COMMENT", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(LINE_COMMENT);
var BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "/*", "*/");
NonGrammarTerminals.Add(BLOCK_COMMENT);
//Punctuation
KeyTerm O_PAREN = ToTerm("(", "O_PAREN"),
C_PAREN = ToTerm(")", "C_PAREN"),
O_BOX = ToTerm("[", "O_BOX"),
C_BOX = ToTerm("]", "C_BOX"),
O_CURLY = ToTerm("{", "O_CURLY"),
C_CURLY = ToTerm("}", "C_CURLY"),
SEMICOLON = ToTerm(";", "SEMICOLON"),
COLON = ToTerm(":", "COLON"),
EQ = ToTerm("=", "EQ"),
VAR = ToTerm("var", "VAR"),
COMMA = ToTerm(",", "COMMA"),
DOT = ToTerm(".", "DOT"),
FUNCTION = ToTerm("function", "FUNCTION"),
VOID = ToTerm("void", "VOID"),
CLASS = ToTerm("class", "CLASS"),
NEW = ToTerm("new", "NEW");
MarkPunctuation(O_PAREN, C_PAREN, O_BOX, C_BOX, O_CURLY, C_CURLY, SEMICOLON, COLON, EQ, VAR, COMMA, DOT, FUNCTION, VOID, CLASS, NEW);
//Keywords
KeyTerm LOG = ToTerm("log", "LOG"),
ALERT = ToTerm("alert", "ALERT"),
GRAPH = ToTerm("graph", "GRAPH"),
IF = ToTerm("if", "IF"),
SWITCH = ToTerm("switch", "SWITCH"),
CASE = ToTerm("case", "CASE"),
DEFAULT = ToTerm("default", "DEFAULT"),
ELSE = ToTerm("else", "ELSE"),
FOR = ToTerm("for", "FOR"),
DO = ToTerm("do", "DO"),
WHILE = ToTerm("while", "WHILE"),
RETURN = ToTerm("return", "RETURN"),
BREAK = ToTerm("break", "BREAK"),
CONTINUE = ToTerm("continue", "CONTINUE"),
IMPORTAR = ToTerm("importar", "IMPORTAR");//IMPORT NO ES KEYWORD PORQUE NINGUNA FUNCION NATIVA LO ES
//Operators
//Binary
KeyTerm PLUS = ToTerm("+"),
MINUS = ToTerm("-"),//Could be unary
MULT = ToTerm("*"),
DIV = ToTerm("/"),
POW = ToTerm("pow"),
GREATER = ToTerm(">"),
LESS = ToTerm("<"),
EQ_EQ = ToTerm("=="),
NOT_EQ = ToTerm("<>"),
GREATER_EQ = ToTerm(">="),
LESS_EQ = ToTerm("<="),
AND = ToTerm("&&"),
OR = ToTerm("||"),
XOR = ToTerm("^");
//Unary
KeyTerm NOT = ToTerm("!");
KeyTerm PLUS_PLUS = ToTerm("++");
KeyTerm MINUS_MINUS = ToTerm("--");
//Constants
//Literals
var NUMBER_LITERAL = new NumberLiteral("NUMBER_LITERAL", NumberOptions.None, typeof(NumberLiteralNode));
var STRING_LITERAL = new StringLiteral("STRING_LITERAL", "\"", StringOptions.AllowsAllEscapes, typeof(StringLiteralNode));
var CHAR_LITERAL = new StringLiteral("CHAR_LITERAL", "'", StringOptions.IsChar, typeof(CharLiteralNode));
//CHAPUZ SE CAMBIARON VARIAS CONFIGURACIONES PARA QUE LOS KEYTERM TRUE, FALSE Y NULL TENGA ASTNODE
KeyTerm TRUE = ToTerm("true", "TRUE"),
FALSE = ToTerm("false", "FALSE");
TRUE.AstConfig.NodeType = typeof(BooleanLiteralNode);
TRUE.Flags = TermFlags.None;
FALSE.AstConfig.NodeType = typeof(BooleanLiteralNode);
FALSE.Flags = TermFlags.None;
KeyTerm NULL = ToTerm("null", "NULL");
NULL.AstConfig.NodeType = typeof(NullLiteralNode);
NULL.Flags = TermFlags.None;
//Identifiers
IdentifierTerminal IDENTIFIER = new IdentifierTerminal("IDENTIFIER");
IDENTIFIER.AstConfig.NodeType = typeof(IdentifierNode);
RegexBasedTerminal MAIN = new RegexBasedTerminal("MAIN", "main");
MAIN.AstConfig.NodeType = typeof(IdentifierNode);
#endregion
#region Non terminals
var program = new NonTerminal("program", typeof(ProgramNode));
var stmtList = new NonTerminal("stmtList", typeof(TransientNode)); //Ast Transient
//definitions
//Chapuz medio alto: se le agrego un # a los bnf defintion para identificarlos al hacer el arbol Ast de program
var import = new NonTerminal("$import", typeof(ImportNode)); //Chapuz medio alto: se le agrego un $ a los bnf import para identificarlos al hacer el arbol Ast de program
var definition = new NonTerminal("#definition"); //Transient
var method = new NonTerminal("#method", typeof(MethodNode));
var function = new NonTerminal("#function", typeof(FunctionNode));
var class_definition = new NonTerminal("#class_definition", typeof(ClassNode));
var class_bodyList = new NonTerminal("#class_bodyList", typeof(TransientNode)); //Ast transient
var class_body = new NonTerminal("#class_body"); //transient
var definition_stmt_or_importList = new NonTerminal("definition_stmt_or_importList", typeof(TransientNode)); //Transient
var definition_stmt_or_import = new NonTerminal("definition_stmt_or_import"); //Transient
var paramList = new NonTerminal("paramList", typeof(TransientNode));
var param = new NonTerminal("param", typeof(Declaration));
var argumentList = new NonTerminal("paramList", typeof(TransientNode)); //Lista de expr separadas por coma
//stmts
var stmt = new NonTerminal("stmt"); //Transient
var decl = new NonTerminal("decl", typeof(Declaration));
var identierList = new NonTerminal("identfierList", typeof(TransientNode));
var assign = new NonTerminal("assign", typeof(Assignment));
//nativas
var log = new NonTerminal("log", typeof(LogNode));
var alert = new NonTerminal("alert", typeof(Alert));
var graph = new NonTerminal("graph", typeof(Graph));
//control
var block = new NonTerminal("block", typeof(Block));
var if_stmt = new NonTerminal("if_stmt", typeof(IfNode));
var if_else_stmt = new NonTerminal("if_else_stmt", typeof(IfNode));
var else_content = new NonTerminal("else_content"); //transient
var switch_stmt = new NonTerminal("switch_stmt", typeof(SwitchNode));
var switch_element = new NonTerminal("switch_element"); //Transient
var switch_elementList = new NonTerminal("switch_elementList", typeof(TransientNode)); //AstTransient
var switch_label = new NonTerminal("switch_label", typeof(SwitchLabelNode));
var for_stmt = new NonTerminal("for_stmt", typeof(ForNode));
var while_stmt = new NonTerminal("while_stmt", typeof(WhileNode));
var do_while_stmt = new NonTerminal("do_while_stmt", typeof(DoWhileNode));
//jump
var jumper_stmt = new NonTerminal("jumper_stmt");//transient
var break_stmt = new NonTerminal("break_stmt", typeof(BreakNode));
var continue_stmt = new NonTerminal("break_stmt", typeof(ContinueNode));
var return_stmt = new NonTerminal("break_stmt", typeof(ReturnNode));
//Member access
var member_access = new NonTerminal("member_access", typeof(MemberAccess));
var member_access_segment = new NonTerminal("member_access_segment"); //Transient
var member_access_optional_segmentList = new NonTerminal("member_access_optional_segmentList", typeof(TransientNode)); //Ast Transient
var member_access_optional_segment = new NonTerminal("member_access_optional_segment"); //Transient
var identifier_access = new NonTerminal("identifier_access", typeof(IdentifierAccess));
var index_access = new NonTerminal("index_access", typeof(IndexAccess));
var expr_access = new NonTerminal("expr_access", typeof(ExprAccess));
var index_accessList = new NonTerminal("index_accessList", typeof(TransientNode));//Ast Transient
var function_access = new NonTerminal("function_access", typeof(ProcedureAccess));
var object_creation_access = new NonTerminal("object_creation_access", typeof(ObjectCreationAccess));
//Expressions
var expr = new NonTerminal("expr"); //Transient
var parentesis_expr = new NonTerminal("parentesis_expr"); //Transient
var atomic_expr = new NonTerminal("atomic_expr", typeof(AtomicExpr));
var binary_expr = new NonTerminal("binaray_expr", typeof(BinaryExpr));
var unary_expr = new NonTerminal("unary_expr", typeof(UnaryExpr));
var array_expr = new NonTerminal("array_expr", typeof(ArrayExpr));
var exprList = new NonTerminal("exprList", typeof(TransientNode)); //Ast Transient
var inc_dec_expr = new NonTerminal("inc_dec_expr", typeof(IncDecExpr));
var unary_op = new NonTerminal("unary_op"); //Transient, the precendece doesnt work other wise
var binary_op = new NonTerminal("binary_op"); //Transient, the precendece doesnt work other wise
var inc_dec_op = new NonTerminal("inc_dec_op"); //Transient, the precendece doesnt work other wise
#endregion
#region BNF Rules
Root = program;
program.Rule = definition_stmt_or_importList;
//Definitions
definition_stmt_or_importList.Rule = MakeStarRule(definition_stmt_or_importList, definition_stmt_or_import);
definition_stmt_or_import.Rule = stmt
| definition
| import;
definition.Rule = method
| function
| class_definition;
import.Rule = IMPORTAR + O_PAREN + STRING_LITERAL + C_PAREN + SEMICOLON;
method.Rule = FUNCTION + VOID + IDENTIFIER + O_PAREN + paramList + C_PAREN + O_CURLY + stmtList + C_CURLY
| MAIN + O_PAREN + paramList + C_PAREN + O_CURLY + stmtList + C_CURLY;//Chapuz alto para que acepte la sintaxis del metodo main
function.Rule = FUNCTION + IDENTIFIER + O_PAREN + paramList + C_PAREN + O_CURLY + stmtList + C_CURLY;
class_definition.Rule = CLASS + IDENTIFIER + O_CURLY + class_bodyList + C_CURLY;
class_bodyList.Rule = MakeStarRule(class_bodyList, class_body);
class_body.Rule = method
| function
| stmt;
paramList.Rule = MakeStarRule(paramList, COMMA, param);
param.Rule = VAR + IDENTIFIER;
argumentList.Rule = MakeStarRule(argumentList, COMMA, expr);
//stmts
stmtList.Rule = MakeStarRule(stmtList, stmt);
stmt.Rule = decl + SEMICOLON
| assign + SEMICOLON
| member_access + SEMICOLON
| inc_dec_expr + SEMICOLON
| log + SEMICOLON
| alert + SEMICOLON
| graph + SEMICOLON
| if_stmt
| if_else_stmt
| switch_stmt
| while_stmt
| do_while_stmt
| for_stmt
| jumper_stmt;
//control stmts:
block.Rule = O_CURLY + stmtList + C_CURLY;
if_stmt.Rule = IF + O_PAREN + expr + C_PAREN + block;
if_else_stmt.Rule = IF + O_PAREN + expr + C_PAREN + block + ELSE + else_content;
else_content.Rule = block
| if_stmt
| if_else_stmt;
switch_stmt.Rule = SWITCH + O_PAREN + expr + C_PAREN + O_CURLY + switch_elementList + C_CURLY;
switch_elementList.Rule = MakeStarRule(switch_elementList, switch_element);
switch_element.Rule = switch_label |
stmt;
switch_label.Rule = CASE + expr + COLON |
DEFAULT + COLON;
while_stmt.Rule = WHILE + O_PAREN + expr + C_PAREN + block;
do_while_stmt.Rule = DO + block + WHILE + O_PAREN + expr + C_PAREN + SEMICOLON;
for_stmt.Rule = FOR + O_PAREN + decl + SEMICOLON + expr + SEMICOLON + inc_dec_expr + C_PAREN + block
| FOR + O_PAREN + assign + SEMICOLON + expr + SEMICOLON + inc_dec_expr + C_PAREN + block;//Chapuz medio para que puedan venir assinganciones tambien
//jumpers:
jumper_stmt.Rule = return_stmt
| break_stmt
| continue_stmt;
return_stmt.Rule = RETURN + SEMICOLON
| RETURN + expr + SEMICOLON;
break_stmt.Rule = BREAK + SEMICOLON;
continue_stmt.Rule = CONTINUE + SEMICOLON;
//mem
decl.Rule = VAR + identierList + index_accessList + EQ + expr
| VAR + identierList + index_accessList;
identierList.Rule = MakePlusRule(identierList, COMMA, IDENTIFIER);
index_accessList.Rule = MakeStarRule(index_accessList, index_access);
assign.Rule = member_access + EQ + expr;
log.Rule = LOG + O_PAREN + expr + C_PAREN;
alert.Rule = ALERT + O_PAREN + expr + C_PAREN;
graph.Rule = GRAPH + O_PAREN + expr + COMMA + expr + C_PAREN;
expr.Rule = atomic_expr
| binary_expr
| unary_expr;
parentesis_expr.Rule = O_PAREN + expr + C_PAREN;
atomic_expr.Rule = NUMBER_LITERAL
| STRING_LITERAL
| CHAR_LITERAL
| TRUE
| FALSE
| NULL
| array_expr
| member_access
| inc_dec_expr;
binary_expr.Rule = expr + binary_op + expr;
unary_expr.Rule = unary_op + expr + ReduceHere();
array_expr.Rule = O_CURLY + exprList + C_CURLY;
exprList.Rule = MakeStarRule(exprList, COMMA, expr);
inc_dec_expr.Rule = member_access + PreferShiftHere() + inc_dec_op;
member_access.Rule = member_access_segment + member_access_optional_segmentList;
member_access_segment.Rule = identifier_access
| function_access
| object_creation_access
| expr_access;
member_access_optional_segmentList.Rule = MakeStarRule(member_access_optional_segmentList, member_access_optional_segment);
member_access_optional_segment.Rule = DOT + identifier_access
| DOT + function_access
| index_access;
identifier_access.Rule = IDENTIFIER;
object_creation_access.Rule = NEW + IDENTIFIER + O_PAREN + /*argumentList +*/ C_PAREN;
function_access.Rule = IDENTIFIER + O_PAREN + argumentList + C_PAREN;
index_access.Rule = O_BOX + expr + C_BOX;
expr_access.Rule = O_PAREN + expr + C_PAREN;
binary_op.Rule = PLUS | MINUS | MULT | DIV | POW | GREATER | LESS | EQ_EQ | NOT_EQ | GREATER_EQ | LESS_EQ | AND | OR | XOR;
unary_op.Rule = NOT | MINUS;
inc_dec_op.Rule = PLUS_PLUS | MINUS_MINUS;
#endregion
#region Precedence
RegisterOperators(5, OR);
RegisterOperators(10, AND);
RegisterOperators(20, Associativity.Neutral, EQ_EQ, LESS, LESS_EQ, GREATER, GREATER_EQ, NOT_EQ);
RegisterOperators(30, PLUS, MINUS);
RegisterOperators(40, MULT, DIV);
RegisterOperators(50, Associativity.Right, POW);
RegisterOperators(60, NOT);
#endregion
#region Transients
MarkTransient(stmt, expr, parentesis_expr, binary_op, unary_op, inc_dec_op, member_access_segment, member_access_optional_segment,
jumper_stmt, else_content, switch_element, definition, param, definition_stmt_or_import, class_body);
#endregion
}
override public void VisitStringLiteral(StringLiteral x)
{
_serializer.Serialize(typeof(StringLiteral).Name, SerializeSpan(x.Span), new NodeObj("Value", x.Value) /*, new NodeObj("Format", x.Format == Literal.LiteralFormat.SingleQuotes ? "SingleQuotes" : "DoubleQuotes")*/);
}
public EqlGrammar() : base(false)
{
//terminals
NonGrammarTerminals.Add(new CommentTerminal("COMMENT", "/*", "*/"));
NonGrammarTerminals.Add(new CommentTerminal("LINE_COMMENT", "--", "\n", "\r\n"));
var NUMBER = new NumberLiteral("NUMBER");
var STRING = new StringLiteral("STRING", "'", StringOptions.AllowsDoubledQuote);
var ARGUMENT = new IdentifierTerminal("ARGUMENT");
var IDENTIFIER = new IdentifierTerminal("IDENTIFIER");
var COMMA = ToTerm(",");
var DOT = ToTerm(".");
var NULL = ToTerm("NULL");
var SELECT = ToTerm("SELECT");
var FROM = ToTerm("FROM");
var WHERE = ToTerm("WHERE");
var ORDER = ToTerm("ORDER");
var BY = ToTerm("BY");
var PAGE = ToTerm("PAGE");
var PAGESIZE = ToTerm("PAGESIZE");
var ASC = ToTerm("ASC");
var DESC = ToTerm("DESC");
//non-terminals
var identifier = new NonTerminal("identifier");
var expressionIdentifier = new NonTerminal("expression_identifier");
var argument = new NonTerminal("argument");
var statement = new NonTerminal("statement");
var selectStmt = new NonTerminal("select_statement");
var identifierList = new NonTerminal("identifier_list");
var orderList = new NonTerminal("order_list");
var orderMember = new NonTerminal("order_member");
var orderDirOpt = new NonTerminal("order_direction_optional");
var expression = new NonTerminal("expression");
var exprList = new NonTerminal("expression_list");
var selList = new NonTerminal("select_list");
var countClause = new NonTerminal("count_clause");
var fromClause = new NonTerminal("from_clause");
var orderClauseOpt = new NonTerminal("order_clause_optional");
var columnItemList = new NonTerminal("column_item_list");
var columnItem = new NonTerminal("column_item");
var columnSource = new NonTerminal("column_source");
var columnRelation = new NonTerminal("column_relation");
var columnRelationList = new NonTerminal("column_relation_list");
var whereClauseOpt = new NonTerminal("where_clause_optional");
var pageClauseOpt = new NonTerminal("page_clause_optional");
var pageSizeClauseOpt = new NonTerminal("pagesize_clause_optional");
var term = new NonTerminal("term");
var nullTerm = new NonTerminal("null");
var tuple = new NonTerminal("tuple");
var binExpr = new NonTerminal("binary_expression");
var binOp = new NonTerminal("binary_operator");
var stmtRoot = new NonTerminal("root");
//BNF root
this.Root = stmtRoot;
stmtRoot.Rule = selectStmt;
//identifier
identifier.Rule = IDENTIFIER; //MakePlusRule(identifier, DOT, IDENTIFIER);
statement.Rule = selectStmt;
identifierList.Rule = MakePlusRule(identifierList, COMMA, identifier);
//argument
argument.Rule = ToTerm("@") + ARGUMENT;
//order
orderList.Rule = MakePlusRule(orderList, COMMA, orderMember);
orderMember.Rule = identifier + orderDirOpt | argument + orderDirOpt;
orderDirOpt.Rule = Empty | ASC | DESC | argument;
//select statement
selectStmt.Rule = SELECT + columnItemList + fromClause + whereClauseOpt + orderClauseOpt + pageClauseOpt + pageSizeClauseOpt;
selList.Rule = columnItemList;
columnItemList.Rule = MakePlusRule(columnItemList, COMMA, columnItem);
columnItem.Rule = columnSource;
columnSource.Rule = identifier | "*" | columnRelationList + DOT + identifier | columnRelationList + DOT + "*";
columnRelation.Rule = "$" + identifier | "$$" + identifier;
columnRelationList.Rule = MakePlusRule(columnRelationList, DOT, columnRelation);
fromClause.Rule = FROM + identifier;
whereClauseOpt.Rule = Empty | WHERE + expression;
orderClauseOpt.Rule = Empty | ORDER + BY + orderList;
pageClauseOpt.Rule = Empty | PAGE + NUMBER | PAGE + argument;
pageSizeClauseOpt.Rule = Empty | PAGESIZE + NUMBER | PAGESIZE + argument;
//expression
exprList.Rule = MakePlusRule(exprList, COMMA, expression);
expression.Rule = term | binExpr;
term.Rule = expressionIdentifier | argument | tuple | NUMBER | STRING | NULL;
expressionIdentifier.Rule = identifier | columnRelation + DOT + identifier;
tuple.Rule = "(" + exprList + ")";
binExpr.Rule = expression + binOp + expression;
binOp.Rule = ToTerm("=") | ">" | "<" | ">=" | "<=" | "<>" | "!=" | //compare operators
"AND" | "OR" | //logical operators
"CONTAINS" | "STARTSWITH" | // text operators
"~" | "~*" | "!~" | "!~*" | //regex operators
"@@"; // fts operator
//operators precedence
RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "CONTAINS", "STARTSWITH", "~", "~*", "!~", "!~*", "@@");
RegisterOperators(5, "AND");
RegisterOperators(4, "OR");
MarkPunctuation(",", "(", ")");
base.MarkTransient(statement, expression, tuple);
binOp.SetFlag(TermFlags.InheritPrecedence);
}
public virtual TResult Visit(StringLiteral literal, TEnvironment environment)
{
return(default(TResult));
}
public QuasarGrammar()
{
var Comment = new CommentTerminal("BLOCK_COMMENT", "/*", "*/");
var LineComment = new CommentTerminal("LINE_COMMENT", "//", "\n", "\r\n");
NonGrammarTerminals.Add(Comment);
NonGrammarTerminals.Add(LineComment);
//
var IntegerLiteral = new NumberLiteral(IntLiteral, NumberOptions.IntOnly | NumberOptions.AllowSign);
var StringLiteral = new StringLiteral(QuasarGrammar.StringLiteral, "'", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);
var UseLiteral = new StringLiteral("USE_LITERAL", "'", StringOptions.None);
var EscapableStringLiteral = new StringLiteral(QuasarGrammar.EscapableStringLiteral, "\"");
var BoolLiteral = new RegexBasedTerminal(QuasarGrammar.BoolLiteral, "true|false");
var DecimalLiteral = new RegexBasedTerminal(QuasarGrammar.DecimalLiteral, "[+-]?([0-9]+M|[0-9]+\\.[0-9]+M)");
var FloatLiteral = new RegexBasedTerminal(QuasarGrammar.FloatLiteral, "[+-]?([0-9]+F|[0-9]+\\.[0-9]+F)");
var DoubleLiteral = new RegexBasedTerminal(QuasarGrammar.DoubleLiteral, "[-+]?([0-9]\\.[0-9]+)");
var Identifier = new IdentifierTerminal(QuasarGrammar.Identifier, IdOptions.IsNotKeyword);
//
var Expression = new NonTerminal(QuasarGrammar.Expression);
//
var BinaryOperator = new NonTerminal(BinaryOp);
var BinaryOperation = new NonTerminal(QuasarGrammar.BinaryOperation);
//
var FunctionCall = new NonTerminal(QuasarGrammar.FunctionCall);
var FunctionCallArgument = new NonTerminal(FunctionCallArgs);
//
var DictionaryInitialize = new NonTerminal(DictInitialize);
var DictionaryMember = new NonTerminal(DictMember);
var DictionaryMemberList = new NonTerminal(DictMemberList);
//
//
var StatementBlock = new NonTerminal(QuasarGrammar.StatementBlock);
var Statement = new NonTerminal(QuasarGrammar.Statement);
var ImportStatement = new NonTerminal(ImportStmt);
var FuncDefineStatement = new NonTerminal(FuncDefine);
var FuncDefineArgList = new NonTerminal(FuncDefineArgumentList);
var AssignStatement = new NonTerminal(QuasarGrammar.AssignStatement);
var IfStatement = new NonTerminal(IfStmt);
var ReturnStatement = new NonTerminal(QuasarGrammar.ReturnStatement);
var BreakStatement = new NonTerminal(BreakStmt);
var ContinueStatement = new NonTerminal(ContinueStmt);
var WhileStatement = new NonTerminal(QuasarGrammar.WhileStatement);
var ForStatement = new NonTerminal(QuasarGrammar.ForStatement);
var ForeachStatement = new NonTerminal(QuasarGrammar.ForeachStatement);
//
var ClassStatement = new NonTerminal(QuasarGrammar.ClassStatement);
var CompilationUnit = new NonTerminal(QuasarGrammar.CompilationUnit);
// EXPRESSIONS
Expression.Rule = IntegerLiteral |
StringLiteral |
EscapableStringLiteral |
BoolLiteral |
DecimalLiteral |
FloatLiteral |
DoubleLiteral |
Identifier |
BinaryOperation |
FunctionCall |
DictionaryInitialize |
"(" + Expression + ")"
;
BinaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | ">" | "<" | ">=" | "<=" |
"%" | "==" | "!=" | ">>" | "<<" | "&" | "|" | "and" | "or";
BinaryOperation.Rule = Expression + BinaryOperator + Expression;
FunctionCallArgument.Rule = Expression | Expression + "," + FunctionCallArgument;
FunctionCall.Rule = Identifier + "(" + ")" | Identifier + "(" + FunctionCallArgument + ")";
//
DictionaryMember.Rule = Expression + ":" + Expression;
DictionaryMemberList.Rule = DictionaryMember | DictionaryMember + "," + DictionaryMemberList;
DictionaryInitialize.Rule = "{" + DictionaryMemberList + "}";
//
// STATEMENTS
Statement.Rule = ImportStatement + ";" |
FuncDefineStatement |
AssignStatement + ";" |
IfStatement |
BreakStatement + ";" |
ContinueStatement + ";" |
ReturnStatement + ";" |
WhileStatement |
ForStatement |
ForeachStatement |
ClassStatement;
BreakStatement.Rule = ToTerm("break");
ContinueStatement.Rule = ToTerm("continue");
ReturnStatement.Rule = ToTerm("return") | "return" + Expression;
// while(a < 10)
WhileStatement.Rule = ToTerm("while") + "(" + Expression + ")" + "{" + StatementBlock + "}";
// for(i; i < 10; i=i+1)
ForStatement.Rule = ToTerm("for") + "(" + Identifier + ";" + Expression + ";" + AssignStatement + ")" + "{" + StatementBlock + "}";
// foreach(i in collection)
ForeachStatement.Rule = ToTerm("foreach") + "(" + Identifier + "in" + Expression + ")" + "{" + StatementBlock + "}";
AssignStatement.Rule = "var" + Identifier + "=" + Expression |
Identifier + "=" + Expression |
Expression + "=" + Expression;
StatementBlock.Rule = Statement | Statement + StatementBlock | Empty;
ImportStatement.Rule = "use" + UseLiteral;
FuncDefineArgList.Rule = Identifier | Identifier + "," + FuncDefineArgList;
FuncDefineStatement.Rule = "func" + Identifier + "(" + ")" + "{" + StatementBlock + "}" |
"func" + Identifier + "(" + FuncDefineArgList + ")" + "{" + StatementBlock + "}";
//
IfStatement.Rule = ToTerm("if") + "(" + Expression + ")" + Statement |
ToTerm("if") + "(" + Expression + ")" + "{" + StatementBlock + "}" |
IfStatement + "else" + "{" + StatementBlock + "}" |
IfStatement + "else" + IfStatement;
ClassStatement.Rule = "class" + Identifier + "{" + StatementBlock + "}";
CompilationUnit.Rule = StatementBlock;
Root = CompilationUnit;
MarkReservedWords("return", "new", "break", "continue", "use", "if", "else", "this", "class", "dto", "null", "while", "in");
RegisterOperators(6, Associativity.Left, ".");
RegisterOperators(5, Associativity.Left, "*", "/", "%");
RegisterOperators(4, Associativity.Left, "+", "-", "&", "|", ">>", "<<");
RegisterOperators(3, Associativity.Left, ">", "<", ">=", "<=", "<>", "==");
RegisterOperators(2, Associativity.Left, "and");
RegisterOperators(1, Associativity.Left, "or");
}
public ValueType Visit(StringLiteral literal, TypeEnvironment environment)
{
return(new StringValueType());
}
public Gramatica_LUP() : base(caseSensitive: false)
{
#region Expresiones_Regulares
StringLiteral CADENA = new StringLiteral("Cadena", "\"");
NumberLiteral NUMERO = new NumberLiteral("Numero");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("Identificador");
CommentTerminal CONT_DATA_IMPORT = new CommentTerminal("CONT_DATA_IMPORT", "[+DATA]", "[-DATA]");
#endregion
#region Terminales
var RLOGIN = ToTerm("LOGIN");
var RSUCCESS = ToTerm("SUCCESS");
var RFAIL = ToTerm("FAIL");
var RLOGOUT = ToTerm("LOGOUT");
var RUSER = ToTerm("USER");
var RPASS = ToTerm("PASS");
var RQUERY = ToTerm("QUERY");
var RDATA = ToTerm("DATA");
var RMESSAGE = ToTerm("MESSAGE");
var RERROR = ToTerm("ERROR");
var RLINE = ToTerm("LINE");
var RCOLUMN = ToTerm("COLUMN");
var RTYPE = ToTerm("TYPE");
var RDESC = ToTerm("DESC");
var RSTRUC = ToTerm("STRUC");
var RDATABASES = ToTerm("DATABASES");
var RDATABASE = ToTerm("DATABASE");
var RNAME = ToTerm("NAME");
var RTABLES = ToTerm("TABLES");
var RTABLE = ToTerm("TABLE");
var RCOLUMNS = ToTerm("COLUMNS");
var RTYPES = ToTerm("TYPES");
var RATTRIBUTES = ToTerm("ATTRIBUTES");
var RPROCEDURES = ToTerm("PROCEDURES");
var CORIZQ = ToTerm("[");
var CORDER = ToTerm("]");
var MAS = ToTerm("+");
var MENOS = ToTerm("-");
#endregion
#region No_Terminales
NonTerminal
S = new NonTerminal("S"),
Instrucciones = new NonTerminal("Instrucciones"),
Instruccion = new NonTerminal("Instruccion"),
LOGIN = new NonTerminal("LOGIN"),
LOGOUT = new NonTerminal("LOGOUT"),
QUERY = new NonTerminal("QUERY"),
DATA = new NonTerminal("DATA"),
MESSAGE = new NonTerminal("MESSAGE"),
ERROR = new NonTerminal("ERROR"),
STRUC = new NonTerminal("STRUC"),
DATABASES = new NonTerminal("DATABASES"),
USER = new NonTerminal("USER"),
PASSWORD = new NonTerminal("PASSWORD"),
VALOR = new NonTerminal("VALOR"),
RESPUESTA = new NonTerminal("RESPUESTA"),
LINEA = new NonTerminal("LINEA"),
COLUMNA = new NonTerminal("COLUMNA"),
TIPO = new NonTerminal("TIPO"),
DESCRIPCION = new NonTerminal("DESCRIPCION"),
DATABASES2 = new NonTerminal("DATABASES2"),
DATABASE = new NonTerminal("DATABASE"),
NAME = new NonTerminal("NAME"),
TABLES = new NonTerminal("TABLES"),
TABLES2 = new NonTerminal("TABLES2"),
TABLE = new NonTerminal("TABLE"),
COLUMNS = new NonTerminal("COLUMNS"),
COLUMN = new NonTerminal("COLUMN"),
TYPES = new NonTerminal("TYPES"),
TYPES2 = new NonTerminal("TYPES2"),
TYPE = new NonTerminal("TYPE"),
ATTRIBUTES = new NonTerminal("ATTRIBUTES"),
ATTRIBUTE = new NonTerminal("ATTRIBUTE"),
PROCEDURES = new NonTerminal("PROCEDURES"),
VALORES = new NonTerminal("VALORES");
#endregion
#region GRAMATICA
S.Rule = Instrucciones;
Instrucciones.Rule = Instrucciones + Instruccion
| Instruccion;
Instruccion.Rule = LOGIN
| LOGOUT
| QUERY
| DATA
| MESSAGE
| ERROR
| STRUC
| DATABASES;
LOGIN.Rule = CORIZQ + MAS + RLOGIN + CORDER + USER + PASSWORD + CORIZQ + MENOS + RLOGIN + CORDER
| CORIZQ + MAS + RLOGIN + CORDER + RESPUESTA + CORIZQ + MENOS + RLOGIN + CORDER;
USER.Rule = CORIZQ + MAS + RUSER + CORDER + VALOR + CORIZQ + MENOS + RUSER + CORDER;
PASSWORD.Rule = CORIZQ + MAS + RPASS + CORDER + VALOR + CORIZQ + MENOS + RPASS + CORDER;
VALOR.Rule = CADENA
| IDENTIFICADOR
| NUMERO;
RESPUESTA.Rule = CORIZQ + RSUCCESS + CORDER
| CORIZQ + RFAIL + CORDER;
LOGOUT.Rule = CORIZQ + MAS + RLOGOUT + CORDER + RESPUESTA + CORIZQ + MENOS + RLOGOUT + CORDER
| CORIZQ + MAS + RLOGOUT + CORDER + USER + CORIZQ + MENOS + RLOGOUT + CORDER;
QUERY.Rule = CORIZQ + MAS + RQUERY + CORDER + USER + DATA + CORIZQ + MENOS + RQUERY + CORDER;
DATA.Rule = CONT_DATA_IMPORT;
MESSAGE.Rule = CORIZQ + MAS + RMESSAGE + CORDER + VALORES + CORIZQ + MENOS + RMESSAGE + CORDER;
ERROR.Rule = CORIZQ + MAS + RERROR + CORDER + LINEA + COLUMNA + TIPO + DESCRIPCION + CORIZQ + MENOS + RERROR + CORDER;
LINEA.Rule = CORIZQ + MAS + RLINE + CORDER + VALOR + CORIZQ + MENOS + RLINE + CORDER;
COLUMNA.Rule = CORIZQ + MAS + RCOLUMN + CORDER + VALOR + CORIZQ + MENOS + RCOLUMN + CORDER;
TIPO.Rule = CORIZQ + MAS + RTYPE + CORDER + VALOR + CORIZQ + MENOS + RTYPE + CORDER;
DESCRIPCION.Rule = CORIZQ + MAS + RDESC + CORDER + VALOR + CORIZQ + MENOS + RDESC + CORDER;
STRUC.Rule = CORIZQ + MAS + RSTRUC + CORDER + USER + CORIZQ + MENOS + RSTRUC + CORDER;
DATABASES.Rule = CORIZQ + MAS + RDATABASES + CORDER + DATABASES2 + CORIZQ + MENOS + RDATABASES + CORDER;
DATABASES2.Rule = DATABASES2 + DATABASE
| DATABASE;
DATABASE.Rule = CORIZQ + MAS + RDATABASE + CORDER + NAME + TABLES + TYPES + PROCEDURES + CORIZQ + MENOS + RDATABASE + CORDER;
NAME.Rule = CORIZQ + MAS + RNAME + CORDER + VALOR + CORIZQ + MENOS + RNAME + CORDER;
TABLES.Rule = CORIZQ + MAS + RTABLES + CORDER + TABLES2 + CORIZQ + MENOS + RTABLES + CORDER;
TABLES2.Rule = TABLES2 + TABLE
| TABLE;
TABLE.Rule = CORIZQ + MAS + RTABLE + CORDER + NAME + COLUMNS + CORIZQ + MENOS + RTABLE + CORDER
| CORIZQ + MAS + RTABLE + CORDER + VALORES + CORIZQ + MENOS + RTABLE + CORDER;
COLUMNS.Rule = COLUMNS + COLUMN
| COLUMN;
COLUMN.Rule = CORIZQ + MAS + RCOLUMNS + CORDER + VALORES + CORIZQ + MENOS + RCOLUMNS + CORDER;
TYPES.Rule = CORIZQ + MAS + RTYPES + CORDER + TYPES2 + CORIZQ + MENOS + RTYPES + CORDER;
TYPES2.Rule = TYPES2 + TYPE
| TYPE;
TYPE.Rule = CORIZQ + MAS + RTYPE + CORDER + NAME + ATTRIBUTES + CORIZQ + MENOS + RTYPE + CORDER
| CORIZQ + MAS + RTYPE + CORDER + VALORES + CORIZQ + MENOS + RTYPE + CORDER;
ATTRIBUTES.Rule = ATTRIBUTES + ATTRIBUTE
| ATTRIBUTE;
ATTRIBUTE.Rule = CORIZQ + MAS + RATTRIBUTES + CORDER + VALORES + CORIZQ + MENOS + RATTRIBUTES + CORDER;
PROCEDURES.Rule = CORIZQ + MAS + RPROCEDURES + CORDER + VALORES + CORIZQ + MENOS + RPROCEDURES + CORDER;
VALORES.Rule = VALORES + VALOR
| VALOR;
#endregion
#region Preferencias
this.Root = S;
#endregion
}
public CSharpSyntaxNode Convert(StringLiteral node)
{
return(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.Text)));
}
public virtual void Enter(StringLiteral stringLiteral)
{
}
public override void Visit(StringLiteral node)
{
AssignToImplicitReturn(node);
}
