int main(){
char bloque[TAM_BLOQUE];
int fd_cdrom;
int ret;
int num=0;
printf("mostrar el cdrom por pantalla");
/* abrir fichero origen */
fd_cdrom = abrir ("/DISPOSITIVOS/cdrom",0);
if (0 > fd_cdrom) {
printf("copiar_disco: Error al abrir el cdrom\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("mostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
while (0 < ret) {
printf("%s",bloque);
num=num+1;
printf("\n\nmostrar_disco: leyendo bloque %d\n\n\n",num);
ret = leer(fd_cdrom,bloque,TAM_BLOQUE);
}
/* cerrar cdrom */
cerrar (fd_cdrom);
return (0);
}
void procesoDeInsRel( GRAFO_MRS *g )
{
int verRel, res, verF, verD;
do
{
system( "cls" );
verF = leer( "\n Vertice origen : " );
verD = leer( " Vertice destino : " );
verRel = insRelMRS( g, verF, verD );
if( verRel == 2 )
printf( "\n El vertices %d no existe\n", verF );
else
if( verRel == 3 )
printf( "\n El vertices %d no existe\n", verD );
printf( "\n Otro relacion ? \n ( 1: Si 0: No ) opcion: " );
scanf( "%d", &res );
}while( res == 1 );
system( "pause" );
}
int main(){
char bloque[1025];
int fd_disco;
int ret;
int num_bloque=0;
int error_encontrado = 0;
int id_actual = obtener_id_proceso();
printf("Comprobando lectura por bloques (%d)\n", id_actual);
/* limpiar el bloque */
for(ret = 0; ret < 1024; ret ++){
bloque[ret] = 'n';
}
bloque[1024] = '\0';
/* abrir fichero origen */
fd_disco = abrir ("/DISPOSITIVOS/disco",0);
if (0 > fd_disco) {
printf("test_bloque_cdrom(%d): Error al abrir el cdrom\n", id_actual);
printf("### Result: Fail\n");
return (-1);
}
/* mostra cdrom por pantalla */
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
error_encontrado = comprobar_valores(bloque, num_bloque);
while ((0 < ret) && !error_encontrado) {
fprintf(stdout, "{%s}FIN\n", bloque);
num_bloque++;
printf("test_disco_cdrom (%d) leyendo bloque %d\n", id_actual, num_bloque);
ret = leer(fd_disco, bloque, 1024);
if(ret > 0){
error_encontrado = comprobar_valores(bloque, num_bloque);
}
}
printf("Bloque final: %d, error_encontrado: %d\n", num_bloque, error_encontrado);
/* El Ãltimo bloque leido no deberÃa sobrepasar la imagen. */
if(num_bloque != 10){
printf("### Result: Fail\n");
}else{
if(!error_encontrado){
printf("### Result: OK\n");
}else{
printf("### Result: Fail\n");
}
}
/* cerrar cdrom */
cerrar (fd_disco);
return (0);
}
void procesoDeEliminaRel( GRAFO_MRS *g)
{
int verF, verD, verRel, res;
do
{
system( "cls" );
verF = leer( "\n Vertice origen : " );
verD = leer( " Vertice destino : " );
switch( verRel = eliminaRel( g, verF, verD ) )
{
case 2: printf( "\n El vertices %d no existe\n", verF ); break;
case 3: printf( "\n El vertices %d no existe\n", verD ); break;
case 4: printf( "\n El vertices %d no tiene ninguna relacion\n", verF ); break;
}
printf( "\n Otro eliminacion 1: Si 0: No : " );
scanf( "%d", &res );
}while( res );
system( "pause" );
}
int main(void) {
escribir();
leer();
multiplicar();
leer();
return 0;
}
int main() {
char* fichero_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos256";
char* fichero_no_existente = "/FICHEROS/lectura/leer_escritura_varios_tamanyos64";
//Montar disco.
printf("abrir_fichero_exista_noexista -> Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
if(montar("disco", "lectura", "discoFS") < 0) {
printf("abrir_fichero_exista_noexista -> Error al montar particion lectura en disco con discoFS.\n");
}
//Abrir ficheros
int fd64 = abrir(fichero_no_existente, T_FICHERO);
if(fd64 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_no_existente);
return -1;
}
int fd256 = abrir(fichero_existente, T_FICHERO);
if(fd256 < 0) {
printf("abrir_fichero_exista_noexista: Error al abrir fichero origen %s\n", fichero_existente);
return -1;
}
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_no_existente, fd64);
printf("abrir_fichero_exista_noexista -> %s -> fd = %d", fichero_existente, fd256);
//Mostrar ficheros.
char buffer[TAM_BUFFER + 1];
int leidos;
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
int leidos256 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd256, buffer, TAM_BUFFER);
leidos256 += leidos;
}
printf("Leidos(%s): %d\n", fichero_existente, leidos256);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
int leidos64 = leidos;
while(leidos > 0) {
printf("%s",buffer);
bzero(buffer, TAM_BUFFER + 1);
leidos = leer(fd64, buffer, TAM_BUFFER);
leidos64 += leidos;
}
printf("Leidos(%s): %d\n", fichero_no_existente, leidos64);
//Cerrar ficheros
cerrar(fd64);
cerrar(fd256);
return 0;
}
void main (void)
{
frac c1, c2, c;
int opcion;
clrscr ();
leer (&c1);
leer (&c2);
do {
printf ("0.-fin 1(+) 2(-) 3(*) 4(/) opcion: ");
scanf ("%d", &opcion);
switch (opcion) {
case 1:
sumar (c1, c2, &c);
escribir (c1);
putchar ('+');
escribir (c2);
putchar ('=');
simplifica (&c);
escribir (c);
break;
case 2:
restar (c1, c2, &c);
escribir (c1);
putchar ('-');
escribir (c2);
putchar ('=');
simplifica (&c);
escribir (c);
break;
case 3:
multiplicar (c1, c2, &c);
escribir (c1);
putchar ('*');
escribir (c2);
putchar ('=');
simplifica (&c);
escribir (c);
break;
case 4:
dividir (c1, c2, &c);
escribir (c1);
putchar ('/');
escribir (c2);
putchar ('=');
simplifica (&c);
escribir (c);
break;
}
printf ("\n");
} while (opcion);
printf ("fin de programa...\n");
getch ();
}
int main()
{
int nR, nC;
nR = leer("\n Dame el numero de renglones ");
nC = leer(" Dame el numero de columnas ");
determinaMatriz(nR, nC);
system("pause");
}
int main()
{
int m_base, m_exp, pot;
m_base = leer ( "\nIntroduce la base: " );
m_exp = leer ( "Introduce el exponente: " );
pot = potencia ( m_base, m_exp );
escribePotencia ( pot );
system ( "pause" );
}
/*
* Lee datos del socket. Devuelve el numero de bytes leidos o
* 0 si se cierra fichero o -1 si hay error.
*/
int recibirDatos(int socket, char** datos, char* op) {
int leido = 0;
int longitud = sizeof(uint32_t);
char* buffer = malloc(longitud + 1);
/*
* Comprobacion de que los parametros de entrada son correctos
*/
if ((socket < 0) || (buffer == NULL ))
return -1;
/* HEADER
* Se reciben primero los datos necesarios que dan informacion
* sobre el verdadero buffer a recibir
*/
if ((leido = leer(socket, buffer, longitud + sizeof(char))) > 0) {
if (op == NULL ) {
memcpy(&longitud, buffer + 1, sizeof(uint32_t));
} else {
memcpy(op, buffer, sizeof(char));
memcpy(&longitud, buffer + 1, sizeof(uint32_t));
}
free(buffer);
buffer = malloc(longitud);
} else {
free(buffer);
return -1;
}
/*
* Se recibe el buffer con los datos
*/
if ((leido = leer(socket, buffer, longitud)) < 0) {
free(buffer);
return -1;
}
if (leido != longitud)
printf("No se han podido leer todos los datos del socket!!");
*datos = (char*) malloc(longitud);
memcpy(*datos, buffer, longitud);
free(buffer);
/*
* Se devuelve el total de los caracteres leidos
*/
return leido;
}
main()
{
Pila dada,top,aux;
int g=0;
inicpila(&dada);
inicpila(&top);
inicpila(&aux);
while (g<5)
{
leer(&dada);
g++;
}
apilar(&top, desapilar(&dada));
while (!pilavacia(&dada))
{
apilar(&aux, desapilar(&dada));
}
apilar(&dada, desapilar(&top));
while (!pilavacia(&aux))
{
apilar(&dada, desapilar(&aux));
}
mostrar(&dada);
getch();
return(0);
}
void main(){
flujo = 0;
abrir();
leer();
cerrar();
printf("buffer leido: %s \n", databuffer);
system("pause");
while(flujo == 0){
intentos = 10;
clearScreen();
copy_from_buffer_to_local();
rellena_cadenaRevelada(); //rellenar con guiones
implementar_mouse();
imprimeAbecedario();
if(game_over == 0){
printf("se acabaron los intentos \n");
printf("llegaste a formar: %s\n", cadenaRevelada);
//flujo = 1;
}
printf("volver a jugar? (presiona ENTER)\n");
printf("salir de la aplicacion? (presiona ESC)\n");
teclaLetra();
}
system("pause");
}
void procesoDeEliminaVer( GRAFO_MRS *g )
{
int ver, verRel, res;
do
{
system( "cls" );
ver = leer( "\n Nombre del vertice : " );
switch( verRel = eliminaVer( g, ver ) )
{
case 1: printf( "\n El vertices %d se a eliminado\n", ver );
printf( "\n Otro eliminacion ?\n ( 1: Si 0: No ) opc: " );
scanf( "%d", &res );
break;
case 0: printf( "\n No existe ningun vertice\n", ver); res = 0; break;
}
}while( res );
system( "pause" );
}
int main(int argc,char** argv)
{
int** A;
int n,end;
int i;
int res;
clock_t t1,t2;
scanf("%i %i",&n,&end);
A=leer(n);
t1=clock();
res=find_paths(A,0,n,end);
t2=clock();
printf("%i\n",res);
/*
t2=(int)((t2-t1)*1000/CLOCKS_PER_SEC); //milisec
printf("Completado en %2.i:%2.i:%2.i:%3.i. (Tamano %i)\n"
,t2/3600000
,(t2/60000)%60
,(t2/1000)%60
,t2%1000
,n);
*/
for(i=0;i<n;++i)
free(A[i]);
free(A);
return 0;
}
unsigned int ad_adquirir(ad_t ad){
unsigned int result = 0;
unsigned int b = 0;
//printf("ENTRA\n");
//RERET Y MODO AD:
ad_resetear_contador(ad);
ad_set_modo_ad(ad);
if(!result)
result = direccion(0x0b);
if (!result)
result = startLeer();
if (!result){
do{
printf("ENTRA\n");
b=leer();
}while(!(b&0x01));
result = endLeer();
// printf("leyo b = %u\n",b);
}
ad->adq_count++;
ad_leer_buffers(ad);
return result;
}
void procesoDeDeterminaRel( GRAFO_MRS *g )
{
int verF, verD;
system( "cls" );
verF = leer( "\n Vertice origen : " );
verD = leer( " Vertice destino : " );
if( determinaRel( g, verF, verD ) )
printf( "\n %d y %d Estan relacionados\n\n", verF, verD );
else
printf( "\n %d y %d no estan relacionados\n\n", verF, verD );
system( "pause" );
}
int main(int argc, const char * argv[])
{
int tuberia[2];
pid_t pid;
pipe(tuberia);
pid = fork();
if (pid == -1)
{
printf("Error al crear el proceso hijo");
exit(-1);
}
else if (pid == 0)
{
/* Hijo */
close(tuberia[1]);
printf(" Soy el hijo y estoy leyendo ... \n");
leer(tuberia[0]);
}
else {
/* Padre */
close(tuberia[0]);
printf(" Soy el padre y estoy escribiendo ... \n");
escribir(tuberia[1]);
}
return 0;
}
main()
{
int id,posrel;
TIPO libro,v;
char c;
id = _creat ("LIBRO",32);
close (id);
id = _open ("LIBRO",O_WRONLY);
c = 's';
while (c == 's') {
printf ("De los datos del libro\n");
leer (&libro);
grabar (id,libro);
printf ("Desea grabar mas libros? (s/n)\n");
c = getche();
printf ("\n");
}
close (id);
id = _open ("LIBRO",O_RDONLY);
while (lea_reg (id,v) != 0)
printf ("%d %s %f\n",v.cod,v.N,v.precio);
getch();
close (id);
if ( _open ("LIBRO",O_RDWR) == -1 ) {
printf ("Error en apertura\n");
exit (1);
}
printf ("Lea posicion relativa para el libro a modificar\n");
posrel = lea_entero();
while (posrel != 9999) {
ubicar (id,posrel); /* Ubica el registro a modificar */
lea_reg (id,v); /* Lee el registro y avanza el apuntador */
modificar (&v); /* Modifica el registro */
ubicar (id,posrel); /* Reubica el apuntador */
grabar (id,v); /* Graba el registro modificado */
printf ("Lea posicion relativa para el libro a modificar\n");
posrel = lea_entero();
}
close (id);
id = _open ("LIBRO",O_RDONLY);
while (lea_reg (id,v) != 0)
printf ("%d %s %f\n",v.cod,v.N,v.precio);
getch();
close (id);
}
int main(int argc, char *argv[]){
double base, exponente;
leer(&base, &exponente);
printf("%4.2lf, %4.2lf\n", base, exponente);
return EXIT_SUCCESS;
}
void operaAB( AVL *a )
{
int opc, dato;
char res;
*a = NULL;
do
{
opc = imprimeMenu();
switch( opc )
{
case 1: system( "cls" );
puts( "\n Arbol creado .....\n\n " );
iniAVL( a );
system( "pause" );
break;
case 2: procesoDeInsercion( a );
break;
case 3: system("cls");
puts( "\n\n" );
preOrden(*a);
puts( "\n\n" );
system("pause");
break;
case 4:
do
{
system("cls");
if( buscaDatoAVL( *a ,dato = leer( "\n Digite el numero a buscar : " ) ) )
{
printf("\n El dato %d existe en el arbol\n\n ", dato );
res = -1 ;
} else
{
printf("\n El numero %d no existe\n\n ", dato );
printf(" Otra busqueda ? ( S / N ) : " );
fflush(stdin);
scanf("%c", &res );
}
}while( res == 's' || res == 'S' );
system("pause" );
break;
case 5: moduloDeEliminacion( a );break;
}
}while( opc > 0 && opc < 6 );
}
void escribir(int sem){
int fact, i;
while(1){
printf("Ingresa un número: ");
scanf("%d",&fact);
s.val = fact;
semctl(sem, 0, SETVAL,s);
leer(sem);
if(fact == -1) break;
}
}
int main()
{
float m_c[N_M][N_P], m_pMat[N_M], m_pPer[N_P];
int nMat, nPer;
float num = (float)58/63;
printf("%.3f", num );
nMat = leer("Dame el numero # de materias ", N_M );
nPer = leer("Dame el numero # de periodos ", N_P);
leerMatriz(m_c, nMat, nPer);
boleta(m_c, nMat, nPer,m_pMat, m_pPer);
escribeBoleta(m_pMat, m_pPer, nMat, nPer);
system("pause");
}
char* recibirDatos(int socket, uint32_t ** op, uint32_t ** id) {
int leido = 0;
uint32_t longitud = 3 * sizeof(uint32_t);
char* buffer = malloc(longitud);
/*
* Comprobacion de que los parametros de entrada son correctos
*/
if ((socket < 0) || (buffer == NULL))
return "ERROR";
/* HEADER
* Se reciben primero los datos necesarios que dan informacion
* sobre el verdadero buffer a recibir
*/
if ((leido = leer(socket, buffer, longitud)) > 0) {
if (op == NULL) {
memcpy(id, buffer + sizeof(uint32_t), sizeof(uint32_t));
memcpy(&longitud, buffer + (2 * sizeof(uint32_t)), sizeof(uint32_t));
} else {
memcpy(op, buffer, sizeof(uint32_t));
memcpy(id, buffer + sizeof(uint32_t), sizeof(uint32_t));
memcpy(&longitud, buffer + (2 * sizeof(uint32_t)), sizeof(uint32_t));
}
free(buffer);
buffer = malloc(longitud);
} else {
free(buffer);
return "ERROR";
}
if ((leido = leer(socket, buffer, longitud)) < 0) {
free(buffer);
return "ERROR";
}
if (leido != longitud)
printf("No se han podido leer todos los datos del socket!!");
return buffer;
}
void main (void)
{
char cad[50], resp;
int total, esta;
clrscr ();
do {
printf ("Introduzca un número: ");
do {
gets (cad);
menos (cad);
total = strlen (cad);
esta = comprobar (cad, total);
if (esta != 0) {
printf ("No metas porquería.");
if (indice != total - 1)
printf (" A partir de la %c no vale.", cad[indice]);
else
printf (" La %c no vale.", cad[indice]);
printf ("\nIntroduzca otro: ");
}
if (total == 0)
esta = 1;
}
while (esta != 0);
ceros (cad);
total = strlen (cad);
leer (cad, total);
printf ("\n\n¿Desea probar otro número?(s/n): ");
do {
resp = getche ();
printf ("\n");
resp = tolower (resp);
if ((resp != 's') && (resp != 'n'))
printf ("¿Otro número?(s/n): ");
}
while ((resp != 's') && (resp != 'n'));
}
while (resp == 's');
}
int main(){
int pid = fork();
if(pid == 0){
char** arg = NULL;
execv("hijo",arg);
}else{
escribir('a');
}
sleep(1);
leer();
return 0;
}
// Función Principal.
int main(int argc, char *argv[])
{
char opc; // Opción de entrada.
int arr[MAX_TAM], // El vector.
tam, // El tamaño del vector.
valor, // El valor a buscar.
res; // El resultado (posición).
printf("\t\tBúsqueda Binaria.\n\n");
do{
printf("¿Desea introducir el arreglo? S/N > ");
scanf(" %c",&opc);
}while(opc != 'S' && opc != 's' && opc != 'n' && opc != 'N');
if(opc == 's' || opc == 'S')
{
leer(arr,&tam);
}
else
{
printf("Introduzca el tamaño del arreglo a generar: ");
scanf(" %d",&tam);
if(tam < 1 || tam > MAX_TAM)
{
printf("Error: Ha introducido un valor inválido, se ha truncado a %d.\n",MAX_TAM);
tam = MAX_TAM;
}
for(int i = 0; i < tam; i++)
{
arr[i] = i+1; // 1-tam;
}
}
printf("\nIntroduzca el valor a buscar en el arreglo: ");
scanf("%d",&valor);
res = busqueda(valor,arr,tam);
if(res != -1)
{
printf("El dato (%d) se encuentra en la posición [%d] dentro del arreglo.\n", valor, res);
}
else
{
printf("El valor no se encuentra dentro del arreglo.\n");
}
printf("\nFin del Programa.\n");
return 0; // Fin del Programa con estado 0.
}
int main()
{
FILE *punfile;
int n=6;
//n=contar(punfile);
char nombres[n][20];
int edades[n];
leer(punfile, edades, nombres);
mostrar(nombres, edades, n);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
FILE *fichero;
char sopa[NMAX][NMAX];
int opcion;
char nombre_de_fichero[0x20];
srand(time(NULL));
int sopa_cargada = 0; // 0 equivale a falso, cualquier cosa != 0 es verdadero
do {
switch(opcion = leer_menu()) {
case crear:
cabecera("Nueva Sopa");
rellenar(sopa);
sopa_cargada = 1;
pintar(sopa);
break;
case abrir:
imprimir_directorio("./");
printf("Elige un fichero sopa: ");
scanf(" %s", nombre_de_fichero);
fichero = fopen(nombre_de_fichero, "r");
leer(fichero, sopa);
sopa_cargada = 1;
fclose(fichero);
break;
case ver:
if (sopa_cargada) {
cabecera("Sopa Activa");
pintar(sopa);
} else
inform("De momento no hay ninguna sopa cargada.");
break;
case guardar:
if (sopa_cargada) {
imprimir_directorio("./");
printf("Elige un nombre para guardar la sopa: ");
scanf(" %s", nombre_de_fichero);
fichero = fopen(nombre_de_fichero, "w");
escribir(fichero, sopa);
fclose(fichero);
inform("Fichero Guardado.");
} else
inform("De momento no hay ninguna sopa cargada.");
break;
}
} while(opcion != salir);
return EXIT_SUCCESS;
}
char* leer(int pagina,int offset, int tamanio)
{
if((tamanio+offset)<=tamanioPag){
char * lecturaUMC2= malloc(12);
t_direccion *datos_para_umc2=malloc(sizeof(t_direccion));
datos_para_umc2->offset=offset;
datos_para_umc2->pagina=pagina;
datos_para_umc2->size=tamanio;
enviarDirecParaLeerUMC(lecturaUMC2, datos_para_umc2);
t_paquete* instruccion2;
instruccion2 = recibir(umc);
log_info(log,"Codigo de operacion recibido: %d\n", instruccion2->codigo_operacion);
if(instruccion2->codigo_operacion==7) return NULL;
char* sentencia2=malloc(datos_para_umc2->size);
memcpy(sentencia2, instruccion2->data, datos_para_umc2->size);
free(lecturaUMC2);
free(datos_para_umc2);
liberar_paquete(instruccion2);
return sentencia2;}
else{
char* lectura1 = leer(pagina,offset,(tamanioPag-offset));
if(lectura1==NULL) return NULL;
char* lectura2 = leer(pagina+1,0,tamanio-(tamanioPag-offset));
if(lectura2==NULL) return NULL;
char* nuevo =malloc((tamanioPag-offset)+tamanio-(tamanioPag-offset));
memcpy(nuevo,lectura1,(tamanioPag-offset));
memcpy(nuevo+(tamanioPag-offset),lectura2,tamanio-(tamanioPag-offset));
free(lectura1);
free(lectura2);
return nuevo;
}
}
// Función Principal.
int main(int argc, char *argv[])
{
string or;
string sub;
char* filename;
// Para empaquetarlos posteriormente.
char temp[MAX_BUFFER];
int templen;
FILE *archivo;
printf("\tPrograma que busca un substring en un archivo\n\n");
if(argc != 2)
{
printf("Introduzca el nombre del fichero a abrir: ");
scanf(" %s",filename);
}
else
{
filename = argv[1];
}
printf("Se leerá %s ...\n");
// Abrir archivo.
archivo = fopen(filename,LECTURA);
// Lectura
templen = file2arr(archivo,or.str);
// Empaquetamiento
or.tam = templen;
printf("Introduce la palabra que deseas buscar: ");
leer(&sub);
// Función principal.
templen = indice(or,sub,0); // Reuso de variable.
if(templen == -1)
{
printf("No se eoncontró el substring en el archivo.\n");
}
else
{
printf("El substring se encontró por primera vez en el archivo en la posición %d\n",templen);
}
printf("\nFin del Programa\n");
return 0; // Fin del Programa con estado 0.
}