Refactoring cssdk

Fix some things

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.

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

reapi/include/cssdk/dlls/regamedll_common.h

@@ -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

reapi/include/cssdk/public/FileSystem.h

@@ -1,32 +1,54 @@
-//========= Copyright <20> 1996-2001, Valve LLC, All rights reserved. ============
+/*
-//
+*
-// Purpose: 
+*    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
-// $NoKeywords: $
+*    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 <stdio.h>
 #include <stdlib.h>
 
+// 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,				// Don't print anything
-	FILESYSTEM_WARNING_QUIET = 0,
+	FILESYSTEM_WARNING_REPORTUNCLOSED,			// On shutdown, report names of files left unclosed
-
+	FILESYSTEM_WARNING_REPORTUSAGE,				// Report number of times a file was opened, closed
-	// On shutdown, report names of files left unclosed
+	FILESYSTEM_WARNING_REPORTALLACCESSES		// Report all open/close events to console (!slow!)
-	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
 } FileWarningLevel_t;
 
-#define FILESYSTEM_INVALID_HANDLE	( FileHandle_t )0
+#define FILESYSTEM_INVALID_HANDLE (FileHandle_t)0
-#endif
+#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			Mount() = 0;
-	virtual void			Unmount( void ) = 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
+	//  and this file becomes the highest priority search path (i.e., it's looked at first
-	//   even before the mod's file system path ).
+	//   even before the mod's file system path).
-	virtual void			AddSearchPath( const char *pPath, const char *pathID ) = 0;
+	virtual void			AddSearchPath(const char *pPath, const char *pathID) = 0;
-	virtual bool			RemoveSearchPath( const char *pPath ) = 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			FileExists(const char *pFileName) = 0;
-	virtual bool			IsDirectory( 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 void			Seek(FileHandle_t file, int pos, FileSystemSeek_t seekType) = 0;
-	virtual unsigned int	Tell( FileHandle_t file ) = 0;
+	virtual unsigned int	Tell(FileHandle_t file) = 0;
 
-	virtual unsigned int	Size( FileHandle_t file ) = 0;
+	virtual unsigned int	Size(FileHandle_t file) = 0;
-	virtual unsigned int	Size( const char *pFileName ) = 0;
+	virtual unsigned int	Size(const char *pFileName) = 0;
 
-	virtual long			GetFileTime( const char *pFileName ) = 0;
+	virtual long			GetFileTime(const char *pFileName) = 0;
-	virtual void			FileTimeToString( char* pStrip, int maxCharsIncludingTerminator, long fileTime ) = 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 void			Flush(FileHandle_t file) = 0;
-	virtual bool			EndOfFile( FileHandle_t file ) = 0;
+	virtual bool			EndOfFile(FileHandle_t file) = 0;
 
-	virtual int				Read( void* pOutput, int size, 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 int				Write(void const *pInput, int size, FileHandle_t file) = 0;
-	virtual char			*ReadLine( char *pOutput, int maxChars, 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				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			*GetReadBuffer(FileHandle_t file, int *outBufferSize, bool failIfNotInCache) = 0;
-	virtual void			ReleaseReadBuffer( FileHandle_t file, void *readBuffer ) = 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		*FindFirst(const char *pWildCard, FileFindHandle_t *pHandle, const char *pathID = 0L) = 0;
-	virtual const char		*FindNext( FileFindHandle_t handle ) = 0;
+	virtual const char		*FindNext(FileFindHandle_t handle) = 0;
-	virtual bool			FindIsDirectory( FileFindHandle_t handle ) = 0;
+	virtual bool			FindIsDirectory(FileFindHandle_t handle) = 0;
-	virtual void			FindClose( 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 )
+	// 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;
+	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			SetWarningFunc(WarningFunc_t pfnWarning) = 0;
-	virtual void			SetWarningLevel( FileWarningLevel_t level ) = 0;
+	virtual void			SetWarningLevel(FileWarningLevel_t level) = 0;
 
-	virtual void			LogLevelLoadStarted( const char *name ) = 0;
+	virtual void			LogLevelLoadStarted(const char *name) = 0;
-	virtual void			LogLevelLoadFinished( const char *name ) = 0;
+	virtual void			LogLevelLoadFinished(const char *name) = 0;
-	virtual int				HintResourceNeed( const char *hintlist, int forgetEverything ) = 0;
+	virtual int				HintResourceNeed(const char *hintlist, int forgetEverything) = 0;
-	virtual int				PauseResourcePreloading( void ) = 0;
+	virtual int				PauseResourcePreloading() = 0;
-	virtual int				ResumeResourcePreloading( void ) = 0;
+	virtual int				ResumeResourcePreloading() = 0;
-	virtual int				SetVBuf( FileHandle_t stream, char *buffer, int mode, long size ) = 0;
+	virtual int				SetVBuf(FileHandle_t stream, char *buffer, int mode, long size) = 0;
-	virtual void			GetInterfaceVersion( char *p, int maxlen ) = 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;
+	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 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

reapi/include/cssdk/public/basetypes.h

@@ -1,9 +1,30 @@
-//========= Copyright  1996-2001, Valve LLC, All rights reserved. ============
+/*
-//
+*
-// Purpose: 
+*    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
-// $NoKeywords: $
+*    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)
+	(((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
 
 #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<unsigned long*>(&f);
-}
-
-inline unsigned long const& FloatBits(vec_t const& f)
-{
-	return *reinterpret_cast<unsigned long const*>(&f);
-}
-
-inline vec_t BitsToFloat(unsigned long i)
-{
-	return *reinterpret_cast<vec_t*>(&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 <math.h>
-// 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;
+	int      x, y, width, height;
-	vrect_t			*pnext;
+	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<DummyType> MakeHandle(HANDLE_TYPE val)
-	{
-		return CIntHandle16<DummyType>(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<DummyType> MakeHandle(HANDLE_TYPE val)
-	{
-		return CIntHandle32<DummyType>(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

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 == nullptr)
-	if (name == NULL)
 	{
 		// 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
-//static hlds_run wants to use this function 
+void *Sys_GetProcAddress(const char *pModuleName, const char *pName)
-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
-// hlds_run wants to use this function 
+void *Sys_GetProcAddress(void *pModuleHandle, const char *pName)
-void *Sys_GetProcAddress( void *pModuleHandle, const char *pName )
 {
-#if defined ( _WIN32 )
+	return GetProcAddress((HMODULE)pModuleHandle, pName);
-	return GetProcAddress( (HINSTANCE)pModuleHandle, pName );
-#else
-	return GetProcAddress( pModuleHandle, pName );
-#endif
 }
 
-//-----------------------------------------------------------------------------
 // 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 )
+#ifdef _WIN32
-	HMODULE hDLL = LoadLibrary( pModuleName );
+	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 ) );
+		_snprintf(szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/%s", szCwd, pModuleName);
-		if ( szCwd[ strlen( szCwd ) - 1 ] == '/' )
+		hDLL = dlopen(szAbsoluteModuleName, RTLD_NOW);
-			szCwd[ strlen( szCwd ) - 1 ] = 0;
-
-		_snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s/%s", szCwd, pModuleName );
-
-		hDLL = dlopen( szAbsoluteModuleName, RTLD_NOW );
 	}
 	else
 	{
-		_snprintf( szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s", pModuleName );
+		_snprintf(szAbsoluteModuleName, sizeof(szAbsoluteModuleName), "%s", pModuleName);
-		 hDLL = dlopen( pModuleName, RTLD_NOW );
+		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 );
+#if defined(_WIN32)
-		hDLL = LoadLibrary( str );
+		_snprintf(str, sizeof(str), "%s.dll", pModuleName);
+		hDLL = LoadLibrary(str);
 #elif defined(OSX)
-		printf("Error:%s\n",dlerror());
+		printf("Error: %s\n", dlerror());
-		_snprintf( str, sizeof(str), "%s.dylib", szAbsoluteModuleName );
+		_snprintf(str, sizeof(str), "%s.dylib", szAbsoluteModuleName);
-		hDLL = dlopen(str, RTLD_NOW);		
+		hDLL = dlopen(str, RTLD_NOW);
 #else
-		printf("Error:%s\n",dlerror());
+		printf("Error: %s\n", dlerror());
-		_snprintf( str, sizeof(str), "%s.so", szAbsoluteModuleName );
+		_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<CSysModule *>(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<HMODULE>(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 )
+	if (!pModule)
-		return NULL;
+		return nullptr;
 
-	HMODULE	hDLL = reinterpret_cast<HMODULE>(pModule);
+	return reinterpret_cast<CreateInterfaceFn>(Sys_GetProcAddress(pModule, CREATEINTERFACE_PROCNAME));
-#if defined ( _WIN32 )
-	return reinterpret_cast<CreateInterfaceFn>(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
 }
 
-
-
-//-----------------------------------------------------------------------------
 // Purpose: returns the instance of this module
-// Output : interface_instance_t
+// Output : CreateInterfaceFn
-//-----------------------------------------------------------------------------
+CreateInterfaceFn Sys_GetFactoryThis()
-CreateInterfaceFn Sys_GetFactoryThis( void )
 {
-#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
+// Output : CreateInterfaceFn - instance of that module
-//-----------------------------------------------------------------------------
+CreateInterfaceFn Sys_GetFactory(const char *pModuleName)
-CreateInterfaceFn Sys_GetFactory( const char *pModuleName )
 {
-#if defined ( _WIN32 )
+	return reinterpret_cast<CreateInterfaceFn>(Sys_GetProcAddress(pModuleName, CREATEINTERFACE_PROCNAME));
-	return static_cast<CreateInterfaceFn>( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) );
+}
-#else
+
-// Linux gives this error:
+// Purpose: finds a particular interface in the factory set
-//../public/interface.cpp: In function `IBaseInterface *(*Sys_GetFactory 
+void *InitializeInterface(char const *interfaceName, CreateInterfaceFn *factoryList, int numFactories)
-//(const char *)) (const char *, int *)':
+{
-//../public/interface.cpp:186: invalid static_cast from type `void *' to 
+	void *retval;
-//type `IBaseInterface *(*) (const char *, int *)'
+
-//
+	for (int i = 0; i < numFactories; i++)
-// so lets use the old style cast.
+	{
-	return (CreateInterfaceFn)( Sys_GetProcAddress( pModuleName, CREATEINTERFACE_PROCNAME ) );
+		CreateInterfaceFn factory = factoryList[ i ];
-#endif
+		if (!factory)
+			continue;
+
+		retval = factory(interfaceName, nullptr);
+		if (retval)
+			return retval;
+	}
+
+	// No provider for requested interface!!!
+	// assert(!"No provider for requested interface!!!");
+
+	return nullptr;
 }

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 
+// 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 
+//    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
+#pragma once
-//#include "tier1/interface.h"
-//#else
 
-#ifndef INTERFACE_H
+#ifndef _WIN32
-#define INTERFACE_H
 
-#if !defined ( _WIN32 )
+#include <dlfcn.h> // dlopen, dlclose, et al
-
-#include <dlfcn.h> // dlopen,dlclose, et al
 #include <unistd.h>
 
 #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* (*CreateInterfaceFn)(const char *pName, int *pReturnCode);
+typedef IBaseInterface *(*InstantiateInterfaceFn)();
-
-
-typedef IBaseInterface* (*InstantiateInterfaceFn)();
-
 
 // Used internally to register classes.
 class InterfaceReg
@@ -60,19 +50,18 @@ public:
 
 public:
 
-	InstantiateInterfaceFn	m_CreateFn;
+	InstantiateInterfaceFn m_CreateFn;
-	const char				*m_pName;
+	const char             *m_pName;
 
-	InterfaceReg			*m_pNext; // For the global list.
+	InterfaceReg           *m_pNext; // For the global list.
-	static InterfaceReg		*s_pInterfaceRegs;
+	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) \
+#define EXPOSE_INTERFACE(className, interfaceName, versionName)\
-	static IBaseInterface* __Create##className##_interface() {return (interfaceName *)new className;}\
+	static IBaseInterface *__Create##className##_interface() {return (interfaceName *)new className;}\
-	static InterfaceReg __g_Create##className##_reg(__Create##className##_interface, versionName );
+	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) \
+#define EXPOSE_SINGLE_INTERFACE_GLOBALVAR(className, interfaceName, versionName, globalVarName)\
-	static IBaseInterface* __Create##className##interfaceName##_interface() {return (IBaseInterface *)&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")))
+	#define EXPORT_FUNCTION __attribute__((visibility("default"))) EXT_FUNC
-#endif
+#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 CSysModule			*Sys_LoadModule( const char *pModuleName );
+extern void Sys_UnloadModule(CSysModule *pModule);
-extern void					Sys_UnloadModule( CSysModule *pModule );
+extern CreateInterfaceFn Sys_GetFactory(CSysModule *pModule);
-
+extern void *InitializeInterface(char const *interfaceName, CreateInterfaceFn *factoryList, int numFactories);
-extern CreateInterfaceFn	Sys_GetFactory( CSysModule *pModule );
-
-
-#endif
-//#endif // MSVC 6.0
-
-

reapi/include/cssdk/public/protected_things.h

@@ -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

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 <size_t size>
+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 size>
+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;
+}

reapi/include/cssdk/public/tier0/dbg.cpp

@@ -432,4 +432,4 @@ void* Plat_SimpleLog(const char* file, int line)
 	fclose(f);
 
 	return NULL;
-}
+}

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 <math.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -450,4 +449,4 @@ private:
 //#endif
 //#endif
 
-#endif /* DBG_H */
+#endif /* DBG_H */

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.
+*    This program is free software; you can redistribute it and/or modify it
-// The contents may be used and/or copied only with the written permission of
+*    under the terms of the GNU General Public License as published by the
-// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+*    Free Software Foundation; either version 2 of the License, or (at
-// the agreement/contract under which the contents have been supplied.
+*    your option) any later version.
-//
+*
-// $Header: $
+*    This program is distributed in the hope that it will be useful, but
-// $NoKeywords: $
+*    WITHOUT ANY WARRANTY; without even the implied warranty of
-//
+*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Extremely low-level platform-specific stuff
+*    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 <malloc.h>			// need this for _alloca
-#include <malloc.h>
+#include <string.h>			// need this for memset
-
-// need this for memset
-#include <string.h>
 
 #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 <limits.h>
