Esempio n. 1
0
 private void EscribirMain( EscritorC escritor )
 {
     escritor.WriteLine( "int main()" );
     escritor.AbrirCorchetes();
     if( ContarCantInstrucciones )
     {
         escritor.WriteLine( "/*-----Archivo para contar instrucciones-------*/" );
         escritor.WriteLine( "fs = fopen(\" " + ArchivoCuentaInstrucciones + "\", \"w\");" );
         escritor.If( "!fs" );
         escritor.PrintfNoSePudoAbrirElArchivo( ArchivoCuentaInstrucciones );
         escritor.FinIf();
     }
     escritor.WriteLine( "/*------------Parametros-------------------------*/" );
     escritor.WriteLine( "int cantErrores = 0;" );
     escritor.WriteLine( "/*------------Llamada a pruebas------------------*/" );
     foreach( Prueba prueba in Pruebas )
     {
         if( FrenarEnElPrimerError )
             escritor.If( "cantErrores == 0" );
         escritor.WriteLine( "cantErrores = " + prueba.Nombre + "();" );
         if( FrenarEnElPrimerError )
             escritor.FinIf();
     }
     if( ContarCantInstrucciones )
         escritor.WriteLine( "fclose(fs);" );
     escritor.PrintfPruebasConcluidas();
     escritor.WriteLine( "return 0;" );
     escritor.CerrarCorchetes();
 }
Esempio n. 2
0
 public override void LiberarMemoria(EscritorC escritor)
 {
     escritor.WriteLine("salidaFree2 = free2( " + Definicion.Nombre + " );");
     escritor.If("salidaFree2 == escrituraFueraDelBuffer");
     escritor.PrintfEscrituraFueraDelBuffer(Definicion.Nombre);
     escritor.WriteLine("cantErrores++;");
     escritor.FinIf();
     escritor.If("salidaFree2 == liberarPosMemNoValida");
     escritor.PrintfCambioDeDireccionDelPuntero(Definicion.Nombre);
     escritor.WriteLine("cantErrores++;");
     escritor.FinIf();
     escritor.If("salidaFree2 == dosFreeDelMismoBuffer");
     escritor.PrintfDosFreeAlMismoParam(Definicion.Nombre);
     escritor.WriteLine("cantErrores++;");
     escritor.FinIf();
 }
Esempio n. 3
0
        public override void LiberarMemoria(EscritorC escritor)
        {
            string pedido;
            string varFila = Definicion.Nombre + "Fila";

            //Libera cada una de las filas
            escritor.For(varFila + " = 0", varFila + " < " + cantFilas, varFila + "++");
            escritor.WriteLine("salidaFree2 = free2( " + Definicion.Nombre + "[" + varFila + "] );");
            escritor.If("salidaFree2 == escrituraFueraDelBuffer");
            escritor.PrintfEscrituraFueraDelBufferEnFilaDeMatriz(Definicion.Nombre, varFila);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();
            escritor.If("salidaFree2 == liberarPosMemNoValida");
            escritor.PrintfCambioDeDireccionDelPunteroEnFilaDeMatriz(Definicion.Nombre, varFila);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();
            escritor.If("salidaFree2 == dosFreeDelMismoBuffer");
            escritor.PrintfDosFreeAlMismoParamEnFilaDeMatriz(Definicion.Nombre, varFila);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();

            escritor.FinFor();

            //Libera el arreglo de punteros
            escritor.WriteLine("salidaFree2 = free2( " + Definicion.Nombre + " );");
            escritor.If("salidaFree2 == escrituraFueraDelBuffer");
            escritor.PrintfEscrituraFueraDelBuffer(Definicion.Nombre);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();
            escritor.If("salidaFree2 == liberarPosMemNoValida");
            escritor.PrintfCambioDeDireccionDelPuntero(Definicion.Nombre);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();
            escritor.If("salidaFree2 == dosFreeDelMismoBuffer");
            escritor.PrintfDosFreeAlMismoParam(Definicion.Nombre);
            escritor.WriteLine("cantErrores++;");
            escritor.FinIf();
        }
