CnC_Remastered_Collection

RAWFILE.CPP (55762B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/RAWFILE.CPP 1     3/03/97 10:25a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Westwood Library                                             *
  *                                                                                             *
  *                    File Name : RAWFILE.CPP                                                  *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : August 8, 1994                                               *
  *                                                                                             *
  *                  Last Update : August 4, 1996 [JLB]                                         *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  *   RawFileClass::Bias -- Bias a file with a specific starting position and length.           *
  *   RawFileClass::Close -- Perform a closure of the file.                                     *
  *   RawFileClass::Create -- Creates an empty file.                                            *
  *   RawFileClass::Delete -- Deletes the file object from the disk.                            *
  *   RawFileClass::Error -- Handles displaying a file error message.                           *
  *   RawFileClass::Get_Date_Time -- Gets the date and time the file was last modified.         *
  *   RawFileClass::Is_Available -- Checks to see if the specified file is available to open.   *
  *   RawFileClass::Open -- Assigns name and opens file in one operation.                       *
  *   RawFileClass::Open -- Opens the file object with the rights specified.                    *
  *   RawFileClass::RawFileClass -- Simple constructor for a file object.                       *
  *   RawFileClass::Raw_Seek -- Performs a seek on the unbiased file                            *
  *   RawFileClass::Read -- Reads the specified number of bytes into a memory buffer.           *
  *   RawFileClass::Seek -- Reposition the file pointer as indicated.                           *
  *   RawFileClass::Set_Date_Time -- Sets the date and time the file was last modified.         *
  *   RawFileClass::Set_Name -- Manually sets the name for a file object.                       *
  *   RawFileClass::Size -- Determines size of file (in bytes).                                 *
  *   RawFileClass::Write -- Writes the specified data to the buffer specified.                 *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 
 #include	<stdlib.h>
 #include	<stdio.h>
 #include	<string.h>
 #include	<direct.h>
 #include	<share.h>
 #include	<stddef.h>
 
 #include	"rawfile.h"
 
 #ifndef WIN32
 #include	<fcntl.h>
 #include	<io.h>
 #include	<dos.h>
 extern short Hard_Error_Occured;
 #endif
 
 
 /***********************************************************************************************
  * RawFileClass::Error -- Handles displaying a file error message.                             *
  *                                                                                             *
  *    Display an error message as indicated. If it is allowed to retry, then pressing a key    *
  *    will return from this function. Otherwise, it will exit the program with "exit()".       *
  *                                                                                             *
  * INPUT:   error    -- The error number (same as the DOSERR.H error numbers).                 *
  *                                                                                             *
  *          canretry -- Can this routine exit normally so that retrying can occur? If this is  *
  *                      false, then the program WILL exit in this routine.                     *
  *                                                                                             *
  *          filename -- Optional filename to report with this error. If no filename is         *
  *                      supplied, then no filename is listed in the error message.             *
  *                                                                                             *
  * OUTPUT:  none, but this routine might not return at all if the "canretry" parameter is      *
  *          false or the player pressed ESC.                                                   *
  *                                                                                             *
  * WARNINGS:   This routine may not return at all. It handles being in text mode as well as    *
  *             if in a graphic mode.                                                           *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/17/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void RawFileClass::Error(int , int , char const * )
 {
 }
 
 
 /***********************************************************************************************
  * RawFileClass::RawFileClass -- Simple constructor for a file object.                         *
  *                                                                                             *
  *    This constructor is called when a file object is created with a supplied filename, but   *
  *    not opened at the same time. In this case, an assumption is made that the supplied       *
  *    filename is a constant string. A duplicate of the filename string is not created since   *
  *    it would be wasteful in that case.                                                       *
  *                                                                                             *
  * INPUT:   filename -- The filename to assign to this file object.                            *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/17/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 RawFileClass::RawFileClass(char const * filename) :
 	Rights(0),
 	BiasStart(0),
 	BiasLength(-1),
 	Handle(NULL_HANDLE),
 	Filename(filename),
 	Date(0),
 	Time(0),
 	Allocated(false)
 {
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Set_Name -- Manually sets the name for a file object.                         *
  *                                                                                             *
  *    This routine will set the name for the file object to the name specified. This name is   *
  *    duplicated in free store. This allows the supplied name to be a temporarily constructed  *
  *    text string. Setting the name in this fashion doesn't affect the closed or opened state  *
  *    of the file.                                                                             *
  *                                                                                             *
  * INPUT:   filename -- The filename to assign to this file object.                            *
  *                                                                                             *
  * OUTPUT:  Returns with a pointer to the allocated copy of this filename. This pointer is     *
  *          guaranteed to remain valid for the duration of this file object or until the name  *
  *          is changed -- whichever is sooner.                                                 *
  *                                                                                             *
  * WARNINGS:   Because of the allocation this routine must perform, memory could become        *
  *             fragmented.                                                                     *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/17/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 char const * RawFileClass::Set_Name(char const * filename)
 {
 	if (Filename != NULL && Allocated) {
 		free((char *)Filename);
 		((char *&)Filename) = 0;
 		Allocated = false;
 	}
 
 	if (filename == NULL) return(NULL);
 
 	Bias(0);
 
 	((char *&)Filename) = strdup(filename);
 	if (Filename == NULL) {
 		Error(ENOMEM, false, filename);
 	}
 	Allocated = true;
 	return(Filename);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Open -- Assigns name and opens file in one operation.                         *
  *                                                                                             *
  *    This routine will assign the specified filename to the file object and open it at the    *
  *    same time. If the file object was already open, then it will be closed first. If the     *
  *    file object was previously assigned a filename, then it will be replaced with the new    *
  *    name. Typically, this routine is used when an anonymous file object has been crated and  *
  *    now it needs to be assigned a name and opened.                                           *
  *                                                                                             *
  * INPUT:   filename -- The filename to assign to this file object.                            *
  *                                                                                             *
  *          rights   -- The open file access rights to use.                                    *
  *                                                                                             *
  * OUTPUT:  bool; Was the file opened? The return value of this is moot, since the open file   *
  *          is designed to never return unless it succeeded.                                   *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/17/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 int RawFileClass::Open(char const * filename, int rights)
 {
 	Set_Name(filename);
 	return(Open(rights));
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Open -- Opens the file object with the rights specified.                      *
  *                                                                                             *
  *    This routine is used to open the specified file object with the access rights indicated. *
  *    This only works if the file has already been assigned a filename. It is guaranteed, by   *
  *    the error handler, that this routine will always return with success.                    *
  *                                                                                             *
  * INPUT:   rights   -- The file access rights to use when opening this file. This is a        *
  *                      combination of READ and/or WRITE bit flags.                            *
  *                                                                                             *
  * OUTPUT:  bool; Was the file opened successfully? This will always return true by reason of  *
  *          the error handler.                                                                 *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/17/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 int RawFileClass::Open(int rights)
 {
 	Close();
 
 	/*
 	**	Verify that there is a filename associated with this file object. If not, then this is a
 	**	big error condition.
 	*/
 	if (Filename == NULL) {
 		Error(ENOENT, false);
 	}
 
 	/*
 	**	Record the access rights used for this open call. These rights will be used if the
 	**	file object is duplicated.
 	*/
 	Rights = rights;
 
 	/*
 	**	Repetitively try to open the file. Abort if a fatal error condition occurs.
 	*/
 	for (;;) {
 
 		/*
 		**	Try to open the file according to the access rights specified.
 		*/
 		#ifndef WIN32
 			Hard_Error_Occured = 0;
 		#endif
 		switch (rights) {
 
 			/*
 			**	If the access rights are not recognized, then report this as
 			**	an invalid access code.
 			*/
 			default:
 				errno = EINVAL;
 				break;
 
 			case READ:
 				#ifdef WIN32
 					Handle = CreateFile(Filename, GENERIC_READ, FILE_SHARE_READ,
 												NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 				#else
 					_dos_open(Filename, O_RDONLY|SH_DENYNO, &Handle);
 				#endif
 				break;
 
 			case WRITE:
 				#ifdef WIN32
 					Handle = CreateFile(Filename, GENERIC_WRITE, 0,
 												NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 				#else
 					_dos_creat(Filename, 0, &Handle);
 				#endif
 				break;
 
 			case READ|WRITE:
 				#ifdef WIN32
 					Handle = CreateFile(Filename, GENERIC_READ | GENERIC_WRITE, 0,
 												NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 				#else
 					_dos_open(Filename, O_RDWR|O_CREAT|SH_DENYWR, &Handle);
 				#endif
 				break;
 		}
 
 		/*
 		**	Biased files must be positioned past the bias start position.
 		*/
 		if (BiasStart != 0 || BiasLength != -1) {
 			Seek(0, SEEK_SET);
 		}
 
 		/*
 		**	If the handle indicates the file is not open, then this is an error condition.
 		**	For the case of the file cannot be found, then allow a retry. All other cases
 		**	are fatal.
 		*/
 		if (Handle == NULL_HANDLE) {
 
 #ifdef WIN32
 //			return(false);
 			Error(GetLastError(), false, Filename);
 //			continue;
 #else
 			/*
 			**	If this flag is set, then some hard error occurred. Just assume that the error
 			**	is probably a removed CD-ROM and allow a retry.
 			*/
 			if (Hard_Error_Occured) {
 				Error(Hard_Error_Occured, true, Filename);
 			} else {
 				if (errno == ENOENT) {
 					Error(ENOENT, true, Filename);
 				} else {
 					Error(errno, false, Filename);
 				}
 			}
 			continue;
 #endif
 		}
 		break;
 	}
 
 	return(true);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Is_Available -- Checks to see if the specified file is available to open.     *
  *                                                                                             *
  *    This routine will examine the disk system to see if the specified file can be opened     *
  *    or not. Use this routine before opening a file in order to make sure that is available   *
  *    or to perform other necessary actions.                                                   *
  *                                                                                             *
  * INPUT:   force -- Should this routine keep retrying until the file becomes available? If    *
  *                   in this case it doesn't become available, then the program will abort.    *
  *                                                                                             *
  * OUTPUT:  bool; Is the file available to be opened?                                          *
  *                                                                                             *
  * WARNINGS:   Depending on the parameter passed in, this routine may never return.            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 int RawFileClass::Is_Available(int forced)
 {
 #ifndef WIN32
 	bool open_failed;
 #endif
 
 	if (Filename == NULL) return(false);
 
 	/*
 	**	If the file is already open, then is must have already passed the availability check.
 	**	Return true in this case.
 	*/
 	if (Is_Open()) return(true);
 
 	/*
 	**	If this is a forced check, then go through the normal open channels, since those
 	**	channels ensure that the file must exist.
 	*/
 	if (forced) {
 		RawFileClass::Open(READ);
 		RawFileClass::Close();
 		return(true);
 	}
 
 	/*
 	**	Perform a raw open of the file. If this open fails for ANY REASON, including a missing
 	**	CD-ROM, this routine will return a failure condition. In all but the missing file
 	**	condition, go through the normal error recover channels.
 	*/
 	for (;;) {
 
 #ifdef WIN32
 		Handle = CreateFile(Filename, GENERIC_READ, FILE_SHARE_READ,
 											NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 		if (Handle == NULL_HANDLE) {
 			return(false);
 		}
 		break;
 #else
 
 		Hard_Error_Occured = 0;
 		open_failed = _dos_open(Filename, O_RDONLY|SH_DENYNO, &Handle);
 
 		/*
 		**	If DOS reports that everything is just fine except that the file is not present,
 		**	then return with this fact. Any other case will fall through to the error handler
 		**	routine.
 		*/
 		if (open_failed && errno == ENOENT) return(false);
 
 		/*
 		** If we got an access error it could be because there is no cd in
 		** the drive.  Call the error handler but allow a continue if it
 		** returns.
 		*/
 		if (open_failed && errno == EACCES) {
 			Error(errno, true, Filename);
 			continue;
 		}
 
 		/*
 		**	If the file could not be found, then return with this information. If a more
 		**	serious error occurred, then display the error message and abort.
 		*/
 		if (Hard_Error_Occured) {
 			Error(Hard_Error_Occured, true, Filename);
 			continue;
 		} else {
 			if (open_failed) {
 				/*
 				**	An unhandled error condition is fatal. Display the error message and then
 				**	abort.
 				*/
 				Error(errno, false, Filename);
 			}
 		}
 		if (!open_failed) break;
 #endif
 	}
 
 	/*
 	**	Since the file could be opened, then close it and return that the file exists.
 	*/
 #ifdef WIN32
 	if (!CloseHandle(Handle)) {
 		Error(GetLastError(), false, Filename);
 	}
 #else
 	if (_dos_close(Handle)) {
 		Error(errno, false, Filename);
 	}
 #endif
 	Handle = NULL_HANDLE;
 
 	return(true);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Close -- Perform a closure of the file.                                       *
  *                                                                                             *
  *    Close the file object. In the rare case of an error, handle it as appropriate.           *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   Some rare error conditions may cause this routine to abort the program.         *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void RawFileClass::Close(void)
 {
 	/*
 	**	If the file is open, then close it. If the file is already closed, then just return. This
 	**	isn't considered an error condition.
 	*/
 	if (Is_Open()) {
 
 #ifdef WIN32
 		/*
 		**	Try to close the file. If there was an error (who knows what that could be), then
 		**	call the error routine.
 		*/
 		if (!CloseHandle(Handle)) {
 			Error(GetLastError(), false, Filename);
 		}
 #else
 		for (;;) {
 			/*
 			**	Close the file. If there was an error in the close operation -- abort.
 			*/
 			Hard_Error_Occured = 0;
 			if (_dos_close(Handle)) {
 
 				/*
 				**	By definition, this error can only be a bad file handle. This a fatal condition
 				**	of course, so abort with an error message.
 				*/
 				Error(errno, false, Filename);
 			}
 
 			/*
 			**	In the condition (if it is even possible) of a hard error occurring, then
 			**	assume it is the case of missing media. Display an error message and try
 			**	again if indicated.
 			*/
 			if (Hard_Error_Occured) {
 				Error(Hard_Error_Occured, true, Filename);
 				continue;
 			}
 			break;
 		}
 
 #endif
 
 		/*
 		**	At this point the file must have been closed. Mark the file as empty and return.
 		*/
 		Handle = NULL_HANDLE;
 	}
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Read -- Reads the specified number of bytes into a memory buffer.             *
  *                                                                                             *
  *    This routine will read the specified number of bytes and place the data into the buffer  *
  *    indicated. It is legal to call this routine with a request for more bytes than are in    *
  *    the file. This condition can result in fewer bytes being read than requested. Determine  *
  *    this by examining the return value.                                                      *
  *                                                                                             *
  * INPUT:   buffer   -- Pointer to the buffer to read data into. If NULL is passed, no read    *
  *                      is performed.                                                          *
  *                                                                                             *
  *          size     -- The number of bytes to read. If NULL is passed, then no read is        *
  *                      performed.                                                             *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes read into the buffer. If this number is less      *
  *          than requested, it indicates that the file has been exhausted.                     *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 long RawFileClass::Read(void * buffer, long size)
 {
 	long	bytesread = 0;			// Running count of the number of bytes read into the buffer.
 	int	opened = false;		// Was the file opened by this routine?
 
 	/*
 	**	If the file isn't opened, open it. This serves as a convenience
 	**	for the programmer.
 	*/
 	if (!Is_Open()) {
 
 		/*
 		**	The error check here is moot. Open will never return unless it succeeded.
 		*/
 		if (!Open(READ)) {
 			return(0);
 		}
 		opened = true;
 	}
 
 	/*
 	**	A biased file has the requested read length limited to the bias length of
 	**	the file.
 	*/
 	if (BiasLength != -1) {
 		int remainder = BiasLength - Seek(0);
 		size = size < remainder ? size : remainder;
 	}
 
 #ifdef WIN32
 	long total = 0;
 	while (size > 0) {
 		bytesread = 0;
 
 		SetErrorMode(SEM_FAILCRITICALERRORS);
 		if (!ReadFile(Handle, buffer, size, &(unsigned long&)bytesread, NULL)) {
 			size -= bytesread;
 			total += bytesread;
 			Error(GetLastError(), true, Filename);
 			SetErrorMode(0);
 			continue;
 		}
 		SetErrorMode(0);
 		size -= bytesread;
 		total += bytesread;
 		if (bytesread == 0) break;
 	}
 	bytesread = total;
 
 #else
 
 	int	readresult;
 
 	/*
 	**	Read the file in convenient chunk sizes. When the actual number
 	**	of bytes read does not match the desired, then assume that the file
 	**	is exhausted and bail. This loop was adjusted to take into
 	**	consideration the fact that "read" returns a SIGNED value whereas
 	**	it takes an UNSIGNED value as the byte count.
 	*/
 	while (size) {
 		unsigned	desired;		// Bytes desired to be read this pass.
 		unsigned actual;		// Actual number of bytes read.
 
 		/*
 		**	Break the read request into chunks no bigger than the low level DOS read
 		**	can handle.
 		*/
 		desired = size < 32000L ? size : 32000L;
 
 		Hard_Error_Occured = 0;
 		readresult = _dos_read(Handle, buffer, desired, &actual);
 
 		/*
 		**	If a hard error occurred, then assume that it is the case of the CD-ROM or
 		**	floppy media having been removed. Display the error and retry as directed.
 		*/
 		if (Hard_Error_Occured) {
 			Error(Hard_Error_Occured, true, Filename);
 			continue;			// Not technically needed, but to be consistent...
 		} else {
 
 			/*
 			**	If negative one is returned from the read operation, then this indicates
 			**	either a bad file number or invalid access. These are fatal conditions, so
 			**	display the error and then abort.
 			*/
 			if (readresult != 0) {
 				Error(errno, false, Filename);
 			} else {
 
 				/*
 				**	No error occurred during the read. Adjust the pointers and size counters and
 				**	loop again if more data is needed to be read.
 				*/
 				buffer = (char *)buffer + actual;
 				bytesread += actual;
 				size -= actual;
 				if (actual != desired) break;		// No more data?
 			}
 		}
 	}
 #endif	//WIN32
 
 	/*
 	**	Close the file if it was opened by this routine and return
 	**	the actual number of bytes read into the buffer.
 	*/
 	if (opened) Close();
 	return(bytesread);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Write -- Writes the specified data to the buffer specified.                   *
  *                                                                                             *
  *    This routine will write the data specified to the file.                                  *
  *                                                                                             *
  * INPUT:   buffer   -- The buffer that holds the data to write.                               *
  *                                                                                             *
  *          size     -- The number of bytes to write to the file.                              *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes written to the file. This routine catches the     *
  *          case of a disk full condition, so this routine will always return with the number  *
  *          matching the size request.                                                         *
  *                                                                                             *
  * WARNINGS:   A fatal file condition could cause this routine to never return.                *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 long RawFileClass::Write(void const * buffer, long size)
 {
 	long	bytesread = 0;
 	int	opened = false;		// Was the file manually opened?
 
 	/*
 	**	Check to open status of the file. If the file is open, then merely write to
 	**	it. Otherwise, open the file for writing and then close the file when the
 	**	output is finished.
 	*/
 	if (!Is_Open()) {
 		if (!Open(WRITE)) {
 			return(0);
 		}
 		opened = true;
 	}
 
 #ifdef WIN32
 	if (!WriteFile(Handle, buffer, size, &(unsigned long&)bytesread, NULL)) {
 		Error(GetLastError(), false, Filename);
 	}
 
 #else
 
 	int	writeresult;
 	/*
 	**	Write the data to the file in chunks no bigger than what the low level DOS write
 	**	can handle.
 	*/
 	while (size) {
 		unsigned	desired;		// Bytes desired to be write this pass.
 		unsigned actual;		// Actual number of bytes written.
 
 		Hard_Error_Occured = 0;
 //		desired = (unsigned)MIN(size, Transfer_Block_Size());
 		desired = size;
 		writeresult = _dos_write(Handle, buffer, desired, &actual);
 
 		/*
 		**	If a hard error occurred, then assume it is the case of the media being
 		**	removed. Print the error message an retry as directed.
 		*/
 		if (Hard_Error_Occured) {
 			Error(Hard_Error_Occured, true, Filename);
 			continue;			// Not technically needed, but to be consistent...
 		} else {
 
 			/*
 			**	If negative one is returned by the DOS read, then this indicates a bad file
 			**	handle or invalid access. Either condition is fatal -- display error condition
 			**	and abort.
 			*/
 			if (writeresult != 0) {
 				Error(errno, false, Filename);
 			} else {
 
 				/*
 				**	A successful write occurred. Update pointers and byte counter as appropriate.
 				*/
 				buffer = (char *)buffer + actual;
 				bytesread += actual;
 				size -= actual;
 
 				/*
 				**	If the actual bytes written is less than requested, assume this is a case of
 				**	the disk being full. Consider this a fatal error condition.
 				*/
 				if (actual != desired) {
 					Error(ENOSPC, false, Filename);
 				}
 			}
 		}
 	}
 #endif	//WIN32
 
 	/*
 	**	Fixup the bias length if necessary.
 	*/
 	if (BiasLength != -1) {
 		if (Raw_Seek(0) > BiasStart+BiasLength) {
 			BiasLength = Raw_Seek(0) - BiasStart;
 		}
 	}
 
 	/*
 	**	If this routine had to open the file, then close it before returning.
 	*/
 	if (opened) {
 		Close();
 	}
 
 	/*
 	**	Return with the number of bytes written. This will always be the number of bytes
 	**	requested, since the case of the disk being full is caught by this routine.
 	*/
 	return(bytesread);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Seek -- Reposition the file pointer as indicated.                             *
  *                                                                                             *
  *    Use this routine to move the filepointer to the position indicated. It can move either   *
  *    relative to current position or absolute from the beginning or ending of the file. This  *
  *    routine will only return if it successfully performed the seek.                          *
  *                                                                                             *
  * INPUT:   pos   -- The position to seek to. This is interpreted as relative to the position  *
  *                   indicated by the "dir" parameter.                                         *
  *                                                                                             *
  *          dir   -- The relative position to relate the seek to. This can be either SEEK_SET  *
  *                   for the beginning of the file, SEEK_CUR for the current position, or      *
  *                   SEEK_END for the end of the file.                                         *
  *                                                                                             *
  * OUTPUT:  This routine returns the position that the seek ended up at.                       *
  *                                                                                             *
  * WARNINGS:   If there was a file error, then this routine might never return.                *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 long RawFileClass::Seek(long pos, int dir)
 {
 
 	/*
 	**	A file that is biased will have a seek operation modified so that the file appears to
 	**	exist only within the bias range. All bytes outside of this range appear to be
 	**	non-existant.
 	*/
 	if (BiasLength != -1) {
 		switch (dir) {
 			case SEEK_SET:
 				if (pos > BiasLength) {
 					pos = BiasLength;
 				}
 				pos += BiasStart;
 				break;
 
 			case SEEK_CUR:
 				break;
 
 			case SEEK_END:
 				dir = SEEK_SET;
 				pos += BiasStart + BiasLength;
 //				pos = (pos <= BiasStart+BiasLength) ? pos : BiasStart+BiasLength;
 //				pos = (pos >= BiasStart) ? pos : BiasStart;
 				break;
 		}
 
 		/*
 		**	Perform the modified raw seek into the file.
 		*/
 		long newpos = Raw_Seek(pos, dir) - BiasStart;
 
 		/*
 		**	Perform a final double check to make sure the file position fits with the bias range.
 		*/
 		if (newpos < 0) {
 			newpos = Raw_Seek(BiasStart, SEEK_SET) - BiasStart;
 		}
 		if (newpos > BiasLength) {
 			newpos = Raw_Seek(BiasStart+BiasLength, SEEK_SET) - BiasStart;
 		}
 		return(newpos);
 	}
 
 	/*
 	**	If the file is not biased in any fashion, then the normal seek logic will
 	**	work just fine.
 	*/
 	return(Raw_Seek(pos, dir));
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Size -- Determines size of file (in bytes).                                   *
  *                                                                                             *
  *    Use this routine to determine the size of the file. The file must exist or this is an    *
  *    error condition.                                                                         *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes in the file.                                      *
  *                                                                                             *
  * WARNINGS:   This routine handles error conditions and will not return unless the file       *
  *             exists and can successfully be queried for file length.                         *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 long RawFileClass::Size(void)
 {
 	long	size = 0;
 
 	/*
 	**	A biased file already has its length determined.
 	*/
 	if (BiasLength != -1) {
 		return(BiasLength);
 	}
 
 	/*
 	**	If the file is open, then proceed normally.
 	*/
 	if (Is_Open()) {
 
 #ifdef WIN32
 		size = GetFileSize(Handle, NULL);
 
 		/*
 		**	If there was in internal error, then call the error function.
 		*/
 		if (size == 0xFFFFFFFF) {
 			Error(GetLastError(), false, Filename);
 		}
 #else
 
 		/*
 		**	Repetitively try to determine the file size until a fatal error condition or success
 		**	is achieved.
 		*/
 		for (;;) {
 			Hard_Error_Occured = 0;
 			size = filelength(Handle);
 
 			/*
 			**	If a hard error occurred, then assume it is the case of removed media. Display an
 			**	error condition and allow retry.
 			*/
 			if (Hard_Error_Occured) {
 				Error(Hard_Error_Occured, true, Filename);
 				continue;
 			} else {
 				if (size == -1) {
 					Error(errno, false, Filename);
 				}
 			}
 			break;
 		}
 #endif
 
 	} else {
 
 		/*
 		**	If the file wasn't open, then open the file and call this routine again. Count on
 		**	the fact that the open function must succeed.
 		*/
 		if (Open()) {
 			size = Size();
 
 			/*
 			**	Since we needed to open the file we must remember to close the file when the
 			**	size has been determined.
 			*/
 			Close();
 		}
 	}
 
 	BiasLength = size-BiasStart;
 	return(BiasLength);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Create -- Creates an empty file.                                              *
  *                                                                                             *
  *    This routine will create an empty file from the file object. The file object's filename  *
  *    must already have been assigned before this routine will function.                       *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  bool; Was the file successfully created? This routine will always return true.     *
  *                                                                                             *
  * WARNINGS:   A fatal error condition could occur with this routine. Especially if the disk   *
  *             is full or a read-only media was selected.                                      *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 int RawFileClass::Create(void)
 {
 	Close();
 	if (Open(WRITE)) {
 
 		/*
 		**	A biased file must be at least as long as the bias offset. Seeking to the
 		**	appropriate start offset has the effect of lengthening the file to the
 		**	correct length.
 		*/
 		if (BiasLength != -1) {
 			Seek(0, SEEK_SET);
 		}
 
 		Close();
 		return(true);
 	}
 	return(false);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Delete -- Deletes the file object from the disk.                              *
  *                                                                                             *
  *    This routine will delete the file object from the disk. If the file object doesn't       *
  *    exist, then this routine will return as if it had succeeded (since the effect is the     *
  *    same).                                                                                   *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  bool; Was the file deleted? If the file was already missing, the this value will   *
  *                be false.                                                                    *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   10/18/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 int RawFileClass::Delete(void)
 {
 	/*
 	**	If the file was open, then it must be closed first.
 	*/
 	Close();
 
 	/*
 	**	If there is no filename associated with this object, then this indicates a fatal error
 	**	condition. Report this and abort.
 	*/
 	if (!Filename) {
 		Error(ENOENT, false);
 	}
 
 	/*
 	**	Repetitively try to delete the file if possible. Either return with success, or
 	**	abort the program with an error.
 	*/
 	for (;;) {
 
 		/*
 		**	If the file is already missing, then return with this fact. No action is necessary.
 		**	This can occur as this section loops if the file exists on a floppy and the floppy
 		**	was removed, the file deleted on another machine, and then the floppy was
 		**	reinserted. Admittedly, this is a rare case, but is handled here.
 		*/
 		if (!Is_Available()) {
 			return(false);
 		}
 
 #ifdef WIN32
 		if (!DeleteFile(Filename)) {
 			Error(GetLastError(), false, Filename);
 			return(false);
 		}
 #else
 		Hard_Error_Occured = 0;
 		if (remove(Filename) == -1) {
 
 			/*
 			**	If a hard error occurred, then assume that the media has been removed. Display
 			**	error message and retry as directed.
 			*/
 			if (Hard_Error_Occured) {
 				Error(Hard_Error_Occured, true, Filename);
 				continue;
 			}
 
 			/*
 			**	If at this point, DOS says the file doesn't exist, then just exit with this
 			**	fact. It should have been caught earlier, but in any case, this is a legal
 			**	condition.
 			*/
 			if (errno == ENOENT) break;
 
 			/*
 			**	The only way it can reach this point is if DOS indicates that access is denied
 			**	on the file. This occurs when trying to delete a file on a read-only media such
 			**	as a CD-ROM. Report this as a fatal error and then abort.
 			*/
 			Error(errno, false, Filename);
 		}
 #endif
 		break;
 	}
 
 	/*
 	**	DOS reports that the file was successfully deleted. Return with this fact.
 	*/
 	return(true);
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Get_Date_Time -- Gets the date and time the file was last modified.           *
  *                                                                                             *
  *    Use this routine to get the date and time of the file.                                   *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  Returns with the file date and time as a long.                                     *
  *          Use the YEAR(long), MONTH(),....                                                   *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/14/1995 DRD : Created.                                                                 *
  *   07/13/1996 JLB : Handles win32 method.                                                    *
  *=============================================================================================*/
 unsigned long RawFileClass::Get_Date_Time(void)
 {
 #ifdef WIN32
 	BY_HANDLE_FILE_INFORMATION info;
 
 	if (GetFileInformationByHandle(Handle, &info)) {
 		WORD dosdate;
 		WORD dostime;
 		FileTimeToDosDateTime(&info.ftLastWriteTime, &dosdate, &dostime);
 		return((dosdate << 16) | dostime);
 	}
 	return(0);
 #else
 	unsigned short time;
 	unsigned short date;
 	unsigned long datetime = 0;
 
 
 	//
 	//	If the file is open, then proceed normally.
 	//
 	if ( RawFileClass::Is_Open() ) {
 		if ( _dos_getftime( Handle, &date, &time ) ) {
 			//
 			// return 0 indicating error with no date and time
 			//
 			return( datetime );
 		}
 	} else {
 
 		//
 		//	If the file wasn't open, then see if the file exists.
 		//
 		if ( RawFileClass::Is_Available() ) {
 			RawFileClass::Open();
 
 			if ( _dos_getftime( Handle, &date, &time ) ) {
 				RawFileClass::Close();
 				//
 				// return 0 indicating error with no date and time
 				//
 				return( datetime );
 			}
 
 			RawFileClass::Close();
 		} else {
 			//
 			// return 0 indicating error with no date and time
 			//
 			return( datetime );
 		}
 	}
 
 	//
 	// combine the date and time as a long
 	//
 	datetime = (date << 16) + time;
 
 	return( datetime );
 #endif
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Set_Date_Time -- Sets the date and time the file was last modified.           *
  *                                                                                             *
  *    Use this routine to set the date and time of the file.                                   *
  *                                                                                             *
  * INPUT:   the file date and time as a long                                                   *
  *                                                                                             *
  * OUTPUT:  successful or not if the file date and time was changed.                           *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   11/14/1995 DRD : Created.                                                                 *
  *   07/13/1996 JLB : Handles win 32 method                                                    *
  *=============================================================================================*/
 bool RawFileClass::Set_Date_Time(unsigned long datetime)
 {
 #ifdef WIN32
 	if (RawFileClass::Is_Open()) {
 		BY_HANDLE_FILE_INFORMATION info;
 
 		if (GetFileInformationByHandle(Handle, &info)) {
 			FILETIME filetime;
 			if (DosDateTimeToFileTime((WORD)(datetime >> 16), (WORD)(datetime & 0x0FFFF), &filetime)) {
 				return(SetFileTime(Handle, &info.ftCreationTime, &filetime, &filetime));
 			}
 		}
 	}
 	return(false);
 #else
 	unsigned short time;
 	unsigned short date;
 
 	//
 	//	If the file is open, then proceed normally.
 	//
 	if ( RawFileClass::Is_Open() ) {
 		//
 		// only set the date and time if open for READ only
 		//
 		if ( Rights == READ ) {
 			time = (unsigned short)(datetime & 0xFFFF);
 			date = (unsigned short)((datetime >> 16) & 0xFFFF);
 
 			if ( !_dos_setftime( Handle, date, time ) ) {
 				//
 				// return true indicating success
 				//
 				return( true );
 			}
 		}
 	} else {
 
 		//
 		//	If the file wasn't open, then see if the file exists.
 		//
 		if ( RawFileClass::Is_Available() ) {
 			RawFileClass::Open();
 
 			time = (unsigned short)(datetime & 0xFFFF);
 			date = (unsigned short)((datetime >> 16) & 0xFFFF);
 
 			if ( !_dos_setftime( Handle, date, time ) ) {
 				RawFileClass::Close();
 				//
 				// return true indicating success
 				//
 				return( true );
 			}
 
 			RawFileClass::Close();
 		}
 	}
 
 	//
 	// return false indicating error
 	//
 	return( false );
 #endif
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Bias -- Bias a file with a specific starting position and length.             *
  *                                                                                             *
  *    This will bias a file by giving it an artificial starting position and length. By        *
  *    using this routine, it is possible to 'fool' the file into ignoring a header and         *
  *    trailing extra data. An example of this would be a file inside of a mixfile.             *
  *                                                                                             *
  * INPUT:   start    -- The starting offset that will now be considered the start of the       *
  *                      file.                                                                  *
  *                                                                                             *
  *          length   -- The forced length of the file. For files that are opened for write,    *
  *                      this serves as the artificial constraint on the file's length. For     *
  *                      files opened for read, this limits the usable file size.               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   06/02/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 void RawFileClass::Bias(int start, int length)
 {
 	if (start == 0) {
 		BiasStart = 0;
 		BiasLength = -1;
 		return;
 	}
 
 	BiasLength = RawFileClass::Size();
 	BiasStart += start;
 	if (length != -1) {
 		BiasLength = BiasLength < length ? BiasLength : length;
 	}
 	BiasLength = BiasLength > 0 ? BiasLength : 0;
 
 	/*
 	**	Move the current file offset to a legal position if necessary and the
 	**	file was open.
 	*/
 	if (Is_Open()) {
 		RawFileClass::Seek(0, SEEK_SET);
 	}
 }
 
 
 /***********************************************************************************************
  * RawFileClass::Raw_Seek -- Performs a seek on the unbiased file                              *
  *                                                                                             *
  *    This will perform a seek on the file as if it were unbiased. This is in spite of any     *
  *    bias setting the file may have. The ability to perform a raw seek in this fasion is      *
  *    necessary to maintain the bias ability.                                                  *
  *                                                                                             *
  * INPUT:   pos   -- The position to seek the file relative to the "dir" parameter.            *
  *                                                                                             *
  *          dir   -- The origin of the seek operation.                                         *
  *                                                                                             *
  * OUTPUT:  Returns with the new position of the seek operation.                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   08/04/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 long RawFileClass::Raw_Seek(long pos, int dir)
 {
 	/*
 	**	If the file isn't opened, then this is a fatal error condition.
 	*/
 	if (!Is_Open()) {
 		Error(EBADF, false, Filename);
 	}
 
 #ifdef WIN32
 	switch (dir) {
 		case SEEK_SET:
 			dir = FILE_BEGIN;
 			break;
 
 		case SEEK_CUR:
 			dir = FILE_CURRENT;
 			break;
 
 		case SEEK_END:
 			dir = FILE_END;
 			break;
 	}
 
 	pos = SetFilePointer(Handle, pos, NULL, dir);
 
 	/*
 	**	If there was an error in the seek, then bail with an error condition.
 	*/
 	if (pos == 0xFFFFFFFF) {
 		Error(GetLastError(), false, Filename);
 	}
 #else
 
 	/*
 	**	Keep trying to seek until a non-retry condition occurs.
 	*/
 	for (;;) {
 
 		/*
 		**	Perform the low level seek on the file.
 		*/
 		Hard_Error_Occured = 0;
 		pos = lseek(Handle, pos, dir);
 
 		/*
 		**	If a hard error occurred, then assume that it is the case of removed media. Display
 		**	error message and retry.
 		*/
 		if (Hard_Error_Occured) {
 			Error(Hard_Error_Occured, true, Filename);
 			continue;
 		} else {
 
 			/*
 			**	A negative one indicates a fatal error with the seek operation. Display error
 			**	condition and then abort.
 			*/
 			if (pos == -1) {
 				Error(errno, false, Filename);
 			}
 		}
 		break;
 	}
 #endif
 
 	/*
 	**	Return with the new position of the file. This will range between zero and the number of
 	**	bytes the file contains.
 	*/
 	return(pos);
 }