commit 66e1ded75dc357eed7700388ca0fca71dd3e8d4f Author: jdg Date: Fri Sep 3 17:42:38 2021 +0200 First commit 31/01/1996 diff --git a/BDATOS.CPP b/BDATOS.CPP new file mode 100644 index 0000000..9c6bb6e --- /dev/null +++ b/BDATOS.CPP @@ -0,0 +1,734 @@ +#include +#include +#include +#include + +#define __BDatos_CPP +#include "d:\program\src_dos\libs\bdatos\BDatos.hh" + + +// ÚÄÄÄÄÄÄÄÄÄÄÄÄ¿ +#define PROG_NAME "BDatos::JD::" +// ÀÄÄÄÄÄÄÄÄÄÄÄÄÙ +#define VER_HI 1 +#define VER_LOW 0 +#define ARCH_LEN 12 + +#define FALSO 0 +#define CIERTO 1 + +typedef struct +{ + char code; + long pos; +} BTree; + + /**************************************************************************\ +| | +| Contructor de Clase | +| | +| Descripcion: | +| Se encarga de poner a cero todas las variables utilizadas | +| | +| | +| Entradas: (ninguna) | +| | +| Salidas: (ninguna) | +| | + \**************************************************************************/ +BDatos::BDatos() +{ + BDatosHeader.NRegistros = 0; + BDatosHeader.NRegTotal = 0; + BDatosHeader.SizeReg = 0; + BDatosHeader.VerHi = VER_HI; + BDatosHeader.VerLow = VER_LOW; + BDatosHeader.Eof_Code = 26; + + strcpy( BDatosHeader.NBD, "BDatos::JD::" ); + + memset( BDatosHeader.MyHeader.ProgName, 32, sizeof(char)* 15 ); + BDatosHeader.MyHeader.VerHi = 0; + BDatosHeader.MyHeader.VerLow = 0; + + memset( BDatosHeader.MyHeader.Other, 32, sizeof(char)*200 ); + + NRegActual = 0; + lError = 0x00; + *cError = 0x00; + rError = ERROR; +} + + /**************************************************************************\ +| | +| Destructor de clase | +| | +| Descripcion: | +| Finaliza las operaciones pendientes. | +| | +| | +| Entradas: (ninguno) | +| | +| Salidas: (ninguna) | +| | +| | + \**************************************************************************/ +BDatos::~BDatos() +{ + if ( rError == ERROR ) return; + fclose( handle_BDatos ); +} + + + /**************************************************************************\ +| | +| Registros | +| | +| Descripcion: | +| Obtiene el n£mero de registros total de la base de datos. | +| | +| | +| Entradas: (ninguna) | +| | +| Salidas: numero de registros | +| | + \**************************************************************************/ +long BDatos::Registros(void) +{ + return BDatosHeader.NRegistros; +} + + /**************************************************************************\ +| | +| NRegTotal | +| | +| Descripcion: | +| Obtiene el n£mero de registros total, total del la base. | +| | +| | +| Entradas: (ninguna) | +| | +| Salidas: numero de registros | +| | + \**************************************************************************/ +long BDatos::NRegTotal(void) +{ + return BDatosHeader.NRegTotal; +} + + /**************************************************************************\ +| | +| RegActual | +| | +| Descripcion: | +| Obtiene el n£mero de registro actual. | +| | +| | +| Entradas: (ninguna) | +| | +| Salidas: numero de registro en tratamiento | +| | + \**************************************************************************/ +long BDatos::RegActual(void) +{ + return NRegActual; +} + + /**************************************************************************\ +| | +| AbrirReg | +| | +| Descripcion: | +| Abre los ficheros indices y datos. | +| | +| | +| Entradas: nombre fichero "sin comodines" | +| longitud de un registro "en bytes" | +| | +| Salidas: OK ( todo va bien ) | +| ERROR ( error ) | +| | +| | + \**************************************************************************/ +int BDatos::AbrirReg(char *file, long sizereg) +{ +// char bdatos[ARCH_LEN]; + char *bdatos; + + bdatos = file; + + BDatosHeader.MyHeader = MyHeader; + + Header NewHeader = BDatosHeader; + + rError = OK; + + strncpy( bdatos, file, ARCH_LEN ); + + if ( (handle_BDatos = fopen( bdatos, "r+b" ) ) == NULL ) + { + // Inicializamos una nueva base de datos + if ( (handle_BDatos = fopen( bdatos, "w" ) ) == NULL ) + { + lError = 0x01; ObtenError( lError ); + return (rError = ERROR); + } + + rewind( handle_BDatos ); + BDatosHeader.SizeReg = sizereg; + fwrite( &BDatosHeader, sizeof( BDatosHeader ), 1, handle_BDatos ); + + fclose( handle_BDatos ); + + if ( (handle_BDatos = fopen( bdatos, "r+b" ) ) == NULL ) + { + lError = 0x01; ObtenError( lError ); + return (rError = ERROR); + } + } else { + + rewind( handle_BDatos ); + fread( &BDatosHeader, sizeof(BDatosHeader), 1, handle_BDatos); + + if ( BDatosHeader.SizeReg != sizereg || BDatosHeader.VerHi != NewHeader.VerHi ) + { + lError = 0x03; ObtenError( lError ); + fclose( handle_BDatos ); + return (rError = ERROR); + } + } + + return OK; +} + + /**************************************************************************\ +| | +| CerrarReg | +| | +| Descripcion: | +| Cierra la base de datos. | +| | +| | +| Entradas: (ninguno) | +| | +| Salidas: OK ( todo va bien ) | +| ERROR ( error ) | +| | + \**************************************************************************/ +void BDatos::CerrarReg( void ) +{ + if ( rError == ERROR ) return; + fclose( handle_BDatos ); + rError = ERROR; +} + + /**************************************************************************\ +| | +| LeeReg | +| | +| Descripcion: | +| Lee el registro de la posici¢n 'pos' y lo almacena en 'dato' | +| | +| | +| Entradas: puntero a los datos | +| posicion a leer | +| | +| Salidas: OK ( todo va bien ) | +| ERROR ( error ) | +| | + \**************************************************************************/ +int BDatos::LeeReg( void *dato, long pos ) +{ + BTree inx; + + if ( rError == ERROR ) + { + lError = 0x05; ObtenError( lError ); + return ERROR; + } + + if ( pos > BDatosHeader.NRegistros || pos < 0 ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + NRegActual = pos; + fseek( handle_BDatos, (long)( pos * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx, sizeof( BTree ), 1, handle_BDatos ); + + if ( inx.pos < 0 || inx.code != ' ' ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + fseek( handle_BDatos, (long)( inx.pos * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) + sizeof( BTree ) ), SEEK_SET ); + fread ( dato, BDatosHeader.SizeReg, 1, handle_BDatos ); + + return OK; +} + + /**************************************************************************\ +| | +| EscribeReg | +| | +| Descripcion: | +| Escribe el registro en la posici¢n 'pos' de 'dato' | +| | +| | +| Entradas: puntero a los datos | +| posicion a escribir | +| | +| Salidas: OK ( todo va bien ) | +| ERROR ( error ) | +| | + \**************************************************************************/ +int BDatos::EscribeReg( void *dato, long pos ) +{ + BTree inx; + + if ( rError == ERROR ) + { + lError = 0x05; ObtenError( lError ); + return ERROR; + } + + if ( pos > BDatosHeader.NRegistros || pos < 0 ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + NRegActual = pos; + fseek( handle_BDatos, (long)( pos * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx, sizeof( BTree ), 1, handle_BDatos ); + + if ( inx.pos < 0 || inx.code != ' ' ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + fseek( handle_BDatos, (long)( inx.pos * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) + sizeof( BTree ) ), SEEK_SET ); + fwrite( dato, BDatosHeader.SizeReg, 1, handle_BDatos ); + + return OK; +} + + /**************************************************************************\ +| | +| InsReg | +| | +| Descripcion: | +| Inserta un registro, en la posici¢n 'pos' por arriba o abajo | +| | +| | +| Entradas: puntero a los datos a insertar, posici¢n, ARRIBA o ABAJO | +| | +| Salidas: (ninguna) | +| | + \**************************************************************************/ +int BDatos::InsReg( void *dato, long pos, char ab ) +{ + BTree inx, old_inx; + unsigned long avance; + long RegTot; + + if ( rError == ERROR ) + { + lError = 0x05; ObtenError( lError ); + return ERROR; + } + + // Filtro los datos conflictivos + if ( pos == 0 && BDatosHeader.NRegistros == 1 && ab == ARRIBA ) + { + pos = 1; + } else + if ( pos == (BDatosHeader.NRegistros - 1) && ab == ARRIBA ) + { + pos = BDatosHeader.NRegistros; + } + + BDatosHeader.NRegistros++; + if ( pos > (BDatosHeader.NRegistros-1) || pos < 0 ) +// if ( pos >= (BDatosHeader.NRegistros-1) && BDatosHeader.NRegistros!=1 ) + { + BDatosHeader.NRegistros--; + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + // Si hay fichas eliminadas, utilizamos sus direcciones intermedias. + if ( (BDatosHeader.NRegTotal - ( BDatosHeader.NRegistros - 1 ) ) > 0 ) + { + fseek( handle_BDatos, (long)( ( BDatosHeader.NRegistros - 1 ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &old_inx, sizeof( BTree ), 1, handle_BDatos ); + } else { + old_inx.pos = ( BDatosHeader.NRegistros - 1 ); + BDatosHeader.NRegTotal++; + } + +// |<---------- RegTot ----------->| +// |<----- NRegistros ---->| | +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// +// 2 up Âpos+1 +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ * ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// 2 down Âpos +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ * ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + + avance = ( BDatosHeader.NRegistros - 1 ); + while ( avance > ( pos + ab ) ) + { + fseek( handle_BDatos, (long)( ( avance - 1 ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx, sizeof( BTree ), 1, handle_BDatos ); + + fseek( handle_BDatos, (long)( ( avance ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fwrite( &inx, sizeof( BTree ), 1, handle_BDatos ); + + avance--; + }; + + if ( ( BDatosHeader.NRegistros - 1 ) == 0 ) + fseek( handle_BDatos, sizeof( Header ), SEEK_SET); + else { + ab = ( ( BDatosHeader.NRegistros - 1 ) <= ( pos + ab ) ) ? 0 : ab; + fseek( handle_BDatos, (long)( ( pos + ab ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + } + + NRegActual = ( BDatosHeader.NRegistros - 1 ) == 0 ? 0 : pos + ab; + old_inx.code = ' '; + fwrite( &old_inx, sizeof( BTree ), 1, handle_BDatos ); + + fseek( handle_BDatos, (long)( ( old_inx.pos ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) + sizeof( BTree ) ), SEEK_SET ); + fwrite( dato, BDatosHeader.SizeReg, 1, handle_BDatos ); + + rewind( handle_BDatos ); + fwrite( &BDatosHeader, sizeof( Header ), 1, handle_BDatos ); + + return OK; + +} + + + + /**************************************************************************\ +| | +| DelReg | +| | +| Descripcion: | +| Borra un registro, de la posici¢n 'pos' | +| | +| | +| Entradas: posici¢n a borrar | +| | +| Salidas: (ninguna) | +| | + \**************************************************************************/ +int BDatos::DelReg( long pos ) +{ + BTree inx, old_inx; + + if ( rError == ERROR ) + { + lError = 0x05; ObtenError( lError ); + return ERROR; + } + + BDatosHeader.NRegistros--; + if ( pos > BDatosHeader.NRegistros || pos < 0) + { + BDatosHeader.NRegistros++; + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + fseek( handle_BDatos, (long)( ( pos ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &old_inx, sizeof( BTree ), 1, handle_BDatos ); + +// |<---------- RegTot ----------->| +// |<----- NRegistros ---->| | +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// + + unsigned long avance; + + avance = pos; + while ( avance < BDatosHeader.NRegistros ) + { + fseek ( handle_BDatos, (long)( ( avance + 1 ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread ( &inx, sizeof( BTree ), 1, handle_BDatos ); + + fseek ( handle_BDatos, (long)( ( avance ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fwrite( &inx, sizeof( BTree ), 1, handle_BDatos ); + + avance++; + }; + + NRegActual = BDatosHeader.NRegistros == 1 ? 0 : ( BDatosHeader.NRegistros - 1); + fseek( handle_BDatos, (long)( ( BDatosHeader.NRegistros ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + + old_inx.code = '*'; + fwrite( &old_inx, sizeof( BTree ), 1, handle_BDatos ); + + rewind( handle_BDatos ); + fwrite( &BDatosHeader, sizeof( Header ), 1, handle_BDatos ); + + return OK; +} + + /**************************************************************************\ +| | +| ShortReg | +| | +| Descripcion: | +| Corta el fichero y lo hace mas peque¤o. | +| | +| | +| Entradas: (ninguna) | +| | +| Salidas: (ninguna) | +| | + \**************************************************************************/ +int BDatos::ShortReg(void) +{ + long avance, recorrido; + BTree inx, curr_inx; + void *SWAPdatos; + char enc; + + if ( ( BDatosHeader.NRegTotal - BDatosHeader.NRegistros ) <= 0 ) return OK; + + if ( ( SWAPdatos = calloc( 1, BDatosHeader.SizeReg ) ) == NULL ) + { + lError = 0x07; ObtenError( lError ); + return ERROR; + } + + avance = BDatosHeader.NRegTotal-1; + while( avance >= BDatosHeader.NRegistros ) + { + // Obtengo la direcci¢n del campo que est  libre y el dato. + fseek( handle_BDatos, (long)( ( avance ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx, sizeof( BTree ), 1, handle_BDatos ); + fread( SWAPdatos, BDatosHeader.SizeReg, 1, handle_BDatos ); + + // Busco la direcci¢n del indice para la ficha actual. + recorrido = avance; enc = FALSO; + while( recorrido >= 0 && !enc ) + { + fseek( handle_BDatos, (long)( ( recorrido ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &curr_inx, sizeof( BTree ), 1, handle_BDatos ); + if ( curr_inx.pos == avance ) + enc = CIERTO; + else + recorrido--; + } + + // Si alguien de fuera referencia a esa ficha... + if ( enc ) + { + curr_inx.pos = inx.pos; + //Actualizo el indice para comunicarle la nueva posici¢n. + fseek( handle_BDatos, (long)( ( recorrido ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fwrite( &curr_inx, sizeof( BTree ), 1, handle_BDatos ); + // Pongo la ficha actual en la direcci¢n libre. + fseek ( handle_BDatos, (long)( ( curr_inx.pos ) * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) + sizeof( BTree ) ), SEEK_SET ); + fwrite( SWAPdatos, BDatosHeader.SizeReg, 1, handle_BDatos ); + } + + avance--; + + }; + + // Actualizo la base de registros + NRegActual = BDatosHeader.NRegistros - 1; + BDatosHeader.NRegTotal = BDatosHeader.NRegistros; + rewind( handle_BDatos ); + fwrite( &BDatosHeader, sizeof( Header ), 1, handle_BDatos ); + + // Corto todo lo que sobra de fichero + if ( chsize( fileno(handle_BDatos), (long)(sizeof( Header ) + ( BDatosHeader.NRegistros * ( sizeof( BTree ) + BDatosHeader.SizeReg ) )) ) == -1 ) + { + lError = 0x08; ObtenError( lError ); + return OK; // Este error no es del todo grave, pero se avisa. + } + + free( SWAPdatos ); + return OK; +} + + + /**************************************************************************\ +| | +| ObtenError | +| | +| Descripcion: | +| Obtiene el error correspondiente al codigo dado. | +| | +| | +| Entradas: codigo de error | +| | +| Salidas: (ninguna) | +| | + \**************************************************************************/ +void BDatos::ObtenError( int code ) +{ + + switch( code ) + { + case 0x00: + strcpy( cError, "No hay errores" ); + break; + case 0x01: + strcpy( cError, "Imposible inicializar base de datos" ); + break; + case 0x02: + strcpy( cError, "No se puede abrir el fichero" ); + break; + case 0x03: + strcpy( cError, "Version de fich. incompatible" ); + break; + case 0x04: + strcpy( cError, "No se pudo acceder a esa posici¢n." ); + break; + case 0x05: + strcpy( cError, "No hay base de datos en uso..." ); + break; + case 0x06: + strcpy( cError, "Tama¤os de estructuras no coinciden" ); + break; + case 0x07: + strcpy( cError, "Memoria insuficiente. Operaci¢n cancelada" ); + break; + case 0x08: + strcpy( cError, "Acceso de operacion no permitida." ); + break; + } + +} + + + /**************************************************************************\ +| | +| SortReg | +| | +| Descripcion: | +| Ordena la base de datos seg£n especifique el usuario en su | +| funci¢n fcmp... | +| | +| Entradas: /**************************************************************\ | +| | fcmp || +| | || +| | Descripcion: || +| | funci¢n de entrada a SortReg, debe ser realizada || +| | por el usuario y debe ce¤irse a sus par metros.. || +| | || +| | Entradas: ptrs. a dos estructuras de usuario. ( ejm. A, B ) || +| | Salidas: >> 0 si A >> B || +| | == 0 si A == B || +| | << 0 si A << B || +| \************************************************************** | +| | +| | +| | +| | +| Salidas: ERROR se cargan los registros con el codigo de error esp. | +| OK todo ha ido bien | +| | + \**************************************************************************/ +int BDatos::SortReg( int (*fcmp)(const void *, const void *) ) +{ + char dev; + + // Pido memoria para mantener dos elementos auxiliares + if ( + ( A = calloc( 1, BDatosHeader.SizeReg ) ) == NULL || + ( B = calloc( 1, BDatosHeader.SizeReg ) ) == NULL + ) + { + lError = 0x07; ObtenError( lError ); + return ERROR; + } + + dev = SortRegi( fcmp, 0, BDatosHeader.NRegistros-1 ); + + free(A); free(B); + + return dev; +} + +int BDatos::SortRegi( int (*fcmp)(const void *, const void *), long izquierda, long derecha ) +{ + BTree inx1, inx2; + register long i, j; + + i = izquierda; j = derecha; + if ( LeeReg( A, (long)(izquierda+derecha)/2 + 1 ) != OK ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + + do { + if ( LeeReg( B, i )!= OK ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + while( i < derecha && fcmp( B, A ) < 0 ) + { + i++; + if ( LeeReg( B, i ) != OK ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + }; + + LeeReg( B, j ); + while( j > izquierda && fcmp( A, B ) < 0 ) + { + j--; + if ( LeeReg( B, j ) != OK ) + { + lError = 0x04; ObtenError( lError ); + return ERROR; + } + }; + + if ( i <= j ) + { + // Intercambiamos solo los indices sin chequear si son + // accesibles, ( si no lo fueran, se abria abortado ) + fseek( handle_BDatos, (long)( i * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx1, sizeof( BTree ), 1, handle_BDatos ); + fseek( handle_BDatos, (long)( j * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fread( &inx2, sizeof( BTree ), 1, handle_BDatos ); + + fseek( handle_BDatos, (long)( j * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fwrite( &inx1, sizeof( BTree ), 1, handle_BDatos ); + fseek( handle_BDatos, (long)( i * ( sizeof( BTree ) + BDatosHeader.SizeReg ) + sizeof( Header ) ), SEEK_SET ); + fwrite( &inx2, sizeof( BTree ), 1, handle_BDatos ); + + i++; j--; + } + + } while( i <= j ); + + if ( izquierda < j ) SortRegi( fcmp, izquierda, j ); + if ( i < derecha ) SortRegi( fcmp, i, derecha ); + + return OK; +} + diff --git a/BDATOS.EXE b/BDATOS.EXE new file mode 100644 index 0000000..4763e66 Binary files /dev/null and b/BDATOS.EXE differ diff --git a/BDATOS.HH b/BDATOS.HH new file mode 100644 index 0000000..3be4b0d --- /dev/null +++ b/BDATOS.HH @@ -0,0 +1,144 @@ + /**************************************************************************\ +| | +| Clase para el tratamiento de Bases de Datos | +| | +| Jos‚ David Guill‚n 1996 (c) | +| | +| | + \**************************************************************************/ + + +#if !defined(__BDatos_HH) +#define __BDatos_HH + +#include + +#define OK 0 +#define ERROR 1 +#define NO_ENC -1 + +#define ARRIBA 1 +#define ABAJO 0 + +#if !defined(__BDatos_CPP) + #ifdef __cplusplus + extern "C" { + #endif +#endif + + typedef struct + { + char ProgName[15]; // Estos datos se comprueban al abrir la base + char VerHi, VerLow; // para saber si es la adecuada para su progr. + + char Other[200]; + } YourHeader; + + typedef struct + { + char NBD[13]; + char Eof_Code; + char VerHi, VerLow; + YourHeader MyHeader; + long NRegistros; + long NRegTotal; + long SizeReg; + } Header; + + class BDatos { + + public: + + char lError; + char cError[80]; + YourHeader MyHeader; + + void ObtenError(int code); // Obtiene el error "code" + long Registros(void); // N§ de registros + long NRegTotal(void); // N§ de registros + long RegActual(void); // Reg. Actual + + BDatos(); // Constructor de Clase + ~BDatos(); // Destructor de Clase + int AbrirReg( char *file, long sizereg ); // Abre el Fichero + void CerrarReg( void ); // Cierra el Fich. + int EscribeReg( void *dato, long pos ); // Escribe un Dato + int LeeReg( void *dato, long pos ); // Lee un Dato + int InsReg( void *dato, long pos, char ab ); // Inserta un Reg en pos. + int DelReg( long pos ); // Borra un Reg de pos. + + int ShortReg(void); // Corta el fich. y lo hace mas peque¤o + + // Ordena la Base + int SortReg( int (*fcmp)(const void *, const void *) ); + // Busca un registro en una base ordenada + int BuscReg( long PosIni, int (*fcmp)(const void *, const void *) ); + + private: + // Funcion auxiliar de ordenaci¢n + int SortRegInt( long k, long n, int (*fcmp)(const void *, const void *)); + + FILE *handle_BDatos; // Handle a la Base + Header BDatosHeader; + long NRegActual; + char filename[80]; + char rError; + }; + + +#if !defined(__BDatos_CPP) + #ifdef __cplusplus + } + #endif +#endif + +#endif + + + +/* + 1 2 3 4 5 6 7 8 9 0 + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ 6 ³ 9 ³ 1 ³ 4 ³ 5 ³ ³ ³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + +INS (2_3) + (si existen archivos borrados: " (TotalRecords+1) mark * " coge su posicion ) + + 1 2 3 4 5 6 7 8 9 0 + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ 6 ³ 9 ³ 1 ³ 4 ³ 5 ³*X1³*X2³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + ÀÄÄ^ÀÄÄ^ÀÄÄ^ÀÄÄ^ÀÄÄ^ ³ + ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ X2³ 6 ³ 9 ³ 1 ³ 4 ³ 5 ³*X2³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + + (si no existen archivos borrados: coge la posicion de Records + 1 ) + + 1 2 3 4 5 6 7 8 9 0 + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ 6 ³ 7 ³ 1 ³ 4 ³ 5 ³ ³ ³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + ÀÄÄ^ÀÄÄ^ÀÄÄ^ÀÄÄ^ÀÄÄ^ + ÀÄrecords = 7ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ + ÄÂÄ + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³7+1³ 6 ³ 7 ³ 1 ³ 4 ³ 5 ³ ³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + ÄÁÄ +DEL (3) + 1 2 3 4 5 6 7 8 9 0 + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ X ³ 6 ³ 9 ³ 1 ³ 4 ³ 5 ³ ³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + ³^ÄÄÙ^ÄÄÙ^ÄÄÙ^ÄÄÙ /.\ + ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ + ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ + ³ 2 ³ 3 ³ 6 ³ 9 ³ 1 ³ 4 ³ 5 ³*X ³ ³ ³ ³ ³ ³ + ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + Á Reg Mark * +*/ + + diff --git a/BDATOS.PRJ b/BDATOS.PRJ new file mode 100644 index 0000000..0e5d210 Binary files /dev/null and b/BDATOS.PRJ differ diff --git a/D.BAT b/D.BAT new file mode 100644 index 0000000..a1a05ac --- /dev/null +++ b/D.BAT @@ -0,0 +1 @@ +xcopy dummy.bak dummy.fil /y diff --git a/DUMMY.FIL b/DUMMY.FIL new file mode 100644 index 0000000..2678d15 Binary files /dev/null and b/DUMMY.FIL differ diff --git a/PDATOS.CPP b/PDATOS.CPP new file mode 100644 index 0000000..a72eba7 --- /dev/null +++ b/PDATOS.CPP @@ -0,0 +1,190 @@ +#include +int InsReg( long pos, char ab ); + +long NRegistros = 9; + +char BTree_code[100] = { '*', 32, 32, 32, 32, 32, 32, 32, 32, '*', '*', '*'}; +long BTree_pos [100] = { 10, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 11 }; +long NRegTot = 12; + +#define ARRIBA 1 +#define ABAJO 0 +#define OK 0 +#define ERROR 1 +#define NO_ENC -1 + +int DelReg( long pos ); + +void main(void) +{ + int pos, ab; + pos = 0; + printf("\n"); + while ( pos < NRegTot ) + { printf( " %c%d ", BTree_code[pos], BTree_pos[pos] ); pos++; } + + printf("\nIntroduzca posici¢n, y metodo ( ARRIBA=1, ABAJO=0 ) --->"); + scanf( "%d %d", &pos, &ab ); + if ( ab < 0 || ab > 1 ) return; + +// InsReg( pos, ab ); + DelReg( pos ); + pos = 0; + printf("\n"); + while ( pos < NRegTot ) + { printf( " %c%d ", BTree_code[pos], BTree_pos[pos] ); pos++; } + + + +} + +int InsReg( long pos, char ab ) +{ + NRegistros++; + if ( pos >= (NRegistros-1) && NRegistros != 1) + { + NRegistros--; +// ObtenError( 0x04 ); + printf( "\nError registro no valido" ); + return ERROR; + } + +// char RegTot; + long dir_libre; + char codigo; + +/* + fseek( handle_BTree, 0L, SEEK_END ); + RegTot = ( ftell( handle_BTree ) - HeaderLen ) / ( sizeof(long) + sizeof(char) ); +*/ + + // Si hay fichas eliminadas, utilizamos sus direcciones intermedias. + if ( (NRegTot - ( NRegistros - 1 ) ) > 0 ) + { + dir_libre = BTree_pos[NRegistros-1]; + codigo = BTree_code[NRegistros-1]; +/* + fseek( handle_BTree, ( ( sizeof(long) + sizeof(char) ) * ( NRegistros ) ) + Header_Len ), SEEK_SET ); + fread( &dir_libre, sizeof(long), 1, handle_BTree ); + fread( &codigo, sizeof(char), 1, handle_BTree ); +*/ + // si la supuesta ficha eliminada, no lo esta, utilizamos la siguiente + if ( codigo != '*' ) + dir_libre = NRegistros; + } else + dir_libre = ( NRegistros - 1 ); + +// |<---------- RegTot ----------->| +// |<----- NRegistros ---->| | +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// +// 2 up Âpos+1 +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ * ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// 2 down Âpos +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ * ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ + + unsigned long avance; + avance = ( NRegistros - 1 ); + while ( avance > ( pos + ab ) ) + { +/* + fseek( handle_BTree, ((sizeof(long)+sizeof(char))*(avance-1))+HeaderLen, SEEK_SET); + fread( &dirch , sizeof(long), 1, handle_BTree ); + fread( &codch , sizeof(char), 1, handle_BTree ); + + fwrite( &dirch , sizeof(long), 1, handle_BTree ); + fwrite( &codch , sizeof(char), 1, handle_BTree ); +*/ + BTree_code[avance] = BTree_code[avance-1]; + BTree_pos [avance] = BTree_pos [avance-1]; + avance--; + } + if ( ( NRegistros - 1 ) == 0 ) + //fseek( handle_BTree, HeaderLen, SEEK_SET); + {BTree_code[0] = ' '; BTree_pos[0] = dir_libre;} + else + //fseek( handle_BTree, ((sizeof(long)+sizeof(char))*(pos + ab))+HeaderLen, SEEK_SET); + {BTree_code[pos+ab] = ' '; BTree_pos[pos+ab] = dir_libre;} +/* + codch = ' '; + fwrite( &dir_libre, sizeof(long), 1, handle_BTree ); + fwrite( &codch , sizeof(char), 1, handle_BTree ); +*/ +/* + fseek( handle_BDatos, ( ( SizeReg*dir_libre ) + HeaderLen ), SEEK_SET ); + fwrite( datos, SizeReg, 1, handle_BDatos ); + + fseek( handle_BTree, 14L, SEEK_SET ); + fwrite( &NRegistro, sizeof(long), 1, handle_BTree ); +*/ + + +} + +int DelReg( long pos ) +{ + long old_dir; + char new_cod; +/* + NRegistros++; + if ( pos >= (NRegistros-1) && NRegistros != 1) +*/ + NRegistros--; + if ( pos >= (NRegistros+1) ) + { + NRegistros++; + printf( "\nError registro no valido\n" ); + return ERROR; + } + +/* + fseek( handle_BTree, ( ( sizeof(long) + sizeof(char) ) * pos ) + Header_Len ), SEEK_SET ); + fread( &old_dir, sizeof(long), 1, handle_BTree ); +*/ + old_dir = BTree_pos[pos]; + +// |<---------- RegTot ----------->| +// |<----- NRegistros ---->| | +// ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ +// ³ 1 ³ 2 ³ 5 ³ 6 ³ 4 ³ 3 ³ * ³ * ³ ³ ³ ³ ³ ³ +// ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ +// + + unsigned long avance; + + avance = pos; + while ( avance < (NRegistros /*+ 1*/) ) + { +/* + fseek( handle_BTree, ((sizeof(long)+sizeof(char))*(avance+1))+HeaderLen, SEEK_SET); + fread( &dirch , sizeof(long), 1, handle_BTree ); + fread( &codch , sizeof(char), 1, handle_BTree ); + fseek( handle_BTree, ((sizeof(long)+sizeof(char))*( avance ))+HeaderLen, SEEK_SET); + fwrite( &dirch , sizeof(long), 1, handle_BTree ); + fwrite( &codch , sizeof(char), 1, handle_BTree ); +*/ + BTree_code[avance] = BTree_code[avance+1]; + BTree_pos [avance] = BTree_pos [avance+1]; + avance++; + } +/* + fseek( handle_BTree, ((sizeof(long)+sizeof(char))*(NRegistros+1))+HeaderLen, SEEK_SET); + + new_cod = '*'; + fwrite( &old_dir, sizeof(long), 1, handle_BTree ); + fwrite( &new_cod, sizeof(char), 1, handle_BTree ); +*/ + BTree_code[avance] = '*'; + BTree_pos [avance] = old_dir; + +/* + fseek ( handle_BTree, (sizeof(char)*14), SEEK_SET ); + fwrite( &NRegistros, sizeof(long), 1, handle_BTree ); +*/ +} diff --git a/PDATOS.EXE b/PDATOS.EXE new file mode 100644 index 0000000..d9b9d50 Binary files /dev/null and b/PDATOS.EXE differ diff --git a/PRUEBA.CPP b/PRUEBA.CPP new file mode 100644 index 0000000..8fd36ec --- /dev/null +++ b/PRUEBA.CPP @@ -0,0 +1,297 @@ + /*************************************************************************\ +| | +| Programa para probar el buen funcionamiento de la libreria BDatos .(JD) | +| | +| 12.03.96 | + \*************************************************************************/ +#include +#include +#include +#include + +#include "BDatos.hh" + +void Altas(void); +void Bajas(void); +void Listar(void); +void Modificar(void); +void MuestraMenu(void); +int Busca( char *nombre ); +void Insertar_Especial(void); + +void RellenaBase(void); +int fcmp( const void *A, const void *B ); + + +typedef struct +{ + char nombre[15]; + char apellidos[50]; + long DNI; + int Grupo; +} DummyStruct; + +DummyStruct dummy; + +BDatos DummyBase; + +int main(void) +{ + int ok = 0; + + strcpy( DummyBase.MyHeader.ProgName, "Dummy Prog..." ); + DummyBase.MyHeader.VerHi = 1; + DummyBase.MyHeader.VerLow = 0; + if ( DummyBase.AbrirReg( "dummy.fil", sizeof( DummyStruct ) ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + return 1; + } + + do + { + MuestraMenu(); + switch( getch() ) + { + // Altas + case '1': + Altas(); + break; + // Bajas + case '2': + Bajas(); + break; + // Modificaciones + case '3': + Modificar(); + break; + // Listar + case '4': + Listar(); + break; + // CortarRegistros + case '5': + DummyBase.ShortReg(); + break; + // Altas + case '6': + Insertar_Especial(); + break; + // Ordena la base segun nombre + case '7': + DummyBase.SortReg( fcmp ); + break; + case '8': + RellenaBase(); + break; + + // Fin + case '0': + ok = 1; + break; + + }; + }while( !ok ); + + DummyBase.CerrarReg(); + + return 0; +} + +void MuestraMenu(void) +{ + clrscr(); + cprintf(" M E N é P R I N C I P A L \r\n"); + cprintf("-------------------------------\r\n"); + + cprintf(" 1 Altas ³ nReg: %ld \r\n", DummyBase.Registros() ); + cprintf(" 2 Bajas ³ nRegT: %ld \r\n", DummyBase.NRegTotal() ); + cprintf(" 3 Modificaciones ³ CReg: %ld \r\n", DummyBase.RegActual() ); + cprintf(" 4 Listar ³ --- \r\n"); + cprintf(" 5 Cortar Fichero ³ _-ù J.D ù-_\r\n"); + cprintf(" ³ ù-_ F.V _-ù\r\n"); + cprintf(" 0 Salir al DOS ³ --- \r\n"); + cprintf(" ³ F R i \r\n"); + cprintf(" 6 Ins. Especial ³ u e S \r\n"); + cprintf(" 7 Ordenar Campo ³ T N i \r\n"); + cprintf(" ³ u O V \r\n"); +} + +void RellenaBase(void) +{ + int ficha; + + cprintf("\r\nRellenando base con 800 fichas. Por favor, espere..."); + + for( ficha=0; ficha<800; ficha++ ) + { + sprintf( dummy.nombre, "P%03d", (800-ficha) ); + sprintf( dummy.apellidos, "P%03d", ficha ); + dummy.DNI = ficha; + dummy.Grupo = ficha; + + // Inserta un Reg por arriba de pos. + if ( DummyBase.InsReg( (void *)&dummy, ficha, ARRIBA ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + exit(1); + } + } +} + +void Altas(void) +{ + cprintf("\r\nIntroduzca: ( nombre, apellidos, DNI, Grupo ) \r\n"); + scanf( "%14s %49s %ld %d", dummy.nombre, dummy.apellidos, &dummy.DNI, &dummy.Grupo ); + + // Inserta un Reg por arriba de pos. + if ( DummyBase.InsReg( (void *)&dummy, DummyBase.Registros(), ARRIBA ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + exit(1); + } +} + +void Insertar_Especial(void) +{ + int PorDonde, Adonde; + + cprintf("\r\nIntroduzca: ( nombre, apellidos, DNI, Grupo ) \r\n"); + scanf( "%14s %49s %ld %d", dummy.nombre, dummy.apellidos, &dummy.DNI, &dummy.Grupo ); + fflush(stdin); + + cprintf("\r\nIntroduzca donde y por donde insertar (1==ARRIBA)(0==ABAJO): "); + scanf( "%d %d", &Adonde, &PorDonde ); + fflush(stdin); + + PorDonde = ( PorDonde == 1 ) ? ARRIBA : ABAJO ; + + // Inserta un Reg por arriba de pos. + if ( DummyBase.InsReg( (void *)&dummy, Adonde, PorDonde ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + + cprintf("\r\nRegistros aun abiertos, condici¢n metaestable"); + } +} + +void Bajas(void) +{ + char nombTMP[80]; + cprintf("\r\nIntroduzca nombre a eliminar: "); + scanf( "%14s", nombTMP ); + + if ( Busca( nombTMP ) != OK ) + { + cprintf( "\r\nFichero no se encuentra en la base" ); + getch(); + return; + } + + if ( DummyBase.LeeReg( (void *)&dummy, DummyBase.RegActual() ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + exit(1); + } + + cprintf( "%14s %40s %5ld %5d\n\r", dummy.nombre, dummy.apellidos, dummy.DNI, dummy.Grupo ); + + if ( getch() == 32 ) return; + + // Borra el registro de la posicion actual + if ( DummyBase.DelReg( DummyBase.RegActual() ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + exit(1); + } +} + +void Modificar(void) +{ + char nombTMP[80]; + + cprintf("\r\nIntroduzca nombre a modificar: "); + scanf( "%14s", nombTMP ); + + if ( Busca( nombTMP ) != OK ) + { + cprintf( "\r\nFichero no se encuentra en la base" ); + getch(); + return; + } + + + cprintf("\r\nIntroduzca: ( nombre, apellidos, DNI, Grupo ) \r\n"); + scanf( "%14s %49s %ld %d", dummy.nombre, dummy.apellidos, &dummy.DNI, &dummy.Grupo ); + + // Escribe el Reg en la base + if ( DummyBase.EscribeReg( (void *)&dummy, DummyBase.RegActual() ) != OK ) + { + cprintf("\r\nSe producio un error: %d", DummyBase.lError ); + cprintf("\r\n%s\r\n", DummyBase.cError ); + DummyBase.CerrarReg(); + exit(1); + } + +} + +void Listar( void ) +{ + int i; + cprintf( " Nombre Apelidos D.N.I Grupo \n\r" ); + cprintf( "------------------------------------------------------------------------------\n\r" ); + + + for( i=0; i nombre, ((DummyStruct *)B) -> nombre ); +} +