Exemple #1
0
 public override void checkSemantica(TablaSimbolos tabla)
 {
     foreach (Expresion expr in lista)
     {
         expr.checkSemantica(tabla);
     }
 }
Exemple #2
0
        public override void checkSemantica(TablaSimbolos tabla)
        {
            //Chequear que si la variable existe, sea una variable
            Object sym = tabla.buscar(id.Nombre);

            if (sym != null && sym.GetType() != typeof(Variable))
            {
                SemantErrorReport.Instancia.semantError(id, "el identificador " + id.Nombre + " es inválido");
            }

            expr.checkSemantica(tabla);

            //Agregar el id a la tabla de símbolos
            if (sym == null)
            {
                tabla.agregarId(id.Nombre, id);
            }

            id.checkTipo(tabla);
            //chequear el tipo del id y la expresión
            if (!id.Tipo_Expr.Equals(expr.Tipo_Expr))
            {
                SemantErrorReport.Instancia.semantError(id, "no se puede convertir valor de tipo " + expr.Tipo_Expr + " a tipo " + id.Tipo_Expr);
            }
        }
 public Form1()
 {
     InitializeComponent();
     _analizadorLexico           = new AnalizadorLexico();
     _tablaSimbolos              = new TablaSimbolos();
     _analizadorSintactico       = new AnalizadorSintactico();
     _analizadorSemantico        = new AnalizadorSemantico();
     _generadorCodigo            = new GeneradorCodigo();
     cuadroResultados.ScrollBars = ScrollBars.Both;
     cuadroResultados.WordWrap   = false;
     cuadroTexto.ScrollBars      = ScrollBars.Both;
     cuadroTexto.WordWrap        = false;
     new ToolTip().SetToolTip(btnNuevo, "Nuevo");
     new ToolTip().SetToolTip(btnCompilar, "Compilar");
     new ToolTip().SetToolTip(btnOpen, "Abrir");
     new ToolTip().SetToolTip(btnSave, "Guardar");
     new ToolTip().SetToolTip(btnLexi, "Análisis léxico");
     new ToolTip().SetToolTip(btnSemantic, "Análisis semántico");
     new ToolTip().SetToolTip(btnSitax, "Análisis sintáctico");
     new ToolTip().SetToolTip(btnMachine, "Código máquina");
     new ToolTip().SetToolTip(btnIntermedio, "Código intermedio");
     new ToolTip().SetToolTip(btnEjecutar, "Ejecutar");
     openFile.Title            = "Abrir archivos C";
     openFile.Filter           = "Archivo C|*.c";
     openFile.InitialDirectory = @"C:\";
     saveFile.Title            = "Guarcar archivo";
     saveFile.Filter           = "Archivo C|*.c";
     saveFile.InitialDirectory = @"C:\";
 }
