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();
}
public override void CompararValor(EscritorC escritor)
{
string variable = string.Empty;
escritor.WriteLine("//" + Definicion.Nombre);
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:
case Tipo.Char:
case Tipo.Booleano:
case Tipo.Float32:
case Tipo.Float64:
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
variable = "*";
}
break;
case Tipo.CadenaC:
case Tipo.CadenaPascal:
break;
}
variable += Definicion.Nombre;
CompararValor(escritor, variable);
}
public override void Declarar(EscritorC escritor)
{
string declaracion = Definicion.ObtenerNombreDelTipoParaC() + " ";
declaracion += "*" + Definicion.Nombre + ";";
escritor.WriteLine(declaracion);
}
public override void Instanciar(EscritorC escritor)
{
string instanciacion = string.Empty;
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:
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
instanciacion = "*";
}
instanciacion += Definicion.Nombre + " = " + Valor + ";";
break;
case Tipo.Float32:
case Tipo.Float64:
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
instanciacion = "*";
}
instanciacion += Definicion.Nombre + " = 0;\n";
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
instanciacion += "*";
}
instanciacion += Definicion.Nombre + " += " + Valor + ";";
break;
case Tipo.CadenaPascal:
case Tipo.CadenaC:
instanciacion = Definicion.ObtenerNombreDelTipoParaC() + " " + Definicion.Nombre + "[] = \"" + Valor +
"\";";
break;
case Tipo.Booleano:
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
instanciacion = "*";
}
instanciacion += Definicion.Nombre + " = " + (UltimoElementoUno()? "true;" : "false;");
break;
case Tipo.Char:
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
instanciacion = "*";
}
instanciacion += Definicion.Nombre + " = '" + Valor + "';";
break;
}
escritor.WriteLine(instanciacion);
}
public override void PedirMemoria(EscritorC escritor)
{
string pedido;
int cantMemoria;
cantMemoria = Longitud * MA.CuantosBytes(Definicion.Tipo);
pedido = Definicion.Nombre + " = " + "malloc2( " + cantMemoria + " ,true);";
escritor.WriteLine(pedido);
}
private void EscribirFuncionesDePrueba( EscritorC escritor )
{
pruebaActual = 0;
foreach( Prueba prueba in Pruebas )
{
Mensajes.NombreDePrueba = prueba.Nombre;
EscribirFuncionDePrueba( escritor );
pruebaActual++;
}
}
public void DeclararParametros(EscritorC escritor)
{
if (ParametrosSalida[0].Definicion.Tipo != Tipo.Void)
{
ParametrosSalida[0].Declarar(escritor);
}
foreach (Parametro param in ParametrosEntrada)
{
param.Declarar(escritor);
}
}
public void InstanciarParametros(EscritorC escritor)
{
//Instancio el valor de cada uno de los parametros de entrada que no son de salida para pasarselo a la función.
foreach (Parametro param in ParametrosEntrada)
{
if (param.Definicion.EntradaSalida != EntradaSalida.S)
{
param.Instanciar(escritor);
}
}
}
public void PedirMemoria(EscritorC escritor)
{
//Pido memoria para todos los parametros de referencia.
foreach (Parametro param in ParametrosEntrada)
{
if (param.Definicion.EntradaSalida != EntradaSalida.S && param.Definicion.TipoDeAcceso == ValorOReferencia.R)
{
param.PedirMemoria(escritor);
}
}
}
public override void Instanciar(EscritorC escritor)
{
string instanciacion;
int i = 0;
foreach (Elem elemento in Elementos)
{
instanciacion = Definicion.Nombre + "[" + i + "] = " + elemento.Valor + ";";
escritor.WriteLine(instanciacion);
i++;
}
}
public override void PedirMemoria(EscritorC escritor)
{
string pedido;
int cantMemoria;
if (Definicion.Tipo != Tipo.CadenaC && Definicion.Tipo != Tipo.CadenaPascal)
{
cantMemoria = MA.CuantosBytes(Definicion.Tipo);
pedido = Definicion.Nombre + " = " + "malloc2( " + cantMemoria + ",true );";
escritor.WriteLine(pedido);
}
}
public override void PedirMemoria(EscritorC escritor)
{
string pedido;
string varFila = Definicion.Nombre + "Fila";
pedido = Definicion.Nombre + " = " + "malloc2( sizeof(" + Definicion.ObtenerNombreDelTipoParaC() + "*)*" +
cantFilas + ", true );";
escritor.WriteLine(pedido);
escritor.WriteLine("int " + varFila + ";");
escritor.For(varFila + " = 0", varFila + " < " + cantFilas, varFila + "++");
escritor.WriteLine(Definicion.Nombre + "[" + varFila + "] = malloc2( sizeof(" +
Definicion.ObtenerNombreDelTipoParaC() + ")*" + cantColumnas + ", true);");
escritor.FinFor();
}
public override void Declarar(EscritorC escritor)
{
string declaracion = string.Empty;
declaracion = Definicion.ObtenerNombreDelTipoParaC() + " ";
if (Definicion.Tipo != Tipo.CadenaC && Definicion.Tipo != Tipo.CadenaPascal)
{
if (Definicion.TipoDeAcceso == ValorOReferencia.R)
{
declaracion += "*";
}
declaracion += Definicion.Nombre + ";";
escritor.WriteLine(declaracion);
}
}
private void LlamarFuncionAProbar( EscritorC escritor )
{
string llamada = "";
if (Definicion.DefParametroSalida != null && Definicion.DefParametroSalida.Tipo != Tipo.Void)
llamada = Definicion.DefParametroSalida.Nombre + " = ";
llamada += Definicion.Nombre + "( ";
foreach( Parametro param in PruebaActual.ParametrosEntrada )
if( param.Definicion.EsLista )
llamada += "&" + param.Definicion.Nombre + ", "; //por referencia
else
llamada += param.Definicion.Nombre + ", ";
if( PruebaActual.ParametrosEntrada.Length > 0 ) //Si hay parametros de entrada
llamada = llamada.Remove( llamada.Length - 2, 2 ); //Elimino la última coma.)
llamada += " );";
escritor.WriteLine( llamada );
}
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();
}
public override void Instanciar(EscritorC escritor)
{
string instanciacion = string.Empty;
foreach (Elem elemento in Elementos)
{
switch (Definicion.Tipo)
{
case Tipo.UInt8:
case Tipo.Int8:
case Tipo.Char:
instanciacion = "insertarchar(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.Int16:
case Tipo.UInt16:
instanciacion = "insertarshort(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.UInt32:
case Tipo.Int32:
instanciacion = "insertarint(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.Booleano:
instanciacion = "insertarbool(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.UInt64:
case Tipo.Int64:
instanciacion = "insertarlonglong(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.Float32:
instanciacion = "insertarfloat(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
case Tipo.Float64:
instanciacion = "insertardouble(&" + Definicion.Nombre + "," + elemento.Valor + ", false);";
break;
default:
throw new Exception(Mensajes.TipoIncorrectoListas);
}
escritor.WriteLine(instanciacion);
}
}
public void LiberarMemoria(EscritorC escritor)
{
//Libero la memoria para todos los parametros en los que se pidió memoria anteriormente.
foreach (Parametro param in ParametrosEntrada)
{
if (param.Definicion.EntradaSalida != EntradaSalida.S && param.Definicion.TipoDeAcceso == ValorOReferencia.R)
{
param.LiberarMemoria(escritor);
}
}
if (ParametrosSalida[0].Definicion.TipoDeAcceso == ValorOReferencia.R)
{
ParametrosSalida[0].LiberarMemoria(escritor);
}
//escritor.WriteLine( "free2all();");
}
public override void Instanciar(EscritorC escritor)
{
string instanciacion;
int fil = 0, col = 0;
foreach (ParamVector fila in Filas)
{
foreach (Elem elemento in fila.Elementos)
{
instanciacion = Definicion.Nombre + "[" + fil + "][" + col + "] = " + elemento.Valor + ";";
escritor.WriteLine(instanciacion);
col++;
}
fil++;
col = 0;
}
}
public override void Declarar(EscritorC escritor)
{
string declaracion = string.Empty;
switch (Definicion.Tipo)
{
case Tipo.Char:
case Tipo.UInt8:
case Tipo.Int8:
declaracion = "char ";
break;
case Tipo.Int16:
case Tipo.UInt16:
declaracion = "short ";
break;
case Tipo.UInt32:
case Tipo.Int32:
declaracion = "int ";
break;
case Tipo.Booleano:
declaracion = "bool ";
break;
case Tipo.UInt64:
case Tipo.Int64:
declaracion = "longlong ";
break;
case Tipo.Float32:
declaracion = "float ";
break;
case Tipo.Float64:
declaracion = "double ";
break;
default:
throw new Exception(Mensajes.TipoIncorrectoListas);
}
declaracion = "struct Lista" + declaracion + " *" + Definicion.Nombre + " = NULL;";
escritor.WriteLine(declaracion);
}
public override void CompararValor(EscritorC escritor)
{
Elem elem = new Elem();
escritor.WriteLine("//" + Definicion.Nombre);
for (int i = 0; i < Elementos.Length; i++)
{
elem = Elementos[i];
elem.Definicion.Tipo = Definicion.Tipo;
elem.Definicion.TipoDeAcceso = ValorOReferencia.V;
if (Definicion.Tipo == Tipo.Char)
{
elem.Valor = elem.Valor[1].ToString();
}
elem.CompararValor(escritor, Definicion.Nombre + "[" + i + "]");
}
}
public void GenerarPruebas()
{
EscritorC escritor = new EscritorC( "codigoProbador.c" );
escritor.WriteLine( "#include <stdio.h>" );
escritor.WriteLine("#include \"mallocfree.h\"");
escritor.WriteLine("#include \"listas.h\"");
escritor.WriteLine( "#define bool int" );
escritor.WriteLine( "#define true 1" );
escritor.WriteLine( "#define false 0" );
escritor.WriteLine( "FILE *fs;" );
EscribirReferenciaExternaDeLaFuncion( escritor );
EscribirFuncionesDePrueba( escritor );
EscribirMain( escritor );
escritor.Close();
}
public override void CompararValor(EscritorC escritor)
{
Elem elem;
for (int fila = 0; fila < cantFilas; fila++)
{
for (int col = 0; col < cantColumnas; col++)
{
elem = Filas[fila].Elementos[col];
elem.Definicion.Tipo = Definicion.Tipo;
elem.Definicion.TipoDeAcceso = ValorOReferencia.V;
if (Definicion.Tipo == Tipo.Char)
{
elem.Valor = elem.Valor[1].ToString();
}
elem.CompararValor(escritor, Definicion.Nombre + "[" + fila + "]" + "[" + col + "]");
}
}
}
public void CompararValoresDevueltos(EscritorC escritor)
{
//Comparo los valores de los parametros de salida y ES
foreach (Parametro param in ParametrosSalida)
{
if (param.Definicion.Tipo != Tipo.Void)
{
param.CompararValor(escritor);
}
}
//Comparo todos los valores de los parametros de entrada pasados por referencia, contra si mismos; o sea, que no se hayan modificado.
foreach (Parametro param in ParametrosEntrada)
{
if (param.Definicion.EntradaSalida == EntradaSalida.E && param.Definicion.TipoDeAcceso == ValorOReferencia.R)
{
param.CompararValor(escritor);
}
}
}
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();
}
public virtual void LiberarMemoria(EscritorC escritor)
{
}
public virtual void TamanioOValorParaMedicion(EscritorC escritor)
{
}
public override void TamanioOValorParaMedicion(EscritorC escritor)
{
escritor.Write(Longitud * MA.CuantosBytes(Definicion.Tipo));
}
private void EscribirReferenciaExternaDeLaFuncion( EscritorC escritor )
{
escritor.WriteLine( "extern " + Definicion.GenerarPrototipo() + ";" );
escritor.WriteLine("extern long long timer();");
}
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();
}
public override void TamanioOValorParaMedicion(EscritorC escritor)
{
escritor.Write(cantColumnas * cantFilas * MA.CuantosBytes(Definicion.Tipo));
}
