From 30a51e61026e30b7019315d60a60528e3710c723 Mon Sep 17 00:00:00 2001 From: s1lent Date: Sun, 24 Sep 2017 19:54:49 +0700 Subject: [PATCH] Refactoring cssdk Fix some things --- gradlew | 0 .../extra/amxmodx/scripting/include/reapi.inc | 8 + reapi/include/cssdk/dlls/extdll.h | 2 +- reapi/include/cssdk/dlls/regamedll_common.h | 96 --- reapi/include/cssdk/public/FileSystem.h | 196 +++--- reapi/include/cssdk/public/basetypes.h | 272 +------- reapi/include/cssdk/public/interface.cpp | 329 +++++----- reapi/include/cssdk/public/interface.h | 97 +-- reapi/include/cssdk/public/protected_things.h | 187 ------ reapi/include/cssdk/public/strtools.h | 211 +++++++ reapi/include/cssdk/public/tier0/dbg.cpp | 2 +- reapi/include/cssdk/public/tier0/dbg.h | 5 +- reapi/include/cssdk/public/tier0/platform.h | 597 ++---------------- reapi/include/cssdk/public/utlmemory.h | 211 +++---- reapi/src/natives/natives_common.cpp | 27 +- reapi/src/natives/natives_misc.cpp | 26 +- reapi/src/natives/natives_rechecker.cpp | 4 +- 17 files changed, 724 insertions(+), 1546 deletions(-) mode change 100644 => 100755 gradlew delete mode 100644 reapi/include/cssdk/dlls/regamedll_common.h delete mode 100644 reapi/include/cssdk/public/protected_things.h create mode 100644 reapi/include/cssdk/public/strtools.h diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 diff --git a/reapi/extra/amxmodx/scripting/include/reapi.inc b/reapi/extra/amxmodx/scripting/include/reapi.inc index ee544ba..a163afd 100644 --- a/reapi/extra/amxmodx/scripting/include/reapi.inc +++ b/reapi/extra/amxmodx/scripting/include/reapi.inc @@ -224,6 +224,14 @@ native bool:has_reunion(); */ native bool:has_vtc(); +/* +* Check if Rechecker is available. +* +* @return true/false +* +*/ +native bool:has_rechecker(); + /* * This is the callback from the module that gives major/minor versions for verifying compatibility for ReAPI versions. * If an AMXX plugin gets a failure, then you do need to upgrade to the latest version of the ReAPI module or update the files included for AMXX plugins. diff --git a/reapi/include/cssdk/dlls/extdll.h b/reapi/include/cssdk/dlls/extdll.h index 7e956cc..25fa72e 100644 --- a/reapi/include/cssdk/dlls/extdll.h +++ b/reapi/include/cssdk/dlls/extdll.h @@ -36,7 +36,7 @@ #include "archtypes.h" #include "maintypes.h" -#include "regamedll_common.h" +#include "strtools.h" #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN diff --git a/reapi/include/cssdk/dlls/regamedll_common.h b/reapi/include/cssdk/dlls/regamedll_common.h deleted file mode 100644 index 826b6de..0000000 --- a/reapi/include/cssdk/dlls/regamedll_common.h +++ /dev/null @@ -1,96 +0,0 @@ -/* -* -* 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 2 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, write to the Free Software Foundation, -* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -* -* In addition, as a special exception, the author gives permission to -* link the code of this program with the Half-Life Game Engine ("HL -* Engine") and Modified Game Libraries ("MODs") developed by Valve, -* L.L.C ("Valve"). You must obey the GNU General Public License in all -* respects for all of the code used other than the HL Engine and MODs -* from Valve. If you modify this file, you may extend this exception -* to your version of the file, but you are not obligated to do so. If -* you do not wish to do so, delete this exception statement from your -* version. -* -*/ - -#pragma once - -#ifndef _WIN32 -#define _strlwr(p) for (int i = 0; p[i] != 0; i++) p[i] = tolower(p[i]); -#endif - -#define Q_isspace isspace -#define Q_isalnum isalnum -#define Q_isalpha isalpha - -#define Q_malloc malloc -#define Q_calloc calloc -#define Q_alloca alloca -#define Q_free free - -#define Q_min min -#define Q_max max -#define Q_clamp clamp -#define Q_access _access -#define Q_close _close -#define Q_write _write -#define Q_memset memset -#define Q_memcpy memcpy -#define Q_strlen strlen -#define Q_memcmp memcmp -#define Q_strcpy strcpy -#define Q_strncpy strncpy -#define Q_strrchr strrchr -#define Q_strcat strcat -#define Q_strncat strncat -#define Q_strcmp strcmp -#define Q_strncmp strncmp -#define Q_sscanf sscanf -#define Q_strdup _strdup -#define Q_stricmp _stricmp -#define Q_strnicmp _strnicmp -#define Q_strstr strstr -#define Q_strchr strchr -#define Q_strrchr strrchr -#define Q_strlwr _strlwr -#define Q_sprintf sprintf -#define Q_snprintf _snprintf -#define Q_atoi atoi -#define Q_atof atof -#define Q_toupper toupper -#define Q_memmove memmove -#define Q_vsnprintf _vsnprintf -#define Q_vsnwprintf _vsnwprintf -#define Q_abs abs -#define Q_fabs fabs -#define Q_tan tan -#define Q_atan atan -#define Q_atan2 atan2 -#define Q_acos acos -#define Q_cos cos -#define Q_sin sin -#define Q_pow pow -#define Q_fmod fmod -#define Q_fopen fopen -#define Q_fwrite fwrite -#define Q_fprintf fprintf -#define Q_fclose fclose - -#ifdef REGAMEDLL_FIXES -#define Q_sqrt M_sqrt -#else -#define Q_sqrt sqrt -#endif diff --git a/reapi/include/cssdk/public/FileSystem.h b/reapi/include/cssdk/public/FileSystem.h index e1ce53c..e2b8928 100644 --- a/reapi/include/cssdk/public/FileSystem.h +++ b/reapi/include/cssdk/public/FileSystem.h @@ -1,32 +1,54 @@ -//========= Copyright � 1996-2001, Valve LLC, All rights reserved. ============ -// -// Purpose: -// -// $NoKeywords: $ -//============================================================================= +/* +* +* 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 2 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, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +*/ -#ifndef FILESYSTEM_H -#define FILESYSTEM_H -#ifdef _WIN32 #pragma once -#endif #include "interface.h" #include #include +// There is only one instance of the IFileSystem interface, +// located in the filesystem_stdio library (filesystem_steam is obsolete). +#ifdef _WIN32 + #define STDIO_FILESYSTEM_LIB "filesystem_stdio.dll" + #define STEAM_FILESYSTEM_LIB "filesystem_steam.dll" +#else + #define STDIO_FILESYSTEM_LIB "filesystem_stdio.so" + #define STEAM_FILESYSTEM_LIB "filesystem_steam.so" +#endif // _WIN32 -//----------------------------------------------------------------------------- // Forward declarations -//----------------------------------------------------------------------------- -typedef FILE * FileHandle_t; +typedef FILE *FileHandle_t; typedef int FileFindHandle_t; typedef int WaitForResourcesHandle_t; +typedef void (*WarningFunc_t)(const char *fmt, ...); - -//----------------------------------------------------------------------------- // Enums used by the interface -//----------------------------------------------------------------------------- #ifndef FILESYSTEM_INTERNAL_H typedef enum { @@ -42,148 +64,138 @@ enum typedef enum { - // Don't print anything - FILESYSTEM_WARNING_QUIET = 0, - - // On shutdown, report names of files left unclosed - FILESYSTEM_WARNING_REPORTUNCLOSED, - - // Report number of times a file was opened, closed - FILESYSTEM_WARNING_REPORTUSAGE, - - // Report all open/close events to console ( !slow! ) - FILESYSTEM_WARNING_REPORTALLACCESSES + FILESYSTEM_WARNING_QUIET = 0, // Don't print anything + FILESYSTEM_WARNING_REPORTUNCLOSED, // On shutdown, report names of files left unclosed + FILESYSTEM_WARNING_REPORTUSAGE, // Report number of times a file was opened, closed + FILESYSTEM_WARNING_REPORTALLACCESSES // Report all open/close events to console (!slow!) } FileWarningLevel_t; -#define FILESYSTEM_INVALID_HANDLE ( FileHandle_t )0 -#endif +#define FILESYSTEM_INVALID_HANDLE (FileHandle_t)0 +#endif // FILESYSTEM_INTERNAL_H // turn off any windows defines #undef GetCurrentDirectory -//----------------------------------------------------------------------------- // Purpose: Main file system interface -//----------------------------------------------------------------------------- class IFileSystem : public IBaseInterface { public: // Mount and unmount the filesystem - virtual void Mount( void ) = 0; - virtual void Unmount( void ) = 0; + virtual void Mount() = 0; + virtual void Unmount() = 0; // Remove all search paths (including write path?) - virtual void RemoveAllSearchPaths( void ) = 0; + virtual void RemoveAllSearchPaths() = 0; // Add paths in priority order (mod dir, game dir, ....) // If one or more .pak files are in the specified directory, then they are // added after the file system path - // If the path is the relative path to a .bsp file, then any previous .bsp file + // If the path is the relative path to a .bsp file, then any previous .bsp file // override is cleared and the current .bsp is searched for an embedded PAK file - // and this file becomes the highest priority search path ( i.e., it's looked at first - // even before the mod's file system path ). - virtual void AddSearchPath( const char *pPath, const char *pathID ) = 0; - virtual bool RemoveSearchPath( const char *pPath ) = 0; + // and this file becomes the highest priority search path (i.e., it's looked at first + // even before the mod's file system path). + virtual void AddSearchPath(const char *pPath, const char *pathID) = 0; + virtual bool RemoveSearchPath(const char *pPath) = 0; // Deletes a file - virtual void RemoveFile( const char *pRelativePath, const char *pathID ) = 0; + virtual void RemoveFile(const char *pRelativePath, const char *pathID) = 0; // this isn't implementable on STEAM as is. - virtual void CreateDirHierarchy( const char *path, const char *pathID ) = 0; + virtual void CreateDirHierarchy(const char *path, const char *pathID) = 0; // File I/O and info - virtual bool FileExists( const char *pFileName ) = 0; - virtual bool IsDirectory( const char *pFileName ) = 0; + virtual bool FileExists(const char *pFileName) = 0; + virtual bool IsDirectory(const char *pFileName) = 0; // opens a 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 *pathID = 0L ) = 0; + virtual FileHandle_t Open(const char *pFileName, const char *pOptions, const char *pathID = 0L) = 0; - virtual void Close( FileHandle_t file ) = 0; + virtual void Close(FileHandle_t file) = 0; - virtual void Seek( FileHandle_t file, int pos, FileSystemSeek_t seekType ) = 0; - virtual unsigned int Tell( FileHandle_t file ) = 0; + virtual void Seek(FileHandle_t file, int pos, FileSystemSeek_t seekType) = 0; + virtual unsigned int Tell(FileHandle_t file) = 0; - virtual unsigned int Size( FileHandle_t file ) = 0; - virtual unsigned int Size( const char *pFileName ) = 0; + virtual unsigned int Size(FileHandle_t file) = 0; + virtual unsigned int Size(const char *pFileName) = 0; - virtual long GetFileTime( const char *pFileName ) = 0; - virtual void FileTimeToString( char* pStrip, int maxCharsIncludingTerminator, long fileTime ) = 0; + virtual long GetFileTime(const char *pFileName) = 0; + virtual void FileTimeToString(char *pStrip, int maxCharsIncludingTerminator, long fileTime) = 0; - virtual bool IsOk( FileHandle_t file ) = 0; + virtual bool IsOk(FileHandle_t file) = 0; - virtual void Flush( FileHandle_t file ) = 0; - virtual bool EndOfFile( FileHandle_t file ) = 0; + virtual void Flush(FileHandle_t file) = 0; + virtual bool EndOfFile(FileHandle_t file) = 0; - virtual int Read( void* pOutput, int size, FileHandle_t file ) = 0; - virtual int Write( void const* pInput, int size, FileHandle_t file ) = 0; - virtual char *ReadLine( char *pOutput, int maxChars, FileHandle_t file ) = 0; - virtual int FPrintf( FileHandle_t file, char *pFormat, ... ) = 0; + virtual int Read(void *pOutput, int size, FileHandle_t file) = 0; + virtual int Write(void const *pInput, int size, FileHandle_t file) = 0; + virtual char *ReadLine(char *pOutput, int maxChars, FileHandle_t file) = 0; + virtual int FPrintf(FileHandle_t file, char *pFormat, ...) = 0; // direct filesystem buffer access // returns a handle to a buffer containing the file data - // this is the optimal way to access the complete data for a file, + // this is the optimal way to access the complete data for a file, // since the file preloader has probably already got it in memory - virtual void *GetReadBuffer( FileHandle_t file, int *outBufferSize, bool failIfNotInCache ) = 0; - virtual void ReleaseReadBuffer( FileHandle_t file, void *readBuffer ) = 0; + virtual void *GetReadBuffer(FileHandle_t file, int *outBufferSize, bool failIfNotInCache) = 0; + virtual void ReleaseReadBuffer(FileHandle_t file, void *readBuffer) = 0; // FindFirst/FindNext - virtual const char *FindFirst( const char *pWildCard, FileFindHandle_t *pHandle, const char *pathID = 0L ) = 0; - virtual const char *FindNext( FileFindHandle_t handle ) = 0; - virtual bool FindIsDirectory( FileFindHandle_t handle ) = 0; - virtual void FindClose( FileFindHandle_t handle ) = 0; + virtual const char *FindFirst(const char *pWildCard, FileFindHandle_t *pHandle, const char *pathID = 0L) = 0; + virtual const char *FindNext(FileFindHandle_t handle) = 0; + virtual bool FindIsDirectory(FileFindHandle_t handle) = 0; + virtual void FindClose(FileFindHandle_t handle) = 0; - virtual void GetLocalCopy( const char *pFileName ) = 0; + virtual void GetLocalCopy(const char *pFileName) = 0; - virtual const char *GetLocalPath( const char *pFileName, char *pLocalPath, int localPathBufferSize ) = 0; + virtual const char *GetLocalPath(const char *pFileName, char *pLocalPath, int localPathBufferSize) = 0; // Note: This is sort of a secondary feature; but it's really useful to have it here - virtual char *ParseFile( char* pFileBytes, char* pToken, bool* pWasQuoted ) = 0; + virtual char *ParseFile(char *pFileBytes, char *pToken, bool *pWasQuoted) = 0; - // 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 ) = 0; + // 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) = 0; // Gets the current working directory - virtual bool GetCurrentDirectory( char* pDirectory, int maxlen ) = 0; + virtual bool GetCurrentDirectory(char *pDirectory, int maxlen) = 0; // Dump to printf/OutputDebugString the list of files that have not been closed - virtual void PrintOpenedFiles( void ) = 0; + virtual void PrintOpenedFiles() = 0; - virtual void SetWarningFunc( void (*pfnWarning)( const char *fmt, ... ) ) = 0; - virtual void SetWarningLevel( FileWarningLevel_t level ) = 0; + virtual void SetWarningFunc(WarningFunc_t pfnWarning) = 0; + virtual void SetWarningLevel(FileWarningLevel_t level) = 0; - virtual void LogLevelLoadStarted( const char *name ) = 0; - virtual void LogLevelLoadFinished( const char *name ) = 0; - virtual int HintResourceNeed( const char *hintlist, int forgetEverything ) = 0; - virtual int PauseResourcePreloading( void ) = 0; - virtual int ResumeResourcePreloading( void ) = 0; - virtual int SetVBuf( FileHandle_t stream, char *buffer, int mode, long size ) = 0; - virtual void GetInterfaceVersion( char *p, int maxlen ) = 0; + virtual void LogLevelLoadStarted(const char *name) = 0; + virtual void LogLevelLoadFinished(const char *name) = 0; + virtual int HintResourceNeed(const char *hintlist, int forgetEverything) = 0; + virtual int PauseResourcePreloading() = 0; + virtual int ResumeResourcePreloading() = 0; + virtual int SetVBuf(FileHandle_t stream, char *buffer, int mode, long size) = 0; + virtual void GetInterfaceVersion(char *p, int maxlen) = 0; virtual bool IsFileImmediatelyAvailable(const char *pFileName) = 0; // starts waiting for resources to be available // returns FILESYSTEM_INVALID_HANDLE if there is nothing to wait on - virtual WaitForResourcesHandle_t WaitForResources( const char *resourcelist ) = 0; + virtual WaitForResourcesHandle_t WaitForResources(const char *resourcelist) = 0; + // get progress on waiting for resources; progress is a float [0, 1], complete is true on the waiting being done // returns false if no progress is available // any calls after complete is true or on an invalid handle will return false, 0.0f, true - virtual bool GetWaitForResourcesProgress( WaitForResourcesHandle_t handle, float *progress /* out */ , bool *complete /* out */ ) = 0; + virtual bool GetWaitForResourcesProgress(WaitForResourcesHandle_t handle, float *progress /* out */ , bool *complete /* out */) = 0; + // cancels a progress call - virtual void CancelWaitForResources( WaitForResourcesHandle_t handle ) = 0; + virtual void CancelWaitForResources(WaitForResourcesHandle_t handle) = 0; // returns true if the appID has all its caches fully preloaded - virtual bool IsAppReadyForOfflinePlay( int appID ) = 0; + virtual bool IsAppReadyForOfflinePlay(int appID) = 0; // interface for custom pack files > 4Gb - virtual bool AddPackFile( const char *fullpath, const char *pathID ) = 0; - - // open a file but force the data to come from the steam cache, NOT from disk - virtual FileHandle_t OpenFromCacheForRead( const char *pFileName, const char *pOptions, const char *pathID = 0L ) = 0; + virtual bool AddPackFile(const char *fullpath, const char *pathID) = 0; - virtual void AddSearchPathNoWrite( const char *pPath, const char *pathID ) = 0; + // open a file but force the data to come from the steam cache, NOT from disk + virtual FileHandle_t OpenFromCacheForRead(const char *pFileName, const char *pOptions, const char *pathID = 0L) = 0; + virtual void AddSearchPathNoWrite(const char *pPath, const char *pathID) = 0; }; // Steam3/Src compat #define IBaseFileSystem IFileSystem #define FILESYSTEM_INTERFACE_VERSION "VFileSystem009" - -#endif // FILESYSTEM_H diff --git a/reapi/include/cssdk/public/basetypes.h b/reapi/include/cssdk/public/basetypes.h index a953ffe..5975e0e 100644 --- a/reapi/include/cssdk/public/basetypes.h +++ b/reapi/include/cssdk/public/basetypes.h @@ -1,9 +1,30 @@ -//========= Copyright 1996-2001, Valve LLC, All rights reserved. ============ -// -// Purpose: -// -// $NoKeywords: $ -//============================================================================= +/* +* +* 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 2 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, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +*/ #ifndef BASETYPES_H #define BASETYPES_H @@ -12,9 +33,9 @@ #endif #include "osconfig.h" -#include "protected_things.h" #include "commonmacros.h" +#include "mathlib.h" // For backward compatibilty only... #include "tier0/platform.h" @@ -24,45 +45,16 @@ #define NULL 0 #endif - -#define ExecuteNTimes( nTimes, x ) \ - { \ - static int __executeCount=0;\ - if ( __executeCount < nTimes )\ - { \ - x; \ - ++__executeCount; \ - } \ - } - - -#define ExecuteOnce( x ) ExecuteNTimes( 1, x ) - - // Pad a number so it lies on an N byte boundary. // So PAD_NUMBER(0,4) is 0 and PAD_NUMBER(1,4) is 4 #define PAD_NUMBER(number, boundary) \ - ( ((number) + ((boundary)-1)) / (boundary) ) * (boundary) - -#ifndef MATHLIB_H -// In case this ever changes -#define M_PI 3.14159265358979323846 - -#ifndef min -#define min(a,b) (((a) < (b)) ? (a) : (b)) -#endif - -#ifndef max -#define max(a,b) (((a) > (b)) ? (a) : (b)) -#endif -#endif // MATHLIB_H + (((number) + ((boundary) - 1)) / (boundary)) * (boundary) #ifndef FALSE #define FALSE 0 #define TRUE (!FALSE) #endif - typedef int BOOL; typedef int qboolean; typedef unsigned long ULONG; @@ -72,216 +64,14 @@ typedef unsigned short word; typedef float vec_t; - -// FIXME: this should move -#ifndef __cplusplus -#define true TRUE -#define false FALSE -#endif - -//----------------------------------------------------------------------------- -// look for NANs, infinities, and underflows. -// This assumes the ANSI/IEEE 754-1985 standard -//----------------------------------------------------------------------------- - -#ifdef __cplusplus - -inline unsigned long& FloatBits(vec_t& f) -{ - return *reinterpret_cast(&f); -} - -inline unsigned long const& FloatBits(vec_t const& f) -{ - return *reinterpret_cast(&f); -} - -inline vec_t BitsToFloat(unsigned long i) -{ - return *reinterpret_cast(&i); -} - -inline bool IsFinite(vec_t f) -{ - return ((FloatBits(f) & 0x7F800000) != 0x7F800000); -} - -inline unsigned long FloatAbsBits(vec_t f) -{ - return FloatBits(f) & 0x7FFFFFFF; -} - -inline float FloatMakeNegative(vec_t f) -{ - return BitsToFloat(FloatBits(f) | 0x80000000); -} - -#if defined( WIN32 ) - -//#include -// Just use prototype from math.h -#ifdef __cplusplus -extern "C" -{ -#endif - double __cdecl fabs(double); -#ifdef __cplusplus -} -#endif - -// In win32 try to use the intrinsic fabs so the optimizer can do it's thing inline in the code -#pragma intrinsic( fabs ) -// Also, alias float make positive to use fabs, too -// NOTE: Is there a perf issue with double<->float conversion? -inline float FloatMakePositive(vec_t f) -{ - return fabs(f); -} -#else -inline float FloatMakePositive(vec_t f) -{ - return BitsToFloat(FloatBits(f) & 0x7FFFFFFF); -} -#endif - -inline float FloatNegate(vec_t f) -{ - return BitsToFloat(FloatBits(f) ^ 0x80000000); -} - - -#define FLOAT32_NAN_BITS (unsigned long)0x7FC00000 // not a number! -#define FLOAT32_NAN BitsToFloat( FLOAT32_NAN_BITS ) - -#define VEC_T_NAN FLOAT32_NAN - -#endif - -// FIXME: why are these here? Hardly anyone actually needs them. -struct valve_color24 -{ - byte r, g, b; -}; - -typedef struct valve_color32_s -{ - bool operator!=(const struct valve_color32_s &other) const; - - byte r, g, b, a; -} valve_color32; - -inline bool valve_color32::operator!=(const valve_color32 &other) const -{ - return r != other.r || g != other.g || b != other.b || a != other.a; -} - -struct valve_colorRGBExp32 -{ - byte r, g, b; - signed char exponent; -}; - -struct valve_colorVec -{ - unsigned r, g, b, a; -}; - - #ifndef UNUSED #define UNUSED(x) (x = x) // for pesky compiler / lint warnings #endif -#ifdef __cplusplus - struct vrect_t { - int x, y, width, height; - vrect_t *pnext; + int x, y, width, height; + vrect_t *pnext; }; -#endif - - -//----------------------------------------------------------------------------- -// MaterialRect_t struct - used for DrawDebugText -//----------------------------------------------------------------------------- -struct Rect_t -{ - int x, y; - int width, height; -}; - - -//----------------------------------------------------------------------------- -// Declares a type-safe handle type; you can't assign one handle to the next -//----------------------------------------------------------------------------- - -// 32-bit pointer handles. - -// Typesafe 8-bit and 16-bit handles. -template< class HandleType > -class CBaseIntHandle -{ -public: - - inline bool operator==(const CBaseIntHandle &other) { return m_Handle == other.m_Handle; } - inline bool operator!=(const CBaseIntHandle &other) { return m_Handle != other.m_Handle; } - - // Only the code that doles out these handles should use these functions. - // Everyone else should treat them as a transparent type. - inline HandleType GetHandleValue() { return m_Handle; } - inline void SetHandleValue(HandleType val) { m_Handle = val; } - - typedef HandleType HANDLE_TYPE; - -protected: - - HandleType m_Handle; -}; - -template< class DummyType > -class CIntHandle16 : public CBaseIntHandle < unsigned short > -{ -public: - inline CIntHandle16() {} - - static inline CIntHandle16 MakeHandle(HANDLE_TYPE val) - { - return CIntHandle16(val); - } - -protected: - inline CIntHandle16(HANDLE_TYPE val) - { - m_Handle = val; - } -}; - - -template< class DummyType > -class CIntHandle32 : public CBaseIntHandle < unsigned long > -{ -public: - inline CIntHandle32() {} - - static inline CIntHandle32 MakeHandle(HANDLE_TYPE val) - { - return CIntHandle32(val); - } - -protected: - inline CIntHandle32(HANDLE_TYPE val) - { - m_Handle = val; - } -}; - - -// NOTE: This macro is the same as windows uses; so don't change the guts of it -#define DECLARE_HANDLE_16BIT(name) typedef CIntHandle16< struct name##__handle * > name; -#define DECLARE_HANDLE_32BIT(name) typedef CIntHandle32< struct name##__handle * > name; - -#define DECLARE_POINTER_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name -#define FORWARD_DECLARE_HANDLE(name) typedef struct name##__ *name - #endif // BASETYPES_H diff --git a/reapi/include/cssdk/public/interface.cpp b/reapi/include/cssdk/public/interface.cpp index 9a12eef..e6de1be 100644 --- a/reapi/include/cssdk/public/interface.cpp +++ b/reapi/include/cssdk/public/interface.cpp @@ -1,26 +1,98 @@ -#include "precompiled.h" -#include "interface.h" +/* +* +* 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 2 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, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +*/ -#if !defined ( _WIN32 ) +#include "precompiled.h" + +#ifdef _WIN32 + #define WIN32_LEAN_AND_MEAN + #include "windows.h" +#endif // _WIN32 + +// InterfaceReg +InterfaceReg *InterfaceReg::s_pInterfaceRegs = nullptr; + +InterfaceReg::InterfaceReg(InstantiateInterfaceFn fn, const char *pName) : m_pName(pName) +{ + m_CreateFn = fn; + m_pNext = s_pInterfaceRegs; + s_pInterfaceRegs = this; +} + +// This is the primary exported function by a dll, referenced by name via dynamic binding +// that exposes an opqaue function pointer to the interface. +// +// We have the Internal variant so Sys_GetFactoryThis() returns the correct internal +// symbol under GCC/Linux/Mac as CreateInterface is DLL_EXPORT so its global so the loaders +// on those OS's pick exactly 1 of the CreateInterface symbols to be the one that is process wide and +// all Sys_GetFactoryThis() calls find that one, which doesn't work. Using the internal walkthrough here +// makes sure Sys_GetFactoryThis() has the dll specific symbol and GetProcAddress() returns the module specific +// function for CreateInterface again getting the dll specific symbol we need. +EXPORT_FUNCTION IBaseInterface *CreateInterface(const char *pName, int *pReturnCode) +{ + InterfaceReg *pCur; + for (pCur = InterfaceReg::s_pInterfaceRegs; pCur; pCur = pCur->m_pNext) + { + if (strcmp(pCur->m_pName, pName) == 0) + { + if (pReturnCode) + { + *pReturnCode = IFACE_OK; + } + + return pCur->m_CreateFn(); + } + } + + if (pReturnCode) + { + *pReturnCode = IFACE_FAILED; + } + + return nullptr; +} + +#ifndef _WIN32 // Linux doesn't have this function so this emulates its functionality -// -// void *GetModuleHandle(const char *name) { void *handle; - - if (name == NULL) + if (name == nullptr) { // hmm, how can this be handled under linux.... // is it even needed? - return NULL; + return nullptr; } - if ((handle=dlopen(name, RTLD_NOW)) == NULL) + if ((handle = dlopen(name, RTLD_NOW)) == nullptr) { //printf("Error:%s\n",dlerror()); // couldn't open this file - return NULL; + return nullptr; } // read "man dlopen" for details @@ -29,151 +101,67 @@ void *GetModuleHandle(const char *name) dlclose(handle); return handle; } -#endif +#endif // _WIN32 -// ------------------------------------------------------------------------------------ // -// InterfaceReg. -// ------------------------------------------------------------------------------------ // -InterfaceReg *InterfaceReg::s_pInterfaceRegs = NULL; - - -InterfaceReg::InterfaceReg( InstantiateInterfaceFn fn, const char *pName ) : m_pName(pName) -{ - m_CreateFn = fn; - m_pNext = s_pInterfaceRegs; - s_pInterfaceRegs = this; -} - - - -// ------------------------------------------------------------------------------------ // -// CreateInterface. -// ------------------------------------------------------------------------------------ // -EXPORT_FUNCTION IBaseInterface *CreateInterface( const char *pName, int *pReturnCode ) -{ - InterfaceReg *pCur; - - for(pCur=InterfaceReg::s_pInterfaceRegs; pCur; pCur=pCur->m_pNext) - { - if(strcmp(pCur->m_pName, pName) == 0) - { - if ( pReturnCode ) - { - *pReturnCode = IFACE_OK; - } - return pCur->m_CreateFn(); - } - } - - if ( pReturnCode ) - { - *pReturnCode = IFACE_FAILED; - } - return NULL; -} - -#ifdef LINUX -static IBaseInterface *CreateInterfaceLocal( const char *pName, int *pReturnCode ) -{ - InterfaceReg *pCur; - - for(pCur=InterfaceReg::s_pInterfaceRegs; pCur; pCur=pCur->m_pNext) - { - if(strcmp(pCur->m_pName, pName) == 0) - { - if ( pReturnCode ) - { - *pReturnCode = IFACE_OK; - } - return pCur->m_CreateFn(); - } - } - - if ( pReturnCode ) - { - *pReturnCode = IFACE_FAILED; - } - return NULL; -} -#endif - -#ifdef _WIN32 -#define WIN32_LEAN_AND_MEAN -#include "windows.h" -#endif - -//----------------------------------------------------------------------------- // Purpose: returns a pointer to a function, given a module // Input : pModuleName - module name // *pName - proc name -//----------------------------------------------------------------------------- -//static hlds_run wants to use this function -void *Sys_GetProcAddress( const char *pModuleName, const char *pName ) +//static hlds_run wants to use this function +void *Sys_GetProcAddress(const char *pModuleName, const char *pName) { - return GetProcAddress( GetModuleHandle(pModuleName), pName ); + return GetProcAddress(GetModuleHandle(pModuleName), pName); } -//----------------------------------------------------------------------------- // Purpose: returns a pointer to a function, given a module // Input : pModuleName - module name // *pName - proc name -//----------------------------------------------------------------------------- -// hlds_run wants to use this function -void *Sys_GetProcAddress( void *pModuleHandle, const char *pName ) +// hlds_run wants to use this function +void *Sys_GetProcAddress(void *pModuleHandle, const char *pName) { -#if defined ( _WIN32 ) - return GetProcAddress( (HINSTANCE)pModuleHandle, pName ); -#else - return GetProcAddress( pModuleHandle, pName ); -#endif + return GetProcAddress((HMODULE)pModuleHandle, pName); } -//----------------------------------------------------------------------------- // Purpose: Loads a DLL/component from disk and returns a handle to it // Input : *pModuleName - filename of the component // Output : opaque handle to the module (hides system dependency) -//----------------------------------------------------------------------------- -CSysModule *Sys_LoadModule( const char *pModuleName ) +CSysModule *Sys_LoadModule(const char *pModuleName) { -#if defined ( _WIN32 ) - HMODULE hDLL = LoadLibrary( pModuleName ); +#ifdef _WIN32 + HMODULE hDLL = LoadLibrary(pModuleName); #else - HMODULE hDLL = NULL; + HMODULE hDLL = nullptr; char szAbsoluteModuleName[1024]; - szAbsoluteModuleName[0] = 0; - if ( pModuleName[0] != '/' ) + if (pModuleName[0] != '/') { char szCwd[1024]; - char szAbsoluteModuleName[1024]; + getcwd(szCwd, sizeof(szCwd)); + if (szCwd[strlen(szCwd) - 1] == '/') + szCwd[strlen(szCwd) - 1] = '\0'; - getcwd( szCwd, sizeof( szCwd ) ); - if ( szCwd[ strlen( szCwd ) - 1 ] == '/' ) - szCwd[ strlen( szCwd ) - 1 ] = 0; - - _snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/%s", szCwd, pModuleName ); - - hDLL = dlopen( szAbsoluteModuleName, RTLD_NOW ); + _snprintf(szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/%s", szCwd, pModuleName); + hDLL = dlopen(szAbsoluteModuleName, RTLD_NOW); } else { - _snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s", pModuleName ); - hDLL = dlopen( pModuleName, RTLD_NOW ); + _snprintf(szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s", pModuleName); + hDLL = dlopen(pModuleName, RTLD_NOW); } -#endif +#endif // _WIN32 - if( !hDLL ) + if (!hDLL) { char str[512]; -#if defined ( _WIN32 ) - _snprintf( str, sizeof(str), "%s.dll", pModuleName ); - hDLL = LoadLibrary( str ); + +#if defined(_WIN32) + _snprintf(str, sizeof(str), "%s.dll", pModuleName); + hDLL = LoadLibrary(str); #elif defined(OSX) - printf("Error:%s\n",dlerror()); - _snprintf( str, sizeof(str), "%s.dylib", szAbsoluteModuleName ); - hDLL = dlopen(str, RTLD_NOW); + printf("Error: %s\n", dlerror()); + _snprintf(str, sizeof(str), "%s.dylib", szAbsoluteModuleName); + hDLL = dlopen(str, RTLD_NOW); #else - printf("Error:%s\n",dlerror()); - _snprintf( str, sizeof(str), "%s.so", szAbsoluteModuleName ); + printf("Error: %s\n", dlerror()); + _snprintf(str, sizeof(str), "%s.so", szAbsoluteModuleName); hDLL = dlopen(str, RTLD_NOW); #endif } @@ -181,83 +169,68 @@ CSysModule *Sys_LoadModule( const char *pModuleName ) return reinterpret_cast(hDLL); } -//----------------------------------------------------------------------------- // Purpose: Unloads a DLL/component from // Input : *pModuleName - filename of the component // Output : opaque handle to the module (hides system dependency) -//----------------------------------------------------------------------------- -void Sys_UnloadModule( CSysModule *pModule ) +void Sys_UnloadModule(CSysModule *pModule) { - if ( !pModule ) + if (!pModule) return; HMODULE hDLL = reinterpret_cast(pModule); -#if defined ( _WIN32 ) - FreeLibrary( hDLL ); -#else - dlclose((void *)hDLL); -#endif +#ifdef _WIN32 + FreeLibrary(hDLL); +#else + dlclose(hDLL); +#endif // _WIN32 } -//----------------------------------------------------------------------------- // Purpose: returns a pointer to a function, given a module -// Input : module - windows HMODULE from Sys_LoadModule() +// Input : module - windows HMODULE from Sys_LoadModule() // *pName - proc name // Output : factory for this module -//----------------------------------------------------------------------------- -CreateInterfaceFn Sys_GetFactory( CSysModule *pModule ) +CreateInterfaceFn Sys_GetFactory(CSysModule *pModule) { - if ( !pModule ) - return NULL; + if (!pModule) + return nullptr; - HMODULE hDLL = reinterpret_cast(pModule); -#if defined ( _WIN32 ) - return reinterpret_cast(GetProcAddress( hDLL, CREATEINTERFACE_PROCNAME )); -#else -// Linux gives this error: -//../public/interface.cpp: In function `IBaseInterface *(*Sys_GetFactory -//(CSysModule *)) (const char *, int *)': -//../public/interface.cpp:154: ISO C++ forbids casting between -//pointer-to-function and pointer-to-object -// -// so lets get around it :) - return (CreateInterfaceFn)(GetProcAddress( hDLL, CREATEINTERFACE_PROCNAME )); -#endif + return reinterpret_cast(Sys_GetProcAddress(pModule, CREATEINTERFACE_PROCNAME)); } - - -//----------------------------------------------------------------------------- // Purpose: returns the instance of this module -// Output : interface_instance_t -//----------------------------------------------------------------------------- -CreateInterfaceFn Sys_GetFactoryThis( void ) +// Output : CreateInterfaceFn +CreateInterfaceFn Sys_GetFactoryThis() { -#ifdef LINUX - return CreateInterfaceLocal; -#else return CreateInterface; -#endif } -//----------------------------------------------------------------------------- // Purpose: returns the instance of the named module // Input : *pModuleName - name of the module -// Output : interface_instance_t - instance of that module -//----------------------------------------------------------------------------- -CreateInterfaceFn Sys_GetFactory( const char *pModuleName ) +// Output : CreateInterfaceFn - instance of that module +CreateInterfaceFn Sys_GetFactory(const char *pModuleName) { -#if defined ( _WIN32 ) - return static_cast( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) ); -#else -// Linux gives this error: -//../public/interface.cpp: In function `IBaseInterface *(*Sys_GetFactory -//(const char *)) (const char *, int *)': -//../public/interface.cpp:186: invalid static_cast from type `void *' to -//type `IBaseInterface *(*) (const char *, int *)' -// -// so lets use the old style cast. - return (CreateInterfaceFn)( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) ); -#endif + return reinterpret_cast(Sys_GetProcAddress(pModuleName, CREATEINTERFACE_PROCNAME)); +} + +// Purpose: finds a particular interface in the factory set +void *InitializeInterface(char const *interfaceName, CreateInterfaceFn *factoryList, int numFactories) +{ + void *retval; + + for (int i = 0; i < numFactories; i++) + { + CreateInterfaceFn factory = factoryList[ i ]; + if (!factory) + continue; + + retval = factory(interfaceName, nullptr); + if (retval) + return retval; + } + + // No provider for requested interface!!! + // assert(!"No provider for requested interface!!!"); + + return nullptr; } diff --git a/reapi/include/cssdk/public/interface.h b/reapi/include/cssdk/public/interface.h index 3349146..0aeaca4 100644 --- a/reapi/include/cssdk/public/interface.h +++ b/reapi/include/cssdk/public/interface.h @@ -1,4 +1,3 @@ - // This header defines the interface convention used in the valve engine. // To make an interface and expose it: // 1. Derive from IBaseInterface. @@ -8,22 +7,17 @@ // Versioning // There are two versioning cases that are handled by this: -// 1. You add functions to the end of an interface, so it is binary compatible with the previous interface. In this case, +// 1. You add functions to the end of an interface, so it is binary compatible with the previous interface. In this case, // you need two EXPOSE_INTERFACEs: one to expose your class as the old interface and one to expose it as the new interface. -// 2. You update an interface so it's not compatible anymore (but you still want to be able to expose the old interface -// for legacy code). In this case, you need to make a new version name for your new interface, and make a wrapper interface and +// 2. You update an interface so it's not compatible anymore (but you still want to be able to expose the old interface +// for legacy code). In this case, you need to make a new version name for your new interface, and make a wrapper interface and // expose it for the old interface. -//#if _MSC_VER >= 1300 // VC7 -//#include "tier1/interface.h" -//#else +#pragma once -#ifndef INTERFACE_H -#define INTERFACE_H +#ifndef _WIN32 -#if !defined ( _WIN32 ) - -#include // dlopen,dlclose, et al +#include // dlopen, dlclose, et al #include #define HMODULE void * @@ -31,7 +25,7 @@ #define _snprintf snprintf -#endif +#endif // _WIN32 void *Sys_GetProcAddress(const char *pModuleName, const char *pName); void *Sys_GetProcAddress(void *pModuleHandle, const char *pName); @@ -40,17 +34,13 @@ void *Sys_GetProcAddress(void *pModuleHandle, const char *pName); class IBaseInterface { public: - - virtual ~IBaseInterface() {} + virtual ~IBaseInterface() {} }; +#define CREATEINTERFACE_PROCNAME "CreateInterface" -#define CREATEINTERFACE_PROCNAME "CreateInterface" -typedef IBaseInterface* (*CreateInterfaceFn)(const char *pName, int *pReturnCode); - - -typedef IBaseInterface* (*InstantiateInterfaceFn)(); - +typedef IBaseInterface *(*CreateInterfaceFn)(const char *pName, int *pReturnCode); +typedef IBaseInterface *(*InstantiateInterfaceFn)(); // Used internally to register classes. class InterfaceReg @@ -60,19 +50,18 @@ public: public: - InstantiateInterfaceFn m_CreateFn; - const char *m_pName; + InstantiateInterfaceFn m_CreateFn; + const char *m_pName; - InterfaceReg *m_pNext; // For the global list. - static InterfaceReg *s_pInterfaceRegs; + InterfaceReg *m_pNext; // For the global list. + static InterfaceReg *s_pInterfaceRegs; }; - // Use this to expose an interface that can have multiple instances. // e.g.: -// EXPOSE_INTERFACE( CInterfaceImp, IInterface, "MyInterface001" ) +// EXPOSE_INTERFACE(CInterfaceImp, IInterface, "MyInterface001") // This will expose a class called CInterfaceImp that implements IInterface (a pure class) -// clients can receive a pointer to this class by calling CreateInterface( "MyInterface001" ) +// clients can receive a pointer to this class by calling CreateInterface("MyInterface001") // // In practice, the shared header file defines the interface (IInterface) and version name ("MyInterface001") // so that each component can use these names/vtables to communicate @@ -80,71 +69,55 @@ public: // A single class can support multiple interfaces through multiple inheritance // // Use this if you want to write the factory function. -#define EXPOSE_INTERFACE_FN(functionName, interfaceName, versionName) \ +#define EXPOSE_INTERFACE_FN(functionName, interfaceName, versionName)\ static InterfaceReg __g_Create##className##_reg(functionName, versionName); -#define EXPOSE_INTERFACE(className, interfaceName, versionName) \ - static IBaseInterface* __Create##className##_interface() {return (interfaceName *)new className;}\ - static InterfaceReg __g_Create##className##_reg(__Create##className##_interface, versionName ); +#define EXPOSE_INTERFACE(className, interfaceName, versionName)\ + static IBaseInterface *__Create##className##_interface() {return (interfaceName *)new className;}\ + static InterfaceReg __g_Create##className##_reg(__Create##className##_interface, versionName); // Use this to expose a singleton interface with a global variable you've created. -#define EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, globalVarName) \ - static IBaseInterface* __Create##className##interfaceName##_interface() {return (IBaseInterface *)&globalVarName;}\ +#define EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, globalVarName)\ + static IBaseInterface *__Create##className##interfaceName##_interface() {return (IBaseInterface *)&globalVarName;}\ static InterfaceReg __g_Create##className##interfaceName##_reg(__Create##className##interfaceName##_interface, versionName); // Use this to expose a singleton interface. This creates the global variable for you automatically. -#define EXPOSE_SINGLE_INTERFACE(className, interfaceName, versionName) \ +#define EXPOSE_SINGLE_INTERFACE(className, interfaceName, versionName)\ static className __g_##className##_singleton;\ EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, __g_##className##_singleton) - #ifdef _WIN32 - #define EXPORT_FUNCTION __declspec(dllexport) + #define EXPORT_FUNCTION __declspec(dllexport) EXT_FUNC #else - #define EXPORT_FUNCTION __attribute__ ((visibility("default"))) -#endif - + #define EXPORT_FUNCTION __attribute__((visibility("default"))) EXT_FUNC +#endif // _WIN32 // This function is automatically exported and allows you to access any interfaces exposed with the above macros. // if pReturnCode is set, it will return one of the following values // extend this for other error conditions/code -enum +enum { IFACE_OK = 0, IFACE_FAILED }; - extern "C" { - EXPORT_FUNCTION IBaseInterface* CreateInterface(const char *pName, int *pReturnCode); + EXPORT_FUNCTION IBaseInterface *CreateInterface(const char *pName, int *pReturnCode); }; +extern CreateInterfaceFn Sys_GetFactoryThis(); -extern CreateInterfaceFn Sys_GetFactoryThis( void ); - - -//----------------------------------------------------------------------------- // UNDONE: This is obsolete, use the module load/unload/get instead!!! -//----------------------------------------------------------------------------- -extern CreateInterfaceFn Sys_GetFactory( const char *pModuleName ); - +extern CreateInterfaceFn Sys_GetFactory(const char *pModuleName); // load/unload components class CSysModule; -//----------------------------------------------------------------------------- // Load & Unload should be called in exactly one place for each module // The factory for that module should be passed on to dependent components for // proper versioning. -//----------------------------------------------------------------------------- -extern CSysModule *Sys_LoadModule( const char *pModuleName ); -extern void Sys_UnloadModule( CSysModule *pModule ); - -extern CreateInterfaceFn Sys_GetFactory( CSysModule *pModule ); - - -#endif -//#endif // MSVC 6.0 - - +extern CSysModule *Sys_LoadModule(const char *pModuleName); +extern void Sys_UnloadModule(CSysModule *pModule); +extern CreateInterfaceFn Sys_GetFactory(CSysModule *pModule); +extern void *InitializeInterface(char const *interfaceName, CreateInterfaceFn *factoryList, int numFactories); diff --git a/reapi/include/cssdk/public/protected_things.h b/reapi/include/cssdk/public/protected_things.h deleted file mode 100644 index 201438e..0000000 --- a/reapi/include/cssdk/public/protected_things.h +++ /dev/null @@ -1,187 +0,0 @@ -//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============ -// -// Purpose: -// -// $NoKeywords: $ -//============================================================================= - -#ifndef PROTECTED_THINGS_H -#define PROTECTED_THINGS_H -#ifdef _WIN32 -#pragma once -#endif - - -// This header tries to prevent people from using potentially dangerous functions -// (like the notorious non-null-terminating strncpy) and functions that will break -// VCR mode (like time, input, registry, etc). -// -// This header should be included by ALL of our source code. - -// Eventually, ALL of these should be protected, but one man can only accomplish so much in -// one day AND work on features too! -#if defined( PROTECT_STRING_FUNCTIONS ) -#if defined( strncpy ) -#undef strncpy -#endif -#define strncpy strncpy__HEY_YOU__USE_VSTDLIB - - -#if defined( _snprintf ) -#undef _snprintf -#endif -#define _snprintf snprintf__HEY_YOU__USE_VSTDLIB - - -#if defined( sprintf ) -#undef sprintf -#endif -#define sprintf sprintf__HEY_YOU__USE_VSTDLIB - - -#if defined( _vsnprintf ) -#undef _vsnprintf -#endif -#define _vsnprintf vsnprintf__HEY_YOU__USE_VSTDLIB - - -#if defined( strcat ) -#undef strcat -#endif -#define strcat strcat__HEY_YOU__USE_VSTDLIB -#endif - - -#if defined( PROTECT_FILEIO_FUNCTIONS ) -#if defined( fopen ) -#undef fopen -#endif -#define fopen fopen_USE_FILESYSTEM_INSTEAD -#endif - - -#if defined( PROTECTED_THINGS_ENABLE ) - -#if defined( GetTickCount ) -#undef GetTickCount -#endif -#define GetTickCount GetTickCount__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( timeGetTime ) -#undef timeGetTime -#endif -#define timeGetTime timeGetTime__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( clock ) -#undef clock -#endif -#define time time__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( recvfrom ) -#undef recvfrom -#endif -#define recvfrom recvfrom__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( GetCursorPos ) -#undef GetCursorPos -#endif -#define GetCursorPos GetCursorPos__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( ScreenToClient ) -#undef ScreenToClient -#endif -#define ScreenToClient ScreenToClient__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( GetCommandLine ) -#undef GetCommandLine -#endif -#define GetCommandLine GetCommandLine__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegOpenKeyEx ) -#undef RegOpenKeyEx -#endif -#define RegOpenKeyEx RegOpenKeyEx__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegOpenKey ) -#undef RegOpenKey -#endif -#define RegOpenKey RegOpenKey__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegSetValueEx ) -#undef RegSetValueEx -#endif -#define RegSetValueEx RegSetValueEx__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegSetValue ) -#undef RegSetValue -#endif -#define RegSetValue RegSetValue__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegQueryValueEx ) -#undef RegQueryValueEx -#endif -#define RegQueryValueEx RegQueryValueEx__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegQueryValue ) -#undef RegQueryValue -#endif -#define RegQueryValue RegQueryValue__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegCreateKeyEx ) -#undef RegCreateKeyEx -#endif -#define RegCreateKeyEx RegCreateKeyEx__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegCreateKey ) -#undef RegCreateKey -#endif -#define RegCreateKey RegCreateKey__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( RegCloseKey ) -#undef RegCloseKey -#endif -#define RegCloseKey RegCloseKey__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( GetNumberOfConsoleInputEvents ) -#undef GetNumberOfConsoleInputEvents -#endif -#define GetNumberOfConsoleInputEvents GetNumberOfConsoleInputEvents__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( ReadConsoleInput ) -#undef ReadConsoleInput -#endif -#define ReadConsoleInput ReadConsoleInput__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( GetAsyncKeyState ) -#undef GetAsyncKeyState -#endif -#define GetAsyncKeyState GetAsyncKeyState__HEY_YOU__USE_PLATFORM_LIB - - -#if defined( GetKeyState ) -#undef GetKeyState -#endif -#define GetKeyState GetKeyState__HEY_YOU__USE_PLATFORM_LIB - -#endif - - -#endif // PROTECTED_THINGS_H diff --git a/reapi/include/cssdk/public/strtools.h b/reapi/include/cssdk/public/strtools.h new file mode 100644 index 0000000..8b414bf --- /dev/null +++ b/reapi/include/cssdk/public/strtools.h @@ -0,0 +1,211 @@ +/* +* +* 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 2 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, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +*/ + +#pragma once + +#ifdef _WIN32 +const char CORRECT_PATH_SEPARATOR = '\\'; +const char INCORRECT_PATH_SEPARATOR = '/'; +#else +const char CORRECT_PATH_SEPARATOR = '/'; +const char INCORRECT_PATH_SEPARATOR = '\\'; +#endif + +#if !defined(_WIN32) +inline char *_strupr(char *start) +{ + char *str = start; + while (str && *str) + { + *str = (char)toupper(*str); + str++; + } + + return start; +} + +inline char *_strlwr(char *start) +{ + char *str = start; + while (str && *str) + { + *str = (char)tolower(*str); + str++; + } + + return start; +} +#endif + +#if defined(ASMLIB_H) && defined(HAVE_OPT_STRTOOLS) + #define Q_memset A_memset + #define Q_memcpy A_memcpy + #define Q_memcmp A_memcmp + #define Q_memmove A_memmove + #define Q_strlen A_strlen + #define Q_strcpy A_strcpy + #define Q_strncpy strncpy + #define Q_strcat A_strcat + #define Q_strncat strncat + #define Q_strcmp A_strcmp + #define Q_strncmp strncmp + #define Q_strdup _strdup + #define Q_stricmp A_stricmp + #define Q_strnicmp _strnicmp + #define Q_strstr A_strstr + #define Q_strchr strchr + #define Q_strrchr strrchr + #define Q_strlwr A_strtolower + #define Q_strupr A_strtoupper + #define Q_sprintf sprintf + #define Q_snprintf _snprintf + #define Q_vsnprintf _vsnprintf + #define Q_vsnwprintf _vsnwprintf + #define Q_atoi atoi + #define Q_atof atof + #define Q_sqrt M_sqrt + #define Q_min M_min + #define Q_max M_max + #define Q_clamp M_clamp + #define Q_abs abs + #define Q_fabs fabs + #define Q_tan tan + #define Q_atan atan + #define Q_atan2 atan2 + #define Q_acos acos + #define Q_cos cos + #define Q_sin sin + #define Q_pow pow + #define Q_fmod fmod +#else + #define Q_memset memset + #define Q_memcpy memcpy + #define Q_memcmp memcmp + #define Q_memmove memmove + #define Q_strlen strlen + #define Q_strcpy strcpy + #define Q_strncpy strncpy + #define Q_strcat strcat + #define Q_strncat strncat + #define Q_strcmp strcmp + #define Q_strncmp strncmp + #define Q_strdup _strdup + #define Q_stricmp _stricmp + #define Q_strnicmp _strnicmp + #define Q_strstr strstr + #define Q_strchr strchr + #define Q_strrchr strrchr + #define Q_strlwr _strlwr + #define Q_strupr _strupr + #define Q_sprintf sprintf + #define Q_snprintf _snprintf + #define Q_vsnprintf _vsnprintf + #define Q_vsnwprintf _vsnwprintf + #define Q_atoi atoi + #define Q_atof atof + #define Q_sqrt sqrt + #define Q_min min + #define Q_max max + #define Q_clamp clamp + #define Q_abs abs + #define Q_fabs fabs + #define Q_tan tan + #define Q_atan atan + #define Q_atan2 atan2 + #define Q_acos acos + #define Q_cos cos + #define Q_sin sin + #define Q_pow pow + #define Q_fmod fmod +#endif // #if defined(ASMLIB_H) && defined(HAVE_OPT_STRTOOLS) + +// a safe variant of strcpy that truncates the result to fit in the destination buffer +template +char *Q_strlcpy(char (&dest)[size], const char *src) { + Q_strncpy(dest, src, size - 1); + dest[size - 1] = '\0'; + return dest; +} + +inline char *Q_strnlcpy(char *dest, const char *src, size_t n) { + Q_strncpy(dest, src, n - 1); + dest[n - 1] = '\0'; + return dest; +} + +// safely concatenate two strings. +// a variant of strcat that truncates the result to fit in the destination buffer +template +size_t Q_strlcat(char (&dest)[size], const char *src) +{ + size_t srclen; // Length of source string + size_t dstlen; // Length of destination string + + // Figure out how much room is left + dstlen = Q_strlen(dest); + size_t length = size - dstlen + 1; + + if (!length) { + // No room, return immediately + return dstlen; + } + + // Figure out how much room is needed + srclen = Q_strlen(src); + + // Copy the appropriate amount + if (srclen > length) { + srclen = length; + } + + Q_memcpy(dest + dstlen, src, srclen); + dest[dstlen + srclen] = '\0'; + + return dstlen + srclen; +} + +// Force slashes of either type to be = separator character +inline void Q_FixSlashes(char *pname, char separator = CORRECT_PATH_SEPARATOR) +{ + while (*pname) + { + if (*pname == INCORRECT_PATH_SEPARATOR || *pname == CORRECT_PATH_SEPARATOR) + { + *pname = separator; + } + + pname++; + } +} + +// strcpy that works correctly with overlapping src and dst buffers +inline char *Q_strcpy_s(char *dst, char *src) { + int len = Q_strlen(src); + Q_memmove(dst, src, len + 1); + return dst; +} diff --git a/reapi/include/cssdk/public/tier0/dbg.cpp b/reapi/include/cssdk/public/tier0/dbg.cpp index 36994aa..58dabd0 100644 --- a/reapi/include/cssdk/public/tier0/dbg.cpp +++ b/reapi/include/cssdk/public/tier0/dbg.cpp @@ -432,4 +432,4 @@ void* Plat_SimpleLog(const char* file, int line) fclose(f); return NULL; -} \ No newline at end of file +} diff --git a/reapi/include/cssdk/public/tier0/dbg.h b/reapi/include/cssdk/public/tier0/dbg.h index d4b07aa..e1b67bf 100644 --- a/reapi/include/cssdk/public/tier0/dbg.h +++ b/reapi/include/cssdk/public/tier0/dbg.h @@ -19,9 +19,8 @@ #pragma once #endif -#include "osconfig.h" #include "basetypes.h" -#include "tier0/platform.h" + #include #include #include @@ -450,4 +449,4 @@ private: //#endif //#endif -#endif /* DBG_H */ \ No newline at end of file +#endif /* DBG_H */ diff --git a/reapi/include/cssdk/public/tier0/platform.h b/reapi/include/cssdk/public/tier0/platform.h index f9e4e6c..b2b1f22 100644 --- a/reapi/include/cssdk/public/tier0/platform.h +++ b/reapi/include/cssdk/public/tier0/platform.h @@ -1,102 +1,40 @@ -//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. =========== -// -// The copyright to the contents herein is the property of Valve, L.L.C. -// The contents may be used and/or copied only with the written permission of -// Valve, L.L.C., or in accordance with the terms and conditions stipulated in -// the agreement/contract under which the contents have been supplied. -// -// $Header: $ -// $NoKeywords: $ -// -// Extremely low-level platform-specific stuff -//============================================================================= +/* +* +* 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 2 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, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +*/ - -#ifndef PLATFORM_H -#define PLATFORM_H - -#ifdef _WIN32 #pragma once -#endif #include "osconfig.h" -// need this for _alloca -#include - -// need this for memset -#include +#include // need this for _alloca +#include // need this for memset #include "archtypes.h" -typedef float float32; -typedef double float64; - -// for when we don't care about how many bits we use -typedef unsigned int uint; - -// This can be used to ensure the size of pointers to members when declaring -// a pointer type for a class that has only been forward declared -#ifdef _MSC_VER -#define SINGLE_INHERITANCE __single_inheritance -#define MULTIPLE_INHERITANCE __multiple_inheritance -#else -#define SINGLE_INHERITANCE -#define MULTIPLE_INHERITANCE -#endif - -/* -FIXME: Enable this when we no longer fear change =) - -// need these for the limits -#include -#include - -// Maximum and minimum representable values -#define INT8_MAX SCHAR_MAX -#define INT16_MAX SHRT_MAX -#define INT32_MAX LONG_MAX -#define INT64_MAX (((int64)~0) >> 1) - -#define INT8_MIN SCHAR_MIN -#define INT16_MIN SHRT_MIN -#define INT32_MIN LONG_MIN -#define INT64_MIN (((int64)1) << 63) - -#define UINT8_MAX ((uint8)~0) -#define UINT16_MAX ((uint16)~0) -#define UINT32_MAX ((uint32)~0) -#define UINT64_MAX ((uint64)~0) - -#define UINT8_MIN 0 -#define UINT16_MIN 0 -#define UINT32_MIN 0 -#define UINT64_MIN 0 - -#ifndef UINT_MIN -#define UINT_MIN UINT32_MIN -#endif - -#define FLOAT32_MAX FLT_MAX -#define FLOAT64_MAX DBL_MAX - -#define FLOAT32_MIN FLT_MIN -#define FLOAT64_MIN DBL_MIN -*/ - -// portability / compiler settings -#if defined(_WIN32) && !defined(WINDED) - -#if defined(_M_IX86) -#define __i386__ 1 -#endif - -#elif __linux__ -typedef void * HINSTANCE; -#define _MAX_PATH PATH_MAX -#endif // defined(_WIN32) && !defined(WINDED) - - // Defines MAX_PATH #ifndef MAX_PATH #define MAX_PATH 260 @@ -108,92 +46,42 @@ typedef void * HINSTANCE; // C functions for external declarations that call the appropriate C++ methods #ifndef EXPORT #ifdef _WIN32 -#define EXPORT _declspec( dllexport ) -#else +#define EXPORT __declspec(dllexport) +#else #define EXPORT /* */ #endif #endif -#if defined __i386__ && !defined __linux__ -#define id386 1 -#else -#define id386 0 -#endif // __i386__ - #ifdef _WIN32 // Used for dll exporting and importing -#define DLL_EXPORT extern "C" __declspec( dllexport ) -#define DLL_IMPORT extern "C" __declspec( dllimport ) +#define DLL_EXPORT extern "C" __declspec(dllexport) +#define DLL_IMPORT extern "C" __declspec(dllimport) // Can't use extern "C" when DLL exporting a class -#define DLL_CLASS_EXPORT __declspec( dllexport ) -#define DLL_CLASS_IMPORT __declspec( dllimport ) +#define DLL_CLASS_EXPORT __declspec(dllexport) +#define DLL_CLASS_IMPORT __declspec(dllimport) // Can't use extern "C" when DLL exporting a global -#define DLL_GLOBAL_EXPORT extern __declspec( dllexport ) -#define DLL_GLOBAL_IMPORT extern __declspec( dllimport ) +#define DLL_GLOBAL_EXPORT extern __declspec(dllexport) +#define DLL_GLOBAL_IMPORT extern __declspec(dllimport) #elif defined __linux__ // Used for dll exporting and importing -#define DLL_EXPORT extern "C" -#define DLL_IMPORT extern "C" +#define DLL_EXPORT extern "C" +#define DLL_IMPORT extern "C" // Can't use extern "C" when DLL exporting a class -#define DLL_CLASS_EXPORT -#define DLL_CLASS_IMPORT +#define DLL_CLASS_EXPORT +#define DLL_CLASS_IMPORT // Can't use extern "C" when DLL exporting a global -#define DLL_GLOBAL_EXPORT extern -#define DLL_GLOBAL_IMPORT extern +#define DLL_GLOBAL_EXPORT extern +#define DLL_GLOBAL_IMPORT extern #else #error "Unsupported Platform." #endif -// Used for standard calling conventions -#ifdef _WIN32 -#define FASTCALL __fastcall -#define FORCEINLINE __forceinline -#else -#define FASTCALL -#define FORCEINLINE inline -#endif - -// Force a function call site -not- to inlined. (useful for profiling) -#define DONT_INLINE(a) (((int)(a)+1)?(a):(a)) - -// Pass hints to the compiler to prevent it from generating unnessecary / stupid code -// in certain situations. Several compilers other than MSVC also have an equivilent -// construct. -// -// Essentially the 'Hint' is that the condition specified is assumed to be true at -// that point in the compilation. If '0' is passed, then the compiler assumes that -// any subsequent code in the same 'basic block' is unreachable, and thus usually -// removed. -#ifdef _MSC_VER -#define HINT(THE_HINT) __assume((THE_HINT)) -#else -#define HINT(THE_HINT) 0 -#endif - -// Marks the codepath from here until the next branch entry point as unreachable, -// and asserts if any attempt is made to execute it. -#define UNREACHABLE() { Assert(0); HINT(0); } - -// In cases where no default is present or appropriate, this causes MSVC to generate -// as little code as possible, and throw an assertion in debug. -#define NO_DEFAULT default: UNREACHABLE(); - -#ifdef _WIN32 -// Alloca defined for this platform -#define stackalloc( _size ) _alloca( _size ) -#define stackfree( _p ) 0 -#elif __linux__ -// Alloca defined for this platform -#define stackalloc( _size ) alloca( _size ) -#define stackfree( _p ) 0 -#endif - #ifdef _WIN32 // Remove warnings from warning level 4. #pragma warning(disable : 4514) // warning C4514: 'acosl' : unreferenced inline function has been removed @@ -216,274 +104,22 @@ typedef void * HINSTANCE; #pragma warning(disable : 4511) // Disable warnings about private copy constructors #endif #endif -//----------------------------------------------------------------------------- -// Purpose: Standard functions for handling endian-ness -//----------------------------------------------------------------------------- -//------------------------------------- -// Basic swaps -//------------------------------------- - -template -inline T WordSwapC(T w) -{ - uint16 temp; - - temp = ((*((uint16 *)&w) & 0xff00) >> 8); - temp |= ((*((uint16 *)&w) & 0x00ff) << 8); - - return *((T*)&temp); -} - -template -inline T DWordSwapC(T dw) -{ - uint32 temp; - - temp = *((uint32 *)&dw) >> 24; - temp |= ((*((uint32 *)&dw) & 0x00FF0000) >> 8); - temp |= ((*((uint32 *)&dw) & 0x0000FF00) << 8); - temp |= ((*((uint32 *)&dw) & 0x000000FF) << 24); - - return *((T*)&temp); -} - -//------------------------------------- -// Fast swaps -//------------------------------------- - -#ifdef _MSC_VER - -#define WordSwap WordSwapAsm -#define DWordSwap DWordSwapAsm - -#pragma warning(push) -#pragma warning (disable:4035) // no return value - -template -inline T WordSwapAsm(T w) -{ - __asm - { - mov ax, w - xchg al, ah - } -} - -template -inline T DWordSwapAsm(T dw) -{ - __asm - { - mov eax, dw - bswap eax - } -} - -#pragma warning(pop) - -// The assembly implementation is not compatible with floats -template <> -inline float DWordSwapAsm(float f) -{ - return DWordSwapC(f); -} - -#else - -#define WordSwap WordSwapC -#define DWordSwap DWordSwapC - -#endif - -//------------------------------------- -// The typically used methods. -//------------------------------------- - -#if defined(__i386__) -#define VALVE_LITTLE_ENDIAN 1 -#endif - -#ifdef _SGI_SOURCE -#define VALVE_BIG_ENDIAN 1 -#endif - -#if defined(VALVE_LITTLE_ENDIAN) - -#define Valve_BigShort( val ) WordSwap( val ) -#define Valve_BigWord( val ) WordSwap( val ) -#define Valve_BigLong( val ) DWordSwap( val ) -#define Valve_BigDWord( val ) DWordSwap( val ) -#define Valve_BigFloat( val ) DWordSwap( val ) -#define Valve_LittleShort( val ) ( val ) -#define Valve_LittleWord( val ) ( val ) -#define Valve_LittleLong( val ) ( val ) -#define Valve_LittleDWord( val ) ( val ) -#define Valve_LittleFloat( val ) ( val ) - -#elif defined(BIG_ENDIAN) - -#define Valve_BigShort( val ) ( val ) -#define Valve_BigWord( val ) ( val ) -#define Valve_BigLong( val ) ( val ) -#define Valve_BigDWord( val ) ( val ) -#define Valve_BigFloat( val ) ( val ) -#define Valve_LittleShort( val ) WordSwap( val ) -#define Valve_LittleWord( val ) WordSwap( val ) -#define Valve_LittleLong( val ) DWordSwap( val ) -#define Valve_LittleDWord( val ) DWordSwap( val ) -#define Valve_LittleFloat( val ) DWordSwap( val ) - -#else - -// @Note (toml 05-02-02): this technique expects the compiler to -// optimize the expression and eliminate the other path. On any new -// platform/compiler this should be tested. -inline short BigShort(short val) { int test = 1; return (*(char *)&test == 1) ? WordSwap(val) : val; } -inline uint16 BigWord(uint16 val) { int test = 1; return (*(char *)&test == 1) ? WordSwap(val) : val; } -inline long BigLong(long val) { int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; } -inline uint32 BigDWord(uint32 val) { int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; } -inline float BigFloat(float val) { int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; } -inline short LittleShort(short val) { int test = 1; return (*(char *)&test == 1) ? val : WordSwap(val); } -inline uint16 LittleWord(uint16 val) { int test = 1; return (*(char *)&test == 1) ? val : WordSwap(val); } -inline long LittleLong(long val) { int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); } -inline uint32 LittleDWord(uint32 val) { int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); } -inline float LittleFloat(float val) { int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); } - -#endif - - - -#ifdef TIER0_DLL_EXPORT -#define PLATFORM_INTERFACE DLL_EXPORT -#define PLATFORM_OVERLOAD DLL_GLOBAL_EXPORT -#else -#define PLATFORM_INTERFACE DLL_IMPORT -#define PLATFORM_OVERLOAD DLL_GLOBAL_IMPORT -#endif - -/* -PLATFORM_INTERFACE double Plat_FloatTime(); // Returns time in seconds since the module was loaded. -PLATFORM_INTERFACE unsigned long Plat_MSTime(); // Time in milliseconds. - -// b/w compatibility -#define Sys_FloatTime Plat_FloatTime -*/ - -// Processor Information: -struct CPUInformation -{ - int m_Size; // Size of this structure, for forward compatability. - - bool m_bRDTSC : 1, // Is RDTSC supported? - m_bCMOV : 1, // Is CMOV supported? - m_bFCMOV : 1, // Is FCMOV supported? - m_bSSE : 1, // Is SSE supported? - m_bSSE2 : 1, // Is SSE2 Supported? - m_b3DNow : 1, // Is 3DNow! Supported? - m_bMMX : 1, // Is MMX supported? - m_bHT : 1; // Is HyperThreading supported? - - unsigned char m_nLogicalProcessors, // Number op logical processors. - m_nPhysicalProcessors; // Number of physical processors - - int64 m_Speed; // In cycles per second. - - char* m_szProcessorID; // Processor vendor Identification. -}; - -PLATFORM_INTERFACE const CPUInformation& GetCPUInformation(); - - -//----------------------------------------------------------------------------- -// Thread related functions -//----------------------------------------------------------------------------- -// Registers the current thread with Tier0's thread management system. -// This should be called on every thread created in the game. -PLATFORM_INTERFACE unsigned long Plat_RegisterThread(const char *pName = "Source Thread"); - -// Registers the current thread as the primary thread. -PLATFORM_INTERFACE unsigned long Plat_RegisterPrimaryThread(); - -// VC-specific. Sets the thread's name so it has a friendly name in the debugger. -// This should generally only be handled by Plat_RegisterThread and Plat_RegisterPrimaryThread -PLATFORM_INTERFACE void Plat_SetThreadName(unsigned long dwThreadID, const char *pName); - -// These would be private if it were possible to export private variables from a .DLL. -// They need to be variables because they are checked by inline functions at performance -// critical places. -PLATFORM_INTERFACE unsigned long Plat_PrimaryThreadID; - -// Returns the ID of the currently executing thread. -PLATFORM_INTERFACE unsigned long Plat_GetCurrentThreadID(); - -// Returns the ID of the primary thread. -inline unsigned long Plat_GetPrimaryThreadID() -{ - return Plat_PrimaryThreadID; -} - -// Returns true if the current thread is the primary thread. -inline bool Plat_IsPrimaryThread() -{ - //return true; - return (Plat_GetPrimaryThreadID() == Plat_GetCurrentThreadID()); -} - -//----------------------------------------------------------------------------- -// Security related functions -//----------------------------------------------------------------------------- -// Ensure that the hardware key's drivers have been installed. -PLATFORM_INTERFACE bool Plat_VerifyHardwareKeyDriver(); - -// Ok, so this isn't a very secure way to verify the hardware key for now. It -// is primarially depending on the fact that all the binaries have been wrapped -// with the secure wrapper provided by the hardware keys vendor. -PLATFORM_INTERFACE bool Plat_VerifyHardwareKey(); - -// The same as above, but notifies user with a message box when the key isn't in -// and gives him an opportunity to correct the situation. -PLATFORM_INTERFACE bool Plat_VerifyHardwareKeyPrompt(); - -// Can be called in real time, doesn't perform the verify every frame. Mainly just -// here to allow the game to drop out quickly when the key is removed, rather than -// allowing the wrapper to pop up it's own blocking dialog, which the engine doesn't -// like much. -PLATFORM_INTERFACE bool Plat_FastVerifyHardwareKey(); - - - -//----------------------------------------------------------------------------- -// Include additional dependant header components. -//----------------------------------------------------------------------------- -//#include "tier0/fasttimer.h" - - -//----------------------------------------------------------------------------- -// Just logs file and line to simple.log -//----------------------------------------------------------------------------- -void* Plat_SimpleLog(const char* file, int line); - -//#define Plat_dynamic_cast Plat_SimpleLog(__FILE__,__LINE__),dynamic_cast - -//----------------------------------------------------------------------------- // Methods to invoke the constructor, copy constructor, and destructor -//----------------------------------------------------------------------------- - template -inline void Construct(T* pMemory) +inline void Construct(T *pMemory) { - new(pMemory)T; + new(pMemory) T; } template -inline void CopyConstruct(T* pMemory, T const& src) +inline void CopyConstruct(T *pMemory, T const &src) { - new(pMemory)T(src); + new(pMemory) T(src); } template -inline void Destruct(T* pMemory) +inline void Destruct(T *pMemory) { pMemory->~T(); @@ -491,140 +127,3 @@ inline void Destruct(T* pMemory) memset(pMemory, 0xDD, sizeof(T)); #endif } - - -// -// GET_OUTER() -// -// A platform-independent way for a contained class to get a pointer to its -// owner. If you know a class is exclusively used in the context of some -// "outer" class, this is a much more space efficient way to get at the outer -// class than having the inner class store a pointer to it. -// -// class COuter -// { -// class CInner // Note: this does not need to be a nested class to work -// { -// void PrintAddressOfOuter() -// { -// printf( "Outer is at 0x%x\n", GET_OUTER( COuter, m_Inner ) ); -// } -// }; -// -// CInner m_Inner; -// friend class CInner; -// }; - -#define GET_OUTER( OuterType, OuterMember ) \ - ( ( OuterType * ) ( (char *)this - offsetof( OuterType, OuterMember ) ) ) - - -/* TEMPLATE_FUNCTION_TABLE() - -(Note added to platform.h so platforms that correctly support templated -functions can handle portions as templated functions rather than wrapped -functions) - -Helps automate the process of creating an array of function -templates that are all specialized by a single integer. -This sort of thing is often useful in optimization work. - -For example, using TEMPLATE_FUNCTION_TABLE, this: - -TEMPLATE_FUNCTION_TABLE(int, Function, ( int blah, int blah ), 10) -{ -return argument * argument; -} - -is equivilent to the following: - -(NOTE: the function has to be wrapped in a class due to code -generation bugs involved with directly specializing a function -based on a constant.) - -template -class FunctionWrapper -{ -public: -int Function( int blah, int blah ) -{ -return argument*argument; -} -} - -typedef int (*FunctionType)( int blah, int blah ); - -class FunctionName -{ -public: -enum { count = 10 }; -FunctionType functions[10]; -}; - -FunctionType FunctionName::functions[] = -{ -FunctionWrapper<0>::Function, -FunctionWrapper<1>::Function, -FunctionWrapper<2>::Function, -FunctionWrapper<3>::Function, -FunctionWrapper<4>::Function, -FunctionWrapper<5>::Function, -FunctionWrapper<6>::Function, -FunctionWrapper<7>::Function, -FunctionWrapper<8>::Function, -FunctionWrapper<9>::Function -}; -*/ - -bool vtune(bool resume); - - -#define TEMPLATE_FUNCTION_TABLE(RETURN_TYPE, NAME, ARGS, COUNT) \ - \ -typedef RETURN_TYPE (FASTCALL *__Type_##NAME) ARGS; \ - \ -template \ -struct __Function_##NAME \ -{ \ - static RETURN_TYPE FASTCALL Run ARGS; \ -}; \ - \ -template \ -struct __MetaLooper_##NAME : __MetaLooper_##NAME \ -{ \ - __Type_##NAME func; \ - inline __MetaLooper_##NAME() { func = __Function_##NAME::Run; } \ -}; \ - \ -template<> \ -struct __MetaLooper_##NAME<0> \ -{ \ - __Type_##NAME func; \ - inline __MetaLooper_##NAME() { func = __Function_##NAME<0>::Run; } \ -}; \ - \ -class NAME \ -{ \ -private: \ - static const __MetaLooper_##NAME m; \ -public: \ - enum { count = COUNT }; \ - static const __Type_##NAME* functions; \ -}; \ -const __MetaLooper_##NAME NAME::m; \ -const __Type_##NAME* NAME::functions = (__Type_##NAME*)&m; \ -template \ -RETURN_TYPE FASTCALL __Function_##NAME::Run ARGS - - -#define LOOP_INTERCHANGE(BOOLEAN, CODE)\ - if( (BOOLEAN) )\ - {\ - CODE;\ - } else\ - {\ - CODE;\ - } - - -#endif /* PLATFORM_H */ \ No newline at end of file diff --git a/reapi/include/cssdk/public/utlmemory.h b/reapi/include/cssdk/public/utlmemory.h index 4f75f81..4aecc6c 100644 --- a/reapi/include/cssdk/public/utlmemory.h +++ b/reapi/include/cssdk/public/utlmemory.h @@ -26,12 +26,7 @@ * */ -#ifndef UTLMEMORY_H -#define UTLMEMORY_H - -#ifdef _WIN32 #pragma once -#endif #include "osconfig.h" #include "tier0/dbg.h" @@ -40,55 +35,56 @@ #pragma warning (disable:4100) #pragma warning (disable:4514) -/*template -inline void Construct(T *pMemory) -{ - ::new(pMemory) T; -} - -template -inline void CopyConstruct(T *pMemory,T const& src) -{ - ::new(pMemory) T(src); -} - -template -inline void Destruct(T *pMemory) -{ - pMemory->~T(); - -#ifdef _DEBUG - memset(pMemory,0xDD,sizeof(T)); -#endif -}*/ -//----------------------------------------------------------------------------- // The CUtlMemory class: // A growable memory class which doubles in size by default. -//----------------------------------------------------------------------------- -template< class T > +template class CUtlMemory { public: // constructor, destructor CUtlMemory(int nGrowSize = 0, int nInitSize = 0); - CUtlMemory(T* pMemory, int numElements); + CUtlMemory(T *pMemory, int numElements); ~CUtlMemory(); + // Set the size by which the memory grows + void Init(int nGrowSize = 0, int nInitSize = 0); + + class Iterator_t + { + public: + Iterator_t(I i) : m_index(i) {} + I m_index; + + bool operator==(const Iterator_t it) const { return m_index == it.m_index; } + bool operator!=(const Iterator_t it) const { return m_index != it.m_index; } + }; + + Iterator_t First() const { return Iterator_t(IsIdxValid(0) ? 0 : InvalidIndex()); } + Iterator_t Next(const Iterator_t &it) const { return Iterator_t(IsIdxValid(it.index + 1) ? it.index + 1 : InvalidIndex()); } + I GetIndex(const Iterator_t &it) const { return it.index; } + bool IsIdxAfter(I i, const Iterator_t &it) const { return i > it.index; } + bool IsValidIterator(const Iterator_t &it) const { return IsIdxValid(it.index); } + Iterator_t InvalidIterator() const { return Iterator_t(InvalidIndex()); } + // element access - T& operator[](int i); - T const& operator[](int i) const; - T& Element(int i); - T const& Element(int i) const; + T& Element(I i); + T const& Element(I i) const; + T& operator[](I i); + T const& operator[](I i) const; // Can we use this index? - bool IsIdxValid(int i) const; + bool IsIdxValid(I i) const; + + // Specify the invalid ('null') index that we'll only return on failure + static const I INVALID_INDEX = (I)-1; // For use with COMPILE_TIME_ASSERT + static I InvalidIndex() { return INVALID_INDEX; } // Gets the base address (can change when adding elements!) - T* Base(); - T const* Base() const; + T *Base(); + T const *Base() const; // Attaches the buffer to external memory.... - void SetExternalBuffer(T* pMemory, int numElements); + void SetExternalBuffer(T *pMemory, int numElements); // Size int NumAllocated() const; @@ -115,46 +111,54 @@ private: EXTERNAL_BUFFER_MARKER = -1, }; - T* m_pMemory; + T *m_pMemory; int m_nAllocationCount; int m_nGrowSize; }; - -//----------------------------------------------------------------------------- // constructor, destructor -//----------------------------------------------------------------------------- -template< class T > -CUtlMemory::CUtlMemory(int nGrowSize, int nInitAllocationCount) : m_pMemory(0), -m_nAllocationCount(nInitAllocationCount), m_nGrowSize(nGrowSize) +template +CUtlMemory::CUtlMemory(int nGrowSize, int nInitSize) : m_pMemory(0), +m_nAllocationCount(nInitSize), m_nGrowSize(nGrowSize) { Assert((nGrowSize >= 0) && (nGrowSize != EXTERNAL_BUFFER_MARKER)); if (m_nAllocationCount) { - m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T)); + m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T)); } } -template< class T > -CUtlMemory::CUtlMemory(T* pMemory, int numElements) : m_pMemory(pMemory), +template +CUtlMemory::CUtlMemory(T *pMemory, int numElements) : m_pMemory(pMemory), m_nAllocationCount(numElements) { // Special marker indicating externally supplied memory m_nGrowSize = EXTERNAL_BUFFER_MARKER; } -template< class T > -CUtlMemory::~CUtlMemory() +template +CUtlMemory::~CUtlMemory() { Purge(); } +template +void CUtlMemory::Init(int nGrowSize, int nInitSize) +{ + Purge(); + + m_nGrowSize = nGrowSize; + m_nAllocationCount = nInitSize; + Assert(nGrowSize >= 0); + if (m_nAllocationCount) + { + m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T)); + } +} -//----------------------------------------------------------------------------- // Attaches the buffer to external memory.... -//----------------------------------------------------------------------------- -template< class T > -void CUtlMemory::SetExternalBuffer(T* pMemory, int numElements) +template +void CUtlMemory::SetExternalBuffer(T *pMemory, int numElements) { // Blow away any existing allocated memory Purge(); @@ -166,110 +170,91 @@ void CUtlMemory::SetExternalBuffer(T* pMemory, int numElements) m_nGrowSize = EXTERNAL_BUFFER_MARKER; } - -//----------------------------------------------------------------------------- // element access -//----------------------------------------------------------------------------- -template< class T > -inline T& CUtlMemory::operator[](int i) +template +inline T& CUtlMemory::operator[](I i) { Assert(IsIdxValid(i)); return m_pMemory[i]; } -template< class T > -inline T const& CUtlMemory::operator[](int i) const +template +inline T const& CUtlMemory::operator[](I i) const { Assert(IsIdxValid(i)); return m_pMemory[i]; } -template< class T > -inline T& CUtlMemory::Element(int i) +template +inline T& CUtlMemory::Element(I i) { Assert(IsIdxValid(i)); return m_pMemory[i]; } -template< class T > -inline T const& CUtlMemory::Element(int i) const +template +inline T const& CUtlMemory::Element(I i) const { Assert(IsIdxValid(i)); return m_pMemory[i]; } - -//----------------------------------------------------------------------------- // is the memory externally allocated? -//----------------------------------------------------------------------------- -template< class T > -bool CUtlMemory::IsExternallyAllocated() const +template +bool CUtlMemory::IsExternallyAllocated() const { return m_nGrowSize == EXTERNAL_BUFFER_MARKER; } - -template< class T > -void CUtlMemory::SetGrowSize(int nSize) +template +void CUtlMemory::SetGrowSize(int nSize) { Assert((nSize >= 0) && (nSize != EXTERNAL_BUFFER_MARKER)); m_nGrowSize = nSize; } - -//----------------------------------------------------------------------------- // Gets the base address (can change when adding elements!) -//----------------------------------------------------------------------------- -template< class T > -inline T* CUtlMemory::Base() +template +inline T *CUtlMemory::Base() { return m_pMemory; } -template< class T > -inline T const* CUtlMemory::Base() const +template +inline T const *CUtlMemory::Base() const { return m_pMemory; } - -//----------------------------------------------------------------------------- // Size -//----------------------------------------------------------------------------- -template< class T > -inline int CUtlMemory::NumAllocated() const +template +inline int CUtlMemory::NumAllocated() const { return m_nAllocationCount; } -template< class T > -inline int CUtlMemory::Count() const +template +inline int CUtlMemory::Count() const { return m_nAllocationCount; } - -//----------------------------------------------------------------------------- // Is element index valid? -//----------------------------------------------------------------------------- -template< class T > -inline bool CUtlMemory::IsIdxValid(int i) const +template +inline bool CUtlMemory::IsIdxValid(I i) const { - return (i >= 0) && (i < m_nAllocationCount); + return (((int)i) >= 0) && (((int) i) < m_nAllocationCount); } - -//----------------------------------------------------------------------------- // Grows the memory -//----------------------------------------------------------------------------- -template< class T > -void CUtlMemory::Grow(int num) +template +void CUtlMemory::Grow(int num) { Assert(num > 0); if (IsExternallyAllocated()) { - // Can't grow a buffer whose memory was externally allocated + // Can't grow a buffer whose memory was externally allocated Assert(0); return; } @@ -300,27 +285,24 @@ void CUtlMemory::Grow(int num) if (m_pMemory) { - m_pMemory = (T*)realloc(m_pMemory, m_nAllocationCount * sizeof(T)); + m_pMemory = (T *)realloc(m_pMemory, m_nAllocationCount * sizeof(T)); } else { - m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T)); + m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T)); } } - -//----------------------------------------------------------------------------- // Makes sure we've got at least this much memory -//----------------------------------------------------------------------------- -template< class T > -inline void CUtlMemory::EnsureCapacity(int num) +template +inline void CUtlMemory::EnsureCapacity(int num) { if (m_nAllocationCount >= num) return; if (IsExternallyAllocated()) { - // Can't grow a buffer whose memory was externally allocated + // Can't grow a buffer whose memory was externally allocated Assert(0); return; } @@ -328,30 +310,25 @@ inline void CUtlMemory::EnsureCapacity(int num) m_nAllocationCount = num; if (m_pMemory) { - m_pMemory = (T*)realloc(m_pMemory, m_nAllocationCount * sizeof(T)); + m_pMemory = (T *)realloc(m_pMemory, m_nAllocationCount * sizeof(T)); } else { - m_pMemory = (T*)malloc(m_nAllocationCount * sizeof(T)); + m_pMemory = (T *)malloc(m_nAllocationCount * sizeof(T)); } } - -//----------------------------------------------------------------------------- // Memory deallocation -//----------------------------------------------------------------------------- -template< class T > -void CUtlMemory::Purge() +template +void CUtlMemory::Purge() { if (!IsExternallyAllocated()) { if (m_pMemory) { - free((void*)m_pMemory); + free((void *)m_pMemory); m_pMemory = 0; } m_nAllocationCount = 0; } } - -#endif // UTLMEMORY_H diff --git a/reapi/src/natives/natives_common.cpp b/reapi/src/natives/natives_common.cpp index 200f2b4..5f113e3 100644 --- a/reapi/src/natives/natives_common.cpp +++ b/reapi/src/natives/natives_common.cpp @@ -179,7 +179,7 @@ cell AMX_NATIVE_CALL is_regamedll(AMX *amx, cell *params) * * @return true/false * -* native bool:is_has_reunion(); +* native bool:has_reunion(); */ cell AMX_NATIVE_CALL has_reunion(AMX *amx, cell *params) { @@ -191,20 +191,33 @@ cell AMX_NATIVE_CALL has_reunion(AMX *amx, cell *params) * * @return true/false * -* native bool:is_has_vtc(); +* native bool:has_vtc(); */ cell AMX_NATIVE_CALL has_vtc(AMX *amx, cell *params) { return (cell)api_cfg.hasVTC(); } +/* +* Check if the rechecker is available +* +* @return true/false +* +* native bool:has_rechecker(); +*/ +cell AMX_NATIVE_CALL has_rechecker(AMX *amx, cell *params) +{ + return (cell)api_cfg.hasRechecker(); +} + AMX_NATIVE_INFO Natives_Checks[] = { - { "is_entity", is_entity }, - { "is_rehlds", is_rehlds }, - { "is_regamedll", is_regamedll }, - { "has_reunion", has_reunion }, - { "has_vtc", has_vtc }, + { "is_entity", is_entity }, + { "is_rehlds", is_rehlds }, + { "is_regamedll", is_regamedll }, + { "has_reunion", has_reunion }, + { "has_vtc", has_vtc }, + { "has_rechecker", has_rechecker }, }; void RegisterNatives_Common() diff --git a/reapi/src/natives/natives_misc.cpp b/reapi/src/natives/natives_misc.cpp index 626b2d8..687afd1 100644 --- a/reapi/src/natives/natives_misc.cpp +++ b/reapi/src/natives/natives_misc.cpp @@ -396,24 +396,26 @@ cell AMX_NATIVE_CALL rg_round_end(AMX *amx, cell *params) return FALSE; } - const char *_sentence, *_message; ScenarioEventEndRound event = static_cast(params[arg_event]); - _sentence = getAmxString(amx, params[arg_sentence]); - _message = getAmxString(amx, params[arg_message]); + char sentence[190], message[190]; + Q_strlcpy(sentence, getAmxString(amx, params[arg_sentence])); + Q_strlcpy(message, getAmxString(amx, params[arg_message])); if (event != ROUND_NONE) { auto& lst = msg_sentence_list[event]; - if (strcmp(_sentence, "default") == 0) - _sentence = lst.sentence; - if (strcmp(_message, "default") == 0) - _message = lst.msg; + if (strcmp(sentence, "default") == 0) + Q_strlcpy(sentence, lst.sentence); + if (strcmp(message, "default") == 0) + Q_strlcpy(message, lst.msg); } - if (_sentence[0]) - Broadcast(_sentence); + if (sentence[0] != '\0') + { + Broadcast(sentence); + } - CSGameRules()->EndRoundMessage(_message, event); + CSGameRules()->EndRoundMessage(message, event); CSGameRules()->TerminateRound(CAmxArg(amx, params[arg_delay]), winstatus); return TRUE; } @@ -925,7 +927,9 @@ cell AMX_NATIVE_CALL rg_internal_cmd(AMX *amx, cell *params) return FALSE; } - pPlayer->CSPlayer()->ClientCommand(getAmxString(amx, params[arg_cmd]), getAmxString(amx, params[arg_arg])); + char command[128]; + Q_strlcpy(command, getAmxString(amx, params[arg_cmd])); + pPlayer->CSPlayer()->ClientCommand(command, getAmxString(amx, params[arg_arg])); return TRUE; } diff --git a/reapi/src/natives/natives_rechecker.cpp b/reapi/src/natives/natives_rechecker.cpp index 9f07fdc..e3c087e 100644 --- a/reapi/src/natives/natives_rechecker.cpp +++ b/reapi/src/natives/natives_rechecker.cpp @@ -32,11 +32,13 @@ cell AMX_NATIVE_CALL RegisterQueryFile(AMX *amx, cell *params) break; } + char filename[MAX_PATH]; const char *file = getAmxString(amx, params[arg_file]); if (!file || file[0] == '\0') { MF_LogError(amx, AMX_ERR_NATIVE, "%s: file can not be empty.", __FUNCTION__); return FALSE; } + Q_strlcpy(filename, file); int funcid; const char *funcname = getAmxString(amx, params[arg_handler]); @@ -46,7 +48,7 @@ cell AMX_NATIVE_CALL RegisterQueryFile(AMX *amx, cell *params) return FALSE; } - return g_queryFileManager.Add(amx, file, funcname, flag, params[arg_hash]); + return g_queryFileManager.Add(amx, filename, funcname, flag, params[arg_hash]); } /*