Exemple #4
0
        // flanzani 8/11/2012
        // IDC_APP_2
        // Agregar funciones por defecto en el framework
        // Creacion de la libreria de funciones Normal
        private static void AgregarLibreriaNormal(TablaSimbolos tablaSimbolos)
        {
            string           nombre;
            string           nombreFunc;
            string           codigo;
            List <FirmaProc> parametros;

            nombre     = "EsPar";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionEsPar(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Booleano, codigo, nombreFunc);

            nombre     = "EsImpar";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionEsImpar(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Booleano, codigo, nombreFunc);

            nombre     = "Redondear";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionRedondearAEntero(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            nombre     = "Truncar";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionTruncar(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);
        }
Exemple #5
0
 private void buttonLimpiar_Click(object sender, EventArgs e)
 {
     TablaErrores.ObtenerInstancia().limpiar();
     TablaSimbolos.ObtenerInstancia().limpiar();
     ManejadorErrores.obtenerManejadorErrores().limpiarManejadorErrores();
     tablaSimbolos.DataSource = null;
     tablaErrores.DataSource  = null;
 }
Exemple #6
0
 public override void checkSemantica(TablaSimbolos tabla)
 {
     //chequear cada sentencia
     foreach (Sentencia sent in lista)
     {
         sent.checkSemantica(tabla);
     }
 }
Exemple #7
0
 public override void checkTipo(TablaSimbolos tabla)
 {
     if (!expr1.Tipo_Expr.Equals(NucleoLenguaje.tipoEntero) ||
         !expr2.Tipo_Expr.Equals(NucleoLenguaje.tipoEntero))
     {
         SemantErrorReport.Instancia.semantError(this, "la operación igual_a no se puede aplicar a valores de tipo " + expr1.Tipo_Expr + " y " + expr2.Tipo_Expr);
     }
     tipo_expr = NucleoLenguaje.tipoBool;
 }
        private Expresion AnalizarExpresionAritmeticaPrimaria(Token tipoDeDato)
        {
            if (TokenActual.Tipo == TipoSintaxis.TokenParentesisApertura)
            {
                var izquierda = CoincideCon(TipoSintaxis.TokenParentesisApertura);
                var expresion = AnalizarExpresionAritmetica(tipoDeDato);
                var derecha   = CoincideCon(TipoSintaxis.TokenParentesisCierre);
                return(new ExpresionEnParentesis(izquierda, expresion, derecha));
            }

            var tokenNumero = SiguienteToken();

            if (tokenNumero.Tipo is TipoSintaxis.TokenInteger && tipoDeDato.Tipo == TipoSintaxis.IntegerKeyword)
            {
                return(new ExpresionEntera(tokenNumero));
            }
            else if (tokenNumero.Tipo is TipoSintaxis.TokenDecimal && tipoDeDato.Tipo == TipoSintaxis.IntegerKeyword)
            {
                var token = new Token(tokenNumero.Tipo, tokenNumero.Position, tokenNumero.Text, (int)float.Parse(tokenNumero.Value.ToString()));
                return(new ExpresionEntera(token));
            }
            else if (tokenNumero.Tipo is TipoSintaxis.TokenDecimal && tipoDeDato.Tipo == TipoSintaxis.FloatKeyword)
            {
                return(new ExpresionDecimal(tokenNumero));
            }
            else if (tokenNumero.Tipo is TipoSintaxis.TokenInteger && tipoDeDato.Tipo == TipoSintaxis.FloatKeyword)
            {
                var token = new Token(tokenNumero.Tipo, tokenNumero.Position, tokenNumero.Text, (float)int.Parse(tokenNumero.Value.ToString()));
                return(new ExpresionDecimal(token));
            }
            else if (tokenNumero.Tipo is TipoSintaxis.Identificador)
            {
                var identificador = tokenNumero;
                if (TablaSimbolos.ContainsKey(identificador.Value.ToString()))
                {
                    var variable = (Token)TablaSimbolos[identificador.Value.ToString()];
                    if (variable.Tipo is TipoSintaxis.TokenInteger ||
                        variable.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        return(new ExpresionIdentificador(tokenNumero));
                    }
                    else
                    {
                        _diagnostics.Add($"ERROR: Se variable de tipo invalido, se esperaba tipo <{variable.Tipo}>");
                        return(new ExpresionIdentificador(new Token(TipoSintaxis.Identificador, _position, null, null)));
                    }
                }
                else
                {
                    _diagnostics.Add($"ERROR: Identificador <{identificador}> no existe en el ambito actual.");
                    return(new ExpresionNumericaInvalida(new Token(TipoSintaxis.TokenNumericoInvalido, _position, null, null)));
                }
            }

            _diagnostics.Add($"ERROR: Variable de tipo invalido, se esperaba valor numerico.");
            return(new ExpresionNumericaInvalida(new Token(TipoSintaxis.TokenNumericoInvalido, _position, null, null)));
        }
        private Expresion AnalizarExpresionDeDeclaracion()
        {
            var tokenTipoDato      = SiguienteToken();
            var tokenIdentificador = CoincideCon(TipoSintaxis.Identificador);

            if (TablaSimbolos.ContainsKey(tokenIdentificador.Value.ToString()))
            {
                _diagnostics.Add($"ERROR: Multiple declarations of variable <{tokenIdentificador.Value.ToString()}>");
            }
            var equalsToken = CoincideCon(TipoSintaxis.TokenIgual);

            Expresion expresion = null;

            if (tokenTipoDato.Tipo.Equals(TipoSintaxis.IntegerKeyword) ||
                tokenTipoDato.Tipo.Equals(TipoSintaxis.FloatKeyword) ||
                tokenTipoDato.Tipo.Equals(TipoSintaxis.LongKeyword) ||
                tokenTipoDato.Tipo.Equals(TipoSintaxis.DoubleKeyword))
            {
                expresion = AnalizarExpresionAritmetica(tokenTipoDato);

                // If expresion is not an arithmetic expresion, then is invalid.
            }

            else if (tokenTipoDato.Tipo.Equals(TipoSintaxis.BoolKeyword))
            {
                expresion = AnalizarExpresionLogica();
            }
            else if (tokenTipoDato.Tipo.Equals(TipoSintaxis.CharKeyword))
            {
                expresion = AnalizarExpresionChar();
            }
            else if (tokenTipoDato.Tipo.Equals(TipoSintaxis.StringKeyword))
            {
                expresion = AnalizarExpresionString();
            }

            if (tokenTipoDato.Tipo == TipoSintaxis.IntegerKeyword)
            {
                TablaSimbolos[tokenIdentificador.Value.ToString()] =
                    new Token(TipoSintaxis.TokenInteger, tokenIdentificador.Position, tokenIdentificador.Value.ToString(), expresion);
            }
            else if (tokenTipoDato.Tipo == TipoSintaxis.FloatKeyword)
            {
                TablaSimbolos[tokenIdentificador.Value.ToString()] =
                    new Token(TipoSintaxis.TokenDecimal, tokenIdentificador.Position, tokenIdentificador.Value.ToString(), expresion);
            }
            else if (tokenTipoDato.Tipo == TipoSintaxis.StringKeyword)
            {
                TablaSimbolos[tokenIdentificador.Value.ToString()] =
                    new Token(TipoSintaxis.TokenString, tokenIdentificador.Position, tokenIdentificador.Value.ToString(), expresion);
            }

            var semicolonToken = CoincideCon(TipoSintaxis.TokenPuntoyComa);

            return(new ExplresionDeclaracion(tokenTipoDato, tokenIdentificador, equalsToken, expresion, semicolonToken));
        }
Exemple #10
0
        public override void checkSemantica(TablaSimbolos tabla)
        {
            sentencias.checkSemantica(tabla);

            condicion.checkSemantica(tabla);
            //validar que la condición sea de tipo booleana
            if (!condicion.Tipo_Expr.Equals(NucleoLenguaje.tipoBool))
            {
                SemantErrorReport.Instancia.semantError(condicion, "la condición del \"repeat-until\" debe ser un valor de tipo _lógico");
            }
        }
        public Token EvaluarExpresionString(Expresion nodo)
        {
            if (nodo is ExpresionString n)
            {
                string valor       = n.Valor.Value.ToString();
                var    tokenString = new Token(TipoSintaxis.TokenInteger, 0, valor, valor);
                return(tokenString);
            }

            if (nodo is ExpresionIdentificador id)
            {
                var identificador = id.Identificador;
                var tokenString   = (TablaSimbolos[identificador.Value.ToString()] as Token).Value;

                if (!TablaSimbolos.ContainsKey(identificador.Value.ToString()))
                {
                    Diagnostico.Add($"ERROR: Variable no declarada <{identificador}>");
                }
                else if (!(tokenString is null))
                {
                    return(new Token(TipoSintaxis.TokenString, 0, tokenString.ToString(), tokenString.ToString()));
                }

                // Invalid string
                return(null);
            }


            if (nodo is ExpresionBinaria b)
            {
                var izquierda = EvaluarExpresionString(b.Izquierda);
                var derecha   = EvaluarExpresionString(b.Derecha);

                if (b.Operador.Tipo == TipoSintaxis.TokenMas)
                {
                    string result = izquierda.Value.ToString() + derecha.Value.ToString();
                    return(new Token(TipoSintaxis.TokenString, 0, result, result));
                }

                else
                {
                    throw new Exception($"Operador binario inesperado: {b.Operador.Tipo}");
                }
            }

            if (nodo is ExpresionEnParentesis p)
            {
                return(EvaluarExpresionString(p.Expresion));
            }

            throw new Exception($"Nodo inesperado {nodo.Tipo}");
        }
Exemple #12
0
        private void instalarFuncBasicas()
        {
            //crear la tabla de simbolos
            tabla = new TablaSimbolos();

            //agregar los métodos básicos a la tabla.
            List <FuncionDef> funs = NucleoLenguaje.Instancia.getFuncBasicas();

            tabla.crearAmbito();
            foreach (FuncionDef fun in funs)
            {
                tabla.agregarId(fun.Nombre, fun);
            }
        }
        private void BtnResetear_Click(object sender, EventArgs e)
        {
            archivo.LimpiarLineas();
            textBoxReader.Clear();

            TablaSimbolos.ObtenerTablaSimbolos().Limpiar();
            TablaDummys.ObtenerTablaDummys().Limpiar();
            TablaLiterales.ObtenerTablaLiterales().Limpiar();
            ManejadorErrores.ObtenerManejadorErrores().Limpiar();

            tablaSimbolos.DataSource  = TablaSimbolos.ObtenerTablaSimbolos().ObtenerSimbolos();
            tablaLiterales.DataSource = TablaLiterales.ObtenerTablaLiterales().ObtenerLiterales();
            tablaDummys.DataSource    = TablaDummys.ObtenerTablaDummys().ObtenerDummys();
            tablaErrores.DataSource   = ManejadorErrores.ObtenerManejadorErrores().ObtenerErrores();
        }
 private void AgregarComponente(ComponenteLexico componente)
 {
     componente.numeroLinea = numeroLineaActual;
     if (componente.categoria.Equals("FIN DE ARCHIVO"))
     {
         componente.posicionInicial = 1;
         componente.posicionFinal   = 1;
     }
     else
     {
         componente.posicionInicial = puntero - componente.lexema.Length;
         componente.posicionFinal   = (puntero - 1);
     }
     TablaSimbolos.ObtenerInstancia().agregar(componente);
 }
Exemple #15
0
        public override void checkSemantica(TablaSimbolos tabla)
        {
            Object sym = tabla.buscar(nombre);

            checkTipo(tabla);

            if (sym == null)
            {
                SemantErrorReport.Instancia.semantError(this, "la variable \"" + nombre + "\" no ha sido inicializada");
            }
            else if (sym.GetType() != typeof(Variable)) //verificar que sea una nombre de variable
            {
                SemantErrorReport.Instancia.semantError(this, "el identificador \"" + nombre + "\" es inválido");
            }
        }
Exemple #16
0
        public override void checkSemantica(TablaSimbolos tabla)
        {
            Object sym = tabla.buscar(id);
            bool   exists = true, esVariable;

            //chequear que el método exista
            if (sym == null || sym.GetType() != typeof(FuncionDef))
            {
                SemantErrorReport.Instancia.semantError(this, "no se encuentra la definición para la función \"" + id + "\"");
                exists = false;
            }

            //chequear que los tipos de los paramétros se correspondan con los de la función
            if (exists)
            {
                FuncionDef f = (FuncionDef)sym;

                if (f.Parametros.getLongitud() != lparams.getLongitud())
                {
                    SemantErrorReport.Instancia.semantError(this, "la cantidad de paramétros no coincide con la definición de la función \"" + id + "\"");
                }
                else
                {
                    for (int i = 0; i < lparams.getLongitud(); i++)
                    {
                        Expresion param = lparams.getLista()[i];

                        //si el paramétro es una variable agregarlo a la tabla de simbolo
                        esVariable = false;
                        if (param.GetType() == typeof(Variable))
                        {
                            if (tabla.buscar(((Variable)param).Nombre) == null)
                            {
                                tabla.agregarId(((Variable)param).Nombre, param);
                            }
                            esVariable = true;
                        }

                        param.checkSemantica(tabla);
                        if (!param.Tipo_Expr.Equals(f.Parametros.getLista()[i].Tipo) ||
                            (f.Parametros.getLista()[i].EsDireccion && !esVariable))
                        {
                            SemantErrorReport.Instancia.semantError(param, "el tipo de paramétro no coincide con la definición de la función \"" + id + "\"");
                        }
                    }
                }
            }
        }
Exemple #17
0
        private void traducirBtn_Click(object sender, EventArgs e)
        {
            textBoxCadena.Text = "";
            AnalisisSintactico.AnalisisSintactico asintac = new AnalisisSintactico.AnalisisSintactico();
            asintac.analizar(false);
            cadena             = asintac.cadenafinal;
            textBoxCadena.Text = cadena;

            /*foreach (ComponenteLexico componente in TablaSimbolos.ObtenerInstancia().ObtenerTodo())
             * {
             *  MessageBox.Show("Lexema: " + componente.lexema + "\nCategoría: " + componente.categoria + "\nNúmero Línea: " + componente.numeroLinea + "\nPosición Inicial: " + componente.posicionInicial + "\nPosición Final: " + componente.posicionFinal);
             * }
             */

            tablaSimbolos.DataSource = TablaSimbolos.ObtenerInstancia().ObtenerTodo();
            tablaErrores.DataSource  = ManejadorErrores.obtenerManejadorErrores().ObtenerTodo();
        }
Exemple #18
0
        private void LlenarTablas()
        {
            List <ComponenteLexico> listaSimbolo = TablaSimbolos.ObtenerSimbolos();

            for (int i = 0; i < listaSimbolo.Count; i++)
            {
                dataSimbolos.Rows.Add(listaSimbolo[i].ObtenerLexema(), listaSimbolo[i].ObtenerCategoria(), listaSimbolo[i].ObtenerNumeroLinea(), listaSimbolo[i].ObetenerPosicionInicial(), listaSimbolo[i].ObtenerPosicionFinal());
            }
            listaSimbolo = TablaPalabraReservadas.ObtenerSimbolos();
            for (int i = 0; i < listaSimbolo.Count; i++)
            {
                dataPalabraReservada.Rows.Add(listaSimbolo[i].ObtenerLexema(), listaSimbolo[i].ObtenerCategoria(), listaSimbolo[i].ObtenerNumeroLinea(), listaSimbolo[i].ObetenerPosicionInicial(), listaSimbolo[i].ObtenerPosicionFinal());
            }
            listaSimbolo = TablaLiterales.ObtenerLiterales();
            for (int i = 0; i < listaSimbolo.Count; i++)
            {
                dataLiterales.Rows.Add(listaSimbolo[i].ObtenerLexema(), listaSimbolo[i].ObtenerCategoria(), listaSimbolo[i].ObtenerNumeroLinea(), listaSimbolo[i].ObetenerPosicionInicial(), listaSimbolo[i].ObtenerPosicionFinal());
            }
            listaSimbolo = TablaDummys.ObtenerDummys();
            for (int i = 0; i < listaSimbolo.Count; i++)
            {
                dataDummys.Rows.Add(listaSimbolo[i].ObtenerLexema(), listaSimbolo[i].ObtenerCategoria(), listaSimbolo[i].ObtenerNumeroLinea(), listaSimbolo[i].ObetenerPosicionInicial(), listaSimbolo[i].ObtenerPosicionFinal());
            }

            List <Error> listaErrores = ManejadorErrores.ObtenerErroresLexicos();

            for (int i = 0; i < listaErrores.Count; i++)
            {
                dataErroresLexicos.Rows.Add(listaErrores[i].ObtenerLexema(), listaErrores[i].ObtenerCategoria(), listaErrores[i].ObtenerNumeroLinea(), listaErrores[i].ObetenerPosicionInicial(), listaErrores[i].ObtenerPosicionFinal(),
                                            listaErrores[i].ObtenerFalla(), listaErrores[i].ObtenerCausa(), listaErrores[i].ObtenerSolucion());
            }

            listaErrores = ManejadorErrores.ObtenerErroresSintatacticos();
            for (int i = 0; i < listaErrores.Count; i++)
            {
                dataErroresSintac.Rows.Add(listaErrores[i].ObtenerLexema(), listaErrores[i].ObtenerCategoria(), listaErrores[i].ObtenerNumeroLinea(), listaErrores[i].ObetenerPosicionInicial(), listaErrores[i].ObtenerPosicionFinal(),
                                           listaErrores[i].ObtenerFalla(), listaErrores[i].ObtenerCausa(), listaErrores[i].ObtenerSolucion());
            }
            listaErrores = ManejadorErrores.ObtenerErroresSemanticos();
            for (int i = 0; i < listaErrores.Count; i++)
            {
                dataErroresSeman.Rows.Add(listaErrores[i].ObtenerLexema(), listaErrores[i].ObtenerCategoria(), listaErrores[i].ObtenerNumeroLinea(), listaErrores[i].ObetenerPosicionInicial(), listaErrores[i].ObtenerPosicionFinal(),
                                          listaErrores[i].ObtenerFalla(), listaErrores[i].ObtenerCausa(), listaErrores[i].ObtenerSolucion());
            }
        }
        private void BtnCompilar_Click(object sender, EventArgs e)
        {
            TablaSimbolos.ObtenerTablaSimbolos().Limpiar();
            TablaDummys.ObtenerTablaDummys().Limpiar();
            TablaLiterales.ObtenerTablaLiterales().Limpiar();
            ManejadorErrores.ObtenerManejadorErrores().Limpiar();

            textBoxReader.Clear();
            LlenarTextBoxReader();

            AnalizadorSintactico anaSin = new AnalizadorSintactico();

            anaSin.Analizar();

            tablaSimbolos.DataSource  = TablaSimbolos.ObtenerTablaSimbolos().ObtenerSimbolos();
            tablaLiterales.DataSource = TablaLiterales.ObtenerTablaLiterales().ObtenerLiterales();
            tablaDummys.DataSource    = TablaDummys.ObtenerTablaDummys().ObtenerDummys();
            tablaErrores.DataSource   = ManejadorErrores.ObtenerManejadorErrores().ObtenerErrores();
        }
        public string verificarIdentificadores(TablaSimbolos tabla)
        {
            var    listaIds  = new List <string>();
            string resultado = "";

            foreach (Simbolo simbolo in tabla.Simbolos)
            {
                string id = simbolo.Id;
                if (!listaIds.Contains(id))
                {
                    listaIds.Add(id);
                }
                else
                {
                    resultado += "El identificador " + id + " esta repetido \r\n";
                }
            }
            return(resultado);
        }
Exemple #21
0
        private void BtnCompilar_Click(object sender, EventArgs e)
        {
            TablaSimbolos.Limpiar();
            TablaDummy.Limpiar();
            GestorErrores.Limpiar();


            textBoxReader.Clear();
            LlenarTextBoxReader();

            AnalizadorLexico analizador = new AnalizadorLexico();
            ComponenteLexico componente = new ComponenteLexico();

            while (analizador.Analizar().Lexema != "@EOF@")
            {
            }

            tablaSimbolos.DataSource = TablaSimbolos.ObtenerTodosSimbolos();
            tablaDummys.DataSource   = TablaDummy.ObtenerTodosSimbolos();
            tablaErrores.DataSource  = GestorErrores.ObtenerTodosErrores();
        }
        private Expresion AnalizarExpresionStringPrimaria()
        {
            if (TokenActual.Tipo == TipoSintaxis.TokenParentesisApertura)
            {
                var izquierda = CoincideCon(TipoSintaxis.TokenParentesisApertura);
                var expresion = AnalizarExpresionString();
                var derecha   = CoincideCon(TipoSintaxis.TokenParentesisCierre);
                return(new ExpresionEnParentesis(izquierda, expresion, derecha));
            }

            var tokenString = SiguienteToken();

            if (tokenString.Tipo is TipoSintaxis.TokenString)
            {
                return(new ExpresionString(tokenString));
            }
            else if (tokenString.Tipo is TipoSintaxis.Identificador)
            {
                var identificador = tokenString;
                if (TablaSimbolos.ContainsKey(identificador.Value.ToString()))
                {
                    var variable = (Token)TablaSimbolos[identificador.Value.ToString()];
                    if (variable.Tipo is TipoSintaxis.TokenString)
                    {
                        return(new ExpresionIdentificador(tokenString));
                    }
                    else
                    {
                        _diagnostics.Add($"ERROR: Se variable de tipo invalido, se esperaba tipo <{variable.Tipo}>");
                        return(new ExpresionIdentificador(new Token(TipoSintaxis.Identificador, _position, null, null)));
                    }
                }
            }

            _diagnostics.Add($"ERROR: Variable de tipo invalido, se esperaba string.");
            return(new ExpresionStringInvalida(new Token(TipoSintaxis.TokenNumericoInvalido, _position, null, null)));
        }
        public void Reconocedor_Lexico()
        {
            listaMovimientos      = new List <movimientos>();
            lista_tks_reconocidos = new List <tokens>();

            int    estado = 0, newestado = 0, nidentificador = 0;
            char   simbolo;
            string lexema = null;

            char[] palabras = DarFormatoTextoLexico(texto_file_name).Replace(' ', '#').ToCharArray();

            int    cuenta_simbolos = texto_file_name.Length;
            tokens tk = new tokens();
            int    j  = 0;

            movimientos move;

            while (j < palabras.Length)
            {
                simbolo = Convert.ToChar(palabras[j]);

                newestado = movimiento_AFD(estado, simbolo);

                move = new movimientos()
                {
                    EstadoInicial = estado,
                    Leyendo       = simbolo,
                    EstadoFinal   = newestado
                };

                listaMovimientos.Add(move);

                if (newestado == 999)
                {
                    move = new movimientos()
                    {
                        EstadoInicial = estado,
                        Leyendo       = simbolo,
                        EstadoFinal   = newestado
                    };

                    listaMovimientos.Add(move);


                    estado = 0;
                    j++;
                }
                else if (newestado < 0)
                {
                    newestado   = -newestado;
                    tk.NumToken = newestado;
                    tk          = BuscarToken(newestado);
                    tk.Lexema   = lexema;



                    lista_tks_reconocidos.Add(tk);

                    if (tk.NumToken == 1)
                    {
                        TablaSimbolos identificador = new TablaSimbolos();
                        identificador.Nombre = lexema;
                        identificador.Numero = nidentificador++;
                        listTDS.Add(identificador);
                    }
                    estado = 0;
                    lexema = "";
                }
                else
                {
                    lexema += simbolo;
                    estado  = newestado;
                }

                j++;
            }
        }
 private void compilarToolStripMenuItem_Click(object sender, EventArgs e)
 {
     tablaSimbolos = new TablaSimbolos();
     recorrerAST(ast);
 }
        public Token EvaluarExpresionAritmetica(Expresion nodo, TipoSintaxis tipo)
        {
            if (nodo is ExpresionNumericaInvalida invalidExpression)
            {
                return(new Token(TipoSintaxis.TokenInvalido, 0, null, null));
            }

            if (nodo is ExpresionEntera n)
            {
                int valor       = Convert.ToInt32((Convert.ToDouble(n.Numero.Value)));
                var tokenEntero = new Token(TipoSintaxis.TokenInteger, 0, valor.ToString(), valor);
                return(tokenEntero);
            }

            //if (nodo is ExpresionEntera n)
            //{
            //    int valor = Convert.ToInt32((Convert.ToDouble(n.Numero.Value)));
            //    var tokenEntero = new Token(TipoSintaxis.TokenInteger, 0, valor.ToString(), valor);
            //    return tokenEntero;
            //}


            if (nodo is ExpresionDecimal nd)
            {
                float valor        = (float)nd.Numero.Value;
                var   tokenDecimal = new Token(TipoSintaxis.TokenDecimal, 0, valor.ToString(), valor);
                return(tokenDecimal);
            }

            if (nodo is ExpresionIdentificador id)
            {
                var identificador = id.Identificador;
                var tokenNumero   = (TablaSimbolos[identificador.Value.ToString()] as Token).Value;

                if (!TablaSimbolos.ContainsKey(identificador.Value.ToString()))
                {
                    Console.WriteLine($"ERROR: Variable no declarada <{identificador}>");
                    Diagnostico.Add($"ERROR: Variable no declarada <{identificador}>");
                }
                else if (!(tokenNumero is null))
                {
                    var stringData = tokenNumero.ToString();
                    // if contains a dot, then is decimal.
                    if (stringData.Contains("."))
                    {
                        float.TryParse(stringData, out var val);
                        return(new Token(TipoSintaxis.TokenDecimal, 0, val.ToString(), val));
                    }

                    int.TryParse(stringData, out var value);
                    return(new Token(TipoSintaxis.TokenInteger, 0, value.ToString(), value));
                }

                // Invalid number
                return(null);
            }


            if (nodo is ExpresionBinaria b)
            {
                var izquierda = EvaluarExpresionAritmetica(b.Izquierda, tipo);
                var derecha   = EvaluarExpresionAritmetica(b.Derecha, tipo);

                if (b.Operador.Tipo == TipoSintaxis.TokenMas)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenInteger &&
                        derecha.Tipo is TipoSintaxis.TokenInteger)
                    {
                        int result = int.Parse(izquierda.Value.ToString()) + int.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) + float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }

                else if (b.Operador.Tipo == TipoSintaxis.TokenMenos)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenInteger &&
                        derecha.Tipo is TipoSintaxis.TokenInteger)
                    {
                        int result = int.Parse(izquierda.Value.ToString()) - int.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) - float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }

                else if (b.Operador.Tipo == TipoSintaxis.TokenMultiplicacion)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenInteger &&
                        derecha.Tipo is TipoSintaxis.TokenInteger)
                    {
                        int result = int.Parse(izquierda.Value.ToString()) * int.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) * float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }
                else if (b.Operador.Tipo == TipoSintaxis.TokenDivision)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) / float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }
                else if (b.Operador.Tipo == TipoSintaxis.TokenPotencia)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) + float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }
                else if (b.Operador.Tipo == TipoSintaxis.TokenModulo)
                {
                    if (izquierda.Tipo is TipoSintaxis.TokenInteger &&
                        derecha.Tipo is TipoSintaxis.TokenInteger)
                    {
                        int result = int.Parse(izquierda.Value.ToString()) % int.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                    if (izquierda.Tipo is TipoSintaxis.TokenDecimal ||
                        derecha.Tipo is TipoSintaxis.TokenDecimal)
                    {
                        float result = float.Parse(izquierda.Value.ToString()) % float.Parse(derecha.Value.ToString());
                        return(new Token(TipoSintaxis.TokenInteger, 0, result.ToString(), result));
                    }
                }
                else
                {
                    throw new Exception($"Operador binario inesperado: {b.Operador.Tipo}");
                }
            }

            if (nodo is ExpresionEnParentesis p)
            {
                return(EvaluarExpresionAritmetica(p.Expresion, tipo));
            }

            throw new Exception($"Nodo inesperado {nodo.Tipo}");
        }
