#include <codeb.h>

#define  MAXLEN         137     /* Lunghezza massima chiave  */


/*--------------------------------------------------------------------------
  inizializzazione di CodeBase e delle variabili necessarie
  questa funzione deve essere chiamata SOLO una volta all'interno
  di ciascun eseguibile
  --------------------------------------------------------------------------*/
void DB_init(void)
{
}

/*--------------------------------------------------------------------------
  reset di CodeBase
  questa funzione dovrebbe essere chiamata prima di uscire da un eseguibile
  per una questione di correttezza formale. Non usandola comunque non acca-
  de niente di drammatico
  --------------------------------------------------------------------------*/
void DB_exit(void)
{
}

/*-------------------------------------------------------------------------
  apertura del file 'filename'. Il parametro mode consente se != 0 l'apertura
  esclusiva. Il parametro index consente se == 0 l'apertura senza indici.
	Ritorna l'handle del file aperto oppure -1 in caso di errore
  --------------------------------------------------------------------------*/
int  DB_open(const char *filename,int mode,int index)
{
  return -1;
}


/*-------------------------------------------------------------------------
  chiusura del database inviduato da handle
  torna -1 se il database non puo essere chiuso, 0 altrimenti
  --------------------------------------------------------------------------*/
int  DB_close(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  torna il puntatore al buffer del record del database individuato da
  handle. In caso di errore torna (char *) 0
  --------------------------------------------------------------------------*/
char *DB_getrecord(int handle)
{
  return NULL;
}

/*-------------------------------------------------------------------------
  torna la lunghezza del record
  --------------------------------------------------------------------------*/
int  DB_reclen(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna la lunghezza della chiave corrente
  --------------------------------------------------------------------------*/

int DB_keylen(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  torna il numero del record attuale
  --------------------------------------------------------------------------*/
long int DB_recno(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna il numero complessivo dei records presenti nell'archivio
  --------------------------------------------------------------------------*/
long int DB_reccount(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  seleziona un indice sul database specificato
  torna -1 se errore, altrimenti 0
  --------------------------------------------------------------------------*/
int  DB_tagselect(int handle,int index_no)
{
  return -1;
}


/*-------------------------------------------------------------------------
  torna il numero dell'indice selezionato
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_tagget(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  si posiziona sul primo record
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_first(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  si posiziona sull'ultimorecord
  torna -1 se errore
  --------------------------------------------------------------------------*/
int DB_last(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  skip avanti di un record
  --------------------------------------------------------------------------*/
int DB_next(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  skip indietro di un record
  --------------------------------------------------------------------------*/
int DB_prev(int handle)
{
  return -1;
}


/*-------------------------------------------------------------------------
  skip di n records
  --------------------------------------------------------------------------*/
int DB_skip(int handle,long int recno)
{
  return -1;
}

/*-------------------------------------------------------------------------
  locka il record attuale
  --------------------------------------------------------------------------*/
int DB_lock(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  slocka il record attuale
  --------------------------------------------------------------------------*/
int DB_unlock(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  cerca la chiave, torna r4after se not found ma si e' posizionato sul record
  successivo, se torna r4eof e' su eof
  --------------------------------------------------------------------------*/
int DB_seek(int handle,char *key)
{
  return r4eof;
}

/*-------------------------------------------------------------------------
  torna 1 se eof, 0 altrimenti
  --------------------------------------------------------------------------*/
int DB_eof(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  torna 1 se tof, 0 altrimenti
  --------------------------------------------------------------------------*/
int DB_bof(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  legge un record per numero record
  --------------------------------------------------------------------------*/
int DB_go(int handle,long recno)
{
	return -1;
}

/*-------------------------------------------------------------------------
  cancella il record attuale. Non cancella le chiavi.
  --------------------------------------------------------------------------*/
int DB_delete(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  ripristina il record attuale
  --------------------------------------------------------------------------*/
int DB_recall(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  
  --------------------------------------------------------------------------*/
int DB_flush(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  riscrive il record attuale
  --------------------------------------------------------------------------*/
int DB_rewrite(int handle)
{
	return -1;
}


/*-------------------------------------------------------------------------
  appende il record attuale
  --------------------------------------------------------------------------*/
int DB_add(int handle)
{
	return -1;
}

/*-------------------------------------------------------------------------
  Blocca in modo esclusivo il file dati ed indice
  --------------------------------------------------------------------------*/
int DB_lockfile(int handle)
{
  return -1;
}

/*-------------------------------------------------------------------------
  Compatta il file dati
  --------------------------------------------------------------------------*/
int DB_packfile(short vis, const char * filename, long eod)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Compatta il file memo
  --------------------------------------------------------------------------*/
int DB_packmemo(short vis, const char * filename)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Elimina i record duplicati
  --------------------------------------------------------------------------*/
int DB_clean_file(int handle, char * filename, char * ff, RecDes * r, short vis)
{
  return -1;
}

/*-------------------------------------------------------------------------
  Compatta gli indici
  --------------------------------------------------------------------------*/
int DB_packindex(short vis, const char * filename, RecDes *r, long *peod, bool ask)
{
  return 0;
}


/*-------------------------------------------------------------------------
  costruisce il file filename
  --------------------------------------------------------------------------*/

int DB_build(const char * filename, RecDes *r)
{
  return -1;
}

/*-------------------------------------------------------------------------
  reperisce il tracciato record e la stringa di definizione delle chiavi
  Stringa di definizione chiavi:
  expression1|unique1$expression2|unique2$expression3|unique3
  --------------------------------------------------------------------------*/

int DB_recinfo(const char * filename, FileDes *d, RecDes *r, char* keys) 
{
  return -1
}

/*-------------------------------------------------------------------------
  ritorna l'ultimo errore
  --------------------------------------------------------------------------*/
int DB_get_error(void)
{
  return 0
}

/*-------------------------------------------------------------------------
  Azzera la viarabile globale d'errore
  --------------------------------------------------------------------------*/

void DB_zero_error(void)
{
}

/*-------------------------------------------------------------------------
  Si posiziona sull'indice attivo alla chiave indicata, restituisce
  la prima chiave che trova >= a from. (TCursor)
  --------------------------------------------------------------------------*/

int DB_index_seek(int handle, char* from)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna il numero di record corrispondente alla chiave corrente
  --------------------------------------------------------------------------*/

long DB_index_recno(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Si posiziona sulla chiave successiva dell'indice corrente
  --------------------------------------------------------------------------*/
long DB_index_next(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Restituisce la chiave corrente
  --------------------------------------------------------------------------*/

char* DB_index_getkey(int handle)
{
  return NULL;
}

/*-------------------------------------------------------------------------
  Restituisce vero se l'indice e' alla fine
  --------------------------------------------------------------------------*/

int DB_index_eof(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Blocca il record indicato
  --------------------------------------------------------------------------*/

int DB_lock_rec(int handle,long nrec)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna vero(non zero) se il file dati od indice sono stati bloccati
  in modo esclusivo dalla presente applicazione, non da altri programmi!!!
  --------------------------------------------------------------------------*/

int DB_file_locked(int handle)
{
  return 0;
}

/*-------------------------------------------------------------------------
  Ritorna vero se il record nrec e' bloccato dalla presente applicazione,
  non da altri programmi!!!
  --------------------------------------------------------------------------*/

int DB_rec_locked(int handle,long nrec)
{
  return 0;
}

/*-------------------------------------------------------------------------
  restituisce la configurazione della libreria
  --------------------------------------------------------------------------*/

long DB_getconf()
{
  return 0;
}

/*-------------------------------------------------------------------------
  Restituisce il numero di versione scritto sull'header dell'indice
  --------------------------------------------------------------------------*/

long DB_changed(int handle)
{
  return 0;
}

char* DB_memoptr( const int handle, const char * fieldname )
{
  return NULL;
}

int DB_memowrite( const int handle, const char * fieldname, const char * data )
{
  return NULL;
}