RedAlert/WWFLAT32/FILE/FILEINIT.CPP

/*
**	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 <http://www.gnu.org/licenses/>.
*/

/***************************************************************************
 **   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 - Fileio init routines.          *
 *                                                                         *
 *                    File Name : FILEINIT.C                               *
 *                                                                         *
 *                   Programmer : Scott K. Bowen                           *
 *                                                                         *
 *                   Start Date : September 13, 1993                       *
 *                                                                         *
 *                  Last Update : April 19, 1994   [SKB]                   *
 *                                                                         *
 *-------------------------------------------------------------------------*
 * Functions:                                                              *
 *   WWDOS_Init -- Initialize the fileio WWS fileio system.                *
 *   WWDOS_Shutdown -- Clean up any things that needs to be to exit game.  *
 *   Init_FileData_Table -- Initializes or reads in FileData Table.        *
 *   Sort_FileData_Table -- Sorts the FileData table that is in memory.    *
 *   Preload_Files -- Loads files marked with FILEF_PRELOAD into cache.    *
 *   Init_File_Cache -- Initializes and allocs the file cache heap.        *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef WWSTD_H
#include "wwstd.h"
#endif	   

#ifndef _FILE_H
#include "_file.h"
#endif

#ifndef WWMEM_H
#include <wwmem.h>
#endif

#ifndef MISC_H
#include <misc.h>
#endif

#include <direct.h>
#include <search.h>
#include <string.h>

/*=========================================================================*/
/* The following PRIVATE functions are in this file:                       */
/*=========================================================================*/

PRIVATE FileInitErrorType cdecl Init_File_Cache(ULONG cachesize);
PRIVATE FileInitErrorType cdecl Init_FileData_Table(BYTE const *filename);
PRIVATE FileInitErrorType cdecl Set_Search_Drives( BYTE *cdpath );
PRIVATE FileInitErrorType cdecl Preload_Files(VOID);
PRIVATE int QSort_Comp_Func(const void *p1, const void *p2);
PRIVATE VOID Sort_FileData_Table(VOID);

/*= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =*/



/***************************************************************************
 * WWDOS_INIT -- Initialize the fileio WWS fileio system.                  *
 *                                                                         *
 *                                                                         *
 * INPUT:   ULONG cachesize - size wanted for the cache.                   *
 *          BYTE *filedat - NULL or name of filedata table file.           *
 *          BYTE *cdpath - NULL or secondary search path on a CD.          *
 *                                                                         *
 * OUTPUT:  Returns all errors encountered or'd together.						*
 *                                                                         *
 * WARNINGS:  User should call the WWDOS_Init function for all file 			*
 *            initialization.																*
 *                                                                         *
 * HISTORY:                                                                *
 *   04/19/1994 SKB : Created.                                             *
 *=========================================================================*/
FileInitErrorType cdecl WWDOS_Init(ULONG cachesize, BYTE *filedata, BYTE *cdpath)
{
//	FileInitErrorType errors;
	unsigned errors ;
	
	// This has not been completed yet, when it is, uncomment it and add errors.
	Install_Hard_Error_Handler () ;
	Get_Devices();

	if (cachesize) {	
		errors = Init_File_Cache(cachesize);
	} else {
	 	errors = FI_SUCCESS;
	}


	errors = errors | Init_FileData_Table(filedata);

	errors = errors | Set_Search_Drives(cdpath);

	errors = errors | Preload_Files();


	return ( FileInitErrorType ) errors ;
}

/***************************************************************************
 * WWDOS_SHUTDOWN -- Clean up any things that needs to be in file syste to *
 *                   exit game.    														*
 *                   One could shut down the file system and open it back  *
 *                   up with a different size cache or filetable.          *
 *                                                                         *
 * INPUT:   NONE.																				*
 *                                                                         *
 * OUTPUT:  NONE.                                                          *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   04/19/1994 SKB : Created.                                             *
 *=========================================================================*/
