예제 #1
0
        public void EjecutarDeclaracion(Simbolo global)
        {
            FExpresion expresion = (FExpresion)global.Objeto;

            if (expresion != null)
            {
                NodoExpresion valor = expresion.ResolverExpresion(expresion.Incerteza, expresion.RutaArchivo);
                if (TitusNotifiaciones.ContarErrores() == 0)
                {
                    if (global.Tipo == Constante.TString)
                    {
                        if (valor.Tipo == Constante.TString || valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
                        {
                            valor.Tipo = valor.Tipo;
                            TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
                        }
                        else
                        {
                            TabError error = new TabError();
                            error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
                            TitusNotifiaciones.setDatosErrores(error);
                        }
                    }
                    else if (global.Tipo == Constante.TNumber)
                    {
                        if (valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
                        {
                            valor.Tipo = valor.Tipo;
                            TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
                        }
                        else
                        {
                            TabError error = new TabError();
                            error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
                            TitusNotifiaciones.setDatosErrores(error);
                        }
                    }
                    else if (global.Tipo == Constante.TBool)
                    {
                        if (valor.Tipo == Constante.TBool)
                        {
                            valor.Tipo = valor.Tipo;
                            TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
                        }
                        else
                        {
                            TabError error = new TabError();
                            error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
                            TitusNotifiaciones.setDatosErrores(error);
                        }
                    }
                }
            }
            else
            {
                TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, null, null, global.Fila, global.Columna));
            }
        }
예제 #2
0
 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));
     }
 }
