public void setValor(string propiedad, Simbolo valor)
{
if (!variables.ContainsKey(propiedad))
{
throw new ErrorPascal(0, 0, "El objeto \"" + nombre + "\" no contiene la propiedad " + propiedad, "", reporte);
}
if (tipoVariable[propiedad].tipo != valor.tipo.tipo && tipoVariable[propiedad].tipoAuxiliar != valor.tipo.tipoAuxiliar)
{
throw new ErrorPascal(0, 0, "No se puede asignar el valor \"" + valor.valor + "\" a \"" + nombre + "." + propiedad + "\" porque los datos no coinciden", "semantico", reporte);
}
variables[propiedad] = valor;
}
public Tipos GetTipo(Entorno e)
{
Simbolo encontrado = e.Obtener(id);
if (encontrado is MapCollection map)
{
return(map.tipoValor);
}
if (encontrado is ListCollection list)
{
return(list.tipoLista);
}
return(Tipos.NULL);
}
public static void Adicionar(Simbolo simbolo)
{
Automato.Instance.automato[simbolo][0].Transicoes.Add(new Transicao()
{
ElementoTransicao = (char)Simbolo.PALAVRA_VAZIA,
ProximoEstado = new List <Grafo>
{
new Grafo
{
EstadoAtual = (char)Simbolo.PALAVRA_VAZIA
}
}
});
}
public object Ejecutar(Ambito ambito)
{
try
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.id.ToLower());
if (s != null)
{
if (s is Variable && (s.Tipo.ToLower().Equals("entero") || s.Tipo.ToLower().Equals("decimal")))
{
Variable v = (Variable)s;
if (v.valor is int)
{
int aux = (int)v.valor;
v.valor = aux - 1;
}
else if (v.valor is Double)
{
double aux = (double)v.valor;
v.valor = aux - 1;
}
else
{
TError error = new TError("Semantico", "El Simbolo: \"" + this.id.ToLower() + "\" Posiblemente no ha sido inicializada! | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "El Simbolo: \"" + this.id.ToLower() + "\" No hace referencia a una variable que se pueda aplicar el decremento: \"" + s.Tipo + "\"| Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "El Simbolo: \"" + this.id.ToLower() + "\" al cual se hace referencia no existe en este contexto | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al intentar ejecutar un decremento | 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)
{
Entorno tablaLocal = new Entorno(ent);
if (valoresParametros == null)
{
valoresParametros = new LinkedList <Expresion>();
}
//obtengo antes los valores de los parametros en su respectivo entorno.
LinkedList <Expresion> resultados = new LinkedList <Expresion>();
foreach (Expresion e in valoresParametros)
{
resultados.AddLast(new Primitivo(e.getValorImplicito(ent, arbol), 0, 0));
}
if (parametros.Count == resultados.Count)
{
//declaracion de variables
for (int i = 0; i < parametros.Count; i++)
{
Simbolo p = parametros.ElementAt(i);
Expresion exp = resultados.ElementAt(i);
LinkedList <Simbolo> simbolos = new LinkedList <Simbolo>();
simbolos.AddLast(p);
Declaracion declaracion = new Declaracion(p.tipo, simbolos, exp, exp.linea, exp.columna);
declaracion.ejecutar(tablaLocal, arbol);
}
foreach (Instruccion e in instrucciones)
{
Object resultado = e.ejecutar(tablaLocal, arbol);
if (resultado != null)
{
return(resultado);
}
}
}
else
{
Form1.Consola.AppendText("Error semantico en ejecutar " + this.id + " en linea " + linea + " y columna " + columna + ", no se tienen los mismos parametros!!\n");
return(null);
}
return(null);
}
/// <summary>
/// Maneja la forma de sumar entre un char y el resto de tipos primitivos
/// </summary>
/// <param name="intVar"></param>
/// <param name="sym"></param>
/// <returns></returns>
private static Simbolo RelChar(char charVar, Simbolo sym)
{
Simbolo retorno = new Simbolo();
switch (sym.TipoDato)
{
case Tipo.INT:
case Tipo.DOUBLE:
case Tipo.CHAR:
var auxTemp = (sym.TipoDato == Tipo.INT ? (int)sym.Dato : sym.TipoDato == Tipo.CHAR ? (char)sym.Dato : (double)sym.Dato);
switch (tipo)
{
case TipoRel.IGUAL:
retorno.Dato = charVar == auxTemp;
break;
case TipoRel.DIFERENTE:
retorno.Dato = charVar != auxTemp;
break;
case TipoRel.MAYOR:
retorno.Dato = charVar > auxTemp;
break;
case TipoRel.MENOR:
retorno.Dato = charVar < auxTemp;
break;
case TipoRel.MENOR_IGUAL:
retorno.Dato = charVar <= auxTemp;
break;
case TipoRel.MAYOR_IGUAL:
retorno.Dato = charVar >= auxTemp;
break;
}
retorno.TipoDato = Tipo.BOOLEAN;
break;
case Tipo.STRING:
Console.WriteLine("Solo se aceptan compraciones entre strings");
break;
case Tipo.BOOLEAN:
Console.WriteLine("No se puede comparar un char y un booleano");
break;
}
return(retorno);
}
/// <summary>
/// Devuelve un simbolo
/// </summary>
/// <param name="raiz"></param>
/// <param name="operClass"></param>
/// <returns></returns>
public static Simbolo Interpretar(ParseTreeNode raiz, Operar operClass)
{
Simbolo symizq = operClass.Interpretar(raiz.ChildNodes[0]);
Simbolo symder = operClass.Interpretar(raiz.ChildNodes[2]);
//---IZQ
if (symizq.TipoDato == Tipo.INT)
{
return(SumarInt((int)symizq.Dato, symder));
}
if (symizq.TipoDato == Tipo.STRING)
{
return(SumarString(symizq.Dato.ToString(), symder));
}
if (symizq.TipoDato == Tipo.DOUBLE)
{
return(SumarDouble((double)symizq.Dato, symder));
}
if (symizq.TipoDato == Tipo.CHAR)
{
return(SumarChar((char)symizq.Dato, symder));
}
if (symizq.TipoDato == Tipo.BOOLEAN)
{
return(SumarBool((bool)symizq.Dato, symder));
}
if (symder.TipoDato == Tipo.INT)
{
return(SumarInt((int)symder.Dato, symizq));
}
//---DER
if (symder.TipoDato == Tipo.STRING)
{
return(SumarString(symder.Dato.ToString(), symizq));
}
if (symder.TipoDato == Tipo.DOUBLE)
{
return(SumarDouble((double)symder.Dato, symizq));
}
if (symder.TipoDato == Tipo.CHAR)
{
return(SumarChar((char)symder.Dato, symizq));
}
if (symder.TipoDato == Tipo.BOOLEAN)
{
return(SumarBool((bool)symder.Dato, symizq));
}
return(new Simbolo());
}
public override Tipo GetTipo(Entorno e)
{
Simbolo sim = e.GetSimbolo(Id);
if (sim != null)
{
valor = sim.Valor;
return(sim.Tipo);
}
else
{
Console.WriteLine("Error, No existe una variable con el id " + Id + " Línea: " + Linea);
}
return(Tipo.NULL);
}
public override Simbolo evaluar(Entorno entorno, Reporte reporte)
{
Simbolo contenido = expresion.evaluar(entorno, reporte);
if (contenido.tipo.tipo != Tipos.BOOLEAN)
{
throw new util.ErrorPascal(0, 0, "No se puede operar un Not en una expresion no booleana", "semantico", reporte);
}
if ((bool)(contenido.valor) == true)
{
return(new Simbolo(false, contenido.tipo, contenido.id));
}
return(new Simbolo(true, contenido.tipo, contenido.id));
}
public FAsignacion(String tipo, Ambito ambito, FNodoExpresion valor, Object nombre)
{
this.Tipo = tipo;
this.Ambito = ambito;
this.Valor = valor;
if (this.Tipo.Equals(Constante.TAumento) || this.Tipo.Equals(Constante.TDecremento))
{
this.Operacion = (FNodoExpresion)nombre;
}
else
{
this.Nombre = (FLlamadaObjeto)nombre;
}
this.Padre = null;
}
public Tipo getTipo(Entorno.Entorno ent)
{
Simbolo sm = ent.get(variable);
Object valor = sm.valor;
if (valor is int)
{
return(new Tipo("int"));
}
else if (valor is double)
{
return(new Tipo("double"));
}
return(new Tipo("null"));
}
void CambiarEstado(Simbolo simbolo)
{
ANodo temp = actual.AplicarTransicion(simbolo);
if (actual != temp)
{
actual = temp;
// deshacernos del behaviour actual
Destroy(comportamiento);
// reasignar referencia
comportamiento = gameObject.AddComponent(actual.Comportamiento) as MonoBehaviour;
}
}
public Simbolo retornar_asignacion(Entorno entorno)
{
Simbolo simbolo = null;
try
{
simbolo = asignar.retornar_simbolo(entorno);
}catch (Exception e)
{
Console.WriteLine(e);
throw new Exception(e.ToString());
}
return(simbolo);
}
public Simbolo obtenerSiguenteSimbolo()
{
if (caracterActual < EntradaInicial.Length)
{
if (EntradaInicial[caracterActual] == '\n') //cuando el caracter es enter
{
++contadorFilas; //aumenta las filas
contadorColumnas = 1; //reset las columnas
}
var retornarSimbolo = new Simbolo(EntradaInicial[caracterActual++], contadorFilas, contadorColumnas++);
}
return(new Simbolo('\0', contadorFilas, contadorColumnas));
}
private String GenerarArbolRetorno(ref int pos, Simbolo simbolo)
{
int actual = pos;
pos++;
String cadena = "";
if (simbolo.Objeto != null)
{
cadena = "\t\tnodo" + pos.ToString() + "[label=\"Expresion\"]\n";
cadena = cadena + "\t\tnodo" + actual.ToString() + "->nodo" + pos.ToString() + "\n";
}
return(cadena);
}
public object getValorImplicito(Entorno ent, AST arbol)
{
Simbolo simbolo = ent.get(idObjeto);
if (simbolo.Tipo == Tipos.OBJETO)
{
//Se verifica que sea objeto, seguido de esto se devuelve el valor de dicho atributo.
return(((Objeto)simbolo).getAtributos().get(idAtributo).Valor);
}
else
{
Program.getGUI().appendSalida("No es un objeto");
}
return(null);
}
/// <summary>
/// Devuelve un simbolo
/// </summary>
/// <param name="raiz"></param>
/// <param name="operClass"></param>
/// <returns></returns>
public static Simbolo Interpretar(ParseTreeNode raiz, Operar operClass)
{
Simbolo symizq = operClass.Interpretar(raiz.ChildNodes[0]);
Simbolo symder = operClass.Interpretar(raiz.ChildNodes[2]);
//STRING
if (symizq.TipoDato == Tipo.STRING || symder.TipoDato == Tipo.STRING)
{
Console.WriteLine("No se pueden multiplicar cadenas");
}
//ENTERO
if (symizq.TipoDato == Tipo.INT)
{
return(ProductoInt((int)symizq.Dato, symder));
}
if (symder.TipoDato == Tipo.INT)
{
return(ProductoInt((int)symder.Dato, symizq));
}
//DOUBLE
if (symizq.TipoDato == Tipo.DOUBLE)
{
return(ProductoDouble((double)symizq.Dato, symder));
}
if (symder.TipoDato == Tipo.DOUBLE)
{
return(ProductoDouble((double)symder.Dato, symizq));
}
//CHAR
if (symizq.TipoDato == Tipo.CHAR)
{
return(ProductoChar((char)symizq.Dato, symder));
}
if (symder.TipoDato == Tipo.CHAR)
{
return(ProductoChar((char)symder.Dato, symizq));
}
//BOOLEANO
if (symizq.TipoDato == Tipo.BOOLEAN)
{
return(ProductoBool((bool)symizq.Dato, symder));
}
if (symder.TipoDato == Tipo.BOOLEAN)
{
return(ProductoBool((bool)symder.Dato, symizq));
}
return(new Simbolo());
}
public override object ejecutar(Entorno entorno, Reporte reporte)
{
Funcion funcion = entorno.existeFuncion(nombre);
if (funcion == null)
{
goto esProcedimiento;
}
//Comprobar variables
if (funcion.varTipos.Count != valores.Count)
{
throw new util.ErrorPascal(0, 0, "Numero de entradas incorrectas para la funcion \"" + nombre + "\"", "semantico", reporte);
}
//Asignar los valores
funcion.valoresParametros = valores;
Simbolo retorno = (Simbolo)funcion.ejecutar(entorno, reporte); //Aca
if (retorno == null)
{
throw new util.ErrorPascal(0, 0, "La funcion \"" + this.nombre + "\" no devolvio ningun valor", "semantico", reporte);
}
return(retorno);
esProcedimiento:
Procedimiento procedimiento = entorno.existeProcedimiento(nombre);
if (procedimiento == null)
{
throw new util.ErrorPascal(0, 0, "La funcion/procedimiento \"" + nombre + "\" no existe", "semantico", reporte);
}
//Comprobar variables
if (procedimiento.varTipos.Count != valores.Count)
{
throw new util.ErrorPascal(0, 0, "Numero de entradas incorrectas para la funcion \"" + nombre + "\"", "semantico", reporte);
}
//Asignar los valores
procedimiento.valoresParametros = valores;
procedimiento.ejecutar(entorno, reporte); //Aca
return(null);
}
public void EjecutarRetorno(Simbolo retorno)
{
if (retorno.Objeto != null)
{
FExpresion aux = (FExpresion)retorno.Objeto;
NodoExpresion val = aux.ResolverExpresion(retorno.Ambito.Incerteza, retorno.Ambito.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
TablaVariables.Tabla.Add(new Variables(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, val, null, retorno.Fila, retorno.Columna));
}
}
else
{
TablaVariables.Tabla.Add(new Variables(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, null, null, retorno.Fila, retorno.Columna));
}
}
public override Simbolo evaluar(Entorno entorno, Reporte reporte)
{
Simbolo variable = entorno.existeLaVariable(id);
if (variable == null)
{
return(entorno.obtenerConstane(id));
}
return(entorno.obtenerVariable(id));
/*if (entorno.existeVariable(id))
* return entorno.obtenerVariable(id);
* if (entorno.existeConstante(id))
* return entorno.obtenerConstane(id);*/
throw new util.ErrorPascal(0, 0, "No se puede obtener el valor de \"" + id + "\" porque no esta declarado", "semantico", reporte);
}
public void declarar_arreglo()
{
int dimen = ((inferior - superior));
if (dimen < 0)
{
dimen = (dimen * -1) + 1;
}
this.valores = new Simbolo[dimen];
for (int i = 0; i < this.valores.Length; i++)
{
Simbolo simbolo = new Simbolo("", this.contenido.Clonar_Objeto(), 0, 0);
this.valores[i] = simbolo;
}
}
public int EjecutarIf(Simbolo sim)
{
FIf si = (FIf)sim.Valor;
String etq = si.Ejecutar();
if (!etq.Equals(""))
{
Simbolo nuevo = new Simbolo("", Constante.TGoto, etq, Constante.TGoto, 0, 0, new Ambito(etq), null);
nuevo.Anterior = sim.Anterior;
nuevo.Siguiente = sim.Siguiente;
return(EjecutarGoTo(nuevo));
}
return(1);
}
public override Simbolo evaluar(Entorno entorno, Reporte reporte)
{
Simbolo izquierda = this.izquierda.evaluar(entorno, reporte);
Simbolo derecha = this.derecha.evaluar(entorno, reporte);
Simbolo resultado;
Tipos tipoResultante = util.TablaTipos.getTipo(izquierda.tipo, derecha.tipo);
if (tipoResultante != Tipos.NUMBER && tipoResultante != Tipos.DOUBLE && tipo != '+')
{
throw new util.ErrorPascal(0, 0, "Operacion invalida", "semantico", reporte); // Cambiar Exception por errorPascal
}
switch (tipo)
{
case '+':
if (izquierda.tipo.tipo == Tipos.STRING || derecha.tipo.tipo == Tipos.STRING)
{
//Concatenar
resultado = new Simbolo(izquierda.ToString() + derecha.ToString(), izquierda.tipo, null);
}
else
{
//Sumar
resultado = new Simbolo(double.Parse(izquierda.ToString()) + double.Parse(derecha.ToString()), izquierda.tipo, null);
}
return(resultado);
case '-':
resultado = new Simbolo(double.Parse(izquierda.ToString()) - double.Parse(derecha.ToString()), izquierda.tipo, null);
return(resultado);
case '*':
resultado = new Simbolo(double.Parse(izquierda.ToString()) * double.Parse(derecha.ToString()), izquierda.tipo, null);
return(resultado);
case '/':
resultado = new Simbolo(double.Parse(izquierda.ToString()) / double.Parse(derecha.ToString()), izquierda.tipo, null);
return(resultado);
case 'd':
resultado = new Simbolo(int.Parse(izquierda.ToString()) / int.Parse(derecha.ToString()), new Tipo(Tipos.NUMBER, null), null);
return(resultado);
default:
resultado = new Simbolo(double.Parse(izquierda.ToString()) % double.Parse(derecha.ToString()), izquierda.tipo, null);
return(resultado);
}
}
public override object ejecutar(Entorno entorno, Reporte reporte)
{
Simbolo valorReal = valor.evaluar(entorno, reporte);
Dictionary <object, LinkedList <Instruccion> > casosEvaluados = new Dictionary <object, LinkedList <Instruccion> >();
foreach (KeyValuePair <Expresion, LinkedList <Instruccion> > entry in casos)
{
casosEvaluados.Add(entry.Key.evaluar(entorno, reporte).valor, entry.Value);
}
try
{
Entorno entornoCasos = new Entorno(".caso", entorno, reporte);
if (casosEvaluados.Count != 0 && casosEvaluados.ContainsKey(valorReal.valor))
{
foreach (Instruccion instruccion in casosEvaluados[valorReal.valor])
{
try
{
object retorno = instruccion.ejecutar(entornoCasos, reporte);
if (retorno != null)
{
return(retorno);
}
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
}
return(null);
}
//Evaluar else condition
foreach (Instruccion instruccion in caseDefault)
{
try
{
object retorno = instruccion.ejecutar(entornoCasos, reporte);
if (retorno != null)
{
return(retorno);
}
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
}
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
return(null);
}
private Type dameTipo(Ambito ambitoPregunta)
{
Simbolo s = (Simbolo)ambitoPregunta.getSimbolo("respuesta");
if (s != null)
{
String tipo = s.Tipo.ToLower();
switch (tipo)
{
case "booleano":
{
return(typeof(Boolean));
}
case "entero":
{
return(typeof(int));
}
case "decimal":
{
return(typeof(double));
}
case "cadena":
{
return(typeof(String));
}
case "fecha":
{
return(typeof(Date));
}
case "hora":
{
return(typeof(Hour));
}
case "fechahora":
{
return(typeof(DateTime));
}
}
}
return(null);
}
public void Ejecutar(Entorno e)
{
Simbolo encontrado = e.Obtener(id);
if (encontrado == null)
{
Console.WriteLine("No se puede realizar la operacion set porque no se encontro el collection con id " + id);
return;
}
//Si es un map
if (encontrado is MapCollection map)
{
if (valores.Count != 2)
{
Console.WriteLine("Para realizar la operacion set sobre el map " + id + " solo se necesita una llave y un valor");
return;
}
object clave = valores.First.Value.GetValor(e);
if (!map.TieneLaClave(clave))
{
Console.WriteLine("No se puede realizar la operacion set porque el map " + id + " no tiene ninguna clave " + clave);
return;
}
object valor = valores.Last.Value.GetValor(e);
map.Set(clave, valor);
}
//Si es una list
else if (encontrado is ListCollection list)
{
if (valores.Count != 2)
{
Console.WriteLine("Para realizar la operacion set sobre la list " + id + " solo se necesita la posicion y el valor");
return;
}
object posicion = valores.First.Value.GetValor(e);
object valor = valores.Last.Value.GetValor(e);
//Si es un objeto
if (valor is Entorno atributos && valores.Last.Value.GetTipo(e).Equals(Tipos.OBJETO))
{
list.Set(Convert.ToInt32(posicion), new Objeto("", atributos));
}
//Si es un primitivo
else
{
list.Set(Convert.ToInt32(posicion), valor);
}
}
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores)
{
switch (Id.ToLower())
{
case "map":
Tipo = new Tipo(Tipo1, Tipo2);
return(new Collection(new Tipo(Tipo1, Tipo2)));
case "list":
Tipo = new Tipo(Type.LIST, Tipo1);
return(new Collection(new Tipo(Type.LIST, Tipo1)));
case "set":
Tipo = new Tipo(Type.SET, Tipo1);
return(new Collection(new Tipo(Type.SET, Tipo1)));
}
BD actual = e.Master.Actual;
if (actual != null)
{
Simbolo sim = actual.GetUserType(Id);
if (sim != null)
{
Tipo = new Tipo(Id.ToLower());
LinkedList <Simbolo> sims = new LinkedList <Simbolo>();
foreach (Simbolo s in ((Entorno)sim.Valor).Simbolos)
{
sims.AddLast(new Simbolo(s.Tipo, Rol.ATRIBUTO, s.Id));
}
return(new Objeto(Id.ToLower(), new Entorno(null, sims)));
}
else
{
errores.AddLast(new Error("Semántico", "No existe un User Type con el id: " + Id + " en la base de datos.", Linea, Columna));
}
}
else
{
errores.AddLast(new Error("Semántico", "No se ha seleccionado una base de datos, no se pudo buscar el User Type.", Linea, Columna));
}
return(null);
}
public override object ejecutar(Entorno entorno, Reporte reporte)
{
Debug.WriteLine("Ejecutando Write");
try
{
Simbolo valor = this.valor.evaluar(entorno, reporte);
switch (tipo)
{
case 0:
try
{
if (valor.valor == null)
{
throw new util.ErrorPascal(0, 0, "La variable \"" + valor.id + "\" no tiene valor", "semántico", reporte);
}
if (valor.valor == null)
{
throw new util.ErrorPascal(0, 0, "La variable \"" + valor.id + "\" no tiene valor", "semántico", reporte);
}
consola.AppendText(valor.valor.ToString());
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
break;
case 1:
try
{
if (valor == null)
{
throw new util.ErrorPascal(0, 0, "El simbolo no tiene valor (probablemente es un procedimiento)", "semántico", reporte);
}
if (valor.valor == null)
{
throw new util.ErrorPascal(0, 0, "La variable \"" + valor.id + "\" no tiene valor", "semántico", reporte);
}
consola.AppendText(valor.valor.ToString() + "\n");
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
break;
}
}catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
return(null);
}
public override Simbolo evaluar(Entorno entorno, Reporte reporte)
{
Dictionary <int, object> arreglo = (Dictionary <int, object>)entorno.obtenerVariable(nombre).valor;
LinkedList <int> indexes = new LinkedList <int>();
foreach (Expresion expresion in valores)
{
Simbolo valor = expresion.evaluar(entorno, reporte);
if (valor.tipo.tipo != Tipos.NUMBER)
{
throw new util.ErrorPascal(0, 0, "No se puede tomar \"" + valor.valor + "\" como indice para " + nombre, "semantico", reporte);
}
indexes.AddLast(int.Parse(valor.valor.ToString()));
}
int i = 1;
foreach (int index in indexes)
{
if (!arreglo.ContainsKey(index))
{
throw new util.ErrorPascal(0, 0, "Acceso denegado a \"" + this.nombre + "\" No se puede acceder al indice \"" + index + "\" en la posicion " + (i - 1), "semantico", reporte);
}
if (i == valores.Count)
{
if (arreglo[index] is Dictionary <int, object> )
{
throw new util.ErrorPascal(0, 0, "No se devolvio un valor con los indices dados para \"" + nombre + "\"", "semantico", reporte);
}
else
{
return(new Simbolo(arreglo[index], new Tipo(entorno.getTipoArray(nombre), null), null));
}
}
if (!(arreglo[index] is Dictionary <int, object>))
{
throw new util.ErrorPascal(0, 0, "Indices incorrectos para el arreglo \"" + this.nombre + "\"", "semantico", reporte);
}
arreglo = (Dictionary <int, object>)arreglo[index];
i++;
}
throw new util.ErrorPascal(0, 0, "No se pudo obtener el valor del array \"" + nombre + "\"", "semantico", reporte);
}
public override object ejecutar(Entorno entorno, Reporte reporte)
{
try
{
Simbolo valor = this.valor.evaluar(entorno, reporte);
Entorno entornoVariable = entorno.buscarEntornoVariable(this.id);
if (valor.valor == null)
{
throw new util.ErrorPascal(0, 0, "La variable \"" + valor.id + "\" no tiene valor asignado", "semántico", reporte);
}
//return entornoVariable.modificarVariable(id, valor.valor, valor.tipo.tipo,valor.id);
return(entorno.modificarVariable(id, valor.valor, valor.tipo.tipo, valor.id));
}
catch (Exception ex) { Debug.WriteLine(ex.ToString()); }
return(null);
}
/// <summary>
/// Método destinado a Pesquisar um simbolo para ser retornado
/// </summary>
/// <param name="lexema"></param>
/// <returns></returns>
public Simbolo PesquisaSimbolo(String lexema)
{
Simbolo simbolo = new Simbolo();
foreach (ItemSimbolo item in pilhaItens.Reverse<ItemSimbolo>())
{
if (item.Lexema == lexema)
{
if (item.GetType() == typeof(VariavelSimbolo))
return simbolo = ConverteParaSimbolo(((VariavelSimbolo)item).TipoVariavel);
if (item.GetType() == typeof(FuncaoSimbolo))
return simbolo = ConverteParaSimbolo(((FuncaoSimbolo)item).TipoFuncao);
}
}
return simbolo;
}
/// <summary>
/// Método responsável por Analisar o tipo de cada membro da expressao e validar o tipo final da expressâo
/// </summary>
/// <param name="tabelaSimbolos"></param>
/// <param name="tokenAtual"></param>
/// <param name="simboloValido"></param>
/// <param name="comando"></param>
public void AnalisaExpressaoSemanticamente(GeradorCodigo gerador,Token tokenAtual,Simbolo simboloValido, String comando)
{
posFixa.DesimpilharPilhaPrioridade(); // remove os membros restantes da pilha, caso venha ter.
// verifica se o tipo da expressao retornada é de fato igual ao tipo exigido
if (AnalisaExpressaoPosFixa() != simboloValido)
{
if (simboloValido == Simbolo.Sbooleano)
throw new ErroException(String.Format("Linha: {0}. Erro Semântico! {1} deve conter uma expressão booleana!", tokenAtual.Linha, comando), tokenAtual.Linha);
else
throw new ErroException(String.Format("Linha: {0}. Erro Semântico! {1} deve conter uma expressão inteira!", tokenAtual.Linha, comando), tokenAtual.Linha);
}
//gera código da expressao pos fixa
GeraCodigoExpressao(gerador);
// limpar lista da pos fixa
posFixa.ResetarPosFixa();
}
/// <summary>
/// método destinado a realizar a conversão de tipo para Simbolo
/// </summary>
/// <param name="tipo"></param>
/// <returns></returns>
public Simbolo ConverteParaSimbolo(Tipo tipo)
{
Simbolo simbolo = new Simbolo();
//se nao for inteiro ou booleano o simbolo vai ser sem token
simbolo = Simbolo.Ssemtoken;
if (tipo == Tipo.inteiro)
simbolo = Simbolo.Sinteiro;
if (tipo == Tipo.booleano)
simbolo = Simbolo.Sbooleano;
return simbolo;
}
/// <summary>
/// método destinado a realizar a conversão de simbolo para tipo
/// </summary>
/// <param name="simbolo"></param>
/// <returns></returns>
public Tipo ConverteParaTipo (Simbolo simbolo)
{
Tipo tipo = new Tipo();
if (simbolo == Simbolo.Sinteiro)
tipo = Tipo.inteiro;
if (simbolo == Simbolo.Sbooleano)
tipo = Tipo.booleano;
//se nao for inteiro ou booleano o tipo vai ser sem tipo
return tipo;
}
/// <summary>
/// Método a destinado a colocar o tipo em funções ou variáveis sem tipo ainda
/// </summary>
/// <param name="simbolo"></param>
public void ColocarTipo(Simbolo simbolo)
{ //verifica se o tipo é função,
//se for o metodo ColocaTipo foi chamado no analisa_declaração_função
//senão o metodo ColocaTipo foi chamado no analisa_tipo
Tipo novoTipo = ConverteParaTipo(simbolo);
if (pilhaItens.Last().GetType() == typeof(FuncaoSimbolo))
{
((FuncaoSimbolo)pilhaItens.Last()).TipoFuncao = novoTipo;
}
else
{
foreach (ItemSimbolo item in pilhaItens.Reverse<ItemSimbolo>())
{
//verifica se o tipo do item é variável
if (item.GetType() == typeof(VariavelSimbolo))
{
//verifica se o tipo da variavel não foi preenchido
if (((VariavelSimbolo)item).TipoVariavel == Tipo.semTipo)
{
((VariavelSimbolo)item).TipoVariavel = novoTipo;
}
else
break;
}
else
break;
}
}
}