-#include <float.h>
-
-// 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 )
+#define EXPORT	__declspec(dllexport)
-#else 
+#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_EXPORT extern "C" __declspec(dllexport)
-#define  DLL_IMPORT   extern "C" __declspec( dllimport )
+#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_EXPORT __declspec(dllexport)
-#define  DLL_CLASS_IMPORT   __declspec( dllimport )
+#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_EXPORT extern __declspec(dllexport)
-#define  DLL_GLOBAL_IMPORT   extern __declspec( dllimport )
+#define DLL_GLOBAL_IMPORT extern __declspec(dllimport)
 #elif defined __linux__
 
 // Used for dll exporting and importing
-#define  DLL_EXPORT   extern "C" 
+#define DLL_EXPORT extern "C"
-#define  DLL_IMPORT   extern "C" 
+#define DLL_IMPORT extern "C"
 
 // Can't use extern "C" when DLL exporting a class
-#define  DLL_CLASS_EXPORT   
+#define DLL_CLASS_EXPORT
-#define  DLL_CLASS_IMPORT  
+#define DLL_CLASS_IMPORT
 
 // Can't use extern "C" when DLL exporting a global
-#define  DLL_GLOBAL_EXPORT   extern
+#define DLL_GLOBAL_EXPORT extern
-#define  DLL_GLOBAL_IMPORT   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 <typename T>
-inline T WordSwapC(T w)
-{
-	uint16 temp;
-
-	temp = ((*((uint16 *)&w) & 0xff00) >> 8);
-	temp |= ((*((uint16 *)&w) & 0x00ff) << 8);
-
-	return *((T*)&temp);
-}
-
-template <typename T>
-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 <typename T>
-inline T WordSwapAsm(T w)
-{
-	__asm
-	{
-		mov ax, w
-			xchg al, ah
-	}
-}
-
-template <typename T>
-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>(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 <class T>
-inline void Construct(T* pMemory)
+inline void Construct(T *pMemory)
 {
-	new(pMemory)T;
+	new(pMemory) T;
 }
 
 template <class T>
-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 <class T>
-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<int argument>
-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<const int nArgument>											\
-struct __Function_##NAME												\
-{																		\
-	static RETURN_TYPE FASTCALL Run ARGS;								\
-};																		\
-																		\
-template <int i>														\
-struct __MetaLooper_##NAME : __MetaLooper_##NAME<i-1>					\
-{																		\
-	__Type_##NAME func;													\
-	inline __MetaLooper_##NAME() { func = __Function_##NAME<i>::Run; }	\
-};																		\
-																		\
-template<>																\
-struct __MetaLooper_##NAME<0>											\
-{																		\
-	__Type_##NAME func;													\
-	inline __MetaLooper_##NAME() { func = __Function_##NAME<0>::Run; }	\
-};																		\
-																		\
-class NAME																\
-{																		\
-private:																\
-    static const __MetaLooper_##NAME<COUNT> m;							\
-public:																	\
-	enum { count = COUNT };												\
-	static const __Type_##NAME* functions;								\
-};																		\
-const __MetaLooper_##NAME<COUNT> NAME::m;								\
-const __Type_##NAME* NAME::functions = (__Type_##NAME*)&m;				\
-template<int nArgument>													\
-RETURN_TYPE FASTCALL __Function_##NAME<nArgument>::Run ARGS						
-
-
-#define LOOP_INTERCHANGE(BOOLEAN, CODE)\
-	if( (BOOLEAN) )\
-		{\
-		CODE;\
-		} else\
-	{\
-		CODE;\
-	}
-
-
-#endif /* PLATFORM_H */

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 <class T> 
-inline void Construct(T *pMemory)
-{
-	::new(pMemory) T;
-}
-
-template <class T> 
-inline void CopyConstruct(T *pMemory,T const& src)
-{
-	::new(pMemory) T(src);
-}
-
-template <class T> 
-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, class I = int>
-template< class T >
 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&			Element(I i);
-	T const& operator[](int i) const;
+	T const&	Element(I i) const;
-	T& Element(int i);
+	T&			operator[](I i);
-	T const& Element(int i) const;
+	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 *Base();
-	T const* Base() const;
+	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, class I>
-template< class T >
+CUtlMemory<T, I>::CUtlMemory(int nGrowSize, int nInitSize) : m_pMemory(0),
-CUtlMemory<T>::CUtlMemory(int nGrowSize, int nInitAllocationCount) : m_pMemory(0),
+m_nAllocationCount(nInitSize), m_nGrowSize(nGrowSize)
-m_nAllocationCount(nInitAllocationCount), 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 >
+template <class T, class I>
-CUtlMemory<T>::CUtlMemory(T* pMemory, int numElements) : m_pMemory(pMemory),
+CUtlMemory<T, I>::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 >
+template <class T, class I>
-CUtlMemory<T>::~CUtlMemory()
+CUtlMemory<T, I>::~CUtlMemory()
 {
 	Purge();
 }
 
+template <class T, class I>
+void CUtlMemory<T,I>::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, class I>
-template< class T >
+void CUtlMemory<T, I>::SetExternalBuffer(T *pMemory, int numElements)
-void CUtlMemory<T>::SetExternalBuffer(T* pMemory, int numElements)
 {
 	// Blow away any existing allocated memory
 	Purge();
@@ -166,110 +170,91 @@ void CUtlMemory<T>::SetExternalBuffer(T* pMemory, int numElements)
 	m_nGrowSize = EXTERNAL_BUFFER_MARKER;
 }
 
-
-//-----------------------------------------------------------------------------
 // element access
-//-----------------------------------------------------------------------------
+template <class T, class I>
-template< class T >
+inline T& CUtlMemory<T, I>::operator[](I i)
-inline T& CUtlMemory<T>::operator[](int i)
 {
 	Assert(IsIdxValid(i));
 	return m_pMemory[i];
 }
 
-template< class T >
+template <class T, class I>
-inline T const& CUtlMemory<T>::operator[](int i) const
+inline T const& CUtlMemory<T, I>::operator[](I i) const
 {
 	Assert(IsIdxValid(i));
 	return m_pMemory[i];
 }
 
-template< class T >
+template <class T, class I>
-inline T& CUtlMemory<T>::Element(int i)
+inline T& CUtlMemory<T, I>::Element(I i)
 {
 	Assert(IsIdxValid(i));
 	return m_pMemory[i];
 }
 
-template< class T >
+template <class T, class I>
-inline T const& CUtlMemory<T>::Element(int i) const
+inline T const& CUtlMemory<T, I>::Element(I i) const
 {
 	Assert(IsIdxValid(i));
 	return m_pMemory[i];
 }
 
-
-//-----------------------------------------------------------------------------
 // is the memory externally allocated?
-//-----------------------------------------------------------------------------
+template <class T, class I>
-template< class T >
+bool CUtlMemory<T, I>::IsExternallyAllocated() const
-bool CUtlMemory<T>::IsExternallyAllocated() const
 {
 	return m_nGrowSize == EXTERNAL_BUFFER_MARKER;
 }
 
-
+template <class T, class I>
-template< class T >
+void CUtlMemory<T, I>::SetGrowSize(int nSize)
-void CUtlMemory<T>::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, class I>
-template< class T >
+inline T *CUtlMemory<T, I>::Base()
-inline T* CUtlMemory<T>::Base()
 {
 	return m_pMemory;
 }
 
-template< class T >
+template <class T, class I>
-inline T const* CUtlMemory<T>::Base() const
+inline T const *CUtlMemory<T, I>::Base() const
 {
 	return m_pMemory;
 }
 
-
-//-----------------------------------------------------------------------------
 // Size
-//-----------------------------------------------------------------------------
+template <class T, class I>
-template< class T >
+inline int CUtlMemory<T, I>::NumAllocated() const
-inline int CUtlMemory<T>::NumAllocated() const
 {
 	return m_nAllocationCount;
 }
 
-template< class T >
+template <class T, class I>
-inline int CUtlMemory<T>::Count() const
+inline int CUtlMemory<T, I>::Count() const
 {
 	return m_nAllocationCount;
 }
 
-
-//-----------------------------------------------------------------------------
 // Is element index valid?
-//-----------------------------------------------------------------------------
+template <class T, class I>
-template< class T >
+inline bool CUtlMemory<T, I>::IsIdxValid(I i) const
-inline bool CUtlMemory<T>::IsIdxValid(int i) const
 {
-	return (i >= 0) && (i < m_nAllocationCount);
+	return (((int)i) >= 0) && (((int) i) < m_nAllocationCount);
 }
 
-
-//-----------------------------------------------------------------------------
 // Grows the memory
-//-----------------------------------------------------------------------------
+template <class T, class I>
-template< class T >
+void CUtlMemory<T, I>::Grow(int num)
-void CUtlMemory<T>::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<T>::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, class I>
-template< class T >
+inline void CUtlMemory<T, I>::EnsureCapacity(int num)
-inline void CUtlMemory<T>::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<T>::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, class I>
-template< class T >
+void CUtlMemory<T, I>::Purge()
-void CUtlMemory<T>::Purge()
 {
 	if (!IsExternallyAllocated())
 	{
 		if (m_pMemory)
 		{
-			free((void*)m_pMemory);
+			free((void *)m_pMemory);
 			m_pMemory = 0;
 		}
 		m_nAllocationCount = 0;
 	}
 }
-
-#endif // UTLMEMORY_H

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_entity",     is_entity     },
-	{ "is_rehlds",    is_rehlds    },
+	{ "is_rehlds",     is_rehlds     },
-	{ "is_regamedll", is_regamedll },
+	{ "is_regamedll",  is_regamedll  },
-	{ "has_reunion",  has_reunion  },
+	{ "has_reunion",   has_reunion   },
-	{ "has_vtc",      has_vtc      },
+	{ "has_vtc",       has_vtc       },
+	{ "has_rechecker", has_rechecker },
 };
 
 void RegisterNatives_Common()

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<ScenarioEventEndRound>(params[arg_event]);
 
-	_sentence = getAmxString(amx, params[arg_sentence]);
+	char sentence[190], message[190];
-	_message = getAmxString(amx, params[arg_message]);
+	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)
+		if (strcmp(sentence, "default") == 0)
-			_sentence = lst.sentence;
+			Q_strlcpy(sentence, lst.sentence);
-		if (strcmp(_message, "default") == 0)
+		if (strcmp(message, "default") == 0)
-			_message = lst.msg;
+			Q_strlcpy(message, lst.msg);
 	}
 
-	if (_sentence[0])
+	if (sentence[0] != '\0')
-		Broadcast(_sentence);
+	{
+		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;
 }
 

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]);
 }
 
 /*