/*

QFile
Umberto Salsi <salsi@dsnet.it>
5 December 1995

Dev. system: THINK C 4.0

*/

typedef int  BOOLEAN;
#define ASSERT(x) if (!(x)) {SysBeep(10); SysBeep(10); ExitToShell();}  /* da sistemare *****/


/* queste var. dovrebbero essere nascoste *********/
int  fVol, fRef, fErr;
BOOLEAN  fOpened = false;


/* Pascal strings utilities: */

void AssignPStr(char * dest, char * sour)
{
	int sourLen, i;
	
	sourLen = (int) sour[0];
	if (sourLen > 31)  sourLen = 31;  /********/
	dest[0] = sourLen;
	for (i = 1; i <= sourLen; i++)
		dest[i] = sour[i];
}


BOOLEAN  EqPStr(char * a, char * b)
{
	int len, i;

	if (a[0] == b[0]) {
		len = (int) a[0];
		for (i = 1; i <= len; i++)
			if (a[i] != b[i])
				return  false;
		return  true;
	} else
		return  false;
}


BOOLEAN  QFSelectInputFile(OSType type, int * folder, char * name)
{
	Point  where;
	SFTypeList  typeList;
	SFReply  reply;
	
	SetPt(&where, 5, 30);
	typeList[0] = type;
	SFGetFile(where, "\p", NULL, 1, typeList, NULL, &reply);
	if (!reply.good)  return  false;
	*folder = reply.vRefNum;
	AssignPStr(name, (char*)&reply.fName);
	return  true;
}


BOOLEAN  QFSelectOutputFile(int * defFolder,  char * defName)
{
	Point  where;
	SFReply  reply;

	SetPt(&where, 5, 30);
	SFPutFile(&where, "\p", defName, NULL, &reply);
	if (!reply.good)  return  false;
	*defFolder = reply.vRefNum;
	AssignPStr(defName, (char*)&reply.fName);
	return  true;
}


void  QFOpenWrite(int vRefNum,  char * name,  OSType creator, OSType type)
{
	ASSERT(!fOpened);  /* one file at a time, please! */
	fVol = vRefNum;
	fOpened = false;
	fErr = Create(name, fVol, creator, type);
	if (fErr == dupFNErr) {  /* the file already exist */
		/* do noting */
	} else if (fErr != noErr)
		return;
	fErr = FSOpen(name, fVol, &fRef);
	if (fErr != noErr)  return;
	fOpened = (fErr == noErr);
	fErr = SetEOF(fRef, 0);  /* truncate file length to zero */
}


void  QFWrite(long nBytes,  void * buffer)
{
	if (fErr != noErr)  return;
	fErr = FSWrite(fRef, &nBytes, buffer);
}


/********
PROCEDURE  WriteString(s: ARRAY OF CHAR);
VAR
	i: INTEGER;
{
	i :== 0;
	WHILE (i <== HIGH(s)) AND (s[i] != 0C) DO
		INC(i);
	};
	if (i > 0) {
		Write(i, ADR(s));
	};
} WriteString;
*******/

void  QFWriteInt(int i)
{
	QFWrite(sizeof(i), &i);
}


void  QFOpenRead(int vRefNum,  char * name)
{
	ASSERT(!fOpened);
	fVol = vRefNum;
	fErr = FSOpen(name, fVol, &fRef);
	fOpened = (fErr == noErr);
}


void  QFRead(long nBytes,  void * buffer)
{
	if (fErr != noErr)  return;
	fErr = FSRead(fRef, &nBytes, buffer);
}


void  QFRead2(long nBytes,  void * buffer,  long * readed)
{
	if (fErr != noErr)  return;
	fErr = FSRead(fRef, &nBytes, buffer);
	*readed = nBytes;
}


/************
PROCEDURE  ReadString(VAR s: ARRAY OF CHAR);
CONST
	NUL == CHR(0);
	ETX == CHR(3);
	HT  == CHR(9);
	CR  == CHR(13);
VAR
	i: INTEGER;
	c: CHAR;
{
	i :== 0;
	LOOP
		if (i > HIGH(s)) {
			EXIT;
		};
		ReadCHAR(c);
		if ((fErr != noErr) OR (c == NUL) OR (c == ETX) OR (c == HT) OR (c == CR)) {  (* puņ essere anche un eofErr *)
			s[i] :== 0C;
			EXIT;
		};
		s[i] :== c;
		INC(i);
	};
} ReadString;
**************/


void  QFReadInt(int * i)
{
	QFRead(sizeof(int), i);
}


void  QFClose()
{
	OSErr  err;
	long  eofPos;

	if (fErr == noErr) {
		fErr = FSClose(fRef);
		if (fErr == noErr)  fErr = FlushVol(NULL, fVol);
	} else if (fOpened) {
		err = FSClose(fRef);
		err = FlushVol(NULL, fVol);
	}
	fOpened = false;
}


int  QFGetRefNum()
{
	return  fRef;
}


long  QFLength()
{
	long  l;
	
	if (fErr != noErr)  return  0;
	fErr = GetEOF(fRef, &l);
	return  l;
}


OSErr  QFError()
{
	return  fErr;
}