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); }