public ExpressionEvaluatorGrammar() { // 1. Terminals var identifier = new RegexBasedTerminal("identifier", "[a-z\\d_^~]+"); // 2. Non-terminals var root = new NonTerminal("root"); var block = new NonTerminal("block"); var expression = new NonTerminal("expression"); var expressions = new NonTerminal("expressions"); var prop = new NonTerminal("prop"); var op = new NonTerminal("op"); // 3. BNF rules op.Rule = ToTerm("OR") | "AND"; prop.Rule = identifier + "=" ; expression.Rule = "{" + (prop | block) + "}" + "|" ; expressions.Rule = MakeStarRule(expressions, expression); block.Rule = expressions + op; root.Rule = "{" + block +"}"; Root = root; //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source this.LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public GramaticaStr() : base(caseSensitive: false) { RegexBasedTerminal color = new RegexBasedTerminal("color", "#[0-9A-Fa-f]+"); RegexBasedTerminal entero = new RegexBasedTerminal("ent", "[0-9]+"); NonTerminal INICIO = new NonTerminal("INICIO"); NonTerminal ESTILO = new NonTerminal("ESTILO"); NonTerminal LISTA = new NonTerminal("LISTA"); INICIO.Rule = "{" + LISTA + "}"; LISTA.Rule = MakePlusRule(LISTA, ToTerm(","), ESTILO); ESTILO.Rule = ToTerm("negrilla") | ToTerm("cursiva") | ToTerm("subrayado") | ToTerm("color") + ":" + color | ToTerm("tam") + ":" + entero; this.Root = INICIO; this.MarkPunctuation(",", "@", ":", "}", "{"); }
public GramaticaUSQL() : base(caseSensitive: false) { #region EXPRESIONES REGULARES RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+"); IdentifierTerminal id = new IdentifierTerminal("id"); #endregion #region TERMINALES var plus = ToTerm("+"); var minus = ToTerm("-"); var mult = ToTerm("*"); var div = ToTerm("/"); #endregion #region NO TERMINALES NonTerminal S = new NonTerminal("S"), E = new NonTerminal("E"); #endregion #region GRAMATICA S.Rule = E; E.Rule = E + plus + E | E + minus + E | E + mult + E | E + div + E | numero | id; #endregion #region PREFERENCIAS this.Root = S; #endregion }
void InitializeTerminalFields() { foreach (var field in this.GetType().GetFields().Where(f => f.FieldType == typeof(RegexBasedTerminal))) { var patternFieldInfo = typeof(PowerShellGrammar).GetField( field.Name + "_pattern", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static ); var pattern = patternFieldInfo.GetValue <string>(null); var regexBasedTerminal = new RegexBasedTerminal(field.Name, pattern); field.SetValue(this, regexBasedTerminal); } // I'd rather that any other token be selected over `generic_token`, since it's, you know, generic. generic_token.Priority = TerminalPriority.Low - 1; foreach (var field in this.GetType().GetFields().Where(f => f.FieldType == typeof(KeyTerm))) { field.SetValue(this, ToTerm(field.Name)); } // we want 'Get-ChildItem' to parse as a single token, not as 'Get - ChildItem' dash.Priority = TerminalPriority.Low; }
public Gramatica() : base(caseSensitive: false) // inidcamos si nuestro lenguaje es case sentive { #region expresionesER RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+"); #endregion #region TERMINALES var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var div = ToTerm("/"); #endregion #region NOTERMINAL NonTerminal S = new NonTerminal("S"), E = new NonTerminal("E"), F = new NonTerminal("F"), T = new NonTerminal("T"); #endregion #region GRAMATICA S.Rule = E; E.Rule = E + mas + T | E + menos + T | T; T.Rule = T + por + F | T + div + F | F; F.Rule = numero; this.Root = S; #endregion }
public GramaticaCadena() : base(caseSensitive: false) { RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\?[0-9])?"); RegexBasedTerminal numerodecimal = new RegexBasedTerminal("decimanl", "[0-9]+[.][0-9]+"); CommentTerminal cadena = new CommentTerminal("string", "\"", ".", "\""); // es una cadena String CommentTerminal r_char = new CommentTerminal("caracteres", "'", ".", "'"); // es un caracter char #region No Terminales var mas = ToTerm("+"); NonTerminal S = new NonTerminal("S"), SUMACADENA = new NonTerminal("SUMACADENA"); #endregion #region Gramatica //Gramatica ambigua: S.Rule = SUMACADENA; SUMACADENA.Rule = cadena; /* cadena + mas + cadena | cadena + mas + numero | numero + mas + cadena | cadena + mas + numerodecimal | numerodecimal + mas + cadena | cadena + mas + r_char | r_char + mas + cadena;*/ #endregion #region Preferencias this.Root = S; #endregion }
public GramaticaOperaciones() : base(caseSensitive: false) { #region RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+"); RegexBasedTerminal numerodecimal = new RegexBasedTerminal("numero-decimal", "-?[0-9]+(\\.?[0-9]+)?"); //RegexBasedTerminal numerodecimal = new RegexBasedTerminal("numero decimal", "-?[0-9]+.[0-9]+"); RegexBasedTerminal variable = new RegexBasedTerminal("variable", "[a-zA-Z]+[0-9]*"); #endregion #region var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var div = ToTerm("/"); var parentesisizquierdo = ToTerm("("); var parentesisderecho = ToTerm(")"); var raizcuad = ToTerm("√"); var potencia = ToTerm("^"); #endregion #region NonTerminal raiz = new NonTerminal("raiz"), E = new NonTerminal("E"), add = new NonTerminal("add"), muldiv = new NonTerminal("muldiv"), potraiz = new NonTerminal("potraiz"), parentesis = new NonTerminal("parentesis"), vars = new NonTerminal("vars"), nodos = new NonTerminal("nodos"); #endregion #region Gramatica raiz.Rule = nodos; //E.Rule = E + mas + E // |E + menos + E // |E + por + E // |E + div + E // |variable // |numero // ; nodos.Rule = nodos + mas + nodos | nodos + menos + nodos | nodos + por + nodos | nodos + div + nodos | variable | numero | numerodecimal | parentesisizquierdo + nodos + parentesisderecho | nodos + raizcuad + nodos | nodos + potencia + nodos ; #endregion #region Preferencias this.Root = raiz; this.RegisterOperators(20, Associativity.Left, mas, menos); this.RegisterOperators(30, Associativity.Left, por, div); //this.MarkPunctuation(parentesisizquierdo,parentesisderecho); #endregion }
public ProductGrammar() : base(false) { #region 1. Terminals var number = new NumberLiteral("number", NumberOptions.AllowSign); var leg = new RegexBasedTerminal("Leg", @"[a-z]+leg"); var coupon = new RegexBasedTerminal("Coupon", @"[a-z]+coupon"); #endregion #region 2. Non-terminals var Product = new NonTerminal("Product"); var Cancellable = new NonTerminal("Cancellable"); var CancellableType = new NonTerminal("CancellableType"); var DecomposableProduct = new NonTerminal("DecomposableProduct"); var Term = new NonTerminal("Term"); var WeightedDecomposable = new NonTerminal("WeightedDecomposable"); var DecomposableCombination = new NonTerminal("DecomposableCombination"); var CombinationOp = new NonTerminal("CombinationOp", "operator"); var ParDecomposable = new NonTerminal("ParDecomposable"); #endregion #region 3. BNF rules Product.Rule = DecomposableProduct | Cancellable; Cancellable.Rule = CancellableType + PreferShiftHere() + "[" + DecomposableProduct + "]"; CancellableType.Rule = ToTerm("AutoCall") | "Callable" | "Target"; DecomposableProduct.Rule = Term | WeightedDecomposable | DecomposableCombination; Term.Rule = ParDecomposable | coupon | leg; WeightedDecomposable.Rule = number + "*" + Term; ParDecomposable.Rule = "(" + DecomposableProduct + ")"; DecomposableCombination.Rule = DecomposableProduct + CombinationOp + DecomposableProduct; CombinationOp.Rule = ToTerm("+") | "-"; #endregion Root = Product; #region 4. Operators precedence RegisterOperators(10, "?"); RegisterOperators(15, "&", "&&", "|", "||"); RegisterOperators(20, "==", "<", "<=", ">", ">=", "!="); RegisterOperators(30, "+", "-"); RegisterOperators(40, "*", "/"); RegisterOperators(50, Associativity.Right, "**"); // 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, DecomposableProduct, CombinationOp, ParDecomposable, Product); #endregion }
/// <summary> /// Class constructor and grammar definition /// </summary> public FtpGrammar() : base(false) { // declare keywords var openKeyword = ToTerm("open"); var changeDirKeyword = ToTerm("cd"); var dirKeyword = ToTerm("dir"); var listKeyword = ToTerm("ls"); var closeKeyword = ToTerm("close"); var getKeyword = ToTerm("get"); var byeKeyword = ToTerm("bye"); var backfolderKeyword = ToTerm(".."); var rootfolderKeyword = ToTerm(@"\"); // declare non-terminals var program = new NonTerminal("program"); var commandList = new NonTerminal("commandList"); var command = new NonTerminal("command"); var openCommand = new NonTerminal("open"); var changeDirCommand = new NonTerminal("cd"); var dirCommand = new NonTerminal("dir"); var closeCommand = new NonTerminal("close"); var getCommand = new NonTerminal("get"); var byeCommand = new NonTerminal("byeCommand"); var url = new NonTerminal("url"); var folderName = new NonTerminal("folderName"); var quotedUrl = new StringLiteral("quotedUrl", "\""); var unquotedUrl = new IdentifierTerminal("unquotedUrl"); var quotedIdentifier = new StringLiteral("quotedIdentifier", "\""); var unquotedIdentifier = new IdentifierTerminal("unquotedIdentifier"); var filename = new RegexBasedTerminal("filename", @"[a-zA-Z0-9\.\-_]+"); // note: space not allowed. // grammar rules program.Rule = commandList; commandList.Rule = this.MakePlusRule(commandList, null, command); command.Rule = openCommand | changeDirCommand | dirCommand | closeCommand | getCommand | byeCommand; openCommand.Rule = openKeyword + url + this.NewLine; // string_literal + string_literal + changeDirCommand.Rule = changeDirKeyword + rootfolderKeyword + this.NewLine | changeDirKeyword + backfolderKeyword + this.NewLine | changeDirKeyword + folderName + this.NewLine; dirCommand.Rule = (dirKeyword | listKeyword) + this.NewLine; closeCommand.Rule = closeKeyword + this.NewLine; getCommand.Rule = getKeyword + unquotedIdentifier + this.NewLine; // vai ser preciso usar uma regex para o nome do ficheiro byeCommand.Rule = byeKeyword + this.NewLine; //// string regex = @"^[a-zA-Z0-9\.-_ ]+$" (cuidado com ., .., ...) e os espaços //// inválidos: \/:*?"<>| url.Rule = quotedUrl | unquotedUrl; folderName.Rule = quotedIdentifier | filename; // remove these notes as children in the AST this.MarkPunctuation("open", "dir", "ls", "close", "get", "cd", "bye"); this.Root = program; // LanguageFlags |= LanguageFlags.CreateAst; }
public Gramatica() : base(caseSensitive: false) { var ALOGIN = ToTerm("[+LOGIN]"); var CLOGIN = ToTerm("[-LOGIN]"); var AUSER = ToTerm("[+USER]"); var CUSER = ToTerm("[-USER]"); var APASS = ToTerm("[+PASS]"); var CPASS = ToTerm("[-PASS]"); var ALOGOUT = ToTerm("[+LOGOUT]"); var CLOGOUT = ToTerm("[-LOGOUT]"); var AQUERY = ToTerm("[+QUERY]"); var CQUERY = ToTerm("[-QUERY]"); var ASTRUCT = ToTerm("[+STRUCT]"); var CSTRUCT = ToTerm("[-STRUCT]"); RegexBasedTerminal DATA = new RegexBasedTerminal("DATA", "\\[\\+DATA\\](.|\\n|\\r)+\\[-DATA\\]"); RegexBasedTerminal IDENTIFICADOR = new RegexBasedTerminal("IDENTIFICADOR", "([a-zA-Z_])[a-zA-Z0-9_]*"); RegexBasedTerminal CLAVE = new RegexBasedTerminal("CLAVE", "[a-zA-Z0-9]*"); NonTerminal init = new NonTerminal("init"); NonTerminal paquetes = new NonTerminal("paquetes"); NonTerminal paquete = new NonTerminal("paquete"); NonTerminal login = new NonTerminal("login"); NonTerminal logout = new NonTerminal("logout"); NonTerminal query = new NonTerminal("query"); NonTerminal bases = new NonTerminal("bases"); init.Rule = paquetes ; paquetes.Rule = MakePlusRule(paquetes, paquete) ; paquete.Rule = login | logout | query | bases ; login.Rule = ALOGIN + AUSER + IDENTIFICADOR + CUSER + APASS + CLAVE + CPASS + CLOGIN ; logout.Rule = ALOGOUT + AUSER + IDENTIFICADOR + CUSER + CLOGOUT ; query.Rule = AQUERY + AUSER + IDENTIFICADOR + CUSER + DATA + CQUERY ; bases.Rule = ASTRUCT + AUSER + IDENTIFICADOR + CUSER + CSTRUCT ; this.Root = init; }
public Gramatica2() : base(caseSensitive: false) { #region ER RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+"); IdentifierTerminal id = new IdentifierTerminal("id"); #endregion #region Terminales var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var div = ToTerm("/"); #endregion #region No Terminales NonTerminal S = new NonTerminal("S"), E = new NonTerminal("E"), T = new NonTerminal("T"), F = new NonTerminal("F"); #endregion #region Gramatica S.Rule = E; E.Rule = E + mas + E | E + menos + E | E + por + E | E + div + E | ToTerm("(") + E + ToTerm(")") | ToTerm("(") + E + ToTerm(")") + ToTerm("^") + E | numero + ToTerm("^") + E | numero | id; /* //Gramatica no ambigua * S.Rule = E; * E.Rule = E + mas + T | E + menos + T | T; | T.Rule = T + por + F | T + div + F | F; | F.Rule = id | numero;*/ #endregion #region Preferencias this.Root = S; #endregion }
public TransformationRuleGrammar() { #region 1-Terminals - in PascalCase var LowLetter = new RegexBasedTerminal("LowLetter", "[a-z]"); var Disable = ToTerm("Disabled_rule_don't_type_this_and_if_you_do_you're_just_beginning_for_things_to_break", "disabled"); #endregion #region 2-NonTerminals var VarExpression = new NonTerminal(Names.VarExpression); var DynamicCell = new NonTerminal(Names.DynamicCell); var DynamicConstant = new NonTerminal(Names.DynamicConstant); var DynamicRange = new NonTerminal(Names.DynamicRange); #endregion #region 3-Rules VarExpression.Rule = LowLetter | Number | VarExpression + InfixOp + VarExpression; // Constant arrays have the same syntax as dynamic cells, so disable them ConstantArray.Rule = Disable; MarkTransient(ConstantArray); DynamicCell.Rule = OpenCurlyParen + VarExpression + comma + VarExpression + CloseCurlyParen; // Structured references have the same syntax as dynamic constants, so disable them StructureReference.Rule = Disable; MarkTransient(StructureReference); DynamicConstant.Rule = EnclosedInBracketsToken; DynamicRange.Rule = OpenCurlyParen + LowLetter + CloseCurlyParen; // This solves reduce-reduce conflicts with multiple disabled rules var Disabled = new NonTerminal("DISABLED", Disable + ReduceHere()); MarkTransient(Disabled); Reference.Rule = Reference.Rule | DynamicRange | DynamicCell | Disabled; Formula.Rule = Formula.Rule | DynamicConstant; #endregion }
public Gramatica() : base() { #region No Terminales var noTerminalInicio = new NonTerminal(NoTerminalInicio); var noTerminalTipo = new NonTerminal(NoTerminalTipo); var noTerminalValor = new NonTerminal(NoTerminalValor); #endregion #region Terminales var terminalTipoInt = ToTerm(TerminalTipoInt); var terminalTipoFloat = ToTerm(TerminalTipoFloat); var terminalTipoDouble = ToTerm(TerminalTipoDouble); var terminalTipoString = ToTerm(TerminalTipoString); var terminalIgual = ToTerm(TerminalIgual); var terminalPuntoYComa = ToTerm(TerminalPuntoYComa); #endregion #region Expresiones Regulares var regexIdentificador = new RegexBasedTerminal(RegexIdentificador); var regexValorNumero = new RegexBasedTerminal(RegexValorNumero); var regexValorString = new RegexBasedTerminal(RegexValorString); var regexValorIdentificador = new RegexBasedTerminal(RegexValorIdentificador); #endregion #region Reglas de produccion noTerminalInicio.Rule = noTerminalTipo + regexIdentificador + terminalPuntoYComa | noTerminalTipo + regexIdentificador + terminalPuntoYComa + noTerminalInicio | noTerminalTipo + regexIdentificador + terminalIgual + noTerminalValor + terminalPuntoYComa | noTerminalTipo + regexIdentificador + terminalIgual + noTerminalValor + terminalPuntoYComa + noTerminalInicio; noTerminalTipo.Rule = terminalTipoInt | terminalTipoFloat | terminalTipoDouble | terminalTipoString; noTerminalValor.Rule = regexValorNumero | regexValorString | regexValorIdentificador; #endregion Root = noTerminalInicio; }
public GramaticaNumerosEnteros() : base(caseSensitive: false) { #region ER //RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\.?[0-9])?"); RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\?[0-9])?"); //RegexBasedTerminal numerodecimal = new RegexBasedTerminal("[0-9]+ [.] [0-9]+ "); //IdentifierTerminal id = new IdentifierTerminal("id"); #endregion #region Terminales var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var div = ToTerm("/"); var pot = ToTerm("^"); #endregion #region No Terminales NonTerminal S = new NonTerminal("S"), E = new NonTerminal("E"); #endregion #region Gramatica //Gramatica ambigua: S.Rule = E; E.Rule = E + mas + E | E + menos + E | E + por + E | E + div + E | E + pot + E | ToTerm("(") + E + ToTerm(")") | numero; #endregion #region Preferencias this.Root = S; this.RegisterOperators(20, Associativity.Left, mas, menos); this.RegisterOperators(30, Associativity.Left, por, div); this.RegisterOperators(40, Associativity.Left, pot); //this.MarkPunctuation("."); #endregion }
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 }
public HTMLGrammar() { KeyTerm leftAnguralBracket = new KeyTerm("<", "LeftAngularBarakcet"); KeyTerm rightAnguralBracket = new KeyTerm(">", "RightAngularBarakcet"); KeyTerm leftAngularBracketEndTag = new KeyTerm("</", "LeftAngularBracketEndTag"); KeyTerm rightAngularBracketEndTag = new KeyTerm("/>", "RightAngularBracketEndTag"); NonTerminal element = new NonTerminal("Element"); NonTerminal emptyElementTag = new NonTerminal("EmptyElementTag"); NonTerminal startTag = new NonTerminal("StartTag"); NonTerminal content = new NonTerminal("Content"); NonTerminal endTag = new NonTerminal("EndTag"); RegexBasedTerminal name = new RegexBasedTerminal("Name", "\\w+"); element.Rule = emptyElementTag | startTag + content + endTag; emptyElementTag.Rule = leftAnguralBracket + name + rightAngularBracketEndTag; startTag.Rule = leftAnguralBracket + name + rightAnguralBracket; endTag.Rule = leftAngularBracketEndTag + name + rightAnguralBracket; content.Rule = MakeStarRule(content, element); this.Root = element; }
public Gramatica() : base(false) { // Expresiones regulares se escribe de la siguiente forma //existe multiples formas de crear expresiones regulares puedes revisar la documentacion. RegexBasedTerminal palabra = new RegexBasedTerminal("palabra", "[0-9]*[a-zA-Z][0-9a-zA-Z]*"); RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+"); CommentTerminal comm = new CommentTerminal("comm", "\n", "\r"); base.NonGrammarTerminals.Add(comm); //la gramatica siguiente acepta cadenas de entradas de la forma : esto-es-una-lista-de-555-numeros-y-letras-55-61-12-32 //Declaracion de no terminales NonTerminal S = new NonTerminal("S"), L = new NonTerminal("L"); //S.Rule para escribir el cuerpo de un no terminal con todas sus producciones. S.Rule = L; L.Rule = L + "-" + numero | numero | L + "-" + palabra | palabra; //indicamos la produccion inicial con la siguiente linea this.Root = S; MarkPunctuation("-"); }
public Gramaticao() : base(caseSensitive: true) { #region ER RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+"); RegexBasedTerminal deci = new RegexBasedTerminal("decimal", "[0-9]+[.][0-9]+"); IdentifierTerminal id = new IdentifierTerminal("id"); CommentTerminal str = new CommentTerminal("cadena", "\"", "\""); CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n"); CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/-", "-/"); StringLiteral cha = TerminalFactory.CreateCSharpChar("caracter"); #endregion #region Terminales var url = ToTerm("http"); var heredar = ToTerm("hereda_de"); var sla = ToTerm("~"); var pt = ToTerm(";"); var dosp = ToTerm(":"); var par1 = ToTerm("("); var par2 = ToTerm(")"); var principal = ToTerm("principal"); var intt = ToTerm("entero"); var stringg = ToTerm("cadena"); var doublee = ToTerm("decimal"); var charr = ToTerm("caracter"); var booll = ToTerm("booleano"); var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var division = ToTerm("/"); var poten = ToTerm("pow"); var publico = ToTerm("publico"); var protegido = ToTerm("protegido"); var privado = ToTerm("privado"); var corch1 = ToTerm("["); var corch2 = ToTerm("]"); var llave1 = ToTerm("{"); var llave2 = ToTerm("}"); var truee = ToTerm("true"); var falsee = ToTerm("false"); var and = ToTerm("and"); var or = ToTerm("or"); var not = ToTerm("not"); var xor = ToTerm("xor"); var mayor = ToTerm(">"); var menor = ToTerm("<"); var mayori = ToTerm(">="); var menori = ToTerm("<="); var iguali = ToTerm("=="); var distinto = ToTerm("!="); var imprimir = ToTerm("imprimir"); var metodo = ToTerm("metodo"); var funcion = ToTerm("funcion"); var retornar = ToTerm("retorno"); var clase = ToTerm("clase"); var nuevo = ToTerm("nuevo"); var si = ToTerm("Si"); var sino = ToTerm("Sino"); var caso = ToTerm("caso"); var defecto = ToTerm("defecto"); var mientras = ToTerm("Mientras"); var hacer = ToTerm("hacer"); var salir = ToTerm("salir"); var continuar = ToTerm("continuar"); var repetir = ToTerm("Repetir"); var hasta = ToTerm("until"); var x = ToTerm("X"); var para = ToTerm("Para"); var masmas = ToTerm("++"); var menmen = ToTerm("--"); var igual = ToTerm("="); var superr = ToTerm("super"); var importar = ToTerm("importar"); var self = ToTerm("este"); var elegir = ToTerm("elegir"); var llamar = ToTerm("llamar"); #endregion #region No Terminales NonTerminal S = new NonTerminal("S"), E = new NonTerminal("E"), DECGF = new NonTerminal("DECGF"), BLOQUE = new NonTerminal("BLOQUE"), SENTENCIA = new NonTerminal("SENTENCIA"), MOSTRAR = new NonTerminal("MOSTRAR"), LID = new NonTerminal("LID"), LVEC = new NonTerminal("LVEC"), LVEC1 = new NonTerminal("LVEC1"), TIPO = new NonTerminal("TIPO"), VALOR = new NonTerminal("VALOR"), CLASE = new NonTerminal("CLASE"), FUNCIONES = new NonTerminal("FUNCIONES"), CFUN = new NonTerminal("CFUN"), LLAMAR = new NonTerminal("LLAMAR"), ASG = new NonTerminal("ASIGNAR"), ENTERES = new NonTerminal("ENTERES"), PARAMETROS = new NonTerminal("PARAMETROS"), CFUNCIONES = new NonTerminal("CFUNCIONES"), DEC = new NonTerminal("DEC"), DEC2 = new NonTerminal("DEC2"), DECV = new NonTerminal("DECV"), DECV1 = new NonTerminal("DECV1"), PRIV = new NonTerminal("PRIVACIADA"), IMPRESION = new NonTerminal("IMPRESION"), IFC = new NonTerminal("IFC"), LLAMADA = new NonTerminal("LLAMADA"), IF = new NonTerminal("IF"), FOR = new NonTerminal("FOR"), ASIGNACION = new NonTerminal("ASIGNACION"), METODOS = new NonTerminal("METODOS"), PRINCIPAL = new NonTerminal("PRINCIPAL"), LELIF = new NonTerminal("LELIF"), ELIF = new NonTerminal("ELIF"), ELSE = new NonTerminal("ELSE"), COND = new NonTerminal("COND"), ELEGIR = new NonTerminal("ELEGIR"), CASO = new NonTerminal("CASO"), CASO2 = new NonTerminal("CASO2"), DEF = new NonTerminal("DEF"), RET = new NonTerminal("RET"), CICLOS = new NonTerminal("CICLOS"), SAL = new NonTerminal("SAL"), WHILE = new NonTerminal("WHILE"), DOWHILE = new NonTerminal("DO"), INCREMENTO = new NonTerminal("INCRE"), CONDIFOR = new NonTerminal("CONDI"), ATRIBUTOS = new NonTerminal("ATRIBUTOS"), ATRIBUTO1 = new NonTerminal("ATRIBUTO1"), ATRIO = new NonTerminal("ATRIO"), OPEREL = new NonTerminal("OPEREL"), TABU1 = new NonTerminal("TABU"), DECLARACION = new NonTerminal("DECLARACION"), LSENTENCIAS = new NonTerminal("LSENTENCIAS"), TIPO2 = new NonTerminal("TIPO2"), PARA = new NonTerminal("PARA"), PARAMETROS1 = new NonTerminal("PARAMETROS1"), CUERPO = new NonTerminal("CUERPO"), CUERPO2 = new NonTerminal("CUERPO2"), LCUERPO = new NonTerminal("LCUERPO"), DECG = new NonTerminal("DECG"), CONSTRUCTOR = new NonTerminal("CONSTRUCTOR"), INSTANCIA = new NonTerminal("INSTANCIA"), SUPER = new NonTerminal("SUPER"), SELF = new NonTerminal("SELF"), ATRIBUTO = new NonTerminal("ATRIBUTO"), HERENCIA = new NonTerminal("HERENCIA"), MIENTRAS = new NonTerminal("MIENTRAS"), HACER = new NonTerminal("HACER"), REPETIR = new NonTerminal("REPETIR"), LOOP = new NonTerminal("X"), MM = new NonTerminal("MM"), TABU = new NonTerminal("TABULACIONES"), IMPORT = new NonTerminal("IMPORT"), IMPORT2 = new NonTerminal("IMPORT2"), PATH = new NonTerminal("PATH"), PATH2 = new NonTerminal("PATH2"), URL = new NonTerminal("URL"), TIPOA = new NonTerminal("TIPOA"), PARAF = new NonTerminal("FOR"), S1 = new NonTerminal("S1"), EA = new NonTerminal("EA"), VALA = new NonTerminal("VALA"), VALA2 = new NonTerminal("VALA2"), LE = new NonTerminal("LE"), DEC3 = new NonTerminal("DEC3"), DEC4 = new NonTerminal("DEC"), DEC5 = new NonTerminal("DEC5"), EC = new NonTerminal("E"), NATIVAS = new NonTerminal("NATIVAS"); #endregion #region Gramatica S.Rule = IMPORT2 + S1; S1.Rule = MakePlusRule(S1, CLASE); IMPORT2.Rule = MakePlusRule(IMPORT2, IMPORT) | Empty; IMPORT.Rule = importar + par1 + str + par2 + pt | llamar + par1 + str + par2 + pt; TIPOA.Rule = ToTerm("olc") | ToTerm("tree"); PATH.Rule = MakePlusRule(PATH, sla, id); CLASE.Rule = clase + id + HERENCIA + llave1 + LCUERPO + llave2; HERENCIA.Rule = heredar + id | Empty; LCUERPO.Rule = MakePlusRule(LCUERPO, CUERPO); PRINCIPAL.Rule = principal + par1 + par2 + llave1 + BLOQUE + llave2; CUERPO.Rule = METODOS | DECGF | CONSTRUCTOR | PRINCIPAL; PRIV.Rule = protegido | privado | publico | Empty; PARA.Rule = TIPO2 + id | TIPO2 + id + LVEC; PARAMETROS.Rule = MakePlusRule(PARAMETROS, ToTerm(","), PARA) | Empty; CONSTRUCTOR.Rule = id + par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2; FUNCIONES.Rule = par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2; METODOS.Rule = PRIV + metodo + id + par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2; BLOQUE.Rule = MakeStarRule(BLOQUE, SENTENCIA); SENTENCIA.Rule = DEC | ATRIBUTO + pt | LLAMADA + pt | ASIGNACION | SELF | CICLOS | MM + pt | salir + pt | continuar + pt | RET | IMPRESION; LLAMADA.Rule = id + par1 + LE + par2; RET.Rule = retornar + E + pt; INSTANCIA.Rule = nuevo + id + par1 + LE + par2; IMPRESION.Rule = imprimir + par1 + E + par2 + pt; ASIGNACION.Rule = ATRIBUTO + ASG + pt; SELF.Rule = self + ToTerm(".") + ATRIBUTO + ASG + pt; ATRIBUTO.Rule = MakePlusRule(ATRIBUTO, ToTerm("."), ATRIBUTOS); ATRIBUTOS.Rule = id | id + par1 + EA + par2 | id + LVEC; EA.Rule = LE | Empty; ASG.Rule = igual + E | igual + INSTANCIA; CICLOS.Rule = IF | PARAF | MIENTRAS | HACER | REPETIR | LOOP; IF.Rule = si + par1 + COND + par2 + llave1 + BLOQUE + llave2 + LELIF; LELIF.Rule = MakePlusRule(LELIF, ELIF) | Empty; ELIF.Rule = sino + si + par1 + COND + par2 + llave1 + BLOQUE + llave2 | sino + llave1 + BLOQUE + llave2; ELEGIR.Rule = elegir + caso + corch1 + E + corch2 + dosp + CASO + DEF; CASO2.Rule = E + dosp + BLOQUE; DEF.Rule = defecto + dosp + BLOQUE; CASO.Rule = MakePlusRule(CASO, CASO2); MIENTRAS.Rule = mientras + par1 + COND + par2 + llave1 + BLOQUE + llave2; HACER.Rule = hacer + llave1 + BLOQUE + llave2 + mientras + par1 + COND + par2 + pt; REPETIR.Rule = repetir + llave1 + BLOQUE + llave2 + hasta + par1 + COND + par2 + pt; PARAF.Rule = para + par1 + intt + id + igual + E + pt + COND + pt + MM + par2 + llave1 + BLOQUE + llave2; MM.Rule = ATRIBUTO + masmas | ATRIBUTO + menmen; LOOP.Rule = x + par1 + COND + ToTerm(",") + COND + par2 + llave1 + BLOQUE + llave2; DECGF.Rule = PRIV + TIPO2 + id + (DECG | FUNCIONES); DEC3.Rule = ToTerm(",") + LID | LVEC | Empty; DEC5.Rule = E | VALA | INSTANCIA; DEC4.Rule = igual + DEC5 | Empty; DECG.Rule = DEC3 + DEC4 + pt | LVEC + DEC4 + pt; LE.Rule = MakePlusRule(LE, ToTerm(","), E) | Empty; VALA.Rule = MakePlusRule(VALA, ToTerm(","), VALA2); VALA2.Rule = llave1 + LE + llave2 | llave1 + VALA + llave2; DEC.Rule = TIPO2 + DEC2 + DEC4 + pt; DEC2.Rule = LID | id + LVEC; LVEC1.Rule = corch1 + E + corch2; LVEC.Rule = MakePlusRule(LVEC, LVEC1); LID.Rule = MakePlusRule(LID, ToTerm(","), id); OPEREL.Rule = iguali | mayor | menor | mayori | menori | distinto; E.Rule = E + OPEREL + E | E + mas + E | E + menos + E | E + por + E | E + division + E | E + poten + E | E + masmas | E + menmen | par1 + E + par2 | VALOR; COND.Rule = COND + or + COND | COND + and + COND | COND + xor + COND | not + COND | EC + OPEREL + EC | VALOR; EC.Rule = EC + mas + EC | EC + menos + EC | EC + por + EC | EC + division + EC | EC + poten + EC | VALOR; VALOR.Rule = numero | deci | str | truee | falsee | cha | LLAMADA | self + ToTerm(".") + ATRIBUTO | ATRIBUTO; TIPO.Rule = intt | stringg | charr | booll | doublee; TIPO2.Rule = TIPO | id; #endregion #region Preferencias this.Root = S; this.NonGrammarTerminals.Add(comentarioLinea); this.NonGrammarTerminals.Add(comentarioBloque); this.MarkTransient(VALOR, PRIV, TIPO, TIPO2, SENTENCIA, CUERPO2, BLOQUE, CICLOS, CUERPO, PARAMETROS1, EA); this.RegisterOperators(2, Associativity.Left, mas, menos); this.RegisterOperators(3, Associativity.Left, por, division); this.RegisterOperators(4, Associativity.Left, poten); this.RegisterOperators(6, Associativity.Left, and); this.RegisterOperators(7, Associativity.Left, or); this.RegisterOperators(8, Associativity.Left, xor); this.RegisterOperators(9, Associativity.Left, not); this.RegisterOperators(10, Associativity.Left, iguali, distinto, mayor, menor, mayori, menori); this.MarkPunctuation(":", ".", "llamar", "hereda_de", "=", "Para", "X", "Si", "Sino", "Mientras", "Repetir", "until", "este", "metodo", "principal", "imprimir", ";", ",", "[", "]", "(", ")", "~", "{", "}", "void", "funcion", "clase", "si", "si_no_si", "si_no", "elegir", "caso", "defecto", "mientras", "para", "hacer", "repetir", "hasta", "loop"); #endregion }
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 AnalizadorPaquete() : base(false) { //Reservadas RegexBasedTerminal INICIO = new RegexBasedTerminal("Inicio", "\\["); RegexBasedTerminal FIN = new RegexBasedTerminal("Fin", "\\]"); RegexBasedTerminal COMA = new RegexBasedTerminal("COMA", ","); RegexBasedTerminal PAQUETE = new RegexBasedTerminal("PAQUETE", "\"paquete\""); RegexBasedTerminal USQL = new RegexBasedTerminal("USQL ", "\"usql\""); RegexBasedTerminal INSTRUCCION = new RegexBasedTerminal("INSTRUCCION ", "\"instrucción\""); RegexBasedTerminal REPORTE = new RegexBasedTerminal("REPORTE", "\"reporte\""); RegexBasedTerminal COMANDO = new RegexBasedTerminal("COMANDO", "\"comando\""); RegexBasedTerminal VALIDAR = new RegexBasedTerminal("VALIDAR", "\"validar\""); RegexBasedTerminal RFIN = new RegexBasedTerminal("RFIN", "\"fin\""); RegexBasedTerminal LOGIN = new RegexBasedTerminal("LOGIN", "\"login\""); RegexBasedTerminal FLECHA = new RegexBasedTerminal("FLECHA", "=>"); //Datos StringLiteral DATOS = new StringLiteral("DATOS", "'"); NumberLiteral Entero = new NumberLiteral("entero"); //No Terminales NonTerminal S = new NonTerminal("S"), inicio = new NonTerminal("inicio"), cuerpo = new NonTerminal("cuerpo"), login = new NonTerminal("login"), paquete = new NonTerminal("paquete"), sublogin = new NonTerminal("sublogin"), reporte = new NonTerminal("reporte"), fin = new NonTerminal("fin"), usql = new NonTerminal("usql"); S.Rule = inicio; inicio.Rule = INICIO + cuerpo + FIN; cuerpo.Rule = login | paquete; login.Rule = VALIDAR + ":" + Entero + COMA + sublogin; login.ErrorRule = SyntaxError + FIN; sublogin.Rule = LOGIN + ":" + INICIO + COMANDO + FLECHA + DATOS + FIN; sublogin.ErrorRule = SyntaxError + FIN; paquete.Rule = PAQUETE + ":" + fin | PAQUETE + ":" + usql | PAQUETE + ":" + reporte; reporte.Rule = REPORTE + COMA + INSTRUCCION + ":" + DATOS + COMA; fin.Rule = FIN; usql.Rule = USQL + COMA + INSTRUCCION + ":" + DATOS + COMA; usql.ErrorRule = SyntaxError + FIN; this.Root = S; }
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 ArrayList errores; public Gramatica_Lup() : base(caseSensitive: false) { //ERRORES //errores = new ArrayList(); //ACEPTACION var aceptacion = ToTerm("$"); //CONTENIDO RegexBasedTerminal contenido = new RegexBasedTerminal("contenido", "[^\\[-]*"); //ETIQUETAS var _login = ToTerm("login"); var _user = ToTerm("user"); var _pass = ToTerm("pass"); var _logout = ToTerm("logout"); var _query = ToTerm("query"); var _data = ToTerm("data"); var _struct = ToTerm("struct"); //ESTRUCTURA ETIQUETAS var corcheteAbre = ToTerm("["); var corcheteCierra = ToTerm("]"); var mas = ToTerm("+"); var menos = ToTerm("-"); //NO TERMINALES NonTerminal INICIO = new NonTerminal("INICIO"), ABRE_ETIQUETA = new NonTerminal("ABRE_ETIQUETA"), CIERRE_ETIQUETA = new NonTerminal("CIERRE_ETIQUETA"), ETIQUETA_PADRE = new NonTerminal("ETIQUETA_PADRE"), ETIQUETA_LOGIN = new NonTerminal("ETIQUETA_LOGIN"), ETIQUETA_LOGOUT = new NonTerminal("ETIQUETA_LOGOUT"), ETIQUETA_QUERY = new NonTerminal("ETIQUETA_QUERY"), ETIQUETA_STRUCT = new NonTerminal("ETIQUETA_STRUCT"), ETIQUETA_USER = new NonTerminal("ETIQUETA_USER"), ETIQUETA_PASS = new NonTerminal("ETIQUETA_PASS"), ETIQUETA_DATA = new NonTerminal("ETIQUETA_DATA"), CONTENIDO = new NonTerminal("CONTENIDO"); //PREFERENCIAS this.Root = INICIO; this.MarkPunctuation("$", "]", "[", "+", "-", "user", "data", "query", "login", "pass", "logout", "struct"); this.MarkTransient(INICIO, ETIQUETA_PADRE, ABRE_ETIQUETA, CIERRE_ETIQUETA, CONTENIDO, ETIQUETA_USER, ETIQUETA_PASS, ETIQUETA_DATA); //GRAMATICA INICIO.Rule = ABRE_ETIQUETA + ETIQUETA_PADRE + corcheteCierra + aceptacion | aceptacion ; ABRE_ETIQUETA.Rule = corcheteAbre + mas; CIERRE_ETIQUETA.Rule = corcheteAbre + menos; ETIQUETA_PADRE.Rule = ETIQUETA_LOGIN | ETIQUETA_LOGOUT | ETIQUETA_QUERY | ETIQUETA_STRUCT ; ETIQUETA_LOGIN.Rule = _login + corcheteCierra + ETIQUETA_USER + ETIQUETA_PASS + CIERRE_ETIQUETA + _login; ETIQUETA_LOGOUT.Rule = _logout + corcheteCierra + ETIQUETA_USER + CIERRE_ETIQUETA + _logout; ETIQUETA_QUERY.Rule = _query + corcheteCierra + ETIQUETA_USER + ETIQUETA_DATA + CIERRE_ETIQUETA + _query; ETIQUETA_STRUCT.Rule = _struct + corcheteCierra + ETIQUETA_USER + CIERRE_ETIQUETA + _struct; ETIQUETA_USER.Rule = ABRE_ETIQUETA + _user + CONTENIDO + _user + corcheteCierra; ETIQUETA_PASS.Rule = ABRE_ETIQUETA + _pass + CONTENIDO + _pass + corcheteCierra; ETIQUETA_DATA.Rule = ABRE_ETIQUETA + _data + CONTENIDO + _data + corcheteCierra; CONTENIDO.Rule = corcheteCierra + contenido + CIERRE_ETIQUETA; }
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 Gramatica3D() : base(false) { RegexBasedTerminal iniCuerpo = new RegexBasedTerminal("iniCuerpo", "{"); RegexBasedTerminal finCuerpo = new RegexBasedTerminal("finCuerpo", "}"); //Visibilidad RegexBasedTerminal publico = new RegexBasedTerminal("publico", "publico "); RegexBasedTerminal privado = new RegexBasedTerminal("privado", "privado "); RegexBasedTerminal protegido = new RegexBasedTerminal("protegido", "protegido "); //Reservadas RegexBasedTerminal funcion = new RegexBasedTerminal("funcion", "fuction "); //Identificador normal IdentifierTerminal ID = new IdentifierTerminal("ID"); //Temporales RegexBasedTerminal temporal = new RegexBasedTerminal("temporal", "t[0-9]+ "); //Etiquetas RegexBasedTerminal etiqueta = new RegexBasedTerminal("etiqueta", "L[0-9]+ "); RegexBasedTerminal Goto = new RegexBasedTerminal("Goto", "Goto "); RegexBasedTerminal RIF = new RegexBasedTerminal("RIF", "if "); RegexBasedTerminal RIFALSE = new RegexBasedTerminal("RIFFalse", "iffalse "); RegexBasedTerminal RPrint = new RegexBasedTerminal("Print", "Print\\("); //tipos de datos NumberLiteral Entero = new NumberLiteral("entero"); RegexBasedTerminal Doble = new RegexBasedTerminal("Doble", "[0-9]+\\.[0-9]{6}"); RegexBasedTerminal Verdadero = new RegexBasedTerminal("verdadero", "verdadero|true"); RegexBasedTerminal Falso = new RegexBasedTerminal("falso", "falso|false"); RegexBasedTerminal Caracter = new RegexBasedTerminal("Caracter", "\'([a-zA-Z0-9]|#(n|f|t)|#|\\[|\\])\'"); StringLiteral Cadena = new StringLiteral("Cadena", "\""); //Relaciones RegexBasedTerminal Igual = new RegexBasedTerminal("igual", "=="); RegexBasedTerminal Diferente = new RegexBasedTerminal("Diferente", "!="); RegexBasedTerminal Menor = new RegexBasedTerminal("menor", "<"); RegexBasedTerminal Mayor = new RegexBasedTerminal("mayor", ">"); RegexBasedTerminal MenorQue = new RegexBasedTerminal("menor_que", "<="); RegexBasedTerminal MayorQue = new RegexBasedTerminal("mayor_que", ">="); //Artimeticos RegexBasedTerminal suma = new RegexBasedTerminal("suma", "\\+"); RegexBasedTerminal resta = new RegexBasedTerminal("resta", "-"); RegexBasedTerminal multiplicacion = new RegexBasedTerminal("multi", "\\*"); RegexBasedTerminal division = new RegexBasedTerminal("div", "\\/"); RegexBasedTerminal potencia = new RegexBasedTerminal("power", "\\^"); //Otros RegexBasedTerminal llamar = new RegexBasedTerminal("llamar", "Call "); NonTerminal S = new NonTerminal("S"), Cabeza = new NonTerminal("Cabeza"), Visibilidad = new NonTerminal("Visibilidad"), Componentes = new NonTerminal("Componentes"), Componente = new NonTerminal("Componente"), Sentencias = new NonTerminal("Sentencias"), Sentencia = new NonTerminal("Sentencia"), If = new NonTerminal("IF"), Asignacion = new NonTerminal("Asignacion"), Imprimir = new NonTerminal("Imprimir"), Label = new NonTerminal("Label"), Labels = new NonTerminal("Labels"), Globales = new NonTerminal("Globales"), Operacion = new NonTerminal("Operacion"), Operador = new NonTerminal("Operador"), Condicion = new NonTerminal("Condicion"), OCondicion = new NonTerminal("OCondicion"), Go_to = new NonTerminal("Go_to"), Valor = new NonTerminal("Valor"), Clases = new NonTerminal("Clases"), llanada = new NonTerminal("llanada"), Cuerpo = new NonTerminal("Cuerpo"); S.Rule = Clases; Clases.Rule = Clases + Cabeza | Cabeza; Cabeza.Rule = Visibilidad + ID + iniCuerpo + Globales + Componentes + finCuerpo | Visibilidad + ID + iniCuerpo + Componentes + finCuerpo; Globales.Rule = Globales + Asignacion | Asignacion; Componentes.Rule = Componentes + Componente | Componente; Componente.Rule = Visibilidad + funcion + ID + "(" + ")" + iniCuerpo + Labels + finCuerpo; Sentencias.Rule = Sentencias + Sentencia | Sentencia; Sentencia.Rule = If | Asignacion | Go_to | Imprimir | llanada; Asignacion.Rule = ID + "=" + Operacion | ID + "[" + Operacion + "]" + "=" + Operacion | temporal + "=" + Operacion; Operacion.Rule = ID + Operador + ID //3 | ID + Operador + temporal //3 | ID + Operador + Valor //3 | temporal + Operador + temporal //3 | temporal + Operador + ID //3 | temporal + Operador + Valor //3 | Valor + Operador + temporal //3 | Valor + Operador + ID //3 | Valor + Operador + Valor //3 | ID + "[" + ID + "]" //4 | ID + "[" + temporal + "]" //4 | ID + "[" + Valor + "]" //4 | ID | temporal | Valor; If.Rule = RIF + Condicion + Goto + etiqueta //4 | RIFALSE + Condicion + Goto + etiqueta; //4 Imprimir.Rule = RPrint + Operacion + ")"; Labels.Rule = Labels + Label | Label; Label.Rule = etiqueta + Sentencias | etiqueta | Sentencias; Valor.Rule = Entero | Verdadero | Falso | Caracter | Doble | Cadena; Condicion.Rule = ID + OCondicion + ID | ID + OCondicion + temporal | ID + OCondicion + Valor | temporal + OCondicion + temporal | temporal + OCondicion + ID | temporal + OCondicion + Valor | ID + "[" + ID + "]" | ID + "[" + temporal + "]" | ID + "[" + Valor + "]" | Valor + OCondicion + temporal | Valor + OCondicion + ID | Valor + OCondicion + Valor; Operador.Rule = suma | resta | multiplicacion | division | potencia; OCondicion.Rule = Igual | Diferente | Mayor | Menor | MayorQue | MenorQue; Visibilidad.Rule = publico | privado | protegido; Go_to.Rule = Goto + etiqueta; llanada.Rule = llamar + ID + "()"; this.Root = S; }
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 CSGrammar() { // Statement var statements = new NonTerminal("statements"); var statement = new NonTerminal("statement"); var block = new NonTerminal("block"); // Comment var inlineComment = new CommentTerminal("inlineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var blockedComment = new CommentTerminal("blockedComment", "/*", "*/"); NonGrammarTerminals.Add(inlineComment); NonGrammarTerminals.Add(blockedComment); // Operators var plus = ToTerm("+"); var minus = ToTerm("-"); var asterisk = ToTerm("*"); var slash = ToTerm("/"); var percent = ToTerm("%"); var equal = ToTerm("="); var equal2 = ToTerm("=="); var notequal = ToTerm("!="); var lt = ToTerm("<"); var gt = ToTerm(">"); var le = ToTerm("<="); var ge = ToTerm(">="); var and = ToTerm("&"); var pipe = ToTerm("|"); var bang = ToTerm("!"); var hat = ToTerm("^"); var opTilde = ToTerm("~"); var and2 = ToTerm("&&"); var or2 = ToTerm("||"); var lt2 = ToTerm("<<"); var gt2 = ToTerm(">>"); var plus2 = ToTerm("++"); var minus2 = ToTerm("--"); var parenLeft = ToTerm("("); var parenRight = ToTerm(")"); var braceLeft = ToTerm("{"); var braceRight = ToTerm("}"); var bracketLeft = ToTerm("["); var bracketRight = ToTerm("]"); var colon = ToTerm(":"); var comma = ToTerm(","); var period = ToTerm("."); var semiColon = ToTerm(";"); // keywords var @if = ToTerm("if"); var @else = ToTerm("else"); var @for = ToTerm("for"); var @continue = ToTerm("continue"); var @break = ToTerm("break"); var @switch = ToTerm("switch"); var @case = ToTerm("case"); var @loop = ToTerm("loop"); var @return = ToTerm("return"); var @def = ToTerm("def"); var @each = ToTerm("each"); var @in = ToTerm("in"); var @var = ToTerm("var"); var @const = ToTerm("const"); var @null = ToTerm("null"); var @true = ToTerm("true"); var @false = ToTerm("false"); // Value var valString = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes); var valNumber = new NumberLiteral("number"); var valBoolean = new NonTerminal("boolean") { Rule = @true | @false }; var identifier = new RegexBasedTerminal("identifier", "[a-zA-Z_][a-zA-Z0-9_]*"); // Expressions var expression = new NonTerminal("expression"); var exprAndOr = new NonTerminal("exprAndOr"); var exprComparision = new NonTerminal("exprComparision"); var exprBit = new NonTerminal("exprBit"); var exprAddSub = new NonTerminal("exprAddSub"); var exprMulDiv = new NonTerminal("exprMulDiv"); var exprParen = new NonTerminal("exprParen"); var exprUnary = new NonTerminal("exprUnary"); var exprPreIncDec = new NonTerminal("exprPostIncDec"); var exprPostIncDec = new NonTerminal("exprPostIncDec"); var exprValue = new NonTerminal("exprValue"); var exprStatement = new NonTerminal("exprStatement") { Rule = expression }; // Construct Rules statements.Rule = MakeStarRule(statements, statement); statement.Rule = exprStatement + semiColon | block; block.Rule = braceLeft + statements + braceRight; expression.Rule = exprAndOr; exprAndOr.Rule = exprComparision | exprAndOr + and2 + exprAndOr | exprAndOr + or2 + exprAndOr; exprComparision.Rule = exprBit | exprComparision + equal2 + exprComparision | exprComparision + notequal + exprComparision | exprComparision + lt + exprComparision | exprComparision + gt + exprComparision | exprComparision + le + exprComparision | exprComparision + ge + exprComparision; exprBit.Rule = exprAddSub | exprBit + and + exprBit | exprBit + pipe + exprBit | exprBit + hat + exprBit; exprAddSub.Rule = exprMulDiv | exprAddSub + plus + exprAddSub | exprAddSub + minus + exprAddSub; exprMulDiv.Rule = exprParen | exprMulDiv + asterisk + exprMulDiv | exprMulDiv + slash + exprMulDiv | exprMulDiv + percent + exprMulDiv; exprParen.Rule = exprUnary | parenLeft + expression + parenRight; exprUnary.Rule = exprPreIncDec | plus + exprUnary | minus + exprUnary; exprPreIncDec.Rule = exprPostIncDec | plus2 + identifier | minus2 + identifier; exprPostIncDec.Rule = exprValue | exprPreIncDec + plus2 | exprPreIncDec + plus2; exprValue.Rule = valNumber | valString | valBoolean | identifier; Root = statements; }
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 ExcelFormulaGrammar() : base(false) { #region 1-Terminals #region Symbols and operators var comma = ToTerm(","); var colon = ToTerm(":"); var semicolon = ToTerm(";"); var OpenParen = ToTerm("("); var CloseParen = ToTerm(")"); var CloseSquareParen = ToTerm("]"); var OpenSquareParen = ToTerm("["); var exclamationMark = ToTerm("!"); var CloseCurlyParen = ToTerm("}"); var OpenCurlyParen = ToTerm("{"); var mulop = ToTerm("*"); var plusop = ToTerm("+"); var divop = ToTerm("/"); var minop = ToTerm("-"); var concatop = ToTerm("&"); var expop = ToTerm("^"); // Intersect op is a single space, which cannot be parsed normally so we need an ImpliedSymbolTerminal // Attention: ImpliedSymbolTerminal seems to break if you assign it a priority, and it's default priority is low var intersectop = new ImpliedSymbolTerminal(GrammarNames.TokenIntersect); var percentop = ToTerm("%"); var gtop = ToTerm(">"); var eqop = ToTerm("="); var ltop = ToTerm("<"); var neqop = ToTerm("<>"); var gteop = ToTerm(">="); var lteop = ToTerm("<="); #endregion #region Literals var BoolToken = new RegexBasedTerminal(GrammarNames.TokenBool, "TRUE|FALSE"); BoolToken.Priority = TerminalPriority.Bool; var NumberToken = new NumberLiteral(GrammarNames.TokenNumber, NumberOptions.None); NumberToken.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt }; var TextToken = new StringLiteral(GrammarNames.TokenText, "\"", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak); var ErrorToken = new RegexBasedTerminal(GrammarNames.TokenError, "#NULL!|#DIV/0!|#VALUE!|#NAME\\?|#NUM!|#N/A"); var RefErrorToken = ToTerm("#REF!", GrammarNames.TokenRefError); #endregion #region Functions var UDFToken = new RegexBasedTerminal(GrammarNames.TokenUDF, "(_xll\\.)?[a-zA-Z0-9_.]+\\("); UDFToken.Priority = TerminalPriority.UDF; var ExcelRefFunctionToken = new RegexBasedTerminal(GrammarNames.TokenExcelRefFunction, "(INDEX|OFFSET|INDIRECT)\\("); ExcelRefFunctionToken.Priority = TerminalPriority.ExcelRefFunction; var ExcelFunction = new RegexBasedTerminal(GrammarNames.ExcelFunction, "(" + String.Join("|", excelFunctionList) + ")\\("); ExcelFunction.Priority = TerminalPriority.ExcelFunction; // Using this instead of Empty allows a more accurate trees var EmptyArgumentToken = new ImpliedSymbolTerminal(GrammarNames.TokenEmptyArgument); #endregion #region References and names var VRangeToken = new RegexBasedTerminal(GrammarNames.TokenVRange, "[$]?[A-Z]{1,4}:[$]?[A-Z]{1,4}"); var HRangeToken = new RegexBasedTerminal(GrammarNames.TokenHRange, "[$]?[1-9][0-9]*:[$]?[1-9][0-9]*"); const string CellTokenRegex = "[$]?[A-Z]{1,4}[$]?[1-9][0-9]*"; var CellToken = new RegexBasedTerminal(GrammarNames.TokenCell, CellTokenRegex); CellToken.Priority = TerminalPriority.CellToken; const string NamedRangeRegex = @"[A-Za-z\\_][\w\.]*"; var NamedRangeToken = new RegexBasedTerminal(GrammarNames.TokenNamedRange, NamedRangeRegex); NamedRangeToken.Priority = TerminalPriority.NamedRange; // To prevent e.g. "A1A1" being parsed as 2 celltokens var NamedRangeCombinationToken = new RegexBasedTerminal(GrammarNames.TokenNamedRangeCombination, "(TRUE|FALSE|" + CellTokenRegex + ")" + NamedRangeRegex); NamedRangeCombinationToken.Priority = TerminalPriority.NamedRangeCombination; const string singleQuotedContent = @"\w !@#$%^&*()\-\+={}|:;<>,\./\?" + "\\\""; const string sheetRegEx = @"(([\w\.]+)|('([" + singleQuotedContent + @"]|'')+'))!"; var SheetToken = new RegexBasedTerminal(GrammarNames.TokenSheet, sheetRegEx); SheetToken.Priority = TerminalPriority.SheetToken; const string firstSheetName = "[a-zA-Z0-9]+:"; var MultipleSheetsToken = new RegexBasedTerminal(GrammarNames.TokenMultipleSheets, firstSheetName + sheetRegEx); MultipleSheetsToken.Priority = TerminalPriority.MultipleSheetsToken; var FileToken = new RegexBasedTerminal(GrammarNames.TokenFileNameNumeric, "[0-9]+"); FileToken.Priority = TerminalPriority.FileToken;; var QuotedFileSheetToken = new RegexBasedTerminal(GrammarNames.TokenFileSheetQuoted, @"'\[\d+\]([" + singleQuotedContent + @"]|'')+'!"); QuotedFileSheetToken.Priority = TerminalPriority.QuotedFileToken; var ReservedNameToken = new RegexBasedTerminal(GrammarNames.TokenReservedName, @"_xlnm\.[a-zA-Z_]+"); ReservedNameToken.Priority = TerminalPriority.ReservedName; var DDEToken = new RegexBasedTerminal(GrammarNames.TokenDDE, @"'([\[\]" + singleQuotedContent + @"]|'')+'"); #endregion #region Punctuation MarkPunctuation(exclamationMark); MarkPunctuation(OpenParen, CloseParen); MarkPunctuation(OpenSquareParen, CloseSquareParen); MarkPunctuation(OpenCurlyParen, CloseCurlyParen); #endregion #endregion #region 2-NonTerminals // Most nonterminals are first defined here, so they can be used anywhere in the rules // Otherwise you can only use nonterminals that have been defined previously var Argument = new NonTerminal(GrammarNames.Argument); var Arguments = new NonTerminal(GrammarNames.Arguments); var ArrayColumns = new NonTerminal(GrammarNames.ArrayColumns); var ArrayConstant = new NonTerminal(GrammarNames.ArrayConstant); var ArrayFormula = new NonTerminal(GrammarNames.ArrayFormula); var ArrayRows = new NonTerminal(GrammarNames.ArrayRows); var Bool = new NonTerminal(GrammarNames.Bool); var Cell = new NonTerminal(GrammarNames.Cell); var Constant = new NonTerminal(GrammarNames.Constant); var ConstantArray = new NonTerminal(GrammarNames.ConstantArray); var DynamicDataExchange = new NonTerminal(GrammarNames.DynamicDataExchange); var EmptyArgument = new NonTerminal(GrammarNames.EmptyArgument); var Error = new NonTerminal(GrammarNames.Error); var File = new NonTerminal(GrammarNames.File); var Formula = new NonTerminal(GrammarNames.Formula); var FormulaWithEq = new NonTerminal(GrammarNames.FormulaWithEq); var Function = new NonTerminal(GrammarNames.Function); var FunctionCall = new NonTerminal(GrammarNames.FunctionCall); var HRange = new NonTerminal(GrammarNames.HorizontalRange); var InfixOp = new NonTerminal(GrammarNames.TransientInfixOp); var MultipleSheets = new NonTerminal(GrammarNames.MultipleSheets); var NamedRange = new NonTerminal(GrammarNames.NamedRange); var Number = new NonTerminal(GrammarNames.Number); var PostfixOp = new NonTerminal(GrammarNames.TransientPostfixOp); var Prefix = new NonTerminal(GrammarNames.Prefix); var PrefixOp = new NonTerminal(GrammarNames.TransientPrefixOp); var QuotedFileSheet = new NonTerminal(GrammarNames.QuotedFileSheet); var Reference = new NonTerminal(GrammarNames.Reference); var ReferenceFunction = new NonTerminal(GrammarNames.ReferenceFunction); var ReferenceItem = new NonTerminal(GrammarNames.TransientReferenceItem); var RefError = new NonTerminal(GrammarNames.RefError); var ReservedName = new NonTerminal(GrammarNames.ReservedName); var Sheet = new NonTerminal(GrammarNames.Sheet); var Start = new NonTerminal(GrammarNames.TransientStart); var Text = new NonTerminal(GrammarNames.Text); var Union = new NonTerminal(GrammarNames.Union); var VRange = new NonTerminal(GrammarNames.VerticalRange); #endregion #region 3-Rules #region Base rules Root = Start; Start.Rule = FormulaWithEq | Formula | ArrayFormula ; MarkTransient(Start); ArrayFormula.Rule = OpenCurlyParen + eqop + Formula + CloseCurlyParen; FormulaWithEq.Rule = eqop + Formula; Formula.Rule = Reference | Constant | FunctionCall | ConstantArray | OpenParen + Formula + CloseParen | ReservedName ; //MarkTransient(Formula); ReservedName.Rule = ReservedNameToken; Constant.Rule = Number | Text | Bool | Error ; Text.Rule = TextToken; Number.Rule = NumberToken; Bool.Rule = BoolToken; Error.Rule = ErrorToken; RefError.Rule = RefErrorToken; #endregion #region Functions FunctionCall.Rule = Function + Arguments + CloseParen | PrefixOp + Formula | Formula + PostfixOp | Formula + InfixOp + Formula ; Function.Rule = ExcelFunction | UDFToken; Arguments.Rule = MakeStarRule(Arguments, comma, Argument); //Arguments.Rule = Argument | Argument + comma + Arguments; EmptyArgument.Rule = EmptyArgumentToken; Argument.Rule = Formula | EmptyArgument; //MarkTransient(Argument); PrefixOp.Rule = ImplyPrecedenceHere(Precedence.UnaryPreFix) + plusop | ImplyPrecedenceHere(Precedence.UnaryPreFix) + minop; MarkTransient(PrefixOp); InfixOp.Rule = expop | mulop | divop | plusop | minop | concatop | gtop | eqop | ltop | neqop | gteop | lteop; MarkTransient(InfixOp); //PostfixOp.Rule = ImplyPrecedenceHere(Precedence.UnaryPostFix) + percentop; // ImplyPrecedenceHere doesn't seem to work for this rule, but postfix has such a high priority shift will nearly always be the correct action PostfixOp.Rule = PreferShiftHere() + percentop; MarkTransient(PostfixOp); #endregion #region References Reference.Rule = ReferenceItem | Reference + colon + Reference | Reference + intersectop + Reference | OpenParen + Union + CloseParen | OpenParen + Reference + PreferShiftHere() + CloseParen | Prefix + ReferenceItem | Prefix + UDFToken + Arguments + CloseParen | DynamicDataExchange ; Union.Rule = MakePlusRule(Union, comma, Reference); ReferenceItem.Rule = Cell | NamedRange | ReferenceFunction | VRange | HRange | RefError ; MarkTransient(ReferenceItem); VRange.Rule = VRangeToken; HRange.Rule = HRangeToken; ReferenceFunction.Rule = ExcelRefFunctionToken + Arguments + CloseParen; QuotedFileSheet.Rule = QuotedFileSheetToken; Sheet.Rule = SheetToken; MultipleSheets.Rule = MultipleSheetsToken; Cell.Rule = CellToken; File.Rule = OpenSquareParen + FileToken + CloseSquareParen; DynamicDataExchange.Rule = File + exclamationMark + DDEToken; NamedRange.Rule = NamedRangeToken | NamedRangeCombinationToken; Prefix.Rule = Sheet | File + Sheet | File + exclamationMark | QuotedFileSheet | MultipleSheets | File + MultipleSheets; #endregion #region Arrays ConstantArray.Rule = OpenCurlyParen + ArrayColumns + CloseCurlyParen; ArrayColumns.Rule = MakePlusRule(ArrayColumns, semicolon, ArrayRows); ArrayRows.Rule = MakePlusRule(ArrayRows, comma, ArrayConstant); ArrayConstant.Rule = Constant | PrefixOp + Number | RefError; #endregion #endregion #region 5-Operator Precedence // Some of these operators are neutral associative instead of left associative, // but this ensures a consistent parse tree. As a lot of code is "hardcoded" onto the specific // structure of the parse tree, we like consistency. RegisterOperators(Precedence.Comparison, Associativity.Left, eqop, ltop, gtop, lteop, gteop, neqop); RegisterOperators(Precedence.Concatenation, Associativity.Left, concatop); RegisterOperators(Precedence.Addition, Associativity.Left, plusop, minop); RegisterOperators(Precedence.Multiplication, Associativity.Left, mulop, divop); RegisterOperators(Precedence.Exponentiation, Associativity.Left, expop); RegisterOperators(Precedence.UnaryPostFix, Associativity.Left, percentop); RegisterOperators(Precedence.Reference, Associativity.Left, intersectop, colon); RegisterOperators(Precedence.Reference, Associativity.Left, comma); //RegisterOperators(Precedence.ParameterSeparator, comma); #endregion }
public Language() : base(false) { CommentTerminal LINE_COMMENT = new CommentTerminal("LINE_COMMENT", ">>", "\n", "\r\n"); CommentTerminal BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "<-", "->"); NonGrammarTerminals.Add(BLOCK_COMMENT); NonGrammarTerminals.Add(LINE_COMMENT); ////----------------------------------Terminals with precedence KeyTerm increase = ToTerm("++"); KeyTerm decrease = ToTerm("--"); KeyTerm plus = ToTerm("+"); KeyTerm minus = ToTerm("-"); KeyTerm by = ToTerm("*"); KeyTerm divided = ToTerm("/"); KeyTerm power = ToTerm("^"); KeyTerm lessThan = ToTerm("<"); KeyTerm greaterThan = ToTerm(">"); KeyTerm lessThanEqual = ToTerm("<="); KeyTerm greaterThanEqual = ToTerm(">="); KeyTerm doubleEqual = ToTerm("=="); KeyTerm different = ToTerm("!="); KeyTerm not = ToTerm("!"); KeyTerm and = ToTerm("&&"); KeyTerm or = ToTerm("||"); ////----------------------------------precedence this.RegisterOperators(1, Associativity.Left, or); this.RegisterOperators(2, Associativity.Left, and); this.RegisterOperators(3, Associativity.Left, not); this.RegisterOperators(4, Associativity.Left, doubleEqual, different, lessThan, lessThanEqual, greaterThan, greaterThanEqual); this.RegisterOperators(5, Associativity.Left, plus, minus); this.RegisterOperators(6, Associativity.Left, by, divided); this.RegisterOperators(7, Associativity.Left, power); //Regex var integer = new RegexBasedTerminal("int", "[0-9]+"); var tdouble = TerminalFactory.CreateCSharpNumber("double"); var String = TerminalFactory.CreateCSharpString("string"); var caracter = TerminalFactory.CreateCSharpChar("char"); var boolean = new RegexBasedTerminal("bool", "(true)|(false)"); var iden = TerminalFactory.CreateCSharpIdentifier("id"); var hexa = new RegexBasedTerminal("hexa", "^(\\#)[0-9A-F]+$"); //Non terminals var START = new NonTerminal("START"); var BODY = new NonTerminal("BODY"); var DECLARATION = new NonTerminal("DECLARATION"); var DECLARATION2 = new NonTerminal("DECLARATION2"); var ASSIGNATION = new NonTerminal("ASSIGNATION"); var ASSIGN2 = new NonTerminal("ASSIGN2"); var INDEX = new NonTerminal("INDEX"); var DATATYPE = new NonTerminal("DATATYPE"); var OBJECT = new NonTerminal("OBJECT"); var ASSIGN = new NonTerminal("ASSIGN"); var ARRAY = new NonTerminal("ARRAY"); var ARRAY2 = new NonTerminal("ARRAY2"); var ARRAYASIGN = new NonTerminal("ARRAYASIGN"); var ARRAYASIGN2 = new NonTerminal("ARRAYASIGN2"); var ARRAYASIGN3 = new NonTerminal("ARRAYASIGN3"); var ARRAYLIST = new NonTerminal("ARRAYLIST"); var NATIVE = new NonTerminal("NATIVE"); var PRINT = new NonTerminal("PRINT"); var SHOW = new NonTerminal("SHOW"); var IF = new NonTerminal("IF"); var ELSE = new NonTerminal("ELSE"); var FOR = new NonTerminal("FOR"); var REPEAT = new NonTerminal("REPEAT"); var WHILE = new NonTerminal("WHILE"); var VARMANAGMENT = new NonTerminal("VARMANAGMENT"); var UPDATE = new NonTerminal("UPDATE"); var ESINGLE = new NonTerminal("ESINGLE"); var E = new NonTerminal("E"); var ID = new NonTerminal("ID"); var IDPLUS = new NonTerminal("IDPLUS"); var ARRAYS = new NonTerminal("ARRAYS"); var DOWHILE = new NonTerminal("DOWHILE"); var SWITCH = new NonTerminal("SWITCH"); var CASE = new NonTerminal("CASE"); var DEFAULT = new NonTerminal("DEFAULT"); var CASELIST = new NonTerminal("CASELIST"); var FUNCTION = new NonTerminal("FUNCTION"); var FUNCTIONARGS = new NonTerminal("FUNCTIONARGS"); var VISIBILITY = new NonTerminal("VISIBILITY"); var OVERRIDE = new NonTerminal("OVERRIDE"); var PARAMLIST = new NonTerminal("PARAMLIST"); var PARAM = new NonTerminal("PARAM"); var OPTIONAL = new NonTerminal("OPTIONAL"); var RETURN = new NonTerminal("RETURN"); var RETOPTION = new NonTerminal("RETOPTION"); var LISTMETHODS = new NonTerminal("LISTMETHODS"); var CLASS = new NonTerminal("CLASS"); var EXTENDS = new NonTerminal("EXTENDS"); var EXTENDSLIST = new NonTerminal("EXTENDSLIST"); var CALLFUNC = new NonTerminal("CALLFUNC"); var ADDFIGURE = new NonTerminal("ADDFIGURE"); var GEOMETRICAS = new NonTerminal("GEOMETRICAS"); var COLOR = new NonTerminal("COLOR"); var FIGURE = new NonTerminal("FIGURE"); var MAIN = new NonTerminal("MAIN"); var CLASSIMPLEMENTATION = new NonTerminal("CLASSIMPLEMENTATION"); var CFUNCLIST = new NonTerminal("CFUNCLIST"); var LISTCLASSMETHODS = new NonTerminal("LISTCLASSMETHODS"); var LISTCLASSMETHODS2 = new NonTerminal("LISTCLASSMETHODS2"); var LISTOBJECTS = new NonTerminal("LISTCLASSMETHODS2"); ////----------------------------------Innecesary nodes this.MarkPunctuation(".", "(", ")", "{", "}", "[", "]", ";", "=", ",", "importar", "if", "for", "repeat", "mientras", "show", "hacer", "comprobar", "salir", "caso", ":", "print", "defecto", "clase", "addfigure", "main", "return"); this.MarkTransient(DECLARATION2, LISTCLASSMETHODS2, CLASSIMPLEMENTATION, BODY, ASSIGN2, COLOR, ARRAY2, ARRAYASIGN, ARRAYASIGN2, ARRAYASIGN3, NATIVE, VARMANAGMENT, ESINGLE, ASSIGN, ARRAY, ADDFIGURE, RETOPTION); //----------------------------------Grammar START.Rule = MakePlusRule(START, CLASS); CLASS.Rule = "clase" + iden + EXTENDSLIST + "{" + CLASSIMPLEMENTATION + "}"; CLASS.ErrorRule = SyntaxError + "}"; CLASS.ErrorRule = SyntaxError + ";"; CLASSIMPLEMENTATION.Rule = MakeStarRule(CLASSIMPLEMENTATION, LISTCLASSMETHODS); EXTENDSLIST.Rule = MakeStarRule(EXTENDSLIST, ToTerm(","), EXTENDS); EXTENDS.Rule = ToTerm("importar") + ID; LISTMETHODS.Rule = MakePlusRule(LISTMETHODS, BODY); BODY.Rule = ID + ";" | FIGURE | ADDFIGURE | DECLARATION | ASSIGNATION | UPDATE + ";" | PRINT | SHOW | IF | FOR | REPEAT | WHILE | DOWHILE | SWITCH | OPTIONAL + ";" | Empty | CALLFUNC; //methods inside a function DECLARATION.Rule = DATATYPE + DECLARATION2 + ";"; DECLARATION.ErrorRule = SyntaxError + ";"; DECLARATION2.Rule = LISTOBJECTS | ToTerm("array") + ARRAYS; LISTOBJECTS.Rule = MakePlusRule(LISTOBJECTS, ToTerm(","), OBJECT); ARRAYS.Rule = ID + ARRAY; ASSIGN.Rule = ToTerm("=") + E | Empty; ASSIGNATION.Rule = ID + ASSIGN2 + ";"; ASSIGNATION.ErrorRule = SyntaxError + ";"; ASSIGN2.Rule = ToTerm("=") + E | "[" + E + "]" + ASSIGN2; PRINT.Rule = ToTerm("print") + "(" + E + ")" + ";"; PRINT.ErrorRule = SyntaxError + ";"; SHOW.Rule = ToTerm("show") + "(" + E + "," + E + ")" + ";"; SHOW.ErrorRule = SyntaxError + ";"; IF.Rule = ToTerm("if") + "(" + E + ")" + "{" + LISTMETHODS + "}" + ELSE; IF.ErrorRule = SyntaxError + "}"; IF.ErrorRule = SyntaxError + ";"; ELSE.Rule = ToTerm("else") + IF | ToTerm("else") + "{" + LISTMETHODS + "}" | Empty; FOR.Rule = ToTerm("for") + "(" + VARMANAGMENT + E + ";" + UPDATE + ")" + "{" + LISTMETHODS + "}"; FOR.ErrorRule = SyntaxError + "}"; FOR.ErrorRule = SyntaxError + ";"; REPEAT.Rule = ToTerm("repeat") + "(" + E + ")" + "{" + LISTMETHODS + "}"; REPEAT.ErrorRule = SyntaxError + "}"; REPEAT.ErrorRule = SyntaxError + ";"; VARMANAGMENT.Rule = DECLARATION | ASSIGNATION; UPDATE.Rule = ESINGLE + increase | ESINGLE + decrease; WHILE.Rule = ToTerm("mientras") + "(" + E + ")" + "{" + LISTMETHODS + "}"; WHILE.ErrorRule = SyntaxError + "}"; WHILE.ErrorRule = SyntaxError + ";"; DOWHILE.Rule = ToTerm("hacer") + "{" + LISTMETHODS + "}" + ToTerm("mientras") + "(" + E + ")" + ";"; DOWHILE.ErrorRule = SyntaxError + "}"; DOWHILE.ErrorRule = SyntaxError + ";"; SWITCH.Rule = ToTerm("comprobar") + "(" + E + ")" + "{" + CASELIST + DEFAULT + "}"; SWITCH.ErrorRule = SyntaxError + "}"; SWITCH.ErrorRule = SyntaxError + ";"; CASELIST.Rule = MakePlusRule(CASELIST, CASE); CASE.Rule = ToTerm("caso") + E + ":" + LISTMETHODS + ToTerm("salir") + ";"; DEFAULT.Rule = ToTerm("defecto") + ":" + LISTMETHODS + ToTerm("salir") + ";" | Empty; OPTIONAL.Rule = RETURN | ToTerm("continue"); RETURN.Rule = ToTerm("return") + RETOPTION; RETOPTION.Rule = Empty | E; CALLFUNC.Rule = iden + "(" + CFUNCLIST + ")" + ";"; CFUNCLIST.Rule = MakeStarRule(CFUNCLIST, ToTerm(","), E); CALLFUNC.ErrorRule = SyntaxError + ";"; ADDFIGURE.Rule = ToTerm("addfigure") + "(" + GEOMETRICAS + ")" + ";"; GEOMETRICAS.Rule = ToTerm("circle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("triangle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("square") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("line") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")"; GEOMETRICAS.ErrorRule = SyntaxError + ";"; COLOR.Rule = Empty | E; //it can be a string or id FIGURE.Rule = ToTerm("figure") + "(" + E + ")" + ";"; //Methods inside a class LISTCLASSMETHODS.Rule = VISIBILITY + LISTCLASSMETHODS2 | MAIN; LISTCLASSMETHODS2.Rule = DECLARATION | FUNCTION; MAIN.Rule = ToTerm("main") + "(" + ")" + "{" + LISTMETHODS + "}"; FUNCTION.Rule = iden + FUNCTIONARGS + "(" + PARAMLIST + ")" + "{" + LISTMETHODS + "}"; FUNCTION.ErrorRule = SyntaxError + "}"; FUNCTION.ErrorRule = SyntaxError + ";"; FUNCTIONARGS.Rule = DATATYPE + OVERRIDE | ToTerm("array") + DATATYPE + INDEX + OVERRIDE | ToTerm("void"); VISIBILITY.Rule = Empty | ToTerm("publico") | ToTerm("privado"); OVERRIDE.Rule = Empty | ToTerm("override"); PARAMLIST.Rule = MakeStarRule(PARAMLIST, ToTerm(","), PARAM); PARAM.Rule = iden + iden | DATATYPE + iden; //datatypes DATATYPE.Rule = ToTerm("int") | "bool" | "string" | "double" | "char" | iden; OBJECT.Rule = ID + ASSIGN; //Making arrays ARRAY.Rule = "=" + ARRAYASIGN | Empty; ARRAYASIGN.Rule = ToTerm("{") + ARRAYASIGN2 + "}"; ARRAYASIGN2.Rule = ARRAYASIGN3 | ARRAYLIST; ARRAYASIGN3.Rule = ARRAYASIGN | MakePlusRule(ARRAYASIGN3, ToTerm(","), ARRAYASIGN); ARRAYLIST.Rule = MakePlusRule(ARRAYLIST, ToTerm(","), E); //Making EXP E.Rule = E + plus + E | E + minus + E | E + by + E | E + divided + E | E + power + E | E + doubleEqual + E | E + different + E | E + lessThan + E | E + greaterThan + E | E + lessThanEqual + E | E + greaterThanEqual + E | E + or + E | E + and + E | not + E | ESINGLE | ToTerm("(") + E + ")" | minus + E; ESINGLE.Rule = NATIVE | ID | ToTerm("new") + iden + "(" + CFUNCLIST + ")"; INDEX.Rule = INDEX + ToTerm("[") + E + "]" | Empty; ID.Rule = iden + IDPLUS; IDPLUS.Rule = INDEX | Empty | "(" + CFUNCLIST + ")" | "." + ID; NATIVE.Rule = integer | caracter | String | boolean | tdouble; this.Root = START; }