/*
*
@(SH) Funzioni per la gestione dei file ISAM
@(C$) PRIVATE
logname : nome del file di LOG (GIORNALE)
INTTLOCK : costante che indica alla funzione di lettura che e' stata chaimata dalla funzione di scrittura e quindi deve solo controllare lo stato di lock del record
ISLOCKED : costante che indica che il record e' bloccato
@(VG$) PRIVATE
KSv, PosSv : variabili di lavoro
PagSv, IndSv : variabili di lavoro
IndActive : stato indici - TRUE = Aggiornati ad ogni modifica, FALSE = aggiorna solo i dati
isstate : Stato transazione corrente
win,wisfd : variabili di lavoro
isjournal : TRUE scrive il giornale
openf : array di TUTTI i puntatori ai descrittori dei file ISAM aperti
-------------------------------------------------------------------------------
*/
#include "cisam.h"
#include "libdefs.h"
#include "checks.h"
#ifdef __WATCOMC__
#include <malloc.h>
#else
#include <memory.h>
#endif
#define logname "log.gen"
#define INTTLOCK 0xF000
#define ISLOCKED 225
#define NOALLOC (char **) -1
TKey KSv;
int PosSv;
RecNoType PagSv,IndSv;
BOOLEAN IndActive = TRUE;
int isstate = NOTRANS ;
int wln = -1;
isfdptr wisfd;
extern BOOLEAN isjournal;
/* Guy moved them here from extcdecl.h */
Str80 cprefix;
isfdptr* openf;
void savekeystat(isdef *);
void restkeystat(isdef *,int );
int addkeys(isdef *,RecType ,int ,int *);
int delkeys(isdef *,RecType ,int ,int *);
int replkeys(isdef *,RecType ,RecType ,int ,int *);
#ifndef DOS
void writeundo(int ,isdef *,RecType);
void writelog(int ,isdef *,RecType);
char *undoname(void);
void getopenf(int ,RecType *);
#endif
/*
@($) savekeystat ISAM
@(ID)
Salva la chiave corrente.
@(FD)
*/
void savekeystat(isfd)
isfdptr isfd; /* descrittore del file ISAM */
{
strcpy(KSv,isfd->i.Key);
IndSv = isfd->i.Ind;
PosSv = isfd->i.Pos;
PagSv = isfd->i.CurPag;
}
/*
@($) restkeystat ISAM
@(ID)
Ripristina la chiave corrente.
@(FD)
*/
void restkeystat(isfd,knum)
isfdptr isfd; /* descrittore del file ISAM */
int knum; /* numero della chiave */
{
isfd->i.PN = knum - 1;
strcpy(isfd->i.Key,KSv);
isfd->i.Ind = IndSv;
isfd->i.Pos = PosSv;
isfd->i.CurPag = PagSv;
}
/*
@($) relisfd ISAM
@(ID)
Vuota il descrittore del file .
@(FD)
*/
void relisfd(isfd)
isfdptr *isfd; /* descrittore del file ISAM */
{
free((char *) (*isfd)->d);
free((char *) (*isfd)->r);
free((char *) (*isfd));
}
/*
@($) getisfd ISAM
@(ID)
Alloca e carica il descrittore del file con numero logico "logicname".
@(FD)
*/
void getisfd(isfd, logicname)
isdef **isfd; /* descrittore del file ISAM */
int logicname; /* numero logico del file */
{
(*isfd) = (isfdptr) malloc(sizeof(**isfd));
(*isfd)->d = (FileDes *) malloc(sizeof(*((*isfd)->d)));
(*isfd)->r = (RecDes *) malloc(sizeof(*((*isfd)->r)));
COpenDir(ManuLock, NORDIR);
CGetFile(logicname, (*isfd)->d, NoLock, NORDIR);
if ((!(STREMPTY((*isfd)->d->SysName))) && ((*isfd)->d->SysName[0] != '$'))
(*isfd)->ft = COMDIR;
else
(*isfd)->ft = NORDIR;
CCloseDir(NORDIR);
COpenDir(ManuLock, (*isfd)->ft);
COpenFile(logicname, (*isfd)->d, NoLock, (*isfd)->ft);
CCloseDir((*isfd)->ft);
COpenRecDir(ManuLock, (*isfd)->ft);
CGetRec(logicname,(*isfd)->r, (*isfd)->ft);
CCloseRecDir((*isfd)->ft);
}
/*void dump(s,l)
RecType s;
int l;
{
message_box("dump : record: %s ", &s[1]);
}*/
/*
@(#) cisupdflags ISAM
@(ID)
Aggiorna all'interno del direttorio i campi EOD e Flags.
Ritorna il codice di errore.
@(FD)
@(ISV)
wd = riga relativa al file ISAM in oggetto nel Direttorio.
fdir = identificatore del file direttorio.
- Versione DOS e XENIX
@(FSV)
@(IN)
Il campo Flags viene aggiornato comunque, mentre EOD viene aggiornato solo
se il parametro di input "updateeod" e' TRUE.
@(FN)
*/
int cisupdflags(isfd,err,updateeod)
isdef *isfd; /* puntatore al descrittore del file ISAM */
int *err; /* codice di errore */
BOOLEAN updateeod; /* se TRUE si aggiorna anche EOD */
{
FileDes wd;
*err = NoErr ;
if (isfd->ln <= 0) return(*err) ;
COpenDir( ManuLock, isfd->ft);
COpenFile(isfd->ln, &wd, Lock, isfd->ft);
if ((*err = fdir[isfd->ft].IOR) == NoErr)
{
wd.Flags = isfd->d->Flags;
/* #ifdef DOS
if (updateeod) wd.EOD = isfd->d->EOD;
#else */
if ((updateeod) && (isfd->f.LockMode == ExclLock)) wd.EOD = isfd->d->EOD;
/* #endif */
CCloseFile(isfd->ln, &wd, isfd->ft);
}
CCloseDir(isfd->ft);
return(*err);
}
/*
@(#) cisgeteod ISAM
@(ID)
Ritorna l' EOD del file.
@(FD)
@(ISV)
- Versione DOS e XENIX
@(FSV)
*/
RecNoType cisgeteod(isfd,err)
isfdptr isfd; /* puntatore al descrittore del file ISAM */
int *err; /* codice di errore */
{
*err = NoErr ;
if (isfd->ln > 0)
{
COpenDir( ManuLock , isfd->ft);
COpenFile(isfd->ln, isfd->d, NoLock, isfd->ft);
CCloseDir(isfd->ft);
}
return(isfd->d->EOD) ;
}
/*
@(#) cisopen ISAM
@(ID)
Apre un file ISAM e alloca il buffer per un record a attiva la chiave 1 (uno).
Ritorna il codice di errore.
@(FD)
@(ISV)
werr = variabile di lavoro che raccoglie il codice errore proveniente dalla CBCloseFile.
s = stringa di lavoro per messaggi di errore.
- Versione DOS e XENIX
@(FSV)
@(IN)
@(FN)
*/
int cisopen (isfd,logicname,record,mode,err)
isfdptr *isfd; /* puntatore al descrittore del file */
int logicname; /* numero logico */
RecType *record; /* buffer per contenere un record */
unsigned int mode; /* modo di apertura (lock) */
int *err; /* codice di errore */
{
*err = NoErr;
if (openf[logicname - 1] != NULL)
fatal_box("File n. %d already open", logicname);
#ifndef DOS
if ((excllock(CInsPref(glockname, NORDIR), FALSE) == -1) && (errno == EACCES))
fatal_box("Can't open directory : Error n. %d ", errno);
#endif
getisfd (isfd,logicname);
COpen(&((*isfd)->f), (*isfd)->d->SysName, (*isfd)->d->LenR, 0, mode);
if (*err = (*isfd)->f.IOR)
{
Str80 name; strcpy(name, (*isfd)->d->SysName);
relisfd(isfd);
isfd = NULL;
if (*err == 13)
{
if (mode == ExclLock)
fatal_box("L'archivio n. %d (%s) non puo' essere aperto in modo esclusivo", logicname, name);
else
fatal_box("L'archivio n. %d (%s) e' stato aperto in modo esclusivo da un altro programma", logicname, name);
}
fatal_box("Can't open file n. %d (%s): error %d ", logicname, name, *err);
}
if ((*isfd)->r->NKeys)
{
Str80 name; strcpy(name, CGetIdxName((*isfd)->d->SysName));
CBOpenFile (&((*isfd)->i), name, mode, err);
if (*err)
{
CClose(&((*isfd)->f));
relisfd(isfd);
isfd = NULL;
if (*err == 13)
{
if (mode == ExclLock)
fatal_box("L'indice n. %d (%s) non puo' essere aperto in modo esclusivo", logicname, name);
else
fatal_box("L'indice n. %d (%s) e' stato aperto in modo esclusivo da un altro programma", logicname, name);
}
fatal_box("Can't open index n. %d (%s): error %d ",
logicname, name, *err);
}
#ifndef DOS
else
if (mode == ExclLock)
{
CBLockFile(&((*isfd)->i), err);
if (*err)
{
int werr;
CClose(&((*isfd)->f));
CBCloseFile(&((*isfd)->i), &werr);
relisfd(isfd);
fatal_box("Can't open exclusively file n. %d: error %d ", logicname, *err);
}
}
#endif
}
if (record != NOALLOC)
*record = (RecType) malloc((*isfd)->d->LenR);
(*isfd)->ln = logicname;
openf[logicname - 1] = *isfd;
if ((*isfd)->r->NKeys) (*isfd)->i.PN = 0;
return (*err);
}
/*
@(#) ciscopyrec ISAM
@(ID)
Copia un record dati da un record ad un altro.
Ritorna il codice di errore.
@(FD)
@(ISV)
d = riga del direttorio corrispondente al file in esame.
@(FSV)
@(IN)
@(FN)
*/
int ciscopyrec(logicname,recdest, recsrc ,err)
int logicname; /* numero logico del file ISAM */
RecType recdest; /* buffer destinazione */
RecType recsrc; /* buffer sorgente */
int *err; /* codice di errore */
{
FileDes d;
int ft;
*err = NoErr;
if (logicname < 0) logicname = -logicname;
if (openf[logicname - 1] != NULL) d = *(openf[logicname - 1]->d);
{
COpenDir(ManuLock, NORDIR);
CGetFile(logicname, &d, NoLock, NORDIR);
if ((!(STREMPTY(d.SysName))) && (d.SysName[0] != '$')) ft = COMDIR;
else ft = NORDIR;
CCloseDir(NORDIR);
COpenDir(ManuLock, ft);
COpenFile(logicname, &d, NoLock, ft);
CCloseDir(ft);
}
memcpy(recdest, recsrc, d.LenR);
return(*err);
}
/*
@(#) cisallocrec ISAM
@(ID)
Alloca il buffer per un record.
Ritorna il codice di errore.
@(FD)
@(ISV)
d = riga del direttorio corrispondente al file in esame.
@(FSV)
@(IN)
@(FN)
*/
int cisallocrec(logicname,record,err)
int logicname; /* numero logico del file ISAM */
RecType *record; /* buffer per il record */
int *err; /* codice di errore */
{
FileDes d;
int ft;
*err = NoErr;
if (logicname < 0) logicname = -logicname;
if (openf[logicname - 1] != NULL) d = *(openf[logicname - 1]->d);
else
{
COpenDir(ManuLock, NORDIR);
CGetFile(logicname, &d, NoLock, NORDIR);
if ((!(STREMPTY(d.SysName))) && (d.SysName[0] != '$')) ft = COMDIR;
else ft = NORDIR;
CCloseDir(NORDIR);
COpenDir(ManuLock, ft);
COpenFile(logicname, &d, NoLock, ft);
CCloseDir(ft);
}
*record = (RecType) malloc(d.LenR);
if (*record == ((RecType) NULL)) return(ENOMEM);
else return(*err);
}
/*
@(#) cisclose ISAM
@(ID)
Chiude un file ISAM e libera il buffer del record.
Ritorna il codice di errore.
@(FD)
@(ISV)
werr = variabile di lavoro che raccoglie il codice errore proveniente dalla CBCloseFile.
s[20] = stringa di lavoro per messaggi di errore.
- Versione DOS e XENIX
@(FSV)
@(IN)
Restituisce il codice di errore
@(FN)
*/
int cisclose(isfd,rec,err)
isdef **isfd; /* puntatore al descrittore del file */
RecType *rec; /* buffer per il record */
int *err; /* codice di errore */
{
int werr = NoErr;
*err = NoErr;
if (((*isfd)->ln > 0) && ((*isfd == NULL) || (openf[(*isfd)->ln - 1] == NULL)))
{
if (*isfd != NULL)
error_box("File n. % isclose : Error n. %d ", (*isfd)->ln, IsNotOpen);
else
error_box("isclose : errore n. %d ", IsNotOpen);
}
CClose(&((*isfd)->f));
*err = ((*isfd)->f.IOR);
if ((*isfd)->r->NKeys)
{
CBCloseFile(&((*isfd)->i), &werr);
if (werr != NoErr ) *err = werr;
}
if ((*isfd)->ln > 0)
openf[(*isfd)->ln - 1] = NULL ;
if ((rec != NULL) && (*rec != NULL))
free(*rec);
relisfd(isfd);
#ifndef DOS
exclunlock(CInsPref(glockname, NORDIR), FALSE);
#endif
if (*err)
fatal_box("isclose : Error n. %d ", *err);
return (*err);
}
/*
@(#) cisstart ISAM
@(ID)
Esegue una lettura cambiando il numero di chiave attiva.
Ritorna il codice di errore.
@(FD)
@(IN)
La variabile record in input contiene i campi necessari per la ricerca,
in output contiene il record letto.
La variabile mode e' formata da un comando di lock + comando di posizionamento
. Se non si utilizza ISEQUAL o ISGREAT o ISGTEQ, il valore della variabile
record non ha nessuna importanza.
@(FN)
*/
int cisstart(isfd,keynum,record,mode,err)
isfdptr isfd; /* descrittore del file ISAM */
int keynum; /* numero della chiave */
RecType record; /* buffer per il record */
unsigned int mode; /* comando di lettura */
int *err; /* codice di errore */
{
if(isfd == ((isfdptr) NULL)) return ((*err = IsNotOpen));
*err = NoErr;
if(!(keynum >= 1) && (keynum <= isfd->r->NKeys))
return((*err = BTrPathErr));
isfd->i.PN = keynum - 1;
*err = cisread(isfd,record,mode,err);
return(*err);
}
/*
@(#) cisread ISAM
@(ID)
Esegue una lettura utilizzando la chiave attiva.
Ritorna il codice di errore.
@(FD)
@(ISV)
rmode = variabile che contiene il tipo lettura utilizzato.
lmode = varibaile dhe contiene il tipo lock utilizzato.
knum = numero chiave attiva.
junk = variabile spazzatura per la chiamata alla funzione "sleep".
times = variabile di lavoro.
s = stringa contenente messaggio.
w = descrittore finestra .
internaltlock = flag che verifica se la isread e' stata chiamata da iswrite per testare l' esistenza di un record.
@(FSV)
@(IN)
La variabile record in input contiene i campi necessari per la ricerca,
in output contiene il record letto.
La variabile mode e' formata da un comando di lock + comando di posizionamento
. Se non si utilizza ISEQUAL o ISGREAT o ISGTEQ, il valore della variabile
record non ha nessuna importanza.
@(FN)
*/
int cisread(isfd,record,mode,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record;/* buffer per il record */
unsigned int mode; /* modo di lettura */
int *err; /* codice di errore */
{
unsigned int rmode = (mode & READTYPES),
lmode = (mode & RecLockTypes),
knum = (isfd->i.PN+1);
int junk,times = 1;
TKey key,key1,key2;
/* char s[120]; */
BOOLEAN internaltlock = (lmode == INTTLOCK);
if (internaltlock) lmode = ShareLock;
*err = NoErr ;
if (isfd == ((isfdptr) NULL)) return ((*err = IsNotOpen));
if (rmode & (IsPrevN + IsNextN))
{
times = rmode & BYTEMASK;
if (rmode & IsPrevN) rmode = IsPrev;
else rmode = IsNext;
}
if (rmode == IsCurr)
{
if (!isfd->RecNo) return((*err = IsNotCurr));
}
else
{
if (rmode == IsNext)
{
while ((times--) && (!*err))
{
CBNext(&isfd->i,knum,key1,&isfd->RecNo,err);
}
}
else
{
if (rmode == IsPrev)
{
while ((times--) && (!*err))
{
CBPrev(&isfd->i,knum,key1,&isfd->RecNo,err);
}
}
else
{
if (rmode == IsFirst) MinKey(CCalcLenKey(isfd->r,knum),key);
else
if (rmode == IsLast) MaxKey(CCalcLenKey(isfd->r,knum),key);
else
CBuildKey(isfd->r,knum,record,key);
CBRead(&isfd->i,knum,key,key1,&isfd->RecNo,err);
if ((rmode == IsGreat) && (!*err))
while ((strcmp(key,key1) == 0) && (!*err))
CBNext (&isfd->i,knum,key1,&isfd->RecNo,err);
}
}
}
do
{
if (((*err) && (rmode == IsEqual)) ||
((*err == BTrEOF) && (rmode == IsGreat)))
CRead(&isfd->f,record,isfd->RecNo,NoLock);
else
CRead(&isfd->f,record,isfd->RecNo,lmode);
if (TESTLOCK(isfd->f.IOR))
{
if (lmode == ShareLock)
{
if (!*err) *err = ISLOCKED;
break;
}
message_box("Codice %s in uso da parte\ndi un altro utente.", key1);
if (rmode != IsCurr)
{
CBReRead(&isfd->i,knum,key1,key2,isfd->RecNo,&isfd->RecNo,&junk);
if (junk) strcpy(key1, key2) ;
}
}
else
if (!*err) *err = isfd->f.IOR;
} while (TESTLOCK(isfd->f.IOR)) ;
if (((rmode == IsFirst) || (rmode == IsLast)) && (*err != BTrEmptyTree))
*err = NoErr;
if ((rmode == IsGtEq) && (*err != BTrEOF) && (*err != BTrEmptyTree))
*err = NoErr ;
if (DEADLOCK(*err)) return(*err = IsDeadLock);
if (rmode == IsCurr)
{
CBuildKey(isfd->r,knum,record,key);
CBReRead(&isfd->i,knum,key,key1,isfd->RecNo,&isfd->RecNo,&junk);
}
if (*err == BTrEmptyTree) CZeroRec(isfd->r, record);
return(*err);
}
/*
@($) addkeys ISAM
@(ID)
Aggiunge all'indice le chiavi contenute nel record.
Ritorna il codice di errore.
@(FD)
@(ISV)
i,j = contatori.
werr = codice errore restituito dalla CBDelete.
key = valore delle chiavi.
@(FSV)
@(IN)
@(FN)
*/
int addkeys (isfd,record,knum,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer per il record */
int knum; /* numero chiave corrente */
int *err; /* codice errore */
{
int i,j,werr;
TKey key;
for (i = 1;(i <= isfd->r->NKeys) && (!*err);i++)
{
CBuildKey(isfd->r,i,record,key);
CBWrite(&isfd->i,i,key,isfd->RecNo,err);
if (i == knum) savekeystat(isfd);
}
if (*err)
{
if (i == 2 && *err == BTrDupKeysNotAll) *err = IsReInsert;
for (j = 1; (j < i); j++)
{
CBuildKey(isfd->r,j,record,key);
CBDelete(&isfd->i,j,key,isfd->RecNo,&werr);
}
}
else restkeystat(isfd,knum);
return(*err);
}
/*
@(#) ciswrite ISAM
@(ID)
Aggiunge un nuovo record al file ISAM.
Ritorna il codice di errore.
@(FD)
@(ISV)
werr = codice errore restituito.
knum = numero chiave attiva.
junk = variabile di lavoro per la chiamata di varie funzioni.
wrec = buffer di lavoro.
@(FSV)
@(IN)
La variabile record in input contiene il record da aggiungere.
@(FN)
*/
int ciswrite (isfd,record,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer per il record */
int *err; /* codice di errore */
{
int knum = (isfd->i.PN+1), werr, junk;
RecNoType neweox;
*err = NoErr;
if(isfd == ((isfdptr) NULL)) return((*err = IsNotOpen));
if (isfd->ln > 0)
{
COpenDir (ManuLock, isfd->ft);
COpenFile(isfd->ln,isfd->d, NoLock, isfd->ft);
}
if (isfd->d->EOD == isfd->d->EOX)
{
neweox = isfd->d->EOX / 20 + 1;
if (neweox < 10) neweox = 10;
if (demoflag)
*err = IsFileFull;
else
{
neweox += isfd->d->EOX;
cisextend(isfd, isfd->ln, neweox, err);
}
if (*err == NoErr)
{
if (isfd->ln > 0)
{
COpenFile(isfd->ln,isfd->d, NoLock, isfd->ft);
for (junk = 0; junk < isfd->r->NKeys; junk++)
isfd->i.Base[junk].PEOX = neweox;
}
else
{
isfd->d->EOX = neweox;
if (isfd->f.LockMode == ExclLock)
for (junk = 0; junk < isfd->r->NKeys; junk++)
isfd->i.Base[junk].PEOX = neweox;
}
}
else
{
if (isfd->ln > 0)
CCloseDir(isfd->ft);
isfd->RecNo = 0;
if (DEADLOCK(*err)) *err = IsDeadLock;
return((*err ? *err : (*err = IsFileFull)));
}
}
IRecallRec(record);
if (/* test_share() && */ isfd->f.LockMode != ExclLock)
{
RecType wrec = malloc(isfd->d->LenR);
memcpy(wrec, record, isfd->d->LenR);
savekeystat(isfd);
junk = cisstart(isfd, 1, wrec, NoLock+IsEqual, &junk);
restkeystat(isfd, knum);
free(wrec);
if ((junk == NoErr) || (junk == ISLOCKED))
{
*err = IsReInsert;
if (isfd->ln > 0)
CCloseDir(isfd->ft);
isfd->RecNo = 0;
return(*err);
}
}
if (isfd->ln > 0)
{
COpenFile(isfd->ln,isfd->d, Lock, isfd->ft);
}
isfd->RecNo = (++isfd->d->EOD);
if ((isfd->r->NKeys) && IndActive)
{
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i,err) ;
if (!addkeys(isfd, record, knum, err))
{
CWrite(&isfd->f,record,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR))
{
isfd->RecNo = 0;
junk = delkeys(isfd, record, knum, &werr);
}
/* else
if (isfd->ln > 0)
CCloseFile(isfd->ln,isfd->d, isfd->ft) ; */
}
else isfd->d->EOD-- ;
if (isfd->ln > 0)
{
CCloseFile(isfd->ln,isfd->d, isfd->ft) ;
}
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBUnLockFile(&isfd->i, &werr) ;
}
else
{
CWrite(&isfd->f,record,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR)) isfd->RecNo = 0;
else CCloseFile(isfd->ln,isfd->d, isfd->ft) ;
}
if (!(*err))
{
#ifndef DOS
if (isstate == NOTRANS) writelog(FNWRITE, isfd, record);
else writeundo(FNWRITE, isfd, record);
#endif
}
if (isfd->ln > 0)
CCloseDir(isfd->ft);
/* if (test_share()) */
{
junk = cisunlock(isfd, &junk);
if (isstate == NOTRANS)
CLockRec(&isfd->f,isfd->RecNo,UnLock);
if (DEADLOCK(*err)) *err = IsDeadLock;
}
return(*err);
}
/*
@($) delkeys ISAM
@(ID)
Cancella le chiavi contenute nel record dall'indice.
Ritorna il codice di errore.
@(FD)
@(ISV)
i,j = contatori.
werr = codice errore da CBWrite.
key = valori chiave.
@(FSV)
@(IN)
@(FN)
*/
int delkeys (isfd,record,knum,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer per il record */
int knum; /* numero della chiave attuale */
int *err; /* codice di errore */
{
int i,j,werr;
TKey key;
for (i = 1;(i <= isfd->r->NKeys)&&(!*err);i++)
{
CBuildKey(isfd->r,i,record,key);
CBDelete(&isfd->i,i,key,isfd->RecNo,err);
}
if (*err)
{
for (j = 1;(j < i);j++)
{
CBuildKey(isfd->r,j,record,key);
CBWrite(&isfd->i,j,key,isfd->RecNo,&werr);
}
}
else restkeystat(isfd,knum);
return(*err);
}
/*
@(#) cisdelete ISAM
@(ID)
Cancella un record da un file ISAM.
Ritorna il codice di errore.
@(FD)
@(ISV)
knum = numero chiave successiva a quella attiva.
werr = codice errore da CBUnLockFile.
key1,key = valori chiave.
- Versione DOS e XENIX
@(FSV)
@(IN)
La variabile record in input contiene il record da cancellare.
@(FN)
*/
int cisdelete(isfd,record,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer per il record */
int *err; /* codice di errore */
{
int knum = (isfd->i.PN+1), werr;
TKey key,key1;
if(isfd == ((isfdptr) NULL)) return((*err = IsNotOpen));
*err = NoErr;
savekeystat(isfd);
CBuildKey(isfd->r,1,record,key);
*err = NoErr ;
CBRead(&isfd->i,1,key,key1,&isfd->RecNo,err);
if (*err)
{
restkeystat(isfd,knum);
return(*err);
}
CRead(&isfd->f, record, isfd->RecNo, NoLock);
if ((*err = isfd->f.IOR))
{
restkeystat(isfd,knum);
return(*err);
}
if ((isfd->r->NKeys) && IndActive)
{
if( /* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i,err) ;
delkeys(isfd, record, knum, err) ;
}
IDeleteRec(record);
CWrite(&isfd->f,record,isfd->RecNo,UnLock);
if((*err = isfd->f.IOR))
{
IRecallRec(record);
CWrite(&isfd->f,record,isfd->RecNo,NoLock);
if ((isfd->r->NKeys) && IndActive) addkeys(isfd, record, knum, err) ;
restkeystat(isfd,knum);
}
#ifndef DOS
else
{
if (isstate == NOTRANS)
{
writelog(FNDELETE, isfd, NULL);
CRead(&isfd->f,record,isfd->RecNo,UnLock);
}
else writeundo(FNDELETE, isfd, NULL);
}
if (/* test_share() && */(isfd->r->NKeys) && IndActive &&
(isfd->f.LockMode != ExclLock))
CBUnLockFile(&isfd->i, &werr) ;
#else
/* if (test_share()) */
{
CRead(&isfd->f,record,isfd->RecNo,UnLock);
if (isfd->r->NKeys && IndActive &&
(isfd->f.LockMode != ExclLock))
CBUnLockFile(&isfd->i, &werr) ;
}
#endif
return(*err);
}
/*
@($) replkeys ISAM
@(ID)
Rimpiazza le chiavi all'interno dell'indice.
Ritorna il codice di errore.
@(FD)
@(ISV)
i,j = contatori.
werr = codice errore ritornato da CBDelete e CBWrite.
key,key1 = valori delle chiavi.
@(FSV)
*/
int replkeys (isfd,oldrec,record,knum,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType oldrec; /* buffer contenente il vecchio record */
RecType record; /* buffer contenente il nuovo record */
int knum; /* numero della chiave attuale */
int *err; /* codice di errore */
{
int i,j,werr;
TKey key,key1;
for (i = 1;(i <= isfd->r->NKeys)&&(!*err);i++)
{
CBuildKey(isfd->r,i,record,key);
CBuildKey(isfd->r,i,oldrec,key1);
if (strcmp(key,key1) != 0)
{
CBDelete(&isfd->i,i,key1,isfd->RecNo,err);
if (*err) break;
CBWrite(&isfd->i,i,key,isfd->RecNo,err);
if (*err) CBWrite(&isfd->i,i,key1,isfd->RecNo,err);
if (i == knum) savekeystat(isfd);
}
}
if (*err)
{
for (j = 1;(j < i);j++)
{
CBuildKey(isfd->r,j,record,key);
CBuildKey(isfd->r,j,oldrec,key1);
if (strcmp(key,key1) != 0)
{
CBDelete (&isfd->i,j,key,isfd->RecNo,&werr);
CBWrite(&isfd->i,j,key1,isfd->RecNo,&werr);
}
}
}
else restkeystat(isfd,knum);
return(*err);
}
/*
@(#) cisrewrite ISAM
@(ID)
Aggiorna un record nel file ISAM.
Ritorna il codice di errore.
@(FD)
@(ISV)
knum = numero chiave successiva all'attuale.
werr = codice errore restituito da CBUnLock.
key, key1 = valori delle chiavi.
oldrec = buffer di lavoro.
- Versione DOS e XENIX
@(FSV)
@(IN)
La variabile record in input contiene il record da aggiornare.
Utilizza la chiave 1 per ritrovare il record da aggiornare.
@(FN)
*/
int cisrewrite(isfd,record,err)
isfdptr isfd; /* descrittore del file isam */
RecType record; /* buffer contenente i record */
int *err; /* codice di errore */
{
int knum = (isfd->i.PN+1), werr;
TKey key,key1;
RecType oldrec;
*err = NoErr ;
if(isfd == ((isfdptr) NULL)) return((*err = IsNotOpen));
oldrec = (RecType) malloc(isfd->d->LenR);
savekeystat(isfd);
IRecallRec(record);
CBuildKey(isfd->r,1,record,key);
CBRead(&isfd->i,1,key,key1,&isfd->RecNo,err);
if(*err)
{
restkeystat(isfd,knum);
return(*err);
}
CRead(&isfd->f,oldrec,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR))
{
restkeystat(isfd,knum);
free(oldrec);
return(*err);
}
if (memcmp(oldrec,record,isfd->d->LenR) == 0)
{
*err = NoErr;
restkeystat(isfd,knum);
CLockRec(&isfd->f,isfd->RecNo,UnLock);
free(oldrec);
return(*err);
}
if ((isfd->r->NKeys) && IndActive)
{
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i, err) ;
replkeys(isfd, oldrec, record, knum, err) ;
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBUnLockFile(&isfd->i, &werr) ;
}
CWrite(&isfd->f,record,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR))
{
CWrite(&isfd->f,oldrec,isfd->RecNo,NoLock);
replkeys(isfd, record, oldrec, knum, err) ;
restkeystat(isfd,knum);
}
else
#ifndef DOS
{
if (isstate == NOTRANS)
{
writelog(FNREWRITE, isfd, record);
CLockRec(&isfd->f,isfd->RecNo,UnLock);
}
else writeundo(FNREWRITE, isfd, oldrec);
}
#else
/* if (test_share()) */
CLockRec(&isfd->f,isfd->RecNo,UnLock);
#endif
free(oldrec);
return(*err);
}
/*
@(#) cisdelcurr ISAM
@(ID)
Cancella il record corrente.
Ritorna il codice di errore.
@(FD)
*/
int cisdelcurr(isfd,err)
isfdptr isfd; /* descrittore del file ISAM */
int *err; /* codice di errore */
{
if(isfd->RecNo) cisdelrec(isfd,isfd->RecNo,err);
else *err = IsNotCurr;
return(*err);
}
/*
@(#) cisrewcurr ISAM
@(ID)
Riscrive il record corrente.
Ritorna il codice di errore.
@(FD)
@(IN)
La variabile record in input contiene il record da aggiornare.
@(FN)
*/
int cisrewcurr(isfd,record,err)
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer contenente il record */
int *err; /* codice di errore */
{
if(isfd->RecNo) cisrewrec(isfd,isfd->RecNo,record,err);
else *err = IsNotCurr;
return (*err);
}
/*
@(#) cisreadrec ISAM
@(ID)
Legge un record di numero "recnum".
Ritorna il codice di errore.
@(FD)
*/
int cisreadrec(isfd,recnum,record,mode,err)
isfdptr isfd; /* descrittore del file ISAM */
RecNoType recnum; /* numero del record */
RecType record; /* buffer per il record */
unsigned int mode; /* modo di lock */
int *err; /* codice di errore */
{
isfd->RecNo = recnum;
return(cisread(isfd,record,IsCurr+(mode & RecLockTypes),err));
}
/*
@(#) ciswriterec ISAM
@(ID)
Riscrive un record di numero "recnum".
@(FD)
@(IN)
La variabile record in input contiene il record da aggiornare.
@(FN)
@(ISV)
knum = numero chiave attiva.
werr = codice errore restituito da CBUnLockFile.
oldrec = buffer di lavoro.
- Versione DOS e XENIX
@(FSV)
*/
int cisrewrec(isfd,recnum,record,err)
isfdptr isfd; /* descrittore del file ISAM */
RecNoType recnum; /* numero del record da riscrivere */
RecType record; /* buffer per il record */
int *err; /* codice di errore */
{
int knum = (isfd->i.PN+1), werr;
RecType oldrec;
*err = NoErr;
if (isfd == ((isfdptr) NULL)) return ((*err = IsNotOpen));
oldrec = (RecType) malloc(isfd->d->LenR);
isfd->RecNo = recnum;
IRecallRec(record);
CRead(&isfd->f,oldrec,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR))
{
free(oldrec);
return(*err);
}
if (memcmp(oldrec,record,isfd->d->LenR) == 0)
{
*err = NoErr;
/* if (test_share()) */
CLockRec(&isfd->f,isfd->RecNo,UnLock);
free(oldrec);
return(*err);
}
if ((isfd->r->NKeys) && IndActive)
{
if (/* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i, err) ;
replkeys(isfd, oldrec, record, knum, err) ;
if (/* test_share() && */ isfd->f.LockMode != ExclLock)
CBUnLockFile(&isfd->i, &werr) ;
}
if (isstate == NOTRANS) CWrite(&isfd->f,record,isfd->RecNo,UnLock);
else CWrite(&isfd->f,record,isfd->RecNo,NoLock);
if ((*err = isfd->f.IOR))
{
CWrite(&isfd->f,oldrec,isfd->RecNo,NoLock);
replkeys(isfd, record, oldrec, knum, err) ;
}
#ifndef DOS
else
{
if (isstate == NOTRANS)
{
writelog(FNREWRITE, isfd, record);
CLockRec(&isfd->f,isfd->RecNo,UnLock);
}
else writeundo(FNREWRITE, isfd, oldrec);
}
#else
/* if (test_share()) */
CLockRec(&isfd->f,isfd->RecNo,UnLock);
#endif
free(oldrec);
return(*err);
}
/*
@(#) cisdelrec ISAM
@(ID)
Cancella un record utilizzando un numero di record.
Ritorna il codice di errore.
@(FD)
@(IN)
La variabile record in input contiene il record da cancellare.
@(FN)
@(ISV)
knum = numero della chiave attiva.
werr = codice di errore restituito da CBUnLockFiles.
oldrec = buffer di lavoro.
key1 = valore della chiave.
- Versione DOS e XENIX
@(FSV)
*/
int cisdelrec(isfd,recnum,err)
isfdptr isfd; /* descrittore del file ISAM */
RecNoType recnum; /* numero di record */
int *err; /* codice di errore */
{
int knum = (isfd->i.PN+1), werr;
int junk;
RecType oldrec ;
TKey key1 ;
*err = NoErr;
if(isfd == (isfdptr) NULL) return ((*err = IsNotOpen));
oldrec = (RecType) malloc(isfd->d->LenR);
isfd->RecNo = recnum;
savekeystat(isfd);
CRead(&isfd->f, oldrec, isfd->RecNo, NoLock);
if ((*err = isfd->f.IOR))
{
free(oldrec);
return(*err);
}
if ((isfd->r->NKeys) && IndActive)
{
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i, err) ;
delkeys(isfd, oldrec, knum, err);
}
IDeleteRec(oldrec);
CWrite(&isfd->f,oldrec,isfd->RecNo,UnLock);
if ((*err = isfd->f.IOR))
{
IRecallRec(oldrec);
CWrite(&isfd->f,oldrec,isfd->RecNo,NoLock);
if ((isfd->r->NKeys) && IndActive) addkeys(isfd, oldrec, knum, err);
}
#ifndef DOS
else
{
if (isstate == NOTRANS)
{
writelog(FNDELETE, isfd, NULL);
CLockRec(&isfd->f,isfd->RecNo,UnLock);
}
else writeundo(FNDELETE, isfd, NULL);
}
if (/* test_share() && */(isfd->r->NKeys) && IndActive && (isfd->f.LockMode != ExclLock))
CBUnLockFile(&isfd->i, &werr) ;
#else
/* if (test_share()) */
{
CLockRec(&isfd->f,isfd->RecNo,UnLock);
if (isfd->r->NKeys && IndActive &&
(isfd->f.LockMode != ExclLock))
CBUnLockFile(&isfd->i, &werr) ;
}
#endif
free(oldrec);
isfd->RecNo = 0;
return(*err);
}
/*
@(#) cisgetrecno ISAM
@(ID)
Restituisce il numero del record corrente.
@(FD)
*/
RecNoType cisgetrecno(isfd, err)
isfdptr isfd; /* descrittore del file ISAM */
int *err; /* codice di errore */
{
if (!isfd->RecNo) *err = IsNotCurr;
else *err = NoErr;
return(isfd->RecNo);
}
/*
@(#) cislock ISAM
@(ID)
Blocca il file ISAM.
@(FD)
@(ISV)
junk = variabile spazzatura per la chiamata di sleep.
@(FSV)
*/
int cislock(isfd,err)
isfdptr isfd; /* descrittore del file ISAM */
int *err; /* codice di errore */
{
int junk;
*err = NoErr ;
if (lseek(isfd->f.F, 0L, 0) == -1) return ((*err = CIOResult()));
#ifndef DOS
do
{
if (lockf(isfd->f.F,F_TLOCK,0L) == -1)
{
*err = CIOResult() ;
junk = sleep(1) ;
}
} while (TESTLOCK(*err)) ;
#endif
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBLockFile(&isfd->i,err);
return(*err);
}
/*
@(#) cisunlock ISAM
@(ID)
Sblocca un file ISAM.
@(FD)
*/
int cisunlock(isfd,err)
isfdptr isfd; /* descrittore del file */
int *err; /* codice di errore */
{
return(cisrelease(isfd,err));
}
/*
@(#) cisrelease ISAM
@(ID)
Sblocca un file ISAM.
@(FD)
*/
int cisrelease(isfd,err)
isfdptr isfd; /* descrittore del file ISAM */
int *err; /* codice di errore */
{
*err = NoErr ;
#ifndef DOS
if (lseek(isfd->f.F, 0L, 0) == -1) return ((*err = CIOResult()));
do
{
if (lockf(isfd->f.F,F_ULOCK,0L) == -1) *err = CIOResult() ;
} while (TESTLOCK(*err)) ;
#endif
if(/* test_share() && */ isfd->f.LockMode != ExclLock)
CBUnLockFile(&isfd->i,err);
return(*err);
}
/*
@(#) IndexOn ISAM
@(ID)
Attiva Aggiornamento Indici.
@(FD)
@(IN)
Di default gli indici sono attivi.
@(FN)
*/
void IndexOn()
{
IndActive = TRUE ;
}
/*
@(#) IndexOff ISAM
@(ID)
Disattiva l'aggiornamento Indici.
@(FD)
*/
void IndexOff()
{
IndActive = FALSE ;
}
#ifndef DOS
/*
@($) undoname ISAM
@(ID)
Restituisce il nome del file di Undo.
@(FD)
@(ISV)
path = stringa contenente il nome file.
@(FSV)
*/
char *undoname()
{
static PathSt path;
TMPFNAME(path, "undo");
return(path);
}
/*
@($) writeundo ISAM
@(ID)
Scrive una operazione effettuata nel file di Undo.
@(FD)
@(ISV)
fd = puntatore al file.
uname = nome del file di undo.
lgh = variabile di lavoro che contiene l' header del record di undo.
@(FSV)
*/
void writeundo(fntype,isfd,record)
int fntype; /* operazione da effettuare */
isfdptr isfd; /* descrittore del file */
RecType record; /* buffer contenente il record */
{
int fd;
PathSt uname;
loghead lgh;
if (isfd->ln <= 0) return ;
strcpy(uname ,undoname());
if ((fd = open(uname, O_WRONLY | O_CREAT | O_APPEND, 0666)) == -1)
fatal_box("Writeundo : Error n. %d ", errno);
lgh.type = fntype;
lgh.time = time(NULL);
lgh.procid = getpid();
lgh.userid = getuid();
lgh.filenum = isfd->ln;
lgh.recnum = isfd->RecNo;
lgh.lenrec = isfd->d->LenR;
if (write(fd, &lgh, sizeof(lgh)) == -1)
fatal_box("Writeundo : Error n. %d ", errno);
if (fntype & (FNREWRITE))
if (write(fd, record, lgh.lenrec) == -1)
fatal_box("Writeundo : Error n. %d ", errno);
if (close(fd) == -1)
fatal_box("Writeundo : Error n. %d ", errno);
}
/*
@($) writelog ISAM
@(ID)
Scrive sul file Giornale l'operazione effettuata.
@(FD)
@(ISV)
junk = variabile spazzatura per la chiamata di execunlock.
lname = nome del file Giornale (LOG).
fd = puntatore al file giornale.
lgh = testata del file giornale.
@(FSV)
*/
void writelog(fntype,isfd,record)
int fntype; /* operazione effetuata */
isfdptr isfd; /* descrittore del file ISAM */
RecType record; /* buffer per il record */
{
int fd,junk;
PathSt lname;
loghead lgh;
if (!isjournal) return;
if (isfd->ln <= 0) return ;
strcpy(lname, CInsPref(logname, NORDIR));
while (excllock(lname,TRUE) == -1) sleep(1);
if ((fd = open(lname, O_WRONLY | O_CREAT | O_APPEND, 0666)) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Writelog : Error n. %d ", errno);
}
lgh.type = fntype + FNSTTRANS;
lgh.time = time(NULL);
lgh.procid = getpid();
lgh.userid = getuid();
if (fntype & (FNREWRITE + FNWRITE + FNDELETE))
{
lgh.filenum = isfd->ln;
lgh.recnum = isfd->RecNo;
lgh.lenrec = isfd->d->LenR;
}
else
{
lgh.filenum = 0;
if (fntype == FNREORG) lgh.recnum = *((RecNoType *) record);
else lgh.recnum = 0L;
if (fntype == FNCHGREC) lgh.lenrec = sizeof(RecDes);
else lgh.lenrec = 0;
}
if (write(fd, &lgh, sizeof(lgh)) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Writelog : Error n. %d ", errno);
}
if (fntype & (FNREWRITE + FNWRITE + FNCHGREC))
if (write(fd, record, lgh.lenrec) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Writelog : Error n. %d ", errno);
}
if (close(fd) == -1)
fatal_box("Writelog : Error n. %d ", errno);
junk = exclunlock(lname,TRUE);
}
#endif
/*
@(#) StTrans ISAM
@(ID)
Inizia una transazione.
@(FD)
*/
void StTrans()
{
#ifndef DOS
if (isstate == TRANS) EndTrans();
#endif
isstate = TRANS;
}
#ifndef DOS
/*
@($) getopenf ISAM
@(ID)
Riconfigura il file di lavoro attivo sul file di numero logico "ln".
@(FD)
@(ISV)
junk = variabile spazzatura per la chiamata alla cisclose.
err = codice di errore ritornato dalla cisopen.
@(FSV)
*/
void getopenf(ln,record)
int ln; /* numero logico del file */
RecType *record; /* puntatore al buffer per il record */
{
int err,junk;
if (openf[ln - 1] == NULL)
{
if (wln != ln)
{
if (wln != -1) junk = cisclose(&wisfd ,record ,&err);
cisopen(&wisfd, ln, record, ManuLock, &err);
wln = ln;
}
}
else *record = realloc(*record, openf[ln - 1]->d->LenR);
}
#endif
/*
@(#) EndTrans ISAM
@(ID)
Chiude una transazione.
@(FD)
@(ISV)
fdl, fdu = puntatori ai file di LOG e di Undo.
lname, uname = nomi dei file di LOG e di Undo.
lgh, lgh1 = variabili di lavoro contenenti le testate dei file di log.
nread = variabile di lavoro per la chiamata alla read.
werr = codice di errore ritornato dalla cisclose.
junk = variabile spazzatura per la chiamata di exclunlock.
start = variabile di lavoro.
record = buffer di lavoro.
@(FSV)
*/
void EndTrans()
{
#ifndef DOS
int fdl, fdu;
PathSt lname, uname;
loghead lgh, lgh1;
int nread, werr, junk, start = FNSTTRANS;
RecType record;
strcpy(lname ,CInsPref(logname, NORDIR));
while (excllock(lname,TRUE) == -1) sleep(1);
if (((fdl = open(lname, O_WRONLY | O_CREAT | O_APPEND, 0666)) == -1) ||
((fdu = open(uname, O_RDONLY, 0666)) == -1))
{
junk = exclunlock(lname,TRUE);
fatal_box("Endtrans : Error n. %d ", errno);
}
while ((nread = read(fdu, &lgh, sizeof(lgh))) > 0)
{
lgh.type += start;
start = 0;
if (write(fdl, &lgh, sizeof(lgh)) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Endtrans : Error n. %d ", errno);
}
if (lgh.type == FNREWRITE)
if (lseek(fdu, (long) lgh.lenrec, 1) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Endtrans : Error n. %d ", errno);
}
getopenf(lgh.filenum, &record);
CRead(&(openf[lgh.filenum - 1]->f), record, lgh.recnum, UnLock);
if (write(fdl, record, lgh.lenrec) == -1)
{
junk = exclunlock(lname,TRUE);
fatal_box("Endtrans : Error n. %d ", errno);
}
}
if ((nread <= 0) || (close(fdu) == -1) || (close(fdl) == -1) ||
(unlink(uname) == -1))
{
junk = exclunlock(lname,TRUE);
fatal_box("Endtrans : Error n. %d ", errno);
}
if (wln != -1)
{
junk = cisclose(&wisfd, &record, &werr);
wln = -1;
}
junk = exclunlock(lname,TRUE);
#endif
}
/*
@(#) AbTrans ISAM
@(ID)
Abortisce una transazione.
@(FD)
*/
void AbTrans()
{
#ifndef DOS
int fd;
PathSt uname;
loghead lgh;
int nread, werr, junk;
RecType record;
RecType oldrec;
strcpy(uname ,undoname());
if ((fd = open(uname, O_RDONLY, 0666)) == -1)
fatal_box("Abtrans : Error n. %d ", errno);
while ((nread = read(fd, &lgh, sizeof(lgh))) > 0)
{
getopenf(lgh.filenum, &record);
if (oldrec == NULL) oldrec = malloc(lgh.lenrec);
else oldrec = realloc(oldrec, lgh.lenrec);
if (lgh.type & (FNREWRITE))
{
if ((nread = read(fd, record, lgh.lenrec)) <= 0)
fatal_box("Abtrans : Error n. %d ", errno);
}
if (lgh.lenrec != openf[lgh.filenum - 1]->d->LenR)
fatal_box("Abtrans : Error n. %d ", IsNoMatch);
CRead(&(openf[lgh.filenum - 1]->f), oldrec, lgh.recnum, NoLock);
switch (lgh.type)
{
case FNREWRITE :
junk = replkeys(openf[lgh.filenum - 1], oldrec, record,
openf[lgh.filenum - 1]->i.PN + 1, &werr);
CWrite(&(openf[lgh.filenum - 1]->f), record, lgh.recnum, UnLock);
break;
case FNDELETE :
IRecallRec(oldrec);
junk = addkeys(openf[lgh.filenum - 1], oldrec,
openf[lgh.filenum - 1]->i.PN + 1, &werr);
CWrite(&(openf[lgh.filenum - 1]->f), oldrec, lgh.recnum, UnLock);
break;
case FNWRITE :
IDeleteRec(oldrec);
junk = delkeys(openf[lgh.filenum - 1], oldrec,
openf[lgh.filenum - 1]->i.PN + 1, &werr);
CWrite(&(openf[lgh.filenum - 1]->f), record, lgh.recnum, UnLock);
break;
}
}
if ((nread == -1) || (close(fd) == -1) || (unlink(uname) == -1))
fatal_box("Abtrans : Error n. %d ", errno);
if (wln != -1)
{
junk = cisclose(&wisfd, &record, &werr);
wln = -1;
}
#endif
}