Esempio n. 4
0
        private void EscribirFuncionDePrueba( EscritorC escritor )
        {
            escritor.WriteLine( PruebaActual.Prototipo );
            escritor.AbrirCorchetes();
            escritor.WriteLine( "//------------Variables comunes------------------" );
            escritor.WriteLine( "int salidaFree2;" );
            escritor.WriteLine( "long long tiempoDeEjecucion=0;" );
            escritor.WriteLine( "long long tiempo = 0;" );
            escritor.WriteLine( "int cantCorridas = 100;" );
            escritor.WriteLine( "//------------Parametros-------------------------" );
            PruebaActual.DeclararParametros( escritor );
            escritor.WriteLine( "int cantErrores = 0;" );
            if( !ContarCantInstrucciones )
            {
                escritor.WriteLine( "//------------Pedir memoria----------------------" );
                PruebaActual.PedirMemoria( escritor );
                escritor.WriteLine( "//------------Instanciacion----------------------" );
                PruebaActual.InstanciarParametros( escritor );
                escritor.WriteLine( "//------------LlamadaFuncion---------------------" );
                LlamarFuncionAProbar( escritor );
                escritor.WriteLine( "//------------Comparacion de valores-------------" );
                PruebaActual.CompararValoresDevueltos( escritor );
                escritor.WriteLine( "//------------Liberar memoria--------------------" );
                PruebaActual.LiberarMemoria( escritor );
                //Libera la memoria que pidió y verifica que no se haya escrito fuera del buffer.
                escritor.WriteLine( "//------------Informar cant. de errores----------" );
            }
            else
            {
                escritor.WriteLine( "//------------Cuento instrucciones--------------------" );
                escritor.While( "tiempoDeEjecucion < 10000" );
                escritor.WriteLine( "tiempoDeEjecucion = 0;" );
                escritor.WriteLine( "int i;" );
                escritor.For( "i =0", "i<cantCorridas", "i++" );
                escritor.WriteLine( "//------------Pedir memoria----------------------" );
                PruebaActual.PedirMemoria( escritor );
                escritor.WriteLine( "//------------Instanciacion----------------------" );
                PruebaActual.InstanciarParametros( escritor );
                escritor.WriteLine( "tiempo = timer();" );
                LlamarFuncionAProbar( escritor );
                escritor.WriteLine( "tiempoDeEjecucion += timer() - tiempo;" );
                escritor.WriteLine( "//------------Liberar memoria--------------------" );
                PruebaActual.LiberarMemoria( escritor );
                escritor.FinWhile();
                escritor.WriteLine( "cantCorridas *=10;" );
                escritor.FinFor();
                escritor.WriteLine( "tiempoDeEjecucion = tiempoDeEjecucion / cantCorridas;" );
                escritor.WriteLine();
                escritor.WriteLine( "//---Escribo en archivo la cant de inst.----------" );
                escritor.If( "fs" );
                escritor.Write( "fprintf( fs, \"" );
                foreach( Parametro param in PruebaActual.ParametrosEntrada )
                {
                    param.TamanioOValorParaMedicion( escritor );
                    escritor.Write( "\\t" );
                }
                escritor.WriteLine( "%d\\n\", tiempoDeEjecucion);" );
                escritor.FinIf();
            }

            escritor.PrintfPruebaConcluida();
            escritor.WriteLine( "return cantErrores;" );
            escritor.CerrarCorchetes();
        }
