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; } } }