예제 #3
0
        public void BuscarErroresAmbitos(Simbolo simbolo, String archivo, Double Incerteza, String rutaimagen)
        {
            simbolo.RutaArchivo = archivo;
            if (simbolo.Ambito != null)
            {
                simbolo.Ambito.Incerteza    = Inicio.Global.Incerteza;
                simbolo.Ambito.RutaImagenes = Inicio.Global.RutaImagenes;
                simbolo.Ambito.RutaArchivo  = Inicio.Ruta;

                foreach (Simbolo s in simbolo.Ambito.TablaSimbolo)
                {
                    BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                }
            }


            switch (simbolo.Rol)
            {
            case Constante.DECLARACION:

                if (simbolo.Objeto != null)
                {
                    FExpresion expdecla = (FExpresion)simbolo.Objeto;
                    expdecla.RutaArchivo = archivo;
                    expdecla.RutaImagen  = rutaimagen;
                    expdecla.Incerteza   = Incerteza;
                }

                break;

            case Constante.ASIGNACION:
                if (simbolo.Objeto != null)
                {
                    FExpresion expdecla = (FExpresion)simbolo.Objeto;
                    expdecla.RutaArchivo = archivo;
                    expdecla.RutaImagen  = rutaimagen;
                    expdecla.Incerteza   = Incerteza;
                }
                break;

            case Constante.LLAMADA_FUNCION:

                if (simbolo.Objeto != null)
                {
                    FLlamada fllamada = (FLlamada)simbolo.Objeto;
                    fllamada.RutaArchivo = archivo;
                    fllamada.RutaImagen  = rutaimagen;
                    fllamada.Incerteza   = Incerteza;


                    foreach (FExpresion parametro in fllamada.Parametros)
                    {
                        parametro.RutaArchivo = archivo;
                        parametro.RutaImagen  = rutaimagen;
                        parametro.Incerteza   = Incerteza;
                    }

                    if (fllamada.Ambito != null)
                    {
                        foreach (Simbolo s in fllamada.Ambito.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }
                }


                break;

            case Constante.TRetorno:
                if (simbolo.Objeto != null)
                {
                    FExpresion fretorno = (FExpresion)simbolo.Objeto;
                    fretorno.Incerteza   = Incerteza;
                    fretorno.RutaArchivo = archivo;
                    fretorno.RutaImagen  = rutaimagen;
                }
                break;

            case Constante.TSi:
                if (simbolo.Objeto != null)
                {
                    FSi fsi = (FSi)simbolo.Objeto;
                    fsi.RutaArchivo = archivo;
                    fsi.RutaImagen  = rutaimagen;
                    fsi.Incerteza   = Incerteza;

                    fsi.Condicion.RutaArchivo = archivo;
                    fsi.Condicion.RutaImagen  = rutaimagen;
                    fsi.Condicion.Incerteza   = Incerteza;


                    if (fsi.Sino != null)
                    {
                        foreach (Simbolo s in fsi.Sino.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }
                }
                break;

            case Constante.TSelecciona:
                if (simbolo.Objeto != null)
                {
                    FSelecciona fselecciona = (FSelecciona)simbolo.Objeto;
                    fselecciona.RutaArchivo = archivo;
                    fselecciona.RutaImagen  = rutaimagen;
                    fselecciona.Incerteza   = Incerteza;

                    if (fselecciona.Ambito != null)
                    {
                        foreach (Simbolo s in fselecciona.Ambito.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }

                    if (fselecciona.Expresion != null)
                    {
                        fselecciona.Expresion.RutaArchivo = archivo;
                        fselecciona.Expresion.RutaImagen  = rutaimagen;
                        fselecciona.Expresion.Incerteza   = Incerteza;
                    }

                    if (fselecciona.Casos != null)
                    {
                        foreach (FCaso caso in fselecciona.Casos)
                        {
                            caso.RutaArchivo = archivo;
                            caso.RutaImagen  = rutaimagen;
                            caso.Incerteza   = Incerteza;
                            if (caso.ambito != null)
                            {
                                foreach (Simbolo s in caso.ambito.TablaSimbolo)
                                {
                                    BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                                }
                            }
                        }
                    }

                    if (fselecciona.Defecto != null)
                    {
                        fselecciona.Defecto.RutaArchivo = archivo;
                        fselecciona.Defecto.RutaImagen  = rutaimagen;
                        fselecciona.Defecto.Incerteza   = Incerteza;
                        if (fselecciona.Defecto.ambito != null)
                        {
                            foreach (Simbolo s in fselecciona.Defecto.ambito.TablaSimbolo)
                            {
                                BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                            }
                        }
                    }
                }
                break;

            case Constante.TPara:
                if (simbolo.Objeto != null)
                {
                    FPara fpara = (FPara)simbolo.Objeto;
                    fpara.Incerteza   = Incerteza;
                    fpara.RutaArchivo = archivo;
                    fpara.RutaImagen  = rutaimagen;

                    if (fpara.Condicion != null)
                    {
                        fpara.Condicion.Incerteza   = Incerteza;
                        fpara.Condicion.RutaArchivo = archivo;
                        fpara.Condicion.RutaImagen  = rutaimagen;
                    }

                    if (fpara.Declaracion != null)
                    {
                        foreach (Simbolo s in fpara.ambito.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }
                }
                break;

            case Constante.THasta:
                if (simbolo.Objeto != null)
                {
                    FHasta fhasta = (FHasta)simbolo.Objeto;

                    if (fhasta.Condicion != null)
                    {
                        fhasta.Condicion.Incerteza   = Incerteza;
                        fhasta.Condicion.RutaArchivo = archivo;
                        fhasta.Condicion.RutaImagen  = rutaimagen;
                    }

                    if (fhasta.ambito != null)
                    {
                        foreach (Simbolo s in fhasta.ambito.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }
                }
                break;

            case Constante.TMientras:
                if (simbolo.Objeto != null)
                {
                    FMientras fmientras = (FMientras)simbolo.Objeto;

                    if (fmientras.Condicion != null)
                    {
                        fmientras.Condicion.Incerteza   = Incerteza;
                        fmientras.Condicion.RutaArchivo = archivo;
                        fmientras.Condicion.RutaImagen  = rutaimagen;
                    }

                    if (fmientras.ambito != null)
                    {
                        foreach (Simbolo s in fmientras.ambito.TablaSimbolo)
                        {
                            BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
                        }
                    }
                }
                break;

            case Constante.TDetener:
                if (simbolo.Objeto != null)
                {
                }
                break;

            case Constante.TContinuar:
                if (simbolo.Objeto != null)
                {
                }
                break;

            case Constante.TMostrar:
                if (simbolo.Objeto != null)
                {
                    FMostrar funcion = (FMostrar)simbolo.Objeto;
                    funcion.Incerteza   = Incerteza;
                    funcion.RutaArchivo = archivo;
                    funcion.RutaImagen  = rutaimagen;

                    foreach (FExpresion expmostrar in funcion.Parametros)
                    {
                        expmostrar.Incerteza   = Incerteza;
                        expmostrar.RutaImagen  = rutaimagen;
                        expmostrar.RutaArchivo = archivo;
                    }
                }
                break;

            case Constante.TDibujarAST:
                if (simbolo.Objeto != null)
                {
                    FDibujarAST funcion = (FDibujarAST)simbolo.Objeto;
                    funcion.Incerteza   = Incerteza;
                    funcion.RutaArchivo = archivo;
                    funcion.RutaImagen  = rutaimagen;
                }
                break;

            case Constante.TDibujarEXP:
                if (simbolo.Objeto != null)
                {
                    FDibujarExpresion funcion = (FDibujarExpresion)simbolo.Objeto;
                    funcion.Incerteza   = Incerteza;
                    funcion.RutaArchivo = archivo;
                    funcion.RutaImagen  = rutaimagen;

                    if (funcion.Expresion != null)
                    {
                        funcion.Expresion.Incerteza   = Incerteza;
                        funcion.Expresion.RutaArchivo = archivo;
                        funcion.Expresion.RutaImagen  = rutaimagen;
                    }
                }
                break;
            }

            if (simbolo.Ambito.TablaSimbolo.Count > 0)
            {
                foreach (Simbolo simbolo2 in simbolo.Ambito.TablaSimbolo)
                {
                    BuscarErroresAmbitos(simbolo2, archivo, Incerteza, rutaimagen);
                }
            }
        }
예제 #4
0
        public void EjecutarFuncion(Simbolo simbolo)
        {
            FLlamada  listaparametros = (FLlamada)simbolo.Objeto;
            Variables metodo          = TablaVariables.BuscarMetodo(simbolo.Nombre, listaparametros);

            if (metodo != null)
            {
                FFuncion funcion = (FFuncion)metodo.Valor;
                FLlamada llamada = (FLlamada)simbolo.Objeto;


                if (funcion.Parametros.Count == llamada.Parametros.Count)
                {
                    //metemos el return
                    //Variables retorno = new Variables(Constante.TRetorno, Constante.TRetorno, Constante.RETORNO, null, null, 0, 0);
                    //TablaVariables.Tabla.Add(retorno);
                    int cont = 0;
                    //meter variables de los parametros
                    while (cont < funcion.Parametros.Count && TitusNotifiaciones.ContarErrores() == 0)
                    {
                        FExpresion    f = (FExpresion)llamada.Parametros[cont];
                        NodoExpresion resultadoparametro = f.ResolverExpresion(funcion.Incerteza, funcion.RutaArchivo);
                        if (TitusNotifiaciones.ContarErrores() == 0)
                        {
                            if (funcion.Parametros[cont].Tipo == resultadoparametro.Tipo)
                            {
                                Variables parametro = new Variables(funcion.Parametros[cont].Tipo, funcion.Parametros[cont].Nombre, Constante.TVariable, resultadoparametro, null, simbolo.Fila, simbolo.Columna);
                                TablaVariables.Tabla.Add(parametro);
                            }
                            else
                            {
                                //error de asignacion del tipo de parametro
                                TabError error = new TabError();
                                error.InsertarFila(Constante.ErroEjecucion, "Se esperaba un tipo: " + funcion.Parametros[cont].Tipo + ", no un tipo: " + resultadoparametro.Tipo, funcion.RutaArchivo, resultadoparametro.Linea.ToString(), resultadoparametro.Columna.ToString());
                                TitusNotifiaciones.setDatosErrores(error);
                            }
                        }
                        cont++;
                    }

                    //ejecuatamos el metodo
                    if (TitusNotifiaciones.ContarErrores() == 0)
                    {
                        Ejecutar execute = new Ejecutar();
                        execute.EjecutarInstrucciones(metodo.Ambito.TablaSimbolo);

                        //obtenemos el valor del return

                        if (TablaVariables.IsRetorno())
                        {
                            TablaVariables.SacarVariable();
                        }
                        execute.SacarAmbito(metodo.Ambito.TablaSimbolo);
                        execute.SacarAmbito(funcion.Parametros);
                    }
                }
                else
                {
                    //error de cantidad de parametros
                    TabError error = new TabError();
                    error.InsertarFila(Constante.ErroEjecucion, "La funcion esperaba " + funcion.Parametros.Count + " parametros", funcion.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
                    TitusNotifiaciones.setDatosErrores(error);
                }
            }
            else
            {
                TabError error = new TabError();
                error.InsertarFila(Constante.ErroEjecucion, "No existe la funcion " + simbolo.Nombre + "()", simbolo.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
                TitusNotifiaciones.setDatosErrores(error);
            }
        }
예제 #5
0
        public Object RecorrerArbol(ParseTreeNode Nodo)
        {
            switch (Nodo.Term.Name)
            {
            case Constante.INICIO:
                EjecutarSBS ejecucion = new EjecutarSBS();

                foreach (ParseTreeNodeList hijo in (List <ParseTreeNodeList>)RecorrerArbol(Nodo.ChildNodes[0]))    //enviamos a analizar el encabezado
                {
                    if (hijo[0].Term.Name == Constante.TDefine)
                    {
                        if (hijo[1].Term.Name == "numero")
                        {
                            ejecucion.SetDefineNumber(Double.Parse(hijo[1].Token.ValueString));
                        }
                        else if (hijo[1].Term.Name == Constante.Cadena)
                        {
                            ejecucion.SetDefineRuta((String)hijo[1].Token.Value);
                        }
                    }
                    else if (hijo[0].Term.Name == Constante.TIncluye)
                    {
                        EIncluye incluye = new Encabezado.EIncluye(hijo[1].Token.Text + ".sbs", "");

                        ejecucion.AgregarIncluye(new Simbolo(incluye.Archivo, Constante.TIncluye, Constante.Cadena, hijo[1].Token.Location.Line + 1, hijo[1].Token.Location.Column + 1, null, incluye));
                    }
                }

                Ambito global = new Ambito("Global");    //creamos el ambito global para la ejecucion

                global.Incerteza    = ejecucion.DefineNumber;
                global.RutaImagenes = ejecucion.DefineRuta;
                global.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);   //enviamos a analizar el cuerpo que retornara una lista de simbolos

                //asignamos el ambito padre a las instrucciones
                foreach (Simbolo simbolo in global.TablaSimbolo)
                {
                    if (simbolo.Ambito != null)
                    {
                        simbolo.Ambito.Padre = global;
                    }
                }

                ejecucion.Global = global;
                return(ejecucion);

            case Constante.LISTA_ENCABEZADOS:
                if (Nodo.ChildNodes.Count > 0)
                {
                    return(RecorrerArbol(Nodo.ChildNodes[0]));
                }
                else
                {
                    List <ParseTreeNodeList> vacio = new List <ParseTreeNodeList>();
                    return(vacio);
                }

            case Constante.LISTA_ENCABEZADO:
                List <ParseTreeNodeList> listae = new List <ParseTreeNodeList>();
                foreach (ParseTreeNode hijo in Nodo.ChildNodes)
                {
                    listae.Add((ParseTreeNodeList)RecorrerArbol(hijo));
                }
                return(listae);

            case Constante.ENCABEZADO:
                return(RecorrerArbol(Nodo.ChildNodes[0]));

            case Constante.DEFINE:
                return(Nodo.ChildNodes);

            case Constante.INCLUYE:
                return(Nodo.ChildNodes);

            case Constante.LISTA_SENTENCIA:
                List <Simbolo> listas = new List <Simbolo>();
                foreach (ParseTreeNode hijo in Nodo.ChildNodes)
                {
                    foreach (Simbolo s in (List <Simbolo>)RecorrerArbol(hijo))
                    {
                        listas.Add(s);
                    }
                }
                return(listas);

            case Constante.SENTENCIA:
                return(RecorrerArbol(Nodo.ChildNodes[0]));


            case Constante.PRINCIPAL:

                Ambito ambito = new Ambito(Constante.TPrincipal);
                if (Nodo.ChildNodes.Count > 0)
                {
                    //asignamos el listado de instrucciones al ambito principal
                    if (Nodo.ChildNodes[1].ChildNodes.Count > 0)
                    {
                        ambito.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);
                        //asignamos el ambito padre a la lista de instrucciones
                        foreach (Simbolo simbolo in ambito.TablaSimbolo)
                        {
                            if (simbolo.Ambito != null)
                            {
                                simbolo.Ambito.Padre = ambito;
                            }
                        }
                    }
                }
                List <Simbolo> aux = new List <Simbolo>();
                aux.Add(new Simbolo(Constante.TPrincipal, Constante.TPrincipal, Constante.TPrincipal, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, ambito, null));
                return(aux);

            case Constante.LISTA_INSTRUCCIONES:
                if (Nodo.ChildNodes.Count > 0)
                {
                    return(RecorrerArbol(Nodo.ChildNodes[0]));
                }
                else
                {
                    List <Simbolo> vacio = new List <Simbolo>();
                    return(vacio);
                }

            case Constante.LISTA_INSTRUCCION:
                List <Simbolo> listai = new List <Simbolo>();
                foreach (ParseTreeNode hijo in Nodo.ChildNodes)
                {
                    List <Simbolo> listhijo = (List <Simbolo>)RecorrerArbol(hijo);
                    foreach (Simbolo simbolo in listhijo)
                    {
                        listai.Add(simbolo);
                    }
                }
                return(listai);


            case Constante.INSTRUCCION:
                return(RecorrerArbol(Nodo.ChildNodes[0]));

            case Constante.DECLARACION:
                List <Simbolo> listadecla = new List <Simbolo>();

                foreach (ParseTreeNode id in Nodo.ChildNodes[1].ChildNodes)
                {
                    if (Nodo.ChildNodes.Count == 4)
                    {
                        listadecla.Add(new Simbolo(id.Token.ValueString, Constante.DECLARACION, Nodo.ChildNodes[0].Token.ValueString, id.Token.Location.Line + 1, id.Token.Location.Column + 1, new Ambito(id.Token.ValueString), new FExpresion(Nodo.ChildNodes[3])));
                    }
                    else
                    {
                        listadecla.Add(new Simbolo(id.Token.ValueString, Constante.DECLARACION, Nodo.ChildNodes[0].Token.ValueString, id.Token.Location.Line + 1, id.Token.Location.Column + 1, new Ambito(id.Token.ValueString), null));
                    }
                }

                return(listadecla);


            case Constante.ASIGNACION:
                List <Simbolo> listasigna = new List <Simbolo>();

                listasigna.Add(new Simbolo(Nodo.ChildNodes[0].Token.ValueString, Constante.ASIGNACION, "", Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.ASIGNACION), new FExpresion(Nodo.ChildNodes[2])));

                FExpresion a = (FExpresion)(listasigna[0].Objeto);

                return(listasigna);

            case Constante.FUNCION:
                Ambito   ambitof  = new Ambito(Nodo.ChildNodes[1].Token.ValueString);
                FFuncion ffuncion = new FFuncion();

                //enviamos a recorrer si tiene parametros
                if (Nodo.ChildNodes[2].ChildNodes.Count > 0)
                {
                    foreach (ParseTreeNode hijo in Nodo.ChildNodes[2].ChildNodes[0].ChildNodes)
                    {
                        ffuncion.Parametros.Add(new Simbolo(hijo.ChildNodes[1].Token.ValueString, Constante.DECLARACION, hijo.ChildNodes[0].Token.ValueString, hijo.ChildNodes[1].Token.Location.Line + 1, hijo.ChildNodes[1].Token.Location.Column + 1, new Ambito(hijo.ChildNodes[1].Token.ValueString), null));
                    }
                }


                //asignamos el listado de instrucciones al ambito
                if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
                {
                    ambitof.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3]);
                }
                //asignamos el ambito padre a la lista de instrucciones
                foreach (Simbolo simbolo in ambitof.TablaSimbolo)
                {
                    if (simbolo.Ambito != null)
                    {
                        simbolo.Ambito.Padre = ambitof;
                    }
                }
                List <Simbolo> auxf = new List <Simbolo>();
                ffuncion.Ambito = ambitof;
                auxf.Add(new Simbolo(Nodo.ChildNodes[1].Token.ValueString, Constante.FUNCION, Nodo.ChildNodes[0].Token.ValueString, Nodo.ChildNodes[1].Token.Location.Line + 1, Nodo.ChildNodes[1].Token.Location.Column + 1, ambitof, ffuncion));
                return(auxf);


            case Constante.LLAMADA_FUNCION:
                FLlamada fllamadafuncion = new FLlamada();

                //enviamos a recorrer si tiene parametros
                if (Nodo.ChildNodes[1].ChildNodes.Count > 0)
                {
                    foreach (ParseTreeNode hijo in Nodo.ChildNodes[1].ChildNodes[0].ChildNodes)
                    {
                        fllamadafuncion.Parametros.Add(new FExpresion(hijo));
                    }
                }
                List <Simbolo> listllada = new List <Simbolo>();
                fllamadafuncion.Ambito = new Ambito(Nodo.ChildNodes[0].Token.ValueString);
                listllada.Add(new Simbolo(Nodo.ChildNodes[0].Token.ValueString, Constante.LLAMADA_FUNCION, "", Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fllamadafuncion.Ambito, fllamadafuncion));
                return(listllada);


            case Constante.RETORNO:
                List <Simbolo> listaretorno = new List <Simbolo>();
                if (Nodo.ChildNodes.Count == 2)
                {
                    listaretorno.Add(new Simbolo(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TRetorno), new FExpresion(Nodo.ChildNodes[1])));
                }
                else
                {
                    listaretorno.Add(new Simbolo(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TRetorno), null));
                }
                return(listaretorno);

            case Constante.SI:
                List <Simbolo> listasi = new List <Simbolo>();

                FSi    fsi      = new FSi();
                Ambito ambitosi = new Ambito(Constante.TSi);

                fsi.Condicion = new FExpresion(Nodo.ChildNodes[1]);    //asignamos la condicion
                if (Nodo.ChildNodes[2].ChildNodes.Count > 0)
                {
                    List <Simbolo> listasis = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]);
                    foreach (Simbolo hijo in listasis)
                    {
                        //agregamos el ambito padre que seria el si
                        hijo.Ambito.Padre = ambitosi;
                        //agregamos los simbolos al ambito de si
                        ambitosi.TablaSimbolo.Add(hijo);
                    }
                }

                if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
                {
                    fsi.Sino       = new Ambito(Constante.TSino);
                    fsi.Sino.Padre = ambitosi;
                    List <Simbolo> listasino = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3]);
                    foreach (Simbolo hijo in listasino)
                    {
                        //agregamos el ambito padre que seria el sino
                        hijo.Ambito.Padre = fsi.Sino;
                        //agregamos los simbolos al ambito de sino
                        fsi.Sino.TablaSimbolo.Add(hijo);
                    }
                }
                listasi.Add(new Simbolo(Constante.TSi, Constante.TSi, Constante.TSi, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, ambitosi, fsi));

                return(listasi);

            case Constante.SINO:
                List <Simbolo> listsino = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);
                return(listsino);

            case Constante.SELECCIONA:
                List <Simbolo> listselecciona = new List <Simbolo>();
                FSelecciona    fselecciona    = new FSelecciona();
                //enviamos la expresion
                fselecciona.Expresion = new FExpresion(Nodo.ChildNodes[1]);
                //asignamos la lista de casos
                fselecciona.Casos = (List <FCaso>)RecorrerArbol(Nodo.ChildNodes[2]);
                //comprobamos si hay defecto
                if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
                {
                    List <Simbolo> simbolodefecto = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3].ChildNodes[0].ChildNodes[1]);
                    Ambito         ambitodefecto  = new Ambito(Constante.TDefecto);
                    foreach (Simbolo hijo in simbolodefecto)
                    {
                        hijo.Ambito.Padre = ambitodefecto;
                        ambitodefecto.TablaSimbolo.Add(hijo);
                    }
                    fselecciona.Defecto = new FCaso(ambitodefecto, Constante.TDefecto, "");
                }
                Ambito ambitosele = new Ambito(Constante.TSelecciona);
                fselecciona.Ambito = ambitosele;
                listselecciona.Add(new Simbolo(Constante.TSelecciona, Constante.TSelecciona, Constante.TSelecciona, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fselecciona.Ambito, fselecciona));
                //retornamos la lsita
                return(listselecciona);

            case Constante.LISTA_CASOS:
                List <FCaso> listacaso = new List <FCaso>();
                foreach (ParseTreeNode hijo in Nodo.ChildNodes)
                {
                    listacaso.Add((FCaso)RecorrerArbol(hijo));
                }
                return(listacaso);

            case Constante.CASO:

                Ambito ambitocaso = new Ambito(Constante.TCaso);
                FCaso  caso;
                if (Nodo.ChildNodes[0].ChildNodes[0].Token.Terminal.ErrorAlias == Constante.Numero)
                {
                    caso = new FCaso(ambitocaso, Constante.TNumber, Nodo.ChildNodes[0].ChildNodes[0].Token.ValueString);
                }
                else
                {
                    caso = new FCaso(ambitocaso, Constante.TString, Nodo.ChildNodes[0].ChildNodes[0].Token.ValueString);
                }


                foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]))
                {
                    caso.ambito.TablaSimbolo.Add(hijo);
                }
                return(caso);


            case Constante.PARA:
                List <Simbolo> listapara = new List <Simbolo>();
                FPara          fpara     = new FPara();

                fpara.ambito      = new Ambito(Constante.TPara);
                fpara.Condicion   = new FExpresion(Nodo.ChildNodes[5]);
                fpara.Declaracion = new Simbolo(Nodo.ChildNodes[2].Token.ValueString, Constante.DECLARACION, Constante.TNumber, Nodo.ChildNodes[2].Token.Location.Line + 1, Nodo.ChildNodes[2].Token.Location.Column + 1, new Ambito(Constante.DECLARACION), new FExpresion(Nodo.ChildNodes[4]));
                fpara.Operacion   = Nodo.ChildNodes[6].Token.ValueString;

                foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[7]))
                {
                    hijo.Ambito.Padre = fpara.ambito;
                    fpara.ambito.TablaSimbolo.Add(hijo);
                }
                listapara.Add(new Simbolo(Constante.TPara, Constante.TPara, Constante.TPara, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fpara.ambito, fpara));
                return(listapara);


            case Constante.HASTA:
                List <Simbolo> listahasta = new List <Simbolo>();

                FHasta fhasta = new FHasta();

                fhasta.ambito    = new Ambito(Constante.THasta);
                fhasta.Condicion = new FExpresion(Nodo.ChildNodes[1]);

                foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]))
                {
                    hijo.Ambito.Padre = fhasta.ambito;
                    fhasta.ambito.TablaSimbolo.Add(hijo);
                }
                listahasta.Add(new Simbolo(Constante.THasta, Constante.THasta, Constante.THasta, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fhasta.ambito, fhasta));
                return(listahasta);

            case Constante.MIENTRAS:
                List <Simbolo> listamientras = new List <Simbolo>();

                FMientras fmientras = new FMientras();

                fmientras.ambito    = new Ambito(Constante.THasta);
                fmientras.Condicion = new FExpresion(Nodo.ChildNodes[1]);

                foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]))
                {
                    hijo.Ambito.Padre = fmientras.ambito;
                    fmientras.ambito.TablaSimbolo.Add(hijo);
                }
                listamientras.Add(new Simbolo(Constante.TMientras, Constante.TMientras, Constante.TMientras, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fmientras.ambito, fmientras));
                return(listamientras);

            case Constante.TDetener:
                List <Simbolo> listadetener = new List <Simbolo>();
                listadetener.Add(new Simbolo(Constante.TDetener, Constante.TDetener, Constante.TDetener, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Line + 1, new Ambito(Constante.TDetener), null));
                return(listadetener);

            case Constante.TContinuar:
                List <Simbolo> listacontinuar = new List <Simbolo>();
                listacontinuar.Add(new Simbolo(Constante.TContinuar, Constante.TContinuar, Constante.TContinuar, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Line + 1, new Ambito(Constante.TContinuar), null));
                return(listacontinuar);

            case Constante.FMOSTRAR:
                FMostrar fmostrar = new FMostrar();
                if (Nodo.ChildNodes.Count > 2)
                {
                    foreach (ParseTreeNode hijo in Nodo.ChildNodes[2].ChildNodes)
                    {
                        fmostrar.Parametros.Add(new FExpresion(hijo));
                    }
                }

                fmostrar.Cadena = Nodo.ChildNodes[1].Token.ValueString;
                List <Simbolo> listafmostrar = new List <Simbolo>();
                listafmostrar.Add(new Simbolo(Constante.TMostrar, Constante.TMostrar, Constante.TMostrar, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TMostrar), fmostrar));
                return(listafmostrar);


            case Constante.FDIBUJARAST:
                FDibujarAST fdibujarast = new FDibujarAST();

                fdibujarast.Id = Nodo.ChildNodes[1].Token.ValueString;
                List <Simbolo> listafdibujarast = new List <Simbolo>();
                listafdibujarast.Add(new Simbolo(Constante.TDibujarAST, Constante.TDibujarAST, Constante.TDibujarAST, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TDibujarAST), fdibujarast));

                return(listafdibujarast);

            case Constante.FDIBUJAREXP:
                FDibujarExpresion fdibujarexp = new FDibujarExpresion();

                fdibujarexp.Expresion = new FExpresion(Nodo.ChildNodes[1]);
                List <Simbolo> listafdibujarexp = new List <Simbolo>();
                listafdibujarexp.Add(new Simbolo(Constante.TDibujarEXP, Constante.TDibujarEXP, Constante.TDibujarEXP, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TDibujarEXP), fdibujarexp));
                return(listafdibujarexp);

            default:
                return(null);
            }
        }