void ver_registro(){
FILE *archivo = cargar_archivo_leer(archivo);
struct dogType *datos = asignar_memoria(datos);
leer_archivo(archivo,datos);
cerrar_archivo(archivo);
lista_registro(datos);
liberar_memoria(datos); //Metodo ineficiente :S
datos = asignar_memoria(datos);
leer_archivo(archivo,datos);
if(ver_opcion(datos) == 1) printf("Registro mostrado exitosamente");
else printf("No se pudo mostrar el registro solicitado");
liberar_memoria(datos);
//Falta la tecla de espera :(
};
Element* Stack::pop()
{
fstream leer_archivo("Agenda.txt");
ofstream archivo("borrar.txt");
Contacto contacto;
leer_archivo.read((char *)&contacto, sizeof(contacto));
if(leer_archivo.fail())
{
cout <<" Ocurrio un ploblema, intentando abrir la agenda :(" <<endl;
exit(1);
}
while(!leer_archivo.eof())
{
if(contacto.id != id)
{
archivo.write((char *)&contacto, sizeof(contacto));
}
leer_archivo.read((char *)&contacto, sizeof(contacto));
}
cout << endl;
leer_archivo.close();
archivo.close();
remove("Agenda.txt");
rename("borrar.txt", "Agenda.txt");
}
bool crear_recorrido(recorrido_t *recorrido, const char *nombre_archivo,
grafo_t *grafo){
strncpy(recorrido->nombre_archivo, nombre_archivo, MAX_CARACTERES_ARCHIVO);
recorrido->nombre_archivo[MAX_CARACTERES_ARCHIVO - 1] = '\0';
recorrido->distancia_total = 0;
recorrido->grafo = grafo;
crear_lista(&(recorrido->lista), "Recorrido");
bool ok = leer_archivo(recorrido);
computar_distancias(recorrido);
return ok;
}
int main(int argc, char **argv)
{
if(argc<3)
{
printf("\nIngrese los dos parametros \n");
return 0;
}
leer_archivo(argv[1]); //LEO EL ARCHIVO
strcpy( nombre_exe_mv,argv[2]); //Almaceno el nombre del archivo a generar
armar_tabla_etiquetas();
ensamblar();
generar_archivo_mv();
return 0;
}
/*Inicia el problema, abriendo el archivo con la funcion leer_archivo*/
void iniciar(char* nombre_archivo)
{
leer_archivo(nombre_archivo);
}
int sys_ejecutar ( char* arch, char* args[] ) {
int i, fd, idx_codigo, idx_dato;
pcb* nueva_tarea;
dword funcion;
char* dato = (char*)alocar (11);
char* archivo = arch + recuperar_base ();
char** args1 = (char**) (((int)args) + recuperar_base() );
char* argu;
if ( args1 != NULL ) {
i = 0;
imprimir ( "Mostrando argumentos:\n" );
while ( args1[i] != NULL ) {
argu = (char*) ( ((int)args1[i]) + recuperar_base () );
imprimir ( "args[%d] = <%s>\n", i, argu );
i++;
}
for (i = 0; i < 12 && archivo [i] != '\0'; i++) {
dato [i] = archivo [i];
}
} else {
imprimir ( "No se recibieron argumentos en ejecutar\n" );
}
imprimir_cadena ( "Abriendo: <" );
imprimir_cadena ( archivo );
imprimir_cadena ( " - " );
imprimir_cadena ( dato );
imprimir_cadena ( ">\n" );
fd = abrir ( archivo );
funcion = (dword) sys_alocar ( tarea_actual->archivos [fd].ed.tamanio +
TAMANIO_PILA_USUARIO );
if ( funcion == NULL ) {
return -1;
}
if ( fd == ERROR ) {
return -1;
} else {
idx_codigo = siguiente_indice_gdt ();
setear_desc_seg ( SEG_CODIGO, funcion, &_gdt->descriptores[idx_codigo],
0xFFFFF );
// tarea_actual->archivos [fd].ed.tamanio );
idx_dato = siguiente_indice_gdt ();
setear_desc_seg ( SEG_DATOS, funcion, &_gdt->descriptores[idx_dato],
0xFFFFF );
// tarea_actual->archivos [fd].ed.tamanio +
// TAMANIO_PILA_USUARIO );
leer_archivo (fd, (void*)funcion, tarea_actual->archivos [fd].ed.tamanio);
nueva_tarea = crear_tarea ((handler_tarea)funcion);
//nueva_tarea->dato = archivo;
//nueva_tarea->dato = arch;
nueva_tarea->dato = dato;
nueva_tarea->tarea->eip = 0x00;
nueva_tarea->tarea->cs = 8 * idx_codigo;
nueva_tarea->tarea->ds = 8 * idx_dato;
nueva_tarea->tarea->es = nueva_tarea->tarea->ds;
nueva_tarea->tarea->fs = nueva_tarea->tarea->ds;
nueva_tarea->tarea->gs = nueva_tarea->tarea->ds;
nueva_tarea->selector_ds = nueva_tarea->tarea->ds >> 3;
/*
nueva_tarea->tarea->esp = funcion + TAMANIO_PILA_USUARIO +
tarea_actual->archivos [fd].ed.tamanio;
nueva_tarea->tarea->ss = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss0 = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss1 = nueva_tarea->tarea->ds;
nueva_tarea->tarea->ss2 = nueva_tarea->tarea->ds;
*/
/*
imprimir_cadena ("poniendo en ejecucion a ");
imprimir_cadena (dato);
imprimir_cadena ("\n");
*/
agregar (nueva_tarea);
//cerrar ( fd );
}
return nueva_tarea->pid;
}
int main(int argc, char** argv){
float* h=NULL;
float* x=NULL;
int hsize;
int xsize;
t_entrada entradah;
t_entrada entradax;
init(&entradah);
init(&entradax);
int ileido,fleido;
int error=0;
int i;
ileido=0;
fleido=0;
int pulso=0;
int archivo=0;
int errors=0;
int opcion;
const char* const short_options = "hVr:p:";
const struct option long_options[] =
{
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ "response", 1, NULL, 'r' },
{ "pulse", 1, NULL, 'p' },
{ NULL, 0, NULL, 0 }
};
int lista_archivos=0;
int res;
int opt=0;
if(argc==1)
fprintf(stderr,"Error: Falta especificar una opción.");
else
{
do {
opcion = getopt_long (argc, argv, short_options, long_options, NULL);
switch (opcion)
{
case 'h': /* -h o --help */
imprimir_ayuda (stdout, 0);
opt=1;
break;
case 'r': /* -r o --response */
if((!pulso)&&(!archivo)){
lista_archivos=1;
res=leer_archivo(optarg,&entradah);
if(res==3) fprintf(stderr,"ERROR: No se pudo abrir el archivo %s.\n",optarg);
if(res==1) fprintf(stderr,"ERROR: No hay memoria suficiente para continuar.\n");
opt=1;
archivo=1;
} else{
errors=1;
};
break;
case 'p': /* -p o --pulse */
if((!pulso)&&(!archivo)){
res=generar_pulso(optarg,&h,&hsize);
if(res==1) fprintf(stderr,"ERROR: No hay memoria suficiente para continuar.\n");
if(res==2) fprintf(stderr,"ERROR: la sintaxis del pulso ingresado es incorrecta.\n");
opt=1;
ileido=1;
fleido=1;
pulso=1;
} else{
errors=1;
}
break;
case 'V': /* -V o --version */
imprimir_version (stdout, 0);
opt=1;
break;
case '?': /*error*/
fprintf(stderr,"ERROR: La opción no existe.\n");
imprimir_ayuda (stderr, 1);
opt=1;
case -1:
break;
case ':':
fprintf(stderr,"ERROR: Faltan argumentos.\n");
imprimir_ayuda (stderr, 1);
break;
default:
break;
}
} while((opcion != -1));
if((!opt)&&(argc>1))
fprintf(stderr,"ERROR: Falta especificar una opción.");
if(lista_archivos)
{
for (i = optind; i < argc; ++i)
{
res=leer_archivo(argv[i],&entradah);
if(res==3) fprintf(stderr,"ERROR: No se pudo abrir el archivo %s.\n",optarg);
if(res==1) fprintf(stderr,"ERROR: No hay memoria suficiente para continuar.\n");
}
}
}
if(errors){
fprintf(stderr,"ERROR: las opciones ingresadas son incorrectas.\n");
destroy(&entradah);
destroy(&entradax);
return 1;
};
entradah.data[entradah.index]='\0';
res=check_sintax(&entradah);
if(res==0) error=armar_vector(entradah.data,&h,&hsize);
else if(!pulso)fprintf(stderr,"ERROR: la sintaxis de h es incorrecta.\n");
if(!pulso){
if(error==1) fprintf(stderr,"ERROR: no hay memoria suficiente para continuar.\n ");
if(error==2) fprintf(stderr,"ERROR: hay caracteres inválidos en el vector h.\n ");
}
destroy(&entradah);
if(h==NULL){
/* no hay h , no se puede hacer nada*/
return 1;
}
if(!pulso)
if((error)||(res!=0)) return 1;
/* leo x desde stdin */;
ileido=0;
fleido=0;
error=leerEntrada(stdin,&entradax);
entradax.data[entradax.index]='\0';
res=check_sintax(&entradax);
if(res==0) error=armar_vector(entradax.data,&x,&xsize);
else fprintf(stderr,"ERROR: la sintaxis de x es incorrecta.\n");
destroy(&entradax);
if(error==1) fprintf(stderr,"ERROR: no hay memoria suficiente para continuar.\n ");
if(error==2) fprintf(stderr,"ERROR: hay caracteres inválidos en el vector x.\n ");
if(x==NULL){
/*no tengo x, no puedo ahcer nada*/
if(h!=NULL){
/*libero h*/
free(h);
return 1;
}
}
if((error)||(res!=0)) return 1;
/* tengo h y x*/
if((!errors)&&(!error)){
/*no hay error de sintaxis: -r y -p*/
i=0;
/* si x tiene menos elementos que h, repito x*/
if(xsize<hsize){
while(xsize<hsize){
push_back(&x,&xsize,x[i]);
i++;
};
}
/* reservo espacio para y, xsize + hsize -1 */
y=(float*)malloc((xsize+hsize-1)*sizeof(float));
if(y!=NULL){
/* LLAMAR A CONVOLUCIÓN*/
conv(x,xsize,h,hsize);
};
/*imprimo y*/
printf("%s","[ ");
for(i=0;i<xsize+hsize-1;i++){
printf("%.2f ",y[i]);
}
printf("%s","]\n");
/* LIBERO Y*/
if(y!=NULL)
free(y);
}
/*
printf("\n\n X es:");
i=0;
while(i<xsize){
printf(" %f \n",x[i]);
i++;
}
i=0;
printf("\n\n h es:");
while(i<hsize){
printf(" %f \n",h[i]);
i++;
}
*/
/*LIBERO H y X*/
if(h!=NULL)
free(h);
if(x!=NULL)
free(x);
return 0;
}
