/***********************************************************\ * * * VFILE consists of 5 functions which simulate a "BASIC * * RANDOM FILE" structure using fixed length records of * * varying pre-specified size. A record may be up to 255 * * chars long. It is the programmer's responsibility to * * keep track of the contents of his record, and VFILE's * * responsibility to write and read the record to and from * * the correct position in file. Record numbers are * * maximum 32767. VFILE will give ERROR if reading past * * end of file or exceeding legal bounds. It will pad * * as-yet-unwritten internal records with nulls. An error * * is returned if there is not enough disk space for * * either the record or the padding. There is a sixth * * function (vset), which is used internally. * * * * The structure "_vbuf" must be included in the * * programme, and each file must reserve a VBUFSIZ area * * for buffering. This area will vary depending on NSECTS * * in BDSCIO.H THE VALUE OF NSECTS MUST BE GREATER * * THAN TWO. The definitions of _vbuf and VBUFSIZ * * should eventually find their way into BDSCIO.H * * I have included them in this source for clarity. * * * * telend finds the end of any sequential file and returns * * its record number. Only sequential extents are searched* * (i.e. it may not work on random files) * * * \************************************************************ Version 1.0 (c) 1980 Greg Lister Software Source P.O. Box 364 Edgecliff 2027 Australia 19th November, 1980 */ #include "bdscio.h" #define VBUFSIZ NSECTS * SECSIZ + 14 struct _vbuf { int fd; /* File Descriptor */ int eof; /* Actual EOF of file */ int pos; /* Current record's position in buffer */ int len; /* Record length */ int sta; /* Start sector of buffer */ int cnt; /* Number of sectors in buffer */ int wflag; /* flag set if buffer written to */ char buffer[NSECTS * SECSIZ]; }; vset(recno,vbuf) int recno; struct _vbuf *vbuf; /************************************************\ * * * Sets up buffer for random reads and writes. * * Flushes buffer if necessary and fills buffer * * with required data. Sets pointer to beginning* * of r/w record. Fills unwritten buffer with * * nulls. Returns ERROR if cannot flush or * * if hard read error. Returns NULL if * * required buffer is not yet written. Returns * * -2 if required sector (128 byte) is not yet * * written. Else returns valid sectors in buf. * * * \************************************************/ { int tmp,blkno,bss,blkoff,secno,bufsec,endrec; blkno=recno>>7; /* Block Number */ bss=blkno*vbuf->len; /* Block start Sector */ blkoff=(recno%128)*vbuf->len; /* Offset into Block */ secno=bss+(blkoff>>7); /* Sector # of start of rec */ endrec=bss+((blkoff+vbuf->len-1)>>7);/* Sec# END of rec */ bufsec=(secno/(NSECTS-2))*(NSECTS-2); /* Start sec of buf */ vbuf->pos=vbuf->buffer+((secno-bufsec)<<7)+(blkoff%128); if(bufsec!=vbuf->sta) { if(vbuf->wflag) { seek(vbuf->fd,vbuf->sta,0); if(write(vbuf->fd,vbuf->buffer,vbuf->cnt)cnt) return ERROR; if((tmp=tell(vbuf->fd))>vbuf->eof) vbuf->eof=tmp; vbuf->wflag=0; } if((vbuf->sta=bufsec)>vbuf->eof) return NULL; seek(vbuf->fd,bufsec,0); if((vbuf->cnt=read(vbuf->fd,vbuf->buffer,NSECTS))<0) return ERROR; if(vbuf->cnt!=NSECTS) fillb(vbuf->buffer+(vbuf->cnt<<7), vbuf->buffer+(NSECTS<<7),0,0); } if(endrec-bufsec>=vbuf->cnt) return -2; return vbuf->cnt; } vwrite(recno,vbuf,str) int recno; struct _vbuf *vbuf; char *str; /********************************************************\ * * * Writes data at str to file vbuf at recno. Pads file * * with NULLS if skipping unwritten sections of file. * * Returns ERROR if full disk, unopened file etc * * Returns ERROR if bad record #; else returns OK * * * \********************************************************/ { int tmp,tmp1,tmp2; if(recno<0) return ERROR; if((tmp=vset(recno,vbuf))==-1) return ERROR; if(tmp==0) { fillb(vbuf->buffer,NSECTS<<7,0,1); seek(vbuf->fd,vbuf->eof,0); while((vbuf->eof=tell(vbuf->fd))sta) if(write(vbuf->fd,vbuf->buffer,1)>1) return ERROR; } movmem(str,vbuf->pos,vbuf->len); tmp2=vbuf->buffer; tmp1=(127+vbuf->pos-tmp2+vbuf->len)>>7; if(tmp1>vbuf->cnt) vbuf->cnt=tmp1; vbuf->wflag=1; return OK; } vread(recno,vbuf,str) int recno; struct _vbuf *vbuf; char str[]; /************************************************\ * * * Reads record 'recno' from file to 'str'. * * Returns ERROR if hard error (unopened * * file etc) or if attempt is made to read * * past current end of file. Returns no of * * secs read in. ERROR if bad recno. * * * \************************************************/ { int tmp; if(recno<0) return ERROR; tmp=vbuf->sta; if(vset(recno,vbuf)<1) { vbuf->sta=tmp; return ERROR; } movmem(vbuf->pos,str,vbuf->len); return vbuf->cnt; } vclose(vbuf) struct _vbuf *vbuf; /************************************************\ * * * Closes file using vbuf. Returns OK if * * closed successfully. ERROR if error. * * * \************************************************/ { if(vbuf->wflag) { seek(vbuf->fd,vbuf->sta,0); if(write(vbuf->fd,vbuf->buffer,vbuf->cnt)<0) return ERROR; } return close(vbuf->fd); } vopen(filename,vbuf,reclen) int reclen; char filename[]; struct _vbuf *vbuf; /************************************************\ * * * Opens filename for v-format buffered io * * Reclen is the specified record length * * (may be up to 255 chars). Vbuf is a * * VBUFSIZ buffer ((128 * NSECTS)+14) * * **NOTE** NSECTS must be 3 or more for this * * file structure to work. * * Returns ERROR if reclen is out of range * * or if open error occurs (ie file doesn't * * exist - use vcreat) * * * \************************************************/ { if((vbuf->len=reclen)>255)return ERROR; if(reclen<0) return ERROR; if((vbuf->fd=open(filename,2))<0) return ERROR; vbuf->sta=vbuf->cnt=-1; vbuf->wflag=0; vbuf->pos=vbuf->buffer; vbuf->eof=telend(filename); return vbuf->fd; } vcreat(filename,vbuf,reclen) int reclen; char filename[]; struct _vbuf *vbuf; /************************************************\ * * * Creates a file as vopen (see above) * * * \************************************************/ { fabort(creat(filename)); return vopen(filename,vbuf,reclen); } telend(filename) char *filename; /************************************************\ * * * returns number of last 128-byte record in * * file 'filename'. Returns NULL if file * * is either nonexistent or empty. * * * \************************************************/ { int recnt; char fcb[38],ex; setfcb(fcb,filename); ex=recnt=0; while(1) { fcb[12]=ex++; if((bdos(15,fcb))==255) break; recnt+=fcb[15]; } return recnt; }