FileSystem: add standalone implementation

Standalone FileSystem implementation, allowing SDK code to be used in tools without adjusting them as the vtables remain identical. NOTE that this reimplementation is partial and only contains the reading and writing of files to/from buffers or disk as that's what we are mainly interested at. We can always implement the other methods when needed.

NOTE: the filesystem singleton accessor (CFileSystem_Stdio* FileSystem()) has been moved to an implementation file instead of being inline as this would allow existing code to link to the tools implementation instead.

src/filesystem/CMakeLists.txt

@@ -18,3 +18,20 @@ add_sources( SOURCE_GROUP "Public"
 end_sources()
 
 target_include_directories( ${PROJECT_NAME} PRIVATE "${ENGINE_SOURCE_DIR}/tier0/" "${ENGINE_SOURCE_DIR}/tier1/" )
+
+add_module( "lib" "filesystem_std" "vpc" ${FOLDER_CONTEXT} TRUE TRUE )
+
+start_sources()
+
+add_sources( SOURCE_GROUP "Private"
+    "filesystem_std.cpp"
+    "filesystem_std.h"
+)
+
+add_sources( SOURCE_GROUP "Public"
+    "${ENGINE_SOURCE_DIR}/public/ifilesystem.h"
+)
+
+end_sources()
+
+target_include_directories( ${PROJECT_NAME} PRIVATE "${ENGINE_SOURCE_DIR}/tier0/" "${ENGINE_SOURCE_DIR}/tier1/" )

src/filesystem/filesystem.cpp

@@ -4,4 +4,9 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 CFileSystem_Stdio** g_pFullFileSystem  = nullptr;
-CFileSystem_Stdio* g_pFileSystem_Stdio = nullptr;
+CFileSystem_Stdio* g_pFileSystem_Stdio = nullptr;
+
+CFileSystem_Stdio* FileSystem()
+{
+	return (*g_pFullFileSystem);
+}

src/filesystem/filesystem.h

@@ -36,10 +36,7 @@ extern CFileSystem_Stdio*  g_pFileSystem_Stdio;
 //-----------------------------------------------------------------------------
 // Singleton FileSystem
 //-----------------------------------------------------------------------------
-inline CFileSystem_Stdio* FileSystem()
-{
-	return (*g_pFullFileSystem);
-}
+extern CFileSystem_Stdio* FileSystem();
 
 ///////////////////////////////////////////////////////////////////////////////
 class VFileSystem_Stdio : public IDetour

src/filesystem/filesystem_std.cpp

@@ -0,0 +1,354 @@
+//=============================================================================//
+//
+// Purpose: FileSystem class utilizing standard libraries.
+// ----------------------------------------------------------------------------
+// NOTE: use this for standalone/tools projects
+//=============================================================================//
+#include "filesystem_std.h"
+
+ssize_t CBaseFileSystem::Read(void* pOutput, ssize_t size, FileHandle_t file)
+{
+	return fread(pOutput, size, 1, (FILE*)file);
+}
+
+ssize_t CBaseFileSystem::Write(void const* pInput, ssize_t size, FileHandle_t file)
+{
+	return fwrite(pInput, size, 1, (FILE*)file);
+}
+
+FileHandle_t CBaseFileSystem::Open(const char* pFileName, const char* pOptions, const char* pPathID, int64_t unknown)
+{
+	NOTE_UNUSED(unknown);
+
+	char fullPath[1024];
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	return (FileHandle_t)fopen(fullPath, pOptions);
+}
+
+void CBaseFileSystem::Close(FileHandle_t file)
+{
+	fclose((FILE*)file);
+}
+
+void CBaseFileSystem::Seek(FileHandle_t file, ssize_t pos, FileSystemSeek_t seekType)
+{
+	fseek((FILE*)file, (long)pos, seekType);
+}
+
+ptrdiff_t CBaseFileSystem::Tell(FileHandle_t file)
+{
+	return ftell((FILE*)file);
+}
+
+ssize_t CBaseFileSystem::FSize(const char* pFileName, const char* pPathID)
+{
+	char fullPath[1024];
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	FILE* fp = fopen(fullPath, "rb");
+	if (!fp)
+		return 0;
+
+	fseek(fp, 0, SEEK_END);
+	ptrdiff_t size = Tell(fp);
+
+	fclose(fp);
+	return size;
+}
+
+ssize_t CBaseFileSystem::Size(FileHandle_t file)
+{
+	fseek((FILE*)file, 0, SEEK_END);
+	ptrdiff_t size = Tell((FILE*)file);
+
+	fseek((FILE*)file, 0, SEEK_SET);
+	return size;
+}
+
+void CBaseFileSystem::Flush(FileHandle_t file)
+{
+	fflush((FILE*)file);
+}
+
+bool CBaseFileSystem::Precache(const char* pFileName, const char* pPathID)
+{
+	NOTE_UNUSED(pPathID);
+	NOTE_UNUSED(pFileName);
+	return true;
+}
+
+bool CBaseFileSystem::FileExists(const char* pFileName, const char* pPathID)
+{
+	char fullPath[1024];
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	FILE* fp = fopen(fullPath, "rb");
+	if (!fp)
+		return false;
+
+	fclose(fp);
+	return true;
+}
+
+bool CBaseFileSystem::IsFileWritable(char const* pFileName, const char* pPathID)
+{
+	char fullPath[1024];
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	FILE* fp = fopen(fullPath, "a");
+	if (!fp)
+		return false;
+
+	fclose(fp);
+	return true;
+}
+
+bool CBaseFileSystem::SetFileWritable(char const* pFileName, bool writable, const char* pPathID)
+{
+	NOTE_UNUSED(pPathID);
+	NOTE_UNUSED(writable);
+	NOTE_UNUSED(pFileName);
+	return true;
+}
+
+long long CBaseFileSystem::GetFileTime(const char* pFileName, const char* pPathID)
+{
+	char fullPath[1024];
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	struct stat result;
+
+	// On POSIX systems, st_mtime is the time of last
+	// modification in seconds since the epoch.
+	if (stat(fullPath, &result) == NULL)
+		return (long)result.st_mtime;
+	else
+		return -1;
+}
+
+bool CBaseFileSystem::GetOptimalIOConstraints(FileHandle_t hFile, uint64_t* pOffsetAlign, uint64_t* pSizeAlign, uint64_t* pBufferAlign)
+{
+	if (pOffsetAlign)
+		*pOffsetAlign = 1;
+	if (pSizeAlign)
+		*pSizeAlign = 1;
+	if (pBufferAlign)
+		*pBufferAlign = 1;
+	return false;
+}
+
+bool CBaseFileSystem::ReadToBuffer(FileHandle_t hFile, CUtlBuffer& buf, ssize_t nMaxBytes, FSAllocFunc_t pfnAlloc)
+{
+	ssize_t nBytesToRead = Size(hFile);
+	if (nBytesToRead == 0)
+	{
+		// no data in file
+		return true;
+	}
+
+	if (nMaxBytes > 0)
+	{
+		// can't read more than file has
+		nBytesToRead = MIN(nMaxBytes, nBytesToRead);
+	}
+
+	ssize_t nBytesRead = 0;
+	ptrdiff_t nBytesOffset = 0;
+
+	ptrdiff_t iStartPos = Tell(hFile);
+
+	if (nBytesToRead != 0)
+	{
+		ssize_t nBytesDestBuffer = nBytesToRead;
+		uint64_t nSizeAlign = 0, nBufferAlign = 0, nOffsetAlign = 0;
+
+		bool bBinary = !(buf.IsText() && !buf.ContainsCRLF());
+
+		if (bBinary && !IsPosix() && !buf.IsExternallyAllocated() && !pfnAlloc &&
+			(buf.TellPut() == 0) && (buf.TellGet() == 0) && (iStartPos % 4 == 0) &&
+			GetOptimalIOConstraints(hFile, &nOffsetAlign, &nSizeAlign, &nBufferAlign))
+		{
+			// correct conditions to allow an optimal read
+			if (iStartPos % nOffsetAlign != 0)
+			{
+				// move starting position back to nearest alignment
+				nBytesOffset = (iStartPos % nOffsetAlign);
+				Assert((iStartPos - nBytesOffset) % nOffsetAlign == 0);
+				Seek(hFile, -nBytesOffset, FILESYSTEM_SEEK_CURRENT);
+
+				// going to read from aligned start, increase target buffer size by offset alignment
+				nBytesDestBuffer += nBytesOffset;
+			}
+
+			// snap target buffer size to its size alignment
+			// add additional alignment slop for target pointer adjustment
+			nBytesDestBuffer = AlignValue(nBytesDestBuffer, nSizeAlign) + nBufferAlign;
+		}
+
+		AssertMsg(!pfnAlloc, "Custom allocators not yet supported!");
+
+		//if (!pfnAlloc)
+		{
+			buf.EnsureCapacity(nBytesDestBuffer + buf.TellPut());
+		}
+		//else
+		//{
+		//	// caller provided allocator
+		//	void* pMemory = (*pfnAlloc)(g_pszReadFilename, nBytesDestBuffer);
+		//	buf.SetExternalBuffer(pMemory, nBytesDestBuffer, 0, buf.GetFlags() & ~CUtlBuffer::EXTERNAL_GROWABLE);
+		//}
+
+		ssize_t seekGet = -1;
+		if (nBytesDestBuffer != nBytesToRead)
+		{
+			// doing optimal read, align target pointer
+			ssize_t nAlignedBase = AlignValue((byte*)buf.Base(), nBufferAlign) - (byte*)buf.Base();
+			buf.SeekPut(CUtlBuffer::SEEK_HEAD, nAlignedBase);
+
+			// the buffer read position is slid forward to ignore the addtional
+			// starting offset alignment
+			seekGet = nAlignedBase + nBytesOffset;
+		}
+
+		nBytesRead = ReadEx(buf.PeekPut(), nBytesDestBuffer - nBufferAlign, nBytesToRead + nBytesOffset, hFile);
+		buf.SeekPut(CUtlBuffer::SEEK_CURRENT, nBytesRead);
+
+		if (seekGet != -1)
+		{
+			// can only seek the get after data has been put, otherwise buffer sets overflow error
+			buf.SeekGet(CUtlBuffer::SEEK_HEAD, seekGet);
+		}
+
+		Seek(hFile, iStartPos + (nBytesRead - nBytesOffset), FILESYSTEM_SEEK_HEAD);
+	}
+
+	return (nBytesRead != 0);
+}
+
+bool CBaseFileSystem::ReadFile(const char* pFileName, const char* pPath, CUtlBuffer& buf, ssize_t nMaxBytes, ptrdiff_t nStartingByte, FSAllocFunc_t pfnAlloc)
+{
+	//CHECK_DOUBLE_SLASHES(pFileName);
+
+	bool bBinary = !(buf.IsText() && !buf.ContainsCRLF());
+
+	FileHandle_t fp = Open(pFileName, (bBinary) ? "rb" : "rt", pPath);
+	if (!fp)
+		return false;
+
+	if (nStartingByte != 0)
+	{
+		Seek(fp, nStartingByte, FILESYSTEM_SEEK_HEAD);
+	}
+
+	AssertMsg(!pfnAlloc, "Custom allocators not yet supported!");
+
+	//if (pfnAlloc)
+	//{
+	//	g_pszReadFilename = (char*)pFileName;
+	//}
+
+	bool bSuccess = ReadToBuffer(fp, buf, nMaxBytes, pfnAlloc);
+
+	Close(fp);
+
+	return bSuccess;
+}
+
+bool CBaseFileSystem::WriteFile(const char* pFileName, const char* pPath, CUtlBuffer& buf)
+{
+	const char* pWriteFlags = "wb";
+	if (buf.IsText() && !buf.ContainsCRLF())
+	{
+		pWriteFlags = "wt";
+	}
+
+	FileHandle_t fp = Open(pFileName, pWriteFlags, pPath);
+	if (!fp)
+		return false;
+
+	ssize_t nBytesWritten = Write(buf.Base(), buf.TellMaxPut(), fp);
+
+	Close(fp);
+	return (nBytesWritten != 0);
+}
+
+ssize_t CBaseFileSystem::ReadEx(void* pOutput, ssize_t /*destSize*/, ssize_t size, FileHandle_t file)
+{
+	if (!file)
+	{
+		assert(0); // Tried to Read NULL file handle!
+		return 0;
+	}
+	if (size < 0)
+	{
+		return 0;
+	}
+
+	const ssize_t nRet = fread(pOutput, 1, size, (FILE*)file);
+	return nRet;
+
+}
+
+int CBaseFileSystem::CreateDirHierarchy(const char* pFileName, const char* pPathID)
+{
+	char fullPath[1024];
+	int results;
+
+	//if (pPathID)
+	//	snprintf(fullPath, sizeof(fullPath), "%s/%s", pPathID, pFileName);
+	//else
+	snprintf(fullPath, sizeof(fullPath), "%s", pFileName);
+
+	V_FixSlashes(fullPath);
+
+	char* pFullPath = fullPath;
+	while ((pFullPath = strchr(pFullPath, CORRECT_PATH_SEPARATOR)) != NULL)
+	{
+		// Temporarily turn the slash into a null
+		// to get the current directory.
+		*pFullPath = '\0';
+
+		results = _mkdir(fullPath);
+
+		if (results && errno != EEXIST)
+			return results;
+
+		*pFullPath++ = CORRECT_PATH_SEPARATOR;
+	}
+
+	// Try to create the final directory in the path.
+	return _mkdir(fullPath);
+}
+
+char* CBaseFileSystem::ReadLine(char* maxChars, ssize_t maxOutputLength, FileHandle_t file)
+{
+	return fgets(maxChars, (int)maxOutputLength, (FILE*)file);
+}
+
+CUtlString CBaseFileSystem::ReadString(FileHandle_t pFile)
+{
+	CUtlString result;
+	char c = '\0';
+
+	do
+	{
+		Read(&c, sizeof(char), pFile);
+
+		if (c)
+			result += c;
+
+	} while (c);
+
+	return result;
+}

src/filesystem/filesystem_std.h

@@ -0,0 +1,294 @@
+#ifndef FILESYSTEM_H
+#define FILESYSTEM_H
+#include <tier1/keyvalues.h>
+#include "ifilesystem.h"
+
+class CBaseFileSystem : public CTier1AppSystem<IFileSystem>
+{
+public:
+	// Stub implementation of IAppSystem.
+	//virtual ~CBaseFileSystem() {};
+	virtual bool Connect(const CreateInterfaceFn factory) { return false; };
+	virtual void Disconnect() {};
+	virtual void* QueryInterface(const char* const pInterfaceName) { return nullptr; };
+	virtual InitReturnVal_t Init() { return InitReturnVal_t::INIT_FAILED; };
+	virtual void Shutdown() {};
+	virtual AppSystemTier_t GetTier() { return AppSystemTier_t::APP_SYSTEM_TIER_OTHER; };
+	virtual void Reconnect(const CreateInterfaceFn factory, const char* const pInterfaceName) {};
+
+
+	//--------------------------------------------------------
+	virtual bool			IsSteam() const { return false; };
+	virtual	FilesystemMountRetval_t MountSteamContent(int nExtraAppId = -1) { return FilesystemMountRetval_t::FILESYSTEM_MOUNT_FAILED; };
+
+	virtual bool InitFeatureFlags() { return false; };
+	virtual bool InitFeatureFlags(const char* pszFlagSetFile) { return false; };
+
+	virtual void AddSearchPath(const char* pPath, const char* pPathID, SearchPathAdd_t addType) {};
+	virtual bool RemoveSearchPath(const char* pPath, const char* pPathID) { return false; };
+	virtual void			RemoveAllSearchPaths(void) {};
+	virtual void			RemoveSearchPaths(const char* szPathID) {};
+	virtual void			MarkPathIDByRequestOnly(const char* pPathID, bool bRequestOnly) {}
+	virtual const char* RelativePathToFullPath(const char* pFileName, const char* pPathID, char* pLocalPath, ssize_t localPathBufferSize, PathTypeFilter_t pathFilter = FILTER_NONE, PathTypeQuery_t* pPathType = NULL) { return nullptr; };
+#if IsGameConsole()
+	virtual bool            GetPackFileInfoFromRelativePath(const char* pFileName, const char* pPathID, char* pPackPath, ssize_t nPackPathBufferSize, ptrdiff_t& nPosition, ssize_t& nLength) { return false; };
+#endif
+	virtual ssize_t			GetSearchPath(const char* pathID, bool bGetPackFiles, char* pPath, ssize_t nMaxLen) { return NULL; };
+	virtual bool			AddPackFile(const char* fullpath, const char* pathID) { return false; };
+
+	//--------------------------------------------------------
+	// File manipulation operations
+	//--------------------------------------------------------
+	virtual void			RemoveFile(char const* pRelativePath, const char* pathID = 0) {};                  // Deletes a file (on the WritePath)
+	virtual bool			RenameFile(char const* pOldPath, char const* pNewPath, const char* pathID = 0) { return false; }; // Renames a file (on the WritePath)
+	virtual int				CreateDirHierarchy(const char* path, const char* pathID = 0);                   // create a local directory structure
+	virtual bool			IsDirectory(const char* pFileName, const char* pathID = 0) { return false; };                     // File I/O and info
+	virtual ssize_t			FileTimeToString(char* pStrip, ssize_t maxCharsIncludingTerminator, long fileTime) { return NULL; }; // Returns the string size
+
+	//--------------------------------------------------------
+	// Open file operations
+	//--------------------------------------------------------
+
+	virtual void			SetBufferSize(FileHandle_t file/*, ssize_t nBytes*/) {};
+	virtual bool			IsOk(FileHandle_t file) { return false; };
+	virtual bool			EndOfFile(FileHandle_t file) { return false; };
+	virtual char* ReadLine(char* pOutput, size_t maxChars, FileHandle_t file) { return nullptr; };
+#if ! defined(SWIG)
+	// Don't let SWIG see the PRINTF_FORMAT_STRING attribute or it will complain.
+	virtual ssize_t			FPrintf(FileHandle_t file, PRINTF_FORMAT_STRING const char* pFormat, ...) FMTFUNCTION(3, 4) { return NULL; };
+#else
+	virtual ssize_t			FPrintf(FileHandle_t file, const char* pFormat, ...) FMTFUNCTION(3, 4) { return NULL; };
+#endif
+
+	//--------------------------------------------------------
+	// Dynamic library operations
+	//--------------------------------------------------------
+	// load/unload modules
+	virtual CSysModule* LoadModule(const char* pFileName, const char* pPathID = 0, bool bValidatedDllOnly = true) { return nullptr; };
+	virtual void        UnloadModule(CSysModule* pModule) {};
+
+	//--------------------------------------------------------
+	// File searching operations
+	//--------------------------------------------------------
+	// FindFirst/FindNext. Also see FindFirstEx.
+	virtual const char* FindFirst(const char* pWildCard, FileFindHandle_t* pHandle) { return nullptr; };
+	virtual const char* FindNext(FileFindHandle_t handle) { return nullptr; };
+	virtual bool        FindIsDirectory(FileFindHandle_t handle) { return false; };
+	virtual void        FindClose(FileFindHandle_t handle) {};
+
+	// Same as FindFirst, but you can filter by path ID, which can make it faster.
+	virtual const char* FindFirstEx(
+		const char* pWildCard,
+		const char* pPathID,
+		FileFindHandle_t* pHandle
+	) { return nullptr; };
+
+	// Searches for a file in all paths and results absolute path names for the file, works in pack files (zip and vpk) too
+	// Lets you search for something like sound/sound.cache and get a list of every sound cache
+	virtual void			FindFileAbsoluteList(CUtlVector<CUtlString>& outAbsolutePathNames, const char* pWildCard, const char* pPathID) {};
+
+	//--------------------------------------------------------
+	// File name and directory operations
+	//--------------------------------------------------------
+
+	// FIXME: This method is obsolete! Use RelativePathToFullPath instead!
+	// converts a partial path into a full path
+	virtual const char* GetLocalPath(const char* pFileName, char* pLocalPath, ssize_t localPathBufferSize) { return nullptr; };
+
+	// Returns true on success ( based on current list of search paths, otherwise false if 
+	//  it can't be resolved )
+	virtual bool			FullPathToRelativePath(const char* pFullpath, char* pRelative, ssize_t maxlen) { return false; };
+
+	// Gets the current working directory
+	virtual bool			GetCurrentDirectory(char* pDirectory, unsigned int maxlen) { return false; }; // Last parameter is a DWORD passed to 'GetCurrentDirectoryA()' internally.
+
+	//--------------------------------------------------------
+	// Filename dictionary operations
+	//--------------------------------------------------------
+
+	virtual FileNameHandle_t	FindOrAddFileName(char const* pFileName) { return nullptr; };
+	virtual bool				String(const FileNameHandle_t& handle, char* buf, ssize_t buflen) { return NULL; };
+
+	//--------------------------------------------------------
+	// Asynchronous file operations
+	//--------------------------------------------------------
+
+//--------------- [ !!! AMOS: !!! ALL ASYNC METHODS ARE UNIMPLEMENTED !!! PURECALL !!! ] ---------------//
+	//------------------------------------
+	// Global operations
+	//------------------------------------
+	virtual void PureCall0() {};
+	virtual void PureCall1() {};
+	virtual void PureCall2() {};
+	virtual void PureCall3() {};
+	virtual void PureCall4() {};
+	virtual void PureCall5() {};
+
+	//--------------------------------------------------------
+	// Debugging operations
+	//--------------------------------------------------------
+
+	// Dump to printf/OutputDebugString the list of files that have not been closed
+	virtual void			PrintOpenedFiles(void) {};
+	virtual void			PrintSearchPaths(void) {};
+
+	// output
+	virtual void			SetWarningFunc(void (*pfnWarning)(const char* fmt, ...)) {};
+	virtual void			SetWarningLevel(FileWarningLevel_t level) {};
+	virtual void			AddLoggingFunc(void (*pfnLogFunc)(const char* fileName, const char* accessType)) {};
+	virtual void			RemoveLoggingFunc(FileSystemLoggingFunc_t logFunc) {};
+
+	virtual __int64 __fastcall sub_14038C240(__int64 a1) { return NULL; };
+	virtual __int64 __fastcall sub_14038C380(__int64 a1) { return NULL; };
+	virtual __int64 __fastcall sub_14038C400(__int64 a1, __int64 a2) { return NULL; };
+
+	// Returns the file system statistics retrieved by the implementation.  Returns NULL if not supported.
+	virtual const FileSystemStatistics* GetFilesystemStatistics() { return nullptr; };
+
+	//--------------------------------------------------------
+	// Start of new functions after Lost Coast release (7/05)
+	//--------------------------------------------------------
+
+	virtual FileHandle_t	OpenEx(const char* pFileName, const char* pOptions, unsigned flags = 0, const char* pathID = 0/*, char** ppszResolvedFilename = NULL*/) { return nullptr; };
+
+	// Extended version of read provides more context to allow for more optimal reading
+	virtual ssize_t			ReadEx(void* pOutput, ssize_t sizeDest, ssize_t size, FileHandle_t file);
+	virtual ssize_t			ReadFileEx(const char* pFileName, const char* pPath, void** ppBuf, bool bNullTerminate = false, bool bOptimalAlloc = false, ssize_t nMaxBytes = 0, ptrdiff_t nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL) { return NULL; };
+
+	virtual FileNameHandle_t	FindFileName(char const* pFileName) { return nullptr; };
+
+#if defined( TRACK_BLOCKING_IO )
+	virtual void			EnableBlockingFileAccessTracking(bool state) {};
+	virtual bool			IsBlockingFileAccessEnabled() { return false; };
+
+	virtual IBlockingFileItemList* RetrieveBlockingFileAccessInfo() { return nullptr; };
+#endif
+
+	virtual void SetupPreloadData() {};
+	virtual void DiscardPreloadData() {};
+
+	// If the "PreloadedData" hasn't been purged, then this'll try and instance the KeyValues using the fast path of compiled keyvalues loaded during startup.
+	// Otherwise, it'll just fall through to the regular KeyValues loading routines
+	virtual KeyValues* LoadKeyValues(KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return nullptr; };
+	virtual bool		LoadKeyValues(KeyValues& head, KeyValuesPreloadType_t type, char const* filename, char const* pPathID = 0) { return false; };
+
+	virtual bool		GetFileTypeForFullPath(char const* pFullPath, wchar_t* buf, size_t bufSizeInBytes) { return false; };
+
+	//--------------------------------------------------------
+	//--------------------------------------------------------
+	virtual bool		ReadToBuffer(FileHandle_t hFile, CUtlBuffer& buf, ssize_t nMaxBytes = 0, FSAllocFunc_t pfnAlloc = NULL);
+
+	//--------------------------------------------------------
+	// Optimal IO operations
+	//--------------------------------------------------------
+	virtual bool GetOptimalIOConstraints(FileHandle_t hFile, uint64_t* pOffsetAlign, uint64_t* pSizeAlign, uint64_t* pBufferAlign);
+	virtual void* AllocOptimalReadBuffer(ptrdiff_t nOffset = 0/*!!! UNUSED !!!*/, ssize_t nSize = 0) { return nullptr; };
+	virtual void FreeOptimalReadBuffer(void*) {};
+
+
+	virtual bool __fastcall sub_140383E00(__int64 a2) { return false; };
+	virtual bool sub_1403836A0() { return false; };
+	virtual __int64 __fastcall sub_140384310(int a1) { return NULL; };
+	virtual __int64 __fastcall CheckVPKMode(int nMode) { return NULL; }; // Checks if the VPK mode equals the mode input.
+
+
+	//--------------------------------------------------------
+	// Cache/VPK operations
+	//--------------------------------------------------------
+	virtual bool ReadFromCache(const char* pPath, FileSystemCache* pCache) { return false; };
+
+	virtual bool __fastcall sub_14037FFA0(__int64 a1, unsigned int a2, __int64 a3) { return false; };
+
+	virtual void SetVPKCacheModeClient() {}; // g_nVPKCacheMode = 1;
+	virtual void SetVPKCacheModeServer() {}; // g_nVPKCacheMode = 2;
+	virtual bool IsVPKCacheEnabled() { return false; };     // g_nVPKCacheMode != 0;
+
+	virtual __int64 __fastcall PrecacheTaskItem(__int64 a1) { return NULL; };
+
+	virtual void ResetItemCacheSize(int edx) {};
+	virtual void __fastcall sub_140380100(__int64 a1) {};
+	virtual void __fastcall sub_140380230(char a2) {};
+	virtual void* __fastcall sub_1403801F0(const void* a1, unsigned int a2) { return nullptr; };
+	virtual void __fastcall sub_140380220(__int64 a1) {};
+	virtual bool ResetItemCache() { return false; };
+	virtual char __fastcall sub_1403836D0(int a1, char* a2, unsigned int a3) { return false; };
+	virtual __int64 __fastcall sub_140383840(unsigned int a1, __int64 a2, char* a3, unsigned int BufferCount) { return NULL; };
+	virtual const char** __fastcall sub_140383760(unsigned int a1) { return nullptr; };
+	virtual __int64 __fastcall sub_140383A20(const char* a1) { return NULL; };
+
+	virtual VPKData_t* MountVPKFile(const char* pVpkPath) { return nullptr; };
+	virtual const char* UnmountVPKFile(const char* pBasename) { return nullptr; };
+
+	virtual void __fastcall sub_140383370() {};
+	virtual void __fastcall sub_140383560() {};
+
+	virtual unsigned __int64 __fastcall PnpCtxRegQueryInfoKey(__int64 a1, char* a2, unsigned int* a3, unsigned __int64 a4, unsigned __int64 a5, void(__fastcall* a6)(unsigned __int64)) { return NULL; };
+	virtual char* sub_1403842B0() { return nullptr; };
+	virtual __int64 __fastcall sub_1403842C0(__int64 a1, unsigned int a2, __int64 a3) { return NULL; };
+
+	virtual char __fastcall LoadMainVPK(const char* pszVPKFile) { return NULL; };
+
+	virtual __int64 sub_140380080() { return NULL; };
+	virtual char __fastcall sub_14038B530(const char* a1, unsigned __int8* a2, char* a3, __int64 Count) { return NULL; };
+	virtual __int64 __fastcall sub_14038C830(unsigned __int16* a1) { return NULL; };
+	virtual __int64 __fastcall sub_140388360(char* a1, __int64 a2) { return NULL; };
+	virtual __int64 __fastcall sub_140384C60(char* a1, unsigned __int64 a2) { return NULL; };
+	virtual void __fastcall sub_140382A80() { };
+	virtual __int64 __fastcall sub_14038CC90(int a1, unsigned int a2, __int64 a3, __int64 a4) { return NULL; };
+	virtual __int64 __fastcall UserMathErrorFunction() { return NULL; };
+
+	virtual ssize_t			Read(void* pOutput, ssize_t size, FileHandle_t file);
+	virtual ssize_t			Write(void const* pInput, ssize_t size, FileHandle_t file);
+
+	// if pathID is NULL, all paths will be searched for the file
+	virtual FileHandle_t	Open(const char* pFileName, const char* pOptions, const char* pPathID = 0, int64_t unknown = 0);
+	virtual void			Close(FileHandle_t file);
+
+	virtual void			Seek(FileHandle_t file, ptrdiff_t pos, FileSystemSeek_t seekType);
+	virtual ptrdiff_t		Tell(FileHandle_t file);
+	virtual ssize_t			FSize(const char* pFileName, const char* pPathID = 0); // Gets optimized away if it isn't named differently or used.
+	virtual ssize_t			Size(FileHandle_t file);
+
+	virtual void			Flush(FileHandle_t file);
+	virtual bool			Precache(const char* pFileName, const char* pPathID = 0);
+
+	virtual bool			FileExists(const char* pFileName, const char* pPathID = 0);
+	virtual bool			IsFileWritable(char const* pFileName, const char* pPathID = 0);
+	virtual bool			SetFileWritable(char const* pFileName, bool writable, const char* pPathID = 0);
+
+	virtual long long		GetFileTime(const char* pFileName, const char* pPathID = 0);
+
+	virtual bool			ReadFile(const char* pFileName, const char* pPath, CUtlBuffer& buf, ssize_t nMaxBytes = 0, ptrdiff_t nStartingByte = 0, FSAllocFunc_t pfnAlloc = NULL);
+	virtual bool			WriteFile(const char* pFileName, const char* pPath, CUtlBuffer& buf);
+	virtual bool			UnzipFile(const char* pFileName, const char* pPath, const char* pDestination) { return false; };
+
+	char* ReadLine(char* maxChars, ssize_t maxOutputLength, FileHandle_t file);
+	CUtlString ReadString(FileHandle_t pFile);
+};
+
+class CFileSystem_Stdio : public CBaseFileSystem
+{
+protected:
+	// implementation of CBaseFileSystem virtual functions
+	virtual FILE* FS_fopen(const char* filename, const char* options, unsigned flags, int64* size) { return nullptr; };
+	virtual void FS_setbufsize(FILE* fp, unsigned nBytes) {};
+	virtual void FS_fclose(FILE* fp) {};
+	virtual void FS_fseek(FILE* fp, int64 pos, int seekType) {};
+	virtual long FS_ftell(FILE* fp) { return NULL; };
+	virtual int FS_feof(FILE* fp) { return NULL; };
+	virtual size_t FS_fread(void* dest, size_t destSize, size_t size, FILE* fp) { return NULL; };
+	virtual size_t FS_fwrite(const void* src, size_t size, FILE* fp) { return NULL; };
+	virtual bool FS_setmode(FILE* fp, FileMode_t mode) { return false; };
+	virtual size_t FS_vfprintf(FILE* fp, const char* fmt, va_list list) { return NULL; };
+	virtual int FS_ferror(FILE* fp) { return NULL; };
+	virtual int FS_fflush(FILE* fp) { return NULL; };
+	virtual char* FS_fgets(char* dest, unsigned int destSize) { return nullptr; };
+	virtual int FS_stat(const char* path, struct _stat* buf, bool* pbLoadedFromSteamCache = NULL) { return NULL; };
+	virtual int FS_chmod(const char* path, int pmode) { return NULL; };
+	virtual HANDLE FS_FindFirstFile(const char* findname, WIN32_FIND_DATA* dat) { return NULL; };
+	virtual bool FS_FindNextFile(HANDLE handle, WIN32_FIND_DATA* dat) { return false; };
+	virtual bool FS_FindClose(HANDLE handle) { return false; };
+	virtual int FS_GetSectorSize(FILE*) { return NULL; };
+};
+
+#endif // FILESYSTEM_H