示例#1
0
        public static NodoVariable ObtenerVariableSobrecarga(string variable, string metodo, NodoClase claseActual, int linea)
        {
            int cont = 0;


            NodoMetodo     nodoBusqueda       = new NodoMetodo();
            NodoSobrecarga metodoEnSobrecarga = new NodoSobrecarga();
            NodoVariable   variableBuscada    = new NodoVariable();

            nodoBusqueda       = ObtenerMetodo(metodo, claseActual.Lexema);
            cont               = nodoBusqueda.Sobrecarga.Count();
            metodoEnSobrecarga = nodoBusqueda.Sobrecarga.ElementAt(cont - 1);
            variableBuscada    = metodoEnSobrecarga.TSV.FirstOrDefault(x => x.Key == variable).Value;
            if (variableBuscada == null)
            {
                ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no existe en el contexto actual.");
                return(null);
            }
            else
            {
                if (variableBuscada.Valor.Count == 0)
                {
                    ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no ha sido inicializada.");
                    return(null);
                }
                else
                {
                    return(variableBuscada);
                }
            }
        }
示例#2
0
 public static void InsertarParametroSobrecarga(NodoVariable nuevaVariable, NodoSobrecarga metodoActual)
 {
     if (!metodoActual.TSV.ContainsKey(nuevaVariable.Lexema))
     {
         metodoActual.TSV.Add(nuevaVariable.Lexema, nuevaVariable);
     }
     else
     {
         ERRORES.Mensaje("Codigo: 602 Linea:" + nuevaVariable.RenglonDec + " El parametro ya existe en el contexto actual");
     }
 }
示例#3
0
        public static NodoSobrecarga LlenarMetodoSobrecarga(NodoMetodo metodoActual)
        {
            NodoSobrecarga nuevoNodo = new NodoSobrecarga();

            nuevoNodo.LineaDec  = metodoActual.LineaDec;
            nuevoNodo.Lexema    = metodoActual.Lexema;
            nuevoNodo.MiRegreso = metodoActual.MiRegreso;
            nuevoNodo.MiAlcance = metodoActual.MiAlcance;

            return(nuevoNodo);
        }
示例#4
0
        public static void VariableNoReferenciada()
        {
            NodoClase      clase         = new NodoClase();
            NodoMetodo     metodo        = new NodoMetodo();
            NodoSobrecarga sobrecarga    = new NodoSobrecarga();
            NodoVariable   variable      = new NodoVariable();
            bool           conSobrecarga = false;

            for (int contClase = 0; contClase < TSC.Count; contClase++)
            {
                clase = TSC.Values.ElementAt(contClase);
                for (int contMetodo = 0; contMetodo < clase.TSM.Count; contMetodo++)
                {
                    metodo        = clase.TSM.Values.ElementAt(contMetodo);
                    conSobrecarga = metodo.Sobrecarga.Any();
                    for (int contVar = 0; contVar < metodo.TSV.Count; contVar++)
                    {
                        variable = metodo.TSV.Values.ElementAt(contVar);

                        if (variable.Referencias.Count == 0 && variable.EsParametro == false)
                        {
                            ERRORES.Mensaje("Codigo: 602 Linea:" + variable.RenglonDec + " La variable nunca es utilizada.");
                        }
                    }

                    if (conSobrecarga)
                    {
                        for (int contSob = 0; contSob < metodo.Sobrecarga.Count; contSob++)
                        {
                            sobrecarga = metodo.Sobrecarga.ElementAt(contSob);
                            for (int varSob = 0; varSob < sobrecarga.TSV.Count; varSob++)
                            {
                                variable = sobrecarga.TSV.Values.ElementAt(varSob);
                                if (variable.Referencias.Count == 0 && variable.EsParametro == false)
                                {
                                    ERRORES.Mensaje("Codigo: 602 Linea:" + variable.RenglonDec + " La variable nunca es utilizada.");
                                }
                            }
                        }
                    }
                }
            }
        }