VOID cdecl WWDOS_Shutdown(VOID)
{
	FileDataType			*filedata;					// Pointer to the current FileData.
	WORD						file_handle;
	FileHandleType		  	*filehandletable;			// Pointer to the current file handle.

	// Close all open files.
	filehandletable = FileHandleTable;
	for (file_handle = 0; file_handle < TABLE_MAX; file_handle++, filehandletable++) {
		if (!filehandletable->Empty) {
		  	Close_File(file_handle);
		}
	}

	// Free the file cache heap.
	if (FileCacheHeap) {

		// Get a pointer to the current filedata.
		if (FileDataPtr) {
	 		filedata = FileDataPtr;
		} else {
	 		filedata = FileData;
		}

		while(filedata->Name && filedata->Name[0]) {
			filedata->Ptr = NULL;
			filedata++;
		}

		Free(FileCacheHeap);
		FileCacheHeap = NULL;
	}

	// Free up the file data.
	if (FileDataPtr != FileData) {
		Free(FileDataPtr);
	}
	FileDataPtr = NULL;

	chdir(StartPath);
	ibm_setdisk(*StartPath - 'A');

	// This has not been completed yet, when it is, uncomment it and add errors.
	Remove_Hard_Error_Handler();
}


/***************************************************************************
 * INIT_FILE_CACHE -- Initializes and allocs the file cache heap.          *
 *                                                                         *
 * INPUT:  ULONG cachesize - size of heap cache..                          *
 *                                                                         *
 * OUTPUT: FileInitErrorType  error code.                                  *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   04/19/1994 SKB : Created.                                             *
 *=========================================================================*/
PRIVATE FileInitErrorType cdecl Init_File_Cache(ULONG cachesize)
{
	// Allocate and initialize the file cache heap.
	if (FileCacheHeap) {
 	 	return (FI_CACHE_ALREADY_INIT);
	}

	if ((Ram_Free(MEM_NORMAL) >= cachesize)) {
		FileCacheHeap = Alloc(cachesize, MEM_NORMAL);
		Mem_Init(FileCacheHeap, cachesize);
	}

	if (!FileCacheHeap) {
	 	return (FI_CACHE_TOO_BIG);
	}

	return (FI_SUCCESS);
}




/***************************************************************************
 * INIT_FILEDATA_TABLE -- Initializes or reads in FileData Table.          *
 *                                                                         *
 * INPUT:                                                                  *
 *                                                                         *
 * OUTPUT: FileInitErrorType  error code.                                  *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   09/13/1993 SKB : Created.                                             *
 *=========================================================================*/
PRIVATE FileInitErrorType cdecl Init_FileData_Table(BYTE const *filename)
{
	WORD					fd;
	ULONG					fsize;
	FileDataType		*ptr;
	WORD 					index;
	BYTE					fname[13];		

	/*
	**	Inialize the file handle table to reflect no files open.
	*/
	for (index = 0; index < TABLE_MAX; index++) {
		FileHandleTable[index].Empty = TRUE;
	}

	// Set up our FileData ptr to be the initial FileData table.
	FileDataPtr = FileData;

	// Sort the filedata table.
	// This needs to be done even if we load it off disk since the initial file data
	// table might contain a filename.
	Sort_FileData_Table();

	// If there is a file name, then the filedata table will be loaded from disk.
	if (filename) {
		if (!Find_File(filename)) {
		 	return (FI_FILEDATA_FILE_NOT_FOUND);
		}
		fd = Open_File(filename, READ);

		fsize = File_Size(fd);

		if ((Ram_Free(MEM_NORMAL) < fsize)) {
			Close_File(fd);
		 	return (FI_FILEDATA_TOO_BIG);
		}

		// Allocate some system memory.
		// Setup the new FileDataPtr and this time.
		FileDataPtr = ptr = (FileDataType *) Alloc(fsize, MEM_NORMAL);

		// Load the file up into  memory.
		Read_File(fd, FileDataPtr, fsize);
		Close_File(fd);

		// Process the filetable.  The filenames need their pointers adjusted.
		// At this time we will also count the number of files and number of PAK files.
		NumPAKFiles = NumFiles = 0;

		// Make sure that the file name will have a NUL at the end.
		fname[12] = 0;
		while(TRUE) {
			// Have we reached the end of the list?	
			if (!ptr->Name) break;
		 	
			// Adjust the name pointer to point the the correct area.
			ptr->Name = (BYTE *)FileDataPtr + (LONG) ptr->Name;

			// Count up weather it is a PAK file or a normal file.
			if (!NumFiles && strstr((char *) ptr->Name, (char *)  ".PAK")) {
			 	NumPAKFiles++;

				// Mark that it has been processed so that Open_File() will not do it.
				ptr->Flag |= FILEF_PROCESSED;

			} else {
				NumFiles++;
			}

			// Next record.
			ptr++;
		}
	}

	return (FI_SUCCESS);
}