Exemple #26
0
        // flanzani 8/11/2012
        // IDC_APP_2
        // Agregar funciones por defecto en el framework
        // Creacion de la libreria de funciones matematicas
        private static void AgregarLibreriaMatematica(TablaSimbolos tablaSimbolos)
        {
            string           nombre;
            string           nombreFunc;
            string           codigo;
            List <FirmaProc> parametros;

            nombre     = "Potencia";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            parametros.Add(new FirmaProc("exp", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionPotencia(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            nombre     = "Raiz";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            parametros.Add(new FirmaProc("exp", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionRaiz(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "PI";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            codigo     = GeneracionCodigoHelpers.ArmarFuncionPI(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "ValAbs";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionValorAbsoluto(nombreFunc);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "Seno";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionSeno(nombreFunc, false);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "Coseno";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionCoseno(nombreFunc, false);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "Tangente";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionTangente(nombreFunc, false);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "rSeno";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionSeno(nombreFunc, true);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "rCoseno";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionCoseno(nombreFunc, true);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);

            // flanzani 15/11/2012
            // IDC_APP_6
            // Agregar funciones matematicas al framework
            // Agrego la funcion a la libreria matematica
            nombre     = "rTangente";
            nombreFunc = string.Format("FrameworkProgramArProgramAr0000001{0}", nombre);
            parametros = new List <FirmaProc>();
            parametros.Add(new FirmaProc("num", NodoTablaSimbolos.TipoDeDato.Numero, false, false));
            codigo = GeneracionCodigoHelpers.ArmarFuncionTangente(nombreFunc, true);
            tablaSimbolos.AgregarFuncionDelFramework(nombre, parametros, NodoTablaSimbolos.TipoDeDato.Numero, codigo, nombreFunc);
        }
Exemple #27
0
 public static void AgregarLibreriasFramework(TablaSimbolos tablaSimbolos)
 {
     AgregarLibreriaNormal(tablaSimbolos);
     AgregarLibreriaMatematica(tablaSimbolos);
 }
Exemple #28
0
 public override void checkSemantica(TablaSimbolos tabla)
 {
     expr1.checkSemantica(tabla);
     expr2.checkSemantica(tabla);
     checkTipo(tabla);
 }
Exemple #29
0
 public override void checkSemantica(TablaSimbolos tabla)
 {
     //TODO no existe verificacion semantica en este nodo
 }
Exemple #30
0
 public override void checkTipo(TablaSimbolos tabla)
 {
     tipo_expr = NucleoLenguaje.tipoEntero;
 }