/*
** Command & Conquer Red Alert(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program 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.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see .
*/
/***************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D A S S O C I A T E S **
***************************************************************************
* *
* Project Name : Library *
* *
* File Name : FILE.CPP *
* *
* Programmer : Scott K. Bowen *
* *
* Start Date : September 13, 1993 *
* *
* Last Update : September 13, 1993 [SKB] *
* *
*-------------------------------------------------------------------------*
* Functions: *
* File_Exists -- Searches for and FINDS the specified file. *
* File_Size -- Determine the size of the specified file. *
* Open_File -- Opens a file for access. *
* Close_File -- Closes a file previously opened with Open_File. *
* Seek_File -- Adjusts the position of the file pointer. *
* Read_File -- Reads a block of data from a file. *
* Write_File -- Writes a block of data to a file. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef WWSTD_H
#include
#endif
#ifndef FILE_H
#include "_file.h"
#endif
#ifndef WWMEM_H
#include
#endif
#include
#include
#include
#define DEBUGPRINT FALSE
/*=========================================================================*/
/* The following PRIVATE functions are in this file: */
/*=========================================================================*/
/*= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =*/
/***************************************************************************
* OPEN_FILE -- Opens a file for access. *
* *
* This routine will open the specified file for access. It functions *
* in a similar manner to the regular DOS open command. *
* *
* INPUT: filename -- Pointer to the filename to open. *
* *
* mode -- Access mode to use. *
* READ: A file opened for READ access, MUST be available. *
* This may cause a disk swap message to appear. *
* *
* WRITE:A file opened for WRITE access (only), need not be *
* available. If it can't be found, then it will be *
* created in the current directory. *
* *
* OUTPUT: Returns with the westwood file handle. If ERROR is returned *
* it means that the programmer took over the file error handler *
* and signaled that an open access failure should not keep trying*
* for success. *
* *
* WARNINGS: If you take over the file error handling code, you must be *
* sure to anticipate a possible ERROR value being returned. *
* If you open a file for READ or READ|WRITE, then the file *
* must previously exist. To create a file for read and write *
* access, first open it for WRITE, then re-open it for *
* read and write. *
* *
* HISTORY: *
* 11/11/1991 JLB : Created. *
*=========================================================================*/
WORD cdecl Open_File(BYTE const *file_name, WORD mode)
{
WORD file_handle; // Westwood file handle.
WORD handle; // DOS file handle.
UWORD local_mode; // DOS access mode number.
WORD index; // FileData index (if available).
BOOL immediate; // Is the file immediately available?
FileDataType *filedata; // Pointer to the current FileData.
FileDataType *parent; // Pointer to the current FileData.
FileHandleType *filehandletable; // Pointer to the current file handle.
CallingDOSInt++;
#if(DEBUGPRINT)
Mono_Printf("Open_File('%s')\r", file_name);
#endif
/*
** Is there a slot in the FileHandleTable? If not, then exit with
** a file error.
*/
filehandletable = FileHandleTable;
for (file_handle = 0; file_handle < TABLE_MAX; file_handle++, filehandletable++) {
if (filehandletable->Empty) break;
}
if (file_handle == TABLE_MAX) {
Do_IO_Error(TOO_MANY_FILES, file_name);
}
/*
** Find the file in the FileTable (if it exists there).
*/
index = Find_File_Index(file_name);
filedata = &FileDataPtr[index];
// Start out looking at the start drive.
ibm_setdisk(*StartPath - 'A');
/*
** If the file exists in the current directory, then by all
** means, use that file instead of any corresponding pack
** file representation. This is used as a means of
** overriding packed files (quite handy).
*/
immediate = FALSE;
/*
** Check the current directory by attempting to open with READ access.
** Only check if the file is not already cached and it is a packed file.
*/
if ((index != ERROR) && (filedata->Flag & FILEF_PACKED) && (!filedata->Ptr))
{
WORD handle2;
handle2 = FILEOPEN(file_name, MODE_OLDFILE);
if (handle2 != FILEOPENERROR) {
FILECLOSE(handle2);
immediate = TRUE;
}
}
/*
** Check to see if any WRITE permission is requested for the
** file. If so, delete the file from RAM and mark it as non-resident.
**
** NOTE: If the file is packed, we CAN NOT alter it in ANY way.
** We will return an ERROR to the user, and hope he/she is
** smart enough to handle it.
*/
if ((mode & WRITE) && index != ERROR && filedata->Ptr) {
if(filedata->Flag & FILEF_PACKED) { // is file packed?
Mem_Free(FileCacheHeap, filedata->Ptr);
filedata->Ptr = NULL;
} else { // file is packed
Do_IO_Error(WRITING_RESIDENT, file_name);
}
}
// If the file is cached already, then let us use it and leave.
if (filedata->Ptr && index != ERROR) {
/*
** File is resident. Initialize the local table.
*/
filehandletable->Index = index;
filehandletable->Empty = FALSE;
filehandletable->Pos = 0L;
filehandletable->Name = filedata->Name;
filehandletable->Handle = 0; // Resident flag.
filehandletable->Mode = mode;
// If the cached file is packed and its parent is resident, then
// add one to the parent open count.
if (filedata->Flag & FILEF_PACKED) {
parent = &FileDataPtr[filedata->Disk];
}
else {
parent = NULL;
}
if (parent && (parent->Ptr == filedata->Ptr)) {
filehandletable->Start = filedata->Start;
parent->OpenCount++;
} else {
filehandletable->Start = 0;
}
// Mark the pointer in use so that it is never returned as the oldest
// pointer location in memory.
Mem_In_Use(filedata->Ptr);
} else {
/*
** At this time we determine if it is a packed file. If so, the
** opening process takes a dramatically different turn.
*/
if (index != ERROR && (filedata->Flag & FILEF_PACKED) && !immediate && (mode & WRITE) == 0) {
/*
** This is a packed file. Perform recursive open process to reach
** the parent packed file.
*/
parent = &FileDataPtr[filedata->Disk];
file_handle = Open_File(parent->Name, mode);
// Reread the parents information.
parent = &FileDataPtr[filedata->Disk];
filehandletable = &FileHandleTable[file_handle];
/*
** Process the packed file header. Update the start offset for every
** file ellaborated in the packed file.
** Exception: When a file is specified in the packed file and an
** entry exists for it in the file table, BUT the entry
** is not marked as packed, THEN ignore the packed version
** of the file.
*/
if (FileData == FileDataPtr &&
!(FileDataPtr[filehandletable->Index].Flag & FILEF_PROCESSED)) {
LONG offset; // Offset of sub-file start.
WORD i; // Sub-file FileData index.
BYTE name[FILENAMESIZE]; // Name of sub-file.
FileDataType *cur=NULL; // Current entry in FileData.
FileDataType *last=NULL; // Last entry in FileData.
#if(DEBUGPRINT)
Mono_Printf("Processing packed file '%s'\r", FileDataPtr[filedata->Disk].Name);
#endif
Read_File(file_handle, &offset, (ULONG)sizeof(LONG));
while (offset) {
/*
** Due to the fact that the embedded file name is of arbitrary
** length, we must read it in a byte at a time. Reading stops
** when the terminating NULL is found.
*/
i=0;
do {
Read_File(file_handle, &name[i], (ULONG)sizeof(name[0]));
} while (name[i++]);
i = Find_File_Index(name);
if (i != ERROR) {
cur = &FileDataPtr[i];
if ((cur->Flag & FILEF_PACKED) && cur->Disk == filehandletable->Index) {
cur->Start = offset + FileDataPtr[ filehandletable->Index ].Start;
if (last != NULL) {
last->Size = cur->Start - last->Start;
}
last = cur;
}
} else {
// ERROR: File specified in packed file has no table entry.
// When this occurs, the embedded file is ignored.
}
Read_File(file_handle, &offset, (ULONG)sizeof(LONG));
}
/*
** Fixup the size record of the last embedded file.
*/
if (last != NULL) {
last->Size = File_Size(file_handle) - last->Start;
}
FileDataPtr[filehandletable->Index].Flag |= FILEF_PROCESSED;
}
// if the parent is resident, the the child must have the same address.
filedata->Ptr = parent->Ptr;
/*
** Set starting position to start of embedded file.
*/
filehandletable->Index = index;
filehandletable->Name = filedata->Name;
filehandletable->Start = filedata->Start;
Seek_File(file_handle, NULL, SEEK_SET);
// Attempt to cache the file if wanted, and room.
Cache_File(index, file_handle);
} else {
/*
** Convert the Westwood access mode into the system specific mode.
*/
local_mode = MODE_OLDFILE;
switch (mode) {
case READ:
local_mode = MODE_OLDFILE;
break;
case READ | WRITE:
#if(IBM)
local_mode = MODE_READWRITE;
#else
local_mode = MODE_OLDFILE;
#endif
break;
case WRITE:
local_mode = MODE_NEWFILE;
break;
default:
Do_IO_Error(BAD_OPEN_MODE, file_name);
break;
}
/*
** The file is disk based. Perform the DOS open processing.
*/
/*
** Make sure the file is available or the proper disk is inserted.
** The file MUST exist if READ access is requested. A mild attempt
** will be made to find the file if open for WRITE only.
*/
if (mode & READ) {
if (!File_Exists(file_name)) {
CallingDOSInt--;
return(ERROR); /* Ignore the error */
}
}
/*
** Repetitively try to open the file until the error handler
** routine indicates otherwise.
*/
handle = FILEOPENERROR;
for (;;) {
handle = Open_File_With_Recovery( file_name, local_mode );
if (handle != FILEOPENERROR) {
break;
} else {
CHANGEDIR( DataPath );
CHANGEDIR( StartPath );
if (!Do_Open_Error(COULD_NOT_OPEN, file_name)) {
CallingDOSInt--;
return(FILEOPENERROR);
}
}
}
/*
** A file that is read off of disk cannot be part of
** a pack file regardless of the bit settting.
*/
if (immediate && index != ERROR) {
filedata->Flag &= ~FILEF_PACKED;
filedata->Size = 0;
}
if (index != ERROR) {
// The true file size is needed.
// Go back to beginning of file.
filedata->Size = FILESEEK(handle, 0L, SEEK_END);
FILESEEK(handle, 0L, SEEK_SET);
}
/*
** Initialize the local file handle table.
*/
filehandletable->Index = index;
filehandletable->Pos = 0L;
filehandletable->Start = 0L;
filehandletable->Empty = FALSE;
filehandletable->Handle = handle;
filehandletable->Mode = mode;
if (index != ERROR) {
filehandletable->Name = filedata->Name;
} else {
filehandletable->Name = NULL;
}
/*
** If the file should be made resident, then do it at this time.
** Perform all necessary adjustments to the file tables.
*/
if ((mode & WRITE) == 0) {
Cache_File(index, file_handle);
}
}
}
// If in the file table, increment the number of opens on this file.
if (index != ERROR) {
filedata->OpenCount++;
}
/*
** Return with valid file handle.
*/
CallingDOSInt--;
return(file_handle);
}
/***************************************************************************
* CLOSE_FILE -- Closes a file previously opened with Open_File. *
* *
* Use this routine to close a file that was opened with Open_File. *
* This is the only way to close a file that was opened with the *
* Westwood file I/O system. *
* *
* INPUT: handle -- Westwood file handle. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/11/1991 JLB : Created. *
*=========================================================================*/
VOID cdecl Close_File(WORD handle)
{
WORD index; // File data table index.
BOOL flushed = FALSE; // If file flushed from cache, do change time stamp.
BOOL stillopen;
FileDataType *parent = NULL;
FileDataType *filedata = NULL;
VOID *memptr=NULL;
#if(DEBUGPRINT)
Mono_Printf("Close_File(%d)\r", handle);
#endif
/*
** Check for file handle validity.
*/
if (!Is_Handle_Valid(handle, CLOSING_NON_HANDLE, NULL)) {
return;
}
CallingDOSInt++;
index = FileHandleTable[handle].Index;
filedata = &FileDataPtr[index];
// Remove the OpenCount on the file.
if (index != ERROR) {
filedata->OpenCount--;
stillopen = filedata->OpenCount;
// If this file packed in another, then decrement the parents open count.
if (filedata->Flag & FILEF_PACKED) {
parent = &FileDataPtr[filedata->Disk];
// Do not dec OpenCount if the child was cached but not the parent.
if (parent->Ptr == filedata->Ptr) {
parent->OpenCount--;
stillopen = parent->OpenCount;
}
}
}
// If the file was resident, then handle bookeeping.
if (index != ERROR && filedata->Ptr) {
// Get a pointer to the memory area for later use.
memptr = filedata->Ptr;
// If file has a parent, and it is the cached file...
if (parent && (parent->Ptr == filedata->Ptr)) {
// The PAK'd file is closed just by setting the pointer.
if (!filedata->OpenCount) {
filedata->Ptr = NULL;
}
// Uncache parent if no other sons are open and it should be flushed.
if ((!parent->OpenCount) && (parent->Flag & FILEF_FLUSH)) {
Mem_Free(FileCacheHeap, parent->Ptr);
parent->Ptr = NULL;
flushed = TRUE;
}
}
// Else should the file be flushed? Only flush it if the flag says
// so AND there are no other open counts on it.
else if ((filedata->Flag & FILEF_FLUSH) && !filedata->OpenCount) {
Mem_Free(FileCacheHeap, filedata->Ptr);
filedata->Ptr = NULL;
flushed = TRUE;
}
//
// Set the time stamp on the close IF
// the file was not flush AND
// is not open AND
// its time stamp should be changed by being a FILEF_KEEP|PROIORTY file.
//
if (!flushed && !stillopen && !(filedata->Flag & (FILEF_KEEP|FILEF_PRIORITY))) {
Mem_Reference(memptr);
}
}
// Just a simple close will do.
else {
FILECLOSE(FileHandleTable[handle].Handle);
}
// The WWS handle is no longer being used.
FileHandleTable[handle].Empty = TRUE;
CallingDOSInt--;
}
/***************************************************************************
* READ_FILE -- Reads a block of data from a file. *
* *
* This routine is used to read a block of data from a previously *
* opened file. *
* *
* INPUT: handle -- Westwood file handle returned from Open_File. *
* *
* buf -- Pointer to buffer to load the data into. *
* *
* bytes -- Number of bytes to load. *
* *
* OUTPUT: Returns with the number of bytes actually read from the file. *
* If this number is less than the number requested, this *
* indicates the end of the file. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/13/1991 JLB : Created. *
*=========================================================================*/
LONG cdecl Read_File(WORD handle, VOID *buf, ULONG bytes)
{
WORD doshandle; // DOS file handle.
WORD fileindex; // File table index.
LONG bytesread; // Accumulation of number of bytes read.
FileDataType *filedata; // Pointer to the current FileData.
#if(DEBUGPRINT)
Mono_Printf("Read_File(%d, %08lx, %ld)\r", handle, buf, bytes);
#endif
/*
** The handle must be valid or else it is an error.
*/
if (!buf || !bytes || !Is_Handle_Valid(handle, READING_NON_HANDLE, NULL)) {
return(NULL);
}
CallingDOSInt++;
/*
** Prepare some working variables.
*/
doshandle = FileHandleTable[handle].Handle;
fileindex = FileHandleTable[handle].Index;
/*
** Limit the number of bytes to read according to the size of the
** file. If no file size is specified, then don't perform the check.
*/
if (fileindex != ERROR) {
filedata = &FileDataPtr[fileindex];
if (filedata->Size) {
bytes = MIN((ULONG)filedata->Size - FileHandleTable[handle].Pos, bytes);
}
}
/*
** Starts with no bytes being read in.
*/
bytesread = 0;
if (bytes) {
if (doshandle) {
/*
** Perform a DOS read of the file. Read the file in chunks.
*/
while (bytes) {
LONG number; // Number of bytes read.
/*
** Read in a chunk of file data.
*/
Hard_Error_Occured = 0;
number = (LONG)FILEREAD(doshandle, buf, MIN(bytes, IO_CHUNK_SIZE));
/*
** if a hard error occurs, read its copy on a different directory
*/
if ( Hard_Error_Occured ) {
number = Read_File_With_Recovery( handle, buf, (UWORD)MIN(bytes, IO_CHUNK_SIZE));
doshandle = FileHandleTable[handle].Handle;
}
/*
** Adjust the remaining bytes to read counter and adjust the count
** of the number of bytes actually read from the file.
*/
bytes -= number;
bytesread += number;
/*
** Adjust the file position (manually).
*/
FileHandleTable[handle].Pos += number;
/*
** If less than requested bytes were read from the file, then
** we KNOW that the reading loop must terminate.
** Was there an error?
*/
if (number < IO_CHUNK_SIZE) {
break;
}
/*
** Adjust the destination pointer in anticipation of the next
** file read operation.
*/
// this is a BCC bug
// (BYTE *)buf += number;
buf = (BYTE* ) buf + number;
}
} else {
#if (DEBUGPRINT)
Mono_Printf("Resident read '%s' %08lx[%ld].%ld\r", filedata->Name, (LONG)filedata->Start, FileHandleTable[handle].Pos, bytes);
#endif
/*
** Copy the block of the file into the specified buffer.
*/
Mem_Copy((VOID*)((LONG)filedata->Ptr + FileHandleTable[handle].Start + FileHandleTable[handle].Pos), buf, bytes);
bytesread = bytes;
/*
** Adjust the file position (manually).
*/
FileHandleTable[handle].Pos += bytes;
}
}
/*
** Return with the number of bytes read in from the file.
*/
CallingDOSInt--;
return(bytesread);
}
/***************************************************************************
* WRITE_FILE -- Writes a block of data to a file. *
* *
* This routine will write a block of data to a file. The file must *
* have been previously opened with WRITE or READ|WRITE access. *
* Writing cannot occur to a resident or packed file. *
* *
* INPUT: handle -- File handle as returned by Open_File. *
* *
* buf -- Pointer to the buffer that holds the data to be *
* written out. *
* *
* bytes -- The number of bytes to write out. *
* *
* OUTPUT: Returns with the actual number of bytes written to the file. *
* *
* WARNINGS: If the value returned from this function is less than the *
* number of bytes requested to be written, then this *
* indicates some kind of error NOT caught by the file I/O *
* system. *
* *
* HISTORY: *
* 11/13/1991 JLB : Created. *
*=========================================================================*/
LONG cdecl Write_File(WORD handle, VOID const *buf, ULONG bytes)
{
WORD doshandle; // DOS specific file handle.
WORD fileindex; // FileData table index (if any).
LONG byteswritten; // Accumulated number of bytes written.
FileDataType *filedata; // Pointer to the current FileData.
#if(DEBUGPRINT)
Mono_Printf("Write_File(%d, %08lx, %ld)\r", handle, buf, bytes);
#endif
/*
** Check to make sure the file handle is valid.
*/
if (!Is_Handle_Valid(handle, WRITING_NON_HANDLE, NULL)) {
return(NULL);
}
doshandle = FileHandleTable[handle].Handle;
fileindex = FileHandleTable[handle].Index;
filedata = &FileDataPtr[fileindex];
/*
** Writing to a resident file is an error condition.
*/
if (!doshandle) {
Do_IO_Error(WRITING_RESIDENT, filedata->Name);
return(NULL);
}
CallingDOSInt++;
/*
** Perform a DOS write of the data. This write is performed in blocks.
*/
byteswritten = NULL;
while (bytes) {
LONG outbytes; // Number bytes written in one block.
/*
** Write out one block of data.
*/
outbytes = FILEWRITE(doshandle, (void*)buf, MIN((LONG)bytes, IO_CHUNK_SIZE));
/*
** Reduce the bytes remaining to output counter and adjust the
** file position.
*/
bytes -= outbytes;
byteswritten += outbytes;
FileHandleTable[handle].Pos += outbytes;
/*
** If NO bytes were written out, then this is some kind of unknown
** error (possibly disk full?).
*/
if (!outbytes) {
break;
}
/*
** Possible adjustment to the file's size.
*/
if (fileindex != ERROR) {
filedata->Size = MAX(filedata->Size, FileHandleTable[handle].Pos);
}
/*
** Adjust the source pointer in anticipation of the next block write.
*/
buf = (BYTE*)(((LONG)buf) + outbytes);
}
/*
** Return with the actual number of bytes written.
*/
CallingDOSInt--;
return (byteswritten);
}
/***************************************************************************
* SEEK_FILE -- Adjusts the position of the file pointer. *
* *
* This routine adjusts the position of the file pointer. Use this *
* to control where the next Read_File or Write_File will occur. *
* *
* INPUT: handle -- File handle as returned by Open_File. *
* *
* offset -- Signed offset from indicated starting position. *
* *
* starting -- SEEK_CUR: Seeks from the current position. *
* SEEK_SET: Seeks from the start of the file. *
* SEEK_END: Seeks backward from the end. *
* *
* OUTPUT: Returns with the new file position. *
* *
* WARNINGS: Seeking past the end or before the beginning of the file *
* is not allowed. *
* *
* HISTORY: *
* 11/13/1991 JLB : Created. *
*=========================================================================*/
ULONG cdecl Seek_File(WORD handle, LONG offset, WORD starting)
{
WORD doshandle; // DOS specific file handle.
WORD fileindex; // FileData index (if any).
FileDataType *filedata; // Pointer to the current FileData.
#if(DEBUGPRINT)
Mono_Printf("Seek_File(%d, %ld, %d)\r", handle, offset, starting);
#endif
/*
** Check to make sure that the file handle is valid.
*/
if (!Is_Handle_Valid(handle, SEEKING_NON_HANDLE, NULL)) {
return(NULL);
}
CallingDOSInt++;
fileindex = FileHandleTable[handle].Index;
doshandle = FileHandleTable[handle].Handle;
filedata = &FileDataPtr[fileindex];
if (!doshandle) {
/*
** Resident file seek is merely an adjustment to the position value.
*/
switch (starting) {
/*
** Manually position from start of file.
*/
case SEEK_SET:
offset = MAX((long)0, offset); // Only positive offsets allowed.
FileHandleTable[handle].Pos = NULL;
break;
/*
** Position is relative to end of file.
*/
case SEEK_END:
offset = MIN((long)0, offset); // Only negative offsets allowed.
FileHandleTable[handle].Pos = filedata->Size;
break;
case SEEK_CUR:
break;
default:
Do_IO_Error(SEEKING_BAD_OFFSET, FileHandleTable[handle].Name);
break;
}
/*
** Perform the resident file position adjustment.
*/
FileHandleTable[handle].Pos += offset;
FileHandleTable[handle].Pos = MIN(FileHandleTable[handle].Pos, filedata->Size-1);
FileHandleTable[handle].Pos = MAX(FileHandleTable[handle].Pos, (long)0);
} else {
/*
** Special handling for packed file seeks.
*/
if (fileindex != ERROR && (filedata->Flag & FILEF_PACKED)) {
switch (starting) {
case SEEK_SET:
FileHandleTable[handle].Pos = offset;
break;
case SEEK_END:
// Only negative offsets allowed.
// Do not allow seeking past the beginning.
offset = MIN(0L, offset);
if (-offset > filedata->Size) {
Do_IO_Error(SEEKING_BAD_OFFSET, FileHandleTable[handle].Name);
}
FileHandleTable[handle].Pos = filedata->Size + offset;
break;
case SEEK_CUR:
FileHandleTable[handle].Pos += offset;
if (FileHandleTable[handle].Pos < 0) {
FileHandleTable[handle].Pos = 0;
}
if (FileHandleTable[handle].Pos >= filedata->Size) {
FileHandleTable[handle].Pos = filedata->Size;
}
break;
default:
Do_IO_Error(SEEKING_BAD_OFFSET, FileHandleTable[handle].Name);
break;
}
FILESEEK(doshandle, FileHandleTable[handle].Pos+FileHandleTable[handle].Start, SEEK_SET);
CallingDOSInt--;
return (FileHandleTable[handle].Pos);
}
/*
** Perform the straight DOS seek.
*/
FileHandleTable[handle].Pos = FILESEEK(doshandle, offset, starting);
/*
** File position does not recognize packed offset.
*/
if (fileindex != ERROR) {
FileHandleTable[handle].Pos -= FileHandleTable[handle].Start;
//SKB FileHandleTable[handle].Pos -= filedata->Start;
}
}
/*
** Return with the current file position.
*/
CallingDOSInt--;
return (FileHandleTable[handle].Pos);
}
/***************************************************************************
* FILE_EXISTS -- Searches for and FINDS the specified file. *
* *
* This routine will scan the available drives and return when the file *
* is accessable. This routine is used when the programmer MUST be *
* sure of a file's existance before proceeding. This process is *
* automatically performed on a Open_File with READ access. *
* *
* INPUT: file_name -- Name of the file to check for. *
* *
* OUTPUT: Returns the disk number that the file exits on (A=1, B=2, etc) *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/14/1991 JLB : Created. *
*=========================================================================*/
WORD cdecl File_Exists(BYTE const *file_name)
{
/*
** If the filename is invalid then it errors out.
*/
if (!file_name) return(FALSE);
/*
** Continually search for the file (prompting as needed). Only return
** upon success or error function control reasons.
*/
while (!Find_File(file_name)) {
/*
** If the file could not be found then request for proper disk.
*/
do {
//struct find_t ffblk;
//BYTE path[MAXPATH];
if (!Do_Open_Error(COULD_NOT_OPEN, file_name)) {
return(FALSE);
}
ibm_setdisk(*DataPath - 'A');
// Search for the volume ID so that the disk information get read in again.
//_dos_findfirst("*.*", _A_VOLID, &ffblk);
} while (CHANGEDIR( DataPath ));
}
return (TRUE);
}
/***************************************************************************
* FILE_SIZE -- Determine the size of the specified file. *
* *
* This routine will return with the size of the file specified by the *
* file handle passed in. *
* *
* INPUT: handle -- Westwood file handle. *
* *
* OUTPUT: Returns with the size of the file in bytes. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/22/1991 JLB : Created. *
*=========================================================================*/
ULONG cdecl File_Size(WORD handle)
{
FileDataType *filedata; // Pointer to the current FileData.
if (FileHandleTable[handle].Index != ERROR) {
filedata = &FileDataPtr[FileHandleTable[handle].Index];
if (filedata->Size) {
return(filedata->Size);
}
}
return (filelength(FileHandleTable[handle].Handle));
}
/***************************************************************************
* IS_HANDLE_VALID -- Determines validity of the specified file handle. *
* *
* Use this routine to determine if a file handle is valid or not. It *
* checks to see if it falls within legal limits and does in fact *
* reference an open file. This routine will call the error handler *
* with the specified error number if the handle is not valid. *
* *
* INPUT: handle -- Handle to check for validity. *
* *
* error -- Error number to use when calling the IO_Error *
* handler. *
* *
* name -- The file name (if known). *
* *
* OUTPUT: Returns with the file table index, if one exists for this *
* file. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/13/1991 JLB : Created. *
*=========================================================================*/
BOOL cdecl Is_Handle_Valid(WORD handle, FileErrorType error, BYTE const *name)
{
/*
** The handle must be valid or else it is an error.
*/
if (handle < 0 || handle >= TABLE_MAX) {
/*
** ERROR: Invalid file handle.
*/
Do_IO_Error(error, name);
}
/*
** An unused file handle causes an error.
*/
if (FileHandleTable[handle].Empty) {
Do_IO_Error(error, name);
}
return (TRUE);
}