Пример #1
0
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 :(
};
Пример #2
0
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");
				

		
	}
Пример #3
0
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;
}
Пример #5
0
/*Inicia el problema, abriendo el archivo con la funcion leer_archivo*/
void iniciar(char* nombre_archivo)
{
	leer_archivo(nombre_archivo);
}
Пример #6
0
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;
}
Пример #7
0
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;

}