示例#5
0
        public static void InsertarVariableSobrecarga(NodoClase claseActual, string metodo, NodoVariable nuevaVariable)
        {
            int            contador   = 0;
            NodoSobrecarga sobrecarga = new NodoSobrecarga();

            if (claseActual.TSM.ContainsKey(metodo))
            {
                NodoMetodo metodoActual = ObtenerMetodo(metodo, claseActual.Lexema);
                contador   = metodoActual.Sobrecarga.Count();
                sobrecarga = metodoActual.Sobrecarga.ElementAt(contador - 1);
                if (!sobrecarga.TSV.ContainsKey(nuevaVariable.Lexema))
                {
                    sobrecarga.TSV.Add(nuevaVariable.Lexema, nuevaVariable);
                }
                else
                {
                    ERRORES.Mensaje("Codigo: 602 Linea:" + nuevaVariable.RenglonDec + " La variable ya existe en el contexto actual.");
                }
            }
        }
示例#6
0
        //------------------------------------------------------Metodos para metodos----------------------------------------------------------------------------------------

        #region Metodos
        public static void InsertarMetodo(NodoMetodo nuevoMetodo, NodoClase claseActual, List <NodoVariable> Parametros)
        {
            List <NodoAtributo> listaExistente = new List <NodoAtributo>();
            List <NodoAtributo> listaNuevo     = new List <NodoAtributo>();
            bool IngresarNodo = true;

            #region Metodo sin sobrecarga
            if (claseActual.Lexema != nuevoMetodo.Lexema)
            {
                if (!claseActual.TSM.ContainsKey(nuevoMetodo.Lexema))
                {
                    foreach (var item in Parametros)
                    {
                        InsertarParametroMetodo(item, nuevoMetodo);
                    }


                    claseActual.TSM.Add(nuevoMetodo.Lexema, nuevoMetodo);
                }
                #endregion
                #region Sobrecarga de metodos
                else
                {
                    int enteros   = 0;
                    int strings   = 0;
                    int booleanos = 0;
                    int decimales = 0;

                    int enteros2   = 0;
                    int strings2   = 0;
                    int booleanos2 = 0;
                    int decimales2 = 0;

                    int enteros3   = 0;
                    int strings3   = 0;
                    int booleanos3 = 0;
                    int decimales3 = 0;


                    NodoMetodo     metodoExistente  = ObtenerMetodo(nuevoMetodo.Lexema, claseActual.Lexema);
                    NodoSobrecarga metodoSobrecarga = new NodoSobrecarga();
                    bool           nodosEnLista     = metodoExistente.Sobrecarga.Any();
                    if (nodosEnLista)
                    {
                        int contador = metodoExistente.sobrecarga.Count;
                        for (int a = 0; a < metodoExistente.TSV.Count; a++)
                        {
                            NodoVariable parExistente = metodoExistente.TSV.ElementAt(a).Value;
                            switch (parExistente.MiTipo)
                            {
                            case "int":
                                enteros++;
                                break;

                            case "string":
                                strings++;
                                break;

                            case "double":
                                decimales++;
                                break;
                            }
                        }
                        for (int a = 0; a < Parametros.Count; a++)
                        {
                            NodoVariable parNuevo = Parametros.ElementAt(a);
                            switch (parNuevo.MiTipo)
                            {
                            case "int":
                                enteros2++;
                                break;

                            case "string":
                                strings2++;
                                break;

                            case "double":
                                decimales2++;
                                break;
                            }
                        }


                        for (int g = 0; g < contador; g++)
                        {
                            NodoVariable   parExistente    = new NodoVariable();
                            NodoSobrecarga nuevoSobrecarga = metodoExistente.sobrecarga.ElementAt(g);
                            enteros3   = 0;
                            strings3   = 0;
                            booleanos3 = 0;
                            decimales3 = 0;
                            for (int h = 0; h < nuevoSobrecarga.TSV.Count; h++)
                            {
                                parExistente = nuevoSobrecarga.TSV.ElementAt(h).Value;
                                switch (parExistente.MiTipo)
                                {
                                case "int":
                                    enteros3++;
                                    break;

                                case "string":
                                    strings3++;
                                    break;

                                case "double":
                                    decimales3++;
                                    break;
                                }
                            }//



                            if (enteros == enteros2 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros2 && enteros2 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings2 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales2 > 0 && Parametros.Count == metodoExistente.TSV.Count)
                            {
                                IngresarNodo = false;
                                ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");


                                enteros   = 0;
                                strings   = 0;
                                booleanos = 0;
                                decimales = 0;

                                enteros2   = 0;
                                strings2   = 0;
                                booleanos2 = 0;
                                decimales2 = 0;

                                enteros3   = 0;
                                strings3   = 0;
                                booleanos3 = 0;
                                decimales3 = 0;
                            }
                            if (enteros == enteros3 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros3 && enteros3 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings3 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings3 && strings3 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales3 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales3 && decimales3 > 0 && Parametros.Count == metodoExistente.TSV.Count)
                            {
                                IngresarNodo = false;
                                ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");

                                enteros   = 0;
                                strings   = 0;
                                booleanos = 0;
                                decimales = 0;

                                enteros2   = 0;
                                strings2   = 0;
                                booleanos2 = 0;
                                decimales2 = 0;


                                enteros3   = 0;
                                strings3   = 0;
                                booleanos3 = 0;
                                decimales3 = 0;
                            }

                            if (Parametros.Count == nuevoSobrecarga.TSV.Count && enteros3 == enteros2 && strings3 == strings2 && decimales3 == decimales2)
                            {
                                ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");
                                IngresarNodo = false;

                                enteros   = 0;
                                strings   = 0;
                                booleanos = 0;
                                decimales = 0;

                                enteros2   = 0;
                                strings2   = 0;
                                booleanos2 = 0;
                                decimales2 = 0;


                                enteros3   = 0;
                                strings3   = 0;
                                booleanos3 = 0;
                                decimales3 = 0;
                            }
                        }
                        #endregion
                        #region IngresarNodo es true
                        if (IngresarNodo)
                        {
                            NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
                            foreach (var item in Parametros)
                            {
                                InsertarParametroSobrecarga(item, metodoCarga);
                            }
                            metodoExistente.Sobrecarga.Add(metodoCarga);
                            enteros   = 0;
                            strings   = 0;
                            booleanos = 0;
                            decimales = 0;

                            enteros2   = 0;
                            strings2   = 0;
                            booleanos2 = 0;
                            decimales2 = 0;


                            enteros3   = 0;
                            strings3   = 0;
                            booleanos3 = 0;
                            decimales3 = 0;
                        }
                        #endregion
                        #region Comparar solo dos metodos, el actual y el entrante sin sobrecarga
                    }
                    else if (metodoExistente.TSV.Count == 0 && Parametros.Count == 0)
                    {
                        ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo ya existe en el contexto actual");
                    }
                    else if (metodoExistente.TSV.Count == Parametros.Count)
                    {
                        for (int a = 0; a < metodoExistente.TSV.Count; a++)
                        {
                            NodoVariable parExistente = metodoExistente.TSV.ElementAt(a).Value;
                            switch (parExistente.MiTipo)
                            {
                            case "int":
                                enteros++;
                                break;

                            case "string":
                                strings++;
                                break;

                            case "double":
                                decimales++;
                                break;
                            }
                        }

                        for (int a = 0; a < Parametros.Count; a++)
                        {
                            NodoVariable parNuevo = Parametros.ElementAt(a);
                            switch (parNuevo.MiTipo)
                            {
                            case "int":
                                enteros2++;
                                break;

                            case "string":
                                strings2++;
                                break;

                            case "double":
                                decimales2++;
                                break;
                            }
                        }


                        if (enteros == enteros2 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros2 && enteros2 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings2 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales2 > 0 && Parametros.Count == metodoExistente.TSV.Count)
                        {
                            ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo ya existe en el contexto actual");
                            MessageBox.Show("El metodo ya existe en el contexto actual");
                            enteros   = 0;
                            strings   = 0;
                            booleanos = 0;
                            decimales = 0;

                            enteros2   = 0;
                            strings2   = 0;
                            booleanos2 = 0;
                            decimales2 = 0;
                        }
                        else
                        {
                            NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
                            foreach (var item in Parametros)
                            {
                                InsertarParametroSobrecarga(item, metodoCarga);
                            }
                            metodoExistente.Sobrecarga.Add(metodoCarga);
                            enteros   = 0;
                            strings   = 0;
                            booleanos = 0;
                            decimales = 0;

                            enteros2   = 0;
                            strings2   = 0;
                            booleanos2 = 0;
                            decimales2 = 0;
                        }
                    }
                    else
                    {
                        NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
                        foreach (var item in Parametros)
                        {
                            InsertarParametroSobrecarga(item, metodoCarga);
                        }
                        metodoExistente.Sobrecarga.Add(metodoCarga);
                    }
                }
            }
            else
            {
                ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo no puede llamarse igual que la clase.");
            }
            #endregion
        }