/***************************************************************************
 * Set_Search_Drives -- Sets up the CDRom and HardDrive paths.             *
 *                                                                         *
 * INPUT:    BYTE *cdpath - path of data files on a CD.							*
 *           					 Should pass in NULL for non CD products.			*
 *           																					*
 * OUTPUT: FileInitErrorType  error code.                                  *
 *           Varibable defined:                                            *
 *               ExecPath = Full path of EXE file.                         *
 *               StartPath = Directory user started in.                    *
 *               DataPath = secondary search path (typically CD-ROM).      *
 *           Note: format of paths is "C:\PATH"                           	*
 *                                                                         *
 * WARNINGS: The cdpath may be overiden by a "-CD<path>" command line      *
 *           arguement that specifies another drive (HARD or CD) and path  *
 *           where the data resides.  Whenever a file is opened, it checks *
 *           the startup drive first, then the CD search path if the first *
 *           search was unsuccessful.                                      *
 *                                                                         *
 * HISTORY:                                                                *
 *   01/14/1993  SB : Created.                                             *
 *   04/19/1994 SKB : Mods for 32 bit library.                             *
 *=========================================================================*/
PRIVATE FileInitErrorType cdecl Set_Search_Drives( BYTE *cdpath )
{
	BYTE *ptr;


#if LIB_EXTERNS_RESOLVED 
	// NOTE: THIS IS WRONG, THIS IS NOT THE WAY TO GET THE EXE's PATH.
	// Locate the executable.	
	strcpy(ExecPath, _argv[0]);

	// Find the very last '\' on the path.
	ptr = strrchr((char *) ExecPath, (int) '\\');
#else
	ptr = NULL;
#endif

	// Remove the exe name to just have the path.
	if (ptr == NULL) {
		*ExecPath = 0;
	}
	else {
	 	*ptr = 0; 
	}

	// Did the user specify a second path?
	ptr = Find_Argv("-CD");

	// If so, set the data path to that.
	if (ptr) {
		strcpy(DataPath, ptr + 3);
	}
	// Otherwise check to see if there is a CD-Rom drive.
	else {
		if (cdpath && *cdpath) {

#if LIB_EXTERNS_RESOLVED
			UseCD = GetCDDrive();
#else
			UseCD = FALSE;
#endif
		}
		else {
		 	UseCD = FALSE;
		}

		// If so, set the Drive to it and find out if any directories.
		if ( UseCD ) {
			strcpy( DataPath, "A:" );
			strcat( DataPath, cdpath);
			*DataPath = 'A'+UseCD;
		}
		// If not, set the Data path to the execacutable path.
		else {
	 		strcpy(DataPath, ExecPath);
		}
	}

	// Finnally, set the starting path.
	getcwd(StartPath, XMAXPATH);

	// Make sure they are all uppercase.
	strupr(StartPath);
	strupr(DataPath);
	strupr(ExecPath);

	// Change directories to the secondary search path (DataPath).
	if (*DataPath && chdir(DataPath)) {
		return (FI_SEARCH_PATH_NOT_FOUND);
	}

	// Lastley, Make sure we are in the startup directory.  This will overide
	// the secondary data path if they are on the same drive.
	if (chdir(StartPath)) {
		return (FI_STARTUP_PATH_NOT_FOUND);
	}

	return (FI_SUCCESS);
}


