reHLDS/reapi
2
0
Fork 0
mirror of https://github.com/rehlds/reapi.git synced 2025-02-05 18:20:36 +03:00
Code Issues Projects Releases Wiki Activity

Refactoring cssdk

Browse Source 
Fix some things
This commit is contained in:
s1lent 2017-09-24 19:54:49 +07:00
parent 6e8895bed9
commit 30a51e6102
No known key found for this signature in database
GPG Key ID: 0FE401DC73916B5C
17 changed files with 724 additions and 1546 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
gradlew vendored Normal file → Executable file
View File

8
reapi/extra/amxmodx/scripting/include/reapi.inc
View File

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

2
reapi/include/cssdk/dlls/extdll.h
View File

@ -36,7 +36,7 @@
#include "archtypes.h"
#include "maintypes.h"
#include "regamedll_common.h"
#include "strtools.h"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN

96
reapi/include/cssdk/dlls/regamedll_common.h
View File

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

190
reapi/include/cssdk/public/FileSystem.h
View File

@ -1,32 +1,54 @@
//========= Copyright <20> 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 <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,
// 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
// 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,
// 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;
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;
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

272
reapi/include/cssdk/public/basetypes.h
View File

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

321
reapi/include/cssdk/public/interface.cpp
View File

@ -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 )
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 )
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 );
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<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()
// *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<HMODULE>(pModule);
#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
return reinterpret_cast<CreateInterfaceFn>(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<CreateInterfaceFn>( 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<CreateInterfaceFn>(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;
}

89
reapi/include/cssdk/public/interface.h
View File

@ -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.
@ -14,16 +13,11 @@
// 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 <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* (*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,30 +69,28 @@ 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
@ -114,37 +101,23 @@ enum
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);

187
reapi/include/cssdk/public/protected_things.h
View File

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

211
reapi/include/cssdk/public/strtools.h Normal file
View File

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

3
reapi/include/cssdk/public/tier0/dbg.h
View File

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

595
reapi/include/cssdk/public/tier0/platform.h
View File

@ -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 <malloc.h>
// need this for memset
#include <string.h>
#include <malloc.h> // need this for _alloca
#include <string.h> // 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 <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
#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 <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 */

207
reapi/include/cssdk/public/utlmemory.h
View File

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

27
reapi/src/natives/natives_common.cpp
View File

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

26
reapi/src/natives/natives_misc.cpp
View File

@ -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]);
_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;
}

4
reapi/src/natives/natives_rechecker.cpp
View File

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