public BackOGrammar_old() : base(false) { var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n"); NonGrammarTerminals.Add(lineComment); var number = new NumberLiteral("number"); var string_literal = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote); var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple"); //covers normal identifiers (abc) and quoted id's ([abc d], "abc d") var comma = ToTerm(","); var dot = ToTerm("."); var CREATE = ToTerm("CREATE"); var NULL = ToTerm("NULL"); var NOT = ToTerm("NOT"); //var ADD = ToTerm("ADD"); //var COLUMN = ToTerm("COLUMN"); var UPDATE = ToTerm("UPDATE"); var SET = ToTerm("SET"); var DELETE = ToTerm("DELETE"); var SELECT = ToTerm("SELECT"); var FROM = ToTerm("FROM"); var COUNT = ToTerm("COUNT"); var JOIN = ToTerm("JOIN"); //var BY = ToTerm("BY"); }
/// <summary> /// Constructor for the master grammar class. /// </summary> protected MasterGrammar() : base(false) { LanguageFlags = LanguageFlags.NewLineBeforeEOF | LanguageFlags.CreateAst; MarkPunctuation("(", ")"); NonGrammarTerminals.Add(new CommentTerminal("Comment specification", ";", "\r", "\n", Environment.NewLine)); Root = null; }
public ASLGrammar() : base(true) { var string_lit = TerminalFactory.CreateCSharpString("string"); var number = TerminalFactory.CreateCSharpNumber("number"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var code = new CustomTerminal("code", MatchCodeTerminal); var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(single_line_comment); NonGrammarTerminals.Add(delimited_comment); var state = new KeyTerm("state", "state"); var init = new KeyTerm("init", "init"); var exit = new KeyTerm("exit", "exit"); var update = new KeyTerm("update", "update"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var startup = new KeyTerm("startup", "startup"); var shutdown = new KeyTerm("shutdown", "shutdown"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var state_def = new NonTerminal("stateDef"); var version = new NonTerminal("version"); var state_list = new NonTerminal("stateList"); var method_list = new NonTerminal("methodList"); var var_list = new NonTerminal("varList"); var var = new NonTerminal("var"); var module = new NonTerminal("module"); var method = new NonTerminal("method"); var offset_list = new NonTerminal("offsetList"); var offset = new NonTerminal("offset"); var method_type = new NonTerminal("methodType"); root.Rule = state_list + method_list; version.Rule = (comma + string_lit) | Empty; state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}"; state_list.Rule = MakeStarRule(state_list, state_def); method_list.Rule = MakeStarRule(method_list, method); var_list.Rule = MakeStarRule(var_list, semi, var); module.Rule = (string_lit + comma) | Empty; var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty; method.Rule = (method_type + "{" + code + "}") | Empty; offset_list.Rule = MakePlusRule(offset_list, comma, offset); offset.Rule = number; method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown; Root = root; MarkTransient(var_list, method_list, offset, method_type); LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public XmlGrammar() : base(false) { LanguageFlags = LanguageFlags.CreateAst; NonGrammarTerminals.Add(new CommentTerminal("comment", "<%--", "--%>")); var element = Transient("element", null); var identifier = Identifier(); var attributesList = AttributesList(identifier); var xmlText = new XmlTextTerminal(new List <Terminal> { ToTerm(">"), ToTerm("/>") }, (context, node) => node.AstNode = new XmlText { Content = node.FindTokenAndGetText() }); var tag = Tag(identifier, attributesList, element); var directive = Directive(identifier, attributesList); var codeFragment = CodeFragment(); var document = NonTerminal("document", null, node => new AspNetXmlDocument { Elements = node.ChildNodes.Select(c => c.AstNode).Cast <ITagContent>().ToList() }); element.Rule = tag | directive | codeFragment | xmlText; document.Rule = MakeStarRule(document, element); Root = document; }
public JsonGrammar(Domain domain) : base(domain) { B = new BnfTerms(new TerminalFactoryS(this)); this.Root = B.Object; B.Object.Rule = B.NUMBER + SetUnparsePriority((astValue, childAstValues) => astValue is int || astValue is double?(int?)1 : null) | B.STRING | B.BOOLEAN | B.Array | B.NULL + SetUnparsePriority((astValue, childAstValues) => astValue == null ? (int?)1 : null) | B.OBJECT_BEGIN + B.KeyValuePairs.ConvertValue(KeyValuePairsToObject, ObjectToKeyValuePairs) + B.OBJECT_END ; B.KeyValuePairs.Rule = B.KeyValuePair.PlusList(B.COMMA) ; B.KeyValuePair.Rule = B.Key.BindTo(B.KeyValuePair, fv => fv.Key) + B.COLON + B.Value.BindTo(B.KeyValuePair, fv => fv.Value); B.Key.Rule = B.STRING ; B.Value.Rule = B.Object ; B.Array.Rule = B.ARRAY_BEGIN + B.ArrayElements.BindTo(B.Array, metaArray => metaArray.Elements) + B.ARRAY_END ; B.ArrayElements.Rule = B.Object.StarListTL(B.COMMA) ; RegisterBracePair(B.OBJECT_BEGIN, B.OBJECT_END); RegisterBracePair(B.ARRAY_BEGIN, B.ARRAY_END); // TODO: although JSON does not have comments, we define C-style comments for until we solve parsing and unparsing of comments into JSON data CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "//", Environment.NewLine, "\n", "\r"); NonGrammarTerminals.Add(DelimitedComment); NonGrammarTerminals.Add(SingleLineComment); }
public XmlGrammar() : base(false) { //Terminals Terminal comment = new CommentTerminal("comment", "<!--", "-->"); NonGrammarTerminals.Add(comment); StringLiteral stringLiteral = new StringLiteral("string", "\"", StringOptions.None); Terminal stringContent = new ToTerminatorTerminal("StringContent", '<'); KeyTerm elementOpener = ToTerm("<"); KeyTerm closeElementOpener = ToTerm("</"); KeyTerm elementCloser = ToTerm(">"); KeyTerm openCloseElementCloser = ToTerm("/>"); KeyTerm equals = ToTerm("="); KeyTerm xmlDeclOpen = ToTerm("<?"); KeyTerm xmlDeclClose = ToTerm("?>"); IdentifierTerminal attributeIdentifier = new IdentifierTerminal(AttributeIdentifier, ".", "."); IdentifierTerminal elementIdentifier = new IdentifierTerminal(ElementIdentifier, ".-", ".-"); KeyTerm xmlDeclarationIdentifier = ToTerm("xml"); //Non Terminals NonTerminal document = new NonTerminal("document"); NonTerminal elementStart = new NonTerminal("ElementStart"); NonTerminal elementEnd = new NonTerminal("ElementEnd"); NonTerminal openCloseElement = new NonTerminal("OpenCloseElement"); NonTerminal element = new NonTerminal("Element"); NonTerminal requiredElements = new NonTerminal("RequiredElements"); NonTerminal innerContent = new NonTerminal("InnerContent"); NonTerminal content = new NonTerminal("Content"); NonTerminal attribute = new NonTerminal("Attribute"); NonTerminal optionalAttribute = new NonTerminal("OptionalAttribute"); NonTerminal xmlDeclaration = new NonTerminal("XmlDeclaration"); NonTerminal optionalXmlDeclaration = new NonTerminal("OptionalXmlDeclaration"); //Rules this.Root = document; innerContent.Rule = element | stringContent; content.Rule = MakeStarRule(content, innerContent); attribute.Rule = attributeIdentifier + equals + stringLiteral; optionalAttribute.Rule = MakeStarRule(optionalAttribute, attribute); elementStart.Rule = elementOpener + elementIdentifier + optionalAttribute + elementCloser; elementEnd.Rule = closeElementOpener + elementIdentifier + elementCloser; openCloseElement.Rule = elementOpener + elementIdentifier + optionalAttribute + openCloseElementCloser; element.Rule = (elementStart + content + elementEnd) | openCloseElement; requiredElements.Rule = MakePlusRule(requiredElements, element); xmlDeclaration.Rule = xmlDeclOpen + xmlDeclarationIdentifier + optionalAttribute + xmlDeclClose; optionalXmlDeclaration.Rule = MakeStarRule(optionalXmlDeclaration, xmlDeclaration); document.Rule = optionalXmlDeclaration + requiredElements; MarkPunctuation(elementOpener, elementCloser, closeElementOpener, openCloseElementCloser, equals, xmlDeclOpen, xmlDeclClose); MarkTransient(innerContent); }
private void Comments() { var comment = new CommentTerminal("multiline_comment", "/*", "*/"); var lineComment = new CommentTerminal("singleline_comment", "--", "\n", "\r\n"); NonGrammarTerminals.Add(comment); NonGrammarTerminals.Add(lineComment); }
public VASLGrammar() : base(true) { var code = new CustomTerminal("code", MatchCodeTerminal); var stringLit = TerminalFactory.CreateCSharpString("string"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var number = TerminalFactory.CreateCSharpNumber("number"); number.Options |= NumberOptions.AllowSign; var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); // Todo: Aliases var init = new KeyTerm("init", "init"); var exit = new KeyTerm("exit", "exit"); var update = new KeyTerm("update", "update"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var startup = new KeyTerm("startup", "startup"); var shutdown = new KeyTerm("shutdown", "shutdown"); var undoSplit = new KeyTerm("undoSplit", "undoSplit"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var version = new NonTerminal("version"); var methodList = new NonTerminal("methodList"); var varList = new NonTerminal("varList"); var var = new NonTerminal("var"); var method = new NonTerminal("method"); var methodType = new NonTerminal("methodType"); root.Rule = methodList; version.Rule = (comma + stringLit) | Empty; methodList.Rule = MakeStarRule(methodList, method); varList.Rule = MakeStarRule(varList, semi, var); method.Rule = (methodType + "{" + code + "}") | Empty; methodType.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown | undoSplit; Root = root; MarkTransient(varList, methodList, methodType); LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
/// <summary> /// Creates an Irony Grammar /// </summary> public CRLGrammar() : base(caseSensitive: false) { //Comentarios var singleLineComment = new CommentTerminal("SingleLineComment", "!!", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "<<", ">>"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); MarkPunctuation(";", ",", "(", ")", "{", "}", "=", ":"); InitializeSyntax(); }
public IntegrationTestGrammar() { var comment = new CommentTerminal("comment", "/*", "*/"); NonGrammarTerminals.Add(comment); var str = new StringLiteral("str", "'", StringOptions.AllowsLineBreak); var stmt = new NonTerminal("stmt") { Rule = str | Empty }; Root = stmt; }
private readonly TerminalSet mSkipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution public JavaGrammar() { GrammarComments = "NOTE: This grammar does not parse hex floating point literals."; var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":", "@"); InitializeSyntax(); }
public NumericalSchemeGrammar() { this.GrammarComments = ""; //Symbols var whitespace = new NonTerminal("WhiteSpace", Empty | " " | "\t"); // Comments var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var multiLineComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(multiLineComment); //Terminals var semicolon = ToTerm(";", "Semicolon"); var ofString = new StringLiteral("String", "\""); var ofNumber = new NumberLiteral("Number", NumberOptions.AllowSign); var ofIdentifier = TerminalFactory.CreateCSharpIdentifier("Identifier"); var ofArrayTerm = new IdentifierTerminal("SchemeTerm", "(),|*.+-/%^~!&"); //Non-terminals var ofValue = new NonTerminal("Value"); var ofDictionary = new NonTerminal("Dictionary"); var ofDictionaryContent = new NonTerminal("DictionaryContent"); var ofDictionaryContentWrapper = new NonTerminal("DictionaryContentWrapper"); var ofDictEntry = new NonTerminal("DictEntry"); var ofArrayEntry = new NonTerminal("ArrayEntry"); var ofArray = new NonTerminal("Array"); var ofArrayWrapper = new NonTerminal("ArrayWrapper"); //BNF ofValue.Rule = ofIdentifier | ofArrayTerm | ofString | ofNumber; ofDictEntry.Rule = ofArrayWrapper | ofDictionary; ofDictionaryContent.Rule = MakeStarRule(ofDictionaryContent, whitespace, ofDictEntry); ofDictionaryContentWrapper.Rule = "{" + ofDictionaryContent + "}"; ofDictionary.Rule = ofIdentifier + whitespace + ofDictionaryContentWrapper; ofArrayEntry.Rule = ofValue; ofArray.Rule = MakeStarRule(ofArray, whitespace, ofArrayEntry); ofArrayWrapper.Rule = ofArray + semicolon; //Set grammar root this.Root = ofDictionaryContent; MarkPunctuation("{", "}"); MarkTransient(ofValue, ofDictionaryContentWrapper); }
public ASLGrammar() : base(true) { var stringLit = TerminalFactory.CreateCSharpString("string"); var number = TerminalFactory.CreateCSharpNumber("number"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var code = new CustomTerminal("code", MatchCodeTerminal); var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); var state = new KeyTerm("state", "state"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var stateDef = new NonTerminal("stateDef"); var methodList = new NonTerminal("methodList"); var varList = new NonTerminal("varList"); var var = new NonTerminal("var"); var method = new NonTerminal("method"); var offsetList = new NonTerminal("offsetList"); var offset = new NonTerminal("offset"); var methodType = new NonTerminal("methodType"); root.Rule = stateDef + methodList; stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}"; methodList.Rule = MakeStarRule(methodList, method); varList.Rule = MakeStarRule(varList, semi, var); var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty; method.Rule = (methodType + "{" + code + "}") | Empty; offsetList.Rule = MakePlusRule(offsetList, comma, offset); offset.Rule = number; methodType.Rule = start | split | isLoading | gameTime | reset; this.Root = root; MarkTransient(varList, methodList, offset, methodType); this.LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public Kbtter3QueryGrammar() : base(false) { //コメント var comment = new CommentTerminal("Comment", "/*", "*/"); NonGrammarTerminals.Add(comment); //リテラル var number = new NumberLiteral("Number", NumberOptions.AllowSign | NumberOptions.AllowStartEndDot); var str = new StringLiteral("String", "\""); var regex = new RegexLiteral("Regex", '/', '\\'); var ident = new IdentifierTerminal("Identifer"); //非終端 var Value = new NonTerminal("Value"); var Term = new NonTerminal("Term"); var Expression = new NonTerminal("Expression"); var BinExpression = new NonTerminal("BinExpression"); var ParExpression = new NonTerminal("ParExpression"); var PostfixExpression = new NonTerminal("PostfixExpression"); var Operator = new NonTerminal("Operator"); //非終端定義 Value.Rule = number | str | ident | regex | "null" | "true" | "false"; Term.Rule = Value | ParExpression; Operator.Rule = ToTerm("==") | "!=" | ">" | "<" | ">=" | "<=" | "match" | "&&" | "||" | "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "."; BinExpression.Rule = Expression + Operator + Expression; PostfixExpression.Rule = (ToTerm("+") + Term) | ("-" + Term) | ("!" + Term); Expression.Rule = BinExpression | Term | PostfixExpression; ParExpression.Rule = ToTerm("(") + Expression + ")"; RegisterOperators(10, "."); RegisterOperators(9, "*", "/", "%"); RegisterOperators(8, "+", "-"); RegisterOperators(7, ">", "<", ">=", "<=", "match"); RegisterOperators(6, "==", "!="); RegisterOperators(5, "&"); RegisterOperators(4, "^"); RegisterOperators(3, "|"); RegisterOperators(2, "&&"); RegisterOperators(1, "||"); Root = Expression; MarkPunctuation("(", ")"); MarkTransient(Expression, ParExpression, Value, Operator, Term); }
void InitializeComments() { //// comment: //// single_line_comment //// requires_comment //// delimited_comment //// single_line_comment: //// # input_characters_opt //// input_characters: //// input_character //// input_characters input_character //// input_character: //// Any Unicode character except a new_line_character CommentTerminal comment = new CommentTerminal("comment", "#", "\r", "\n", "\r\n"); NonGrammarTerminals.Add(comment); }
public LightGrammar() { var lineComment = new CommentTerminal("LineComment", "#", "\n", "\r\n"); NonGrammarTerminals.Add(lineComment); ConstructAll(); SetAllRules(); MarkPunctuation("[", "]", "(", ")", "{", "}", ":", "=>", ".", "="); RegisterOperators(1, "=="); RegisterOperators(2, "-"); RegisterOperators(3, "mod"); RegisterOperators(4, "**"); this.Root = TopLevelRoot; this.LanguageFlags = LanguageFlags.CreateAst; }
public analizador() { var entero = new RegexBasedTerminal("entero", "[0-9]+"); IdentifierTerminal id = new IdentifierTerminal("id"); var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); var p = new StringLiteral("p", "\""); var ENTERO = ToTerm("entero"); var CADENA = ToTerm("cadena"); var DOUBLE = ToTerm("double"); //ENTERO.AstConfig.NodeType = typeof(Arbol); //CADENA.AstConfig.NodeType = typeof(Arbol); //DOUBLE.AstConfig.NodeType = typeof(Arbol); p.AstConfig.NodeType = typeof(Arbol); entero.AstConfig.NodeType = typeof(Arbol); id.AstConfig.NodeType = typeof(Arbol); NonTerminal E = new NonTerminal("E", typeof(Arbol)); E.Rule = E + ToTerm("+") + E | E + ToTerm("-") + E | E + ToTerm("*") + E | E + ToTerm("/") + E | ToTerm("(") + E + ToTerm(")") | entero | id; RegisterOperators(1, "+", "-");//ESTABLESEMOS PRESEDENCIA RegisterOperators(2, "*", "/"); this.Root = E; NonGrammarTerminals.Add(singleLineComment); // QUITAMOS LOS COMENTARIOS DE LA GRAMATICA NonGrammarTerminals.Add(delimitedComment); LanguageFlags = LanguageFlags.CreateAst; //IMPORTANTE PARA CREAR EL ARBOL SIN ESTO NO LO CREARA }
/// <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 void SetUpTerminals() { Comment = new CommentTerminal(nameof(Comment), ";", "\n", "\r"); NonGrammarTerminals.Add(Comment); var ident = new IdentifierTerminal(nameof(Ident), ".$_", ".$_"); ident.Options = IdOptions.IsNotKeyword; Ident = ident; var number = new NumberLiteral(nameof(Number), NumberOptions.AllowUnderscore | NumberOptions.IntOnly | NumberOptions.AllowSign); number.AddPrefix("0x", NumberOptions.Hex); number.AddPrefix("0b", NumberOptions.Binary); number.AddPrefix("0", NumberOptions.Octal); Number = number; NormalString = new StringLiteral(nameof(NormalString), "\"", StringOptions.NoEscapes); EscapedString = new StringLiteral(nameof(EscapedString), "`", StringOptions.AllowsAllEscapes); CharLiteral = new StringLiteral(nameof(CharLiteral), "'", StringOptions.IsChar | StringOptions.AllowsAllEscapes); Separator = ToTerm(SeparatorToken, nameof(Separator)); }
void InitializeComments() { //// comment: //// single_line_comment //// requires_comment //// delimited_comment //// single_line_comment: //// # input_characters_opt //// input_characters: //// input_character //// input_characters input_character //// input_character: //// Any Unicode character except a new_line_character CommentTerminal comment = new CommentTerminal("comment", "#", "\r", "\n", "\r\n"); NonGrammarTerminals.Add(comment); //// delimited_comment: //// <# delimited_comment_text_opt hashes > //// delimited_comment_text: //// delimited_comment_section //// delimited_comment_text delimited_comment_section //// delimited_comment_section: //// > //// hashes_opt not_greater_than_or_hash //// hashes: //// # //// hashes # //// not_greater_than_or_hash: //// Any Unicode character except > or # CommentTerminal delimited_comment = new CommentTerminal("delimited_comment", "<#", "#>"); NonGrammarTerminals.Add(delimited_comment); }
public GramaticaCQL() : base(false) { CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/"); CommentTerminal lineComment = new CommentTerminal("line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); NonGrammarTerminals.Add(blockComment); NonGrammarTerminals.Add(lineComment); /* Reserved Words */ KeyTerm null_ = ToTerm("null"), true_ = ToTerm("true"), false_ = ToTerm("false"), type_ = ToTerm("type"), if_ = ToTerm("if"), not_ = ToTerm("not"), exists_ = ToTerm("exists"), int_ = ToTerm("int"), double_ = ToTerm("double"), string_ = ToTerm("string"), boolean_ = ToTerm("boolean"), date_ = ToTerm("date"), time_ = ToTerm("time"), use_ = ToTerm("use"), create_ = ToTerm("create"), database_ = ToTerm("database"), drop_ = ToTerm("drop"), table_ = ToTerm("table"), counter_ = ToTerm("counter"), primary_ = ToTerm("primary"), key_ = ToTerm("key"), alter_ = ToTerm("alter"), add_ = ToTerm("add"), truncate_ = ToTerm("truncate"), commit_ = ToTerm("commit"), rollback_ = ToTerm("rollback"), user_ = ToTerm("user"), with_ = ToTerm("with"), password_ = ToTerm("password"), grant_ = ToTerm("grant"), on_ = ToTerm("on"), revoke_ = ToTerm("revoke"), insert_ = ToTerm("insert"), into_ = ToTerm("into"), values_ = ToTerm("values"), update_ = ToTerm("update"), set_ = ToTerm("set"), where_ = ToTerm("where"), delete_ = ToTerm("delete"), from_ = ToTerm("from"), select_ = ToTerm("select"), order_ = ToTerm("order"), by_ = ToTerm("by"), asc_ = ToTerm("asc"), desc_ = ToTerm("desc"), limit_ = ToTerm("limit"), begin_ = ToTerm("begin"), batch_ = ToTerm("batch"), apply_ = ToTerm("apply"), count_ = ToTerm("count"), min_ = ToTerm("min"), max_ = ToTerm("max"), sum_ = ToTerm("sum"), avg_ = ToTerm("avg"), in_ = ToTerm("in"), else_ = ToTerm("else"), switch_ = ToTerm("switch"), case_ = ToTerm("case"), default_ = ToTerm("default"), while_ = ToTerm("while"), do_ = ToTerm("do"), for_ = ToTerm("for"), new_ = ToTerm("new"), map_ = ToTerm("map"), list_ = ToTerm("list"), procedure_ = ToTerm("procedure"), call_ = ToTerm("call"), break_ = ToTerm("break"), continue_ = ToTerm("continue"), return_ = ToTerm("return"), cursor_ = ToTerm("cursor"), is_ = ToTerm("is"), each_ = ToTerm("each"), open_ = ToTerm("open"), close_ = ToTerm("close"), log_ = ToTerm("log"), throw_ = ToTerm("throw"), try_ = ToTerm("try"), catch_ = ToTerm("catch"), as_ = ToTerm("as"); MarkReservedWords("null", "true", "false", "type", "if", "not", "exists", "int", "double", "string", "boolean", "date", "time", "use", "create", "database", "drop", "table", "counter", "primary", "key", "alter", "add", "truncate", "commit", "rollback", "user", "with", "password", "grant", "on", "revoke", "insert", "into", "values", "update", "set", "where", "delete", "from", "select", "order", "by", "asc", "desc", "limit", "begin", "batch", "apply", "count", "min", "max", "sum", "avg", "in", "else", "switch", "case", "default", "while", "do", "for", "new", "map", "list", "procedure", "call", "break", "continue", "return", "cursor", "is", "each", "open", "close", "log", "throw", "try", "catch", "as"); /* Relational operators */ KeyTerm menorigual = ToTerm("<="), mayorigual = ToTerm(">="), menorque = ToTerm("<"), mayorque = ToTerm(">"), igual = ToTerm("=="), diferente = ToTerm("!="); /* Logic operators */ KeyTerm or = ToTerm("||"), and = ToTerm("&&"), xor = ToTerm("^"), not = ToTerm("!"); /* Shift operators */ KeyTerm leftShift = ToTerm("--"), rightShift = ToTerm("++"); /* Arithmetic Operators*/ KeyTerm mas = ToTerm("+"), menos = ToTerm("-"), por = ToTerm("*"), division = ToTerm("/"), modulo = ToTerm("%"), potencia = ToTerm("**"); /* Symbols*/ KeyTerm equal = ToTerm("="), semicolon = ToTerm(";"), leftPar = ToTerm("("), rightPar = ToTerm(")"), dot = ToTerm("."), comma = ToTerm(","), questionmark = ToTerm("?"), colon = ToTerm(":"), leftCor = ToTerm("["), rightCor = ToTerm("]"), leftLla = ToTerm("{"), rightLla = ToTerm("}"), masEqual = ToTerm("+="), menosEqual = ToTerm("-="), porEqual = ToTerm("*="), divisionEqual = ToTerm("/="), menormenor = ToTerm("<<"), mayormayor = ToTerm(">>"); MarkPunctuation(";"); var number = new NumberLiteral("number"); //var identifier = new IdentifierTerminal("identifier"); RegexBasedTerminal identifier = new RegexBasedTerminal("identifier", "([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*"); RegexBasedTerminal identifier2 = new RegexBasedTerminal("identifier2", "@([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*"); //RegexBasedTerminal date = new RegexBasedTerminal("date", "\'([0-2][0-9]{3}|[0-9][0-9]{0,2})-([0]?[0-9]|[1][0-2])-([0]?[0-9]|[1-2][0-9]|[3][0-1])\'"); //RegexBasedTerminal time = new RegexBasedTerminal("time", "\'([0]?[0-9]|[1][0-9]|[2][0-4]):([0]?[0-9]|[1-5][0-9]):([0]?[0-9]|[1-5][0-9])\'"); RegexBasedTerminal date = new RegexBasedTerminal("date", "\'[0-9]+-[0-9]+-[0-9]+\'"); RegexBasedTerminal time = new RegexBasedTerminal("time", "\'[0-9]+:[0-9]+:[0-9]+\'"); var stringliteral = new StringLiteral("stringliteral", "\"", StringOptions.IsTemplate); NonTerminal INICIO = new NonTerminal("INICIO"), INSTRUCCIONES = new NonTerminal("INSTRUCCIONES"), INSTRUCCION = new NonTerminal("INSTRUCCION"), TYPE = new NonTerminal("TYPE"), TYPE_PRIMITIVE = new NonTerminal("TYPE_PRIMITIVE"), TYPE_COLLECTION = new NonTerminal("TYPE_COLLECTION"), TYPEDEF = new NonTerminal("TYPEDEF"), IFNOTEXIST = new NonTerminal("IFNOTEXIST"), IFEXIST = new NonTerminal("IFEXIST"), ATTRIBUTE_LIST = new NonTerminal("ATTRIBUTE_LIST"), ATTRIBUTEREF = new NonTerminal("ATTRIBUTEREF"), ATTRIBUTE = new NonTerminal("ATTRIBUTE"), USE = new NonTerminal("USE"), DATABASEDEF = new NonTerminal("DATABASEDEF"), DROP = new NonTerminal("DROP"), TABLEDEF = new NonTerminal("TABLEDEF"), COLUMN_LIST = new NonTerminal("COLUMN_LIST"), COLUMN = new NonTerminal("COLUMN"), ID_LIST = new NonTerminal("ID_LIST"), TABLEALTER = new NonTerminal("TABLEALTER"), TABLEDROP = new NonTerminal("TABLEDROP"), TABLETRUNCATE = new NonTerminal("TABLETRUNCATE"), COMMIT = new NonTerminal("COMMIT"), ROLLBACK = new NonTerminal("ROLLBACK"), USERDEF = new NonTerminal("USERDEF"), GRANT = new NonTerminal("GRANT"), REVOKE = new NonTerminal("REVOKE"), WHERE = new NonTerminal("WHERE"), INSERT = new NonTerminal("INSERT"), UPDATE = new NonTerminal("UPDATE"), DELETE = new NonTerminal("DELETE"), SELECT = new NonTerminal("SELECT"), SELECT_EXP = new NonTerminal("SELECT_EXP"), ORDER_LIST = new NonTerminal("ORDER_LIST"), ORDER = new NonTerminal("ORDER"), BATCH = new NonTerminal("BATCH"), DML_LIST = new NonTerminal("DML_LIST"), DML = new NonTerminal("DML"), TARGET_LIST = new NonTerminal("TARGET_LIST"), TARGET = new NonTerminal("TARGET"), EXPRESSION_STMT = new NonTerminal("EXPRESSION_STMT"), ASSIGNMENT_STMT = new NonTerminal("ASSIGNMENT_STMT"), ASSIGNMENTS = new NonTerminal("ASSIGNMENTS"), ASSIGNMENT_CALL = new NonTerminal("ASSIGNMENT_CALL"), ASSIGNMENT_LIST = new NonTerminal("ASSIGNMENT_LIST"), DECLARATION_STMT = new NonTerminal("DECLARATION_STMT"), AUGMENTED_ASSIGNMENT_STMT = new NonTerminal("AUGMENTED_ASSIGNMENT_STMT"), //AUGTARGET = new NonTerminal("AUGTARGET"), AUG_OPERATOR = new NonTerminal("AUG_OPERATOR"), IF_STMT = new NonTerminal("IF_STMT"), IF_LIST = new NonTerminal("IF_LIST"), SWITCH_STMT = new NonTerminal("SWITCH_STMT"), CASES = new NonTerminal("CASES"), WHILE_STMT = new NonTerminal("WHILE_STMT"), DOWHILE_STMT = new NonTerminal("DOWHILE_STMT"), FOR_STMT = new NonTerminal("FOR_STMT"), FOR_INIT = new NonTerminal("FOR_INIT"), FOR_UPDATE = new NonTerminal("FOR_UPDATE"), FUNDEF = new NonTerminal("FUNDEF"), PARAMETER_LIST = new NonTerminal("PARAMETER_LIST"), PROCDEF = new NonTerminal("PROCDEF"), BREAK_STMT = new NonTerminal("BREAK_STMT"), CONTINUE_STMT = new NonTerminal("CONTINUE_STMT"), RETURN_STMT = new NonTerminal("RETURN_STMT"), CURSOR_STMT = new NonTerminal("CURSOR_STMT"), FOREACH_STMT = new NonTerminal("FOREACH_STMT"), OPEN_STMT = new NonTerminal("OPEN_STMT"), CLOSE_STMT = new NonTerminal("CLOSE_STMT"), LOG_STMT = new NonTerminal("LOG_STMT"), THROW_STMT = new NonTerminal("THROW_STMT"), TRYCATCH_STMT = new NonTerminal("TRYCATCH_STMT"), BLOQUE = new NonTerminal("BLOQUE"), SENTENCIAS = new NonTerminal("SENTENCIAS"), SENTENCIA = new NonTerminal("SENTENCIA"), /*STARRED_EXPRESSION = new NonTerminal("STARRED_EXPRESSION"), * STARRED_LIST = new NonTerminal("STARRED_LIST"), * STARRED_ITEM = new NonTerminal("STARRED_ITEM"),*/ AGGREGATION = new NonTerminal("AGGREGATION"), AGGREGATION_FUN = new NonTerminal("AGGREGATION_FUN"), EXPRESSION_LIST = new NonTerminal("EXPRESSION_LIST"), EXPRESSION = new NonTerminal("EXPRESSION"), CONDITIONAL_EXPRESSION = new NonTerminal("CONDITIONAL_EXPRESSION"), INSTANCE = new NonTerminal("INSTANCE"), OR_EXPR = new NonTerminal("OR_EXPR"), AND_EXPR = new NonTerminal("AND_EXPR"), XOR_EXPR = new NonTerminal("XOR_EXPR"), NOT_EXPR = new NonTerminal("NOT_EXPR"), COMPARISON = new NonTerminal("COMPARISON"), COMPARISON_EQ = new NonTerminal("COMPARISON_EQ"), COMP_OPERATOR = new NonTerminal("COMP_OPERATOR"), SHIFT_EXPR = new NonTerminal("SHIFT_EXPR"), A_EXPR = new NonTerminal("A_EXPR"), M_EXPR = new NonTerminal("M_EXPR"), U_EXPR = new NonTerminal("U_EXPR"), POWER = new NonTerminal("POWER"), PRIMARY = new NonTerminal("PRIMARY"), ATOM = new NonTerminal("ATOM"), FUNCALL = new NonTerminal("FUNCALL"), CALL = new NonTerminal("CALL"), ACCESS = new NonTerminal("ACCESS"), ENCLOSURE = new NonTerminal("ENCLOSURE"), LITERAL = new NonTerminal("LITERAL"), PARENTH_FORM = new NonTerminal("PARENTH_FORM"), MAP_DISPLAY = new NonTerminal("MAP_DISPLAY"), MAP_LIST = new NonTerminal("MAP_LIST"), LIST_DISPLAY = new NonTerminal("LIST_DISPLAY"), SET_DISPLAY = new NonTerminal("SET_DISPLAY"); this.Root = INICIO; INICIO.Rule = INSTRUCCIONES; INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION); INSTRUCCION.Rule = TYPEDEF + semicolon | USE + semicolon | DATABASEDEF + semicolon | DROP + semicolon | TABLEDEF + semicolon | TABLEALTER + semicolon | TABLEDROP + semicolon | TABLETRUNCATE + semicolon | COMMIT + semicolon | ROLLBACK + semicolon | USERDEF + semicolon | GRANT + semicolon | REVOKE + semicolon | INSERT + semicolon | UPDATE + semicolon | DELETE + semicolon | SELECT + semicolon | BATCH + semicolon | EXPRESSION_STMT + semicolon | DECLARATION_STMT + semicolon | ASSIGNMENT_STMT + semicolon | ASSIGNMENT_CALL + semicolon | AUGMENTED_ASSIGNMENT_STMT + semicolon | IF_STMT | SWITCH_STMT | WHILE_STMT | DOWHILE_STMT + semicolon | FOR_STMT | FUNDEF | PROCDEF | BREAK_STMT + semicolon | CONTINUE_STMT + semicolon | RETURN_STMT + semicolon | CURSOR_STMT + semicolon | FOREACH_STMT | OPEN_STMT + semicolon | CLOSE_STMT + semicolon | LOG_STMT + semicolon | THROW_STMT + semicolon | TRYCATCH_STMT; //INSTRUCCION.ErrorRule = SyntaxError + semicolon; TYPE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_ | map_ | list_ | set_; TYPE_PRIMITIVE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_; TYPE_COLLECTION.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_ | map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque | list_ + menorque + TYPE_COLLECTION + mayorque | set_ + menorque + TYPE_COLLECTION + mayorque; IFNOTEXIST.Rule = if_ + not_ + exists_; IFEXIST.Rule = if_ + exists_; TYPEDEF.Rule = create_ + type_ + identifier + leftPar + ATTRIBUTE_LIST + rightPar | create_ + type_ + IFNOTEXIST + identifier + leftPar + ATTRIBUTE_LIST + rightPar; ATTRIBUTE_LIST.Rule = MakePlusRule(ATTRIBUTE_LIST, comma, ATTRIBUTE); ATTRIBUTE.Rule = identifier + TYPE_COLLECTION; USE.Rule = use_ + identifier; DATABASEDEF.Rule = create_ + database_ + identifier | create_ + database_ + IFNOTEXIST + identifier; DROP.Rule = drop_ + database_ + identifier | drop_ + database_ + IFNOTEXIST + identifier; TABLEDEF.Rule = create_ + table_ + identifier + leftPar + COLUMN_LIST + rightPar | create_ + table_ + IFNOTEXIST + identifier + leftPar + COLUMN_LIST + rightPar; COLUMN_LIST.Rule = MakePlusRule(COLUMN_LIST, comma, COLUMN); COLUMN.Rule = identifier + TYPE_COLLECTION | identifier + TYPE_COLLECTION + primary_ + key_ | primary_ + key_ + leftPar + ID_LIST + rightPar; ID_LIST.Rule = MakePlusRule(ID_LIST, comma, identifier); TABLEALTER.Rule = alter_ + table_ + identifier + add_ + ATTRIBUTE_LIST | alter_ + table_ + identifier + drop_ + ID_LIST; TABLEDROP.Rule = drop_ + table_ + identifier | drop_ + table_ + IFEXIST + identifier; TABLETRUNCATE.Rule = truncate_ + table_ + identifier; COMMIT.Rule = commit_; ROLLBACK.Rule = rollback_; USERDEF.Rule = create_ + user_ + identifier + with_ + password_ + stringliteral; GRANT.Rule = grant_ + identifier + on_ + identifier; REVOKE.Rule = revoke_ + identifier + on_ + identifier; WHERE.Rule = where_ + EXPRESSION | where_ + EXPRESSION + in_ + EXPRESSION_LIST | where_ + EXPRESSION + in_ + leftPar + EXPRESSION_LIST + rightPar; INSERT.Rule = insert_ + into_ + identifier + values_ + leftPar + EXPRESSION_LIST + rightPar | insert_ + into_ + identifier + leftPar + ID_LIST + rightPar + values_ + leftPar + EXPRESSION_LIST + rightPar; UPDATE.Rule = update_ + identifier + set_ + ASSIGNMENT_LIST | update_ + identifier + set_ + ASSIGNMENT_LIST + WHERE; DELETE.Rule = delete_ + from_ + identifier | delete_ + from_ + identifier + WHERE | delete_ + TARGET + from_ + identifier | delete_ + TARGET + from_ + identifier + WHERE; SELECT.Rule = select_ + SELECT_EXP + from_ + identifier | select_ + SELECT_EXP + from_ + identifier + WHERE | select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST | select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST | select_ + SELECT_EXP + from_ + identifier + limit_ + EXPRESSION | select_ + SELECT_EXP + from_ + identifier + WHERE + limit_ + EXPRESSION | select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION | select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION; SELECT_EXP.Rule = EXPRESSION_LIST | por; ORDER_LIST.Rule = MakePlusRule(ORDER_LIST, comma, ORDER); ORDER.Rule = identifier | identifier + asc_ | identifier + desc_; //TARGET* BATCH.Rule = begin_ + batch_ + DML_LIST + apply_ + batch_; DML_LIST.Rule = MakePlusRule(DML_LIST, DML); DML.Rule = INSERT + semicolon | UPDATE + semicolon | DELETE + semicolon; //////////////////////////////////////////////////////////////// BLOQUE.Rule = leftLla + SENTENCIAS + rightLla | leftLla + rightLla; SENTENCIAS.Rule = MakePlusRule(SENTENCIAS, SENTENCIA); SENTENCIA.Rule = TYPEDEF + semicolon /****/ | USE + semicolon | DATABASEDEF + semicolon | DROP + semicolon | TABLEDEF + semicolon | TABLEALTER + semicolon | TABLEDROP + semicolon | TABLETRUNCATE + semicolon | COMMIT + semicolon | ROLLBACK + semicolon | USERDEF + semicolon | GRANT + semicolon | REVOKE + semicolon | INSERT + semicolon | UPDATE + semicolon | DELETE + semicolon | SELECT + semicolon | BATCH + semicolon | EXPRESSION_STMT + semicolon | DECLARATION_STMT + semicolon | ASSIGNMENT_STMT + semicolon | ASSIGNMENT_CALL + semicolon | AUGMENTED_ASSIGNMENT_STMT + semicolon | IF_STMT | SWITCH_STMT | WHILE_STMT | DOWHILE_STMT + semicolon | FOR_STMT | BREAK_STMT + semicolon | CONTINUE_STMT + semicolon | RETURN_STMT + semicolon | CURSOR_STMT + semicolon | FOREACH_STMT | OPEN_STMT + semicolon | CLOSE_STMT + semicolon | LOG_STMT + semicolon | THROW_STMT + semicolon | TRYCATCH_STMT; TARGET_LIST.Rule = MakePlusRule(TARGET_LIST, comma, TARGET); TARGET.Rule = identifier //* | identifier2 | ATTRIBUTEREF //* | ACCESS; EXPRESSION_STMT.Rule = SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift | FUNCALL | CALL | ATTRIBUTEREF; DECLARATION_STMT.Rule = TYPE + TARGET_LIST | TYPE + TARGET_LIST + equal + EXPRESSION; ASSIGNMENT_STMT.Rule = TARGET + equal + EXPRESSION | TARGET + equal + CALL; ASSIGNMENT_CALL.Rule = TARGET_LIST + equal + CALL; ASSIGNMENT_LIST.Rule = MakePlusRule(ASSIGNMENT_LIST, comma, ASSIGNMENTS); ASSIGNMENTS.Rule = ASSIGNMENT_STMT | AUGMENTED_ASSIGNMENT_STMT; AUGMENTED_ASSIGNMENT_STMT.Rule = TARGET + AUG_OPERATOR + EXPRESSION; //AUGTARGET.Rule = identifier | identifier2 | ATTRIBUTEREF; //* AUG_OPERATOR.Rule = masEqual | menosEqual | porEqual | divisionEqual; IF_STMT.Rule = IF_LIST + else_ + BLOQUE | IF_LIST; IF_LIST.Rule = IF_LIST + else_ + if_ + leftPar + EXPRESSION + rightPar + BLOQUE | if_ + leftPar + EXPRESSION + rightPar + BLOQUE; SWITCH_STMT.Rule = switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + rightLla | switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + default_ + colon + BLOQUE + rightLla; CASES.Rule = CASES + case_ + EXPRESSION + colon + BLOQUE | case_ + EXPRESSION + colon + BLOQUE; WHILE_STMT.Rule = while_ + leftPar + EXPRESSION + rightPar + BLOQUE; DOWHILE_STMT.Rule = do_ + BLOQUE + while_ + leftPar + EXPRESSION + rightPar; FOR_STMT.Rule = for_ + leftPar + FOR_INIT + semicolon + EXPRESSION + semicolon + FOR_UPDATE + rightPar + BLOQUE; FOR_INIT.Rule = DECLARATION_STMT | ASSIGNMENT_STMT; FOR_UPDATE.Rule = AUGMENTED_ASSIGNMENT_STMT | ASSIGNMENT_STMT | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift; FUNDEF.Rule = TYPE + identifier + leftPar + PARAMETER_LIST + rightPar + BLOQUE | TYPE + identifier + leftPar + rightPar + BLOQUE; PARAMETER_LIST.Rule = PARAMETER_LIST + comma + TYPE + identifier2 | TYPE + identifier2; PROCDEF.Rule = procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE | procedure_ + identifier + leftPar + rightPar + comma + leftPar + rightPar + BLOQUE | procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + rightPar + BLOQUE | procedure_ + identifier + leftPar + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE; BREAK_STMT.Rule = break_; CONTINUE_STMT.Rule = continue_; RETURN_STMT.Rule = return_ | return_ + EXPRESSION_LIST; CURSOR_STMT.Rule = cursor_ + identifier2 + is_ + SELECT; FOREACH_STMT.Rule = for_ + each_ + leftPar + PARAMETER_LIST + rightPar + in_ + identifier2 + BLOQUE | for_ + each_ + leftPar + rightPar + in_ + identifier2 + BLOQUE; OPEN_STMT.Rule = open_ + identifier2; CLOSE_STMT.Rule = close_ + identifier2; LOG_STMT.Rule = log_ + leftPar + EXPRESSION + rightPar; THROW_STMT.Rule = throw_ + new_ + identifier; TRYCATCH_STMT.Rule = try_ + BLOQUE + catch_ + leftPar + PARAMETER_LIST + rightPar + BLOQUE | try_ + BLOQUE + catch_ + leftPar + rightPar + BLOQUE;; EXPRESSION_LIST.Rule = MakePlusRule(EXPRESSION_LIST, comma, EXPRESSION); EXPRESSION.Rule = CONDITIONAL_EXPRESSION | INSTANCE; INSTANCE.Rule = new_ + identifier | new_ + map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque | new_ + list_ + menorque + TYPE_COLLECTION + mayorque | new_ + set_ + menorque + TYPE_COLLECTION + mayorque; CONDITIONAL_EXPRESSION.Rule = OR_EXPR | OR_EXPR + questionmark + EXPRESSION + colon + EXPRESSION; OR_EXPR.Rule = AND_EXPR | OR_EXPR + or + AND_EXPR; AND_EXPR.Rule = XOR_EXPR | AND_EXPR + and + XOR_EXPR; XOR_EXPR.Rule = COMPARISON_EQ | XOR_EXPR + xor + COMPARISON_EQ; COMPARISON_EQ.Rule = COMPARISON | COMPARISON_EQ + igual + COMPARISON | COMPARISON_EQ + diferente + COMPARISON; COMPARISON.Rule = A_EXPR | COMPARISON + COMP_OPERATOR + A_EXPR; COMP_OPERATOR.Rule = menorque | mayorque | mayorigual | menorigual; A_EXPR.Rule = M_EXPR | A_EXPR + mas + A_EXPR | A_EXPR + menos + M_EXPR; M_EXPR.Rule = U_EXPR | M_EXPR + por + U_EXPR | M_EXPR + division + U_EXPR | M_EXPR + modulo + U_EXPR; U_EXPR.Rule = NOT_EXPR | POWER | menos + U_EXPR | mas + U_EXPR; NOT_EXPR.Rule = not + U_EXPR; POWER.Rule = SHIFT_EXPR | SHIFT_EXPR + potencia + U_EXPR; SHIFT_EXPR.Rule = PRIMARY | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift; PRIMARY.Rule = ATOM | ATTRIBUTEREF | AGGREGATION | FUNCALL | ACCESS; ATOM.Rule = identifier | identifier2 | LITERAL | ENCLOSURE; LITERAL.Rule = number | stringliteral | true_ | false_ | date | time | null_; ATTRIBUTEREF.Rule = PRIMARY + dot + identifier | PRIMARY + dot + FUNCALL; AGGREGATION.Rule = AGGREGATION_FUN + leftPar + menormenor + SELECT + mayormayor + rightPar; AGGREGATION_FUN.Rule = count_ | min_ | max_ | sum_ | avg_; ENCLOSURE.Rule = PARENTH_FORM | MAP_DISPLAY | LIST_DISPLAY | SET_DISPLAY; PARENTH_FORM.Rule = leftPar + EXPRESSION + rightPar | leftPar + TYPE + rightPar + EXPRESSION; MAP_DISPLAY.Rule = leftCor + MAP_LIST + rightCor; MAP_LIST.Rule = MAP_LIST + comma + EXPRESSION + colon + EXPRESSION | EXPRESSION + colon + EXPRESSION; LIST_DISPLAY.Rule = leftCor + EXPRESSION_LIST + rightCor; SET_DISPLAY.Rule = leftLla + EXPRESSION_LIST + rightLla | leftLla + EXPRESSION_LIST + rightLla + as_ + identifier; FUNCALL.Rule = identifier + leftPar + rightPar | identifier + leftPar + EXPRESSION_LIST + rightPar; CALL.Rule = call_ + identifier + leftPar + rightPar | call_ + identifier + leftPar + EXPRESSION_LIST + rightPar; ACCESS.Rule = PRIMARY + leftCor + EXPRESSION + rightCor; }
public TuringGrammarBroken() { //Expr -> n | v | Expr BinOp Expr | UnOP Expr | ( Expr ) //BinOp -> + | - | * | / | ** //UnOp -> - //ExprLine -> Expr EOF MarkReservedWords("not="); //1. Terminals Terminal num = new NumberLiteral("number"); Terminal iden = new IdentifierTerminal("identifier"); 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 expandedIdentifier = new NonTerminal("expandedIndentifier"); var Expr = new NonTerminal("expr"); var BinOp = new NonTerminal("binOp", "operator"); var BinExpr = new NonTerminal("binExpr"); var unOp = new NonTerminal("unOp"); var unExpr = new NonTerminal("unExpr"); var ParExpr = new NonTerminal("parExpr"); var Statement = new NonTerminal("statement"); var Program = new NonTerminal("program"); var setEqual = new NonTerminal("setEqual"); var varType = new NonTerminal("varType"); var variableDeclaration = new NonTerminal("variableDeclaration"); var varOrConst = new NonTerminal("varOrConst"); var idenList = new NonTerminal("identifierList"); var assignment = new NonTerminal("assignment"); var typeSpecifier = new NonTerminal("typeSpecifier"); var ifBlock = new NonTerminal("ifBlock"); var elseIfBlock = new NonTerminal("elseIfBlock"); var optElseBlock = new NonTerminal("optElseBlock"); var caseBlock = new NonTerminal("caseBlock"); var labelBlock = new NonTerminal("labelBlock"); var functionCall = new NonTerminal("functionCall"); var optArgs = new NonTerminal("optArgs"); var args = new NonTerminal("args"); var functionDefinition = new NonTerminal("functionDefinition"); var optParams = new NonTerminal("optParams"); var parameters = new NonTerminal("parameters"); var parameter = new NonTerminal("parameter"); var io = new NonTerminal("io"); var optSameLine = new NonTerminal("optionalSameLine"); var loop = new NonTerminal("loop"); var forLoop = new NonTerminal("forLoop"); var exitLoop = new NonTerminal("exitLoop"); var and = new NonTerminal("and"); var or = new NonTerminal("or"); var not = new NonTerminal("not"); var result = new NonTerminal("result"); var recordList = new NonTerminal("recordList"); var type = new NonTerminal("type"); var memberCall = new NonTerminal("memberCall"); var range = new NonTerminal("range"); var boolean = new NonTerminal("boolean"); var ioArgs = new NonTerminal("ioArgs"); var newer = new NonTerminal("new"); //3. BNF rules varType.Rule = ToTerm("int") | "nat" | "string" | "real" | "boolean" | "array" + range + "of" + varType | ToTerm("flexible") + "array" + range + "of" + varType | "record" + recordList + "end" + "record" | "int1" | "int2" | "int4" | "real1" | "real2" | "real4" | "nat1" | "nat2" | "nat4" | ToTerm("char") + "(" + num + ")" | ToTerm("string") + "(" + num + ")" | iden; range.Rule = Expr + ".." + Expr; setEqual.Rule = ToTerm(":=") + Expr; typeSpecifier.Rule = ToTerm(":") + varType; Expr.Rule = num | iden | BinExpr | ParExpr | stringLiteral | unExpr | functionCall | memberCall | boolean; BinOp.Rule = ToTerm("-") | "*" | "/" | "**" | "+" | "div" | "mod" | and | or | "=" | ">" | "<" | ">=" | "<=" | "~=" | "not="; BinOp.Precedence = 1; unOp.Rule = not | "-"; unOp.Precedence = 2; BinExpr.Rule = Expr + BinOp + Expr; unExpr.Rule = unOp + Expr; ParExpr.Rule = "(" + Expr + ")"; boolean.Rule = ToTerm("true") | "false"; assignment.Rule = expandedIdentifier + setEqual; optArgs.Rule = args | Empty; args.Rule = MakePlusRule(args, ToTerm(","), Expr); //args.Rule = Expr + "," + args | Expr; functionCall.Rule = iden + "(" + optArgs + ")"; optSameLine.Rule = ToTerm("..") | Empty; io.Rule = ToTerm("put") + args + optSameLine | ToTerm("get") + args | ToTerm("put") + ":" + args + optSameLine | ToTerm("get") + ":" + args | ToTerm("open") + ":" + iden + "," + Expr + "," + ioArgs; ioArgs.Rule = ToTerm("get") | "put" | "write" | "read" | "seek" | "tell" | ioArgs + "," + ioArgs; newer.Rule = ToTerm("new") + iden + "," + Expr; optParams.Rule = ToTerm("(") + parameters + ")" | ToTerm("(") + ")" | Empty; parameters.Rule = parameter + "," + parameters | parameter; parameter.Rule = idenList + typeSpecifier | "var" + idenList + typeSpecifier; functionDefinition.Rule = "function" + iden + optParams + typeSpecifier + Program + "end" + iden | "fcn" + iden + optParams + typeSpecifier + Program + "end" + iden | "procedure" + iden + optParams + Program + "end" + iden | "proc" + iden + optParams + Program + "end" + iden; ifBlock.Rule = ToTerm("if") + Expr + ToTerm("then") + Program + elseIfBlock + optElseBlock + ToTerm("end") + "if"; elseIfBlock.Rule = ToTerm("elsif") + Expr + ToTerm("then") + Program + elseIfBlock | Empty; optElseBlock.Rule = ToTerm("else") + Program | Empty; caseBlock.Rule = ToTerm("case") + iden + "of" + labelBlock + "end case"; labelBlock.Rule = ToTerm("label") + Expr + ":" + Program + labelBlock | ToTerm("label") + ":" + labelBlock | Empty; idenList.Rule = iden + "," + idenList | iden; varOrConst.Rule = ToTerm("var") | "const"; variableDeclaration.Rule = varOrConst + idenList | varOrConst + idenList + setEqual | varOrConst + idenList + typeSpecifier | varOrConst + idenList + typeSpecifier + setEqual; loop.Rule = "loop" + Program + "end" + "loop"; forLoop.Rule = "for" + ("decreasing" | Empty) + iden + ":" + (range | iden) + Program + "end" + "for"; exitLoop.Rule = ToTerm("exit") | ToTerm("exit") + "when" + Expr; and.Rule = ToTerm("and") | "&"; or.Rule = ToTerm("or") | "|"; not.Rule = ToTerm("not") | "~" | "!"; result.Rule = "result" + Expr | "return" + Expr; recordList.Rule = iden + typeSpecifier + recordList | Empty; type.Rule = "type" + iden + typeSpecifier; memberCall.Rule = expandedIdentifier + "." + expandedIdentifier; //memberCall.Rule = iden + "." + functionCall | iden + "." + iden | iden + "." + memberCall; expandedIdentifier.Rule = iden | functionCall | memberCall; Statement.Rule = functionCall | memberCall | iden | variableDeclaration | ifBlock | caseBlock | functionCall | functionDefinition | io | assignment | result | loop | forLoop | type | newer | exitLoop; Program.Rule = Statement + Program | Empty; this.Root = Program; //4. Set operator precendence and associativity RegisterOperators(05, Associativity.Left, "not"); RegisterOperators(10, Associativity.Left, "=", "not="); RegisterOperators(30, Associativity.Left, "+", "-"); RegisterOperators(40, Associativity.Left, "*", "/", "div", "mod"); RegisterOperators(50, Associativity.Right, "**"); //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 CilGrammar() : base(true) { LanguageFlags = LanguageFlags.CreateAst; // comments var SINGLELINECOMMENT = new CommentTerminal("SINGLELINECOMMENT", "//", "\n", "\r\n"); ConfigureAstNode(SINGLELINECOMMENT); NonGrammarTerminals.Add(SINGLELINECOMMENT); // lexical tokens var HEXBYTE = new RegexBasedTerminal("HEXBYTE", @"[A-F0-9]{2}"); // DOCS: not specified in ECMA grammar ConfigureAstNode(HEXBYTE); var DOTTEDNAME = CreateNonTerminal("DOTTEDNAME"); DOTTEDNAME.Rule = _("TODO: DOTTEDNAME"); ConfigureAstNode(DOTTEDNAME); var ID = new IdentifierTerminal("ID"); ID.AddPrefix("$", IdOptions.None); // DOCS: ECMA page 110 ConfigureAstNode(ID); var QSTRING = new StringLiteral("QSTRING", "\""); ConfigureAstNode(QSTRING); var SQSTRING = new StringLiteral("SQSTRING", "'"); ConfigureAstNode(SQSTRING); var INT32 = new NumberLiteral("INT32", NumberOptions.AllowSign | NumberOptions.IntOnly); INT32.AddPrefix("0x", NumberOptions.Hex); INT32.DefaultIntTypes = new TypeCode[] { TypeCode.Int32 }; ConfigureAstNode(INT32); var INT64 = new NumberLiteral("INT64", NumberOptions.AllowSign | NumberOptions.IntOnly); INT64.AddPrefix("0x", NumberOptions.Hex); INT64.DefaultIntTypes = new TypeCode[] { TypeCode.Int64 }; ConfigureAstNode(INT64); var FLOAT64 = new NumberLiteral("FLOAT64", NumberOptions.AllowStartEndDot | NumberOptions.AllowSign); ConfigureAstNode(FLOAT64); // non-terminals var decls = CreateNonTerminal("decls"); var decl = CreateNonTerminal("decl"); var compQstring = CreateNonTerminal("compQstring"); var languageDecl = CreateNonTerminal("languageDecl"); var customAttrDecl = CreateNonTerminal("customAttrDecl"); var moduleHead = CreateNonTerminal("moduleHead"); var vtfixupDecl = CreateNonTerminal("vtfixupDecl"); var vtableDecl = CreateNonTerminal("vtableDecl"); var nameSpaceHead = CreateNonTerminal("nameSpaceHead"); var classHead = CreateNonTerminal("classHead"); var classAttr = CreateNonTerminal("classAttr"); var extendsClause = CreateNonTerminal("extendsClause"); var implClause = CreateNonTerminal("implClause"); var classNames = CreateNonTerminal("classNames"); var classDecls = CreateNonTerminal("classDecls"); var classDecl = CreateNonTerminal("classDecl"); var fieldDecl = CreateNonTerminal("fieldDecl"); var atOpt = CreateNonTerminal("atOpt"); var initOpt = CreateNonTerminal("initOpt"); var repeatOpt = CreateNonTerminal("repeatOpt"); var customHead = CreateNonTerminal("customHead"); var customHeadWithOwner = CreateNonTerminal("customHeadWithOwner"); var memberRef = CreateNonTerminal("memberRef"); var customType = CreateNonTerminal("customType"); var ownerType = CreateNonTerminal("ownerType"); var eventHead = CreateNonTerminal("eventHead"); var eventDecls = CreateNonTerminal("eventDecls"); var propHead = CreateNonTerminal("propHead"); var propDecls = CreateNonTerminal("propDecls"); var methodHeadPart1 = CreateNonTerminal("methodHeadPart1"); var methodHead = CreateNonTerminal("methodHead"); var methAttr = CreateNonTerminal("methAttr"); var pinvAttr = CreateNonTerminal("pinvAttr"); var methodName = CreateNonTerminal("methodName"); var paramAttr = CreateNonTerminal("paramAttr"); var fieldAttr = CreateNonTerminal("fieldAttr"); var implAttr = CreateNonTerminal("implAttr"); var localsHead = CreateNonTerminal("localsHead"); var methodDecl = CreateNonTerminal("methodDecl"); var scopeBlock = CreateNonTerminal("scopeBlock"); var sehBlock = CreateNonTerminal("sehBlock"); var methodDecls = CreateNonTerminal("methodDecls"); var dataDecl = CreateNonTerminal("dataDecl"); var ddHead = CreateNonTerminal("ddHead"); var tls = CreateNonTerminal("tls"); var ddBody = CreateNonTerminal("ddBody"); var ddItemList = CreateNonTerminal("ddItemList"); var ddItemCount = CreateNonTerminal("ddItemCount"); var ddItem = CreateNonTerminal("ddItem"); var fieldInit = CreateNonTerminal("fieldInit"); var bytearrayhead = CreateNonTerminal("bytearrayhead"); var bytes = CreateNonTerminal("bytes"); var hexbytes = CreateNonTerminal("hexbytes"); var instr_r_head = CreateNonTerminal("instr_r_head"); var instr_tok_head = CreateNonTerminal("instr_tok_head"); var methodSpec = CreateNonTerminal("methodSpec"); var instr = CreateNonTerminal("instr"); var sigArgs0 = CreateNonTerminal("sigArgs0"); var sigArgs1 = CreateNonTerminal("sigArgs1"); var sigArg = CreateNonTerminal("sigArg"); var name1 = CreateNonTerminal("name1"); var className = CreateNonTerminal("className"); var slashedName = CreateNonTerminal("slashedName"); var typeSpec = CreateNonTerminal("typeSpec"); var callConv = CreateNonTerminal("callConv"); var callKind = CreateNonTerminal("callKind"); var nativeType = CreateNonTerminal("nativeType"); var type = CreateNonTerminal("type"); var bounds1 = CreateNonTerminal("bounds1"); var bound = CreateNonTerminal("bound"); var labels = CreateNonTerminal("labels"); var id = CreateNonTerminal("id"); var int16s = CreateNonTerminal("int16s"); var int32 = CreateNonTerminal("int32"); var int64 = CreateNonTerminal("int64"); var float64 = CreateNonTerminal("float64"); var secDecl = CreateNonTerminal("secDecl"); var psetHead = CreateNonTerminal("psetHead"); var nameValPairs = CreateNonTerminal("nameValPairs"); var nameValPair = CreateNonTerminal("nameValPair"); var truefalse = CreateNonTerminal("truefalse"); var caValue = CreateNonTerminal("caValue"); var secAction = CreateNonTerminal("secAction"); var extSourceSpec = CreateNonTerminal("extSourceSpec"); var fileDecl = CreateNonTerminal("fileDecl"); var hashHead = CreateNonTerminal("hashHead"); var assemblyHead = CreateNonTerminal("assemblyHead"); var asmAttr = CreateNonTerminal("asmAttr"); var assemblyDecls = CreateNonTerminal("assemblyDecls"); var assemblyDecl = CreateNonTerminal("assemblyDecl"); var asmOrRefDecl = CreateNonTerminal("asmOrRefDecl"); var publicKeyHead = CreateNonTerminal("publicKeyHead"); var publicKeyTokenHead = CreateNonTerminal("publicKeyTokenHead"); var localeHead = CreateNonTerminal("localeHead"); var assemblyRefHead = CreateNonTerminal("assemblyRefHead"); var assemblyRefDecls = CreateNonTerminal("assemblyRefDecls"); var assemblyRefDecl = CreateNonTerminal("assemblyRefDecl"); var comtypeHead = CreateNonTerminal("comtypeHead"); var exportHead = CreateNonTerminal("exportHead"); var comtypeDecls = CreateNonTerminal("comtypeDecls"); var manifestResHead = CreateNonTerminal("manifestResHead"); var manresAttr = CreateNonTerminal("manresAttr"); var manifestResDecls = CreateNonTerminal("manifestResDecls"); var manifestResDecl = CreateNonTerminal("manifestResDecl"); // instructions var INSTR_NONE = CreateNonTerminal("INSTR_NONE"); var INSTR_VAR = CreateNonTerminal("INSTR_VAR"); var INSTR_I = CreateNonTerminal("INSTR_I"); var INSTR_I8 = CreateNonTerminal("INSTR_I8"); var INSTR_R = CreateNonTerminal("INSTR_R"); var INSTR_BRTARGET = CreateNonTerminal("INSTR_BRTARGET"); var INSTR_METHOD = CreateNonTerminal("INSTR_METHOD"); var INSTR_FIELD = CreateNonTerminal("INSTR_FIELD"); var INSTR_TYPE = CreateNonTerminal("INSTR_TYPE"); var INSTR_STRING = CreateNonTerminal("INSTR_STRING"); var INSTR_SIG = CreateNonTerminal("INSTR_SIG"); var INSTR_RVA = CreateNonTerminal("INSTR_RVA"); var INSTR_SWITCH = CreateNonTerminal("INSTR_SWITCH"); var INSTR_PHI = CreateNonTerminal("INSTR_PHI"); var INSTR_TOK = CreateNonTerminal("INSTR_TOK"); INSTR_NONE.Rule = _("add") | ___("add.ovf") | ___("add.ovf.un") | _("and") | _("arglist") | _("break") | _("ceq") | _("cgt") | ___("cgt.un") | _("ckfinite") | _("clt") | ___("clt.un") | ___("conv.i") | ___("conv.i1") | ___("conv.i2") | ___("conv.i4") | ___("conv.i8") | ___("conv.ovf.i") | ___("conv.ovf.i.un") | ___("conv.ovf.i1") | ___("conv.ovf.i1.un") | ___("conv.ovf.i2") | ___("conv.ovf.i2.un") | ___("conv.ovf.i4") | ___("conv.ovf.i4.un") | ___("conv.ovf.i8") | ___("conv.ovf.i8.un") | ___("conv.ovf.u") | ___("conv.ovf.u.un") | ___("conv.ovf.u1") | ___("conv.ovf.u1.un") | ___("conv.ovf.u2") | ___("conv.ovf.u2.un") | ___("conv.ovf.u4") | ___("conv.ovf.u4.un") | ___("conv.ovf.u8") | ___("conv.ovf.u8.un") | ___("conv.r.un") | ___("conv.r4") | ___("conv.r8") | ___("conv.u") | ___("conv.u1") | ___("conv.u2") | ___("conv.u4") | ___("conv.u8") | _("cpblk") | _("div") | ___("div.un") | _("dup") | _("endfault") | _("endfilter") | _("endfinally") | _("initblk") | ___("ldarg.0") | ___("ldarg.1") | ___("ldarg.2") | ___("ldarg.3") | ___("ldc.i4.0") | ___("ldc.i4.1") | ___("ldc.i4.2") | ___("ldc.i4.3") | ___("ldc.i4.4") | ___("ldc.i4.5") | ___("ldc.i4.6") | ___("ldc.i4.7") | ___("ldc.i4.8") | ___("ldc.i4.M1") | ___("ldc.i4.m1") | // DOCS: non present in ECMA grammar ___("ldelem.i") | ___("ldelem.i1") | ___("ldelem.i2") | ___("ldelem.i4") | ___("ldelem.i8") | ___("ldelem.r4") | ___("ldelem.r8") | ___("ldelem.ref") | ___("ldelem.u1") | ___("ldelem.u2") | ___("ldelem.u4") | ___("ldind.i") | ___("ldind.i1") | ___("ldind.i2") | ___("ldind.i4") | ___("ldind.i8") | ___("ldind.r4") | ___("ldind.r8") | ___("ldind.ref") | ___("ldind.u1") | ___("ldind.u2") | ___("ldind.u4") | _("ldlen") | ___("ldloc.0") | ___("ldloc.1") | ___("ldloc.2") | ___("ldloc.3") | _("ldnull") | _("localloc") | _("mul") | ___("mul.ovf") | ___("mul.ovf.un") | _("neg") | _("nop") | _("not") | _("or") | _("pop") | _("refanytype") | _("rem") | ___("rem.un") | _("ret") | _("rethrow") | _("shl") | _("shr") | ___("shr.un") | ___("stelem.i") | ___("stelem.i1") | ___("stelem.i2") | ___("stelem.i4") | ___("stelem.i8") | ___("stelem.r4") | ___("stelem.r8") | ___("stelem.ref") | ___("stind.i") | ___("stind.i1") | ___("stind.i2") | ___("stind.i4") | ___("stind.i8") | ___("stind.r4") | ___("stind.r8") | ___("stind.ref") | ___("stloc.0") | ___("stloc.1") | ___("stloc.2") | ___("stloc.3") | _("sub") | ___("sub.ovf") | ___("sub.ovf.un") | _("tail.") | _("throw") | _("volatile.") | _("xor"); INSTR_VAR.Rule = _("ladrg") | ___("ldarg.s") | _("ldarga") | ___("ldarga.s") | _("ldloc") | ___("ldloc.s") | _("ldloca") | ___("ldloca.s") | _("starg") | ___("starg.s") | _("stloc") | ___("stloc.s"); INSTR_I.Rule = ___("ldc.i4") | ___("ldc.i4.s") | _("unaligned."); INSTR_I8.Rule = ___("ldc.i8"); INSTR_R.Rule = ___("ldc.r4") | ___("ldc.r8"); INSTR_BRTARGET.Rule = _("beq") | ___("beq.s") | _("bge") | ___("bge.s") | ___("bge.un") | ___("bge.un.s") | _("bgt") | ___("bgt.s") | ___("bgt.un") | ___("bgt.un.s") | _("ble") | ___("ble.s") | ___("ble.un") | ___("ble.un.s") | _("blt") | ___("blt.s") | ___("blt.un") | ___("blt.un.s") | ___("bne.un") | ___("bne.un.s") | _("br") | ___("br.s") | _("brfalse") | ___("brfalse.s") | _("brtrue") | ___("brtrue.s") | _("leave") | ___("leave.s"); INSTR_METHOD.Rule = _("call") | _("callvirt") | _("jmp") | _("ldftn") | _("ldvirtftn") | _("newobj"); INSTR_FIELD.Rule = _("ldfld") | _("ldflda") | _("ldsfld") | _("ldsflda") | _("stfld") | _("stsfld"); INSTR_TYPE.Rule = _("box") | _("castclass") | _("cpobj") | _("initobj") | _("isinst") | _("ldelem") | // DOCS: non-present in ECMA grammar _("ldelema") | _("ldobj") | _("mkrefany") | _("newarr") | _("refanyval") | _("sizeof") | _("stelem") | // DOCS: non-present in ECMA grammar _("stobj") | _("unbox") | ___("unbox.any"); // DOCS: non-present in ECMA grammar INSTR_STRING.Rule = _("ldstr"); INSTR_SIG.Rule = _("TODO: INSTR_SIG"); INSTR_RVA.Rule = _("TODO: INSTR_RVA"); INSTR_SWITCH.Rule = _("switch"); INSTR_PHI.Rule = _("TODO: INSTR_PHI"); INSTR_TOK.Rule = _("ldtoken"); // rules Root = decls; decls.Rule = Empty | decls + decl; decl.Rule = classHead + _("{") + classDecls + _("}") | nameSpaceHead + _("{") + decls + _("}") | methodHead + methodDecls + _("}") | fieldDecl | dataDecl | vtableDecl | vtfixupDecl | extSourceSpec | fileDecl | assemblyHead + _("{") + assemblyDecls + _("}") | assemblyRefHead + _("{") + assemblyRefDecls + _("}") | comtypeHead + _("{") + comtypeDecls + _("}") | manifestResHead + _("{") + manifestResDecls + _("}") | moduleHead | secDecl | customAttrDecl | _(".subsystem") + int32 | _(".corflags") + int32 | _(".file") + _("alignment") + int32 | _(".imagebase") + int64 | languageDecl | _(".stackreserve") + int64; // DOCS: not present in ECMA grammar compQstring.Rule = QSTRING | compQstring + _("+") + QSTRING; // TODO - languageDecl languageDecl.Rule = _("TODO: languageDecl"); customAttrDecl.Rule = _(".custom") + customType | _(".custom") + customType + _("=") + compQstring | customHead + bytes + _(")") | _(".custom") + _("(") + ownerType + _(")") + customType | _(".custom") + _("(") + ownerType + _(")") + customType + _("=") + compQstring | customHeadWithOwner + bytes + _(")"); moduleHead.Rule = _(".module") | _(".module") + name1 | _(".module") + _("extern") + name1; // TODO - vtfixupDecl vtfixupDecl.Rule = _("TODO: vtfixupDecl"); // TODO - vtableDecl vtableDecl.Rule = _("TODO: vtableDecl"); // TODO - nameSpaceHead nameSpaceHead.Rule = _("TODO: nameSpaceHead"); classHead.Rule = _(".class") + classAttr + id + extendsClause + implClause | _(".class") + classAttr + name1 + extendsClause + implClause; // DOCS: not present in ECMA grammar classAttr.Rule = Empty | classAttr + _("public") | classAttr + _("private") | classAttr + _("value") | classAttr + _("enum") | classAttr + _("interface") | classAttr + _("sealed") | classAttr + _("abstract") | classAttr + _("auto") | classAttr + _("sequential") | classAttr + _("explicit") | classAttr + _("ansi") | classAttr + _("unicode") | classAttr + _("autochar") | classAttr + _("import") | classAttr + _("serializable") | classAttr + _("nested") + _("public") | classAttr + _("nested") + _("private") | classAttr + _("nested") + _("family") | classAttr + _("nested") + _("assembly") | classAttr + _("nested") + _("famandassem") | classAttr + _("nested") + _("famorassem") | classAttr + _("beforefieldinit") | classAttr + _("specialname") | classAttr + _("rtspecialname"); extendsClause.Rule = Empty | _("extends") + className; implClause.Rule = Empty | _("implements") + classNames; classNames.Rule = className + _(",") + className | className; classDecls.Rule = Empty | classDecls + classDecl; classDecl.Rule = methodHead + methodDecls + _("}") | classHead + _("{") + classDecls + _("}") | eventHead + _("{") + eventDecls + _("}") | propHead + _("{") + propDecls + _("}") | fieldDecl | dataDecl | secDecl | extSourceSpec | customAttrDecl | _(".size") + int32 | _(".pack") + int32 | exportHead + _("{") + comtypeDecls + _("}") | _(".override") + typeSpec + _("::") + methodName + _("with") + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") | languageDecl; fieldDecl.Rule = _(".field") + repeatOpt + fieldAttr + type + id + atOpt + initOpt; atOpt.Rule = Empty | _("at") + id; initOpt.Rule = Empty | _("=") + fieldInit; repeatOpt.Rule = Empty | _("[") + int32 + _("]"); customHead.Rule = _(".custom") + customType + _("=") + _("("); customHeadWithOwner.Rule = _(".custom") + _("(") + ownerType + _(")") + customType + _("=") + _("("); memberRef.Rule = methodSpec + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") | methodSpec + callConv + type + methodName + _("(") + sigArgs0 + _(")") | _("field") + type + typeSpec + _("::") + id | _("field") + type + id; customType.Rule = callConv + type + typeSpec + _("::") + _(".ctor") + _("(") + sigArgs0 + _(")") | callConv + type + _(".ctor") + _("(") + sigArgs0 + _(")"); ownerType.Rule = typeSpec | memberRef; // TODO - eventHead eventHead.Rule = _("TODO: eventHead"); // TODO - eventDecls eventDecls.Rule = _("TODO: eventDecls"); // TODO - propHead propHead.Rule = _("TODO: propHead"); // TODO - propDecls propDecls.Rule = _("TODO: propDecls"); methodHeadPart1.Rule = _(".method"); methodHead.Rule = methodHeadPart1 + methAttr + callConv + paramAttr + type + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{") | methodHeadPart1 + methAttr + callConv + paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{"); methAttr.Rule = Empty | methAttr + _("static") | methAttr + _("public") | methAttr + _("private") | methAttr + _("family") | methAttr + _("final") | methAttr + _("specialname") | methAttr + _("virtual") | methAttr + _("abstract") | methAttr + _("assembly") | methAttr + _("famandassem") | methAttr + _("famorassem") | methAttr + _("privatescope") | methAttr + _("hidebysig") | methAttr + _("newslot") | methAttr + _("rtspecialname") | methAttr + _("unmanagedexp") | methAttr + _("reqsecobj") | methAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") | methAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") | methAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")"); // TODO - pinvAttr pinvAttr.Rule = _("TODO: pinvAttr"); methodName.Rule = _(".ctor") | _(".cctor") | name1; fieldAttr.Rule = Empty | fieldAttr + _("static") | fieldAttr + _("public") | fieldAttr + _("private") | fieldAttr + _("family") | fieldAttr + _("initonly") | fieldAttr + _("rtspecialname") | fieldAttr + _("specialname") | fieldAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") | fieldAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") | fieldAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")") | fieldAttr + _("marshal") + _("(") + nativeType + _(")") | fieldAttr + _("assembly") | fieldAttr + _("famandassem") | fieldAttr + _("famorassem") | fieldAttr + _("privatescope") | fieldAttr + _("literal") | fieldAttr + _("notserialized"); paramAttr.Rule = Empty | paramAttr + _("[") + _("in") + _("]") | paramAttr + _("[") + _("out") + _("]") | paramAttr + _("[") + _("opt") + _("]") | paramAttr + _("[") + int32 + _("]"); implAttr.Rule = Empty | implAttr + _("native") | implAttr + _("cil") | implAttr + _("optil") | implAttr + _("managed") | implAttr + _("unmanaged") | implAttr + _("forwardref") | implAttr + _("preservesig") | implAttr + _("runtime") | implAttr + _("internalcall") | implAttr + _("synchronized") | implAttr + _("noinlining"); localsHead.Rule = _(".locals"); methodDecl.Rule = _(".emitbyte") + int32 | sehBlock | _(".maxstack") + int32 | localsHead + _("(") + sigArgs0 + _(")") | localsHead + _("init") + _("(") + sigArgs0 + _(")") | _(".entrypoint") | _(".zeroinit") | dataDecl | instr | id + _(":") | secDecl | extSourceSpec | languageDecl | customAttrDecl | _(".export") + _("[") + int32 + _("]") | _(".export") + _("[") + int32 + _("]") + _("as") + id | _(".vtentry") + int32 + _(":") + int32 | _(".override") + typeSpec + _("::") + methodName | scopeBlock | _(".param") + _("[") + int32 + _("]") + initOpt; // TODO - scopeBlock scopeBlock.Rule = _("TODO: scopeBlock"); // TODO - sehBlock sehBlock.Rule = _("TODO: sehBlock"); methodDecls.Rule = Empty | methodDecls + methodDecl; dataDecl.Rule = ddHead + ddBody; ddHead.Rule = _(".data") + tls + id + _("=") | _(".data") + tls; tls.Rule = Empty | _("tls") | _("cil"); // DOCS: non-present in ECMA grammar ddBody.Rule = _("{") + ddItemList + _("}") | ddItem; ddItemList.Rule = ddItem + _(",") + ddItemList | ddItem; ddItemCount.Rule = Empty | _("[") + int32 + _("]"); ddItem.Rule = _("char") + _("*") + _("(") + compQstring + _(")") | _("&") + _("(") + id + _(")") | bytearrayhead + bytes + _(")") | _("float32") + _("(") + float64 + _(")") + ddItemCount | _("float64") + _("(") + float64 + _(")") + ddItemCount | _("int64") + _("(") + int64 + _(")") + ddItemCount | _("int32") + _("(") + int32 + _(")") + ddItemCount | _("int16") + _("(") + int32 + _(")") + ddItemCount | _("int8") + _("(") + int32 + _(")") + ddItemCount | _("float32") + ddItemCount | _("float64") + ddItemCount | _("int64") + ddItemCount | _("int32") + ddItemCount | _("int16") + ddItemCount | _("int8") + ddItemCount; fieldInit.Rule = _("float32") + _("(") + float64 + _(")") | _("float64") + _("(") + float64 + _(")") | _("float32") + _("(") + int64 + _(")") | _("float64") + _("(") + int64 + _(")") | _("int64") + _("(") + int64 + _(")") | _("int32") + _("(") + int64 + _(")") | _("int16") + _("(") + int64 + _(")") | _("char") + _("(") + int64 + _(")") | _("int8") + _("(") + int64 + _(")") | _("uint8") + _("(") + int64 + _(")") | // DOCS: non-present in ECMA grammar _("bool") + _("(") + truefalse + _(")") | compQstring | bytearrayhead + bytes + _(")") | _("nullref"); bytearrayhead.Rule = _("bytearray") + _("("); bytes.Rule = Empty | hexbytes; hexbytes.Rule = HEXBYTE | hexbytes + HEXBYTE; // TODO - instr_r_head instr_r_head.Rule = _("TODO: instr_r_head"); instr_tok_head.Rule = INSTR_TOK; // TODO - methodSpec methodSpec.Rule = _("TODO: methodSpec"); instr.Rule = INSTR_NONE | INSTR_VAR + int32 | INSTR_VAR + id | INSTR_I + int32 | INSTR_I8 + int64 | INSTR_R + float64 | INSTR_R + int64 | instr_r_head + bytes + _(")") | INSTR_BRTARGET + int32 | INSTR_BRTARGET + id | INSTR_METHOD + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") | INSTR_METHOD + callConv + type + methodName + _("(") + sigArgs0 + _(")") | INSTR_FIELD + type + typeSpec + _("::") + id | INSTR_FIELD + type + id | INSTR_TYPE + typeSpec | INSTR_STRING + compQstring | INSTR_STRING + bytearrayhead + bytes + _(")") | INSTR_SIG + callConv + type + _("(") + sigArgs0 + _(")") | INSTR_RVA + id | INSTR_RVA + int32 | instr_tok_head + ownerType | INSTR_SWITCH + _("(") + labels + _(")") | INSTR_PHI + int16s; sigArgs0.Rule = Empty | sigArgs1; sigArgs1.Rule = sigArg | sigArgs1 + _(",") + sigArg; sigArg.Rule = _("...") | paramAttr + type | paramAttr + type + id | paramAttr + type + _("marshal") + _("(") + nativeType + _(")") | paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + id; name1.Rule = id | DOTTEDNAME | name1 + _(".") + name1; className.Rule = _("[") + name1 + _("]") + slashedName | _("[") + _(".module") + name1 + _("]") + slashedName | slashedName; slashedName.Rule = name1 | slashedName + _("/") + name1; typeSpec.Rule = className | _("[") + name1 + _("]") | _("[") + _(".module") + name1 + _("]") | type; callConv.Rule = _("instance") + callConv | _("explicit") + callConv | callKind; callKind.Rule = Empty | _("default") | _("vararg") | _("unmanaged") + _("cdecl") | _("unmanaged") + _("stdcall") | _("unmanaged") + _("thiscall") | _("unmanaged") + _("fastcall"); // TODO - nativeType nativeType.Rule = _("TODO: nativeType"); type.Rule = _("class") + className | _("object") | _("string") | _("value") + _("class") + className | _("valuetype") + className | type + _("[") + _("]") | type + ("[") + bounds1 + _("]") | type + _("value") + _("[") + int32 + _("]") | type + _("&") | type + _("*") | type + _("pinned") | type + _("modreq") + _("(") + className + _(")") | type + _("modopt") + _("(") + className + _(")") | _("!") + int32 | methodSpec + callConv + type + _("*") + _("(") + sigArgs0 + _(")") | _("typedref") | _("char") | _("void") | _("bool") | _("int8") | _("int16") | _("int32") | _("int64") | _("float32") | _("float64") | _("unsigned") + _("int8") | _("unsigned") + _("int16") | _("unsigned") + _("int32") | _("unsigned") + _("int64") | _("native") + _("int") | _("native") + _("unsigned") + _("int") | _("native") + _("float") | _("uint8") | // DOCS: not present in ECMA grammar _("uint16") | // DOCS: not present in ECMA grammar _("uint32") | // DOCS: not present in ECMA grammar _("uint64"); // DOCS: not present in ECMA grammar bounds1.Rule = bound | bounds1 + _(",") + bound; bound.Rule = Empty | _("...") | int32 | int32 + _("...") + int32 | int32 + _("..."); labels.Rule = Empty | id + _(",") + labels | int32 + _(",") + labels | id | int32; id.Rule = ID | SQSTRING; // TODO - int16s int16s.Rule = _("TODO: int16s"); int32.Rule = INT32; int64.Rule = INT64; float64.Rule = FLOAT64 | _("float32") + _("(") + int32 + _(")") | _("float64") + _("(") + int64 + _(")"); secDecl.Rule = _(".permission") + secAction + typeSpec + _("(") + nameValPairs + _(")") | _(".permission") + secAction + typeSpec | psetHead + bytes + _(")") | _(".permissionset") + secAction + _("=") + _("{") + nameValPairs + _("}"); // DOCS: non-present in ECMA script psetHead.Rule = _(".permissionset") + secAction + _("=") + _("("); nameValPairs.Rule = nameValPair | nameValPair + _(",") + nameValPairs; nameValPair.Rule = compQstring + _("=") + caValue | className + _("=") + caValue; // DOCS: non-present in ECMA script truefalse.Rule = _("true") | _("false"); caValue.Rule = truefalse | int32 | _("int32") + ("(") + int32 + _(")") | compQstring | className + _("(") + _("int8") + _(":") + int32 + _(")") | className + _("(") + _("int16") + _(":") + int32 + _(")") | className + _("(") + _("int32") + _(":") + int32 + _(")") | className + _("(") + int32 + _(")") | _("{") + _("property") + _("bool") + SQSTRING + _("=") + _("bool") + _("(") + _("true") + _(")") + _("}"); // DOCS: non-present in ECMA script secAction.Rule = _("request") | _("demand") | _("assert") | _("deny") | _("permitonly") | _("linkcheck") | _("inheritcheck") | _("reqmin") | _("reqopt") | _("reqrefuse") | _("prejitgrant") | _("prejitdeny") | _("noncasdemand") | _("noncaslinkdemand") | _("noncasinheritance"); // TODO - extSourceSpec extSourceSpec.Rule = _("TODO: extSourceSpec"); // TODO - fileDecl fileDecl.Rule = _("TODO: fileDecl"); // TODO - hashHead hashHead.Rule = _("TODO: hashHead"); assemblyHead.Rule = _(".assembly") + asmAttr + name1; asmAttr.Rule = Empty | asmAttr + _("noappdomain") | asmAttr + _("noprocess") | asmAttr + _("nomachine"); assemblyDecls.Rule = Empty | assemblyDecls + assemblyDecl; assemblyDecl.Rule = _(".hash") + _("algorithm") + int32 | secDecl | asmOrRefDecl; asmOrRefDecl.Rule = publicKeyHead + bytes + _(")") | _(".ver") + int32 + _(":") + int32 + _(":") + int32 + _(":") + int32 | _(".locale") + compQstring | localeHead + bytes + _(")") | customAttrDecl; // TODO - publicKeyHead publicKeyHead.Rule = _("TODO: publicKeyHead"); publicKeyTokenHead.Rule = _(".publickeytoken") + _("=") + _("("); // TODO - localeHead localeHead.Rule = _("TODO: localeHead"); assemblyRefHead.Rule = _(".assembly") + _("extern") + name1 | _(".assembly") + _("extern") + name1 + _("as") + name1; assemblyRefDecls.Rule = Empty | assemblyRefDecls + assemblyRefDecl; assemblyRefDecl.Rule = hashHead + bytes + _(")") | asmOrRefDecl | publicKeyTokenHead + bytes + _(")"); // TODO - comtypeHead comtypeHead.Rule = _("TODO: comtypeHead"); // TODO - exportHead exportHead.Rule = _("TODO: exportHead"); // TODO - comtypeDecls comtypeDecls.Rule = _("TODO: comtypeDecls"); manifestResHead.Rule = _(".mresource") + manresAttr + name1; manresAttr.Rule = Empty | manresAttr + _("public") | manresAttr + _("private"); manifestResDecls.Rule = Empty | manifestResDecls + manifestResDecl; manifestResDecl.Rule = _(".file") + name1 + _("at") + int32 | _(".assembly") + _("extern") + name1 | customAttrDecl; }
public Gramatica() : base(caseSensitive: false) { #region ER /*NUMERO ENTERO*/ RegexBasedTerminal numentero = new RegexBasedTerminal("Int", "[0-9]+"); /*NUMERO DECIMAL*/ RegexBasedTerminal numdecimal = new RegexBasedTerminal("double", "[0-9]+[.][0-9]+"); /*IDENTIFICADOR*/ IdentifierTerminal id = new IdentifierTerminal("id"); /*STRING*/ //CommentTerminal cadena = new CommentTerminal("String", "\"", ".", "\""); StringLiteral cadena = TerminalFactory.CreateCSharpString("String"); /*STRING*/ CommentTerminal importaciones = new CommentTerminal("String", "\"", ".[.].", "\""); /*CHAR*/ StringLiteral caracter = TerminalFactory.CreateCSharpChar("Char"); CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n", "\r\n"); CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/*", "*/"); #endregion //--------------------------------------RESERVADAS------------------------------------------------ #region Terminal //TIPO DATO var rint = ToTerm("Int"); var rdouble = ToTerm("Double"); var rstring = ToTerm("String"); var rchar = ToTerm("Char"); var rbool = ToTerm("Boolean"); var rvoid = ToTerm("Void"); //PALABRAS RESERVADAS var importar = ToTerm("Import"); var retornar = ToTerm("Return"); var rprint = ToTerm("Print"); var rmain = ToTerm("Main"); var comparar = ToTerm("CompareTo"); var rGetUser = ToTerm("GetUser"); var rbreak = ToTerm("Break"); //OPERACIONES ARITMETICAS var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var dividir = ToTerm("/"); var modulo = ToTerm("%"); var potencia = ToTerm("^"); //OPERACIONES RELACIONALES var igual2 = ToTerm("=="); var diferente = ToTerm("!="); var menor = ToTerm("<"); var mayor = ToTerm(">"); var menorigual = ToTerm("<="); var mayorigual = ToTerm(">="); //OPERACIONES LOGICAS var rand = ToTerm("&&"); var ror = ToTerm("||"); var rxor = ToTerm("|&"); var rnot = ToTerm("!"); //OPERACIONES ESPECIALES var incremento = ToTerm("++"); var decremento = ToTerm("--"); var masigual = ToTerm("+="); var menosigual = ToTerm("-="); //SENTENCIAS var rif = ToTerm("If"); var relse = ToTerm("Else"); var relseif = ToTerm("Else if"); var rswitch = ToTerm("Switch"); var rcase = ToTerm("Case"); var defecto = ToTerm("Default"); var rfor = ToTerm("For"); var rdo = ToTerm("Do"); var rwhile = ToTerm("While"); //BOOLEANOS var rtrue = ToTerm("true"); var rfalse = ToTerm("false"); //VARIOS var igual1 = ToTerm("="); var dospuntos = ToTerm(":"); var coma = ToTerm(","); var fin = ToTerm(";"); var apar = ToTerm("("); var cpar = ToTerm(")"); var alla = ToTerm("{"); var clla = ToTerm("}"); var acor = ToTerm("["); var ccor = ToTerm("]"); #endregion #region No terminales NonTerminal INICIO = new NonTerminal("INICIO"); NonTerminal IMPORTE = new NonTerminal("IMPORTE"); NonTerminal IMPORTES = new NonTerminal("IMPORTES"); NonTerminal CUERPO = new NonTerminal("CUERPO"); NonTerminal CONTENIDOGENERAL = new NonTerminal("CONTENIDOGENERAL"); NonTerminal ASIGNA = new NonTerminal("ASIGNA"); NonTerminal DECLARA = new NonTerminal("DECLARA"); NonTerminal LISTA_IDS = new NonTerminal("LISTA_IDS"); NonTerminal TIPODATO = new NonTerminal("TIPODATO"); NonTerminal VALOR = new NonTerminal("VALOR"); NonTerminal EXPRESION = new NonTerminal("EXPRESION"); NonTerminal METODO = new NonTerminal("METODO"); NonTerminal LISTAPARAMETROS = new NonTerminal("LISTAPARAMETROS"); NonTerminal CUERPOMETODO = new NonTerminal("CUERPOMETODO"); NonTerminal LLAMADAMETODO = new NonTerminal("LLAMADAMETODO"); NonTerminal IMPRIMIR = new NonTerminal("IMPRIMIR"); NonTerminal PARAMETROSLLAMADOS = new NonTerminal("PARAMETROSLLAMADOS"); NonTerminal OPCIONAL = new NonTerminal("OPCIONAL"); NonTerminal SENTENCIARETURN = new NonTerminal("SENTENCIARETURN"); NonTerminal SENTENCIAWHILE = new NonTerminal("SENTENCIAWHILE"); NonTerminal SENTENCIADOWHILE = new NonTerminal("SENTENCIADOWHILE"); NonTerminal SENTENCIASWITCH = new NonTerminal("SENTENCIASWITCH"); NonTerminal CASO = new NonTerminal("CASO"); NonTerminal CASOS = new NonTerminal("CASOS"); NonTerminal DEFECTO = new NonTerminal("DEFECTO"); NonTerminal CONTENIDOSWITCH = new NonTerminal("CONTENIDOSWITCH"); NonTerminal LISTA_ARRAY = new NonTerminal(" LISTA_ARRAY"); NonTerminal CONDICION = new NonTerminal("CONDICION"); NonTerminal CONDICIONPRIMA = new NonTerminal("CONDICIONPRIMA"); NonTerminal CONDICIONAL = new NonTerminal("CONDICIONAL"); NonTerminal LOGICOS = new NonTerminal("LOGICOS"); NonTerminal RELACIONAL = new NonTerminal("RELACIONAL"); NonTerminal SENTENCIAIF = new NonTerminal("SENTENCIAIF"); NonTerminal SENTENCIAIFAUX = new NonTerminal("SENTENCIAIFAUX"); NonTerminal SENTPRIMA = new NonTerminal("SENTPRIMA"); NonTerminal SENTENCIAELSEIF = new NonTerminal("SENTENCIAELSEIF"); NonTerminal SENTENCIA = new NonTerminal("SENTENCIA"); NonTerminal SENTENCIAS = new NonTerminal("SENTENCIAS"); NonTerminal SENTENCIAFOR = new NonTerminal("SENTENCIAFOR"); NonTerminal ASIGNACION_CORTO = new NonTerminal("ASIGNACION_CORTO"); NonTerminal C = new NonTerminal("C"); NonTerminal D = new NonTerminal("D"); NonTerminal OPMATEMATICA = new NonTerminal("OPMATEMATICA"); NonTerminal OP = new NonTerminal("OP"); NonTerminal E = new NonTerminal("E"); NonTerminal L = new NonTerminal("L"); NonTerminal R = new NonTerminal("R"); NonTerminal INVOCAR = new NonTerminal("INVOCAR"); NonTerminal LIST_ATRIBUTO = new NonTerminal("LIST_ATRIBUTO"); NonTerminal ACCESO_VECTOR = new NonTerminal("ACCESO_VECTOR"); NonTerminal ATRIBUTO = new NonTerminal("ATRIBUTO"); #endregion #region Gramatica INICIO.Rule = IMPORTES + CUERPO; IMPORTES.Rule = IMPORTES + IMPORTE | IMPORTE | Empty; IMPORTE.Rule = importar + importaciones + fin; CUERPO.Rule = CUERPO + CONTENIDOGENERAL | CONTENIDOGENERAL; CONTENIDOGENERAL.Rule = DECLARA | ASIGNA | METODO; DECLARA.Rule = id + dospuntos + TIPODATO + VALOR | LISTA_IDS + dospuntos + TIPODATO + VALOR | id + dospuntos + TIPODATO + acor + E + ccor + VALOR; ASIGNA.Rule = id + igual1 + C + fin | id + igual1 + alla + LISTA_ARRAY + clla + fin | id + acor + E + ccor + igual1 + C + fin | id + acor + E + ccor + igual1 + id + acor + E + ccor + fin; VALOR.Rule = igual1 + C + fin | fin | alla + LISTA_ARRAY + clla + fin; LISTA_IDS.Rule = LISTA_IDS + coma + id | id; LISTA_ARRAY.Rule = LISTA_ARRAY + coma + C | C; TIPODATO.Rule = rint | rdouble | rstring | rchar | rbool | rvoid; METODO.Rule = id + dospuntos + TIPODATO + apar + LISTAPARAMETROS + cpar + alla + SENTENCIAS + clla | rmain + dospuntos + TIPODATO + apar + LISTAPARAMETROS + cpar + alla + SENTENCIAS + clla; LISTAPARAMETROS.Rule = LISTAPARAMETROS + coma + id + dospuntos + TIPODATO | id + dospuntos + TIPODATO | Empty; SENTENCIAS.Rule = SENTENCIAS + SENTENCIA | SENTENCIA; SENTENCIA.Rule = ASIGNA | DECLARA | LLAMADAMETODO + fin | IMPRIMIR | SENTENCIAFOR | SENTENCIAIF | SENTENCIARETURN | SENTENCIAWHILE | SENTENCIADOWHILE | SENTENCIASWITCH | Empty; //---------LLAMADA A METODO LLAMADAMETODO.Rule = id + apar + PARAMETROSLLAMADOS + cpar | id + apar + cpar; PARAMETROSLLAMADOS.Rule = PARAMETROSLLAMADOS + coma + C | C; //---------PRINT IMPRIMIR.Rule = rprint + apar + C + cpar; //---------RETURN SENTENCIARETURN.Rule = C + fin | fin; //---------FOR //falta contenido SENTENCIAFOR.Rule = rfor + apar + id + dospuntos + TIPODATO + igual1 + E + fin + C + fin + OP + cpar + alla + SENTENCIAS + clla; //---------IF SENTENCIAIF.Rule = rif + SENTENCIAIFAUX; SENTENCIAIFAUX.Rule = apar + C + cpar + alla + SENTENCIAS + clla + SENTENCIAELSEIF; SENTENCIAIFAUX.ErrorRule = SyntaxError + "}"; SENTENCIAELSEIF.Rule = relse + SENTPRIMA | Empty; SENTENCIAELSEIF.ErrorRule = SyntaxError + "}"; SENTPRIMA.Rule = rif + SENTENCIAIFAUX | alla + SENTENCIAS + clla; //---------WHILE SENTENCIAWHILE.Rule = rwhile + apar + C + cpar + alla + SENTENCIAS + clla; SENTENCIAWHILE.ErrorRule = SyntaxError + "}"; //---------DO WHILE SENTENCIADOWHILE.Rule = rdo + alla + SENTENCIAS + clla + rwhile + apar + C + cpar + fin; SENTENCIADOWHILE.ErrorRule = SyntaxError + ";"; ///--------SWITCH SENTENCIASWITCH.Rule = rswitch + apar + E + cpar + alla + SENTENCIAS + clla; SENTENCIASWITCH.ErrorRule = SyntaxError + "}"; CONTENIDOSWITCH.Rule = CASOS + DEFECTO | CASOS | DEFECTO | Empty; CASOS.Rule = CASOS + CASO | CASO; //---FALTA CONTENIDO CASO.Rule = rcase + C + dospuntos + SENTENCIAS + rbreak + fin; //---FALTA CONTENIDO DEFECTO.Rule = defecto + SENTENCIAS + dospuntos; //CONDICION ASIGNACION_CORTO.Rule = id + OP; OP.Rule = incremento | decremento; C.Rule = C + L + C | E + R + E | menos + E | E; R.Rule = igual2 | diferente | menor | mayor | menorigual | mayorigual; L.Rule = ror | rand | rxor | rnot; E.Rule = E + mas + E | E + menos + E | E + por + E | E + dividir + E | E + modulo + E | E + potencia + E | apar + E + cpar | id | numentero | numdecimal | cadena | caracter | rtrue | rfalse; INVOCAR.Rule = id + apar + LIST_ATRIBUTO + cpar | ACCESO_VECTOR; LIST_ATRIBUTO.Rule = LIST_ATRIBUTO + coma + ATRIBUTO | ATRIBUTO | Empty; ATRIBUTO.Rule = E; #endregion #region PREFERENCIAS Root = INICIO; NonGrammarTerminals.Add(comentarioLinea); NonGrammarTerminals.Add(comentarioBloque); MarkPunctuation(";", "(", ")", "{", "}", ":", "=", "[", "]", ","); this.RegisterOperators(1, Associativity.Left, mas, menos); this.RegisterOperators(2, Associativity.Left, por, dividir, modulo); this.RegisterOperators(3, Associativity.Right, potencia); this.RegisterOperators(5, igual2, diferente, menor, mayor, menorigual, mayorigual); this.RegisterOperators(6, Associativity.Left, ror); this.RegisterOperators(7, Associativity.Left, rxor); this.RegisterOperators(8, Associativity.Left, rand); this.RegisterOperators(9, Associativity.Left, diferente); this.RegisterOperators(10, apar, cpar); #endregion }
public ExpressionEvaluatorGrammar() : base(false) { GrammarComments = @"Irony expression evaluator. Case-insensitive. Supports big integers, float data types, variables, assignments, arithmetic operations, augmented assignments (+=, -=), inc/dec (++,--), strings with embedded expressions; bool operations &,&&, |, ||; ternary '?:' operator."; // 1. Terminals var number = new NumberLiteral("number"); //Let's allow big integers (with unlimited number of digits): number.DefaultIntTypes.AddRange(TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt); var identifier = new IdentifierTerminal("identifier"); var comment = new CommentTerminal("comment", "#", "\n", "\r"); //comment must be added to NonGrammarTerminals list; it is not used directly in grammar rules, // so we add it to this list to let Scanner know that it is also a valid terminal. NonGrammarTerminals.Add(comment); var comma = ToTerm(","); //String literal with embedded expressions ------------------------------------------------------------------ var stringLit = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes | StringOptions.IsTemplate); stringLit.AddStartEnd("'", StringOptions.AllowsAllEscapes | StringOptions.IsTemplate); stringLit.AstConfig.NodeType = typeof(StringTemplateNode); var Expr = new NonTerminal("Expr"); //declare it here to use in template definition var templateSettings = new StringTemplateSettings(); //by default set to Ruby-style settings templateSettings.ExpressionRoot = Expr; //this defines how to evaluate expressions inside template SnippetRoots.Add(Expr); stringLit.AstConfig.Data = templateSettings; //-------------------------------------------------------------------------------------------------------- // 2. Non-terminals var Term = new NonTerminal("Term"); var BinExpr = new NonTerminal("BinExpr", typeof(BinaryOperationNode)); var ParExpr = new NonTerminal("ParExpr"); var UnExpr = new NonTerminal("UnExpr", typeof(UnaryOperationNode)); var TernaryIfExpr = new NonTerminal("TernaryIf", typeof(IfNode)); var ArgList = new NonTerminal("ArgList", typeof(ExpressionListNode)); var FunctionCall = new NonTerminal("FunctionCall", typeof(FunctionCallNode)); var MemberAccess = new NonTerminal("MemberAccess", typeof(MemberAccessNode)); var IndexedAccess = new NonTerminal("IndexedAccess", typeof(IndexedAccessNode)); var ObjectRef = new NonTerminal("ObjectRef"); // foo, foo.bar or f['bar'] var UnOp = new NonTerminal("UnOp"); var BinOp = new NonTerminal("BinOp", "operator"); var PrefixIncDec = new NonTerminal("PrefixIncDec", typeof(IncDecNode)); var PostfixIncDec = new NonTerminal("PostfixIncDec", typeof(IncDecNode)); var IncDecOp = new NonTerminal("IncDecOp"); var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssignmentNode)); var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator"); var Statement = new NonTerminal("Statement"); var Program = new NonTerminal("Program", typeof(StatementListNode)); // 3. BNF rules Expr.Rule = Term | UnExpr | BinExpr | PrefixIncDec | PostfixIncDec | TernaryIfExpr; Term.Rule = number | ParExpr | stringLit | FunctionCall | identifier | MemberAccess | IndexedAccess; ParExpr.Rule = "(" + Expr + ")"; UnExpr.Rule = UnOp + Term + ReduceHere(); UnOp.Rule = ToTerm("+") | "-" | "!"; BinExpr.Rule = Expr + BinOp + Expr; BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**" | "==" | "<" | "<=" | ">" | ">=" | "!=" | "&&" | "||" | "&" | "|"; PrefixIncDec.Rule = IncDecOp + identifier; PostfixIncDec.Rule = identifier + PreferShiftHere() + IncDecOp; IncDecOp.Rule = ToTerm("++") | "--"; TernaryIfExpr.Rule = Expr + "?" + Expr + ":" + Expr; MemberAccess.Rule = Expr + PreferShiftHere() + "." + identifier; AssignmentStmt.Rule = ObjectRef + AssignmentOp + Expr; AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/="; Statement.Rule = AssignmentStmt | Expr | Empty; ArgList.Rule = MakeStarRule(ArgList, comma, Expr); FunctionCall.Rule = Expr + PreferShiftHere() + "(" + ArgList + ")"; FunctionCall.NodeCaptionTemplate = "call #{0}(...)"; ObjectRef.Rule = identifier | MemberAccess | IndexedAccess; IndexedAccess.Rule = Expr + PreferShiftHere() + "[" + Expr + "]"; Program.Rule = MakePlusRule(Program, NewLine, Statement); Root = Program; // Set grammar root // 4. Operators precedence RegisterOperators(10, "?"); RegisterOperators(15, "&", "&&", "|", "||"); RegisterOperators(20, "==", "<", "<=", ">", ">=", "!="); RegisterOperators(30, "+", "-"); RegisterOperators(40, "*", "/"); RegisterOperators(50, Associativity.Right, "**"); RegisterOperators(60, "!"); // For precedence to work, we need to take care of one more thing: BinOp. //For BinOp which is or-combination of binary operators, we need to either // 1) mark it transient or 2) set flag TermFlags.InheritPrecedence // We use first option, making it Transient. // 5. Punctuation and transient terms MarkPunctuation("(", ")", "?", ":", "[", "]"); RegisterBracePair("(", ")"); RegisterBracePair("[", "]"); MarkTransient(Term, Expr, Statement, BinOp, UnOp, IncDecOp, AssignmentOp, ParExpr, ObjectRef); // 7. Syntax error reporting MarkNotReported("++", "--"); AddToNoReportGroup("(", "++", "--"); AddToNoReportGroup(NewLine); AddOperatorReportGroup("operator"); AddTermsReportGroup("assignment operator", "=", "+=", "-=", "*=", "/="); //8. Console ConsoleTitle = "Irony Expression Evaluator"; ConsoleGreeting = @"Irony Expression Evaluator Supports variable assignments, arithmetic operators (+, -, *, /), augmented assignments (+=, -=, etc), prefix/postfix operators ++,--, string operations. Supports big integer arithmetics, string operations. Supports strings with embedded expressions : ""name: #{name}"" Press Ctrl-C to exit the program at any time. "; ConsolePrompt = "?"; ConsolePromptMoreInput = "?"; //9. Language flags. // Automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source LanguageFlags = LanguageFlags.NewLineBeforeEOF | LanguageFlags.CreateAst | LanguageFlags.SupportsBigInt; }
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 RIMPRIMIRLN = ToTerm("imprimirln"); 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("="); 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 | RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER | RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER + RELSE + LLAVIZQ + instrucciones + LLAVDER | RIMPRIMIRLN + PARIZQ + expresion_cadena + PARDER + PTCOMA; 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; #endregion #region Preferencias this.Root = ini; #endregion }
public gramatica(tablaErrores tabla, String archivo) : base(caseSensitive: false)//Diferencia entre mayusculas y minusculas { this.tablaErrores = tabla; this.nombreArchivo = archivo; #region ER ////////////////////////////////////////// //------------COMENTARIOS----------------- CommentTerminal comentariobloque = new CommentTerminal("comentariobloque", "$#", "#$"); CommentTerminal comentariolinea = new CommentTerminal("comentariolinea", "$$", "\n", "\r\n"); /*Se ignoran los terminales solo se reconoce*/ NonGrammarTerminals.Add(comentariobloque); NonGrammarTerminals.Add(comentariolinea); ////////////////////////////////////////// //------------OTROS----------------- RegexBasedTerminal valBoolean = new RegexBasedTerminal("valBoolean", "(false|true|verdadero|falso)"); StringLiteral valCaracter = new StringLiteral("valCaracter", "\'"); StringLiteral valCadena = new StringLiteral("valCadena", "\""); var valCadena2 = new StringLiteral("valCadena2", "‘(.)*’"); //RegexBasedTerminal valNumero = new RegexBasedTerminal("numeroValor", "[0-9]+"); NumberLiteral valNumero = new NumberLiteral("valNumero"); var valDecimal = new RegexBasedTerminal("valDecimal", "[0-9]+\\.[0-9]+"); IdentifierTerminal valId = new IdentifierTerminal("valId"); #endregion #region Terminales /* * ============================= * Simbolos * ============================= */ var sMas = ToTerm("+"); var sMenos = ToTerm("-"); var sPor = ToTerm("*"); var sDiv = ToTerm("/"); var sPot = ToTerm("^"); var sMod = ToTerm("%"); var sIgualacion = ToTerm("=="); var sDiferenciacion = ToTerm("!="); var sMenorQue = ToTerm("<"); var sMayorQue = ToTerm(">"); var sMenorIgualQue = ToTerm("<="); var sMayorIgualQue = ToTerm(">="); var sAnd = ToTerm("&&"); var sOr = ToTerm("||"); var sNot = ToTerm("!"); // var sAbreParent = ToTerm("("); var sCierraParent = ToTerm(")"); var sAbreLlave = ToTerm("{"); var sCierraLlave = ToTerm("}"); var sAbreCorchete = ToTerm("["); var sCierraCorchete = ToTerm("]"); var sPunto = ToTerm("."); var sComa = ToTerm(","); var sPuntoComa = ToTerm(";"); var sArroba = ToTerm("@"); var sIgual = ToTerm("="); var sCierraInterrogante = ToTerm("?"); var sDosPuntos = ToTerm(":"); /* * ============================= * Palabras reservadas * ============================= */ var tImport = ToTerm("importar"); var tClase = ToTerm("clase"); var tExtender = ToTerm("extender"); var tPadre = ToTerm("padre"); var tPrincipal = ToTerm("principal"); var tOverride = ToTerm("sobrescribir"); var tNuevo = ToTerm("nuevo"); var tNulo = ToTerm("nulo"); var tVacio = ToTerm("vacio"); var tEste = ToTerm("este"); var tImprimir = ToTerm("imprimir"); var tRetorno = ToTerm("retorno"); var tSi = ToTerm("si"); var tSino = ToTerm("sino"); var tCaso = ToTerm("caso"); var tDe = ToTerm("de"); var tDefecto = ToTerm("defecto"); var tRomper = ToTerm("romper"); var tMientras = ToTerm("mientras"); var tContinuar = ToTerm("continuar"); var tPara = ToTerm("para"); var tHacer = ToTerm("hacer"); var tRepetir = ToTerm("repetir"); var tHasta = ToTerm("hasta"); var tMensaje = ToTerm("mensajes"); var tSubCad = ToTerm("subcad"); var tPosCad = ToTerm("poscad"); var tRandom = ToTerm("random"); var tPi = ToTerm("pi"); var tSqrt = ToTerm("sqrt"); var tTangente = ToTerm("tan"); var tCoseno = ToTerm("cos"); var tSeno = ToTerm("sin"); var tAbs = ToTerm("abs"); var tLog10 = ToTerm("log10"); var tLog = ToTerm("log"); var tPow = ToTerm("pow"); var tMax = ToTerm("max"); var tMin = ToTerm("min"); var tFecha = ToTerm("fecha"); var tAhora = ToTerm("ahora"); var tHoy = ToTerm("hoy"); var tTam = ToTerm("tam"); var tSuper = ToTerm("super"); var tPagina = ToTerm("pagina"); var tTodo = ToTerm("todo"); var tCuadriculo = ToTerm("cuadricula"); var tNativo = ToTerm("_nativo"); var tEscribirArchivo = ToTerm("escribir_archivo"); var tImagen = ToTerm("imagen"); var tVideo = ToTerm("video"); var tAudio = ToTerm("audio"); var tLen = ToTerm("_len"); var tNada = ToTerm("nada"); //tipos var tEntero = ToTerm("entero"); var tCadena = ToTerm("cadena"); var tDecimal = ToTerm("decimal"); var tBooleano = ToTerm("booleano"); var tfecha = ToTerm("fecha"); var tHora = ToTerm("hora"); var tFechaHora = ToTerm("fechahora"); var tPregunta = ToTerm("pregunta"); var tFormulario = ToTerm("formulario"); var tRespuesta = ToTerm("respuesta"); var tMostrar = ToTerm("mostrar"); var tCalcular = ToTerm("calcular"); var tGrupo = ToTerm("grupo"); //visibilidad var tPublico = ToTerm("publico"); var tPrivado = ToTerm("privado"); var tProtegido = ToTerm("protegido"); #endregion #region NoTerminales NonTerminal S = new NonTerminal("S"); NonTerminal IMPORT = new NonTerminal("IMPORT"); NonTerminal LST_IMPORT = new NonTerminal("LST_IMPORT"); NonTerminal LST_CLASE = new NonTerminal("LST_CLASE"); NonTerminal CLASE = new NonTerminal("CLASE"); NonTerminal TIPO = new NonTerminal("TIPO"); NonTerminal EXTENDER = new NonTerminal("EXTENDER"); NonTerminal VISIBILIDAD = new NonTerminal("VISIBILIDAD"); NonTerminal LST_PARAMETROS = new NonTerminal("LST_PARAMETROS"); NonTerminal PARAMETRO = new NonTerminal("PARAMETRO"); NonTerminal LST_VAL = new NonTerminal("LST_VAL"); NonTerminal CP_CLASE = new NonTerminal("CP_CLASE"); NonTerminal CUERPO_CLASE = new NonTerminal("CUERPO_CLASE"); NonTerminal METODO = new NonTerminal("METODO"); NonTerminal SOBRESCRITURA = new NonTerminal("SOBRESCRITURA"); NonTerminal MAIN = new NonTerminal("MAIN"); NonTerminal CONSTRUCTOR = new NonTerminal("CONSTRUCTOR"); NonTerminal FORMULARIO = new NonTerminal("FORMULARIO"); NonTerminal PROCEDIMIENTOS_FORMULARIO = new NonTerminal("PROCEDIMIENTOS_FORMULARIO"); NonTerminal DECLARAR_VARIABLE_GLOBAL = new NonTerminal("DECLARAR_VARIABLE_GLOBAL"); NonTerminal DECLARAR_VARIABLE_SINVISIBI = new NonTerminal("DECLARAR_VARIABLE_SINVISIBI"); NonTerminal VAL = new NonTerminal("VAL"); NonTerminal LST_LLAVES_VAL = new NonTerminal("LST_LLAVES_VAL"); NonTerminal LLAVES_VAL_P = new NonTerminal("LLAVES_VAL_P"); NonTerminal VAR_ARREGLO = new NonTerminal("VAR_ARREGLO"); NonTerminal LST_CORCHETES = new NonTerminal("LST_CORCHETES"); NonTerminal LST_CORCHETES_VAL = new NonTerminal("LST_CORCHETES_VAL"); NonTerminal ASIGNAR_VALOR = new NonTerminal("ASIGNAR_VALOR"); NonTerminal USAR_VARIABLE = new NonTerminal("USAR_VARIABLE"); NonTerminal USAR_VARIABLEP = new NonTerminal("USAR_VARIABLEP"); NonTerminal USAR_METODO = new NonTerminal("USAR_METODO"); NonTerminal USAR_METODOP = new NonTerminal("USAR_METODOP"); NonTerminal LLAMADA_FORMULARIO = new NonTerminal("LLAMADA_FORMULARIO"); NonTerminal LST_ID = new NonTerminal("LST_ID"); NonTerminal LST_CUERPO = new NonTerminal("LST_CUERPO"); NonTerminal CUERPO = new NonTerminal("CUERPO"); NonTerminal RETORNO = new NonTerminal("RETORNO"); NonTerminal ROMPER = new NonTerminal("ROMPER"); NonTerminal CONTINUAR = new NonTerminal("CONTINUAR"); NonTerminal SENTENCIAS = new NonTerminal("SENTENCIAS"); NonTerminal SI = new NonTerminal("SI"); NonTerminal SINO_SI = new NonTerminal("SINO_SI"); NonTerminal SINO = new NonTerminal("SINO"); NonTerminal SI_SIMPLIFICADO = new NonTerminal("SI_SIMPLIFICADO"); NonTerminal CASO = new NonTerminal("CASO"); NonTerminal CUERPO_CASE = new NonTerminal("CUERPO_CASE"); NonTerminal WHILE = new NonTerminal("WHILE"); NonTerminal DOWHILE = new NonTerminal("DOWHILE"); NonTerminal REPETIR = new NonTerminal("REPETIR"); NonTerminal FOR = new NonTerminal("FOR"); NonTerminal FUNCIONES_NATIVAS = new NonTerminal("FUNCIONES_NATIVAS"); NonTerminal IMPRIMIR = new NonTerminal("IMPRIMIR"); NonTerminal MENSAJE = new NonTerminal("MENSAJE"); NonTerminal OPE_TIPO = new NonTerminal("OPE_TIPO"); NonTerminal OPE_ARITME = new NonTerminal("OPE_ARITME"); NonTerminal TO_CADENA = new NonTerminal("TO_CADENA"); NonTerminal SUB_CAD = new NonTerminal("SUB_CAD"); NonTerminal POS_CAD = new NonTerminal("POS_CAD"); NonTerminal TO_BOOLEAN = new NonTerminal("TO_BOOLEAN"); NonTerminal TO_ENTERO = new NonTerminal("TO_ENTERO"); NonTerminal HOY = new NonTerminal("HOY"); NonTerminal AHORA = new NonTerminal("AHORA"); NonTerminal TO_FECHA = new NonTerminal("TO_FECHA"); NonTerminal TO_HORA = new NonTerminal("TO_HORA"); NonTerminal TO_FECHAHORA = new NonTerminal("TO_FECHAHORA"); NonTerminal TAM = new NonTerminal("TAM"); NonTerminal RANDOM = new NonTerminal("RANDOM"); NonTerminal MIN = new NonTerminal("MIN"); NonTerminal MAX = new NonTerminal("MAX"); NonTerminal POTENCIA = new NonTerminal("POTENCIA"); NonTerminal LOGARITMO = new NonTerminal("LOGARITMO"); NonTerminal LOGARITMO10 = new NonTerminal("LOGARITMO10"); NonTerminal ABSOLUTO = new NonTerminal("ABSOLUTO"); NonTerminal USAR_METO_VAR = new NonTerminal("USAR_METO_VAR"); NonTerminal SENO = new NonTerminal("SENO"); NonTerminal COSENO = new NonTerminal("COSENO"); NonTerminal TANGENTE = new NonTerminal("TANGENTE"); NonTerminal RAIZ = new NonTerminal("RAIZ"); NonTerminal PI = new NonTerminal("PI"); NonTerminal FUNC_MULTIMEDIA = new NonTerminal("FUNC_MULTIMEDIA"); NonTerminal IMAGEN = new NonTerminal("IMAGEN"); NonTerminal AUDIO = new NonTerminal("AUDIO"); NonTerminal VIDEO = new NonTerminal("VIDEO"); NonTerminal VALOR = new NonTerminal("VALOR"); NonTerminal E = new NonTerminal("E"); NonTerminal F = new NonTerminal("F"); NonTerminal PAR_CORCHETES_VACIOS = new NonTerminal("PAR_CORCHETES_VACIOS"); NonTerminal ID_VAR_FUNC = new NonTerminal("ID_VAR_FUNC"); NonTerminal LST_PUNTOSP = new NonTerminal("LST_PUNTOSP"); NonTerminal ASIG_VALOR = new NonTerminal("ASIG_VALOR"); //NonTerminal LST_E = new NonTerminal("LST_E"); NonTerminal SUPER = new NonTerminal("SUPER"); NonTerminal CUERPO_PREGUNTA = new NonTerminal("CUERPO_PREGUNTA"); NonTerminal LST_CUERPO_PREGUNTA = new NonTerminal("LST_CUERPO_PREGUNTA"); NonTerminal PREGUNTA = new NonTerminal("PREGUNTA"); NonTerminal GRUPO = new NonTerminal("GRUPO"); NonTerminal PAR_CORCHETES_VAL = new NonTerminal("PAR_CORCHETES_VAL"); NonTerminal PREGUNTA_NATIVA = new NonTerminal("PREGUNTA_NATIVA"); NonTerminal ESCRIBIR_ARCHIVO = new NonTerminal("ESCRIBIR_ARCHIVO"); NonTerminal LEN = new NonTerminal("LEN"); #endregion #region Gramatica S.Rule = LST_IMPORT + LST_CLASE | LST_CLASE; LST_IMPORT.Rule = MakeStarRule(LST_IMPORT, IMPORT); IMPORT.Rule = tImport + sAbreParent + valId + sPunto + valId + sCierraParent + sPuntoComa | SyntaxError; LST_CLASE.Rule = MakeStarRule(LST_CLASE, CLASE); CLASE.Rule = tClase + valId + EXTENDER + sAbreLlave + CP_CLASE + sCierraLlave | tClase + valId + VISIBILIDAD + EXTENDER + sAbreLlave + CP_CLASE + sCierraLlave; TIPO.Rule = tEntero | tCadena | tBooleano | tDecimal | tHora | tfecha | tFechaHora | valId // | tPregunta // | tFormulario // | tRespuesta | tVacio //Para el metodo void, tengo que validar que no lo acepten las variables ; EXTENDER.Rule = tPadre + valId | Empty; VISIBILIDAD.Rule = tPublico | tPrivado | tProtegido; /* |------------------------------------------------------------------------------------------------------------------- | Parametros |------------------------------------------------------------------------------------------------------------------- | */ LST_PARAMETROS.Rule = MakeStarRule(LST_PARAMETROS, sComa, PARAMETRO); PARAMETRO.Rule = TIPO + VAR_ARREGLO; LST_VAL.Rule = MakeStarRule(LST_VAL, sComa, VALOR); //LST_E.Rule = MakePlusRule(LST_E, sComa, E); /* |------------------------------------------------------------------------------------------------------------------- | Cuerpo de la clase |------------------------------------------------------------------------------------------------------------------- | */ CP_CLASE.Rule = MakeStarRule(CP_CLASE, CUERPO_CLASE); CUERPO_CLASE.Rule = CONSTRUCTOR | DECLARAR_VARIABLE_GLOBAL + sPuntoComa | METODO //| SOBRESCRITURA | MAIN | FORMULARIO | PREGUNTA | GRUPO | SyntaxError; ; /* |------------------------------------------------------------------------------------------------------------------- | Funciones/Metodos |------------------------------------------------------------------------------------------------------------------- | */ METODO.Rule = VISIBILIDAD + TIPO + VAR_ARREGLO + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | TIPO + VAR_ARREGLO + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; //metodo void //SOBRESCRITURA.Rule = sArroba + tOverride + METODO; MAIN.Rule = tPrincipal + sAbreParent + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; CONSTRUCTOR.Rule = valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; /* |------------------------------------------------------------------------------------------------------------------- | Declarar variable |------------------------------------------------------------------------------------------------------------------- | */ DECLARAR_VARIABLE_GLOBAL.Rule = TIPO + VISIBILIDAD + VAR_ARREGLO + VAL | TIPO + VISIBILIDAD + VAR_ARREGLO //solo se declaro | DECLARAR_VARIABLE_SINVISIBI; DECLARAR_VARIABLE_SINVISIBI.Rule = TIPO + VAR_ARREGLO + VAL | TIPO + VAR_ARREGLO;//sin visibilidad y solo declarada VAL.Rule = sIgual + VALOR /* | sIgual + tNuevo + valId + sAbreParent + LST_VAL + sCierraParent //aqui tengo que reconocer el-> nuevo opciones() | sIgual + tNuevo + TIPO + LST_CORCHETES_VAL | sIgual + LST_LLAVES_VAL | sIgual + tNulo*/ ; /* |------------------------------------------------------------------------------------------------------------------- | Arreglos |------------------------------------------------------------------------------------------------------------------- | */ /* |---------------------------------------------- | Llaves */ LST_LLAVES_VAL.Rule = MakePlusRule(LST_LLAVES_VAL, sComa, LLAVES_VAL_P); LLAVES_VAL_P.Rule = sAbreLlave + LST_LLAVES_VAL + sCierraLlave | sAbreLlave + LST_VAL + sCierraLlave; /* |---------------------------------------------- | Corchetes */ VAR_ARREGLO.Rule = valId | valId + LST_CORCHETES; LST_CORCHETES.Rule = MakePlusRule(LST_CORCHETES, PAR_CORCHETES_VACIOS); PAR_CORCHETES_VACIOS.Rule = sAbreCorchete + sCierraCorchete; PAR_CORCHETES_VAL.Rule = sAbreCorchete + E + sCierraCorchete; //PAR_CORCHETES_VAL.Rule = sAbreCorchete + VALOR + sCierraCorchete; LST_CORCHETES_VAL.Rule = MakePlusRule(LST_CORCHETES_VAL, PAR_CORCHETES_VAL); /* |------------------------------------------------------------------------------------------------------------------- | Para poder acceder a los metodos o variables |------------------------------------------------------------------------------------------------------------------- | Me va devolver un metodo () al final | Me va devolver un Id al final */ ID_VAR_FUNC.Rule = ID_VAR_FUNC + LST_PUNTOSP //| ID_VAR_FUNC + LST_CORCHETES_VAL // | LST_PUNTOSP // | tEste + sPunto + valId | valId | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent | valId + sAbreParent + LST_VAL + sCierraParent //para hacer uso de corchetes | tEste + sPunto + valId + LST_CORCHETES_VAL | valId + LST_CORCHETES_VAL | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL | valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; LST_PUNTOSP.Rule = sPunto + valId | sPunto + valId + sAbreParent + LST_VAL + sCierraParent //Corchetes | sPunto + valId + LST_CORCHETES_VAL | sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; /* |------------------------------------------------------------------------------------------------------------------- | Asignar valor |------------------------------------------------------------------------------------------------------------------- | Hay que validar que reciba un id, y no un idFUNC */ ASIG_VALOR.Rule = ID_VAR_FUNC + VAL | ID_VAR_FUNC + sMas + sMas | ID_VAR_FUNC + sMenos + sMenos // | ID_VAR_FUNC + LST_CORCHETES_VAL + VAL ; #region asgi /* * * USAR_METO_VAR.Rule = USAR_VARIABLEP + USAR_METO_VAR | USAR_VARIABLE | USAR_METODO; | | //ASIGNAR_VALOR.Rule = VAL | // | | /// | ; | | | //#Usar variable | //USAR_VARIABLE.Rule = tEste + sPunto + USAR_VARIABLEP | // | USAR_VARIABLEP; | | USAR_VARIABLEP.Rule = valId + sPunto | // | valId + LST_CORCHETES_VAL + sPunto | valId + sAbreParent + LST_VAL + sCierraParent + sPunto | ; | | USAR_VARIABLE.Rule = valId + VAL | valId + sMas + sMas | valId + sMenos + sMenos | valId + LST_CORCHETES_VAL + VAL; | | USAR_METODO.Rule = valId + sAbreParent + LST_VAL + sCierraParent; */ //#------------------+ //# USAR METODO /* * USAR_METODO.Rule = tEste + sPunto + USAR_METODOP | USAR_VARIABLEP; | | USAR_VARIABLEP.Rule = valId + sPunto + USAR_VARIABLEP | valId + LST_CORCHETES_VAL + sPunto + USAR_VARIABLEP | valId + sAbreParent + LST_VAL + sCierraParent + sPunto + USAR_VARIABLEP | valId | valId + LST_CORCHETES_VAL; */ #endregion //LLAMADA_FORMULARIO.Rule = tNuevo + USAR_VARIABLEP; //aqui hay duda we //identificador /* |------------------------------------------------------------------------------------------------------------------- | Cuerpo |------------------------------------------------------------------------------------------------------------------- | */ LST_CUERPO.Rule = MakeStarRule(LST_CUERPO, CUERPO); //| RETORNA ; CUERPO.Rule = DECLARAR_VARIABLE_SINVISIBI + sPuntoComa | ID_VAR_FUNC + sPuntoComa //hay que validar que sea un metodo y no una variables | ASIG_VALOR + sPuntoComa | Empty | SyntaxError | FUNCIONES_NATIVAS + sPuntoComa | SENTENCIAS | SUPER //| USAR_METODO | ROMPER | CONTINUAR | RETORNO | ESCRIBIR_ARCHIVO //| PROCEDIMIENTOS_FORMULARIO //| FUNC_MULTIMEDIA | FUNC_MULTIMEDIA + sPuntoComa | LLAMADA_FORMULARIO; ; LLAMADA_FORMULARIO.Rule = tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tPagina + sPuntoComa | tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tTodo + sPuntoComa | tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tCuadriculo + sPuntoComa; /* |------------------------------------------------------------------------------------------------------------------- | MULTIMEDIA |------------------------------------------------------------------------------------------------------------------- | */ FUNC_MULTIMEDIA.Rule = AUDIO | VIDEO | IMAGEN ; AUDIO.Rule = tAudio + sAbreParent + E + sComa + E + sCierraParent; VIDEO.Rule = tVideo + sAbreParent + E + sComa + E + sCierraParent; IMAGEN.Rule = tImagen + sAbreParent + E + sComa + E + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | SUPER |------------------------------------------------------------------------------------------------------------------- | */ SUPER.Rule = tSuper + sAbreParent + LST_VAL + sCierraParent + sPuntoComa; /* |------------------------------------------------------------------------------------------------------------------- | Sentencias de cotrol |------------------------------------------------------------------------------------------------------------------- | */ RETORNO.Rule = tRetorno + sPuntoComa | tRetorno + VALOR + sPuntoComa; ROMPER.Rule = tRomper + sPuntoComa; CONTINUAR.Rule = tContinuar + sPuntoComa; /* |------------------------------------------------------------------------------------------------------------------- | Sentencias |------------------------------------------------------------------------------------------------------------------- | */ SENTENCIAS.Rule = SI // | SI_SIMPLIFICADO | CASO //CICLOS | WHILE | FOR | DOWHILE | REPETIR; /* * ------------------------------------------ * SI * ------------------------------------------ * */ SI.Rule = tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI | tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO; SINO_SI.Rule = tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI | tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO; SINO.Rule = tSino + sAbreLlave + LST_CUERPO + sCierraLlave; /* * ------------------------------------------ * SI SIMPLIFICADO * ------------------------------------------ */ SI_SIMPLIFICADO.Rule = VALOR + sCierraInterrogante + E + sDosPuntos + E; /* * ------------------------------------------ * CASE * ------------------------------------------ */ CASO.Rule = tCaso + sAbreParent + E + sCierraParent + tDe + sAbreLlave + CUERPO_CASE + sCierraLlave; CUERPO_CASE.Rule = E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE | E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave | tDefecto + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave; /* |------------------------------------------------------------------------------------------------------------------- | BUCLES |------------------------------------------------------------------------------------------------------------------- | | | | /* | ------------------------------------------ * WHILE * ------------------------------------------ */ WHILE.Rule = tMientras + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; /* * ------------------------------------------ * FOR * ------------------------------------------ */ FOR.Rule = tPara + sAbreParent + DECLARAR_VARIABLE_SINVISIBI + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | tPara + sAbreParent + ASIG_VALOR + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; /* * ------------------------------------------ * DOWHILE * ------------------------------------------ */ DOWHILE.Rule = tHacer + sAbreLlave + LST_CUERPO + sCierraLlave + tMientras + sAbreParent + E + sCierraParent + sPuntoComa; /* * ------------------------------------------ * DOWHILE * ------------------------------------------ */ REPETIR.Rule = tRepetir + sAbreLlave + LST_CUERPO + sCierraLlave + tHasta + sAbreParent + E + sCierraParent + sPuntoComa; /* |------------------------------------------------------------------------------------------------------------------- | Funciones Nativas |------------------------------------------------------------------------------------------------------------------- | */ FUNCIONES_NATIVAS.Rule = IMPRIMIR | MENSAJE ; IMPRIMIR.Rule = tImprimir + sAbreParent + VALOR + sCierraParent | tImprimir + sAbreParent + sCierraParent; MENSAJE.Rule = tMensaje + sAbreParent + E + sCierraParent | tMensaje + sAbreParent + sCierraParent; /* * ------------------------------------------ * Internas del lenguaje * ------------------------------------------ */ PREGUNTA_NATIVA.Rule = tNativo + valId + sAbreParent + LST_VAL + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | Funciones ope Tipo |------------------------------------------------------------------------------------------------------------------- | */ OPE_TIPO.Rule = TO_CADENA | SUB_CAD | POS_CAD | TO_BOOLEAN | TO_ENTERO | HOY | AHORA | TO_FECHA | TO_HORA | TO_FECHAHORA | TAM | RANDOM | MIN | MAX; /* |------------------------------------------------------------------------------------------------------------------- | Funciones Cadena |------------------------------------------------------------------------------------------------------------------- | */ /* * ------------------------------------------ * CADENA * ------------------------------------------ */ TO_CADENA.Rule = tCadena + sAbreParent + E + sCierraParent; SUB_CAD.Rule = tSubCad + sAbreParent + E + sComa + E + sComa + E + sCierraParent; POS_CAD.Rule = tPosCad + sAbreParent + E + sComa + E + sCierraParent; /* * ------------------------------------------ * Booleana * ------------------------------------------ */ TO_BOOLEAN.Rule = tBooleano + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * Entera * ------------------------------------------ */ TO_ENTERO.Rule = tEntero + sAbreParent + E + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | Funciones Date |------------------------------------------------------------------------------------------------------------------- | */ /* * ------------------------------------------ * Hoy * ------------------------------------------ * Retorno: fecha */ HOY.Rule = tHoy + sAbreParent + sCierraParent; /* * ------------------------------------------ * Ahora * ------------------------------------------ * Retorno: fechaHora */ AHORA.Rule = tAhora + sAbreParent + sCierraParent; /* * ------------------------------------------ * To Fecha * ------------------------------------------ * Retorno: fecha */ TO_FECHA.Rule = tFecha + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * To Hora * ------------------------------------------ * Retorno: hora */ TO_HORA.Rule = tHora + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * To FechaHora * ------------------------------------------ * Retorno: hora */ TO_FECHAHORA.Rule = tFechaHora + sAbreParent + E + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | Otras Funciones |------------------------------------------------------------------------------------------------------------------- | */ /* * ------------------------------------------ * OBjeto * ------------------------------------------ * retorno:entero */ TAM.Rule = tTam + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * Random * ------------------------------------------ * retorno:entero/decimal/cadena */ RANDOM.Rule = tRandom + sAbreParent + LST_VAL + sCierraParent; //| tRandom + sAbreParent + sCierraParent; /* * ------------------------------------------ * Minimo * ------------------------------------------ * retorno:entero/decimal */ MIN.Rule = tMin + sAbreParent + LST_VAL + sCierraParent; /* * ------------------------------------------ * Maximo * ------------------------------------------ * retorno:entero/decimal */ MAX.Rule = tMax + sAbreParent + LST_VAL + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | Operaciones matematicas |------------------------------------------------------------------------------------------------------------------- | */ OPE_ARITME.Rule = POTENCIA | LOGARITMO | LOGARITMO10 | ABSOLUTO | SENO | COSENO | TANGENTE | RAIZ | PI; /* * ------------------------------------------ * POTENCIA * ------------------------------------------ * Retorno:decimal */ POTENCIA.Rule = tPow + sAbreParent + E + sComa + E + sCierraParent; /* * ------------------------------------------ * LOGARITMO * ------------------------------------------ * Retorno:decimal */ LOGARITMO.Rule = tLog + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * LOGARITMO10 * ------------------------------------------ * Retorno:decimal */ LOGARITMO10.Rule = tLog10 + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * ABSOLUTO * ------------------------------------------ * Retorno:decimal/enter */ ABSOLUTO.Rule = tAbs + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * TRIGONOMETRICAS * ------------------------------------------ * Retorno:decimal */ SENO.Rule = tSeno + sAbreParent + E + sCierraParent; COSENO.Rule = tCoseno + sAbreParent + E + sCierraParent; TANGENTE.Rule = tTangente + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * RAIZ * ------------------------------------------ * Retorno:decimal */ RAIZ.Rule = tSqrt + sAbreParent + E + sCierraParent; /* * ------------------------------------------ * PI * ------------------------------------------ * Retorno:decimal */ PI.Rule = tPi + sAbreParent + sCierraParent; /* |------------------------------------------------------------------------------------------------------------------- | Formulario |------------------------------------------------------------------------------------------------------------------- | */ FORMULARIO.Rule = tFormulario + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; PREGUNTA.Rule = tPregunta + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO_PREGUNTA + sCierraLlave; GRUPO.Rule = tGrupo + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; LST_CUERPO_PREGUNTA.Rule = MakeStarRule(LST_CUERPO_PREGUNTA, CUERPO_PREGUNTA); CUERPO_PREGUNTA.Rule = DECLARAR_VARIABLE_GLOBAL + sPuntoComa | METODO | VISIBILIDAD + tRespuesta + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | VISIBILIDAD + tMostrar + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave | VISIBILIDAD + tCalcular + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; /* |------------------------------------------------------------------------------------------------------------------- | ESCRIBIR_ARCHIVO |------------------------------------------------------------------------------------------------------------------- | */ ESCRIBIR_ARCHIVO.Rule = tEscribirArchivo + sAbreParent + LST_VAL + sCierraParent + sPuntoComa; /* |------------------------------------------------------------------------------------------------------------------- | Valor |------------------------------------------------------------------------------------------------------------------- | */ VALOR.Rule = tNuevo + valId + sAbreParent + LST_VAL + sCierraParent //aqui tengo que reconocer el-> nuevo opciones() | tNuevo + TIPO + LST_CORCHETES_VAL | LST_LLAVES_VAL //| tNulo | PREGUNTA_NATIVA | tEste //para el this solamente | E; E.Rule = sMenos + E //Aritemeticas | E + sPot + E | E + sDiv + E | E + sPor + E | E + sMas + E | E + sMenos + E | E + sMod + E //Relacional | E + sIgualacion + E | E + sDiferenciacion + E | E + sMenorQue + E | E + sMenorIgualQue + E | E + sMayorQue + E | E + sMayorIgualQue + E //logicos | E + sAnd + E | E + sOr + E | sNot + E | sAbreParent + E + sCierraParent | ID_VAR_FUNC //validar que si viene func() tiene que retornar algo obligatoriamente prro | valBoolean | valCadena | valCadena2 | valCaracter | valDecimal | valNumero | tNulo | tNada | SI_SIMPLIFICADO | OPE_ARITME | OPE_TIPO | LEN; LEN.Rule = tLen + sAbreParent + E + sCierraParent; RegisterOperators(1, Associativity.Left, sOr); RegisterOperators(2, Associativity.Left, sAnd); RegisterOperators(3, Associativity.Left, sNot); RegisterOperators(4, Associativity.Left, sMayorQue, sMenorQue, sMayorIgualQue, sMenorIgualQue, sIgualacion, sDiferenciacion); RegisterOperators(5, Associativity.Left, sMas, sMenos); RegisterOperators(6, Associativity.Left, sPor, sDiv, sMod); RegisterOperators(7, Associativity.Left, sPot); this.Root = S; #endregion }
public GWBasicGrammar() : base(false) // BASIC is not case sensitive... { this.GrammarComments = "This grammar uses one new Irony feature - Scanner-Parser link. Parser helps Scanner to disambiguate " + "similar but different token types when more than one terminal matches the current input char.\r\n" + "See comments in GwBasicGrammar.cs file."; /* * Scanner-Parser link. * The grammar defines 3 terminals for numbers: number, lineNumber and fileNumber. All three return decimal * digits in GetFirsts() method. So when current input is a digit, the scanner has 3 potential candidate terminals * to match the input. However, because each of the 3 terminals can appear in specific "places" in grammar, * the parser is able to assist scanner to pick the correct terminal, depending on the current parser state. * The disambiguation happens in Scanner.SelectTerminals method. When the terminal list for current input char * has more than 1 terminal, the scanner code gets the current parser state from core parser (through compilerContext), * and then checks the terminals agains the ExpectedTerms set in the parser state. * As you might see in Grammar Explorer, the conflict is resolved successfully. */ //Terminals var lineNumber = new NumberLiteral("LINE_NUMBER", NumberOptions.IntOnly); var fileNumber = new NumberLiteral("FILE_NUMBER", NumberOptions.IntOnly); var number = new NumberLiteral("NUMBER", NumberOptions.AllowStartEndDot); //ints that are too long for int32 are converted to int64 number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 }; number.AddExponentSymbols("eE", TypeCode.Single); number.AddExponentSymbols("dD", TypeCode.Double); number.AddSuffix("!", TypeCode.Single); number.AddSuffix("#", TypeCode.Double); var variable = new IdentifierTerminal("Identifier"); variable.AddSuffix("$", TypeCode.String); variable.AddSuffix("%", TypeCode.Int32); variable.AddSuffix("!", TypeCode.Single); variable.AddSuffix("#", TypeCode.Double); var stringLiteral = new StringLiteral("STRING", "\"", StringOptions.None); //Important: do not add comment term to base.NonGrammarTerminals list - we do use this terminal in grammar rules var userFunctionName = variable; var comment = new CommentTerminal("Comment", "REM", "\n"); var short_comment = new CommentTerminal("ShortComment", "'", "\n"); var line_cont = new LineContinuationTerminal("LineContinuation", "_"); var comma = ToTerm(",", "comma"); var colon = ToTerm(":", "colon"); var comma_opt = new NonTerminal("comma_opt"); comma_opt.Rule = Empty | ","; var semi_opt = new NonTerminal("semi_opt"); semi_opt.Rule = Empty | ";"; var pound_opt = new NonTerminal("pound_opt"); pound_opt.Rule = Empty | "#"; // Non-terminals var PROGRAM = new NonTerminal("PROGRAM"); var LINE = new NonTerminal("LINE"); var LINE_CONTENT_OPT = new NonTerminal("LINE_CONTENT_OPT"); var COMMENT_OPT = new NonTerminal("COMMENT_OPT"); var STATEMENT_LIST = new NonTerminal("STATEMENT_LIST"); var STATEMENT = new NonTerminal("STATEMENT"); var PRINT_STMT = new NonTerminal("PRINT_STMT"); var PRINT_LIST = new NonTerminal("PRINT_LIST"); var PRINT_ARG = new NonTerminal("PRINT_ARG"); var OPEN_STMT = new NonTerminal("OPEN_STMT"); var OPEN_STMT_MODE = new NonTerminal("OPEN_STMT_MODE"); var OPEN_STMT_ACCESS = new NonTerminal("OPEN_STMT_ACCESS"); var CLOSE_STMT = new NonTerminal("CLOSE_STMT"); var INPUT_STMT = new NonTerminal("INPUT_STMT"); var VARIABLES = new NonTerminal("VARIABLES"); var IF_STMT = new NonTerminal("IF_STMT"); var THEN_CLAUSE = new NonTerminal("THEN_CLAUSE"); var ELSE_CLAUSE_OPT = new NonTerminal("ELSE_CLAUSE_OPT"); //, typeof(AstNode)); var EXPR = new NonTerminal("EXPRESSION"); var EXPR_LIST = new NonTerminal("EXPRESSION_LIST"); var BINARY_OP = new NonTerminal("BINARY_OP", "operator"); var BINARY_EXPR = new NonTerminal("BINARY_EXPR"); var UNARY_EXPR = new NonTerminal("UNARY_EXPR"); var SIGN = new NonTerminal("SIGN"); var ASSIGN_STMT = new NonTerminal("ASSIGN_STMT"); var FOR_STMT = new NonTerminal("FOR_STMT"); var STEP_OPT = new NonTerminal("STEP_OPT"); var NEXT_STMT = new NonTerminal("NEXT_STMT"); var LOCATE_STMT = new NonTerminal("LOCATE_STMT"); var WHILE_STMT = new NonTerminal("WHILE_STMT"); var WEND_STMT = new NonTerminal("WEND_STMT"); var SWAP_STMT = new NonTerminal("SWAP_STMT"); var FUN_CALL = new NonTerminal("FUN_CALL"); var VARIABLE_OR_FUNCTION_EXPR = new NonTerminal("VARIABLE_OR_FUNCTION_EXPR"); var ARG_LIST = new NonTerminal("ARG_LIST"); var LINE_INPUT_STMT = new NonTerminal("LINE_INPUT_STMT"); var LINE_INPUT_POUND_STMT = new NonTerminal("LINE_INPUT_POUND_STMT"); var END_STMT = new NonTerminal("END_STMT"); var CLS_STMT = new NonTerminal("CLS_STMT"); var CLEAR_STMT = new NonTerminal("CLEAR_STMT"); var DIM_STMT = new NonTerminal("DIM_STMT"); var DEF_FN_STMT = new NonTerminal("DEF_FN_STMT"); var GOTO_STMT = new NonTerminal("GOTO_STMT"); var GOSUB_STMT = new NonTerminal("GOSUB_STMT"); var RETURN_STMT = new NonTerminal("RETURN_STMT"); var ON_STMT = new NonTerminal("ON_STMT"); var LINE_NUMBERS = new NonTerminal("LINE_NUMBERS"); var RANDOMIZE_STMT = new NonTerminal("RANDOMIZE_STMT"); // set the PROGRAM to be the root node of BASIC programs. this.Root = PROGRAM; // BNF Rules PROGRAM.Rule = MakePlusRule(PROGRAM, LINE); // A line can be an empty line, or it's a number followed by a statement list ended by a new-line. LINE.Rule = NewLine | lineNumber + LINE_CONTENT_OPT + COMMENT_OPT + NewLine | SyntaxError + NewLine; LINE.NodeCaptionTemplate = "Line #{0}"; // A statement list is 1 or more statements separated by the ':' character LINE_CONTENT_OPT.Rule = Empty | IF_STMT | STATEMENT_LIST; STATEMENT_LIST.Rule = MakePlusRule(STATEMENT_LIST, colon, STATEMENT); COMMENT_OPT.Rule = short_comment | comment | Empty; // A statement can be one of a number of types STATEMENT.Rule = ASSIGN_STMT | PRINT_STMT | INPUT_STMT | OPEN_STMT | CLOSE_STMT | LINE_INPUT_POUND_STMT | LINE_INPUT_STMT | LOCATE_STMT | CLS_STMT | END_STMT | CLEAR_STMT | DIM_STMT | DEF_FN_STMT | SWAP_STMT | RANDOMIZE_STMT | GOSUB_STMT | RETURN_STMT | GOTO_STMT | ON_STMT | FOR_STMT | NEXT_STMT | WHILE_STMT | WEND_STMT; // The different statements are defined here PRINT_STMT.Rule = "print" + PRINT_LIST; PRINT_LIST.Rule = MakeStarRule(PRINT_LIST, null, PRINT_ARG); PRINT_ARG.Rule = EXPR + semi_opt; INPUT_STMT.Rule = "input" + semi_opt + stringLiteral + ";" + VARIABLES; OPEN_STMT.Rule = "open" + EXPR + (Empty | "for" + OPEN_STMT_MODE) + (Empty | "access" + OPEN_STMT_ACCESS) + "as" + pound_opt + fileNumber; OPEN_STMT_ACCESS.Rule = "read" + (Empty | "write") | "write"; OPEN_STMT_MODE.Rule = ToTerm("o") | "i" | "a" | "output" | "input" | "append"; CLOSE_STMT.Rule = "close" + pound_opt + fileNumber; LINE_INPUT_STMT.Rule = ToTerm("line") + "input" + semi_opt + stringLiteral + ";" + VARIABLE_OR_FUNCTION_EXPR; LINE_INPUT_POUND_STMT.Rule = ToTerm("line") + "input" + ToTerm("#") + fileNumber + comma + VARIABLE_OR_FUNCTION_EXPR; DIM_STMT.Rule = "dim" + VARIABLES; DEF_FN_STMT.Rule = "def" + userFunctionName + (Empty | "(" + ARG_LIST + ")") + "=" + EXPR; VARIABLES.Rule = VARIABLE_OR_FUNCTION_EXPR | VARIABLE_OR_FUNCTION_EXPR + "," + VARIABLES; IF_STMT.Rule = "if" + EXPR + THEN_CLAUSE + ELSE_CLAUSE_OPT; THEN_CLAUSE.Rule = "then" + STATEMENT_LIST | GOTO_STMT; //Inject PreferShift hint here to explicitly set shift as preferred action. Suppresses warning message about conflict. ELSE_CLAUSE_OPT.Rule = Empty | PreferShiftHere() + "else" + STATEMENT_LIST; GOTO_STMT.Rule = "goto" + lineNumber; GOSUB_STMT.Rule = "gosub" + lineNumber; RETURN_STMT.Rule = "return"; ON_STMT.Rule = "on" + EXPR + (ToTerm("goto") | "gosub") + LINE_NUMBERS; LINE_NUMBERS.Rule = MakePlusRule(LINE_NUMBERS, comma, lineNumber); ASSIGN_STMT.Rule = VARIABLE_OR_FUNCTION_EXPR + "=" + EXPR; LOCATE_STMT.Rule = "locate" + EXPR + comma + EXPR; SWAP_STMT.Rule = "swap" + EXPR + comma + EXPR; END_STMT.Rule = "end"; CLS_STMT.Rule = "cls"; CLEAR_STMT.Rule = ToTerm("clear") + comma + (Empty | number) + (Empty | comma + number) | "clear" + number | "clear"; RANDOMIZE_STMT.Rule = "randomize" + EXPR; // An expression is a number, or a variable, a string, or the result of a binary comparison. EXPR.Rule = number | variable | FUN_CALL | stringLiteral | BINARY_EXPR | "(" + EXPR + ")" | UNARY_EXPR; BINARY_EXPR.Rule = EXPR + BINARY_OP + EXPR; UNARY_EXPR.Rule = SIGN + EXPR; SIGN.Rule = ToTerm("-") | "+"; //Inject PreferShift hint here to explicitly set shift as preferred action. Suppresses warning message about conflict. //The conflict arises from PRINT statement, when there may be ambigous interpretations for expression like // PRINT F (X) -- either function call or identifier followed by expression FUN_CALL.Rule = variable + PreferShiftHere() + "(" + ARG_LIST + ")"; VARIABLE_OR_FUNCTION_EXPR.Rule = variable | FUN_CALL; BINARY_OP.Rule = ToTerm("+") | "^" | "-" | "*" | "/" | "=" | "<=" | ">=" | "<" | ">" | "<>" | "and" | "or"; //let's do operator precedence right here RegisterOperators(60, "^"); RegisterOperators(50, "*", "/"); RegisterOperators(40, "+", "-"); RegisterOperators(30, "=", "<=", ">=", "<", ">", "<>"); RegisterOperators(20, "and", "or"); EXPR_LIST.Rule = MakeStarRule(EXPR_LIST, EXPR); FOR_STMT.Rule = "for" + ASSIGN_STMT + "to" + EXPR + STEP_OPT; STEP_OPT.Rule = Empty | "step" + EXPR; NEXT_STMT.Rule = "next" + VARIABLES | "next"; WHILE_STMT.Rule = "while" + EXPR; WEND_STMT.Rule = "wend"; //TODO: check number of arguments for particular function in node constructor ARG_LIST.Rule = MakePlusRule(ARG_LIST, comma, EXPR); //Punctuation and Transient elements MarkPunctuation("(", ")", ","); MarkTransient(EXPR, STATEMENT, LINE_CONTENT_OPT, VARIABLE_OR_FUNCTION_EXPR, COMMENT_OPT); NonGrammarTerminals.Add(line_cont); this.LanguageFlags = LanguageFlags.NewLineBeforeEOF; lineNumber.ValidateToken += identifier_ValidateToken; }
public Gramatica() : base(caseSensitive: true) { //Prueba #region er StringLiteral CADENA = new StringLiteral("cadena", "\""); RegexBasedTerminal letras = new RegexBasedTerminal("letras", "[(a-z)*(A-Z)*(0-9)*]+"); var ENTERO = new RegexBasedTerminal("Entero", "[0-9]+"); var DECIMAL = new RegexBasedTerminal("Decimal", "[0-9]+[.]+[0-9]+"); IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("ID"); //CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/", "/"); CommentTerminal comentarioLinea = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); CommentTerminal comentarioBloque = new CommentTerminal("DelimitedComment", "/*", "*/"); //var whiteSpace = new NonGrammarTerminals.Add(comentarioLinea); NonGrammarTerminals.Add(comentarioBloque); #endregion #region KeyWords de Puntuacion KeyTerm dosPuntos = ToTerm(":", "dosPuntos"); KeyTerm puntoComa = ToTerm(";", "puntoComa"); KeyTerm punto = ToTerm(".", "punto"); KeyTerm coma = ToTerm(",", "coma"); KeyTerm parentesisIzq = ToTerm("(", "parentesisIzq"); KeyTerm parentesisDer = ToTerm(")", "parentesisDer"); KeyTerm llaveIzq = ToTerm("{", "llaveIzq"); KeyTerm llaveDer = ToTerm("}", "llaveDer"); #endregion #region KeyWords Operadores, Comparadores, nombre variables, KeyTerm plus = ToTerm("+", "plus"); KeyTerm minus = ToTerm("-", "minus"); KeyTerm por = ToTerm("*", "por"); KeyTerm div = ToTerm("/", "div"); KeyTerm plusPlus = ToTerm("++", "plusPlus"); KeyTerm minusMinus = ToTerm("--", "menosMenos"); //Comparadores KeyTerm mayorQue = ToTerm(">", "mayorQue"); KeyTerm menorQue = ToTerm("<", "menorQue"); KeyTerm igual = ToTerm("=", "igual"); KeyTerm mayorIgual = ToTerm(">=", "mayorIgual"); KeyTerm menorIgual = ToTerm("<=", "menorIgual"); KeyTerm diferente = ToTerm("!=", "diferente"); KeyTerm igualIgual = ToTerm("==", "igualIgual"); //Variables KeyTerm varInt = ToTerm("int"); KeyTerm varFloat = ToTerm("float"); KeyTerm varString = ToTerm("string"); KeyTerm varBoolean = ToTerm("bool"); //Ciclos y condicionales KeyTerm condIf = ToTerm("if"); KeyTerm condElif = ToTerm("elif"); KeyTerm condElse = ToTerm("else"); KeyTerm kwBreack = ToTerm("break"); KeyTerm kwCase = ToTerm("case"); KeyTerm kwClass = ToTerm("class"); KeyTerm kwTry = ToTerm("Try"); KeyTerm kwCatch = ToTerm("Catch"); KeyTerm kwWhile = ToTerm("while"); KeyTerm kwDowhile = ToTerm("do while"); KeyTerm kwFor = ToTerm("for"); KeyTerm kwPublic = ToTerm("public"); KeyTerm kwThrow = ToTerm("Throw"); KeyTerm kwVoid = ToTerm("Void"); KeyTerm kwSwitch = ToTerm("Switch"); KeyTerm kwTrue = ToTerm("true"); KeyTerm kwFalse = ToTerm("false"); #endregion #region Terminales NonTerminal ini = new NonTerminal("ini"); NonTerminal instruccion = new NonTerminal("instruccion"); NonTerminal instrucciones = new NonTerminal("instrucciones"); NonTerminal expresion_numerica = new NonTerminal("expresion_numerica"); NonTerminal expresion_cadena = new NonTerminal("expresion_cadena"); NonTerminal expresion_logica = new NonTerminal("expresion_logica"); //No terminales para declarar variables NonTerminal declararVar = new NonTerminal("decVar"); NonTerminal decInt = new NonTerminal("decInt"); NonTerminal decFloat = new NonTerminal("decFloat"); NonTerminal decString = new NonTerminal("decString"); NonTerminal decBool = new NonTerminal("decBool"); var entradaID = new NonTerminal("entradaID"); #endregion #region No terminales #endregion #region Gramatica ini.Rule = instrucciones; //Declarar varibles declararVar.Rule = decInt | decFloat | decString | decBool | declararVar; decInt.Rule = varInt + entradaID + igual + ENTERO + puntoComa; decFloat.Rule = (varFloat + entradaID + igual + DECIMAL + puntoComa); decString.Rule = (varString + entradaID + igual + (CADENA) + puntoComa); decBool.Rule = (varBoolean + entradaID + igual + (kwTrue | kwFalse) + puntoComa); entradaID.Rule = MakePlusRule(entradaID, ToTerm(","), IDENTIFICADOR); #endregion #region Jesus IF //----------------------IF------------------ //En estos if solo se podran hacer 2 condiciones maximo por ejemplo if(a==2 && b=false){} //No terminales para condicional if NonTerminal condicionIF = new NonTerminal("condicionIF"); NonTerminal condicionIFELSE = new NonTerminal("condicionIFELSE"); NonTerminal condicionalIFELSEIF = new NonTerminal("condicionIFELSEIF"); NonTerminal condicionELSE = new NonTerminal("condicionELSE"); NonTerminal condicionELSEIF = new NonTerminal("condicionELSEIF"); NonTerminal expComparacion = new NonTerminal("expComparacion"); NonTerminal nuevaCondicion = new NonTerminal("nuevaCondicion"); NonTerminal nuevaCondicion2 = new NonTerminal("nuevaCondicion2"); NonTerminal compIgualDiferente = new NonTerminal("compIgualDiferente"); NonTerminal compMayorMenor = new NonTerminal("comMayorMenor"); NonTerminal compMayorMenorIgual = new NonTerminal("comMayorMenor"); NonTerminal compBool = new NonTerminal("comBool"); KeyTerm signoOR = ToTerm("|"); KeyTerm signoAND = ToTerm("&&"); //Nota: El Ciclo if que se presenta se modificara para poder poner mas codigo dentro del ciclo if //Declarar un if condicionIF.Rule = condIf + parentesisIzq + (expComparacion | (expComparacion + nuevaCondicion)) + parentesisDer + llaveIzq + llaveDer; expComparacion.Rule = (parentesisIzq + (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool) + parentesisDer) | (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool); compIgualDiferente.Rule = ((DECIMAL + igualIgual + DECIMAL) | (ENTERO + igualIgual + ENTERO) | (entradaID + igualIgual + (ENTERO | DECIMAL | CADENA))) | ((DECIMAL + diferente + DECIMAL) | (ENTERO + diferente + ENTERO) | (entradaID + diferente + (ENTERO | DECIMAL | CADENA))); compMayorMenor.Rule = ((DECIMAL + mayorQue + DECIMAL) | (ENTERO + mayorQue + ENTERO) | (entradaID + mayorQue + (ENTERO | DECIMAL | CADENA))) | ((DECIMAL + menorQue + DECIMAL) | (ENTERO + menorQue + ENTERO) | (entradaID + menorQue + (ENTERO | DECIMAL | CADENA))); compMayorMenorIgual.Rule = ((DECIMAL + mayorIgual + DECIMAL) | (ENTERO + mayorIgual + ENTERO) | (entradaID + mayorIgual + (ENTERO | DECIMAL | CADENA))) | ((DECIMAL + menorIgual + DECIMAL) | (ENTERO + menorIgual + ENTERO) | (entradaID + menorIgual + (ENTERO | DECIMAL | CADENA))); compBool.Rule = entradaID + igual + (kwTrue | kwFalse); nuevaCondicion.Rule = ((signoAND | signoOR) + expComparacion) | ((signoAND | signoOR) + expComparacion + nuevaCondicion2); nuevaCondicion2.Rule = nuevaCondicion; //Declarar un if else condicionIFELSE.Rule = condicionIF + condicionELSE; condicionELSE.Rule = condElse + llaveIzq + llaveDer; //Declarar un if else if condicionalIFELSEIF.Rule = condicionIF + condicionELSEIF; condicionELSEIF.Rule = condElse + (condicionIF | condicionELSE | condicionalIFELSEIF); #endregion #region ADRI SWITCH NonTerminal condicionSwitch = new NonTerminal("condicionSwitch"); NonTerminal switchOpcion = new NonTerminal("switchOpcion"); NonTerminal opcionCase = new NonTerminal("opcionCase"); NonTerminal opcionDefault = new NonTerminal("opcionDefault"); //poner con las keyterm KeyTerm kwDefault = ToTerm("default"); opcionDefault.Rule = kwDefault + dosPuntos + kwBreack + puntoComa; opcionCase.Rule = kwCase + switchOpcion + dosPuntos + kwBreack + puntoComa + (opcionCase | opcionDefault); switchOpcion.Rule = DECIMAL | ENTERO | CADENA | entradaID; condicionSwitch.Rule = kwSwitch + parentesisIzq + switchOpcion + parentesisDer + llaveIzq + opcionCase + llaveDer; //cierre de Switch #endregion #region Jesus Imprimir //-----------------------Print KeyTerm kwConsole = ToTerm("Console"); KeyTerm kwWrite = ToTerm("Write"); KeyTerm kwWriteLn = ToTerm("WriteLine"); NonTerminal imprimir = new NonTerminal("imprimir"); NonTerminal imprimirWrite = new NonTerminal("imprimirWrite"); NonTerminal imprimirWriteLn = new NonTerminal("imprimirWriteLn"); NonTerminal textoOVariable = new NonTerminal("textoOVariable"); imprimir.Rule = kwConsole + punto + (imprimirWrite | imprimirWriteLn) + puntoComa; imprimirWrite.Rule = kwWrite + parentesisIzq + textoOVariable + parentesisDer; imprimirWriteLn.Rule = kwWriteLn + parentesisIzq + textoOVariable + parentesisDer; textoOVariable.Rule = (CADENA | entradaID) | ((CADENA | entradaID) + plus + textoOVariable); #endregion #region Jesus Operaciones //-------------------------Operaciones NonTerminal operaciones = new NonTerminal("operaciones"); NonTerminal opeSuma = new NonTerminal("opeSuma"); NonTerminal opeResta = new NonTerminal("opeResta"); NonTerminal opeMultiplicacion = new NonTerminal("opeMultiplicacion"); NonTerminal opeDivision = new NonTerminal("opeDivision"); NonTerminal opeCompuesta = new NonTerminal("opeCompuesta"); NonTerminal datoEntradaOpe = new NonTerminal("datoEntradaOpe"); operaciones.Rule = ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + puntoComa) | (opeCompuesta + puntoComa); opeSuma.Rule = datoEntradaOpe | (datoEntradaOpe + plus + opeSuma) | (parentesisIzq + opeSuma + parentesisDer) | (plus + datoEntradaOpe); opeResta.Rule = datoEntradaOpe | (datoEntradaOpe + minus + opeResta) | (parentesisIzq + opeResta + parentesisDer) | (minus + datoEntradaOpe); opeMultiplicacion.Rule = datoEntradaOpe | (datoEntradaOpe + por + opeMultiplicacion) | (parentesisIzq + opeMultiplicacion + parentesisDer) | (por + datoEntradaOpe) | (parentesisIzq + opeMultiplicacion + parentesisDer); opeDivision.Rule = datoEntradaOpe | (datoEntradaOpe + div + opeDivision) | (parentesisIzq + opeDivision + parentesisDer) | (div + datoEntradaOpe); opeCompuesta.Rule = (opeSuma | opeResta | opeMultiplicacion | opeDivision) | ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + opeCompuesta); datoEntradaOpe.Rule = (ENTERO | DECIMAL | entradaID) | (parentesisIzq + datoEntradaOpe + parentesisDer) | (parentesisIzq + (opeSuma | opeResta | opeMultiplicacion | opeDivision) + parentesisDer); #endregion #region Jesus funciones y clases //------------------funciones de clases NonTerminal nameSpace = new NonTerminal("nameSpace"); NonTerminal ntClass = new NonTerminal("ntClass"); NonTerminal ntMain = new NonTerminal("ntMain"); NonTerminal ntPublic = new NonTerminal("ntPublic"); nameSpace.Rule = "namespace" + entradaID + llaveIzq + ntClass + llaveDer; ntClass.Rule = kwClass + entradaID + llaveIzq + (ntPublic | ntMain) + llaveDer; ntMain.Rule = "static void Main" + parentesisIzq + varString + "[] args" + parentesisDer + llaveIzq + llaveDer; ntPublic.Rule = kwPublic + entradaID + "()" + llaveIzq + llaveDer; #endregion #region Preferencias #endregion }
public ScriptdotnetGrammar(bool expressionGrammar) { #region 1. Terminals NumberLiteral n = TerminalFactory.CreateCSharpNumber("number"); IdentifierTerminal v = CreateScriptNetIdentifier("Identifier"); Terminal s = CreateScriptNetString("string"); Terminal @is = Symbol("is"); Terminal dot = Symbol(".", "dot"); Terminal less = Symbol("<"); Terminal greater = Symbol(">"); Terminal arrow = Symbol("->"); Terminal LSb = Symbol("["); Terminal RSb = Symbol("]"); Terminal LCb = Symbol("("); Terminal RCb = Symbol(")"); Terminal RFb = Symbol("}"); Terminal LFb = Symbol("{"); Terminal LMb = Symbol("<!"); Terminal RMb = Symbol("!>"); Terminal LGb = Symbol("<|"); Terminal RGb = Symbol("|>"); Terminal comma = Symbol(","); Terminal semicolon = Symbol(";"); Terminal colon = Symbol(":"); #endregion #region 2. Non-terminals #region 2.1 Expressions NonTerminal Expr = new NonTerminal("Expr", typeof(ScriptExpr)); NonTerminal ConstExpr = new NonTerminal("ConstExpr", typeof(ScriptConstExpr)); NonTerminal BinExpr = new NonTerminal("BinExpr", typeof(ScriptBinExpr)); NonTerminal UnaryExpr = new NonTerminal("UnaryExpr", typeof(ScriptUnaryExpr)); NonTerminal AssignExpr = new NonTerminal("AssignExpr", typeof(ScriptAssignExpr)); NonTerminal TypeConvertExpr = new NonTerminal("TypeConvertExpr", typeof(ScriptTypeConvertExpr)); NonTerminal IsExpr = new NonTerminal("IsExpr", typeof(ScriptIsExpr)); NonTerminal MetaExpr = new NonTerminal("MetaExpr", typeof(ScriptMetaExpr)); NonTerminal FuncDefExpr = new NonTerminal("FuncDefExpr", typeof(ScriptFunctionDefinition)); //typeof(ScriptFunctionDefExpression)); NonTerminal TypeExpr = new NonTerminal("TypeExpr", typeof(ScriptTypeExpr)); NonTerminal TypeConstructor = new NonTerminal("TypeConstructor", typeof(ScriptTypeConstructor)); NonTerminal FunctionCall = new NonTerminal("FunctionCall", typeof(ScriptFunctionCall)); NonTerminal ArrayResolution = new NonTerminal("ArrayResolution", typeof(ScriptArrayResolution)); NonTerminal BinOp = new NonTerminal("BinOp"); NonTerminal LUnOp = new NonTerminal("LUnOp"); NonTerminal RUnOp = new NonTerminal("RUnOp"); NonTerminal ArrayConstructor = new NonTerminal("ArrayConstructor", typeof(ScriptArrayConstructor)); NonTerminal MObjectConstructor = new NonTerminal("MObjectConstructor", typeof(ScriptMObject)); NonTerminal MObjectPart = new NonTerminal("MObjectPart", typeof(ScriptMObjectPart)); NonTerminal MObjectParts = new NonTerminal("MObjectPart", typeof(ScriptAst)); NonTerminal TypeList = new NonTerminal("TypeList", typeof(ScriptTypeExprList)); #endregion #region 2.2 QualifiedName //Expression List: expr1, expr2, expr3, .. NonTerminal ExprList = new NonTerminal("ExprList", typeof(ScriptExprList)); //A name in form: a.b.c().d[1,2].e .... NonTerminal NewStmt = new NonTerminal("NewStmt", typeof(ScriptNewStmt)); NonTerminal NewArrStmt = new NonTerminal("NewArrStmt", typeof(ScriptNewArrStmt)); NonTerminal QualifiedName = new NonTerminal("QualifiedName", typeof(ScriptQualifiedName)); NonTerminal GenericsPostfix = new NonTerminal("GenericsPostfix", typeof(ScriptGenericsPostfix)); NonTerminal GlobalList = new NonTerminal("GlobalList", typeof(ScriptGlobalList)); #endregion #region 2.3 Statement NonTerminal Condition = new NonTerminal("Condition", typeof(ScriptCondition)); NonTerminal Statement = new NonTerminal("Statement", typeof(ScriptStatement)); NonTerminal IfStatement = new NonTerminal("IfStatement", typeof(ScriptIfStatement)); NonTerminal WhileStatement = new NonTerminal("WhileStatement", typeof(ScriptWhileStatement)); NonTerminal ForStatement = new NonTerminal("ForStatement", typeof(ScriptForStatement)); NonTerminal ForEachStatement = new NonTerminal("ForEachStatement", typeof(ScriptForEachStatement)); NonTerminal OptionalExpression = new NonTerminal("OptionalExpression", typeof(ScriptExpr)); NonTerminal SwitchStatement = new NonTerminal("SwitchStatement", typeof(ScriptStatement)); NonTerminal SwitchStatements = new NonTerminal("SwitchStatements", typeof(ScriptSwitchStatement)); NonTerminal SwitchCaseStatement = new NonTerminal("SwitchCaseStatement", typeof(ScriptSwitchCaseStatement)); NonTerminal SwitchDefaultStatement = new NonTerminal("SwitchDefaultStatement", typeof(ScriptSwitchDefaultStatement)); NonTerminal UsingStatement = new NonTerminal("UsingStatement", typeof(ScriptUsingStatement)); NonTerminal TryCatchFinallyStatement = new NonTerminal("TryCatchFinallyStatement", typeof(ScriptTryCatchFinallyStatement)); NonTerminal FlowControlStatement = new NonTerminal("FlowControl", typeof(ScriptFlowControlStatement)); NonTerminal ExprStatement = new NonTerminal("ExprStatement", typeof(ScriptStatement)); //Block NonTerminal BlockStatement = new NonTerminal("BlockStatement", typeof(ScriptStatement)); NonTerminal Statements = new NonTerminal("Statements(Compound)", typeof(ScriptCompoundStatement)); #endregion #region 2.4 Program and Functions NonTerminal Prog = new NonTerminal("Prog", typeof(ScriptProg)); NonTerminal Element = new NonTerminal("Element", typeof(ScriptAst)); NonTerminal Elements = new NonTerminal("Elements", typeof(ScriptElements)); NonTerminal FuncDef = new NonTerminal("FuncDef", typeof(ScriptFunctionDefinition)); NonTerminal FuncContract = new NonTerminal("FuncContract", typeof(ScriptFuncContract)); NonTerminal ParameterList = new NonTerminal("ParamaterList", typeof(ScriptFuncParameters)); NonTerminal FuncContractPre = new NonTerminal("Pre Conditions", typeof(ScriptFuncContractPre)); NonTerminal FuncContractPost = new NonTerminal("Post Conditions", typeof(ScriptFuncContractPost)); NonTerminal FuncContractInv = new NonTerminal("Invariant Conditions", typeof(ScriptFuncContractInv)); #endregion #endregion #region 3. BNF rules #region 3.1 Expressions ConstExpr.Rule = Symbol("true") | "false" | "null" | s | n; BinExpr.Rule = Expr + BinOp + Expr | IsExpr; UnaryExpr.Rule = LUnOp + Expr; IsExpr.Rule = Expr + @is + TypeExpr; TypeConvertExpr.Rule = LCb + Expr + RCb + Expr.Q(); AssignExpr.Rule = QualifiedName + "=" + Expr | QualifiedName + "++" | QualifiedName + "--" | QualifiedName + ":=" + Expr | QualifiedName + "+=" + Expr | QualifiedName + "-=" + Expr; //TODO: MetaFeatures; // <[ ] + > because of conflict a[1]>2 MetaExpr.Rule = LMb + Elements + RMb; GlobalList.Rule = "global" + LCb + ParameterList + RCb; FuncDefExpr.Rule = "function" + LCb + ParameterList + RCb + GlobalList.Q() + FuncContract.Q() + BlockStatement; Expr.Rule = ConstExpr | BinExpr | UnaryExpr | QualifiedName | AssignExpr | NewStmt | FuncDefExpr | NewArrStmt | ArrayConstructor | MObjectConstructor | TypeConvertExpr | MetaExpr ; NewStmt.Rule = "new" + TypeConstructor; NewArrStmt.Rule = "new" + TypeExpr + ArrayResolution; BinOp.Rule = Symbol("+") | "-" | "*" | "/" | "%" | "^" | "&" | "|" | "&&" | "||" | "==" | "!=" | greater | less | ">=" | "<="; LUnOp.Rule = Symbol("~") | "-" | "!" | "$"; ArrayConstructor.Rule = LSb + ExprList + RSb; MObjectPart.Rule = v + arrow + Expr; MObjectParts.Rule = MakePlusRule(MObjectParts, comma, MObjectPart); MObjectConstructor.Rule = LSb + MObjectParts + RSb; OptionalExpression.Rule = Expr.Q(); #endregion #region 3.2 QualifiedName TypeExpr.Rule = //MakePlusRule(TypeExpr, dot, v); v + GenericsPostfix.Q() | TypeExpr + dot + (v + GenericsPostfix.Q()); GenericsPostfix.Rule = LGb + TypeList + RGb; FunctionCall.Rule = LCb + ExprList.Q() + RCb; ArrayResolution.Rule = LSb + ExprList + RSb; QualifiedName.Rule = v + (GenericsPostfix | ArrayResolution | FunctionCall).Star() | QualifiedName + dot + v + (GenericsPostfix | ArrayResolution | FunctionCall).Star(); ExprList.Rule = MakePlusRule(ExprList, comma, Expr); TypeList.Rule = MakePlusRule(TypeList, comma, TypeExpr); TypeConstructor.Rule = TypeExpr + FunctionCall; #endregion #region 3.3 Statement Condition.Rule = LCb + Expr + RCb; IfStatement.Rule = "if" + Condition + Statement + ("else" + Statement).Q(); WhileStatement.Rule = "while" + Condition + Statement; ForStatement.Rule = "for" + LCb + OptionalExpression + semicolon + OptionalExpression + semicolon + OptionalExpression + RCb + Statement; ForEachStatement.Rule = "foreach" + LCb + v + "in" + Expr + RCb + Statement; UsingStatement.Rule = "using" + LCb + Expr + RCb + BlockStatement; TryCatchFinallyStatement.Rule = "try" + BlockStatement + "catch" + LCb + v + RCb + BlockStatement + "finally" + BlockStatement; SwitchStatement.Rule = "switch" + LCb + Expr + RCb + LFb + SwitchStatements + RFb; ExprStatement.Rule = Expr + semicolon; FlowControlStatement.Rule = "break" + semicolon | "continue" + semicolon | "return" + Expr + semicolon | "throw" + Expr + semicolon; Statement.Rule = semicolon | IfStatement //1. If | WhileStatement //2. While | ForStatement //3. For | ForEachStatement //4. ForEach | UsingStatement //5. Using | SwitchStatement //6. Switch | BlockStatement //7. Block | TryCatchFinallyStatement //8. TryCatch | ExprStatement //9. Expr | FlowControlStatement; //10. FlowControl Statements.SetOption(TermOptions.IsList); Statements.Rule = Statements + Statement | Empty; BlockStatement.Rule = LFb + Statements + RFb; SwitchStatements.Rule = SwitchCaseStatement.Star() + SwitchDefaultStatement.Q(); SwitchCaseStatement.Rule = Symbol("case") + Expr + colon + Statements; SwitchDefaultStatement.Rule = "default" + colon + Statements; #endregion #region 3.4 Prog FuncContract.Rule = LSb + FuncContractPre + semicolon + FuncContractPost + semicolon + FuncContractInv + semicolon + RSb; FuncContractPre.Rule = "pre" + LCb + ExprList.Q() + RCb; FuncContractPost.Rule = "post" + LCb + ExprList.Q() + RCb; FuncContractInv.Rule = "invariant" + LCb + ExprList.Q() + RCb; ParameterList.Rule = MakeStarRule(ParameterList, comma, v); FuncDef.Rule = "function" + v + LCb + ParameterList + RCb + GlobalList.Q() + FuncContract.Q() + BlockStatement; Element.Rule = Statement | FuncDef; Elements.SetOption(TermOptions.IsList); Elements.Rule = Elements + Element | Empty; Prog.Rule = Elements + Eof; Terminal Comment = new CommentTerminal("Comment", "/*", "*/"); NonGrammarTerminals.Add(Comment); Terminal LineComment = new CommentTerminal("LineComment", "//", "\n"); NonGrammarTerminals.Add(LineComment); #endregion #endregion #region 4. Set starting symbol if (!expressionGrammar) { Root = Prog; // Set grammar root } else { Root = Expr; } #endregion #region 5. Operators precedence RegisterOperators(1, "=", "+=", "-=", ":="); RegisterOperators(2, "|", "||"); RegisterOperators(3, "&", "&&"); RegisterOperators(4, "==", "!=", ">", "<", ">=", "<="); RegisterOperators(5, "is"); RegisterOperators(6, "+", "-"); RegisterOperators(7, "*", "/", "%"); RegisterOperators(8, Associativity.Right, "^"); RegisterOperators(9, "~", "!", "$", "++", "--"); RegisterOperators(10, "."); //RegisterOperators(10, Associativity.Right, ".",",", ")", "(", "]", "[", "{", "}"); //RegisterOperators(11, Associativity.Right, "else"); #endregion #region 6. Punctuation symbols RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";"); #endregion }