public override void ValidSemantic()
        {
            foreach (var stack in ContenidoStack.InstanceStack.Stack)
            {
                if (stack.VariableExist(identificador.identificador))
                {
                    throw new SintanticoException("variable " + identificador.identificador + " existe fila " + identificador._TOKEN.Fila + " colunma" + identificador._TOKEN.Columna);
                }
            }
            List <TiposBases> listaParametros = new List <TiposBases>();

            if (paramentros != null)
            {
                foreach (var lista in paramentros)
                {
                    if (lista is YporBitStamentNode)
                    {
                        Type        fieldsType            = typeof(YporBitStamentNode);
                        FieldInfo[] fields                = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
                        var         identificadorNode     = fields[1].GetValue(lista);
                        var         identificadorOperando = identificadorNode.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
                        var         tipo       = identificadorOperando[3].GetValue(identificadorNode);
                        var         referencia = new YreferenciaTipo();
                        referencia.tipoReferencia = obtenerTipo((string)tipo);
                        listaParametros.Add(referencia);
                    }
                    if (lista is Identificador.IdentificadorStamNode)
                    {
                        Type        fieldsType          = typeof(Identificador.IdentificadorStamNode);
                        FieldInfo[] fields              = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
                        var         tipo                = fields[3].GetValue(lista);
                        var         referenciaApuntador = fields[1].GetValue(lista);
                        if (referenciaApuntador != null)
                        {
                            var apuntador = new MulpilicadorOperdadorReferenciaTipo();
                            apuntador.tipoReferencia = obtenerTipo((string)tipo);
                            listaParametros.Add(apuntador);
                        }
                        else
                        {
                            listaParametros.Add(obtenerTipo((string)tipo));
                        }
                    }
                    if (lista is Identificador.IdentificadorArrayNode)
                    {
                        Type        fieldsType  = typeof(Identificador.IdentificadorArrayNode);
                        FieldInfo[] fields      = fieldsType.GetFields(BindingFlags.Public | BindingFlags.Instance);
                        var         declaracion = fields[0].GetValue(lista);

                        var tipo          = declaracion.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
                        var puntero       = tipo[1].GetValue(declaracion);
                        var unidimesional = fields[1].GetValue(lista);
                        var bidimesional  = fields[2].GetValue(lista);
                        var array         = new ArrayTipo();
                        array.tipo           = obtenerTipo((string)tipo[0].GetValue(declaracion));
                        array.unidimensional = (unidimesional != null)?true:false;
                        array.bidimensional  = (bidimesional != null) ? true : false;

                        if (puntero != null)
                        {
                            var apuntador = new MulpilicadorOperdadorReferenciaTipo();
                            apuntador.tipoReferencia = array;
                            listaParametros.Add(apuntador);
                        }
                        else
                        {
                            listaParametros.Add(array);
                        }
                    }
                }
            }

            if (identificador.tipo == "void")
            {
                var funcion = new VoidTipo();
                if (paramentros != null)
                {
                    funcion.listaParametros = listaParametros;
                }

                ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
            }
            else
            {
                var funcion = new FuncionTipo();
                if (paramentros != null)
                {
                    funcion.listaParametros = listaParametros;
                }
                funcion.retorno = obtenerTipo(identificador.tipo);
                ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
            }
            ContenidoStack.InstanceStack.Stack.Push(new TablaSimbolos());
            if (paramentros != null)
            {
                foreach (var lista in paramentros)
                {
                    lista.ValidSemantic();
                }
            }
            if (declaracionDeFuncion.Count != 0)
            {
                foreach (var lista in declaracionDeFuncion)
                {
                    if (identificador.tipo == "void")
                    {
                        if (lista is ReturnNode)
                        {
                            throw new SemanticoException("la funcion " + identificador.identificador + " es una funcion void y no es de retorno");
                        }
                    }

                    lista.ValidSemantic();
                }
                if (!(declaracionDeFuncion.Last() is ReturnNode))
                {
                    throw new SemanticoException("la funcion " + identificador.identificador + " debe tener una funcion de retorno ");
                }
            }
            ContenidoStack.InstanceStack.Stack.Pop();
        }
        public override void ValidSemantic()
        {
            foreach (var stack in ContenidoStack.InstanceStack.Stack)
            {
                if (stack.VariableExist(identificador.identificador))
                {
                    throw new SintanticoException("variable " + identificador.identificador + " existe fila " + identificador._TOKEN.Fila + " colunma" + identificador._TOKEN.Columna);
                }
            }

            Dictionary <string, TiposBases> listaParametros = new Dictionary <string, TiposBases>();

            if (paramentros != null)
            {
                foreach (var lista in paramentros)
                {
                    if (lista is YporBitStamentNode)
                    {
                        var identificadorNode = (lista as YporBitStamentNode).OperandoStament;
                        var tipo       = (identificadorNode as IdentificadorStamNode).tipo;
                        var referencia = new YreferenciaTipo();
                        referencia.tipoReferencia = obtenerTipo(tipo);
                        listaParametros.Add((identificadorNode as IdentificadorStamNode).value, referencia);
                    }
                    if (lista is IdentificadorStamNode)
                    {
                        var tipo = (lista as IdentificadorStamNode).tipo;
                        var referenciaApuntador = (lista as IdentificadorStamNode).pointer;
                        if (referenciaApuntador != null)
                        {
                            var apuntador = new MulpilicadorOperdadorReferenciaTipo();
                            apuntador.tipoReferencia = obtenerTipo((string)tipo);
                            listaParametros.Add((lista as IdentificadorStamNode).value, apuntador);
                        }
                        else
                        {
                            listaParametros.Add((lista as IdentificadorStamNode).value, obtenerTipo(tipo));
                        }
                    }
                    if (lista is IdentificadorArrayNode)
                    {
                        var declaracion = (lista as IdentificadorArrayNode).identificador;

                        var tipo          = (declaracion as GeneralDeclarationNode).tipo;
                        var puntero       = (declaracion as GeneralDeclarationNode).pointer;
                        var unidimesional = (lista as IdentificadorArrayNode).unidimesionarioArray;
                        var bidimesional  = (lista as IdentificadorArrayNode).BidimesionarioArray;
                        var array         = new ArrayTipo();
                        array.tipo           = obtenerTipo(tipo);
                        array.unidimensional = (unidimesional != null)?true:false;
                        array.bidimensional  = (bidimesional != null) ? true : false;

                        if (puntero != null)
                        {
                            var apuntador = new MulpilicadorOperdadorReferenciaTipo();
                            apuntador.tipoReferencia = array;
                            listaParametros.Add((declaracion as GeneralDeclarationNode).identificador, apuntador);
                        }
                        else
                        {
                            listaParametros.Add((declaracion as GeneralDeclarationNode).identificador, array);
                        }
                    }
                }
            }

            if (identificador.tipo == "void")
            {
                var funcion = new VoidTipo();
                if (paramentros != null)
                {
                    funcion.listaParametros = listaParametros;
                }
                if (declaracionDeFuncion != null)
                {
                    funcion.sentencias = declaracionDeFuncion;
                }
                ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
            }
            else
            {
                var funcion = new FuncionTipo();
                if (paramentros != null)
                {
                    funcion.listaParametros = listaParametros;
                }
                funcion.retorno    = obtenerTipo(identificador.tipo);
                funcion.sentencias = declaracionDeFuncion;
                ContenidoStack.InstanceStack.Stack.Peek().DeclareVariable(identificador.identificador, funcion);
            }
            ContenidoStack.InstanceStack.Stack.Push(new TablaSimbolos());
            if (paramentros != null)
            {
                foreach (var lista in paramentros)
                {
                    lista.ValidSemantic();
                }
            }
            if (declaracionDeFuncion.Count != 0)
            {
                foreach (var lista in declaracionDeFuncion)
                {
                    if (identificador.tipo == "void")
                    {
                        if (lista is ReturnNode)
                        {
                            throw new SemanticoException("la funcion " + identificador.identificador + " es una funcion void y no es de retorno");
                        }
                    }

                    lista.ValidSemantic();
                }
                if (identificador.tipo != "void")
                {
                    if (!(declaracionDeFuncion[declaracionDeFuncion.Count - 1] is ReturnNode))
                    {
                        throw new SemanticoException("la funcion " + identificador.identificador + " debe tener una funcion de retorno ");
                    }
                }
            }
            ContenidoStack.InstanceStack.Stack.Pop();
        }