Esempio n. 5
0
        public override void CompararValor(EscritorC escritor)
        {
            escritor.WriteLine("//" + Definicion.Nombre);
            switch (Definicion.Tipo)
            {
            case Tipo.UInt8:
            case Tipo.Int8:
            case Tipo.Char:
                escritor.WriteLine("struct Listachar *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearchar(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarchar(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*escritor.If("TienePunterosInvalidoschar(" + Definicion.Nombre + ")");
                 * escritor.PrintPunterosInvalidos();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 * escritor.If("ListaCircularchar(" + Definicion.Nombre + ")");
                 * escritor.PrintListaCircular();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 */
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularchar(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");

                escritor.If("!igualdadchar(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux)");
                escritor.WriteLine("   cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Int16:
            case Tipo.UInt16:
                escritor.WriteLine("struct Listashort *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearshort(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarshort(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*                    escritor.If("TienePunterosInvalidosshort(" + Definicion.Nombre + ")");
                 *                  escritor.PrintPunterosInvalidos();
                 *                  escritor.WriteLine("return 1;");
                 *                  escritor.FinIf();
                 *                  escritor.If("ListaCircularshort(" + Definicion.Nombre + ")");
                 *                  escritor.PrintListaCircular();
                 *                  escritor.WriteLine("return 1;");
                 *                  escritor.FinIf();*/
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularshort(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdadshort(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux)");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.UInt32:
            case Tipo.Int32:
                escritor.WriteLine("struct Listaint *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearint(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarint(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*escritor.If("TienePunterosInvalidosint(" + Definicion.Nombre + ")");
                 * escritor.PrintPunterosInvalidos();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 * escritor.If("ListaCircularint(" + Definicion.Nombre + ")");
                 * escritor.PrintListaCircular();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();*/
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularint(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdadint(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux)");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Booleano:
                escritor.WriteLine("struct Listabool *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearbool(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarbool(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*escritor.If("TienePunterosInvalidosbool(" + Definicion.Nombre + ")");
                 * escritor.PrintPunterosInvalidos();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 * escritor.If("ListaCircularbool(" + Definicion.Nombre + ")");
                 * escritor.PrintListaCircular();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();*/
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularbool(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdadbool(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux)");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.UInt64:
            case Tipo.Int64:
                escritor.WriteLine("struct Listalonglong *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearlonglong(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarlonglong(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularlonglong(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdadlonglong(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux)");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Float32:
                escritor.WriteLine("struct Listafloat *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("crearfloat(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertarfloat(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*escritor.If("TienePunterosInvalidosfloat(" + Definicion.Nombre + ")");
                 * escritor.PrintPunterosInvalidos();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 * escritor.If("ListaCircularfloat(" + Definicion.Nombre + ")");
                 * escritor.PrintListaCircular();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();*/
                escritor.WriteLine("switch(PunteroInvalidoOListaCircularfloat(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdadfloat(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux," + Definicion.Precision + ")");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Float64:
                escritor.WriteLine("struct Listadouble *" + Definicion.Nombre + "listaaux;");
                escritor.WriteLine("creardouble(&" + Definicion.Nombre + "listaaux);");
                foreach (Elem elemento in Elementos)
                {
                    escritor.WriteLine("insertardouble(&" + Definicion.Nombre + "listaaux, " + elemento.Valor + ", false);");
                }

                /*escritor.If("TienePunterosInvalidosdouble(" + Definicion.Nombre + ")");
                 * escritor.PrintPunterosInvalidos();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();
                 * escritor.If("ListaCirculardouble(" + Definicion.Nombre + ")");
                 * escritor.PrintListaCircular();
                 * escritor.WriteLine("return 1;");
                 * escritor.FinIf();*/
                escritor.WriteLine("switch(PunteroInvalidoOListaCirculardouble(" + Definicion.Nombre + ")){");
                escritor.WriteLine("case listaCircular:");
                escritor.PrintListaCircular();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("case punteroInvalido:");
                escritor.PrintPunterosInvalidos();
                escritor.WriteLine("return 1;");
                escritor.WriteLine("}");
                escritor.If("!igualdaddouble(" + Definicion.Nombre + ", " + Definicion.Nombre + "listaaux, " + Definicion.Precision + ")");
                escritor.WriteLine("    cantErrores++;");
                escritor.FinIf();
                break;

            default:
                throw new Exception(Mensajes.TipoIncorrectoListas);
            }
        }
Esempio n. 6
0
        public void CompararValor(EscritorC escritor, string variable)
        {
            //(!this.EsDeSalidaOEntradaSalida);
            string diferencia   = "AUX" + variable;
            string varPrecision = "PR" + variable;
            string iterador     = "IT" + variable;

            switch (Definicion.Tipo)
            {
            case Tipo.UInt8:
            case Tipo.UInt16:
            case Tipo.UInt32:
            case Tipo.UInt64:
            case Tipo.Int8:
            case Tipo.Int16:
            case Tipo.Int32:
            case Tipo.Int64:
                escritor.If(variable + " != " + Valor);
                escritor.PrintfValorDistintoConDiferencia(variable, Valor);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Char:
                escritor.If(variable + " != " + "'" + Valor + "'");
                escritor.PrintfValorDistintoChar(variable, Valor);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Booleano:
                escritor.If("(" + variable + " == " + "0 && " + Valor + "!=0)||(" + variable + " != " +
                            "0 && " + Valor + "==0)");
                escritor.PrintfValorDistinto(variable, Valor);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Float32:
                // Realiza la resta entre ambos operandos y si la misma dio un resultado menor que
                // 10^precision entonces los considera iguales
                MA.EliminarAsteriscos(ref diferencia);
                MA.EliminarCorchetes(ref diferencia);
                MA.EliminarAsteriscos(ref varPrecision);
                MA.EliminarCorchetes(ref varPrecision);

                escritor.WriteLine("float " + diferencia + " = (" + variable + ") - (" + Valor + ");");
                escritor.WriteLine(diferencia + " = (" + diferencia + " >= 0) ? " + diferencia + " : -" +
                                   diferencia + ";");
                escritor.WriteLine("float " + varPrecision + " = pow((float)10, -" + Definicion.Precision + ");");
                escritor.If(diferencia + " >= " + varPrecision);
                escritor.PrintfValorDistintoFloatConDiferencia(variable, Valor, diferencia);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.Float64:
                MA.EliminarAsteriscos(ref diferencia);
                MA.EliminarCorchetes(ref diferencia);
                MA.EliminarAsteriscos(ref varPrecision);
                MA.EliminarCorchetes(ref varPrecision);

                escritor.WriteLine("float " + diferencia + " = (" + variable + ") - (" + Valor + ");");
                escritor.WriteLine(diferencia + " = (" + diferencia + " >= 0) ? " + diferencia + " : -" +
                                   diferencia + ";");
                escritor.WriteLine("double " + varPrecision + " = pow((double)10, -" + Definicion.Precision + ");");
                escritor.If(diferencia + " >= " + varPrecision);
                escritor.PrintfValorDistintoFloatConDiferencia(variable, Valor, diferencia);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                break;

            case Tipo.CadenaC:
                escritor.WriteLine("char " + diferencia + "[] = \"" + Valor + "\";");
                escritor.WriteLine("int " + iterador + ";");
                escritor.For(iterador + "=0", diferencia + "[" + iterador + "]!=0 && " +
                             variable + "[" + iterador + "]!=0", iterador + "++");
                escritor.If(variable + "[" + iterador + "] != " + diferencia + "[" +
                            iterador + "]");
                escritor.PrintfValorDeStringDistintos(variable, iterador, diferencia);
                escritor.WriteLine("cantErrores++;");
                escritor.FinIf();
                escritor.FinFor();
                break;

            case Tipo.CadenaPascal:
                break;
            }
        }