/***************************************************************************
 * PRELOAD_FILES -- Loads files marked with FILEF_PRELOAD into cache.      *
 *                                                                         *
 *                                                                         *
 * INPUT:  none.                                                           *
 *                                                                         *
 * OUTPUT: FileInitErrorType  error code.                                  *
 *                                                                         *
 * WARNINGS: The FileData must be initialized and the file heap initialized*
 *           in order for this to work.                                    *
 *                                                                         *
 * HISTORY:                                                                *
 *   04/19/1994 SKB : Created.                                             *
 *=========================================================================*/
PRIVATE FileInitErrorType cdecl Preload_Files(VOID)
{
	FileDataType	*filedata;		// Working file data table pointer.
	BOOL				oldflag;			// Previous file flag.

	if (!FileDataPtr) {
		return (FI_FILETABLE_NOT_INIT);
	}

	if (!FileCacheHeap) {
		return (FI_NO_CACHE_FOR_PRELOAD);
	}

	/*
	**	Make all files flagged to be made resident at startup, resident.
	*/
	filedata = FileDataPtr;

	while (filedata->Name && strlen(filedata->Name)) {
		if (filedata->Flag & FILEF_PRELOAD) {

			oldflag = filedata->Flag;
			filedata->Flag |= FILEF_RESIDENT;	// Make it resident.
			filedata->Flag &= ~FILEF_FLUSH;		// Don't purge on Close_File.

			Close_File(Open_File(filedata->Name, READ));

			filedata->Flag &= ~(FILEF_RESIDENT|FILEF_FLUSH);	// Clear bits.
			filedata->Flag |= oldflag & (FILEF_RESIDENT|FILEF_FLUSH);	// Restore bits.

		}
		filedata++;
	}
	return (FI_SUCCESS);
}



/***************************************************************************
 * SORT_FILEDATA_TABLE -- Sorts the FileData table that is in memory.      *
 *                                                                         *
 * INPUT:  NONE                                                            *
 *                                                                         *
 * OUTPUT: NONE.                                                           *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   09/13/1993 SKB : Created.                                             *
 *=========================================================================*/

PRIVATE int QSort_Comp_Func(const void *p1, const void *p2)
{
	return(strcmp(((FileDataType*)p1)->Name, ((FileDataType*)p2)->Name));
}
PRIVATE VOID Sort_FileData_Table(VOID)
{
	/*
	**	Sort the filetable it but keep the pack file indexes correct.
	*/

	/*
	**	The number of pak files in the file table.
	*/
	NumPAKFiles = 0;
	strupr(FileData[NumPAKFiles].Name);
	while (strstr((char *) FileData[NumPAKFiles].Name, (char *) ".PAK")) {
		strupr(FileData[NumPAKFiles].Name);
		NumPAKFiles++;
	}

	/*
	**	Count the remaining files within the file table.
	*/
	NumFiles = 0;
	while(FileData[NumFiles+NumPAKFiles].Name && FileData[NumFiles+NumPAKFiles].Name[0]) {
		strupr(FileData[NumFiles+NumPAKFiles].Name);
		NumFiles++;
	}

	/*
	**	Sort the file entries (past the pak files).
	*/
	if (NumFiles) {
		qsort(&FileData[NumPAKFiles], NumFiles, sizeof(FileDataType), QSort_Comp_Func);
	}
}