static Grammer()
{
Number = new TerminalMatch("[0-9]");
Plus = new TerminalChar('+');
Minus = new TerminalChar('-');
Mul = new TerminalChar('*');
Div = new TerminalChar('/');
LeftParen = new TerminalChar('(');
RigtParen = new TerminalChar(')');
Value = Number / (() => LeftParen + Expr + RigtParen);
Product = Value + new ZeroOrMore((Mul / (() => Div)) + Value);
Sum = Product + new ZeroOrMore((Plus / (() => Minus)) + Product);
Expr = Sum;
}
Expresion factor()
{
Expresion x = null;
switch (token.TokenType)
{
case TokenType.IPAREN:
eat(TokenType.IPAREN); x = parseExpression(); eat(TokenType.DPAREN);
return(x);
case TokenType.ENTERO:
x = new Constante(token, Tipo.Int); eat(TokenType.ENTERO); return(x);
case TokenType.FLOTANTE:
x = new Constante(token, Tipo.Float); eat(TokenType.FLOTANTE); return(x);
case TokenType.TRUE:
x = Constante.True; eat(TokenType.TRUE); return(x);
case TokenType.FALSE:
x = Constante.False; eat(TokenType.FALSE); return(x);
case TokenType.ID:
Identifier id = entornoActual.Get(token);
if (id == null)
{
error(token.Lexeme + " no declarado");
}
eat(TokenType.ID);
return(id);
case TokenType.CADENA:
Token tok = token;
eat(TokenType.CADENA);
return(new Expresion(tok, Tipo.String));
default:
error("error de sintaxis");
return(x);
}
}
public object getValor(Ambito ambito)
{
try
{
if (tipo == 1)
{
int maximo = this.expresiones.Count - 1; /// TOMO EL VALOR MAXIMO
Random r = new Random(); /// FUNCION RANDOM
int index = r.Next(0, maximo); /// VALOR DEL INDEX DE LA EXPRESION
Expresion v = this.expresiones.ElementAt(index); /// ELEMENTO
this.valor = v.getValor(ambito);
if (valor is string || valor is int || valor is double)
{
return(valor);
}
else
{
TError error = new TError("Semantico", "La Funcion Random() solo permite retornar valores: Cadena, entero o Decimal | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(new Nulo());
}
else
{
Random r = new Random();
this.valor = r.Next(0, 1);
return(this.valor);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al ejecutar la funcion: Random() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(new Nulo());
}
public object ejecutar(Entorno ent, AST arbol)
{
foreach (NodoAST nodo in Instrucciones)
{
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
object result = ins.ejecutar(ent, arbol);
if (result != null)
{
if (verificarTipo(this.Tipo, result))
{
return(result);
}
else
{
Program.getGUI().appendSalida("EL tipo del retorno no es el declarado en la funcion");
return(null);
}
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
object result = expr.getValorImplicito(ent, arbol);
if (result != null)
{
if (expr.getTipo(ent, arbol) == this.Tipo)
{
return(result);
}
else
{
Program.getGUI().appendSalida("EL tipo del retorno no es el declarado en la funcion");
return(null);
}
}
}
}
return(null);
}
private bool EvaluarExpresionLogica(Expresion nodo)
{
if (nodo is ExpresionBool n)
{
return(Boolean.Parse(n.TokenBool.Value.ToString()));
}
if (nodo is ExpresionBinaria b)
{
var izquierda = EvaluarExpresionLogica(b.Izquierda);
var derecha = EvaluarExpresionLogica(b.Derecha);
if (b.Operador.Tipo == TipoSintaxis.TokenAnd)
{
return(izquierda && derecha);
}
else if (b.Operador.Tipo == TipoSintaxis.TokenOr)
{
return(izquierda || derecha);
}
else if (b.Operador.Tipo == TipoSintaxis.TokenIgualIgual)
{
return(izquierda == derecha);
}
else if (b.Operador.Tipo == TipoSintaxis.TokenNotIgual)
{
return(izquierda != derecha);
}
else
{
throw new Exception($"Operador binario inesperado: {b.Operador.Tipo}");
}
}
if (nodo is ExpresionEnParentesis p)
{
return(EvaluarExpresionLogica(p.Expresion));
}
throw new Exception($"Nodo inesperado {nodo.Tipo}");
}
private static Expresion resolverExpresion(ParseTreeNode raiz, Entorno ent)
{
Expresion retorno = null;
switch (raiz.Term.Name)
{
case "int":
{
retorno = new Expresion(Simbolo.EnumTipo.entero, raiz.Token.ValueString);
}
break;
case "string":
{
retorno = new Expresion(Simbolo.EnumTipo.cadena, raiz.Token.ValueString);
}
break;
case "identificador":
{
Simbolo sim = ent.buscar(raiz.Token.ValueString, raiz.Token.Location.Line + 1, raiz.Token.Location.Column + 1);
if (sim != null)
{
retorno = new Expresion(sim.tipo, sim.valor);
}
else
{
Program.ventanaPrincipal.richConsola.AppendText("La variable no ha sido previamente declarada. Línea: " + (raiz.Token.Location.Line + 1) + " Columna: " + (raiz.Token.Location.Column + 1) + "\n");
}
}
break;
default:
{
retorno = new Expresion(Simbolo.EnumTipo.error, "Error", "No se reconoce el tipo. Línea: " + (raiz.Token.Location.Line + 1) + " Columna: " + (raiz.Token.Location.Column + 1));
}
break;
}
return(retorno);
}
public override object ejecutar(Entorno ent)
{
ejecutado = false;
Expresion valor = Condicion.getValor(ent);
if (valor.tipo.tipo == Tipo.enumTipo.booleano)
{
bool condition = bool.Parse(valor.valor.ToString());
if (condition)
{
Entorno nuevo = new Entorno(ent, ent.global); //
Object retornar = instrucciones.ejecutar(nuevo);
ejecutado = true;
if (retornar != null)
{
if (typeof(Break).IsInstanceOfType(retornar))
{
//si viene un break se detiene el flujo del ciclo
return(retornar);
}
else if (typeof(Continue).IsInstanceOfType(retornar))
{
//aqui solo se debe continuar el ciclo
//continue;
}
else if (typeof(Primitivo).IsInstanceOfType(retornar))
{
//Aqui devolvemos el valor del retorno
return(retornar);
}
}
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede operar tipo de dato: " + valor.tipo.tipo + " como condicion ", linea, columna));
}
return(null);
}
public Expresion EXPRESION_PRIMA(ParseTreeNode actual, Expresion izq, int cant_tabs)
{
/*
* EXPRESION_PRIMA.Rule
* = PLUS + TERMINO + EXPRESION_PRIMA
| MIN + TERMINO + EXPRESION_PRIMA
| ;
*/
if (actual.ChildNodes.Count > 0)
{
var simb = actual.ChildNodes[0].Token.Text;
var derecho = TERMINO(actual.ChildNodes[1], cant_tabs);
var row = actual.ChildNodes[0].Token.Location.Line;
var col = actual.ChildNodes[0].Token.Location.Column;
var aritmetica = new Arithmetic(izq, derecho, simb, row, col, cant_tabs);
return(EXPRESION_PRIMA(actual.ChildNodes[2], aritmetica, cant_tabs));
}
return(izq);
}
private static void ejecutarDeclaracion(ParseTreeNode raiz, Entorno ent)
{
ParseTreeNode[] hijos = raiz.ChildNodes.ToArray();
Simbolo.EnumTipo tipoVariable = obtenerTipo(hijos[0].ToString().Replace(" (Keyword)", ""));
String id = hijos[1].Token.ValueString;
if (hijos.Length > 2)
{
Expresion resultado = resolverExpresion(hijos[3], ent);
if (tipoVariable != resultado.tipo)
{
Program.ventanaPrincipal.richConsola.AppendText("El tipo que se le quiere asignar a la variable '" + id + "' no es permitido. '" + tipoVariable + "' != '" + resultado.tipo + "'. Línea: " + (hijos[3].Token.Location.Line + 1) + " Columna: " + (hijos[3].Token.Location.Column + 1) + "\n");
return;
}
Simbolo nuevo = new Simbolo(tipoVariable, resultado.valor);
ent.insertar(id, nuevo, hijos[1].Token.Location.Line + 1, hijos[1].Token.Location.Column + 1);
}
else
{
ent.insertar(id, new Simbolo(), hijos[1].Token.Location.Line + 1, hijos[1].Token.Location.Column + 1);
}
}
public Expresion EXPLOGICA_PRIMA(ParseTreeNode actual, Expresion izq, int cant_Tabs)
{
/*
* EXPLOGICA_PRIMA.Rule
* = AND + EXPRELACIONAL + EXPLOGICA_PRIMA
| OR + EXPRELACIONAL + EXPLOGICA_PRIMA
| Empty
| ;
*/
if (actual.ChildNodes.Count > 0)
{
var simb = actual.ChildNodes[0].Token.Text.ToLower();
var derecho = EXPRELACIONAL(actual.ChildNodes[1], cant_Tabs);
var row = actual.ChildNodes[0].Token.Location.Line;
var col = actual.ChildNodes[0].Token.Location.Column;
var logica = new Logical(izq, derecho, simb, row, col, cant_Tabs);
return(EXPLOGICA_PRIMA(actual.ChildNodes[2], logica, cant_Tabs));
}
return(izq);
}
public override Resultado ejecutar(Contexto ctx, int nivel)
{
Resultado exec = null;
while (true)
{
Resultado condicion = new Expresion(instruccion.ChildNodes[0].ChildNodes[0]).resolver(ctx);
if (condicion.Tipo != Constantes.T_BOOL)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "La condicion no retorna un valor booleando", Interprete.archivo);
return(FabricarResultado.creaFail());
}
bool cond = condicion.Boleano;
if (!cond)
{
exec = FabricarResultado.creaOk();
break;
}
Cuerpo cuerpo = new Cuerpo(instruccion.ChildNodes[1], true);
exec = cuerpo.ejecutar(ctx, nivel);
if (exec.esContinuar())
{
continue;
}
if (exec.esDetener())
{
exec = FabricarResultado.creaOk();
break;
}
if (exec.esRetorno())
{
break;
}
ctx.limpiarContexto(nivel);
}
ctx.limpiarContexto(nivel);
return(exec);
}
public override Expresion getValor(Entorno ent)
{
//creamos el objeto que vamos a devolver
Expresion l = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
//Creamos una variable de entorno para ir buscando en ellos
//Iniciamos en el entorno actual
Entorno entBuscar = ent;
//recorremos la lista
foreach (Id id in accesos)
{
//buscamos el objeto en el entorno que viene
Expresion sim = id.getValor(entBuscar);
//vamos preguntando si es el ultimo
if (id == accesos.Last.Value)
{
//si es el ultimo no debe ser un objeto
//retornamos el simbolo
l = new Primitivo(sim.tipo, sim.valor);
break;
}
else
{
//Como no es ultimo de la lista de ids
//Tiene que ser de tipo objeto
if (sim.tipo.tipo != Tipo.enumTipo.Objecto)
{
//Si es diferente de objeto no puede ser acceso
/*Error*/
}
//Si es de tipo objeto nos metemos a su entorno y seguimos buscando
//entBuscar = ((Objecto)sim.valor).global;
}
}
return(l);
}
public Expresion masTexto(ParseTreeNode actual)
{
if (actual.ChildNodes.Count == 0)
{
return(null);
}
else
{
//Tiene 3 hijos (, Expresion_Cadena Mas_Texto)
Expresion expresionCadena = this.expresionCadena(actual.ChildNodes[1]);
Expresion masTexto = this.masTexto(actual.ChildNodes[2]);
if (expresionCadena != null && masTexto != null)
{
return(new Aritmetica(expresionCadena, masTexto, '+'));
}
else
{
return(expresionCadena);
}
}
}
public Expresion TERMINO_PRIMA(ParseTreeNode actual, Expresion izq, int cant_tabs)
{
/*
* TERMINO_PRIMA.Rule
* = POR + FACTOR + TERMINO_PRIMA
| DIVI + FACTOR + TERMINO_PRIMA
| MODULE + FACTOR + TERMINO_PRIMA
| Empty
| ;
*/
if (actual.ChildNodes.Count > 0)
{
var simb = actual.ChildNodes[0].Token.Text;
var derecho = FACTOR(actual.ChildNodes[1], cant_tabs);
var row = actual.ChildNodes[0].Token.Location.Line;
var col = actual.ChildNodes[0].Token.Location.Column;
var aritmetica = new Arithmetic(izq, derecho, simb, row, col, cant_tabs);
return(TERMINO_PRIMA(actual.ChildNodes[2], aritmetica, cant_tabs));
}
return(izq);
}
private List <Object> linealizadaValores(List <Object> linealizada, Ambito am)
{
List <Object> valores = new List <object>();
foreach (Object o in linealizada)
{
if (o is Expresion)
{
Expresion aux = (Expresion)o;
Object val = aux.getValor(am);
String tipo = aux.getTipo(am).ToLower();
if (tipo != this.tipo.ToLower())
{
return(null);
}
else
{
valores.Add(val);
}
}
}
return(valores);
}
Expresion rel()
{
Expresion x = expr();
Token tok;
switch (token.TokenType)
{
case TokenType.MENOR:
tok = token; mover(); return(new Relacion(tok, x, expr()));
case TokenType.MENORIGUAL:
tok = token; mover(); return(new Relacion(tok, x, expr()));
case TokenType.MAYORIGUAL:
tok = token; mover(); return(new Relacion(tok, x, expr()));
case TokenType.MAYOR:
tok = token; mover(); return(new Relacion(tok, x, expr()));
default:
return(x);
}
}
private Comando ParsearComandoPrint()
{
lexer.Aceptar();
Expresion exp = ParsearExpresion();
string alias = null;
if (lexer.tokenActual.Type == TokenType.id)
{
alias = lexer.tokenActual.Valor;
lexer.Aceptar(TokenType.id);
}
else if (lexer.tokenActual.Type == TokenType.hilera)
{
alias = lexer.tokenActual.Valor;
lexer.Aceptar(TokenType.hilera);
}
else
{
throw new LanguageException($"Se esperaba el alias para la expresion '{exp.ToString()}' del Print");
}
lexer.Aceptar(TokenType.puntoComa);
return(new ComandoPrint(salida, exp, alias));
}
private static void ejecutarImprimir(ParseTreeNode raiz, Entorno ent)
{
Expresion resultado = resolverExpresion(raiz, ent);
if (resultado != null)
{
if (resultado.tipo != Simbolo.EnumTipo.error)
{
if (resultado.valor != null)
{
Program.ventanaPrincipal.richConsola.AppendText(resultado.valor.ToString() + "\n");
}
else
{
Program.ventanaPrincipal.richConsola.AppendText("La variable no ha sido previamente inicializada. Línea: " + (raiz.Token.Location.Line + 1) + " Columna: " + (raiz.Token.Location.Column + 1) + "\n");
}
}
else
{
Program.ventanaPrincipal.richConsola.AppendText(resultado.error + "\n");
}
}
}
public Resultado ejecutar(Contexto ctx, int nivel)
{
if (instruccion.ChildNodes.Count > 0)
{
string cad = instruccion.ChildNodes[0].Token.Text;
// string Cadena = cad.Substring(1, cad.Length - 2);
if (instruccion.ChildNodes.Count == 1)
{
Interprete.ConcatenarSalida(cad);
Interprete.ConcatenarSalida("\r\n");
return(FabricarResultado.creaOk());
}
ParseTreeNode Param = instruccion.ChildNodes[1];
List <String> valores = new List <String>();
foreach (var parametro in Param.ChildNodes)
{
Resultado res = new Expresion(parametro.ChildNodes[0]).resolver(ctx);
String tempval = "";
if (res.Tipo == Constantes.T_ERROR)
{
}
tempval = res.Valor;
valores.Add(tempval);
}
String[] parametrosMostrar = valores.ToArray();
String resultado = String.Format(cad, parametrosMostrar);
Interprete.ConcatenarSalida(resultado);
Interprete.ConcatenarSalida("\r\n");
}
return(FabricarResultado.creaOk());
}
public object getValor(Entorno.Entorno ent)
{
if (contenido == null)
{
return(new Lista(tipo));
}
else
{
Expresion primero = contenido.First();
Tipo tipo_primero = primero.getTipo(ent);
bool todos_igual = true;
foreach (Expresion exp in contenido)
{
Tipo exp_tipo = exp.getTipo(ent);
if (!tipo_primero.tipo.Equals(exp_tipo.tipo))
{
todos_igual = false;
}
}
if (todos_igual)
{
valores = new List <object>();
foreach (Expresion exp in contenido)
{
Object exp_valor = exp.getValor(ent);
valores.Add(exp_valor);
}
return(new Lista(valores, tipo_primero));
}
else
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error de tipos en la lista no todos son del mismo tipo ", this.fila, this.columna));
}
}
return(null);
}
private Comando ParsearComandoIf()
{
Comando resultado;
lexer.Aceptar();
lexer.Aceptar(TokenType.lParentesis);
Expresion exp = ParseExpresionLogica();
lexer.Aceptar(TokenType.rParentesis);
Comando comandosDelIF = ParsearComando();
if (lexer.tokenActual.Type == TokenType.ELSE)
{
lexer.Aceptar();
Comando comandosDelElse = ParsearComando();
resultado = new ComandoIf(exp, comandosDelIF, comandosDelElse);
}
else
{
resultado = new ComandoIf(exp, comandosDelIF);
}
return(resultado);
}
public Instruccion nuevaAsignacion(ParseTreeNode actual)
{
switch (actual.ChildNodes.Count)
{
case 7:
return(new AsignacionObjeto(actual.ChildNodes[0].Token.Text, actual.ChildNodes[2].Token.Text, expresionCadena(actual.ChildNodes[5])));
default:
switch (actual.ChildNodes[0].Term.ToString())
{
case "ID":
return(new NuevaAsignacion(actual.ChildNodes[0].Token.Text, expresionCadena(actual.ChildNodes[3])));
case "Valor_Arreglo":
Expresion expresion = expresionCadena(actual.ChildNodes[3]);
actual = actual.ChildNodes[0];
LinkedList <Expresion> indices = new LinkedList <Expresion>();
return(new AsignacionArreglo(actual.ChildNodes[0].Token.Text, getIndicesArray(actual.ChildNodes[2], indices), expresion));
default:
return(null);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("DEMO Expresion!");
var x = new Variable("x", 100);
Expresion e = x + 5 * 20;
Console.WriteLine();
Console.WriteLine($"Evaluar | {e} => {e.Evaluar()}");
Console.WriteLine();
Console.WriteLine(e.NPI());
Console.WriteLine();
e.Mostrar();
Console.ReadLine();
return;
Console.WriteLine();
Expresion contador = new Asignar(x, x + 1);
Console.WriteLine("> CONTADOR");
contador.Mostrar();
Console.WriteLine();
Console.WriteLine(contador.NPI());
Console.WriteLine($"Contador | {contador} => {contador.Evaluar()}");
Console.WriteLine($"Contador | {contador} => {contador.Evaluar()}");
Console.WriteLine($"Contador | {contador} => {contador.Evaluar()}");
Console.WriteLine();
var repetir = new Repeticion(new Menor(x, 20), contador);
Console.WriteLine("> REPETICION");
Console.WriteLine(repetir.NPI());
repetir.Mostrar();
Console.WriteLine($"Repeticion | {repetir} => {repetir.Evaluar()}");
Console.ReadLine();
}
public Logica(Expresion op1, Expresion op2, Operador op, int linea, int columna) : base(op1, op2, op, linea, columna)
{
}
public Logica(Expresion op1, int linea, int columna) : base(op1, null, Operador.NOT, linea, columna)
{
}
public Unario(Expresion op1, Operador op, int linea, int columna) : base(op1, null, op, linea, columna)
{
}
public override object Ejecutar(Entorno e, bool funcion, bool ciclo, bool sw, bool tc, LinkedList <Salida> log, LinkedList <Error> errores)
{
BD actual = e.Master.Actual;
if (actual != null)
{
if (e.Master.UsuarioActual != null)
{
if (e.Master.UsuarioActual.GetPermiso(actual.Id))
{
Simbolo sim = actual.GetTabla(Id);
if (sim != null)
{
Tabla tabla = (Tabla)sim.Valor;
if (Columnas != null)
{
if (Columnas.Count() == Valores.Count())
{
Entorno datos = tabla.GetNuevaFila();
LinkedList <Simbolo> primary = new LinkedList <Simbolo>();
for (int i = 0; i < Columnas.Count(); i++)
{
Expresion valor = Valores.ElementAt(i);
object valValor = valor.GetValor(e, log, errores);
if (valValor != null)
{
if (valValor is Throw)
{
return(valValor);
}
string col = Columnas.ElementAt(i);
Simbolo dato = datos.GetCualquiera(col);
if (dato != null)
{
if (dato.Tipo.IsCounter())
{
return(new Throw("CounterTypeException", Linea, Columna));
//dato.Valor = tabla.Contador;
//continue;
}
if (dato.Tipo.Equals(valor.Tipo))
{
dato.Valor = valValor;
if (dato.Rol == Rol.PRIMARY)
{
if (valValor is Null)
{
errores.AddLast(new Error("Semántico", "Una llave primaria no puede ser Null.", Linea, Columna));
return(null);
}
}
}
else
{
Casteo cast = new Casteo(dato.Tipo, new Literal(valor.Tipo, valValor, 0, 0), 0, 0)
{
Mostrar = false
};
valValor = cast.GetValor(e, log, errores);
if (valValor != null)
{
if (valValor is Throw)
{
return(valValor);
}
dato.Valor = valValor;
continue;
}
return(new Throw("ValuesException", Linea, Columna));
//errores.AddLast(new Error("Semántico", "El tipo de la expresión no corresponde al tipo en la columna: " + sim.Id + ".", Linea, Columna));
//return null;
}
}
else
{
errores.AddLast(new Error("Semántico", "No hay un campo con el id: " + col + " en la Tabla.", Linea, Columna));
return(null);
}
}
else
{
return(null);
}
}
foreach (Simbolo col in datos.Simbolos)
{
if (col.Tipo.IsCounter())
{
col.Valor = tabla.Contador;
}
if (col.Rol == Rol.PRIMARY)
{
if (col.Valor is Null)
{
errores.AddLast(new Error("Semántico", "Una llave primaria no puede ser Null.", Linea, Columna));
return(null);
}
primary.AddLast(col);
}
}
if (!tabla.Insertar(datos, primary))
{
errores.AddLast(new Error("Semántico", "No se pueden insertar valores con la misma llave primaria.", Linea, Columna));
}
else
{
tabla.Contador++;
Correcto = true;
}
return(null);
}
else
{
errores.AddLast(new Error("Semántico", "La lista de campos no corresponde a la lista de valores.", Linea, Columna));
}
}
else
{
if (tabla.Cabecera.Simbolos.Count() == Valores.Count())
{
Entorno datos = new Entorno(null, new LinkedList <Simbolo>());
LinkedList <Simbolo> primary = new LinkedList <Simbolo>();
for (int i = 0; i < Valores.Count(); i++)
{
Expresion valor = Valores.ElementAt(i);
object valValor = valor.GetValor(e, log, errores);
if (valValor != null)
{
if (valValor is Throw)
{
return(valValor);
}
Simbolo col = tabla.Cabecera.Simbolos.ElementAt(i);
if (col.Tipo.IsCounter())
{
return(new Throw("CounterTypeException", Linea, Columna));
//errores.AddLast(new Error("Semántico", "No se puede insertar un valor en una columna tipo Counter.", Linea, Columna));
//return null;
}
if (!col.Tipo.Equals(valor.Tipo))
{
Casteo cast = new Casteo(col.Tipo, new Literal(valor.Tipo, valValor, 0, 0), 0, 0)
{
Mostrar = false
};
valValor = cast.GetValor(e, log, errores);
if (valValor == null)
{
if (valValor is Throw)
{
return(valValor);
}
return(new Throw("ValuesException", Linea, Columna));
//errores.AddLast(new Error("Semántico", "El tipo de la expresión no corresponde al tipo en la columna: " + col.Id + ".", Linea, Columna));
//return null;
}
}
Simbolo dato = new Simbolo(col.Tipo, col.Rol, col.Id, valValor);
if (col.Rol == Rol.PRIMARY)
{
if (valValor is Null)
{
errores.AddLast(new Error("Semántico", "Una llave primaria no puede ser Null.", Linea, Columna));
return(null);
}
primary.AddLast(dato);
}
datos.Add(dato);
}
else
{
return(null);
}
}
if (!tabla.Insertar(datos, primary))
{
errores.AddLast(new Error("Semántico", "No se pueden insertar valores con la misma llave primaria.", Linea, Columna));
}
else
{
Correcto = true;
}
return(null);
}
else
{
return(new Throw("ValuesException", Linea, Columna));
}
//errores.AddLast(new Error("Semántico", "Los valores no corresponden a las columnas en la Tabla.", Linea, Columna));
}
}
else
{
return(new Throw("TableDontExists", Linea, Columna));
}
//errores.AddLast(new Error("Semántico", "No existe una Tabla con el id: " + Id + " en la base de datos.", Linea, Columna));
}
else
{
errores.AddLast(new Error("Semántico", "El Usuario no tiene permisos sobre: " + actual.Id + ".", Linea, Columna));
}
}
else
{
errores.AddLast(new Error("Semántico", "No hay un Usuario logeado.", Linea, Columna));
}
}
else
{
return(new Throw("UseBDException", Linea, Columna));
}
//errores.AddLast(new Error("Semántico", "No se ha seleccionado una base de datos, no se pudo Insertar.", Linea, Columna));
return(null);
}
public Return(Expresion exp, int linea, int columna)
{
this.valorRetorno = exp;
this.linea = linea;
this.columna = columna;
}
/*
* CONSTRUCTOR DE LA CLASE
* param {expresion} expresion a mostrar
*/
public Log(Expresion expresion)
{
this.expresion = expresion;
}
public FuncionAudio(Expresion ruta, Expresion condicion, String clase, int linea, int col) : base(linea, col, clase)
{
this.ruta = ruta;
this.condicion = condicion;
}
public OrderedChoice(Expresion e1, Factory e2Factory)
{
this.e1 = e1;
this.e2Factory = e2Factory;
}
public Switch(Expresion expr, LinkedList <Case> cases, int linea, int columna) : base(linea, columna)
{
Expr = expr;
Cases = cases;
}
public ZeroOrMore(Expresion e)
{
this.e = e;
}
public Sequence(Expresion e1, Expresion e2)
{
this.e1 = e1;
this.e2 = e2;
}
