public void TestCSharpChar()
{
SetTerminal(TerminalFactory.CreateCSharpChar("Char"));
TryMatch("'a' ");
Assert.IsTrue((char)_token.Value == 'a', "Failed to process char.");
TryMatch(@"'\n' ");
Assert.IsTrue((char)_token.Value == '\n', "Failed to process new-line char.");
TryMatch(@"'' ");
Assert.IsTrue(_token.IsError(), "Failed to recognize empty quotes as invalid char literal.");
TryMatch(@"'abc' ");
Assert.IsTrue(_token.IsError(), "Failed to recognize multi-char sequence as invalid char literal.");
//Note: unlike strings, c# char literals don't allow the "@" prefix
}
public void TestString_CSharpChar()
{
var parser = TestHelper.CreateParser(TerminalFactory.CreateCSharpChar("Char"));
var token = parser.ParseInput("'a' ");
Assert.IsTrue((char)token.Value == 'a', "Failed to process char.");
token = parser.ParseInput(@"'\n' ");
Assert.IsTrue((char)token.Value == '\n', "Failed to process new-line char.");
token = parser.ParseInput(@"'' ");
Assert.IsTrue(token.IsError, "Failed to recognize empty quotes as invalid char literal.");
token = parser.ParseInput(@"'abc' ");
Assert.IsTrue(token.IsError, "Failed to recognize multi-char sequence as invalid char literal.");
//Note: unlike strings, c# char literals don't allow the "@" prefix
}
public Gramatica() : base(caseSensitive: true)
{
#region ER
NumberLiteral doble = new NumberLiteral("doble");
IdentifierTerminal id = new IdentifierTerminal("id");
StringLiteral cadena = TerminalFactory.CreateCSharpString("cadena");
StringLiteral carac = TerminalFactory.CreateCSharpChar("cadena");
ConstantTerminal booleano = new ConstantTerminal("booleano");
booleano.Add("true", true);
booleano.Add("false", false);
CommentTerminal comentario2 = new CommentTerminal("comentario2", "</", "/>");
CommentTerminal comentario1 = new CommentTerminal("comentario1", "-->", "\n", "\r\n");
base.NonGrammarTerminals.Add(comentario2);
base.NonGrammarTerminals.Add(comentario1);
#endregion
#region Terminales
var mas = ToTerm("+");
var menos = ToTerm("-");
var mul = ToTerm("*");
var div = ToTerm("/");
var mod = ToTerm("%");
var pot = ToTerm("^");
var parA = ToTerm("(");
var parC = ToTerm(")");
var corA = ToTerm("[");
var corC = ToTerm("]");
var llavA = ToTerm("{");
var llavC = ToTerm("}");
var pYc = ToTerm(";");
var dosPuntos = ToTerm(":");
var coma = ToTerm(",");
var asig = ToTerm("=");
var igual = ToTerm("=");
var mayor = ToTerm(">");
var menor = ToTerm("<");
var mayorIgual = ToTerm(">=");
var menorIgual = ToTerm("<=");
var igualIgual = ToTerm("==");
var noIgual = ToTerm("!=");
var diferecia = ToTerm("~");
var Mostrar = ToTerm("Mostrar");
var resInt = ToTerm("Entero");
var resDouble = ToTerm("Decimal");
var resString = ToTerm("Texto");
var resChar = ToTerm("Caracter");
var resBool = ToTerm("Booleano");
var resVoid = ToTerm("Vacio");
var OR = ToTerm("||");
var AND = ToTerm("&&");
var NOT = ToTerm("!");
var resReturn = ToTerm("Retorno");
var Es_verdadero = ToTerm("Es_verdadero");
var Es_false = ToTerm("Es_falso");
var Cambiar_A = ToTerm("Cambiar_A");
var Valor = ToTerm("Valor");
var No_cumple = ToTerm("No_cumple");
var Para = ToTerm("Para");
var Hasta_que = ToTerm("Hasta_que");
var Mientras = ToTerm("Mientras_que");
var Romper = ToTerm("Romper");
var Continuar = ToTerm("Continuar");
var DibujarAST = ToTerm("DibujarAST");
var DibujarEXP = ToTerm("DibujarEXP");
var DibujarTS = ToTerm("DibujarTS");
var Principal = ToTerm("Principal");
var Importar = ToTerm("Importar");
var Definir = ToTerm("Definir");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
EXPR = new NonTerminal("EXPR"),
EXPL = new NonTerminal("EXPL"),
PROGRAMA = new NonTerminal("PROGRAMA"),
CUERPOS = new NonTerminal("CUERPOS"),
CUERPO = new NonTerminal("CUERPO"),
ATRIBUTOS = new NonTerminal("ATRIBUTOS"),
ATRIBUTO = new NonTerminal("ATRIBUTO"),
DECLARACION = new NonTerminal("DECLARACION"),
ASIGNACION = new NonTerminal("ASIGNACION"),
PRINCIPAL = new NonTerminal("PRINCIPAL"),
METODO = new NonTerminal("METODO"),
FUNCION = new NonTerminal("FUNCION"),
TIPO = new NonTerminal("TIPO"),
MOSTRAR = new NonTerminal("MOSTRAR"),
MOST = new NonTerminal("MOST"),
DIBUJAR = new NonTerminal("DIBUJAR"),
LISTA_ID = new NonTerminal("LISTA_ID"),
LISTA_PARAM = new NonTerminal("LISTA_PARAM"),
DECLA = new NonTerminal("DECLA"),
UNICO = new NonTerminal("UNICO"),
UNICOS = new NonTerminal("UNICOS"),
LLAMADA = new NonTerminal("LLAMADA"),
LLAMFUNC = new NonTerminal("LLAMFUNC"),
OPERANDO = new NonTerminal("OPERANDO"),
RETORNO = new NonTerminal("RETORNO"),
SI = new NonTerminal("SI"),
SINO = new NonTerminal("SINO"),
SINO_SI = new NonTerminal("SINO_SI"),
SINOSI = new NonTerminal("SINOSI"),
INTERRUMPIR = new NonTerminal("INTERRUMPIR"),
CASO = new NonTerminal("CASO"),
CASOS = new NonTerminal("CASOS"),
DEFECTO = new NonTerminal("DEFECTO"),
MIENTRAS = new NonTerminal("MIENTRAS"),
PARA = new NonTerminal("PARA"),
OP = new NonTerminal("OP"),
HACER = new NonTerminal("HACER"),
SALIR = new NonTerminal("SALIR"),
DEFINIR = new NonTerminal("DEFINIR"),
IMPORTAR = new NonTerminal("IMPORTAR"),
IMPORTE = new NonTerminal("IMPORTE");
#endregion
#region Gramatica
S.Rule = PROGRAMA;
PROGRAMA.Rule = CUERPO;
CUERPO.Rule = MakePlusRule(CUERPO, CUERPOS);
CUERPOS.Rule = METODO
| FUNCION
| PRINCIPAL
| DEFINIR
| IMPORTAR
| DECLARACION
| ASIGNACION;
CUERPOS.ErrorRule = SyntaxError + llavC;
CUERPOS.ErrorRule = SyntaxError + pYc;
IMPORTAR.Rule = Importar + IMPORTE + pYc;
IMPORTE.Rule = MakePlusRule(IMPORTE, ToTerm("."), id);
DEFINIR.Rule = Definir + cadena + pYc
| Definir + doble + pYc;
ATRIBUTOS.Rule = MakePlusRule(ATRIBUTOS, ATRIBUTO)
| Empty;
ATRIBUTO.Rule = DECLARACION
| ASIGNACION
| DIBUJAR
| MOSTRAR
| LLAMFUNC
| SALIR
| SI
| INTERRUMPIR
| MIENTRAS
| PARA
| HACER
| RETORNO;
ATRIBUTO.ErrorRule = SyntaxError + pYc;
ATRIBUTO.ErrorRule = SyntaxError + llavC;
METODO.Rule = resVoid + id + parA + LISTA_PARAM + parC + llavA + ATRIBUTOS + llavC;
FUNCION.Rule = TIPO + id + parA + LISTA_PARAM + parC + llavA + ATRIBUTOS + llavC;
PRINCIPAL.Rule = resVoid + Principal + parA + parC + llavA + ATRIBUTOS + llavC;
RETORNO.Rule = resReturn + EXPL + pYc;
SALIR.Rule = Romper + pYc;
DECLARACION.Rule = TIPO + LISTA_ID + pYc;
DECLA.Rule = TIPO + id;
ASIGNACION.Rule = TIPO + LISTA_ID + asig + EXPL + pYc
| id + asig + EXPL + pYc;
DIBUJAR.Rule = DibujarAST + parA + E + parC + pYc
| DibujarEXP + parA + EXPL + parC + pYc
| DibujarTS + parA + parC + pYc;
MOSTRAR.Rule = Mostrar + parA + MOST + parC + pYc;
MOST.Rule = MakePlusRule(MOST, coma, E);
LISTA_ID.Rule = MakePlusRule(LISTA_ID, coma, id);
LISTA_PARAM.Rule = MakePlusRule(LISTA_PARAM, coma, DECLA)
| MakePlusRule(LISTA_PARAM, coma, E)
| Empty;
UNICO.Rule = MakePlusRule(UNICO, OPERANDO, UNICOS);
UNICOS.Rule = E;
LLAMADA.Rule = id + parA + LISTA_PARAM + parC;
LLAMFUNC.Rule = LLAMADA + pYc;
SI.Rule = Es_verdadero + parA + EXPL + parC + llavA + ATRIBUTOS + llavC + SINO;
SINO.Rule = Es_false + llavA + ATRIBUTOS + llavC
| Empty;
INTERRUMPIR.Rule = Cambiar_A + parA + E + parC + llavA + CASOS + DEFECTO + llavC;
CASOS.Rule = MakePlusRule(CASOS, CASO)
| Empty;
CASO.Rule = Valor + E + dosPuntos + ATRIBUTOS;
DEFECTO.Rule = No_cumple + dosPuntos + ATRIBUTOS
| Empty;
MIENTRAS.Rule = Mientras + parA + EXPL + parC + llavA + ATRIBUTOS + llavC;
PARA.Rule = Para + parA + ASIGNACION + EXPL + pYc + OP + parC + llavA + ATRIBUTOS + llavC;
OP.Rule = ToTerm("++") | ToTerm("--");
HACER.Rule = Hasta_que + parA + EXPL + parC + llavA + ATRIBUTOS + llavC;
OPERANDO.Rule = mas | menos | mul | div | pot | mod;
TIPO.Rule = resInt
| resDouble
| resString
| resChar
| resBool;
E.Rule = E + mas + E
| E + menos + E
| E + mul + E
| E + div + E
| E + mod + E
| E + pot + E
| parA + E + parC
| menos + E
| LLAMADA
| id
| doble
| cadena
| booleano
| carac;
EXPR.Rule = E + mayor + E
| E + menor + E
| E + mayorIgual + E
| E + menorIgual + E
| E + igualIgual + E
| E + noIgual + E
| E + diferecia + E
| E;
EXPL.Rule = EXPL + OR + EXPL
| EXPL + AND + EXPL
| NOT + EXPL
| EXPR
| parA + EXPL + parC;
#endregion
#region Preferencias
this.Root = S;
this.MarkTransient(TIPO, UNICOS, CUERPOS);
this.RegisterOperators(1, Associativity.Left, mas, menos);
this.RegisterOperators(2, Associativity.Left, mul, div, mod);
this.RegisterOperators(3, Associativity.Right, pot);
this.RegisterOperators(4, "==", "!=", "<", ">", "<=", ">=");
this.RegisterOperators(5, Associativity.Left, OR);
this.RegisterOperators(6, Associativity.Left, AND);
this.RegisterOperators(7, Associativity.Left, NOT);
this.RegisterOperators(8, "(", ")");
this.MarkPunctuation("(", ")", ",", ";", "[", "]", "=", ":", "{", "}");
#endregion
}
public Gramatica() : base(caseSensitive: true)
{
#region Terminales
//comentarios
CommentTerminal simple = new CommentTerminal("simple", "//", "\n", "\r\n");
CommentTerminal multiple = new CommentTerminal("multiple", "/*", "*/");
NonGrammarTerminals.Add(simple);
NonGrammarTerminals.Add(multiple);
//tipos de datos
var entero = ToTerm("Int", "Int");
var cadena = ToTerm("String", "String");
var doble = ToTerm("Double", "Double");
var booleano = ToTerm("Bool", "Bool");
var caracter = ToTerm("Char", "Char");
var vacio = ToTerm("Void", "Void");
//palabras reservadas
var importar = ToTerm("Import", "Import");
var retornar = ToTerm("Return", "Return");
var imprimir = ToTerm("Print", "Print");
var principal = ToTerm("Main", "Main");
var comparar = ToTerm("CompareTo", "CompareTo");
var obtenerUsuario = ToTerm("GetUser", "GetUser");
//palabras reservadas de sentencias de control
var si = ToTerm("If", "If");
var sino = ToTerm("Else", "Else");
var cambiar = ToTerm("Switch", "Switch");
var caso = ToTerm("Case", "Case");
var defecto = ToTerm("Default", "Default");
var quebrar = ToTerm("Break", "Break");
var para = ToTerm("For", "For");
var mientras = ToTerm("While", "While");
var hacer = ToTerm("Do", "Do");
//operadores aritmeticos
var sumar = ToTerm("+", "+");
var restar = ToTerm("-", "-");
var multiplicar = ToTerm("*", "*");
var dividir = ToTerm("/", "/");
var modular = ToTerm("%", "%");
var elevar = ToTerm("^", "^");
var asignacion = ToTerm("=", "=");
var incremento = ToTerm("++", "++");
var decremento = ToTerm("--", "--");
//operadores relacionales
var menorQue = ToTerm("<", "<");
var mayorQue = ToTerm(">", ">");
var menorIgual = ToTerm("<=", "<=");
var mayorIgual = ToTerm(">=", ">=");
var equivalente = ToTerm("==", "==");
var noEquivalente = ToTerm("!=", "!=");
//operadores logicos
var and = ToTerm("&&", "&&");
var or = ToTerm("||", "||");
var xor = ToTerm("|&", "|&");
var not = ToTerm("!", "!");
//punctuation mark
var finSentencia = ToTerm(";", ";");
var parentesisA = ToTerm("(", "(");
var parentesisC = ToTerm(")", ")");
var llaveA = ToTerm("{", "{");
var llaveC = ToTerm("}", "}");
var dosPuntos = ToTerm(":", ":");
var corcheteA = ToTerm("[", "[");
var corcheteC = ToTerm("]", "]");
var coma = ToTerm(",", ",");
var punto = ToTerm(".", ".");
//valores
var numero = TerminalFactory.CreateCSharpNumber("numero");
var identificador = TerminalFactory.CreateCSharpIdentifier("identificador");
var cad = TerminalFactory.CreateCSharpString("cadena");
var falso = ToTerm("False", "falso");
var verdadero = ToTerm("True", "verdadero");
var car = TerminalFactory.CreateCSharpChar("caracter");
#endregion
#region Precedencias y puntuaciones
this.MarkPunctuation(finSentencia, parentesisA, parentesisC,
llaveA, llaveC, dosPuntos, coma, punto);
RegisterOperators(1, Associativity.Left, sumar, restar);
RegisterOperators(2, Associativity.Left, multiplicar, modular, dividir);
RegisterOperators(3, Associativity.Right, elevar);
RegisterOperators(5, equivalente, noEquivalente, menorQue, menorIgual, mayorQue, mayorIgual);
RegisterOperators(6, Associativity.Left, or);
RegisterOperators(7, Associativity.Left, xor);
RegisterOperators(8, Associativity.Left, and);
RegisterOperators(9, Associativity.Left, not);
RegisterOperators(10, parentesisA, parentesisC);
#endregion
#region No Terminales
NonTerminal INICIO = new NonTerminal("INICIO");
NonTerminal DECLARACION = new NonTerminal("DECLARACION");
NonTerminal PRINCIPAL = new NonTerminal("PRINCIPAL");
NonTerminal ASIGNACION = new NonTerminal("ASIGNACION");
NonTerminal WHILE = new NonTerminal("WHILE");
NonTerminal DO_WHILE = new NonTerminal("DO_WHILE");
NonTerminal IF = new NonTerminal("IF");
NonTerminal ELSE = new NonTerminal("ELSE");
NonTerminal FOR = new NonTerminal("FOR");
NonTerminal SWITCH = new NonTerminal("SWITCH");
NonTerminal LISTA_ACCIONES = new NonTerminal("LISTA_ACCIONES");
NonTerminal ACCION = new NonTerminal("ACCION");
NonTerminal IMPORT = new NonTerminal("IMPORT");
NonTerminal ENCABEZADO = new NonTerminal("ENCABEZADO");
NonTerminal TIPO_DATO = new NonTerminal("TIPO_DATO");
NonTerminal LISTA_VARS = new NonTerminal("LISTA_VARS");
NonTerminal EXPRESION_LOGICA = new NonTerminal("EXPRESION_LOGICA");
NonTerminal EXPRESION_RELACIONAL = new NonTerminal("EXPRESION_RELACIONAL");
NonTerminal EXPRESION = new NonTerminal("EXPRESION");
NonTerminal DECLARACION_ARREGLO = new NonTerminal("DECLARACION_ARREGLO");
NonTerminal ASIGNACION_ARREGLO = new NonTerminal("ASIGNACION_ARREGLO");
NonTerminal LISTA_DATOS = new NonTerminal("LISTA_DATOS");
NonTerminal ASIGNACION_POSICION = new NonTerminal("ASIGNACION_POSICION");
NonTerminal SENTENCIA = new NonTerminal("SENTENCIA");
NonTerminal LISTA_SENTENCIAS = new NonTerminal("LISTA_SENTENCIAS");
NonTerminal PROCEDIMIENTO = new NonTerminal("PROCEDIMIENTO");
NonTerminal LISTA_PARAMETROS = new NonTerminal("LISTA_PARAMETROS");
NonTerminal PARAMETRO = new NonTerminal("PARAMETRO");
NonTerminal FUNCION_PRINT = new NonTerminal("FUNCION_PRINT");
NonTerminal FUNCION_COMPARAR = new NonTerminal("FUNCION_COMPARAR");
NonTerminal RETORNO = new NonTerminal("RETORNO");
NonTerminal OBTENER_USUARIO = new NonTerminal("OBTENER_USUARIO");
NonTerminal OPERADOR_RELACIONAL = new NonTerminal("OPERADOR_RELACIONAL");
NonTerminal LLAMADA = new NonTerminal("LLAMADA");
NonTerminal DINCREMENTO = new NonTerminal("DINCREMENTO");
NonTerminal CASE = new NonTerminal("CASE");
NonTerminal DEFAULT = new NonTerminal("DEFAULT");
NonTerminal CUERPO_SWITCH = new NonTerminal("CUERPO_SWITCH");
NonTerminal LISTA_CASE = new NonTerminal("LISTA_CASE");
NonTerminal VALOR = new NonTerminal("VALOR");
NonTerminal OPCION_SENTENCIAS = new NonTerminal("OPCION_SENTENCIAS");
#endregion
#region reglas gramaticales
//Encabezado
ENCABEZADO.Rule = MakePlusRule(ENCABEZADO, IMPORT)
| IMPORT;
IMPORT.Rule = importar + cad + finSentencia;
// Cuerpo principal
this.Root = INICIO;
INICIO.Rule = ENCABEZADO + LISTA_ACCIONES
| ENCABEZADO
| LISTA_ACCIONES;
LISTA_ACCIONES.Rule = MakePlusRule(LISTA_ACCIONES, ACCION)
| ACCION;
ACCION.Rule = DECLARACION
| PROCEDIMIENTO
| PRINCIPAL
| ASIGNACION
| DECLARACION_ARREGLO
| ASIGNACION_POSICION
| DINCREMENTO + finSentencia
| FUNCION_PRINT + finSentencia;
PRINCIPAL.Rule = principal + dosPuntos + vacio + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC
| principal + dosPuntos + TIPO_DATO + parentesisA + LISTA_PARAMETROS + parentesisC
+ llaveA + OPCION_SENTENCIAS + llaveC
| principal + dosPuntos + vacio + parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC
| principal + dosPuntos + TIPO_DATO + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC;
// Sintaxis de las Declaraciones
TIPO_DATO.Rule = entero | doble | cadena | caracter | booleano;
LISTA_VARS.Rule = MakePlusRule(LISTA_VARS, coma, identificador);
DECLARACION.Rule = LISTA_VARS + dosPuntos + TIPO_DATO + asignacion + EXPRESION_LOGICA + finSentencia
| identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION_LOGICA + finSentencia
| LISTA_VARS + dosPuntos + TIPO_DATO + finSentencia
| identificador + dosPuntos + TIPO_DATO + finSentencia;
// Sintaxis de las Asignaciones
ASIGNACION.Rule = identificador + asignacion + EXPRESION_LOGICA + finSentencia
| identificador + asignacion + llaveA + LISTA_DATOS + llaveC + finSentencia;
// Sintaxis de los arreglos
DECLARACION_ARREGLO.Rule = identificador + dosPuntos + TIPO_DATO
+ corcheteA + EXPRESION + corcheteC + finSentencia
| identificador + dosPuntos + TIPO_DATO + corcheteA + EXPRESION + corcheteC
+ asignacion + ASIGNACION_ARREGLO + finSentencia;
LISTA_DATOS.Rule = MakePlusRule(LISTA_DATOS, coma, EXPRESION_LOGICA)
| EXPRESION_LOGICA;
ASIGNACION_ARREGLO.Rule = llaveA + LISTA_DATOS + llaveC
| identificador;
ASIGNACION_POSICION.Rule = identificador + corcheteA + EXPRESION + corcheteC
+ asignacion + EXPRESION_LOGICA + finSentencia;
//Sintaxis de Metodos y Funciones
PROCEDIMIENTO.Rule = identificador + dosPuntos + TIPO_DATO
+ parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC
| identificador + dosPuntos + vacio
+ parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC
| identificador + dosPuntos + TIPO_DATO
+ parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC
| identificador + dosPuntos + vacio
+ parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC;
PARAMETRO.Rule = identificador + dosPuntos + TIPO_DATO
| identificador + dosPuntos + TIPO_DATO + corcheteA + corcheteC;
LISTA_PARAMETROS.Rule = MakePlusRule(LISTA_PARAMETROS, coma, PARAMETRO)
| PARAMETRO;
LISTA_SENTENCIAS.Rule = MakePlusRule(LISTA_SENTENCIAS, SENTENCIA)
| SENTENCIA;
OPCION_SENTENCIAS.Rule = LISTA_SENTENCIAS | Empty;
SENTENCIA.Rule = DECLARACION
| ASIGNACION
| DECLARACION_ARREGLO
| ASIGNACION_POSICION
| IF
| FOR
| SWITCH
| WHILE
| DO_WHILE
| FUNCION_PRINT + finSentencia
| DINCREMENTO + finSentencia
| LLAMADA + finSentencia
| quebrar + finSentencia
| RETORNO;
RETORNO.Rule = retornar + EXPRESION_LOGICA + finSentencia
| retornar + finSentencia;
//Funciones nativas
FUNCION_PRINT.Rule = imprimir + parentesisA + EXPRESION_LOGICA + parentesisC;
FUNCION_COMPARAR.Rule = punto + comparar + parentesisA + EXPRESION + parentesisC;
OBTENER_USUARIO.Rule = obtenerUsuario + parentesisA + parentesisC;
//If Else
IF.Rule = si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC
| si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC
| si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC + ELSE
| si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC + ELSE;
ELSE.Rule = sino + llaveA + LISTA_SENTENCIAS + llaveC
| sino + llaveA + llaveC;
//While
WHILE.Rule = mientras + parentesisA + EXPRESION_LOGICA + parentesisC
+ llaveA + LISTA_SENTENCIAS + llaveC
| mientras + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC;
//Do While
DO_WHILE.Rule = hacer + llaveA + LISTA_SENTENCIAS + llaveC + mientras + parentesisA
+ EXPRESION_LOGICA + parentesisC + finSentencia
| hacer + llaveA + llaveC + mientras + parentesisA + EXPRESION_LOGICA + parentesisC + finSentencia;
//For
FOR.Rule = para + parentesisA + identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION
+ finSentencia + EXPRESION_LOGICA + finSentencia + DINCREMENTO + parentesisC + llaveA + LISTA_SENTENCIAS
+ llaveC
| para + parentesisA + identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION
+ finSentencia + EXPRESION_LOGICA + finSentencia + DINCREMENTO + parentesisC + llaveA + llaveC;
DINCREMENTO.Rule = identificador + incremento
| identificador + decremento;
//Switch
SWITCH.Rule = cambiar + parentesisA + identificador + parentesisC + llaveA + CUERPO_SWITCH + llaveC;
CUERPO_SWITCH.Rule = LISTA_CASE
| LISTA_CASE + DEFAULT;
LISTA_CASE.Rule = MakePlusRule(LISTA_CASE, CASE)
| CASE;
CASE.Rule = caso + VALOR + dosPuntos + LISTA_SENTENCIAS
| caso + VALOR + dosPuntos;
VALOR.Rule = cad | numero;
DEFAULT.Rule = defecto + dosPuntos + LISTA_SENTENCIAS
| defecto + dosPuntos;
//Llamadas
LLAMADA.Rule = identificador + parentesisA + parentesisC
| identificador + parentesisA + LISTA_DATOS + parentesisC;
// Expresiones
EXPRESION_LOGICA.Rule = EXPRESION_LOGICA + and + EXPRESION_LOGICA
| EXPRESION_LOGICA + or + EXPRESION_LOGICA
| EXPRESION_LOGICA + xor + EXPRESION_LOGICA
| not + EXPRESION_LOGICA
| EXPRESION_RELACIONAL;
EXPRESION_RELACIONAL.Rule = EXPRESION + OPERADOR_RELACIONAL + EXPRESION
| EXPRESION;
OPERADOR_RELACIONAL.Rule = menorQue
| menorIgual
| mayorQue
| mayorIgual
| equivalente
| noEquivalente;
EXPRESION.Rule = EXPRESION + sumar + EXPRESION
| EXPRESION + restar + EXPRESION
| EXPRESION + multiplicar + EXPRESION
| EXPRESION + dividir + EXPRESION
| EXPRESION + modular + EXPRESION
| EXPRESION + elevar + EXPRESION
| restar + EXPRESION
| parentesisA + EXPRESION_LOGICA + parentesisC
| identificador + corcheteA + EXPRESION + corcheteC
| identificador
| LLAMADA
| OBTENER_USUARIO
| verdadero
| falso
| cad
| car
| numero
| identificador + FUNCION_COMPARAR
| identificador + corcheteA + EXPRESION + corcheteC + FUNCION_COMPARAR;
#endregion
}
public Gramatica() : base(caseSensitive: true)
{
#region Expresiones Regulares
//numeros
RegexBasedTerminal Entero = new RegexBasedTerminal("Entero", "[0-9]+");
RegexBasedTerminal Decimal = new RegexBasedTerminal("Decimal", "[0-9]+[.][0-9]+");
RegexBasedTerminal IDMetodo = new RegexBasedTerminal("IDMetodo", "[a-zA-Z]+[_]?[0-9]*");
//id
IdentifierTerminal Id = new IdentifierTerminal("Id");
//cadena
StringLiteral Cadena = new StringLiteral("Cadena", "\"");
StringLiteral Char = TerminalFactory.CreateCSharpChar("Char");
//comentarios
CommentTerminal COMENTARIOLINEA = new CommentTerminal("LINE_COMMENT", "//", "\n", "\r\n");
CommentTerminal COMENTARIOBLOQUE = new CommentTerminal("BLOCK_COMMENT", "/*", "*/");
#endregion
#region Terminales
//tipos de variables.
var tkVOID = ToTerm("Void");
var tkINT = ToTerm("Int");
var tkFLOAT = ToTerm("Float");
var tkBOOL = ToTerm("Boolean");
var tkCHAR = ToTerm("Char");
var tkSTRING = ToTerm("String");
var tkDOUBLE = ToTerm("Double");
var tkMAIN = ToTerm("main");
var tkRETURN = ToTerm("Return");
var tkTRUE = ToTerm("true");
var tkFALSE = ToTerm("false");
var tkIMPORT = ToTerm("Import");
var tkFOR = ToTerm("For");
var tkIF = ToTerm("If");
var tkELSE = ToTerm("Else");
var tkDO = ToTerm("Do");
var tkWHILE = ToTerm("While");
var tkSWITCH = ToTerm("Switch");
var tkCASE = ToTerm("Case");
var tkDEFAULT = ToTerm("Default");
var tkBREAK = ToTerm("Break");
var tkCOMPARE = ToTerm("CompareTo");
var tkGETUSER = ToTerm("GetUser");
var tkPRINT = ToTerm("Print");
var ESPACIO = ToTerm(" ");
//Simbolos
var tkMAS = ToTerm("+");
var tkMENOS = ToTerm("-");
var tkPOR = ToTerm("*");
var tkDIV = ToTerm("/");
var tkPORCENT = ToTerm("%");
var tkPOTENCIA = ToTerm("^");
var tkPARA = ToTerm("(");
var tkPARC = ToTerm(")");
var tkLLAVA = ToTerm("{");
var tkLLAVC = ToTerm("}");
var tkCORA = ToTerm("[");
var tkCORC = ToTerm("]");
var tkMENOR = ToTerm("<");
var tkMAYOR = ToTerm(">");
var tkMENORIGUAL = ToTerm("<=");
var tkMAYORIGUAL = ToTerm(">=");
var tkIGUAL = ToTerm("=");
var tkDISTINTO = ToTerm("!");
var tkOR = ToTerm("||");
var tkXOR = ToTerm("!&");
var tkAND = ToTerm("&&");
var tkPUNTO = ToTerm(".");
var tkPUNTOYCOMA = ToTerm(";");
var tkCOMA = ToTerm(",");
var tkDOSPUNTOS = ToTerm(":");
var tkAPOSTRO = ToTerm("\'");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
INICIO = new NonTerminal("INICIO"),
IMPORTS = new NonTerminal("IMPORTS"),
IMPORTACION = new NonTerminal("IMPORTACION"),
SENTENCIAS = new NonTerminal("SENTENCIAS"),
LISTAIDS = new NonTerminal("LISTAIDS"),
TIPO = new NonTerminal("TIPO"),
DECLARACIONVARIABLES = new NonTerminal("DECLARACIONVARIABLES"),
MASASIGNACION = new NonTerminal("MASASIGNACION"),
ASIGNACION = new NonTerminal("ASIGNACION"),
OPERACION = new NonTerminal("OPERACION"),
OPERACIONES1 = new NonTerminal("OPERACIONES1"),
OPERACIONES2 = new NonTerminal("OPERACIONES2"),
OPERACIONES3 = new NonTerminal("OPERACIONES3"),
OPERACIONES4 = new NonTerminal("OPERACIONES4"),
OPERACIONES5 = new NonTerminal("OPERACIONES5"),
OPERACIONES6 = new NonTerminal("OPERACIONES6"),
OPERACIONES7 = new NonTerminal("OPERACIONES7"),
DECLARACIONMETODOS = new NonTerminal("DECLARACIONMETODOS"),
LISTAPARAMETROS = new NonTerminal("LISTAPARAMETROS"),
LISTASENTENCIAS = new NonTerminal("LISTASENTENCIAS"),
PARAMETRO = new NonTerminal("PARAMETRO"),
IF = new NonTerminal("IF"),
CONDICIONES = new NonTerminal("CONDICIONES"),
BLOQUEELSE = new NonTerminal("BLOQUEELSE"),
WHILE = new NonTerminal("WHILE"),
DO = new NonTerminal("DO"),
CONDICIONES1 = new NonTerminal("CONDICIONES1"),
CONDICIONES2 = new NonTerminal("CONDICIONES2"),
CONDICIONES3 = new NonTerminal("CONDICIONES3"),
CONDICIONES4 = new NonTerminal("CONDICIONES4"),
CONDICIONES5 = new NonTerminal("CONDICIONES5"),
CONDICIONES6 = new NonTerminal("CONDICIONES6"),
CONDICIONES7 = new NonTerminal("CONDICIONES7"),
CONDICIONES8 = new NonTerminal("CONDICIONES8"),
CONDICIONES9 = new NonTerminal("CONDICIONES9"),
CONDICIONES10 = new NonTerminal("CONDICIONES10"),
SWITCH = new NonTerminal("SWITCH"),
LISTACASOS = new NonTerminal("LISTACASOS"),
CASOS = new NonTerminal("CASOS"),
DEFAULT = new NonTerminal("DEFAULT"),
FOR = new NonTerminal("FOR"),
INCREODECRE = new NonTerminal("INCREODECRE"),
PRINT = new NonTerminal("PRINT"),
LISTAEXPRESIONES = new NonTerminal("LISTAEXPRESIONES"),
LLAMADA = new NonTerminal("LLAMADA"),
LISTAPARAMETROSLLAMADA = new NonTerminal("LISTAPARAMETROSLLAMADA"),
PAR = new NonTerminal("PAR"),
RETURN = new NonTerminal("RETURN"),
ASIGNACIONVAR = new NonTerminal("ASIGNACIONVAR"),
VALOR = new NonTerminal("VALOR"),
ACCIONES = new NonTerminal("ACCIONES"),
DECLARACIONARREGLOS = new NonTerminal("DECLARACIONARREGLOS"),
AC = new NonTerminal("AC"),
INICIALIZACIONARREGLO = new NonTerminal("INICIALIZACIONARREGLO"),
LISTADATOS = new NonTerminal("LISTADATOS"),
ASIGNACIONARREGLO = new NonTerminal("ASIGNACIONARREGLO"),
MASASIG = new NonTerminal("MASASIG");
#endregion
#region Gramatica
S.Rule = IMPORTS + INICIO;
;
IMPORTS.Rule = IMPORTS + IMPORTACION
| IMPORTACION
;
IMPORTACION.Rule = tkIMPORT + Cadena + tkPUNTOYCOMA
| Empty
;
INICIO.Rule = INICIO + ACCIONES
| ACCIONES;
//UNICAS ACCIONES QUE SE REALIZARAN DE FORMA GLOBAL.
ACCIONES.Rule = //declaraciones
DECLARACIONVARIABLES
| DECLARACIONMETODOS
| DECLARACIONARREGLOS
//asignaciones
| ASIGNACIONARREGLO
| ASIGNACIONVAR;
#region DECLARACION DE ARREGLO
DECLARACIONARREGLOS.Rule = Id + tkDOSPUNTOS + TIPO + tkCORA + OPERACION + tkCORC + INICIALIZACIONARREGLO + tkPUNTOYCOMA;
INICIALIZACIONARREGLO.Rule = tkIGUAL + tkLLAVA + LISTADATOS + tkLLAVC
| Empty;
LISTADATOS.Rule = LISTADATOS + tkCOMA + CONDICIONES
| CONDICIONES;
#endregion
#region ASIGNACION DE ARREGLOS
ASIGNACIONARREGLO.Rule = Id + tkIGUAL + INICIALIZACIONARREGLO + tkPUNTOYCOMA
| Id + tkCORA + OPERACION + tkCORC + tkIGUAL + CONDICIONES + tkPUNTOYCOMA;
#endregion
#region DECLARACION DE VARIABLES MULTIPLES
DECLARACIONVARIABLES.Rule = Id + MASASIG;
MASASIG.Rule = tkCOMA + LISTAIDS + tkDOSPUNTOS + TIPO + ASIGNACION + tkPUNTOYCOMA
| tkDOSPUNTOS + TIPO + ASIGNACION + tkPUNTOYCOMA;
LISTAIDS.Rule = LISTAIDS + tkCOMA + Id
| Id;
TIPO.Rule = tkINT
| tkDOUBLE
| tkSTRING
| tkCHAR
| tkBOOL;
ASIGNACION.Rule = tkIGUAL + CONDICIONES //<-- (OPERACIONES ARITMETICAS)
| Empty;
#endregion
#region ASIGNACION DE VARIABLE
ASIGNACIONVAR.Rule = Id + tkIGUAL + CONDICIONES + tkPUNTOYCOMA
| Id + INCREODECRE + tkPUNTOYCOMA;
#endregion
#region DECLARACION METODOS
DECLARACIONMETODOS.Rule = Id + tkDOSPUNTOS + TIPO + tkPARA + LISTAPARAMETROS + tkPARC + tkLLAVA + LISTASENTENCIAS + tkLLAVC;
LISTAPARAMETROS.Rule = LISTAPARAMETROS + tkCOMA + PARAMETRO
| PARAMETRO;
PARAMETRO.Rule = Id + tkDOSPUNTOS + TIPO
| Empty;
#endregion
#region LISTASENTENCIAS
LISTASENTENCIAS.Rule = LISTASENTENCIAS + SENTENCIAS //a esta produccion caeran todas las sentencias de metodos, if´s, etc.
| SENTENCIAS;
SENTENCIAS.Rule = IF
| SWITCH
| FOR
| DO
| WHILE
| PRINT
| LLAMADA + tkPUNTOYCOMA
| tkRETURN + OPERACION + tkPUNTOYCOMA //return
| tkBREAK + tkPUNTOYCOMA //break
| ACCIONES
| Empty;
#endregion
#region IF-ELSE
IF.Rule = tkIF + tkPARA + CONDICIONES + tkPARC + tkLLAVA + LISTASENTENCIAS + tkLLAVC + BLOQUEELSE;
BLOQUEELSE.Rule = tkELSE + tkLLAVA + LISTASENTENCIAS + tkLLAVC
| Empty;
#endregion
#region SWITCH
SWITCH.Rule = tkSWITCH + tkPARA + OPERACION + tkPARC + tkLLAVA + LISTACASOS + DEFAULT + tkLLAVC;
LISTACASOS.Rule = LISTACASOS + CASOS
| CASOS;
CASOS.Rule = tkCASE + OPERACION + tkDOSPUNTOS + LISTASENTENCIAS + tkBREAK + tkPUNTOYCOMA;
DEFAULT.Rule = tkDEFAULT + tkDOSPUNTOS + LISTASENTENCIAS + tkBREAK + tkPUNTOYCOMA
| Empty;
#endregion
#region FOR
FOR.Rule = tkFOR + tkPARA + DECLARACIONVARIABLES + CONDICIONES + tkPUNTOYCOMA + Id + INCREODECRE + tkPARC + tkLLAVA + LISTASENTENCIAS + tkLLAVC;
INCREODECRE.Rule = tkMAS + tkMAS
| tkMENOS + tkMENOS;
#endregion
#region DO-WHILE
DO.Rule = tkDO + tkLLAVA + LISTASENTENCIAS + tkLLAVC + tkWHILE + tkPARA + CONDICIONES + tkPARC;
#endregion
#region WHILE
WHILE.Rule = tkWHILE + tkPARA + CONDICIONES + tkPARC + tkLLAVA + LISTASENTENCIAS + tkLLAVC;
#endregion
#region PRINT
PRINT.Rule = tkPRINT + tkPARA + LISTAEXPRESIONES + tkPARC + tkPUNTOYCOMA;
LISTAEXPRESIONES.Rule = LISTAEXPRESIONES + tkMAS + OPERACION
| OPERACION;
#endregion
#region LLAMADA METODO
LLAMADA.Rule = Id + tkPARA + PAR + tkPARC;
PAR.Rule = LISTAPARAMETROSLLAMADA
| Empty;
LISTAPARAMETROSLLAMADA.Rule = LISTAPARAMETROSLLAMADA + tkCOMA + CONDICIONES
| CONDICIONES;
#endregion
#region OPERACIONES ARITMETICAS
OPERACION.Rule = OPERACION + tkMAS + OPERACIONES1
| OPERACIONES1;
OPERACIONES1.Rule = OPERACIONES1 + tkMENOS + OPERACIONES2
| OPERACIONES2;
;
OPERACIONES2.Rule = OPERACIONES2 + tkPOR + OPERACIONES3
| OPERACIONES3;
;
OPERACIONES3.Rule = OPERACIONES3 + tkDIV + OPERACIONES4
| OPERACIONES4;
;
OPERACIONES4.Rule = OPERACIONES4 + tkPORCENT + OPERACIONES5
| OPERACIONES5;
;
OPERACIONES5.Rule = OPERACIONES5 + tkPOTENCIA + OPERACIONES6
| OPERACIONES6;
OPERACIONES6.Rule = tkMENOS + OPERACIONES7
| OPERACIONES7;
OPERACIONES7.Rule = Entero
| Decimal
| Id
| Id + tkCORA + OPERACION + tkCORC //acceso a una posicion de un arreglo
| Char //| Id + INCREODECRE
| Cadena
| LLAMADA //llamada a un metodo
| tkGETUSER + tkPARA + tkPARC //funcion privada que devuelde el usuario logeado
| tkPARA + OPERACION + tkPARC
| tkTRUE
| tkFALSE
//|CONDICIONES
;
#endregion
#region OPERACIONES LOGICAS Y RELACIONALES (CONDICIONES)
CONDICIONES.Rule = CONDICIONES + tkIGUAL + tkIGUAL + CONDICIONES1
| CONDICIONES1
;
CONDICIONES1.Rule = CONDICIONES1 + tkDISTINTO + tkIGUAL + CONDICIONES2
| CONDICIONES2
;
CONDICIONES2.Rule = CONDICIONES2 + tkMAYORIGUAL + CONDICIONES3
| CONDICIONES3
;
CONDICIONES3.Rule = CONDICIONES3 + tkMENORIGUAL + CONDICIONES4
| CONDICIONES4
;
CONDICIONES4.Rule = CONDICIONES4 + tkMAYOR + CONDICIONES5
| CONDICIONES5
;
CONDICIONES5.Rule = CONDICIONES5 + tkMENOR + CONDICIONES6
| CONDICIONES6
;
CONDICIONES6.Rule = CONDICIONES6 + tkOR + CONDICIONES7
| CONDICIONES7
;
CONDICIONES7.Rule = CONDICIONES7 + tkXOR + CONDICIONES8
| CONDICIONES8
;
CONDICIONES8.Rule = CONDICIONES8 + tkAND + CONDICIONES9
| CONDICIONES9
;
CONDICIONES9.Rule = tkDISTINTO + CONDICIONES10 // < --- funcionara como not
| CONDICIONES10
;
CONDICIONES10.Rule = OPERACION
| Id + tkPUNTO + tkCOMPARE + tkPARA + Cadena + tkPARC //compare porque siempre devolvera un tru o un false
| tkPARA + CONDICIONES + tkPARC
;
#endregion
#region Comentarios
//agregamos los comentarios y si vienen que no haga nada.
NonGrammarTerminals.Add(COMENTARIOLINEA);
NonGrammarTerminals.Add(COMENTARIOBLOQUE);
#endregion
#endregion
#region Estado de Inicio
this.Root = S;
#endregion
}
public Gramatica() : base(caseSensitive: false)
{
#region EXPRESION REGULAR
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
RegexBasedTerminal Decimal = new RegexBasedTerminal("Decimal", "[0-9]+\\.[0-9]+");
StringLiteral cadena = new StringLiteral("cadena", "\"");
StringLiteral caracter = TerminalFactory.CreateCSharpChar("caracter");
IdentifierTerminal id = new IdentifierTerminal("id");
CommentTerminal comentarioUnaLinea = new CommentTerminal("comentarioUnaLinea", ">>", "\n", "\r\n");
CommentTerminal comentarioMultilinea = new CommentTerminal("comentarioMultilinea", "<-", "->");
NonGrammarTerminals.Add(comentarioUnaLinea);
NonGrammarTerminals.Add(comentarioMultilinea);
#endregion
#region TERMINALES
var punto = ToTerm(".");
var coma = ToTerm(",");
//operadores aritméticos y lógicos
var mayor = ToTerm(">");
var menor = ToTerm("<");
var igual = ToTerm("=");
var mayorigual = ToTerm(">=");
var menorigual = ToTerm("<=");
var igualigual = ToTerm("==");
var not = ToTerm("!");
var diferente = ToTerm("!=");
var and = ToTerm("&&");
var or = ToTerm("||");
var potencia = ToTerm("^");
var mult = ToTerm("*");
var div = ToTerm("/");
var mas = ToTerm("+");
var menos = ToTerm("-");
var parAbre = ToTerm("(");
var parCierra = ToTerm(")");
var llavAbre = ToTerm("{");
var llavCierra = ToTerm("}");
//tipos de dato
var Int = ToTerm("int");
var String = ToTerm("string");
var Double = ToTerm("double");
var Char = ToTerm("char");
var Bool = ToTerm("bool");
//tipos de acceso
var publico = ToTerm("publico");
var privado = ToTerm("privado");
//palabras reservadas
var clase = ToTerm("clase");
var importar = ToTerm("importar");
var Void = ToTerm("void");
var array = ToTerm("array");
var True = ToTerm("true");
var False = ToTerm("false");
var verdadero = ToTerm("verdadero");
var falso = ToTerm("falso");
var New = ToTerm("new");
var main = ToTerm("main");
var Override = ToTerm("Override");
var If = ToTerm("if");
var Else = ToTerm("else");
var For = ToTerm("for");
var repeat = ToTerm("repeat");
var While = ToTerm("while");
var comprobar = ToTerm("comprobar");
var caso = ToTerm("caso");
var salir = ToTerm("salir");
var defecto = ToTerm("defecto");
var hacer = ToTerm("hacer");
var mientras = ToTerm("mientras");
var Return = ToTerm("return");
var print = ToTerm("print");
var show = ToTerm("show");
var continuar = ToTerm("continuar");
var addFigure = ToTerm("addfigure");
var circle = ToTerm("circle");
var triangle = ToTerm("triangle");
var square = ToTerm("square");
var line = ToTerm("line");
#endregion
#region NO TERMINALES
NonTerminal S = new NonTerminal("S");
NonTerminal LISTA_CLASES = new NonTerminal("LISTA_CLASES");
NonTerminal CLASE = new NonTerminal("CLASE");
NonTerminal IMPORTAR = new NonTerminal("IMPORTAR");
NonTerminal LISTA_CUERPO = new NonTerminal("LISTA_CUERPO");
NonTerminal CUERPO = new NonTerminal("CUERPO");
NonTerminal MAIN = new NonTerminal("MAIN");
NonTerminal METODO = new NonTerminal("METODO");
NonTerminal FUNCION = new NonTerminal("FUNCION");
NonTerminal FUNCION_HEADER = new NonTerminal("FUNCION_HEADER");
NonTerminal FUNCION_PARAM = new NonTerminal("FUNCION_PARAM");
NonTerminal DECLARACION = new NonTerminal("DECLARACION");
NonTerminal DECLA_VARIABLES = new NonTerminal("DECLA_VARIABLES");
NonTerminal VAR = new NonTerminal("VAR");
NonTerminal VAR_ID = new NonTerminal("VAR_ID");
NonTerminal ACCESO = new NonTerminal("ACCESO");
NonTerminal LISTA_ID = new NonTerminal("LISTA_ID");
NonTerminal DIMENSION = new NonTerminal("DIMENSION");
NonTerminal ARRAY_INIT = new NonTerminal("ARRAY_INIT");
NonTerminal LISTA_LLAV = new NonTerminal("LISTA_LLAV");
NonTerminal LLAVE = new NonTerminal("LLAVE");
NonTerminal LISTA_EXP = new NonTerminal("LISTA_EXP");
NonTerminal TIPO = new NonTerminal("TIPO");
NonTerminal EXP = new NonTerminal("EXP");
NonTerminal VALOR = new NonTerminal("VALOR");
NonTerminal LISTA_PARAMETROS = new NonTerminal("LISTA_PARAMETROS");
NonTerminal PARAMETRO = new NonTerminal("PARAMETRO");
NonTerminal RETORNO = new NonTerminal("RETORNO");
NonTerminal L_SENTENCIAS = new NonTerminal("L_SENTENCIAS");
NonTerminal SENTENCIA = new NonTerminal("SENTENCIA");
NonTerminal INIT = new NonTerminal("INIT");
NonTerminal IF = new NonTerminal("IF");
NonTerminal IF_LIST = new NonTerminal("IF_LIST");
NonTerminal FOR = new NonTerminal("FOR");
NonTerminal FOR_INIT = new NonTerminal("FOR_INIT");
NonTerminal REPEAT = new NonTerminal("REPEAT");
NonTerminal WHILE = new NonTerminal("WHILE");
NonTerminal COMPROBAR = new NonTerminal("COMPROBAR");
NonTerminal CASOS = new NonTerminal("CASOS");
NonTerminal CASO = new NonTerminal("CASO");
NonTerminal HACER = new NonTerminal("HACER");
NonTerminal PASOS = new NonTerminal("PASOS");
NonTerminal FIGURA = new NonTerminal("FIGURA");
NonTerminal CALL = new NonTerminal("CALL");
#endregion
#region GRAMATICA
S.Rule = LISTA_CLASES
;
LISTA_CLASES.Rule = LISTA_CLASES + CLASE
| CLASE
;
CLASE.Rule = clase + id + IMPORTAR + "{" + LISTA_CUERPO + "}"
| clase + id + "{" + LISTA_CUERPO + "}"
;
IMPORTAR.Rule = importar + LISTA_ID
;
LISTA_ID.Rule = LISTA_ID + coma + id
| id
;
LISTA_CUERPO.Rule = LISTA_CUERPO + CUERPO
| CUERPO
;
CUERPO.Rule = FUNCION
| MAIN
| DECLARACION + ";"
//| EXP + ";"
;
DECLARACION.Rule = ACCESO + TIPO + LISTA_ID + igual + EXP //5 **
| ACCESO + TIPO + array + LISTA_ID + DIMENSION + igual + ARRAY_INIT //7
| TIPO + LISTA_ID + igual + EXP //4 **
| TIPO + array + LISTA_ID + DIMENSION + igual + ARRAY_INIT //6 **
| ACCESO + TIPO + LISTA_ID //3 **
| ACCESO + TIPO + array + LISTA_ID + DIMENSION //5 **
| TIPO + LISTA_ID //2 **
| TIPO + array + LISTA_ID + DIMENSION //4 **
//De tipo id
| ACCESO + id + LISTA_ID + igual + EXP //5
| id + LISTA_ID + igual + EXP //4
| ACCESO + id + LISTA_ID //3
| id + LISTA_ID //2
;
FUNCION.Rule = FUNCION_HEADER + "{" + L_SENTENCIAS + "}"
;
//FUNCION_PARAM.Rule = FUNCION_HEADER + "(" + LISTA_PARAMETROS + ")"
// | FUNCION_HEADER + "(" + ")"
// ;
FUNCION_HEADER.Rule = //CON PARÁMETROS
ACCESO + id + Void + "(" + LISTA_PARAMETROS + ")"
| ACCESO + id + Void + Override + "(" + LISTA_PARAMETROS + ")"
| id + Void + Override + "(" + LISTA_PARAMETROS + ")"
| id + Void + "(" + LISTA_PARAMETROS + ")"
//Funciones con retorno
| ACCESO + id + TIPO + "(" + LISTA_PARAMETROS + ")"
| ACCESO + id + TIPO + Override + "(" + LISTA_PARAMETROS + ")"
| id + TIPO + Override + "(" + LISTA_PARAMETROS + ")"
| id + TIPO + "(" + LISTA_PARAMETROS + ")"
//Funciones con retorno de arreglos
| ACCESO + id + array + TIPO + DIMENSION + "(" + LISTA_PARAMETROS + ")"
| id + array + TIPO + DIMENSION + "(" + LISTA_PARAMETROS + ")"
//SIN PARÁMETROS
| ACCESO + id + Void + "(" + ")"
| ACCESO + id + Void + Override + "(" + ")"
| id + Void + Override + "(" + ")"
| id + Void + "(" + ")"
//Funciones con retorno
| ACCESO + id + TIPO + "(" + ")"
| ACCESO + id + TIPO + Override + "(" + ")"
| id + TIPO + Override + "(" + ")"
| id + TIPO + "(" + ")"
//Funciones con retorno de arreglos
| ACCESO + id + array + TIPO + DIMENSION + "(" + ")"
| id + array + TIPO + DIMENSION + "(" + ")"
//########### DE TIPO ID
| ACCESO + id + id + "(" + LISTA_PARAMETROS + ")"
| ACCESO + id + id + Override + "(" + LISTA_PARAMETROS + ")"
| id + id + Override + "(" + LISTA_PARAMETROS + ")"
| id + id + "(" + LISTA_PARAMETROS + ")"
| ACCESO + id + id + "(" + ")"
| ACCESO + id + id + Override + "(" + ")"
| id + id + Override + "(" + ")"
| id + id + "(" + ")"
;
MAIN.Rule = main + "(" + ")" + "{" + L_SENTENCIAS + "}"
;
L_SENTENCIAS.Rule = MakeStarRule(L_SENTENCIAS, SENTENCIA);
//L_SENTENCIAS.Rule = L_SENTENCIAS + SENTENCIA
// | SENTENCIA
// ;
SENTENCIA.Rule = DECLARACION + ";" //1*
| Return + EXP + ";" //2*
| Return + ";" //1
| EXP + ";" //1*
| continuar + ";" //1
| salir + ";" //1
| print + "(" + EXP + ")" + ";" //2*
| show + "(" + EXP + coma + EXP + ")" + ";" //4
| addFigure + "(" + FIGURA + ")" //2
| IF //1*
| FOR //1**
| REPEAT //1**
| WHILE //1**
| HACER //1*
| COMPROBAR //1*
;
IF.Rule = IF_LIST + Else + "{" + L_SENTENCIAS + "}"
| IF_LIST
;
IF_LIST.Rule = IF_LIST + Else + If + "(" + EXP + ")" + "{" + L_SENTENCIAS + "}"
| If + "(" + EXP + ")" + "{" + L_SENTENCIAS + "}"
;
FOR.Rule = For + "(" + FOR_INIT + ";" + EXP + ";" + id + mas + mas + ")" + "{" + L_SENTENCIAS + "}"
| For + "(" + FOR_INIT + ";" + EXP + ";" + id + menos + menos + ")" + "{" + L_SENTENCIAS + "}"
;
FOR_INIT.Rule = DECLARACION
| EXP
;
REPEAT.Rule = repeat + "(" + EXP + ")" + "{" + L_SENTENCIAS + "}"
;
WHILE.Rule = While + "(" + EXP + ")" + "{" + L_SENTENCIAS + "}"
;
HACER.Rule = hacer + "{" + L_SENTENCIAS + "}" + mientras + "(" + EXP + ")" + ";"
;
COMPROBAR.Rule = comprobar + "(" + EXP + ")" + "{" + CASOS + "}"
| comprobar + "(" + EXP + ")" + "{" + CASOS + defecto + ":" + L_SENTENCIAS + "}"
;
//CASOS.Rule = CASOS + caso + EXP + ":" + L_SENTENCIAS + salir + ";"
// | caso + EXP + ":" + L_SENTENCIAS + salir + ";"
// ;
CASOS.Rule = MakePlusRule(CASOS, CASO);
CASO.Rule = caso + EXP + ":" + L_SENTENCIAS
;
FIGURA.Rule = circle + "(" + LISTA_EXP + ")" //color, radio, solido, posx centro, posy centro
| triangle + "(" + LISTA_EXP + ")" //color, solido, puntox v1, puntoy v1, puntox v2, puntoy v2, puntox v3, puntoy v3
| square + "(" + LISTA_EXP + ")" //color, solido, posx centro, posy centro, alto, ancho
| line + "(" + LISTA_EXP + ")" //color, posx inicio, posy inicio, posx final, posy final, grosor
;
ACCESO.Rule = publico
| privado
;
LISTA_PARAMETROS.Rule = LISTA_PARAMETROS + coma + PARAMETRO
| PARAMETRO
;
PARAMETRO.Rule = TIPO + id
| id + id
;
TIPO.Rule = Int
| String
| Double
| Char
| Bool
;
DIMENSION.Rule = DIMENSION + "[" + EXP + "]"
| "[" + EXP + "]"
;
ARRAY_INIT.Rule = "{" + LISTA_LLAV + "}"
;
LISTA_LLAV.Rule = LISTA_LLAV + coma + LLAVE
| LLAVE
;
LLAVE.Rule = ToTerm("{") + LISTA_LLAV + ToTerm("}")
| LISTA_EXP
;
LISTA_EXP.Rule = LISTA_EXP + coma + EXP
| EXP
;
EXP.Rule = EXP + igual + EXP //3
| EXP + or + EXP
| EXP + and + EXP
| EXP + potencia + EXP
| not + EXP
| EXP + mayor + EXP
| EXP + menor + EXP
| EXP + mayorigual + EXP
| EXP + menorigual + EXP
| EXP + igualigual + EXP
| EXP + diferente + EXP
| EXP + mas + EXP
| EXP + menos + EXP
| EXP + mult + EXP
| EXP + div + EXP
| menos + EXP
| EXP + mas + mas
| EXP + menos + menos
| "(" + EXP + ")"
| New + id + "(" + ")" //2
| Decimal
| numero
| id
| id + punto + EXP //3
| id + CALL //2
| cadena
| caracter
| verdadero
| falso
| True
| False
| id + DIMENSION //2
;
CALL.Rule = "(" + LISTA_EXP + ")"
| "(" + ")"
;
#endregion
#region PREFERENCIAS
this.Root = S;
MarkPunctuation("{", "}", "(", ")", ";", "[", "]", ":");
RegisterOperators(7, Associativity.Right, "^");
RegisterOperators(6, Associativity.Left, "*", "/");
RegisterOperators(5, Associativity.Left, "+", "-");
RegisterOperators(4, Associativity.Left, ">", "<", ">=", "<=", "==", "!=", "=");
RegisterOperators(3, Associativity.Right, "!");
RegisterOperators(2, Associativity.Left, "&&");
RegisterOperators(1, Associativity.Left, "||");
#endregion
}
public Gramatica() : base(caseSensitive: false)
{
#region ER
//RegexBasedTerminal numero = new RegexBasedTerminal("int", "[0-9]+");
RegexBasedTerminal dec = new RegexBasedTerminal("double", "[0-9]+[.][0-9]+");
RegexBasedTerminal booleano = new RegexBasedTerminal("bool", "verdadero|falso|true|false");
NumberLiteral numero = TerminalFactory.CreateCSharpNumber("int");
IdentifierTerminal id = new IdentifierTerminal("id");
StringLiteral cadena = TerminalFactory.CreateCSharpString("string");
StringLiteral caracter = TerminalFactory.CreateCSharpChar("char");
CommentTerminal simple = new CommentTerminal("simple", ">>", "\n", "\r\n");
CommentTerminal multi = new CommentTerminal("multi", "<-", "->");
#endregion
#region Terminales
var mas = ToTerm("+");
var menos = ToTerm("-");
var div = ToTerm("/");
var por = ToTerm("*");
var para = ToTerm("(");
var parc = ToTerm(")");
var elevar = ToTerm("^");
var aumento = ToTerm("++");
var decremento = ToTerm("--");
var igual = ToTerm("=");
var not = ToTerm("!");
var diferente = ToTerm("!=");
var equivalente = ToTerm("==");
var or = ToTerm("||");
var and = ToTerm("&&");
var menorque = ToTerm("<");
var mayorque = ToTerm(">");
var menorigual = ToTerm("<=");
var mayorigual = ToTerm(">=");
var puntocoma = ToTerm(";");
var coma = ToTerm(",");
var punto = ToTerm(".");
var dospuntos = ToTerm(":");
var llavea = ToTerm("{");
var llavec = ToTerm("}");
var corchetea = ToTerm("[");
var corchetec = ToTerm("]");
var tint = ToTerm("int");
var tdouble = ToTerm("double");
var tstring = ToTerm("string");
var tchar = ToTerm("char");
var tbool = ToTerm("bool");
var array = ToTerm("array");
var clase = ToTerm("clase");
var importar = ToTerm("importar");
var publico = ToTerm("publico");
var privado = ToTerm("privado");
var tvoid = ToTerm("void");
var tnew = ToTerm("new");
var toverride = ToTerm("override");
var main = ToTerm("main");
var treturn = ToTerm("return");
var print = ToTerm("print");
var show = ToTerm("show");
var tif = ToTerm("if");
var telse = ToTerm("else");
var tfor = ToTerm("for");
var repeat = ToTerm("repeat");
var twhile = ToTerm("while");
var salir = ToTerm("salir");
var comprobar = ToTerm("comprobar");
var caso = ToTerm("caso");
var defecto = ToTerm("defecto");
var hacer = ToTerm("hacer");
var mientras = ToTerm("mientras");
var continuar = ToTerm("continuar");
var addfigure = ToTerm("addfigure");
var line = ToTerm("line");
var triangle = ToTerm("triangle");
var square = ToTerm("square");
var circle = ToTerm("circle");
var figure = ToTerm("figure");
#endregion
#region No Terminales
NonTerminal INICIO = new NonTerminal("INICIO"),
LISTACLASES = new NonTerminal("LISTACLASES"),
CLASE = new NonTerminal("CLASE"),
OBJETO = new NonTerminal("OBJETO"),
LISTAINSTRUCCIONES = new NonTerminal("LISTAINSTRUCCIONES"),
LISTAMETODOS = new NonTerminal("LISTAMETODOS"),
INSTRUCCION = new NonTerminal("INSTRUCCION"),
METODO = new NonTerminal("METODO"),
LISTAPARAM = new NonTerminal("LISTAPARAM"),
LISTAENVIADA = new NonTerminal("LISTAENVIADA"),
LISTAIDES = new NonTerminal("LISTAIDES"),
DECLARACION = new NonTerminal("DECLARACION"),
ASIGNACION = new NonTerminal("ASIGNACION"),
VISIBILIDAD = new NonTerminal("VISIBILIDAD"),
METODOVOID = new NonTerminal("METODOVOID"),
METODORETURN = new NonTerminal("METODORETURN"),
FUNCION = new NonTerminal("FUNCION"),
RETURN = new NonTerminal("RETURN"),
PRINT = new NonTerminal("PRINT"),
IF = new NonTerminal("IF"),
FOR = new NonTerminal("FOR"),
REPEAT = new NonTerminal("REPEAT"),
WHILE = new NonTerminal("WHILE"),
COMPROBAR = new NonTerminal("COMPROBAR"),
OPCION = new NonTerminal("OPCION"),
DOWHILE = new NonTerminal("DOWHILE"),
ADDFIGURA = new NonTerminal("ADDFIGURA"),
FIGURA = new NonTerminal("FIGURA"),
IFELSE = new NonTerminal("IF ELSE"),
SHOW = new NonTerminal("SHOW"),
LISTAIFELSE = new NonTerminal("LISTAIFELSE"),
TIPO = new NonTerminal("TIPO"),
LISTACASOS = new NonTerminal("LISTACASOS"),
CONTINUAR = new NonTerminal("CONTINUAR"),
CASO = new NonTerminal("CASO"),
SALIR = new NonTerminal("SALIR"),
PARAMETRO = new NonTerminal("PARAMETRO"),
E = new NonTerminal("E"),
MROBJECT = new NonTerminal("MROBJECT"),
CALL = new NonTerminal("CALL"),
AUMENTO = new NonTerminal("AUMENTO"),
ACCESOVAR = new NonTerminal("ACCESOVAR"),
DECREMENTO = new NonTerminal("DECREMENTO"),
CAMBIO = new NonTerminal("CAMBIO"),
DIMENSION = new NonTerminal("DIMENSION"),
ASARREGLO = new NonTerminal("ASARREGLO"),
AS1 = new NonTerminal("AS1"),
AS2 = new NonTerminal("AS2"),
AS3 = new NonTerminal("AS3"),
RETURNARREGLO = new NonTerminal("RETURNARREGLO"),
LISTAEXTRA = new NonTerminal("LISTAEXTRA"),
EXTRA = new NonTerminal("EXTRA"),
PRUEBA = new NonTerminal("PRUEBA"),
LISTAPRUEBA = new NonTerminal("LISTAPRUEBA"),
ASIGNACIONARRAY = new NonTerminal("ASIGNACIONARRAY"),
TOARRAY = new NonTerminal("TOARRAY"),
DARREGLO = new NonTerminal("DARREGLO");
#endregion
#region Gramatica
//precedencia
this.RegisterOperators(0, Associativity.Left, or);
this.RegisterOperators(1, Associativity.Left, and);
this.RegisterOperators(2, Associativity.Left, not);
this.RegisterOperators(3, Associativity.Left, equivalente, diferente, mayorigual, mayorque, menorque, menorigual);
this.RegisterOperators(4, Associativity.Left, mas, menos);
this.RegisterOperators(5, Associativity.Left, por, div);
this.RegisterOperators(6, Associativity.Left, elevar);
//marcar como puntuacion para que no aparezca en el arbol
this.MarkPunctuation(para, array, treturn, hacer, mientras, punto, twhile, parc, puntocoma, coma, dospuntos, llavea, llavec, corchetea, corchetec, igual, clase, importar, tvoid, print, show, tif, telse, tfor, repeat);
//no tomar para el analisis
this.NonGrammarTerminals.Add(simple);
this.NonGrammarTerminals.Add(multi);
//hacer intrasendentes para optimizar el arbol
this.MarkTransient(INSTRUCCION, TIPO, METODO, ASARREGLO, EXTRA, PRUEBA);
//palabras reservadas para no confundir con ids
this.MarkReservedWords("array", "clase", "importar", "publico", "privado", "void", "new", "override", "main", "return", "print", "show", "if", "else", "for", "repeat", "while", "salir", "comprobar", "caso", "defecto", "hacer", "mientras", "continuar", "addfigure", "circle", "triangle", "line", "square", "figure");
INICIO.Rule = LISTACLASES;
//SOLO UN NODO ACTUANDO COMO LISTA
LISTACLASES.Rule = MakePlusRule(LISTACLASES, CLASE);
CLASE.Rule = clase + id + llavea + LISTAINSTRUCCIONES + LISTAMETODOS + llavec
| clase + id + llavea + LISTAINSTRUCCIONES + llavec
| clase + id + llavea + LISTAMETODOS + llavec
| clase + id + llavea + llavec
| clase + id + importar + LISTAIDES + llavea + LISTAINSTRUCCIONES + LISTAMETODOS + llavec
| clase + id + importar + LISTAIDES + llavea + LISTAINSTRUCCIONES + llavec
| clase + id + importar + LISTAIDES + llavea + LISTAMETODOS + llavec
| clase + id + importar + LISTAIDES + llavea + llavec;
LISTAIDES.Rule = MakePlusRule(LISTAIDES, coma, id);
LISTAINSTRUCCIONES.Rule = MakePlusRule(LISTAINSTRUCCIONES, INSTRUCCION);
LISTAMETODOS.Rule = MakePlusRule(LISTAMETODOS, METODO);
INSTRUCCION.Rule = DECLARACION
| ASIGNACION
| FUNCION
| PRINT
| SHOW
| IF
| FOR
| COMPROBAR
| SALIR
| CONTINUAR
| WHILE
| DOWHILE
| REPEAT
| RETURN
| E
| CAMBIO
| OBJETO
| MROBJECT
| DARREGLO
| ASIGNACIONARRAY
;
DARREGLO.Rule = TIPO + array + LISTAIDES + DIMENSION + puntocoma
| VISIBILIDAD + TIPO + array + LISTAIDES + DIMENSION + puntocoma
| TIPO + array + LISTAIDES + DIMENSION + igual + ASARREGLO + puntocoma
| VISIBILIDAD + TIPO + array + LISTAIDES + DIMENSION + igual + ASARREGLO + puntocoma
;
ASARREGLO.Rule = AS1 | AS2 | AS3 | E;
AS1.Rule = llavea + LISTAENVIADA + llavec;
AS2.Rule = llavea + LISTAEXTRA + llavec;
AS3.Rule = llavea + LISTAPRUEBA + llavec;
LISTAPRUEBA.Rule = MakePlusRule(LISTAPRUEBA, coma, PRUEBA);
PRUEBA.Rule = llavea + LISTAEXTRA + llavec;
LISTAEXTRA.Rule = MakePlusRule(LISTAEXTRA, coma, EXTRA);
EXTRA.Rule = llavea + LISTAENVIADA + llavec;
DIMENSION.Rule = corchetea + E + corchetec
| corchetea + E + corchetec + corchetea + E + corchetec
| corchetea + E + corchetec + corchetea + E + corchetec + corchetea + E + corchetec;
ASIGNACIONARRAY.Rule = id + igual + ASARREGLO + puntocoma;
MROBJECT.Rule = id + id + igual + id + para + parc + puntocoma;
OBJETO.Rule = id + id + puntocoma
| id + id + igual + tnew + id + para + parc + puntocoma;
CAMBIO.Rule = AUMENTO
| DECREMENTO;
AUMENTO.Rule = id + aumento + puntocoma;
DECREMENTO.Rule = id + decremento + puntocoma;
METODO.Rule = METODOVOID
| METODORETURN;
METODOVOID.Rule = main + para + parc + llavea + LISTAINSTRUCCIONES + llavec//MAIN
| VISIBILIDAD + id + tvoid + toverride + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + tvoid + toverride + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + tvoid + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + tvoid + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + tvoid + toverride + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + tvoid + toverride + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + tvoid + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + tvoid + para + parc + llavea + LISTAINSTRUCCIONES + llavec
;
METODORETURN.Rule = VISIBILIDAD + id + TIPO + toverride + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + TIPO + toverride + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + TIPO + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + TIPO + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + TIPO + toverride + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + TIPO + toverride + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + TIPO + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + TIPO + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| RETURNARREGLO;
;
RETURNARREGLO.Rule = VISIBILIDAD + id + array + TIPO + DIMENSION + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + array + TIPO + DIMENSION + para + parc + llavea + LISTAINSTRUCCIONES + llavec
| VISIBILIDAD + id + array + TIPO + DIMENSION + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec
| id + array + TIPO + DIMENSION + para + LISTAPARAM + parc + llavea + LISTAINSTRUCCIONES + llavec;
DECLARACION.Rule = VISIBILIDAD + TIPO + LISTAIDES + igual + E + puntocoma
| TIPO + LISTAIDES + igual + E + puntocoma
| TIPO + LISTAIDES + puntocoma
| VISIBILIDAD + TIPO + LISTAIDES + puntocoma
;
LISTAPARAM.Rule = MakePlusRule(LISTAPARAM, coma, PARAMETRO);
PARAMETRO.Rule = TIPO + E
| TIPO + TOARRAY;
ASIGNACION.Rule = id + igual + E + puntocoma
| TOARRAY + igual + E + puntocoma
| id + punto + id + igual + E + puntocoma
| id + punto + TOARRAY + igual + E + puntocoma;
VISIBILIDAD.Rule = publico
| privado;
TIPO.Rule = tint
| tdouble
| tstring
| tchar
| tbool
| id
| TOARRAY;
RETURN.Rule = treturn + E + puntocoma;
FUNCION.Rule = id + para + LISTAENVIADA + parc + puntocoma
| id + para + parc + puntocoma
| id + punto + id + para + parc + puntocoma
| id + punto + id + para + LISTAENVIADA + parc + puntocoma;
LISTAENVIADA.Rule = MakePlusRule(LISTAENVIADA, coma, E);
PRINT.Rule = print + para + E + parc + puntocoma;
SHOW.Rule = show + para + E + coma + E + parc + puntocoma;
IF.Rule = tif + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec
| tif + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec + telse + llavea + LISTAINSTRUCCIONES + llavec
| tif + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec + LISTAIFELSE + telse + llavea + LISTAINSTRUCCIONES + llavec
;
LISTAIFELSE.Rule = MakePlusRule(LISTAIFELSE, IFELSE);
IFELSE.Rule = telse + tif + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec;
FOR.Rule = tfor + para + OPCION + E + puntocoma + E + parc + llavea + LISTAINSTRUCCIONES + llavec;
OPCION.Rule = ASIGNACION | DECLARACION;
REPEAT.Rule = repeat + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec;
WHILE.Rule = twhile + para + E + parc + llavea + LISTAINSTRUCCIONES + llavec;
COMPROBAR.Rule = comprobar + para + E + parc + llavea + LISTACASOS + llavec;
LISTACASOS.Rule = MakePlusRule(LISTACASOS, CASO);
CASO.Rule = caso + E + dospuntos + LISTAINSTRUCCIONES
| defecto + dospuntos + LISTAINSTRUCCIONES;
SALIR.Rule = salir + puntocoma;
DOWHILE.Rule = hacer + llavea + LISTAINSTRUCCIONES + llavec + mientras + para + E + parc + puntocoma;
CONTINUAR.Rule = continuar + puntocoma;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + div + E
| E + elevar + E
| E + equivalente + E
| E + diferente + E
| E + mayorque + E
| E + mayorigual + E
| E + menorigual + E
| E + menorque + E
| menos + E
| E + aumento
| E + decremento
| E + or + E
| E + and + E
| not + E
| para + E + parc
| numero
| dec
| id
| booleano
| cadena
| caracter
| CALL
| tnew + id + para + parc
| ACCESOVAR
| TOARRAY
;
TOARRAY.Rule = id + DIMENSION;
CALL.Rule = id + para + parc
| id + para + LISTAENVIADA + parc
| id + punto + id + para + parc
| id + punto + id + para + LISTAENVIADA + parc;
ACCESOVAR.Rule = id + punto + id;
#endregion
#region Raiz
this.Root = INICIO;
#endregion
}
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 Grammar() : base(caseSensitive: false)
{
#region ER
RegexBasedTerminal num = new RegexBasedTerminal("num", "[0-9]+");
RegexBasedTerminal dec = new RegexBasedTerminal("dec", "[0-9]+[.][0-9]+");
RegexBasedTerminal rtrue = new RegexBasedTerminal("rtrue", "true|verdadero");
RegexBasedTerminal rfalse = new RegexBasedTerminal("rfalse", "false|falso");
CommentTerminal com_linea = new CommentTerminal("comentariolinea", ">>", "\n", "\r\n");
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "<-", "->");
CommentTerminal com_multi = new CommentTerminal("comentariomulti", "<-", "->");
StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("String");
StringLiteral CharLiteral = TerminalFactory.CreateCSharpChar("Char");
IdentifierTerminal identifier = new IdentifierTerminal("Identifier");
NonGrammarTerminals.Add(com_linea);
NonGrammarTerminals.Add(comentarioBloque);
NonGrammarTerminals.Add(com_multi);
#endregion
#region Terminales
/*simbolos*/
var igual = ToTerm("=");
var aumento = ToTerm("++");
var decremento = ToTerm("--");
var punto = ToTerm(".");
/*aritmeticos*/
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var entre = ToTerm("/");
var elevado = ToTerm("^");
/*relacionales*/
var igualLogico = ToTerm("==");
var desigual = ToTerm("!=");
var mayor = ToTerm(">");
var mayorigual = ToTerm(">=");
var menor = ToTerm("<");
var menorigual = ToTerm("<=");
/*logicos*/
var or = ToTerm("||");
var and = ToTerm("&&");
var not = ToTerm("!");
/*tipos de dato*/
var rint = ToTerm("int");
var rdouble = ToTerm("double");
var rbool = ToTerm("bool");
var rchar = ToTerm("char");
var rstring = ToTerm("string");
var rarray = ToTerm("array");
/*Reservadas*/
var rclase = ToTerm("clase");
var rimportar = ToTerm("importar");
var rvoid = ToTerm("void");
var rpublico = ToTerm("publico");
var rprivado = ToTerm("privado");
var rreturn = ToTerm("return");
var rnew = ToTerm("new");
var roverride = ToTerm("override");
var rmain = ToTerm("main");
var rprint = ToTerm("print");
var rshow = ToTerm("show");
/*sentencias*/
var rif = ToTerm("if");
var relse = ToTerm("else");
var rfor = ToTerm("for");
var rrepeat = ToTerm("repeat");
var rwhile = ToTerm("while");
var rcomprobar = ToTerm("comprobar");
var rcaso = ToTerm("caso");
var rsalir = ToTerm("salir");
var rdefecto = ToTerm("defecto");
var rhacer = ToTerm("hacer");
var rmientras = ToTerm("mientras");
var rcontinuar = ToTerm("continuar");
/*figure*/
var raddfigure = ToTerm("addfigure");
var rcircle = ToTerm("circle");
var rtriangle = ToTerm("triangle");
var rsquare = ToTerm("square");
var rline = ToTerm("line");
var rfigure = ToTerm("figure");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
FUNCION = new NonTerminal("Funcion"), PARAMFUNCION = new NonTerminal("ParamFuncion"),
BLOQUE = new NonTerminal("BLOQUE"), LISTA_BLOQUE = new NonTerminal("LISTA_BLOQUE"),
ASIGNACION = new NonTerminal("Asignacion"), DECLARACION = new NonTerminal("Declaracion"),
METODOS = new NonTerminal("Metodos"), SENTENCIAS = new NonTerminal("Sentencias"),
LID = new NonTerminal("ListaId"), T_DATO = new NonTerminal("TipoDato"), DIM = new NonTerminal("Dimension"),
LDIM = new NonTerminal("LDim"), DIM1 = new NonTerminal("Dim1"), DIM2 = new NonTerminal("Dim2"), DIM3 = new NonTerminal("Dim3"),
LISTACLASE = new NonTerminal("ListaClase"), BLOCKCLASE = new NonTerminal("Bloqueclase"),
LPARAMETROS = new NonTerminal("ListaParametros"), VISIBILIDAD = new NonTerminal("Visibilidad"),
OVERRIDE = new NonTerminal("Override"), LISTAMSENTENCIA = new NonTerminal("ListaMSentencia"), MSENTENCIA = new NonTerminal("MSentencia"),
INMETODO = new NonTerminal("InMetodo"), BLOQUESHOW = new NonTerminal("BloqueShow"), BLOQUEPRINT = new NonTerminal("BloquePrint"),
BLOQUEIF = new NonTerminal("BloqueIf"), BLOQUEREPETIR = new NonTerminal("BloqueRepetir"), BLOQUEFOR = new NonTerminal("BloqueFor"),
BLOQUEWHILE = new NonTerminal("BloqueWhile"), BLOQUEELSEIF = new NonTerminal("BloqueElseIf"), BLOQUEHACER = new NonTerminal("BloqueHacer"),
BLOQUECOMPROBAR = new NonTerminal("BloqueComprobar"), BLOQUECASO = new NonTerminal("BloqueCaso"), ADDFIGURE = new NonTerminal("AddFigure"),
FIGURE = new NonTerminal("Figure"), TFIGURE = new NonTerminal("TFigure"), B3 = new NonTerminal("B3"), B2 = new NonTerminal("B2"),
MAIN = new NonTerminal("Main"), L1 = new NonTerminal("L1"), C1 = new NonTerminal("C1"), D1 = new NonTerminal("D1"),
IF = new NonTerminal("IF"), ElseIF = new NonTerminal("ELSEIF"), ELSE = new NonTerminal("ELSE"),
BARREGLO = new NonTerminal("BArreglo"), T_DATO1 = new NonTerminal("TipoDato");
#endregion
#region Gramaticas
S.Rule = LISTACLASE;
LISTACLASE.Rule = MakePlusRule(LISTACLASE, BLOCKCLASE);
BLOCKCLASE.Rule = rclase + identifier + ToTerm("{") + LISTA_BLOQUE + ToTerm("}") //3 ya
| rclase + identifier + rimportar + LID + ToTerm("{") + LISTA_BLOQUE + ToTerm("}") //5 ya
| rclase + identifier + ToTerm("{") + ToTerm("}") //2 ya
| rclase + identifier + rimportar + LID + ToTerm("{") + ToTerm("}"); //4 ya
LISTA_BLOQUE.Rule = MakePlusRule(LISTA_BLOQUE, BLOQUE);
BLOQUE.Rule = VISIBILIDAD + DECLARACION
| DECLARACION
| ASIGNACION
| VISIBILIDAD + METODOS
| METODOS
| MAIN
;
MAIN.Rule = rmain + ToTerm("(") + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
METODOS.Rule = identifier + rvoid + OVERRIDE + ToTerm("(") + LPARAMETROS + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}") //4 hijos
| identifier + rvoid + OVERRIDE + ToTerm("(") + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}") //3 hijos
| identifier + T_DATO + OVERRIDE + ToTerm("(") + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}") //3 hijos
| identifier + T_DATO + OVERRIDE + ToTerm("(") + LPARAMETROS + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}") //4 hijos
| identifier + rarray + T_DATO + DIM + OVERRIDE + ToTerm("(") + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}") //5 hijos
| identifier + rarray + T_DATO + DIM + OVERRIDE + ToTerm("(") + LPARAMETROS + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}"); //6 hijos
OVERRIDE.Rule = roverride
| Empty;
INMETODO.Rule = LISTAMSENTENCIA
| Empty;
LISTAMSENTENCIA.Rule = MakePlusRule(LISTAMSENTENCIA, MSENTENCIA);
MSENTENCIA.Rule = VISIBILIDAD + DECLARACION
| DECLARACION
| ASIGNACION
| BLOQUESHOW //YA
| BLOQUEPRINT //YA
| BLOQUEREPETIR //YA
| BLOQUEWHILE //YA
| BLOQUEIF //YA
| BLOQUEHACER //YA
| BLOQUEFOR //YA
| BLOQUECOMPROBAR //YA
| ADDFIGURE //YA
| FIGURE //YA
| FUNCION + ToTerm(";")
| D1 + ToTerm(";")
| rcontinuar + ToTerm(";") //YA
| rsalir + ToTerm(";") //YA
| rreturn + E + ToTerm(";"); //YA
BLOQUEIF.Rule = IF
| IF + ELSE
| IF + BLOQUEELSEIF
| IF + BLOQUEELSEIF + ELSE;
IF.Rule = rif + ToTerm("(") + E + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
ELSE.Rule = relse + ToTerm("{") + INMETODO + ToTerm("}");
ElseIF.Rule = relse + rif + ToTerm("(") + E + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
BLOQUEELSEIF.Rule = MakePlusRule(BLOQUEELSEIF, ElseIF);
BLOQUEREPETIR.Rule = rrepeat + ToTerm("(") + E + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
BLOQUEWHILE.Rule = rwhile + ToTerm("(") + E + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
BLOQUEPRINT.Rule = rprint + ToTerm("(") + E + ToTerm(")") + ToTerm(";");
BLOQUESHOW.Rule = rshow + ToTerm("(") + E + ToTerm(",") + E + ToTerm(")") + ToTerm(";")
| rshow + ToTerm("(") + E + ToTerm(")") + ToTerm(";");
BLOQUEHACER.Rule = rhacer + ToTerm("{") + INMETODO + ToTerm("}") + rmientras + ToTerm("(") + E + ToTerm(")") + ToTerm(";");
BLOQUEFOR.Rule = rfor + ToTerm("(") + T_DATO + identifier + igual + E + ToTerm(";") + E + ToTerm(";") + ASIGNACION + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}")
| rfor + ToTerm("(") + identifier + igual + E + ToTerm(";") + E + ToTerm(";") + ASIGNACION + ToTerm(")") + ToTerm("{") + INMETODO + ToTerm("}");
BLOQUECOMPROBAR.Rule = rcomprobar + ToTerm("(") + E + ToTerm(")") + ToTerm("{") + BLOQUECASO + ToTerm("}");
BLOQUECASO.Rule = MakePlusRule(BLOQUECASO, C1);
C1.Rule = rcaso + E + ToTerm(":") + INMETODO
| rdefecto + ToTerm(":") + INMETODO;
FIGURE.Rule = rfigure + ToTerm("(") + E + ToTerm(")") + ToTerm(";");
ADDFIGURE.Rule = raddfigure + ToTerm("(") + TFIGURE + ToTerm(")") + ToTerm(";");
TFIGURE.Rule = rcircle + ToTerm("(") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(")")
| rtriangle + ToTerm("(") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(")")
| rsquare + ToTerm("(") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(")")
| rline + ToTerm("(") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(",") + E + ToTerm(")");
DECLARACION.Rule = T_DATO + LID + ToTerm(";")
| identifier + identifier + ToTerm(";")
| T_DATO + LID + igual + E + ToTerm(";")
| T_DATO + rarray + LID + DIM + ToTerm(";")
| identifier + identifier + igual + rnew + identifier + ToTerm("(") + ToTerm(")") + ToTerm(";")
| identifier + identifier + igual + E + ToTerm(";")
| T_DATO + rarray + LID + DIM + igual + LDIM + ToTerm(";");
ASIGNACION.Rule = identifier + igual + E + ToTerm(";") //2 hijos ya
| identifier + igual + rnew + identifier + ToTerm("(") + ToTerm(")") + ToTerm(";") //3 hijos ya
| identifier + DIM + igual + E + ToTerm(";") //3 hijos ya
| D1 + DIM + igual + E + ToTerm(";")
| D1 + DIM + aumento + ToTerm(";")
| D1 + DIM + decremento + ToTerm(";")
| identifier + DIM + aumento + ToTerm(";")
| identifier + DIM + decremento + ToTerm(";")
| identifier + aumento + ToTerm(";") //2 hijos ya
| identifier + decremento + ToTerm(";") //2 hijos ya
| identifier + aumento
| identifier + decremento
| D1 + igual + E + ToTerm(";") //2 hijos pendiente
| D1 + aumento + ToTerm(";")
| D1 + decremento + ToTerm(";")
;
LDIM.Rule = ToTerm("{") + DIM1 + ToTerm("}")
| ToTerm("{") + DIM2 + ToTerm("}")
| ToTerm("{") + DIM3 + ToTerm("}");
DIM3.Rule = MakePlusRule(DIM3, ToTerm(","), B3);
B3.Rule = ToTerm("{") + DIM2 + ToTerm("}");
DIM2.Rule = MakePlusRule(DIM2, ToTerm(","), B2);
B2.Rule = ToTerm("{") + DIM1 + ToTerm("}");
DIM1.Rule = MakePlusRule(DIM1, ToTerm(","), E);
LID.Rule = MakePlusRule(LID, ToTerm(","), identifier);
LPARAMETROS.Rule = MakePlusRule(LPARAMETROS, ToTerm(","), L1);
L1.Rule = T_DATO + identifier
| T_DATO + rarray + identifier + DIM;
T_DATO.Rule = rint
| rchar
| rdouble
| rbool
| rstring
| identifier;
T_DATO1.Rule = rint
| rchar
| rdouble
| rbool
| rstring;
VISIBILIDAD.Rule = rprivado
| rpublico;
DIM.Rule = ToTerm("[") + E + ToTerm("]")
| ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]")
| ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]");
E.Rule = E + or + E
| E + and + E
| not + E
| E + mayor + E
| E + mayorigual + E
| E + menor + E
| E + menorigual + E
| E + igualLogico + E
| E + desigual + E
| E + mas + E
| E + menos + E
| E + por + E
| E + entre + E
| E + elevado + E
| menos + E
| D1 + aumento
| D1 + decremento
| dec
| rtrue
| rfalse
| StringLiteral
| CharLiteral
| num
| ToTerm("(") + E + ToTerm(")")
| D1
| BARREGLO
| BARREGLO + aumento
| BARREGLO + decremento;
BARREGLO.Rule = D1 + ToTerm("[") + E + ToTerm("]")
| D1 + ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]")
| D1 + ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]") + ToTerm("[") + E + ToTerm("]");
D1.Rule = MakePlusRule(D1, punto, identifier)
| MakePlusRule(D1, punto, FUNCION);
FUNCION.Rule = identifier + ToTerm("(") + PARAMFUNCION + ToTerm(")")
| identifier + ToTerm("(") + ToTerm(")");
PARAMFUNCION.Rule = MakePlusRule(PARAMFUNCION, ToTerm(","), E);
#endregion
#region Preferencias
this.Root = S;
this.MarkTransient(T_DATO, OVERRIDE, INMETODO, VISIBILIDAD, B2, B3);
this.RegisterOperators(1, Associativity.Left, or);
this.RegisterOperators(2, Associativity.Left, and);
this.RegisterOperators(3, Associativity.Right, not);
this.RegisterOperators(4, Associativity.Left, mayor, mayorigual, menor, menorigual, igualLogico, desigual);
this.RegisterOperators(5, Associativity.Left, mas, menos);
this.RegisterOperators(6, Associativity.Left, por, entre);
this.RegisterOperators(7, Associativity.Left, elevado);
this.RegisterOperators(8, Associativity.Left, aumento, decremento);
this.MarkPunctuation("(", ")", ",", ";", ":", "[", "]", "{", "}", "=");
#endregion
}
public EntropyGrammar() : base(false) // turns off case-sensitivity
{
#region definitions
#region literals
// Str
StringLiteral stringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
// Char
StringLiteral charLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
// Real
NumberLiteral number = CreateRealNumber("Number");
#endregion
#region non-terminals
NonTerminal program = new NonTerminal("program"); //, typeof(ProgramNode));
this.Root = program; // specify the non-terminal which is the root of the AST
NonTerminal programDeclaration = new NonTerminal("programDeclaration");
NonTerminal statementList = new NonTerminal("statementList"); //, typeof(StatementListNode));
NonTerminal emptyStatement = new NonTerminal("emptyStatement");
NonTerminal statement = new NonTerminal("statement"); //, typeof(StatementNode));
NonTerminal printStatement = new NonTerminal("printStatement");
NonTerminal ifStatement = new NonTerminal("ifStatement"); //, typeof(IfStatementNode));
NonTerminal whileLoop = new NonTerminal("whileLoop");
NonTerminal expression = new NonTerminal("expression"); //, typeof(ExpressionNode));
NonTerminal binaryOperator = new NonTerminal("binaryOperator"); //, typeof(BinaryOperatorNode));
NonTerminal assignment = new NonTerminal("assignmentOperator");
NonTerminal localVariableDeclaration = new NonTerminal("localVariableDeclaration");
NonTerminal conditionalExpression = new NonTerminal("conditionalExpression");
NonTerminal functionDeclaration = new NonTerminal("functionDeclaration");
#endregion
#region terminals
CommentTerminal singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(singleLineComment);
CommentTerminal delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(delimitedComment);
IdentifierTerminal variable_id = TerminalFactory.CreateCSharpIdentifier("variable_id");
IdentifierTerminal namespace_id = TerminalFactory.CreateCSharpIdentifier("namespace_id");
IdentifierTerminal function_id = TerminalFactory.CreateCSharpIdentifier("function_id");
IdentifierTerminal program_id = TerminalFactory.CreateCSharpIdentifier("program_id");
IdentifierTerminal identifier_id = CreateCSharpIdentifier("identifier_id");
NonTerminal datatype = new NonTerminal("datatype");
//identifierTerminal.("set", "to", "if", "freight", "cost", "is", "loop", "through", "order");
this.MarkPunctuation(";", "[", "]", "(", ")");
#endregion
#endregion
#region grammar
//<Program> ::= "Program" <ProgramName> <StatementList> <FunctionList> "End" "Program"
programDeclaration.Rule = ToTerm("Program") + namespace_id + program_id + "[" + statementList + "]";
program.Rule = programDeclaration; // +Symbol("End") + Symbol("Program");
datatype.Rule = ToTerm("char") | "real" | "string";
#region statements
//<StatementList> ::= <Statement>*
statementList.Rule = MakeStarRule(statementList, null, statement);
statement.Rule = emptyStatement | printStatement | ifStatement
| whileLoop
| localVariableDeclaration | assignment;
emptyStatement.Rule = ToTerm(";"); //setVariable + ";" | ifStatement | orderLoop | expression + ";";
// printStatement.Rule = ToTerm("print") + (stringLiteral | charLiteral) + ";";
printStatement.Rule = ToTerm("print") + expression + ";";
//<IfStatement> ::= "if" <Expression> "[" <StatementList> "]"
ifStatement.Rule = ToTerm("if") + expression + "[" + statementList + "]";
whileLoop.Rule = ToTerm("while") + expression + "[" + statementList + "]";
assignment.Rule = "let" + identifier_id + (ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=") + expression + ";";
//functionDeclaration.Rule = "function" + identifier_id + "(" +
localVariableDeclaration.Rule = ToTerm("declare") + identifier_id + datatype + ";"; // identifier_id
#endregion
#region expressions
//<Expression> ::= <number> | <variable> | <string>
// | <Expression> <BinaryOperator> <Expression>
// | "(" <Expression> ")"
expression.Rule = number | variable_id | stringLiteral | charLiteral
| expression + binaryOperator + expression
| conditionalExpression
| "(" + expression + ")";
//<BinaryOperator> ::= "+" | "-" | "*" | "/" | "<" | ">" | "<=" | ">=" | "is"
binaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "%";
// "=="
conditionalExpression.Rule = expression + (ToTerm("<") | ">" | "<=" | ">=") + expression;
#endregion
#endregion
}
public GramaticaPython()
: base(caseSensitive: false)
{
#region expresiones regulares
var identificador = TerminalFactory.CreateCSharpIdentifier("identificador");
var numero = TerminalFactory.CreateCSharpNumber("numero");
var val_false = Constantes.falso;
var val_true = Constantes.verdadero;
StringLiteral cadena = new StringLiteral("cadena", "\"");
var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter);
CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "/*", "*/");
CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "//", "\n", "\r\n");
NonGrammarTerminals.Add(COMENT_BLOQUE);
NonGrammarTerminals.Add(COMENT_LINEA);
#endregion
NonTerminal EXPRESION = new NonTerminal(Constantes.expresion);
NonTerminal DECIMAL = new NonTerminal(Constantes.tipoDecimal);
NonTerminal ENTERO = new NonTerminal(Constantes.tipoEntero);
NonTerminal CADENA = new NonTerminal(Constantes.tipoCadena);
NonTerminal CHAR = new NonTerminal(Constantes.tipoChar);
NonTerminal BOOLEANO = new NonTerminal(Constantes.tipoBool);
NonTerminal SIMB_ARIT = new NonTerminal(Constantes.simb_arit);
NonTerminal SIMB_REL = new NonTerminal(Constantes.simb_rel);
NonTerminal UNARIO = new NonTerminal(Constantes.unario);
NonTerminal ID = new NonTerminal(Constantes.id);
NonTerminal NEGATIVO = new NonTerminal(Constantes.negativo);
NonTerminal RELACIONAL = new NonTerminal(Constantes.relacional);
NonTerminal ARITMETICA = new NonTerminal(Constantes.aritmetica);
NonTerminal LOGICA = new NonTerminal(Constantes.logica);
NonTerminal LLAMADA = new NonTerminal(Constantes.llamada);
NonTerminal POSVECTOR = new NonTerminal(Constantes.posvector);
NonTerminal LISTAPUNTOS = new NonTerminal(Constantes.listapuntos);
NonTerminal SIMB_LOG = new NonTerminal(Constantes.simb_log);
NonTerminal MAS_MAS = new NonTerminal(Constantes.masmas);
NonTerminal MENOS_MENOS = new NonTerminal(Constantes.menosmenos);
NonTerminal ASIG_ARRAY = new NonTerminal(Constantes.asig_array);
NonTerminal termino = new NonTerminal(Constantes.termino);
NonTerminal L_IDS = new NonTerminal(Constantes.listaIds);
NonTerminal SUMA = new NonTerminal(Constantes.suma);
NonTerminal RESTA = new NonTerminal(Constantes.resta);
NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion);
NonTerminal DIVISION = new NonTerminal(Constantes.division);
NonTerminal POTENCIA = new NonTerminal(Constantes.potencia);
NonTerminal MENOR = new NonTerminal(Constantes.menor);
NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual);
NonTerminal MAYOR = new NonTerminal(Constantes.mayor);
NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual);
NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual);
NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA);
NonTerminal XOR = new NonTerminal(Constantes.xorJava);
NonTerminal AND = new NonTerminal(Constantes.andJava);
NonTerminal NOT = new NonTerminal(Constantes.notJavaPython);
NonTerminal OR = new NonTerminal(Constantes.orJava);
NonTerminal INSTANCIA = new NonTerminal(Constantes.instancia);
NonTerminal POSICION = new NonTerminal(Constantes.posicion);
NonTerminal FILA = new NonTerminal(Constantes.fila);
NonTerminal LPOSICIONES = new NonTerminal(Constantes.lposiciones);
NonTerminal LEXPRESIONES = new NonTerminal(Constantes.lexpresiones);
NonTerminal LFILAS = new NonTerminal(Constantes.lfilas);
#region expresion
POSICION.Rule = ToTerm("[") + EXPRESION + "]";
LPOSICIONES.Rule = MakePlusRule(LPOSICIONES, POSICION);
FILA.Rule = ToTerm("{") + LEXPRESIONES + "}";
LEXPRESIONES.Rule = MakePlusRule(LEXPRESIONES, ToTerm(","), EXPRESION);
LFILAS.Rule = MakePlusRule(LFILAS, ToTerm(","), FILA);
DECIMAL.Rule = numero;
ENTERO.Rule = numero;
CADENA.Rule = cadena;
ID.Rule = identificador;
CHAR.Rule = caracter;
BOOLEANO.Rule = ToTerm(val_false)
| ToTerm(val_true);
ARITMETICA.Rule = SUMA
| RESTA
| MULTIPLICACION
| DIVISION
| POTENCIA;
RELACIONAL.Rule = MENOR
| MAYOR
| MENORIGUAL
| MAYORIGUAL
| DISTINTOA
| IGUALIGUAL;
LOGICA.Rule = XOR
| OR
| AND
| NOT;
SUMA.Rule = EXPRESION + ToTerm(Constantes.suma) + EXPRESION;
RESTA.Rule = EXPRESION + ToTerm(Constantes.resta) + EXPRESION;
MULTIPLICACION.Rule = EXPRESION + ToTerm(Constantes.multiplicacion) + EXPRESION;
DIVISION.Rule = EXPRESION + ToTerm(Constantes.division) + EXPRESION;
POTENCIA.Rule = EXPRESION + ToTerm(Constantes.potencia) + EXPRESION;
MENOR.Rule = EXPRESION + ToTerm(Constantes.menor) + EXPRESION;
MENORIGUAL.Rule = EXPRESION + ToTerm(Constantes.menorIgual) + EXPRESION;
MAYOR.Rule = EXPRESION + ToTerm(Constantes.mayor) + EXPRESION;
MAYORIGUAL.Rule = EXPRESION + ToTerm(Constantes.mayorIgual) + EXPRESION;
IGUALIGUAL.Rule = EXPRESION + ToTerm(Constantes.igualIgual) + EXPRESION;
DISTINTOA.Rule = EXPRESION + ToTerm(Constantes.distintoA) + EXPRESION;
XOR.Rule = EXPRESION + ToTerm(Constantes.xorJava) + EXPRESION;
AND.Rule = EXPRESION + ToTerm(Constantes.andJava) + EXPRESION;
NOT.Rule = ToTerm(Constantes.notJavaPython) + EXPRESION;
OR.Rule = EXPRESION + ToTerm(Constantes.orJava) + EXPRESION;
INSTANCIA.Rule = Constantes.nuevo + identificador + "(" + LEXPRESIONES + ")"
| Constantes.nuevo + identificador + "(" + ")";
UNARIO.Rule = MAS_MAS
| MENOS_MENOS;
MAS_MAS.Rule = identificador + ToTerm(Constantes.masmas);
MENOS_MENOS.Rule = identificador + ToTerm(Constantes.menosmenos);
NEGATIVO.Rule = ToTerm("-") + EXPRESION;
termino.Rule = //ARITMETICA
//| RELACIONAL
// | LOGICA
DECIMAL
| ENTERO
| ID
| CADENA
| BOOLEANO
| CHAR;
//| LLAMADA
//| POSVECTOR
//| UNARIO
//| ToTerm("(") + EXPRESION + ")"
//| NEGATIVO
//| "{" + LFILAS + "}"
//| INSTANCIA;
LLAMADA.Rule = identificador + ToTerm("(") + LEXPRESIONES + ")"
| identificador + ToTerm("(") + ")";
POSVECTOR.Rule = identificador + LPOSICIONES;
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), termino);
NonTerminal n = new NonTerminal("fdsfd");
n.Rule = EXPRESION;
#endregion
Root = n;
}
public SLAngGrammer()
: base()
{
StringLiteral stringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
StringLiteral charLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
NumberLiteral number = TerminalFactory.CreateCSharpNumber("Number");
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
CommentTerminal delimitedComment = new CommentTerminal("DelimitedComment", "/[", "]/");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "--", "\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(delimitedComment);
#region Terminals
KeyTerm colon = ToTerm(":");
KeyTerm dot = ToTerm(".");
KeyTerm comma = ToTerm(",");
KeyTerm propertyIs = ToTerm("->");
KeyTerm lbr = ToTerm("{");
KeyTerm rbr = ToTerm("}");
KeyTerm lpar = ToTerm("(");
KeyTerm rpar = ToTerm(")");
KeyTerm scopeIn = ToTerm("::");
KeyTerm suchThat = ToTerm("|");
KeyTerm _package = ToTerm("package");
KeyTerm context = ToTerm("context");
KeyTerm body = ToTerm("body");
KeyTerm def = ToTerm("def");
KeyTerm derive = ToTerm("derive");
KeyTerm In = ToTerm("in");
KeyTerm inv = ToTerm("inv");
KeyTerm let = ToTerm("let");
KeyTerm post = ToTerm("post");
KeyTerm pre = ToTerm("pre");
KeyTerm Static = ToTerm("static");
KeyTerm self = ToTerm("self");
KeyTerm result = ToTerm("result");
KeyTerm equalsTo = ToTerm("=");
KeyTerm _null = ToTerm("null");
KeyTerm invalid = ToTerm("invalid");
KeyTerm not = ToTerm("not");
KeyTerm and = ToTerm("and");
KeyTerm or = ToTerm("or");
KeyTerm xor = ToTerm("xor");
#endregion
#region NonTerminal
var specification = new NonTerminal("specification");
var specificationBody = new NonTerminal("specificationBody");
var package = new NonTerminal("package");
var packages = new NonTerminal("packages");
var oclPackage = new NonTerminal("oclPackage");
var emofOclPackage = new NonTerminal("emofOclPackage");
var packageBody = new NonTerminal("packageBody");
var packageBodyItem = new NonTerminal("packageBodyItem");
var contextExp = new NonTerminal("contextExp");
var classType = new NonTerminal("classType");
var enumeration = new NonTerminal("enumeration");
var primitive = new NonTerminal("primitive");
var primitiveType = new NonTerminal("primitiveType");
var primitiveTypes = new NonTerminal("primitiveTypes");
var delimitedIdentifier = new NonTerminal("delimitedIdentifier");
var classSignature = new NonTerminal("classSignature");
var classBody = new NonTerminal("classBody");
var classBodyItem = new NonTerminal("classBodyItem");
var invExp = new NonTerminal("invExp");
var functionDefination = new NonTerminal("functionDefination");
var attributeDiclaration = new NonTerminal("attributeDiclaration");
var emofAttributeDiclaration = new NonTerminal("emofAttributeDiclaration");
var oclAttributeDiclaration = new NonTerminal("oclAttributeDiclaration");
var type = new NonTerminal("type");
var expression = new NonTerminal("expression");
var customType = new NonTerminal("customType");
var collectionTpye = new NonTerminal("collectionTpye");
var fullType = new NonTerminal("fullType");
var globalType = new NonTerminal("globalType");
var setType = new NonTerminal("setType");
var orderedSetType = new NonTerminal("orderedSetType");
var sequenceType = new NonTerminal("sequenceType");
var bagType = new NonTerminal("bagType");
var functionSignature = new NonTerminal("functionSignature");
var functionSignatureBody = new NonTerminal("functionSignatureBody");
var functionBody = new NonTerminal("functionBody");
var oclFunctionSignature = new NonTerminal("oclFunctionSignature");
var emofFunctionSignature = new NonTerminal("emofFunctionSignature");
var argumentList = new NonTerminal("argumentList");
var variableDiclaration = new NonTerminal("variableDiclaration");
var emofFunctionBody = new NonTerminal("emofFunctionBody");
var oclFunctionBody = new NonTerminal("oclFunctionBody");
var singleValueCollectionMember = new NonTerminal("singleValueCollectionMember");
var booleanValueCollection = new NonTerminal("booleanValueCollection");
var letExp = new NonTerminal("letExp");
var ifThenElseExp = new NonTerminal("ifThenElseExp");
var collectionValueExp = new NonTerminal("collectionValueExp");
var sum = new NonTerminal("sum");
var size = new NonTerminal("size");
var first = new NonTerminal("first");
var last = new NonTerminal("last");
var at = new NonTerminal("at");
var indexOf = new NonTerminal("indexOf");
var countOperation = new NonTerminal("countOperation");
var maxOperation = new NonTerminal("maxOperation");
var minOperation = new NonTerminal("minOperation");
var valueExp = new NonTerminal("valueExp");
var includesOperation = new NonTerminal("includesOperation");
var includesAllOperation = new NonTerminal("includesAllOperation");
var excludesOperation = new NonTerminal("excludesOperation");
var excludesAllOperation = new NonTerminal("excludesAllOperation");
var isEmptyOperation = new NonTerminal("isEmptyOperation");
var notEmptyOperation = new NonTerminal("notEmptyOperation");
var specialIteratorBodyExp = new NonTerminal("specialIteratorBodyExp");
var existsExp = new NonTerminal("existsExp");
var forAllExp = new NonTerminal("forAllExp");
var isUniqueExp = new NonTerminal("isUniqueExp");
var anyExp = new NonTerminal("anyExp");
var oneExp = new NonTerminal("oneExp");
var selectExp = new NonTerminal("selectExp");
var includingOperation = new NonTerminal("includingOperation");
var excludingOperation = new NonTerminal("excludingOperation");
var collect = new NonTerminal("collect");
var subOrderedSet = new NonTerminal("subOrderedSet");
var symmetricDifference = new NonTerminal("symmetricDifference");
var prepend = new NonTerminal("prepend");
var append = new NonTerminal("append");
var insertAt = new NonTerminal("insertAt");
var intersection = new NonTerminal("intersection");
var union = new NonTerminal("union");
var asBag = new NonTerminal("asBag");
var asSequence = new NonTerminal("asSequence");
var asOrderdSet = new NonTerminal("asOrderdSet");
var asSet = new NonTerminal("asSet");
var flatten = new NonTerminal("flatten");
var subSequence = new NonTerminal("subSequence");
var andExp = new NonTerminal("andExp");
var orExp = new NonTerminal("orExp");
var notExp = new NonTerminal("notExp");
var xorExp = new NonTerminal("xorExp");
var impliesExp = new NonTerminal("impliesExp");
var comparisonOperator = new NonTerminal("comparisonOperator");
var arithmaticOperator = new NonTerminal("arithmaticOperator");
var oclInvExp = new NonTerminal("oclInvExp");
var emofInvExp = new NonTerminal("emofInvExp");
var operationContextExp = new NonTerminal("operationContextExp");
var attributeContextExp = new NonTerminal("attributeContextExp");
var classContextExp = new NonTerminal("classContextExp");
var classContextSignature = new NonTerminal("classContextSignature");
var attributeContextbody = new NonTerminal("attributeContextbody");
var attributeContextbodyItem = new NonTerminal("attributeContextbodyItem");
var deriveExp = new NonTerminal("deriveExp");
var initExp = new NonTerminal("initExp");
var operationContextBodyExps = new NonTerminal("operationContextBodyExps");
var operationContextSignature = new NonTerminal("operationContextSignature");
var operationContextBodyItem = new NonTerminal("operationContextBodyItem");
var preCondition = new NonTerminal("preCondition");
var postCondition = new NonTerminal("postCondition");
var bodyExp = new NonTerminal("bodyExp");
var iterateExp = new NonTerminal("iterateExp");
var productExp = new NonTerminal("productExp");
var tupleExp = new NonTerminal("tupleExp");
var rejectExp = new NonTerminal("rejectExp");
var collection = new NonTerminal("collection");
var tuplElementList = new NonTerminal("tuplElementList");
var tupleElement = new NonTerminal("tupleElement");
var binaryOperator = new NonTerminal("binaryOperator");
var parameterList = new NonTerminal("parameterList");
var structuralExp = new NonTerminal("structuralExp");
var setLiteral = new NonTerminal("setLiteral");
var bagLiteral = new NonTerminal("orderedSetLiteral");
var orderedSetLiteral = new NonTerminal("");
var sequenceLiteral = new NonTerminal("sequenceLiteral");
var tupleLiteral = new NonTerminal("tupleLiteral");
var literalList = new NonTerminal("literalList");
var iteratorList = new NonTerminal("iteratorList");
var iteratorInitializationList = new NonTerminal("iteratorInitializationList");
var iteratorInitialization = new NonTerminal("iteratorInitialization");
var collectionValue = new NonTerminal("collectionValue");
var ArrayType = new NonTerminal("ArrayType");
var binaryBooleanOperator = new NonTerminal("binaryBooleanOperator");
var oclIsTypeOf = new NonTerminal("oclIsTypeOf");
var ValueExp = new NonTerminal("ValueExp");
var unValueExp = new NonTerminal("unValueExp");
var instanceMemberAccess = new NonTerminal("instanceMemberAccess");
var instanceMathodAccess = new NonTerminal("instanceMathodAccess");
#endregion
#region Rules
#region specification
specification.Rule = "specification" + identifier + lbr + specificationBody + rbr;
specificationBody.Rule = MakePlusRule(packages, package);
#endregion
#region package
package.Rule = oclPackage | emofOclPackage;
oclPackage.Rule = _package + identifier + packageBody + "endpackage";
emofOclPackage.Rule = _package + identifier + lbr + packageBody + rbr;
packageBody.Rule = MakeStarRule(packageBody, null, packageBodyItem);
packageBodyItem.Rule = primitive | enumeration | classType | contextExp | package;
#endregion
#region primitive
primitive.Rule = "primitive" + primitiveTypes + identifier + "IDENTICAL";
primitiveTypes.Rule = ToTerm("Real") | ToTerm("Integer") | ToTerm("String") | ToTerm("Boolean");
#endregion
#region enumeration
enumeration.Rule = "enumeration" + identifier + lbr + delimitedIdentifier + rbr;
delimitedIdentifier.Rule = MakePlusRule(delimitedIdentifier, comma, identifier);
#endregion
#region class
classType.Rule = classSignature + lbr + classBody + rbr;
classSignature.Rule = ToTerm("class") + identifier
| ToTerm("abstract") + ToTerm("class") + identifier
| ToTerm("abstract") + ToTerm("class") + identifier + ToTerm("extends") + identifier
| ToTerm("class") + identifier + ToTerm("extends") + type;
classBody.Rule = MakeStarRule(classBody, classBodyItem);
classBodyItem.Rule = attributeDiclaration | functionDefination | invExp;
#endregion
#region attribute
attributeDiclaration.Rule = oclAttributeDiclaration | emofAttributeDiclaration;
oclAttributeDiclaration.Rule = def + colon + identifier + type + ReduceHere()
| def + colon + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere()
| def + colon + "attr" + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere()
| def + colon + "attr" + identifier + type + ReduceHere();
emofAttributeDiclaration.Rule = identifier + colon + type + ReduceHere()
| ToTerm("component") + identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere()
| ToTerm("component") + identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + equalsTo + expression + ReduceHere()
| identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere()
| identifier + colon + type + ToTerm("unique") + ReduceHere();
#endregion
#region type
type.Rule = primitiveTypes | customType;
customType.Rule = fullType | globalType | ArrayType | collectionTpye | tupleExp;
fullType.Rule = identifier + scopeIn + fullType | identifier + ReduceHere();
globalType.Rule = PreferShiftHere() + scopeIn + fullType
| PreferShiftHere() + scopeIn + ArrayType;
ArrayType.Rule = fullType + "[" + "*" + "]"
| fullType + "[" + identifier + "]"
| fullType + "[" + number + "]"
| fullType + "[" + number + comma + number + "]"
| fullType + "[" + number + comma + "*" + "]";
collectionTpye.Rule = setType | orderedSetType | sequenceType | bagType | collection;
setType.Rule = "Set(" + customType + ")";
orderedSetType.Rule = "OrderedSet(" + customType + ")";
sequenceType.Rule = "Sequence(" + customType + ")";
bagType.Rule = "Bag(" + customType + ")";
collection.Rule = "Collection(" + customType + ")";
tupleExp.Rule = "Tuple" + lbr + argumentList + rbr;
#endregion
#region function
functionDefination.Rule = functionSignature + functionBody;
functionSignature.Rule = oclFunctionSignature | emofFunctionSignature;
oclFunctionSignature.Rule = def + colon + functionSignatureBody;
functionSignatureBody.Rule = identifier + lpar + argumentList + rpar + colon + type
| identifier + lpar + argumentList + rpar + colon + type + ToTerm("ordered") + ToTerm("unique")
| identifier + lpar + argumentList + rpar + colon;
argumentList.Rule = MakeStarRule(argumentList, comma, variableDiclaration);
variableDiclaration.Rule = identifier + PreferShiftHere() + colon + type;
emofFunctionSignature.Rule = functionSignatureBody;
functionBody.Rule = oclFunctionBody | emofFunctionBody;
oclFunctionBody.Rule = equalsTo + expression;
emofFunctionBody.Rule = equalsTo + lbr + expression + rbr;
#endregion
#region expression
expression.Rule = valueExp | structuralExp;
#endregion
#region valueExp
valueExp.Rule = // ValueExp + ReduceHere() |
unValueExp + ReduceHere()
| valueExp + PreferShiftHere() + binaryOperator + valueExp
| ToTerm("not") + valueExp
| lpar + valueExp + rpar;
#endregion
#region unValueExp
unValueExp.Rule = booleanValueCollection
| ToTerm("false") | ToTerm("true")
| collectionValue
| tupleLiteral
| singleValueCollectionMember
| collectionValueExp
| iterateExp
| stringLiteral
| charLiteral
| number
| self
| oclIsTypeOf
| unValueExp + lpar + parameterList + rpar
| instanceMemberAccess
| instanceMathodAccess
| ToTerm("-") + number;
#endregion
#region ValueExp
ValueExp.Rule = fullType + dot + instanceMemberAccess
| globalType + dot + instanceMemberAccess
| ValueExp + dot + identifier + lpar + parameterList + rpar;
#endregion
#region instanceMemberAccess
instanceMemberAccess.Rule = MakePlusRule(instanceMemberAccess, dot, identifier);
instanceMathodAccess.Rule = unValueExp + dot + identifier + lpar + parameterList + rpar;
#endregion
#region parameterList
parameterList.Rule = MakeStarRule(parameterList, comma, expression);
#endregion
#region booleanExp
booleanValueCollection.Rule = includesOperation | includesAllOperation | excludesOperation | excludesAllOperation
| isEmptyOperation | notEmptyOperation | existsExp | forAllExp | isUniqueExp | anyExp | oneExp;
#endregion
#region oclBuildInMethods
oclIsTypeOf.Rule = valueExp + dot + ToTerm("oclIsTypeOf") + lpar + type + rpar;
#endregion
#region binaryOperator
binaryOperator.Rule = comparisonOperator | arithmaticOperator | binaryBooleanOperator;
arithmaticOperator.Rule = ToTerm("/") | ToTerm("div") | ToTerm("*") | ToTerm("+") | ToTerm("-");
comparisonOperator.Rule = ToTerm(">") | ToTerm("<") | ToTerm(">=") | ToTerm("<=") | ToTerm("<>") | equalsTo;
binaryBooleanOperator.Rule = ToTerm("and") | ToTerm("or") | ToTerm("xor") | ToTerm("implies");
#endregion
#region booleanValueCollection
includesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includes") + lpar + valueExp + rpar;
includesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includesAll") + lpar + identifier + rpar;
excludesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludes") + lpar + identifier + rpar;
excludesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludesAll") + lpar + identifier + rpar;
isEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isEmpty") + lpar + rpar;
notEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("notEmpty") + lpar + rpar;
existsExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("exists") + lpar + specialIteratorBodyExp + rpar;
forAllExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("forAll") + lpar + specialIteratorBodyExp + rpar;
isUniqueExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isUnique") + lpar + specialIteratorBodyExp + rpar;
anyExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("any") + lpar + specialIteratorBodyExp + rpar;
oneExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("one") + lpar + specialIteratorBodyExp + rpar;
specialIteratorBodyExp.Rule = delimitedIdentifier + colon + type + suchThat + valueExp
| argumentList + suchThat + valueExp
| valueExp;
#endregion
#region collectionValue
collectionValue.Rule = setLiteral | bagLiteral | orderedSetLiteral | sequenceLiteral;
setLiteral.Rule = "Set" + lbr + literalList + rbr
| "Set" + lpar + type + rpar + lbr + literalList + rbr;
bagLiteral.Rule = "Bag" + lbr + literalList + rbr
| "Bag" + lpar + type + rpar + lbr + literalList + rbr;
orderedSetLiteral.Rule = "OrderedSet" + lbr + literalList + rbr
| "OrderedSet" + lpar + type + rpar + lbr + literalList + rbr;
sequenceLiteral.Rule = "Sequence" + lbr + literalList + rbr
| "Sequence" + lpar + type + rpar + lbr + literalList + rbr;
literalList.Rule = MakeStarRule(literalList, comma, valueExp);
tupleLiteral.Rule = "Tuple" + lbr + tuplElementList + rbr;
tuplElementList.Rule = MakePlusRule(tuplElementList, comma, tupleElement);
tupleElement.Rule = variableDiclaration + equalsTo + valueExp | identifier + equalsTo + valueExp;
collectionValueExp.Rule = includingOperation | excludingOperation | selectExp | rejectExp
| union | intersection | insertAt | append | prepend | symmetricDifference | subOrderedSet | collect | productExp
| subSequence | flatten | asSet | asOrderdSet | asSequence | asBag;
includingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("including") + lpar + identifier + rpar;
excludingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excluding") + lpar + identifier + rpar;
selectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("select") + lpar + specialIteratorBodyExp + rpar;
rejectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("reject") + lpar + specialIteratorBodyExp + rpar;
union.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("union") + lpar + valueExp + rpar;
intersection.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("intersection") + lpar + identifier + rpar;
insertAt.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("insertAt") + lpar + number + comma + identifier + rpar;
append.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("append") + lpar + identifier + rpar;
prepend.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("prepend") + lpar + identifier + rpar;
symmetricDifference.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("symmetricDifference") + lpar + identifier + rpar;
subOrderedSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subOrderedSet") + lpar + number + comma + number + rpar;
collect.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + specialIteratorBodyExp + rpar
| valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + identifier + rpar
| valueExp + dot + identifier + lpar + argumentList + rpar
| valueExp + PreferShiftHere() + propertyIs + identifier + lpar + argumentList + rpar;
productExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("product") + lpar + identifier + rpar;
subSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subSequence") + lpar + number + comma + number + rpar;
flatten.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("flatten") + lpar + rpar;
asSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSet") + lpar + rpar;
asOrderdSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asOrderdSet") + lpar + rpar;
asSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSequence") + lpar + rpar;
asBag.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asBag") + lpar + rpar;
#endregion
#region singleValueCollectionMember
singleValueCollectionMember.Rule = maxOperation | minOperation | countOperation | at | indexOf | first | last | sum | size;
maxOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "max" + lpar + rpar;
minOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "min" + lpar + rpar;
countOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "count" + lpar + identifier + rpar;
at.Rule = valueExp + PreferShiftHere() + propertyIs + "at" + lpar + identifier + rpar;
indexOf.Rule = valueExp + PreferShiftHere() + propertyIs + "indexOf" + lpar + identifier + rpar;
first.Rule = valueExp + PreferShiftHere() + propertyIs + "first" + lpar + rpar;
last.Rule = valueExp + PreferShiftHere() + propertyIs + "last" + lpar + rpar;
sum.Rule = valueExp + PreferShiftHere() + propertyIs + "sum" + lpar + rpar;
size.Rule = valueExp + PreferShiftHere() + propertyIs + "size" + lpar + rpar;
#endregion
#region iterateExp
iterateExp.Rule = valueExp + PreferShiftHere() + propertyIs + "iterate" + lpar + iteratorList + ";"
+ iteratorInitializationList + suchThat + expression + rpar;
iteratorList.Rule = MakePlusRule(iteratorList, comma, variableDiclaration);
iteratorInitializationList.Rule = MakePlusRule(iteratorInitializationList, comma, iteratorInitialization);
iteratorInitialization.Rule = variableDiclaration + equalsTo + valueExp;
#endregion
#region structuralExp
structuralExp.Rule = ifThenElseExp | letExp;
#endregion
#region ifThenElseExp
ifThenElseExp.Rule = "if" + valueExp + "then" + expression + "endif"
| "if" + valueExp + "then" + expression + "else" + expression + "endif";
#endregion
#region letExp
letExp.Rule = let + variableDiclaration + equalsTo + valueExp + In + expression
| let + identifier + equalsTo + valueExp + In + expression;
#endregion
#region invExp
invExp.Rule = oclInvExp | emofInvExp;
oclInvExp.Rule = inv + identifier + colon + expression
| inv + colon + expression;
emofInvExp.Rule = "invariant" + lbr + expression + rbr;
#endregion
#region contextExp
contextExp.Rule = classContextExp | attributeContextExp | operationContextExp;
#endregion
#region classContextExp
classContextExp.Rule = classContextSignature + classBody;
classContextSignature.Rule = context + type
| context + identifier + colon + type;
classBody.Rule = MakePlusRule(classBody, null, classBodyItem);
classBodyItem.Rule = invExp | attributeDiclaration | functionDefination;
#endregion
#region attributeContextExp
attributeContextExp.Rule = context + type + colon + type + attributeContextbody;
attributeContextbody.Rule = MakePlusRule(attributeContextbody, null, attributeContextbodyItem);
attributeContextbodyItem.Rule = initExp | deriveExp;
#endregion
#region initExp
initExp.Rule = ToTerm("init") + colon + equalsTo + valueExp;
#endregion
#region deriveExp
deriveExp.Rule = ToTerm("derive") + colon + expression;
#endregion
#region operationContextExp
operationContextExp.Rule = operationContextSignature + invExp + operationContextBodyExps;
operationContextSignature.Rule = context + customType + PreferShiftHere() + scopeIn + functionSignature;
operationContextBodyExps.Rule = MakePlusRule(operationContextBodyExps, null, operationContextBodyItem);
operationContextBodyItem.Rule = preCondition | bodyExp | postCondition;
#endregion
#region preCondition
preCondition.Rule = pre + identifier + colon + valueExp
| pre + colon + valueExp;
#endregion
#region bodyExp
bodyExp.Rule = body + colon + expression;
#endregion
#region postCondition
postCondition.Rule = post + colon + valueExp
| post + identifier + colon + valueExp;
#endregion
#endregion
#region Operator,punctuation
MarkPunctuation(",", "(", ")", "{", "}", "[", "]", ":");
MarkMemberSelect(".", "->"); //dot, propertyIs);
RegisterOperators(1, lpar, rpar);
RegisterOperators(2, "let", "in");
RegisterOperators(3, letExp, In);
RegisterOperators(4, dot, scopeIn);
RegisterOperators(5, not);
RegisterOperators(6, "*", "/");
RegisterOperators(7, letExp, In);
RegisterOperators(8, dot, scopeIn);
RegisterOperators(9, "+", "-");
RegisterOperators(10, "<", ">", "<=", ">=");
RegisterOperators(11, "=", "<>");
RegisterOperators(12, and);
RegisterOperators(12, "div", "implies");
RegisterOperators(13, or);
RegisterOperators(14, xor);
RegisterOperators(15, "=", "<>");
#endregion
this.Root = specification;
}
public AnalizadorPy()
: base(caseSensitive: false)
{
#region expresiones regulares
var identificador = TerminalFactory.CreateCSharpIdentifier("identificador");
var numero = TerminalFactory.CreateCSharpNumber("numero");
var val_false = Constantes.falso;
var val_true = Constantes.verdadero;
StringLiteral cadena = new StringLiteral("cadena", "\"");
var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter);
CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "/*", "*/");
CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "//", "\n", "\r\n");
NonGrammarTerminals.Add(COMENT_BLOQUE);
NonGrammarTerminals.Add(COMENT_LINEA);
#endregion
#region palabras reservadas
var tipoDecimal = Constantes.tipoDecimal;
var tipoString = Constantes.tipoCadena;
var tipoBoolean = Constantes.tipoBool;
var tipoCaracter = Constantes.tipoChar;
var tipoInt = Constantes.tipoEntero;
var tipoVoid = Constantes.tipoVoid;
var visiPublico = Constantes.publico;
var visiPrivado = Constantes.privado;
var visiProtegido = Constantes.protegido;
var clase = Constantes.clase;
var sobreescribir = Constantes.sobreescribir;
#endregion
#region declaproducciones
NonTerminal FUN_SOBRE = new NonTerminal(Constantes.funSobre);
NonTerminal TIPO = new NonTerminal(Constantes.tipo);
NonTerminal FUNCION = new NonTerminal(Constantes.funcion);
NonTerminal VISIBILIDAD = new NonTerminal(Constantes.visibilidad);
NonTerminal CUERPO = new NonTerminal(Constantes.cuerpo);
NonTerminal PARAMETRO = new NonTerminal(Constantes.parametro);
NonTerminal L_PARAMETRO = new NonTerminal(Constantes.listaParametros);
NonTerminal L_ELEMENTOS = new NonTerminal(Constantes.listaElementos);
NonTerminal ATRIBUTO = new NonTerminal(Constantes.atributo);
NonTerminal L_IDS = new NonTerminal(Constantes.listaIds);
NonTerminal EXPRESION = new NonTerminal(Constantes.expresion);
NonTerminal ELEMENTO = new NonTerminal(Constantes.elementoClase);
NonTerminal CLASE = new NonTerminal(Constantes.clase);
NonTerminal CUERPO_CLASE = new NonTerminal(Constantes.CUERPO_CLASE);
NonTerminal PRINCIPAL = new NonTerminal(Constantes.principal);
NonTerminal CONSTRUCTOR = new NonTerminal(Constantes.constructor);
NonTerminal IMPRIMIR = new NonTerminal(Constantes.imprimir);
NonTerminal DECLAPARA = new NonTerminal("DECLAPARA");
NonTerminal INSTRUCCIONES = new NonTerminal(Constantes.instrucciones);
NonTerminal INSTRUCCION = new NonTerminal(Constantes.instruccion);
NonTerminal DECLARACION = new NonTerminal(Constantes.declaracion);
NonTerminal LPOSICIONES = new NonTerminal(Constantes.lposiciones);
NonTerminal LEXPRESIONES = new NonTerminal(Constantes.lexpresiones);
NonTerminal LFILAS = new NonTerminal(Constantes.lfilas);
NonTerminal ASIGNACION = new NonTerminal(Constantes.asignacion);
NonTerminal POSICION = new NonTerminal(Constantes.posicion);
NonTerminal FILA = new NonTerminal(Constantes.fila);
NonTerminal DECIMAL = new NonTerminal(Constantes.tipoDecimal);
NonTerminal ENTERO = new NonTerminal(Constantes.tipoEntero);
NonTerminal CADENA = new NonTerminal(Constantes.tipoCadena);
NonTerminal CHAR = new NonTerminal(Constantes.tipoChar);
NonTerminal BOOLEANO = new NonTerminal(Constantes.tipoBool);
NonTerminal SIMB_ARIT = new NonTerminal(Constantes.simb_arit);
NonTerminal SIMB_REL = new NonTerminal(Constantes.simb_rel);
NonTerminal UNARIO = new NonTerminal(Constantes.unario);
NonTerminal ID = new NonTerminal(Constantes.id);
NonTerminal NEGATIVO = new NonTerminal(Constantes.negativo);
NonTerminal RELACIONAL = new NonTerminal(Constantes.relacional);
NonTerminal ARITMETICA = new NonTerminal(Constantes.aritmetica);
NonTerminal LOGICA = new NonTerminal(Constantes.logica);
NonTerminal LLAMADA = new NonTerminal(Constantes.llamada);
NonTerminal POSVECTOR = new NonTerminal(Constantes.posvector);
NonTerminal LISTAPUNTOS = new NonTerminal(Constantes.listapuntos);
NonTerminal SIMB_LOG = new NonTerminal(Constantes.simb_log);
NonTerminal MAS_MAS = new NonTerminal(Constantes.masmas);
NonTerminal MENOS_MENOS = new NonTerminal(Constantes.menosmenos);
NonTerminal ASIG_ARRAY = new NonTerminal(Constantes.asig_array);
NonTerminal termino = new NonTerminal(Constantes.termino);
NonTerminal RETORNO = new NonTerminal(Constantes.retorno);
NonTerminal LISTACLASES = new NonTerminal(Constantes.l_clases);
NonTerminal SUMA = new NonTerminal(Constantes.suma);
NonTerminal RESTA = new NonTerminal(Constantes.resta);
NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion);
NonTerminal DIVISION = new NonTerminal(Constantes.division);
NonTerminal POTENCIA = new NonTerminal(Constantes.potencia);
NonTerminal MENOR = new NonTerminal(Constantes.menor);
NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual);
NonTerminal MAYOR = new NonTerminal(Constantes.mayor);
NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual);
NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual);
NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA);
NonTerminal XOR = new NonTerminal(Constantes.xorJava);
NonTerminal AND = new NonTerminal(Constantes.andJava);
NonTerminal NOT = new NonTerminal(Constantes.notJavaPython);
NonTerminal OR = new NonTerminal(Constantes.orJava);
NonTerminal INSTANCIA = new NonTerminal(Constantes.instancia);
NonTerminal SALIR = new NonTerminal(Constantes.salir);
NonTerminal CONTINUAR = new NonTerminal(Constantes.continuar);
NonTerminal SI = new NonTerminal(Constantes.si);
NonTerminal EXTRA = new NonTerminal(Constantes.extraSi);
NonTerminal SINO = new NonTerminal(Constantes.sino);
NonTerminal CUERPOSI = new NonTerminal(Constantes.cuerposi);
NonTerminal L_EXTRAS = new NonTerminal(Constantes.lextra);
NonTerminal MIENTRAS = new NonTerminal(Constantes.mientras);
NonTerminal REPETIR = new NonTerminal(Constantes.repetir);
NonTerminal HACER = new NonTerminal(Constantes.hacer);
NonTerminal PARA = new NonTerminal(Constantes.para);
NonTerminal LOOP = new NonTerminal(Constantes.loop);
#endregion
VISIBILIDAD.Rule = ToTerm(visiPrivado)
| ToTerm(visiProtegido)
| ToTerm(visiPublico);
TIPO.Rule = ToTerm(tipoBoolean)
| ToTerm(tipoCaracter)
| ToTerm(tipoDecimal)
| ToTerm(tipoInt)
| ToTerm(tipoString)
| identificador;
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
DECLARACION.Rule = TIPO + L_IDS
| TIPO + L_IDS + LPOSICIONES;
POSICION.Rule = ToTerm("[") + EXPRESION + "]";
LPOSICIONES.Rule = MakePlusRule(LPOSICIONES, POSICION);
FILA.Rule = ToTerm("{") + LEXPRESIONES + "}";
LFILAS.Rule = MakePlusRule(LFILAS, ToTerm(","), FILA);
ASIGNACION.Rule = EXPRESION + ToTerm("=") + ">" + EXPRESION;
INSTRUCCION.Rule = DECLARACION + Eos
| CONTINUAR + Eos
| SALIR + Eos
| MIENTRAS + Eos
| HACER
| REPETIR
| LOOP + Eos;
INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION);
CUERPO.Rule = Indent + INSTRUCCIONES + Dedent;
FUNCION.Rule = VISIBILIDAD + ToTerm("funcion") + TIPO + identificador + "[" + "]" + Eos + CUERPO;
#region estructuras de control
CONTINUAR.Rule = ToTerm(Constantes.continuar);
SALIR.Rule = ToTerm(Constantes.salir);
MIENTRAS.Rule = ToTerm(Constantes.mientras) + EXPRESION + ":" + Eos + CUERPO;
HACER.Rule = ToTerm(Constantes.hacer) + ":" + Eos + CUERPO + ToTerm(Constantes.mientras) + EXPRESION + Eos;
REPETIR.Rule = ToTerm(Constantes.repetir) + ":" + Eos + CUERPO + ToTerm(Constantes.hasta) + EXPRESION + Eos;
LOOP.Rule = ToTerm(Constantes.loop) + ":" + Eos + CUERPO;
#endregion
#region expresion
DECIMAL.Rule = numero;
ENTERO.Rule = numero;
CADENA.Rule = cadena;
ID.Rule = identificador;
CHAR.Rule = caracter;
BOOLEANO.Rule = ToTerm(val_false)
| ToTerm(val_true);
ARITMETICA.Rule = SUMA
| RESTA
| MULTIPLICACION
| DIVISION
| POTENCIA;
RELACIONAL.Rule = MENOR
| MAYOR
| MENORIGUAL
| MAYORIGUAL
| DISTINTOA
| IGUALIGUAL;
LOGICA.Rule = XOR
| OR
| AND
| NOT;
SUMA.Rule = EXPRESION + ToTerm(Constantes.suma) + EXPRESION;
RESTA.Rule = EXPRESION + ToTerm(Constantes.resta) + EXPRESION;
MULTIPLICACION.Rule = EXPRESION + ToTerm(Constantes.multiplicacion) + EXPRESION;
DIVISION.Rule = EXPRESION + ToTerm(Constantes.division) + EXPRESION;
POTENCIA.Rule = EXPRESION + ToTerm(Constantes.potencia) + EXPRESION;
MENOR.Rule = EXPRESION + ToTerm(Constantes.menor) + EXPRESION;
MENORIGUAL.Rule = EXPRESION + ToTerm(Constantes.menorIgual) + EXPRESION;
MAYOR.Rule = EXPRESION + ToTerm(Constantes.mayor) + EXPRESION;
MAYORIGUAL.Rule = EXPRESION + ToTerm(Constantes.mayorIgual) + EXPRESION;
IGUALIGUAL.Rule = EXPRESION + ToTerm(Constantes.igualIgual) + EXPRESION;
DISTINTOA.Rule = EXPRESION + ToTerm(Constantes.distintoA) + EXPRESION;
XOR.Rule = EXPRESION + ToTerm(Constantes.xorPython) + EXPRESION;
AND.Rule = EXPRESION + ToTerm(Constantes.andPython) + EXPRESION;
NOT.Rule = ToTerm(Constantes.notJavaPython) + EXPRESION;
OR.Rule = EXPRESION + ToTerm(Constantes.orPython) + EXPRESION;
INSTANCIA.Rule = Constantes.nuevoPython + identificador + "[" + LEXPRESIONES + "]"
| Constantes.nuevoPython + identificador + "[" + "]";
UNARIO.Rule = MAS_MAS
| MENOS_MENOS;
MAS_MAS.Rule = identificador + ToTerm(Constantes.masmas);
MENOS_MENOS.Rule = identificador + ToTerm(Constantes.menosmenos);
NEGATIVO.Rule = ToTerm("-") + EXPRESION;
termino.Rule = ToTerm("(") + ARITMETICA + ")"
| ToTerm("[") + RELACIONAL + "]"
| ToTerm("{") + LOGICA + "}"
| DECIMAL
| ENTERO
| ID
| CADENA
| BOOLEANO
| CHAR
| LLAMADA
| POSVECTOR
| ToTerm("(") + UNARIO + ")"
| NEGATIVO
| "{" + LFILAS + "}"
| INSTANCIA;
LLAMADA.Rule = identificador + ToTerm("[") + LEXPRESIONES + "]"
| identificador + ToTerm("[") + "]";
POSVECTOR.Rule = identificador + LPOSICIONES;
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), termino);
LEXPRESIONES.Rule = MakePlusRule(EXPRESION, ToTerm(","), EXPRESION);
#endregion
NonTerminal n = new NonTerminal("fdsfd");
n.Rule = termino + Eos;
this.Root = n;
}
public Gramatica()
: base(caseSensitive: false)
{
#region expresiones regulares
var doble = new RegexBasedTerminal("doble", "[0-9]+[.][0-9]+");
var entero = new RegexBasedTerminal("entero", "[0-9]+");
var identificador = TerminalFactory.CreateCSharpIdentifier("identificador");
var numero = TerminalFactory.CreateCSharpNumber("numero");
var val_false = Constantes.falso;
var val_true = Constantes.verdadero;
StringLiteral cadena = new StringLiteral("cadena", "\"");
var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter);
CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "/*", "*/");
CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "//", "\n", "\r\n");
NonGrammarTerminals.Add(COMENT_BLOQUE);
NonGrammarTerminals.Add(COMENT_LINEA);
#endregion
#region palabras reservadas
var tipoDecimal = Constantes.tipoDecimal;
var tipoString = Constantes.tipoCadena;
var tipoBoolean = Constantes.tipoBool;
var tipoCaracter = Constantes.tipoChar;
var tipoInt = Constantes.tipoEntero;
var tipoVoid = Constantes.tipoVoid;
var visiPublico = Constantes.publico;
var visiPrivado = Constantes.privado;
var visiProtegido = Constantes.protegido;
var clase = Constantes.clase;
var sobreescribir = Constantes.sobreescribir;
#endregion
#region No terminales
NonTerminal FUN_SOBRE = new NonTerminal(Constantes.funSobre);
NonTerminal TIPO = new NonTerminal(Constantes.tipo);
NonTerminal FUNCION = new NonTerminal(Constantes.funcion);
NonTerminal VISIBILIDAD = new NonTerminal(Constantes.visibilidad);
NonTerminal CUERPO = new NonTerminal(Constantes.cuerpo);
NonTerminal PARAMETRO = new NonTerminal(Constantes.parametro);
NonTerminal L_PARAMETRO = new NonTerminal(Constantes.listaParametros);
NonTerminal L_ELEMENTOS = new NonTerminal(Constantes.listaElementos);
NonTerminal ATRIBUTO = new NonTerminal(Constantes.atributo);
NonTerminal L_IDS = new NonTerminal(Constantes.listaIds);
NonTerminal EXPRESION = new NonTerminal(Constantes.expresion);
NonTerminal ELEMENTO = new NonTerminal(Constantes.elementoClase);
NonTerminal CLASE = new NonTerminal(Constantes.clase);
NonTerminal CUERPO_CLASE = new NonTerminal(Constantes.CUERPO_CLASE);
NonTerminal PRINCIPAL = new NonTerminal(Constantes.principal);
NonTerminal CONSTRUCTOR = new NonTerminal(Constantes.constructor);
NonTerminal SI = new NonTerminal(Constantes.si);
NonTerminal EXTRA = new NonTerminal(Constantes.extraSi);
NonTerminal SINO = new NonTerminal(Constantes.sino);
NonTerminal CUERPOSI = new NonTerminal(Constantes.cuerposi);
NonTerminal L_EXTRAS = new NonTerminal(Constantes.lextra);
NonTerminal MIENTRAS = new NonTerminal(Constantes.mientras);
NonTerminal REPETIR = new NonTerminal(Constantes.repetir);
NonTerminal HACER = new NonTerminal(Constantes.hacer);
NonTerminal X = new NonTerminal(Constantes.x);
NonTerminal PARA = new NonTerminal(Constantes.para);
NonTerminal IMPRIMIR = new NonTerminal(Constantes.imprimir);
NonTerminal DECLAPARA = new NonTerminal("DECLAPARA");
NonTerminal INSTRUCCIONES = new NonTerminal(Constantes.instrucciones);
NonTerminal INSTRUCCION = new NonTerminal(Constantes.instruccion);
NonTerminal DECLARACION = new NonTerminal(Constantes.decla2);
NonTerminal LPOSICIONES = new NonTerminal(Constantes.lposiciones);
NonTerminal LEXPRESIONES = new NonTerminal(Constantes.lexpresiones);
NonTerminal LFILAS = new NonTerminal(Constantes.lfilas);
NonTerminal ASIGNACION = new NonTerminal(Constantes.asignacion);
NonTerminal POSICION = new NonTerminal(Constantes.posicion);
NonTerminal FILA = new NonTerminal(Constantes.fila);
NonTerminal DECIMAL = new NonTerminal(Constantes.tipoDecimal);
NonTerminal ENTERO = new NonTerminal(Constantes.tipoEntero);
NonTerminal CADENA = new NonTerminal(Constantes.tipoCadena);
NonTerminal CHAR = new NonTerminal(Constantes.tipoChar);
NonTerminal BOOLEANO = new NonTerminal(Constantes.tipoBool);
NonTerminal SIMB_ARIT = new NonTerminal(Constantes.simb_arit);
NonTerminal SIMB_REL = new NonTerminal(Constantes.simb_rel);
NonTerminal UNARIO = new NonTerminal(Constantes.unario);
NonTerminal ID = new NonTerminal(Constantes.id);
NonTerminal NEGATIVO = new NonTerminal(Constantes.negativo);
NonTerminal RELACIONAL = new NonTerminal(Constantes.relacional);
NonTerminal ARITMETICA = new NonTerminal(Constantes.aritmetica);
NonTerminal LOGICA = new NonTerminal(Constantes.logica);
NonTerminal LLAMADA = new NonTerminal(Constantes.llamada);
NonTerminal POSVECTOR = new NonTerminal(Constantes.posvector);
NonTerminal LISTAPUNTOS = new NonTerminal(Constantes.listapuntos);
NonTerminal SIMB_LOG = new NonTerminal(Constantes.simb_log);
NonTerminal MAS_MAS = new NonTerminal(Constantes.masmas);
NonTerminal MENOS_MENOS = new NonTerminal(Constantes.menosmenos);
NonTerminal ASIG_ARRAY = new NonTerminal(Constantes.asig_array);
NonTerminal TERMINO = new NonTerminal(Constantes.termino);
NonTerminal RETORNO = new NonTerminal(Constantes.retorno);
NonTerminal LISTACLASES = new NonTerminal(Constantes.l_clases);
NonTerminal SUMA = new NonTerminal(Constantes.suma);
NonTerminal RESTA = new NonTerminal(Constantes.resta);
NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion);
NonTerminal DIVISION = new NonTerminal(Constantes.division);
NonTerminal POTENCIA = new NonTerminal(Constantes.potencia);
NonTerminal MENOR = new NonTerminal(Constantes.menor);
NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual);
NonTerminal MAYOR = new NonTerminal(Constantes.mayor);
NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual);
NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual);
NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA);
NonTerminal XOR = new NonTerminal(Constantes.xorJava);
NonTerminal AND = new NonTerminal(Constantes.andJava);
NonTerminal NOT = new NonTerminal(Constantes.notJavaPython);
NonTerminal OR = new NonTerminal(Constantes.orJava);
NonTerminal INSTANCIA = new NonTerminal(Constantes.instancia);
NonTerminal THIS = new NonTerminal("THIS");
NonTerminal SUPER = new NonTerminal("SUPER");
NonTerminal LLAMADAOBJETO = new NonTerminal("LLAMADA_OBJETO");
NonTerminal tipoLista = new NonTerminal("tipoElemento");
#endregion
#region gramatica
#region clases
LISTACLASES.Rule = MakePlusRule(LISTACLASES, CLASE);
CLASE.Rule = ToTerm(clase) + identificador + identificador + CUERPO_CLASE
| ToTerm(clase) + identificador + CUERPO_CLASE;
CUERPO_CLASE.Rule = ToTerm("{") + L_ELEMENTOS + ToTerm("}");
L_ELEMENTOS.Rule = MakeStarRule(L_ELEMENTOS, ELEMENTO);
ELEMENTO.Rule = FUNCION
| ATRIBUTO
| PRINCIPAL
| CONSTRUCTOR
| FUN_SOBRE;
FUN_SOBRE.Rule = ToTerm("@") + ToTerm(sobreescribir) + FUNCION;
#endregion
#region funciones
PRINCIPAL.Rule = ToTerm(Constantes.principal) + ToTerm("(") + ToTerm(")") + CUERPO;
CONSTRUCTOR.Rule = identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO;
FUNCION.Rule = VISIBILIDAD + TIPO + identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO
| VISIBILIDAD + ToTerm(tipoVoid) + identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO
| TIPO + identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO
| ToTerm(tipoVoid) + identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO;
CUERPO.Rule = ToTerm("{") + INSTRUCCIONES + "}";
#endregion
RETORNO.Rule = ToTerm(Constantes.retorno) + EXPRESION + ToTerm(";");
ATRIBUTO.Rule = VISIBILIDAD + TIPO + L_IDS + ToTerm(";")
| VISIBILIDAD + TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
| TIPO + L_IDS + ToTerm(";")
| TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
| VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm(";")
| VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";"
| TIPO + identificador + LPOSICIONES + ToTerm(";")
| TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";"
| TIPO + identificador + ToTerm("=") + INSTANCIA + ";"
| VISIBILIDAD + TIPO + identificador + ToTerm("=") + INSTANCIA + ";";
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
TIPO.Rule = ToTerm(tipoBoolean)
| ToTerm(tipoCaracter)
| ToTerm(tipoDecimal)
| ToTerm(tipoInt)
| ToTerm(tipoString)
| identificador;
VISIBILIDAD.Rule = ToTerm(visiPrivado)
| ToTerm(visiProtegido)
| ToTerm(visiPublico);
PARAMETRO.Rule = TIPO + identificador;
L_PARAMETRO.Rule = MakeStarRule(L_PARAMETRO, ToTerm(","), PARAMETRO);
#region sentenciasControl
SI.Rule = ToTerm(Constantes.si) + "(" + EXPRESION + ")" + CUERPO + L_EXTRAS + SINO
| ToTerm(Constantes.si) + "(" + EXPRESION + ")" + CUERPO + L_EXTRAS
| ToTerm(Constantes.si) + "(" + EXPRESION + ")" + CUERPO + SINO;
SINO.Rule = ToTerm(Constantes.sino) + CUERPO;
EXTRA.Rule = ToTerm(Constantes.sino) + Constantes.si + CUERPO;
L_EXTRAS.Rule = MakeStarRule(L_EXTRAS, EXTRA);
MIENTRAS.Rule = ToTerm(Constantes.mientras) + "(" + EXPRESION + ")" + CUERPO;
HACER.Rule = ToTerm(Constantes.hacer) + CUERPO + Constantes.mientras + "(" + EXPRESION + ")" + ";";
X.Rule = ToTerm(Constantes.x) + "(" + EXPRESION + "," + EXPRESION + ")" + CUERPO;
REPETIR.Rule = ToTerm(Constantes.repetir) + CUERPO + Constantes.until + "(" + EXPRESION + ")" + ";";
PARA.Rule = ToTerm(Constantes.para) + "(" + DECLAPARA + ";" + EXPRESION + ";" + EXPRESION + ")" + CUERPO;
IMPRIMIR.Rule = ToTerm(Constantes.imprimir) + "(" + EXPRESION + ")" + ";";
INSTRUCCION.Rule = IMPRIMIR
| PARA //--
| REPETIR //--
| X
| HACER //--
| MIENTRAS //--
| SI //--
| DECLARACION //
| ASIGNACION //--
| EXPRESION + ToTerm(";") //--
| RETORNO; //--
DECLAPARA.Rule = DECLARACION
| ASIGNACION;
INSTRUCCIONES.Rule = MakeStarRule(INSTRUCCIONES, INSTRUCCION);
DECLARACION.Rule = TIPO + identificador + ToTerm(";")
| TIPO + identificador + ToTerm("=") + EXPRESION + ";"
| TIPO + identificador + LPOSICIONES + ToTerm(";")
| TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";"
| TIPO + identificador + ToTerm("=") + INSTANCIA + ";";
ASIGNACION.Rule = EXPRESION + ToTerm("=") + EXPRESION + ";"
| EXPRESION + ToTerm("=") + INSTANCIA;
#region expresion
POSICION.Rule = ToTerm("[") + EXPRESION + "]";
LPOSICIONES.Rule = MakePlusRule(LPOSICIONES, POSICION);
FILA.Rule = ToTerm("{") + LEXPRESIONES + "}";
LFILAS.Rule = MakePlusRule(LFILAS, ToTerm(","), FILA);
DECIMAL.Rule = doble;
ENTERO.Rule = entero;
CADENA.Rule = cadena;
ID.Rule = identificador;
CHAR.Rule = caracter;
BOOLEANO.Rule = ToTerm(val_false)
| ToTerm(val_true);
ARITMETICA.Rule = SUMA
| RESTA
| MULTIPLICACION
| DIVISION
| POTENCIA;
RELACIONAL.Rule = MENOR
| MAYOR
| MENORIGUAL
| MAYORIGUAL
| DISTINTOA
| IGUALIGUAL;
LOGICA.Rule = XOR
| OR
| AND
| NOT;
SUMA.Rule = TERMINO + ToTerm(Constantes.suma) + TERMINO;
RESTA.Rule = TERMINO + ToTerm(Constantes.resta) + TERMINO;
MULTIPLICACION.Rule = TERMINO + ToTerm(Constantes.multiplicacion) + TERMINO;
DIVISION.Rule = TERMINO + ToTerm(Constantes.division) + TERMINO;
POTENCIA.Rule = TERMINO + ToTerm(Constantes.potencia) + TERMINO;
MENOR.Rule = TERMINO + ToTerm(Constantes.menor) + TERMINO;
MENORIGUAL.Rule = TERMINO + ToTerm(Constantes.menorIgual) + TERMINO;
MAYOR.Rule = TERMINO + ToTerm(Constantes.mayor) + TERMINO;
MAYORIGUAL.Rule = TERMINO + ToTerm(Constantes.mayorIgual) + TERMINO;
IGUALIGUAL.Rule = TERMINO + ToTerm(Constantes.igualIgual) + TERMINO;
DISTINTOA.Rule = TERMINO + ToTerm(Constantes.distintoA) + TERMINO;
XOR.Rule = TERMINO + ToTerm(Constantes.xorJava) + TERMINO;
AND.Rule = TERMINO + ToTerm(Constantes.andJava) + TERMINO;
NOT.Rule = ToTerm(Constantes.notJavaPython) + TERMINO;
OR.Rule = TERMINO + ToTerm(Constantes.orJava) + TERMINO;
INSTANCIA.Rule = Constantes.nuevo + identificador + "(" + LEXPRESIONES + ")"
| Constantes.nuevo + identificador + "(" + ")";
UNARIO.Rule = MAS_MAS
| MENOS_MENOS;
MAS_MAS.Rule = identificador + ToTerm(Constantes.masmas);
MENOS_MENOS.Rule = identificador + ToTerm(Constantes.menosmenos);
NEGATIVO.Rule = ToTerm("-") + TERMINO;
TERMINO.Rule = ARITMETICA //
| RELACIONAL //
| LOGICA //
| DECIMAL //
| ENTERO //
| ID //
| CADENA //
| BOOLEANO //
| CHAR //
| LLAMADA //
| POSVECTOR //
| UNARIO
| ToTerm("(") + TERMINO + ")" //no es necesario en python
| NEGATIVO
| "{" + LFILAS + "}"
| THIS
| LLAMADAOBJETO;//no existe en python;
// | INSTANCIA;//
tipoLista.Rule = ID
| LLAMADA;
LLAMADAOBJETO.Rule = MakePlusRule(LLAMADAOBJETO, ToTerm("."), tipoLista);
THIS.Rule = ToTerm(Constantes.este) + "." + ID;
LLAMADA.Rule = identificador + ToTerm("(") + LEXPRESIONES + ")"
| identificador + ToTerm("(") + ")";
POSVECTOR.Rule = identificador + LPOSICIONES;
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
LEXPRESIONES.Rule = MakePlusRule(LEXPRESIONES, ToTerm(","), EXPRESION);
// EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), TERMINO);
EXPRESION.Rule = TERMINO;
#endregion
this.RegisterOperators(9, UNARIO, NEGATIVO);
this.RegisterOperators(8, Associativity.Right, "^");
this.RegisterOperators(7, Associativity.Left, "/", "*");
this.RegisterOperators(6, Associativity.Left, "-", "+");
this.RegisterOperators(5, "==", "!=", "<", ">", "<=", ">=");
this.RegisterOperators(4, Associativity.Left, "NOT");
this.RegisterOperators(3, Associativity.Left, "&&");
this.RegisterOperators(2, Associativity.Left, "??");
this.RegisterOperators(1, Associativity.Left, "||");
this.RegisterOperators(10, Associativity.Left, "(");
MarkPunctuation(Constantes.este, ",", "(", ")", ";", "=", "@", "{", "}", "clase", "[", "]", Constantes.nuevo, ".", "si", "sino",
"mientras", "hacer", "para", "x", "repetir", "return", "imprimir", Constantes.masmas, Constantes.menosmenos,
Constantes.menor, Constantes.mayor, Constantes.menorIgual, Constantes.mayorIgual, Constantes.igualIgual, Constantes.distintoA,
Constantes.principal, Constantes.orJava, Constantes.andJava, Constantes.xorJava, Constantes.notJavaPython, sobreescribir, "*", "^", "+", "-", "/", Constantes.retorno);
MarkTransient(L_ELEMENTOS, ELEMENTO, POSICION, SIMB_ARIT, SIMB_LOG, SIMB_REL, DECLAPARA, INSTRUCCION, INSTRUCCIONES,
ARITMETICA, LOGICA, RELACIONAL, UNARIO, INSTRUCCIONES, TERMINO, CUERPO_CLASE, tipoLista);
this.Root = LISTACLASES;
#endregion
#endregion
}
public Gramatica() : 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 sla = ToTerm("~");
var pt = ToTerm("&");
var dosp = ToTerm(":");
var par1 = ToTerm("(");
var par2 = ToTerm(")");
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("return");
var clase = ToTerm("clase");
var constructor = ToTerm("__constructor");
var nuevo = ToTerm("nuevo");
var si = ToTerm("si");
var sino1 = ToTerm("si_no");
var sinosi = ToTerm("si_no_si");
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("hasta");
var loop = ToTerm("loop");
var para = ToTerm("para");
var masmas = ToTerm("++");
var menmen = ToTerm("--");
var punto = ToTerm(".");
var igual = ToTerm("=>");
var superr = ToTerm("super");
var importar = ToTerm("importar");
var self = ToTerm("self");
var elegir = ToTerm("elegir");
var outs = ToTerm("out_string");
var parseint = ToTerm("parseint");
var parsedo = ToTerm("parsedouble");
var intstr = ToTerm("inttostr");
var doustr = ToTerm("doubletostr");
var douint = ToTerm("doubletoint");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
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"),
IMPRIMIR = new NonTerminal("IMPRIMIR"),
PARAMETROS = new NonTerminal("PARAMETROS"),
CFUNCIONES = new NonTerminal("CFUNCIONES"),
DEC = new NonTerminal("DEC"),
DEC2 = new NonTerminal("DEC2"),
DEC4 = new NonTerminal("DEC4"),
DECV = new NonTerminal("DECV"),
DECV1 = new NonTerminal("DECV1"),
DEC3 = new NonTerminal("DEC3"),
PRIV = new NonTerminal("PRIVACIADA"),
IMPRESION = new NonTerminal("IMPRESION"),
IFC = new NonTerminal("IFC"),
SALIR = new NonTerminal("SALIR"),
IF = new NonTerminal("IF"),
FOR = new NonTerminal("FOR"),
ASIGNACION = new NonTerminal("ASIGNACION"),
METODOS = new NonTerminal("METODOS"),
EA = new NonTerminal("EA"),
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"),
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("LOOP"),
MM = new NonTerminal("MM"),
CONTINUAR = new NonTerminal("CONTINUAR"),
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"),
LE = new NonTerminal("LE"),
EC = new NonTerminal("E"),
NATIVAS = new NonTerminal("NATIVAS");
#endregion
#region Gramatica
S.Rule = IMPORT + S1;
S1.Rule = MakePlusRule(S1, CLASE);
IMPORT.Rule = importar + IMPORT2 + Eos | Empty;
IMPORT2.Rule = MakePlusRule(IMPORT2, ToTerm(","), PATH2);
PATH2.Rule = url + dosp + division + division + ToTerm("mynube") + division + id + punto + TIPOA | id + punto + TIPOA | ToTerm("C") + dosp + sla + PATH + punto + TIPOA;
TIPOA.Rule = ToTerm("olc") | ToTerm("tree");
PATH.Rule = MakePlusRule(PATH, sla, id);
CLASE.Rule = clase + id + corch1 + HERENCIA + corch2 + dosp + Eos + CUERPO2;
HERENCIA.Rule = id | Empty;
CUERPO2.Rule = Indent + LCUERPO + Dedent;
LCUERPO.Rule = MakePlusRule(LCUERPO, CUERPO);
CUERPO.Rule = METODOS | FUNCIONES | DECG | CONSTRUCTOR;
PRIV.Rule = protegido | privado | publico | Empty;
PARA.Rule = TIPO2 + id
| TIPO2 + id + corch1 + corch2;
PARAMETROS.Rule = MakePlusRule(PARAMETROS, ToTerm(","), PARA) | Empty;
CONSTRUCTOR.Rule = constructor + corch1 + PARAMETROS + corch2 + dosp + Eos + BLOQUE;
FUNCIONES.Rule = PRIV + funcion + TIPO2 + id + corch1 + PARAMETROS + corch2 + dosp + Eos + BLOQUE;
METODOS.Rule = PRIV + metodo + id + corch1 + PARAMETROS + corch2 + dosp + Eos + BLOQUE;
BLOQUE.Rule = Indent + LSENTENCIAS + Dedent | Empty;
LSENTENCIAS.Rule = MakeStarRule(LSENTENCIAS, SENTENCIA);
SENTENCIA.Rule = DEC | ATRIBUTO + Eos | ASIGNACION | SELF | CICLOS | SALIR | CONTINUAR | NATIVAS + Eos | RET | MM + Eos | IMPRIMIR;
SALIR.Rule = salir + Eos;
CONTINUAR.Rule = continuar + Eos;
LE.Rule = MakePlusRule(LE, ToTerm(","), E) | Empty;
LLAMAR.Rule = id + corch1 + LE + corch2 + Eos;
RET.Rule = retornar + E + Eos;
INSTANCIA.Rule = nuevo + id + corch1 + LE + corch2;
ASIGNACION.Rule = ATRIBUTO + ASG + Eos;
SELF.Rule = self + punto + ATRIBUTO + ASG + Eos;
SUPER.Rule = superr + punto + id;
ATRIBUTO.Rule = MakePlusRule(ATRIBUTO, ToTerm("."), ATRIBUTOS) | SUPER;
ATRIBUTOS.Rule = id | id + corch1 + EA + corch2 | id + LVEC;
EA.Rule = MakePlusRule(EA, ToTerm(","), E) | Empty;
ASG.Rule = igual + E | igual + INSTANCIA;
CICLOS.Rule = IF | ELEGIR | PARAF | MIENTRAS | HACER | REPETIR | LOOP;
IF.Rule = si + corch1 + COND + corch2 + dosp + Eos + BLOQUE + LELIF + ELSE;
LELIF.Rule = MakePlusRule(LELIF, ELIF) | Empty;
ELIF.Rule = sinosi + corch1 + COND + corch2 + dosp + Eos + BLOQUE | Empty;
ELSE.Rule = sino1 + dosp + Eos + BLOQUE | Empty;
ELEGIR.Rule = elegir + caso + corch1 + E + corch2 + dosp + Eos + Indent + CASO + DEF;
CASO2.Rule = E + dosp + Eos + BLOQUE | Empty;
DEF.Rule = defecto + dosp + Eos + BLOQUE + Dedent | Dedent;
CASO.Rule = MakePlusRule(CASO, CASO2);
MIENTRAS.Rule = mientras + corch1 + COND + corch2 + dosp + Eos + BLOQUE;
HACER.Rule = hacer + dosp + Eos + BLOQUE + mientras + corch1 + COND + corch2 + Eos;
REPETIR.Rule = repetir + dosp + Eos + BLOQUE + hasta + corch1 + COND + corch2 + Eos;
PARAF.Rule = para + corch1 + intt + id + igual + E + dosp + COND + dosp + MM + corch2 + dosp + Eos + BLOQUE;
MM.Rule = ATRIBUTO + masmas | ATRIBUTO + menmen;
LOOP.Rule = loop + dosp + Eos + BLOQUE;
IMPRIMIR.Rule = outs + corch1 + E + corch2 + Eos;
NATIVAS.Rule = parseint + corch1 + E + corch2
| parsedo + corch1 + E + corch2
| doustr + corch1 + E + corch2
| douint + corch1 + E + corch2
| intstr + corch1 + E + corch2;
DECG.Rule = PRIV + DEC | DEC;
DEC.Rule = TIPO2 + DEC2 + DEC3 + Eos;
DEC2.Rule = LID | id + LVEC;
DEC3.Rule = igual + DEC4 | Empty;
DEC4.Rule = E | INSTANCIA;
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 + E + OPEREL
| E + E + mas
| E + E + menos
| E + E + por
| E + E + division
| E + E + poten
| E + masmas
| E + menmen
| par1 + E + par2
| VALOR;
COND.Rule = COND + COND + or
| COND + COND + and
| COND + COND + xor
| not + COND
| EC + EC + OPEREL
| VALOR;
EC.Rule = EC + EC + mas
| EC + EC + menos
| EC + EC + por
| EC + EC + division
| EC + EC + poten
| VALOR;
VALOR.Rule = numero
| deci
| str
| truee
| falsee
| ATRIBUTO
| NATIVAS
| self + punto + ATRIBUTO
| cha;
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);
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(":", "__constructor", "=>", "self", ".", "~", "metodo", "funcion", "importar", "clase", "si", "si_no_si", "si_no", "elegir", "caso", "defecto", "mientras", "para", "hacer", "repetir", "hasta", "loop");
#endregion
}
//TerminalSet _skipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution
public ExpressionGrammar()
{
//this.GrammarComments = "NOTE: This grammar is just a demo, and it is a broken demo.\r\n" +
// "Demonstrates token preview technique to help parser resolve conflicts.\r\n";
#region Lexical structure
StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
StringLiteral CharLiteral = TerminalFactory.CreateCSharpChar("CharLiteral");
NumberLiteral Number = TerminalFactory.CreateCSharpNumber("Number");
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//Temporarily, treat preprocessor instructions like comments
CommentTerminal ppInstruction = new CommentTerminal("ppInstruction", "#", "\n");
NonGrammarTerminals.Add(ppInstruction);
//Symbols
Terminal colon = new Terminal(":"); //ToTerm(":", "colon");
Terminal semi = ToTerm(";"); //, "semi");
NonTerminal semi_opt = new NonTerminal("semi?");
semi_opt.Rule = Empty | semi;
Terminal dot = ToTerm("."); //, "dot");
Terminal comma = ToTerm(","); //, "comma");
NonTerminal comma_opt = new NonTerminal("comma_opt", Empty | comma);
NonTerminal commas_opt = new NonTerminal("commas_opt");
commas_opt.Rule = MakeStarRule(commas_opt, null, comma);
Terminal qmark = ToTerm("?");//, "qmark");
NonTerminal qmark_opt = new NonTerminal("qmark_opt", Empty | qmark);
Terminal Lbr = ToTerm("{");
Terminal Rbr = ToTerm("}");
Terminal Lpar = ToTerm("(");
Terminal Rpar = ToTerm(")");
Terminal tgoto = ToTerm("goto");
Terminal yld = ToTerm("yield");
Terminal Lparx = ToTerm("(*");
#endregion
#region NonTerminals
//B.2.1. Basic concepts
var qual_name_with_targs = new NonTerminal("qual_name_with_targs");
var base_type_list = new NonTerminal("base_type_list");
var generic_dimension_specifier = new NonTerminal("generic_dimension_specifier");
var qual_name_segment = new NonTerminal("qual_name_segment");
var qual_name_segments_opt = new NonTerminal("qual_name_segments_opt");
var type_or_void = new NonTerminal("type_or_void", "type or void");
var builtin_type = new NonTerminal("builtin_type", "built-in type");
var type_ref_list = new NonTerminal("type_ref_list");
var identifier_ext = new NonTerminal("identifier_ext");
var identifier_or_builtin = new NonTerminal("identifier_or_builtin");
//B.2.2. Types
var type_ref = new NonTerminal("type_ref");
var type_argument_list = new NonTerminal("type_argument_list");
var typearg_or_gendimspec_list = new NonTerminal("typearg_or_gendimspec_list");
var type_argument_list_opt = new NonTerminal("type_argument_list_opt");
var integral_type = new NonTerminal("integral_type");
//B.2.4. Expressions
var argument = new NonTerminal("argument");
var argument_list = new NonTerminal("argument_list");
var argument_list_opt = new NonTerminal("argument_list_opt");
var expression = new NonTerminal("expression", "expression");
var expression_list = new NonTerminal("expression_list");
var expression_opt = new NonTerminal("expression_opt");
var conditional_expression = new NonTerminal("conditional_expression");
var lambda_expression = new NonTerminal("lambda_expression");
var query_expression = new NonTerminal("query_expression");
var unary_operator = new NonTerminal("unary_operator");
var assignment_operator = new NonTerminal("assignment_operator");
var primary_expression = new NonTerminal("primary_expression");
var unary_expression = new NonTerminal("unary_expression");
var pre_incr_decr_expression = new NonTerminal("pre_incr_decr_expression");
var post_incr_decr_expression = new NonTerminal("post_incr_decr_expression");
var literal = new NonTerminal("literal");
var parenthesized_expression = new NonTerminal("parenthesized_expression");
var member_access = new NonTerminal("member_access");
var member_access_segment = new NonTerminal("member_access_segment");
var member_access_segments_opt = new NonTerminal("member_access_segments_opt");
var array_indexer = new NonTerminal("array_indexer");
var argument_list_par = new NonTerminal("argument_list_par");
var argument_list_par_opt = new NonTerminal("argument_list_par_opt");
var incr_or_decr = new NonTerminal("incr_or_decr");
var incr_or_decr_opt = new NonTerminal("incr_or_decr_opt");
var creation_args = new NonTerminal("creation_args");
var object_creation_expression = new NonTerminal("object_creation_expression");
var anonymous_object_creation_expression = new NonTerminal("anonymous_object_creation_expression");
var typeof_expression = new NonTerminal("typeof_expression");
var checked_expression = new NonTerminal("checked_expression");
var unchecked_expression = new NonTerminal("unchecked_expression");
var default_value_expression = new NonTerminal("default_value_expression");
//var anonymous_method_expression = new NonTerminal("anonymous_method_expression");
var elem_initializer = new NonTerminal("elem_initializer");
var elem_initializer_list = new NonTerminal("elem_initializer_list");
var elem_initializer_list_ext = new NonTerminal("elem_initializer_list_ext");
var initializer_value = new NonTerminal("initializer_value");
var anonymous_object_initializer = new NonTerminal("anonymous_object_initializer");
var member_declarator = new NonTerminal("member_declarator");
var member_declarator_list = new NonTerminal("member_declarator_list");
var unbound_type_name = new NonTerminal("unbound_type_name");
var generic_dimension_specifier_opt = new NonTerminal("generic_dimension_specifier_opt");
var bin_op_expression = new NonTerminal("bin_op_expression");
var typecast_expression = new NonTerminal("typecast_expression");
var bin_op = new NonTerminal("bin_op", "operator symbol");
//B.2.5. Statements
var statement = new NonTerminal("statement", "statement");
var statement_list = new NonTerminal("statement_list");
var statement_list_opt = new NonTerminal("statement_list_opt");
var declaration_statement = new NonTerminal("declaration_statement");
var embedded_statement = new NonTerminal("embedded_statement");
var selection_statement = new NonTerminal("selection_statement");
var iteration_statement = new NonTerminal("iteration_statement");
var block = new NonTerminal("block");
var statement_expression = new NonTerminal("statement_expression");
var statement_expression_list = new NonTerminal("statement_expression_list");
var local_variable_declaration = new NonTerminal("local_variable_declaration");
//var local_constant_declaration = new NonTerminal("local_constant_declaration");
var local_variable_type = new NonTerminal("local_variable_type");
var local_variable_declarator = new NonTerminal("local_variable_declarator");
//var local_variable_declarators = new NonTerminal("local_variable_declarators");
var if_statement = new NonTerminal("if_statement");
var else_clause_opt = new NonTerminal("else_clause_opt");
var while_statement = new NonTerminal("while_statement");
var do_statement = new NonTerminal("do_statement");
var for_statement = new NonTerminal("for_statement");
var for_initializer_opt = new NonTerminal("for_initializer_opt");
var for_condition_opt = new NonTerminal("for_condition_opt");
var for_iterator_opt = new NonTerminal("for_iterator_opt");
var break_statement = new NonTerminal("break_statement");
var continue_statement = new NonTerminal("continue_statement");
var return_statement = new NonTerminal("return_statement");
var identifier_opt = new NonTerminal("identifier_opt");
var resource_acquisition = new NonTerminal("resource_acquisition");
//namespaces, compilation units
var qualified_identifier = new NonTerminal("qualified_identifier");
var qualified_alias_member = new NonTerminal("qualified_alias_member");
//B.2.9. Arrays
var rank_specifier = new NonTerminal("rank_specifier");
var rank_specifiers = new NonTerminal("rank_specifiers");
var rank_specifiers_opt = new NonTerminal("rank_specifiers_opt");
var dim_specifier = new NonTerminal("dim_specifier");
var dim_specifier_opt = new NonTerminal("dim_specifier_opt");
var list_initializer = new NonTerminal("array_initializer");
var list_initializer_opt = new NonTerminal("array_initializer_opt");
var new_opt = new NonTerminal("new_opt");
#endregion
#region operators, punctuation and delimiters
RegisterOperators(1, "||");
RegisterOperators(2, "&&");
RegisterOperators(3, "|");
RegisterOperators(4, "^");
RegisterOperators(5, "&");
RegisterOperators(6, "==", "!=");
RegisterOperators(7, "<", ">", "<=", ">=", "is", "as");
RegisterOperators(8, "<<", ">>");
RegisterOperators(9, "+", "-");
RegisterOperators(10, "*", "/", "%");
RegisterOperators(-3, "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
RegisterOperators(-2, "?");
RegisterOperators(-1, "??");
this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
//this.MarkTransient(/*namespace_member_declaration, member_declaration, type_declaration,*/ statement, embedded_statement, expression,
// literal, bin_op, primary_expression, expression);
//this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
//this.AddTermsReportGroup("typename", "bool", "decimal", "float", "double", "string", "object",
// "sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "char");
//this.AddTermsReportGroup("statement", "if", "switch", "do", "while", "for", "foreach", "continue", "goto", "return", "try", "yield",
// "break", "throw", "unchecked", "using");
//this.AddTermsReportGroup("type declaration", "public", "private", "protected", "static", "internal", "sealed", "abstract", "partial",
// "class", "struct", "delegate", "interface", "enum");
//this.AddTermsReportGroup("member declaration", "virtual", "override", "readonly", "volatile", "extern");
//this.AddTermsReportGroup("constant", Number, StringLiteral, CharLiteral);
//this.AddTermsReportGroup("constant", "true", "false", "null");
//this.AddTermsReportGroup("unary operator", "+", "-", "!", "~");
//this.AddToNoReportGroup(comma, semi);
//this.AddToNoReportGroup("var", "const", "new", "++", "--", "this", "base", "checked", "lock", "typeof", "default",
// "{", "}", "[");
//
#endregion
#region "<" conflict resolution
//var gen_lt = new NonTerminal("gen_lt");
//gen_lt.Rule = CustomActionHere(this.ResolveLessThanConflict) + "<";
#endregion
// RULES
//B.2.1. Basic concepts
//qual_name_with_targs is an alias for namespace-name, namespace-or-type-name, type-name,
generic_dimension_specifier.Rule = /*gen_lt +*/ commas_opt + ">";
qual_name_segments_opt.Rule = MakeStarRule(qual_name_segments_opt, null, qual_name_segment);
identifier_or_builtin.Rule = identifier | builtin_type;
identifier_ext.Rule = identifier_or_builtin | "this" | "base";
qual_name_segment.Rule = dot + identifier
| "::" + identifier
| type_argument_list;
//generic_dimension_specifier.Rule = lt + commas_opt + ">";
generic_dimension_specifier.Rule = /*gen_lt +*/ commas_opt + ">";
qual_name_with_targs.Rule = identifier_or_builtin + qual_name_segments_opt;
type_argument_list.Rule = /*gen_lt +*/ type_ref_list + ">";
type_argument_list_opt.Rule = Empty | type_argument_list;
typearg_or_gendimspec_list.Rule = type_argument_list | generic_dimension_specifier_opt;
//B.2.2. Types
type_or_void.Rule = /*qual_name_with_targs |*/ "void";
builtin_type.Rule = integral_type | "bool" | "decimal" | "float" | "double" | "string" | "object";
type_ref.Rule = type_or_void + qmark_opt + rank_specifiers_opt + typearg_or_gendimspec_list;
type_ref_list.Rule = MakePlusRule(type_ref_list, comma, type_ref);
var comma_list_opt = new NonTerminal("comma_list_opt");
comma_list_opt.Rule = MakeStarRule(comma_list_opt, null, comma);
rank_specifier.Rule = "[" + comma_list_opt + "]";
rank_specifiers.Rule = MakePlusRule(rank_specifiers, null, rank_specifier);
rank_specifiers_opt.Rule = rank_specifiers.Q();
integral_type.Rule = ToTerm("sbyte") | "byte" | "short" | "ushort" | "int" | "uint" | "long" | "ulong" | "char";
//B.2.4. Expressions
argument.Rule = expression | "ref" + identifier | "out" + identifier;
argument_list.Rule = MakePlusRule(argument_list, comma, argument);
argument_list_opt.Rule = Empty | argument_list;
expression.Rule = conditional_expression
| bin_op_expression
| typecast_expression
| primary_expression;
expression_opt.Rule = Empty | expression;
expression_list.Rule = MakePlusRule(expression_list, comma, expression);
unary_operator.Rule = ToTerm("+") | "-" | "!" | "~" | "*";
assignment_operator.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=";
conditional_expression.Rule = expression /*+ PreferShiftHere()*/ + qmark + expression + colon + expression;// + ReduceThis();
bin_op_expression.Rule = expression + bin_op + expression;
typecast_expression.Rule = parenthesized_expression + primary_expression;
primary_expression.Rule =
literal
| unary_expression
| parenthesized_expression
| member_access
| pre_incr_decr_expression
| post_incr_decr_expression
| object_creation_expression
| anonymous_object_creation_expression
| typeof_expression
| checked_expression
| unchecked_expression
| default_value_expression
/*| anonymous_method_expression*/;
unary_expression.Rule = unary_operator + primary_expression;
dim_specifier.Rule = "[" + expression_list + "]";
dim_specifier_opt.Rule = dim_specifier.Q();
literal.Rule = Number | StringLiteral | CharLiteral | "true" | "false" | "null";
parenthesized_expression.Rule = Lpar + expression + Rpar;
pre_incr_decr_expression.Rule = incr_or_decr + member_access;
post_incr_decr_expression.Rule = member_access + incr_or_decr;
//joined invocation_expr and member_access; for member access left the most general variant
member_access.Rule = identifier_ext + member_access_segments_opt;
member_access_segments_opt.Rule = MakeStarRule(member_access_segments_opt, null, member_access_segment);
member_access_segment.Rule = dot + identifier
| array_indexer
| argument_list_par
| type_argument_list;
array_indexer.Rule = "[" + expression_list + "]";
argument_list_par.Rule = Lpar + argument_list_opt + Rpar;
argument_list_par_opt.Rule = Empty | argument_list_par;
list_initializer.Rule = Lbr + elem_initializer_list_ext + Rbr;
list_initializer_opt.Rule = list_initializer.Q();
elem_initializer.Rule = initializer_value | identifier + "=" + initializer_value;
elem_initializer_list.Rule = MakePlusRule(elem_initializer_list, comma, elem_initializer);
elem_initializer_list_ext.Rule = Empty | elem_initializer_list + comma_opt;
initializer_value.Rule = expression | list_initializer;
//delegate, anon-object, object
object_creation_expression.Rule = "new" + qual_name_with_targs + qmark_opt + creation_args + list_initializer_opt;
creation_args.Rule = dim_specifier | rank_specifier | argument_list_par;
anonymous_object_creation_expression.Rule = "new" + anonymous_object_initializer;
anonymous_object_initializer.Rule = Lbr + Rbr | Lbr + member_declarator_list + comma_opt + Rbr;
member_declarator.Rule = expression | identifier + "=" + expression;
member_declarator_list.Rule = MakePlusRule(member_declarator_list, comma, member_declarator);
//typeof
typeof_expression.Rule = "typeof" + Lpar + type_ref + Rpar;
generic_dimension_specifier_opt.Rule = Empty /*| gen_lt*/ + commas_opt + ">";
//checked, unchecked
checked_expression.Rule = "checked" + parenthesized_expression;
unchecked_expression.Rule = "unchecked" + parenthesized_expression;
//default-value
default_value_expression.Rule = "default" + Lpar + type_ref + Rpar;
bin_op.Rule = ToTerm("<")
| "||" | "&&" | "|" | "^" | "&" | "==" | "!=" | ">" | "<=" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%"
| "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>="
| "is" | "as" | "??";
//Queries
query_expression.Rule = "from";
//B.2.5. Statements
statement.Rule = /*labeled_statement |*/ declaration_statement | embedded_statement;
statement.ErrorRule = SyntaxError + semi; //skip all until semicolon
statement_list.Rule = MakePlusRule(statement_list, null, statement);
statement_list_opt.Rule = Empty | statement_list;
declaration_statement.Rule = local_variable_declaration + semi /*| local_constant_declaration*/ + semi;
local_variable_declaration.Rule = local_variable_type /*+ local_variable_declarators*/;
local_variable_type.Rule = member_access | "var"; // | builtin_type; //to fix the conflict, changing to member-access here
local_variable_declarator.Rule = identifier | identifier + "=" + initializer_value;
//local_variable_declarators.Rule = MakePlusRule(local_variable_declarators, comma, local_variable_declarator);
//local_constant_declaration.Rule = "const" + type_ref /*+ constant_declarators*/;
//embedded_statement
embedded_statement.Rule = block | semi /*empty_statement*/ | statement_expression + semi | selection_statement
| iteration_statement /* | jump_statement | try_statement | checked_statement | unchecked_statement
| lock_statement | using_statement | yield_statement*/;
block.Rule = Lbr + statement_list_opt + Rbr;
//selection (if and switch)
selection_statement.Rule = if_statement /*| switch_statement*/;
if_statement.Rule = ToTerm("if") + Lpar + expression + Rpar + embedded_statement + else_clause_opt;
else_clause_opt.Rule = Empty /*| PreferShiftHere()*/ + "else" + embedded_statement;
iteration_statement.Rule = while_statement | do_statement | for_statement /*| foreach_statement*/;
while_statement.Rule = "while" + parenthesized_expression + embedded_statement;
do_statement.Rule = "do" + embedded_statement + "while" + parenthesized_expression + semi;
for_statement.Rule = "for" + Lpar + for_initializer_opt + semi + for_condition_opt + semi + for_iterator_opt + Rpar + embedded_statement;
for_initializer_opt.Rule = Empty | local_variable_declaration | statement_expression_list;
for_condition_opt.Rule = Empty | expression;
for_iterator_opt.Rule = Empty | statement_expression_list;
break_statement.Rule = "break" + semi;
continue_statement.Rule = "continue" + semi;
return_statement.Rule = "return" + expression_opt + semi;
identifier_opt.Rule = Empty | identifier;
resource_acquisition.Rule = local_variable_declaration | expression;
statement_expression.Rule = object_creation_expression
| member_access | member_access + assignment_operator + expression
| pre_incr_decr_expression | post_incr_decr_expression
;
statement_expression_list.Rule = MakePlusRule(statement_expression_list, comma, statement_expression);
incr_or_decr_opt.Rule = Empty | ToTerm("++") | "--";
incr_or_decr.Rule = ToTerm("++") | "--";
//B.2.6. Namespaces
this.Root = block;
qualified_identifier.Rule = MakePlusRule(qualified_identifier, dot, identifier);
base_type_list.Rule = MakePlusRule(base_type_list, comma, qual_name_with_targs);
new_opt.Rule = Empty | "new";
//_skipTokensInPreview.UnionWith(new Terminal[] { dot, identifier, comma, ToTerm("::"), comma, ToTerm("["), ToTerm("]") });
}
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;
}
public Gramatica() : base(caseSensitive: true)
{
#region ER
var numero = TerminalFactory.CreateCSharpNumber("numero");
IdentifierTerminal id = new IdentifierTerminal("id");
StringLiteral cadena = TerminalFactory.CreateCSharpString("cadena");
var caracter = TerminalFactory.CreateCSharpChar("caracter");
#endregion
#region Terminales
/* OPERADORES ARITMETICOS */
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
/* OPERADORES COMPARAR */
var igual = ToTerm("==");
var menor = ToTerm("<");
var mayor = ToTerm(">");
var menor_igual = ToTerm("<=");
var mayor_igual = ToTerm(">=");
var diferente = ToTerm("!=");
/* OPERADORES LOGICOS
* var or = ToTerm("||");
* var and = ToTerm("&&");
* var not = ToTerm("!");
* var nand = ToTerm("!&&");
* var nor = ToTerm("!||");
* var xor = ToTerm("|&"); */
/* TIPOS DE DATOS */
var tipo_cadena = ToTerm("cadena");
var tipo_caracter = ToTerm("caracter");
var tipo_entero = ToTerm("entero");
var tipo_doble = ToTerm("doble");
var tipo_bool = ToTerm("boolean");
/* SENTENCIAS DE CONTROL */
var sentencia_si = ToTerm("si");
var sentencia_sino = ToTerm("sino");
var sentencia_para = ToTerm("para");
var sentencia_mientras = ToTerm("mientras");
var sentencia_hacer = ToTerm("hacer");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
PROGRAMA = new NonTerminal("PROGRAMA"),
SENTENCIA = new NonTerminal("SENTENCIA"),
CONDICION = new NonTerminal("CONDICION"),
INICIO_PARA = new NonTerminal("INICIO PARA"),
FIN_PARA = new NonTerminal("FIN PARA"),
SI = new NonTerminal("SI"),
SINO = new NonTerminal("SINO"),
PARA = new NonTerminal("PARA"),
MIENTRAS = new NonTerminal("MIENTRAS"),
HACER = new NonTerminal("HACER"),
L_ID = new NonTerminal("LST ID"),
ASIGNACION = new NonTerminal("ASIGNACION"),
COMPARACION = new NonTerminal("COMPARACION"),
DECLARACION = new NonTerminal("DECLARAR"),
COMPARAR = new NonTerminal("COMPARAR"),
TIPO = new NonTerminal("TIPO"),
E = new NonTerminal("E");
#endregion
#region Gramatica
S.Rule = PROGRAMA;
PROGRAMA.Rule = MakePlusRule(PROGRAMA, SENTENCIA);
SENTENCIA.Rule = SI | PARA | MIENTRAS | HACER | ASIGNACION;
/*
* si ( CONDICION ) ¿ SENTENCIA ? sino ¿ SENTENCIA ?
* para ( INICIO_PARA ; FIN_PARA; CONDICION) ¿ SENTENCIA ?
* mientras ( CONDICION ) ¿ SENTENCIA ?
* hacer ¿ SENTENCIA ? mientras ( CONDICION ) $
*/
SI.Rule = sentencia_si + ToTerm("(") + COMPARACION + ToTerm(")") +
ToTerm("¿") + SENTENCIA + ToTerm("?") +
sentencia_sino + ToTerm("¿") + SENTENCIA + ToTerm("?");
PARA.Rule = sentencia_para + ToTerm("(") + ASIGNACION + ToTerm(";") + COMPARACION + ToTerm(";") + COMPARACION + ToTerm(")") +
ToTerm("¿") + SENTENCIA + ToTerm("?");
MIENTRAS.Rule = sentencia_mientras + ToTerm("(") + COMPARACION + ToTerm(")") +
ToTerm("¿") + SENTENCIA + ToTerm("?");
HACER.Rule = sentencia_hacer + ToTerm("¿") + SENTENCIA + ToTerm("?") +
sentencia_mientras + ToTerm("(") + COMPARACION + ToTerm(")") + ToTerm("$");
/*
* CONDICION -> COMPARACION
* INICIO_PARA -> ASIGNACION
* FIN_PARA -> COMPARACION
*/
ASIGNACION.Rule = DECLARACION + ToTerm("=") + E + ToTerm("$");
DECLARACION.Rule = TIPO + id;
COMPARACION.Rule = E + COMPARAR + E;
TIPO.Rule = tipo_cadena | tipo_caracter | tipo_doble | tipo_entero | tipo_bool;
COMPARAR.Rule = igual | menor | mayor | menor_igual | mayor_igual | diferente;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + div + E
| ToTerm("(") + E + ToTerm(")")
| numero
| id
| cadena
| caracter;
#endregion
#region Preferencias
this.Root = S;
this.RegisterOperators(20, Associativity.Left, mas, menos);
this.RegisterOperators(30, Associativity.Left, por, div);
this.MarkPunctuation("(", ")", ",", ";", "=", "¿", "?", "$");
this.MarkTransient(S, SENTENCIA, TIPO);
#endregion
}
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 GramaticaTree()
: base(caseSensitive: false)
{
#region expresiones regulares
var doble = new RegexBasedTerminal("doble", "[0-9]+[.][0-9]+");
var entero = new RegexBasedTerminal("entero", "[0-9]+");
var identificador = TerminalFactory.CreateCSharpIdentifier("identificador");
var numero = TerminalFactory.CreateCSharpNumber("numero");
var val_false = Constantes.falso;
var val_true = Constantes.verdadero;
StringLiteral cadena = new StringLiteral("cadena", "\"");
var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter);
CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "{--", "--}");
CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "##", "\n", "\r\n");
NonGrammarTerminals.Add(COMENT_BLOQUE);
NonGrammarTerminals.Add(COMENT_LINEA);
#endregion
#region declaracion de producciones
NonTerminal
VISIBILIDAD = new NonTerminal(Constantes.visibilidad),
TIPO = new NonTerminal(Constantes.tipo),
L_IDS = new NonTerminal(Constantes.listaIds),
DECLRACION = new NonTerminal(Constantes.declaracion),
ATRIBUTO = new NonTerminal(Constantes.atributo),
INSTRUCCION = new NonTerminal(Constantes.instruccion),
INSTRUCCIONES = new NonTerminal(Constantes.instrucciones),
CUERPO = new NonTerminal(Constantes.cuerpo),
FUNCION = new NonTerminal(Constantes.funcion),
FUNCION_SOBRE = new NonTerminal(Constantes.funSobre),
METODO = new NonTerminal(Constantes.metodo),
PARAMETRO = new NonTerminal(Constantes.parametro),
PARAMETROS = new NonTerminal(Constantes.listaParametros),
CONSTRUCTOR = new NonTerminal(Constantes.constructor),
ASIGNACION = new NonTerminal(Constantes.asignacion),
SI = new NonTerminal(Constantes.si),
SI_NO = new NonTerminal(Constantes.sino),
EXTRA = new NonTerminal(Constantes.extraSi),
L_EXTRAS = new NonTerminal(Constantes.lextra),
SALIR = new NonTerminal(Constantes.salir),
CONTINUAR = new NonTerminal(Constantes.constructor),
MIENTRAS = new NonTerminal(Constantes.mientras),
HACER = new NonTerminal(Constantes.hacer),
REPETIR = new NonTerminal(Constantes.repetir),
PARA = new NonTerminal(Constantes.para),
LOOP = new NonTerminal(Constantes.loop),
CASO = new NonTerminal(Constantes.caso),
DEFECTO = new NonTerminal(Constantes.defecto),
LISTACASOS = new NonTerminal(Constantes.lcasos),
ELEGIR = new NonTerminal(Constantes.elegir),
CUERPOELEGIR = new NonTerminal(Constantes.cuerpoElegir),
LLAMADA = new NonTerminal(Constantes.llamada),
INSTANCIA = new NonTerminal(Constantes.instancia),
LEXPRESIONES = new NonTerminal(Constantes.lexpresiones),
CLASE = new NonTerminal(Constantes.clase);
NonTerminal LISTACLASES = new NonTerminal(Constantes.l_clases),
CUERPO_CLASE = new NonTerminal(Constantes.CUERPO_CLASE),
L_ELEMENTOS = new NonTerminal(Constantes.listaElementos),
ELEMENTO = new NonTerminal(Constantes.elementoClase);
NonTerminal
EXPRESION = new NonTerminal(Constantes.expresion),
ID = new NonTerminal(Constantes.id),
ENTERO = new NonTerminal(Constantes.tipoEntero),
DECIMAL = new NonTerminal(Constantes.tipoDecimal),
BOOL = new NonTerminal(Constantes.tipoBool),
CADENA = new NonTerminal(Constantes.tipoCadena),
TERMINO = new NonTerminal(Constantes.termino),
CHAR = new NonTerminal(Constantes.tipoChar),
POSICION = new NonTerminal(Constantes.posicion),
POSICIONES = new NonTerminal(Constantes.lposiciones),
OUT_STRING = new NonTerminal(Constantes.imprimir),
PARSEINT = new NonTerminal(Constantes.parseint),
PARSEDOUBLE = new NonTerminal(Constantes.parsedouble),
INTTOSTR = new NonTerminal(Constantes.inttostr),
DOUBLETOSTR = new NonTerminal(Constantes.doubletostr),
DOUBLETOINT = new NonTerminal(Constantes.doubletoint),
SUPER = new NonTerminal(Constantes.super),
SELF = new NonTerminal(Constantes.self),
DECLAARREGLO = new NonTerminal(Constantes.declaArreglo),
ARITMETICA = new NonTerminal(Constantes.aritmetica),
LOGICA = new NonTerminal(Constantes.logica),
RELACIONAL = new NonTerminal(Constantes.relacional);
NonTerminal SUMA = new NonTerminal(Constantes.suma);
NonTerminal RESTA = new NonTerminal(Constantes.resta);
NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion);
NonTerminal DIVISION = new NonTerminal(Constantes.division);
NonTerminal POTENCIA = new NonTerminal(Constantes.potencia);
NonTerminal MENOR = new NonTerminal(Constantes.menor);
NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual);
NonTerminal MAYOR = new NonTerminal(Constantes.mayor);
NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual);
NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual);
NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA);
NonTerminal XOR = new NonTerminal(Constantes.xorPython);
NonTerminal AND = new NonTerminal(Constantes.andPython);
NonTerminal NOT = new NonTerminal(Constantes.notJavaPython);
NonTerminal OR = new NonTerminal(Constantes.orPython);
NonTerminal UNARIO = new NonTerminal(Constantes.unario),
MAS_MAS = new NonTerminal(Constantes.masmas),
MENOS_MENOS = new NonTerminal(Constantes.menosmenos),
TIPOUNARIO = new NonTerminal("TIPOU"),
NEGATIVO = new NonTerminal(Constantes.negativo);
NonTerminal RETORNO = new NonTerminal(Constantes.retorno);
#endregion
#region reglas semanticas
VISIBILIDAD.Rule = ToTerm(Constantes.publico)
| ToTerm(Constantes.protegido)
| ToTerm(Constantes.privado);
TIPO.Rule = ToTerm(Constantes.tipoBool)
| ToTerm(Constantes.tipoCadena)
| ToTerm(Constantes.tipoChar)
| ToTerm(Constantes.tipoDecimal)
| ToTerm(Constantes.tipoEntero)
| identificador;
L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador);
#region instrucciones clase
ATRIBUTO.Rule = VISIBILIDAD + TIPO + L_IDS
| VISIBILIDAD + TIPO + DECLAARREGLO
| TIPO + L_IDS
| TIPO + DECLAARREGLO;
PARAMETRO.Rule = TIPO + identificador;
PARAMETROS.Rule = MakeStarRule(PARAMETROS, ToTerm(","), PARAMETRO);
FUNCION.Rule = VISIBILIDAD + ToTerm(Constantes.metodo) + identificador + ToTerm("[") + PARAMETROS + "]" + ":" + Eos + CUERPO
| ToTerm(Constantes.metodo) + identificador + ToTerm("[") + PARAMETROS + "]" + ":" + Eos + CUERPO
| VISIBILIDAD + ToTerm(Constantes.funcion) + TIPO + identificador + "[" + PARAMETROS + "]" + ":" + Eos + CUERPO
| ToTerm(Constantes.funcion) + TIPO + identificador + "[" + PARAMETROS + "]" + ":" + Eos + CUERPO;
FUNCION_SOBRE.Rule = ToTerm("/**Sobreescribir**/") + FUNCION;
CONSTRUCTOR.Rule = ToTerm("__constructor") + "[" + PARAMETROS + "]" + ":" + Eos + CUERPO;
LISTACLASES.Rule = MakePlusRule(LISTACLASES, CLASE);
CLASE.Rule = ToTerm(Constantes.clase) + identificador + "[" + identificador + "]" + ":" + Eos + CUERPO_CLASE
| ToTerm(Constantes.clase) + identificador + "[" + "]" + ":" + Eos + CUERPO_CLASE;
CUERPO_CLASE.Rule = Indent + L_ELEMENTOS + Dedent;
L_ELEMENTOS.Rule = MakeStarRule(L_ELEMENTOS, ELEMENTO);
ELEMENTO.Rule = FUNCION
| ATRIBUTO + Eos
| CONSTRUCTOR
| FUNCION_SOBRE;
#endregion
#region instrucciones funcion
CUERPO.Rule = Indent + INSTRUCCIONES + Dedent;
INSTRUCCIONES.Rule = MakeStarRule(INSTRUCCIONES, INSTRUCCION);
INSTRUCCION.Rule = DECLRACION + Eos //
| ASIGNACION + Eos //--
| SI //--
| SALIR + Eos
| CONTINUAR + Eos
| MIENTRAS //--
| PARA //--
| LOOP
| HACER //--
| REPETIR //--
| ELEGIR
| EXPRESION + Eos //--
| RETORNO + Eos; //--
DECLAARREGLO.Rule = identificador + POSICIONES;
DECLRACION.Rule = TIPO + L_IDS
| TIPO + DECLAARREGLO;
ASIGNACION.Rule = EXPRESION + ToTerm("=") + ">" + EXPRESION;
#region estructuras de control
SI.Rule = ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + L_EXTRAS + SI_NO
| ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + L_EXTRAS
| ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + SI_NO;
RETORNO.Rule = ToTerm(Constantes.retorno) + EXPRESION;
SI_NO.Rule = ToTerm(Constantes.sino_python) + ":" + Eos + CUERPO;
EXTRA.Rule = ToTerm(Constantes.sino_si_python) + EXPRESION + ":" + Eos + CUERPO;
L_EXTRAS.Rule = MakeStarRule(L_EXTRAS, EXTRA);
SALIR.Rule = ToTerm(Constantes.salir);
CONTINUAR.Rule = ToTerm(Constantes.continuar);
MIENTRAS.Rule = ToTerm(Constantes.mientras) + EXPRESION + ":" + Eos + CUERPO;
HACER.Rule = ToTerm(Constantes.hacer) + ":" + Eos + CUERPO + Constantes.mientras + EXPRESION + Eos;
REPETIR.Rule = ToTerm(Constantes.repetir) + ":" + Eos + CUERPO + Constantes.hasta + EXPRESION + Eos;
PARA.Rule = ToTerm(Constantes.para) + "[" + ASIGNACION + ":" + EXPRESION + ":" + EXPRESION + "]" + ":" + Eos + CUERPO;
LOOP.Rule = ToTerm(Constantes.loop) + ":" + Eos + CUERPO;
CASO.Rule = EXPRESION + ToTerm(":") + Eos + CUERPO;
DEFECTO.Rule = ToTerm(Constantes.defecto) + ":" + Eos + CUERPO;
LISTACASOS.Rule = MakeStarRule(LISTACASOS, CASO);
CUERPOELEGIR.Rule = Indent + LISTACASOS + DEFECTO + Dedent
| Indent + LISTACASOS + Dedent
| Indent + DEFECTO + Dedent;
ELEGIR.Rule = ToTerm(Constantes.elegir) + EXPRESION + ":" + Eos + CUERPOELEGIR;
#endregion
#endregion
#region expresion
LEXPRESIONES.Rule = MakeStarRule(LEXPRESIONES, ToTerm(","), EXPRESION);
LLAMADA.Rule = identificador + ToTerm("[") + LEXPRESIONES + "]"
| identificador + ToTerm("[") + "]";
INSTANCIA.Rule = ToTerm(Constantes.nuevoPython) + identificador + ToTerm("[") + LEXPRESIONES + "]"
| ToTerm(Constantes.nuevoPython) + identificador + ToTerm("[") + "]";
OUT_STRING.Rule = ToTerm(Constantes.out_string) + "[" + EXPRESION + "]";
PARSEINT.Rule = ToTerm(Constantes.parseint) + "[" + EXPRESION + "]";
PARSEDOUBLE.Rule = ToTerm(Constantes.parsedouble) + "[" + EXPRESION + "]";
INTTOSTR.Rule = ToTerm(Constantes.inttostr) + "[" + EXPRESION + "]";
DOUBLETOSTR.Rule = ToTerm(Constantes.doubletostr) + "[" + EXPRESION + "]";
DOUBLETOINT.Rule = ToTerm(Constantes.doubletoint) + "[" + EXPRESION + "]";
POSICION.Rule = ToTerm("[") + EXPRESION + "]";
POSICIONES.Rule = MakePlusRule(POSICIONES, POSICION);
SUPER.Rule = ToTerm(Constantes.super);
SELF.Rule = ToTerm(Constantes.self);
ID.Rule = identificador;
ENTERO.Rule = entero;
DECIMAL.Rule = doble;
CADENA.Rule = cadena;
CHAR.Rule = caracter;
BOOL.Rule = ToTerm(val_true)
| ToTerm(val_false);
ARITMETICA.Rule = SUMA
| RESTA
| MULTIPLICACION
| DIVISION
| POTENCIA;
RELACIONAL.Rule = MENOR
| MAYOR
| MENORIGUAL
| MAYORIGUAL
| DISTINTOA
| IGUALIGUAL;
LOGICA.Rule = XOR
| OR
| AND
| NOT;
SUMA.Rule = TERMINO + TERMINO + ToTerm(Constantes.suma);
RESTA.Rule = TERMINO + TERMINO + ToTerm(Constantes.resta);
MULTIPLICACION.Rule = TERMINO + TERMINO + ToTerm(Constantes.multiplicacion);
DIVISION.Rule = TERMINO + TERMINO + ToTerm(Constantes.division);
POTENCIA.Rule = TERMINO + TERMINO + ToTerm(Constantes.potencia);
MENOR.Rule = TERMINO + TERMINO + ToTerm(Constantes.menor);
MENORIGUAL.Rule = TERMINO + TERMINO + ToTerm(Constantes.menorIgual);
MAYOR.Rule = TERMINO + TERMINO + ToTerm(Constantes.mayor);
MAYORIGUAL.Rule = TERMINO + TERMINO + ToTerm(Constantes.mayorIgual);
IGUALIGUAL.Rule = TERMINO + TERMINO + ToTerm(Constantes.igualIgual);
DISTINTOA.Rule = TERMINO + TERMINO + ToTerm(Constantes.distintoA);
XOR.Rule = TERMINO + TERMINO + ToTerm(Constantes.xorJava);
AND.Rule = TERMINO + TERMINO + ToTerm(Constantes.andJava);
NOT.Rule = TERMINO + ToTerm(Constantes.notJavaPython);
OR.Rule = TERMINO + TERMINO + ToTerm(Constantes.orJava);
TIPOUNARIO.Rule = CHAR
| DECIMAL
| ENTERO;
UNARIO.Rule = MAS_MAS
| MENOS_MENOS;
MAS_MAS.Rule = TIPOUNARIO + ToTerm(Constantes.masmas);
MENOS_MENOS.Rule = TIPOUNARIO + ToTerm(Constantes.menosmenos);
NEGATIVO.Rule = ToTerm("-") + TERMINO;
TERMINO.Rule = ID
| ENTERO
| DECIMAL
| CADENA
| CHAR
| BOOL
| OUT_STRING
| PARSEINT
| PARSEDOUBLE
| INTTOSTR
| DOUBLETOSTR
| DOUBLETOINT
| INSTANCIA
| LLAMADA
| SUPER
| SELF
| DECLAARREGLO
| ToTerm("(") + ARITMETICA + ")"
| ToTerm("[") + RELACIONAL + "]"
| ToTerm("{") + LOGICA + "}"
| UNARIO
| NEGATIVO;
EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), TERMINO);
#endregion
#endregion
NonTerminal h = new NonTerminal("e");
h.Rule = TERMINO + Eos;
this.Root = LISTACLASES;
MarkPunctuation(Constantes.out_string, Constantes.orPython, Constantes.andPython, Constantes.xorPython, Constantes.notJavaPython, "+", "-", "*", "/", "^", "(", ")", ";", "=", "@", "{", "}", "clase", "[", "]", Constantes.nuevoPython, ".", "si", "sino",
"mientras", "hacer", "para", "x", "repetir", "return", "imprimir", Constantes.masmas, Constantes.menosmenos,
Constantes.menor, Constantes.mayor, Constantes.menorIgual, Constantes.mayorIgual, Constantes.igualIgual, Constantes.distintoA,
Constantes.orPython, Constantes.andPython, Constantes.xorPython, Constantes.notJavaPython, "__constructor", Constantes.metodo, Constantes.funcion,
Constantes.out_string, Constantes.loop,
Constantes.parseint,
Constantes.parsedouble,
Constantes.inttostr,
Constantes.doubletostr,
Constantes.doubletoint, Constantes.super, Constantes.self, "/**Sobreescribir**/", ":", Constantes.sino_python, Constantes.sino_si_python
);
MarkTransient(L_ELEMENTOS, ELEMENTO, POSICION, TIPOUNARIO, INSTRUCCION, INSTRUCCIONES,
ARITMETICA, LOGICA, RELACIONAL, UNARIO, INSTRUCCIONES, TERMINO, CUERPO_CLASE, h);
}
