Added support clang

.gitignore

@@ -7,4 +7,5 @@ msvc/*.suo
 msvc/*.aps
 msvc/Server*.bat
 msvc/ipch
+publish
 PublishPath*.txt

Makefile

@@ -1,24 +1,25 @@
 NAME = refreelook
-COMPILER = /opt/intel/bin/icpc
+COMPILER = clang
 CSSDK = include/cssdk
 
 OBJECTS = src/main.cpp src/meta_api.cpp src/h_export.cpp src/amxxmodule.cpp src/mod_regamedll_api.cpp\
 	src/sdk_util.cpp $(CSSDK)/public/interface.cpp\
 
-LINK = -lm -ldl -static-intel -static-libgcc -no-intel-extensions
+LINK = -lm -ldl -static-libgcc -Wno-return-type-c-linkage -fPIC
 
 METAMOD = include/metamod
 
-OPT_FLAGS = -O3 -msse3 -no-prec-div -funroll-loops -fomit-frame-pointer -fno-stack-protector -g
+OPT_FLAGS = -O3 -msse3 -funroll-loops -fomit-frame-pointer -fno-stack-protector -g -fwritable-strings -Wreturn-type-c-linkage
 
-INCLUDE = -I. -Isrc -I$(CSSDK)/common -I$(CSSDK)//dlls -I$(CSSDK)/engine -I$(CSSDK)/pm_shared -I$(CSSDK)/public -I$(METAMOD)
+INCLUDE = -I. -Isrc -I$(CSSDK)/common -I$(CSSDK)//dlls -I$(CSSDK)/engine -I$(CSSDK)/pm_shared -I$(CSSDK)/public -I$(METAMOD) -I$(CSSDK)/game_shared
 
 BIN_DIR = Release
 CFLAGS = $(OPT_FLAGS)
 
 CFLAGS += -g0 -fvisibility=hidden -DNOMINMAX -fvisibility-inlines-hidden\
-	-DNDEBUG -Dlinux -D__linux__ -std=c++11 -shared -wd147,274 -fasm-blocks\
-	-Qoption,cpp,--treat_func_as_string_literal_cpp -fno-rtti
+	-DNDEBUG -Dlinux -D__linux__ -std=c++11 -shared -fasm-blocks\
+	-fno-rtti -D_bswap16=__builtin_bswap16 -D_bswap=bswap\
+	-D_bswap64=__builtin_bswap64 -D_vsnprintf=vsnprintf
 
 OBJ_LINUX := $(OBJECTS:%.c=$(BIN_DIR)/%.o)
 
@@ -47,4 +48,3 @@ clean:
 	rm -rf Release/*.o
 	rm -rf Release/$(NAME)_amxx_i386.so
 
-

README.md

@@ -66,5 +66,5 @@ Originally created by [Arkshine](https://github.com/Arkshine/AdminFreeLook).
 5. Open your *configs/modules.ini* and add at the end `refreelook`
 6. Configure `mp_forcechasecam` and `mp_forcecamera` gameplay cvars. Both should have the same value.
 7. Make sure `mp_fadetoblack` is set to 0.
-8. Configure `afl_admin_access_flags` and `afl_user_override_mode` modules cvars.
+8. Configure `afl_admin_access_flags` modules cvar.
 9. Start your server.

include/cssdk/dlls/osconfig.h

@@ -111,6 +111,7 @@
 	typedef unsigned int uchar32;
 #endif
 #else // _WIN32
+#ifndef __CLANG_STDINT_H
 	typedef unsigned long long uint64_t;
 	typedef unsigned int uint32_t;
 	typedef unsigned short uint16_t;
@@ -122,7 +123,7 @@
 		typedef short int16_t;
 		typedef char int8_t;
 	#endif
-
+#endif
 	typedef unsigned char byte;
 	typedef unsigned char BYTE;
 	typedef unsigned short uchar16;

include/cssdk/dlls/regamedll_api.h

@@ -30,6 +30,8 @@
 #include "regamedll_interfaces.h"
 #include "hookchains.h"
 #include "interface.h"
+#include "player.h"
+#include "gamerules.h"
 
 #define REGAMEDLL_API_VERSION_MAJOR 2
 #define REGAMEDLL_API_VERSION_MINOR 1
@@ -140,8 +142,8 @@ typedef IVoidHookChain<const char *> IReGameHook_CBasePlayer_GiveNamedItem;
 typedef IVoidHookChainRegistryClass<class CBasePlayer, const char *> IReGameHookRegistry_CBasePlayer_GiveNamedItem;
 
 // CBasePlayer::AddAccount hook
-typedef IVoidHookChain<int, enum RewardType, bool> IReGameHook_CBasePlayer_AddAccount;
-typedef IVoidHookChainRegistryClass<class CBasePlayer, int, enum RewardType, bool> IReGameHookRegistry_CBasePlayer_AddAccount;
+typedef IVoidHookChain<int, RewardType, bool> IReGameHook_CBasePlayer_AddAccount;
+typedef IVoidHookChainRegistryClass<class CBasePlayer, int, RewardType, bool> IReGameHookRegistry_CBasePlayer_AddAccount;
 
 // CBasePlayer::GiveShield hook
 typedef IVoidHookChain<bool> IReGameHook_CBasePlayer_GiveShield;
@@ -173,8 +175,8 @@ typedef IVoidHookChain<class CBasePlayer *, struct entvars_s *, struct entvars_s
 typedef IVoidHookChainRegistry<class CBasePlayer *, struct entvars_s *, struct entvars_s *, Vector &, Vector &, struct TraceResult *> IReGameHookRegistry_RadiusFlash_TraceLine;
 
 // RoundEnd hook
-typedef IHookChain<bool, int, enum ScenarioEventEndRound, float> IReGameHook_RoundEnd;
-typedef IHookChainRegistry<bool, int, enum ScenarioEventEndRound, float> IReGameHookRegistry_RoundEnd;
+typedef IHookChain<bool, int, ScenarioEventEndRound, float> IReGameHook_RoundEnd;
+typedef IHookChainRegistry<bool, int, ScenarioEventEndRound, float> IReGameHookRegistry_RoundEnd;
 
 // CanBuyThis hook
 typedef IHookChain<bool, class CBasePlayer *, int> IReGameHook_CanBuyThis;

include/cssdk/engine/archtypes.h

@@ -24,7 +24,8 @@
 *    you do not wish to do so, delete this exception statement from your
 *    version.
 *
-*/#ifndef ARCHTYPES_H
+*/
+#ifndef ARCHTYPES_H
 #define ARCHTYPES_H
 
 #ifdef __x86_64__
@@ -33,8 +34,6 @@
 
 #if defined( _WIN32 ) && (! defined( __MINGW32__ ))
 
-typedef __int8 int8;
-typedef unsigned __int8 uint8;
 typedef __int16 int16;
 typedef unsigned __int16 uint16;
 typedef __int32 int32;
@@ -45,8 +44,7 @@ typedef __int32 intp;				// intp is an integer that can accomodate a pointer
 typedef unsigned __int32 uintp;		// (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
 
 #else /* _WIN32 */
-typedef char int8;
-typedef unsigned char uint8;
+
 typedef short int16;
 typedef unsigned short uint16;
 typedef int int32;

include/cssdk/public/basetypes.h

@@ -0,0 +1,300 @@
+//========= Copyright  1996-2001, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef BASETYPES_H
+#define BASETYPES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "osconfig.h"
+#include "protected_things.h"
+#include "commonmacros.h"
+
+
+// For backward compatibilty only...
+//#include "tier0/platform.h"
+
+// stdio.h
+#ifndef NULL
+#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)
+
+// 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
+
+#ifdef __cplusplus
+template<typename T>
+inline T clamp2(T const &val, T const &minVal, T const &maxVal) //renamed to clamp2 to avoid conflicts with clamp defined in mathlib
+{
+	if (val < minVal)
+		return minVal;
+	else if (val > maxVal)
+		return maxVal;
+	else
+		return val;
+}
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE (!FALSE)
+#endif
+
+
+typedef int BOOL;
+typedef int qboolean;
+typedef unsigned long ULONG;
+typedef unsigned char BYTE;
+typedef unsigned char byte;
+typedef unsigned short word;
+
+//#include "string_t.h"
+
+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;
+};
+
+#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

include/cssdk/public/commonmacros.h

@@ -0,0 +1,30 @@
+#ifndef COMMONMACROS_H
+#define COMMONMACROS_H
+#pragma once
+
+
+// -------------------------------------------------------
+//
+// commonmacros.h
+//
+// This should contain ONLY general purpose macros that are 
+// appropriate for use in engine/launcher/all tools
+//
+// -------------------------------------------------------
+
+#include "osconfig.h"
+// Makes a 4-byte "packed ID" int out of 4 characters
+#define MAKEID(d,c,b,a)					( ((int)(a) << 24) | ((int)(b) << 16) | ((int)(c) << 8) | ((int)(d)) )
+
+// Compares a string with a 4-byte packed ID constant
+#define STRING_MATCHES_ID( p, id )		( (*((int *)(p)) == (id) ) ? true : false )
+#define ID_TO_STRING( id, p )			( (p)[3] = (((id)>>24) & 0xFF), (p)[2] = (((id)>>16) & 0xFF), (p)[1] = (((id)>>8) & 0xFF), (p)[0] = (((id)>>0) & 0xFF) )
+
+#define ARRAYSIZE(p)		(sizeof(p)/sizeof(p[0]))
+
+// Keeps clutter down a bit, when using a float as a bit-vector
+#define SETBITS(flBitVector, bits)		((flBitVector) = (int)(flBitVector) | (bits))
+#define CLEARBITS(flBitVector, bits)	((flBitVector) = (int)(flBitVector) & ~(bits))
+#define FBitSet(flBitVector, bit)		((flBitVector) & (bit))
+
+#endif		// COMMONMACROS_H

include/cssdk/public/protected_things.h

@@ -0,0 +1,187 @@
+//========= 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

include/cssdk/public/tier0/dbg.cpp

@@ -0,0 +1,444 @@
+//=========== (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: $
+//
+// The main debug library implementation
+//=============================================================================
+
+#include "precompiled.h"
+#include <assert.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include "tier0/dbg.h"
+#include <math.h>
+
+
+
+//-----------------------------------------------------------------------------
+// internal structures
+//-----------------------------------------------------------------------------
+
+#define MAX_GROUP_NAME_LENGTH 48
+//enum
+//{
+//	MAX_GROUP_NAME_LENGTH = 48
+//};
+
+struct SpewGroup_t
+{
+	char	m_GroupName[MAX_GROUP_NAME_LENGTH];
+	int		m_Level;
+};
+
+
+//-----------------------------------------------------------------------------
+// Templates to assist in validating pointers:
+
+void _AssertValidReadPtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!IsBadReadPtr(ptr, count));
+#else
+	Assert(ptr);
+#endif
+
+}
+
+void _AssertValidWritePtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!IsBadWritePtr(ptr, count));
+#else
+	Assert(ptr);
+#endif
+}
+
+void _AssertValidReadWritePtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!(IsBadWritePtr(ptr, count) || IsBadReadPtr(ptr, count)));
+#else
+	Assert(ptr);
+#endif
+}
+
+void AssertValidStringPtr(const char* ptr, int maxchar/* = 0xFFFFFF */)
+{
+#ifdef _WIN32
+	Assert(!IsBadStringPtr(ptr, maxchar));
+#else
+	Assert(ptr);
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// globals
+//-----------------------------------------------------------------------------
+
+SpewRetval_t DefaultSpewFunc(SpewType_t type, char const *pMsg)
+{
+	printf("%s", pMsg);
+	if (type == SPEW_ASSERT)
+		return SPEW_DEBUGGER;
+	else if (type == SPEW_ERROR)
+		return SPEW_ABORT;
+	else
+		return SPEW_CONTINUE;
+}
+
+static SpewOutputFunc_t   s_SpewOutputFunc = DefaultSpewFunc;
+
+static char const*	s_pFileName;
+static int			s_Line;
+static SpewType_t	s_SpewType;
+
+static SpewGroup_t* s_pSpewGroups = 0;
+static int			s_GroupCount = 0;
+static int			s_DefaultLevel = 0;
+
+
+
+//-----------------------------------------------------------------------------
+// Spew output management.
+//-----------------------------------------------------------------------------
+
+void  SpewOutputFunc(SpewOutputFunc_t func)
+{
+	s_SpewOutputFunc = func ? func : DefaultSpewFunc;
+}
+
+SpewOutputFunc_t GetSpewOutputFunc(void)
+{
+	if (s_SpewOutputFunc)
+	{
+		return s_SpewOutputFunc;
+	}
+	else
+	{
+		return DefaultSpewFunc;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Spew functions
+//-----------------------------------------------------------------------------
+
+void  _SpewInfo(SpewType_t type, char const* pFile, int line)
+{
+	// Only grab the file name. Ignore the path.
+	char const* pSlash = strrchr(pFile, '\\');
+	char const* pSlash2 = strrchr(pFile, '/');
+	if (pSlash < pSlash2) pSlash = pSlash2;
+
+	s_pFileName = pSlash ? pSlash + 1 : pFile;
+	s_Line = line;
+	s_SpewType = type;
+}
+
+SpewRetval_t  _SpewMessage(SpewType_t spewType, char const* pMsgFormat, va_list args)
+{
+	char pTempBuffer[1024];
+
+	/* Printf the file and line for warning + assert only... */
+	int len = 0;
+	if ((spewType == SPEW_ASSERT))
+	{
+		len = sprintf(pTempBuffer, "%s (%d) : ", s_pFileName, s_Line);
+	}
+
+	/* Create the message.... */
+	len += vsprintf(&pTempBuffer[len], pMsgFormat, args);
+
+	// Add \n for warning and assert
+	if ((spewType == SPEW_ASSERT))
+	{
+		len += sprintf(&pTempBuffer[len], "\n");
+	}
+
+	assert(len < 1024); /* use normal assert here; to avoid recursion. */
+	assert(s_SpewOutputFunc);
+
+	/* direct it to the appropriate target(s) */
+	SpewRetval_t ret = s_SpewOutputFunc(spewType, pTempBuffer);
+	switch (ret)
+	{
+		// Put the break into the macro so it would occur in the right place
+		//	case SPEW_DEBUGGER:
+		//		DebuggerBreak();
+		//		break;
+
+	case SPEW_ABORT:
+		//		MessageBox(NULL,"Error in _SpewMessage","Error",MB_OK);
+		exit(0);
+	}
+
+	return ret;
+}
+
+SpewRetval_t  _SpewMessage(char const* pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	SpewRetval_t ret = _SpewMessage(s_SpewType, pMsgFormat, args);
+	va_end(args);
+	return ret;
+}
+
+SpewRetval_t _DSpewMessage(char const *pGroupName, int level, char const* pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return SPEW_CONTINUE;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	SpewRetval_t ret = _SpewMessage(s_SpewType, pMsgFormat, args);
+	va_end(args);
+	return ret;
+}
+
+void Msg(char const* pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DMsg(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void Warning(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DWarning(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void Log(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void DLog(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void Error(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_ERROR, pMsgFormat, args);
+	va_end(args);
+}
+
+
+//-----------------------------------------------------------------------------
+// A couple of super-common dynamic spew messages, here for convenience 
+// These looked at the "developer" group, print if it's level 1 or higher 
+//-----------------------------------------------------------------------------
+
+void DevMsg(int level, char const* pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevWarning(int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevLog(int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevMsg(char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", 1))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevWarning(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevLog(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+//-----------------------------------------------------------------------------
+// Find a group, return true if found, false if not. Return in ind the
+// index of the found group, or the index of the group right before where the
+// group should be inserted into the list to maintain sorted order.
+//-----------------------------------------------------------------------------
+
+bool FindSpewGroup(char const* pGroupName, int* pInd)
+{
+	int s = 0;
+	if (s_GroupCount)
+	{
+		int e = (int)(s_GroupCount - 1);
+		while (s <= e)
+		{
+			int m = (s + e) >> 1;
+			int cmp = Q_stricmp(pGroupName, s_pSpewGroups[m].m_GroupName);
+			if (!cmp)
+			{
+				*pInd = m;
+				return true;
+			}
+			if (cmp < 0)
+				e = m - 1;
+			else
+				s = m + 1;
+		}
+	}
+	*pInd = s;
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the priority level for a spew group
+//-----------------------------------------------------------------------------
+
+void SpewActivate(char const* pGroupName, int level)
+{
+	Assert(pGroupName);
+
+	// check for the default group first...
+	if ((pGroupName[0] == '*') && (pGroupName[1] == '\0'))
+	{
+		s_DefaultLevel = level;
+		return;
+	}
+
+	// Normal case, search in group list using binary search.
+	// If not found, grow the list of groups and insert it into the
+	// right place to maintain sorted order. Then set the level.
+	int ind;
+	if (!FindSpewGroup(pGroupName, &ind))
+	{
+		// not defined yet, insert an entry.
+		++s_GroupCount;
+		if (s_pSpewGroups)
+		{
+			s_pSpewGroups = (SpewGroup_t*)realloc(s_pSpewGroups,
+				s_GroupCount * sizeof(SpewGroup_t));
+
+			// shift elements down to preserve order
+			int numToMove = s_GroupCount - ind - 1;
+			memmove(&s_pSpewGroups[ind + 1], &s_pSpewGroups[ind],
+				numToMove * sizeof(SpewGroup_t));
+		}
+		else
+			s_pSpewGroups = (SpewGroup_t*)malloc(s_GroupCount * sizeof(SpewGroup_t));
+
+		Assert(strlen(pGroupName) < MAX_GROUP_NAME_LENGTH);
+		strcpy(s_pSpewGroups[ind].m_GroupName, pGroupName);
+	}
+	s_pSpewGroups[ind].m_Level = level;
+}
+
+
+//-----------------------------------------------------------------------------
+// Tests to see if a particular spew is active
+//-----------------------------------------------------------------------------
+
+bool IsSpewActive(char const* pGroupName, int level)
+{
+	// If we don't find the spew group, use the default level.
+	int ind;
+	if (FindSpewGroup(pGroupName, &ind))
+		return s_pSpewGroups[ind].m_Level >= level;
+	else
+		return s_DefaultLevel >= level;
+}
+
+
+// If we don't have a function from math.h, then it doesn't link certain floating-point
+// functions in and printfs with %f cause runtime errors in the C libraries.
+float CrackSmokingCompiler(float a)
+{
+	return fabs(a);
+}
+
+void* Plat_SimpleLog(const char* file, int line)
+{
+	FILE* f = fopen("simple.log", "at+");
+	fprintf(f, "%s:%i\n", file, line);
+	fclose(f);
+
+	return NULL;
+}

include/cssdk/public/tier0/dbg.h

@@ -0,0 +1,451 @@
+//=========== (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: $
+//
+// The main debug library interfaces
+//=============================================================================
+
+
+#ifndef DBG_H
+#define DBG_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "osconfig.h"
+#include "basetypes.h"
+#include "tier0/platform.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+//-----------------------------------------------------------------------------
+// dll export stuff
+//-----------------------------------------------------------------------------
+
+#ifdef TIER0_DLL_EXPORT
+#define DBG_INTERFACE	DLL_EXPORT
+#define DBG_OVERLOAD	DLL_GLOBAL_EXPORT
+#define DBG_CLASS		DLL_CLASS_EXPORT
+#else
+#define DBG_INTERFACE	DLL_IMPORT
+#define DBG_OVERLOAD	DLL_GLOBAL_IMPORT
+#define DBG_CLASS		DLL_CLASS_IMPORT
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Usage model for the Dbg library
+//
+// 1. Spew.
+// 
+//   Spew can be used in a static and a dynamic mode. The static
+//   mode allows us to display assertions and other messages either only
+//   in debug builds, or in non-release builds. The dynamic mode allows us to
+//   turn on and off certain spew messages while the application is running.
+// 
+//   Static Spew messages:
+//
+//     Assertions are used to detect and warn about invalid states
+//     Spews are used to display a particular status/warning message.
+//
+//     To use an assertion, use
+//
+//     Assert( (f == 5) );
+//     AssertMsg( (f == 5), ("F needs to be %d here!\n", 5) );
+//     AssertFunc( (f == 5), BadFunc() );
+//     AssertEquals( f, 5 );
+//     AssertFloatEquals( f, 5.0f, 1e-3 );
+//
+//     The first will simply report that an assertion failed on a particular
+//     code file and line. The second version will display a print-f formatted message 
+//	   along with the file and line, the third will display a generic message and
+//     will also cause the function BadFunc to be executed, and the last two
+//	   will report an error if f is not equal to 5 (the last one asserts within
+//	   a particular tolerance).
+//
+//     To use a warning, use
+//      
+//     Warning("Oh I feel so %s all over\n", "yummy");
+//
+//     Warning will do its magic in only Debug builds. To perform spew in *all*
+//     builds, use RelWarning.
+//
+//	   Three other spew types, Msg, Log, and Error, are compiled into all builds.
+//	   These error types do *not* need two sets of parenthesis.
+//
+//	   Msg( "Isn't this exciting %d?", 5 );
+//	   Error( "I'm just thrilled" );
+//
+//   Dynamic Spew messages
+//
+//     It is possible to dynamically turn spew on and off. Dynamic spew is 
+//     identified by a spew group and priority level. To turn spew on for a 
+//     particular spew group, use SpewActivate( "group", level ). This will 
+//     cause all spew in that particular group with priority levels <= the 
+//     level specified in the SpewActivate function to be printed. Use DSpew 
+//     to perform the spew:
+//
+//     DWarning( "group", level, "Oh I feel even yummier!\n" );
+//
+//     Priority level 0 means that the spew will *always* be printed, and group
+//     '*' is the default spew group. If a DWarning is encountered using a group 
+//     whose priority has not been set, it will use the priority of the default 
+//     group. The priority of the default group is initially set to 0.      
+//
+//   Spew output
+//   
+//     The output of the spew system can be redirected to an externally-supplied
+//     function which is responsible for outputting the spew. By default, the 
+//     spew is simply printed using printf.
+//
+//     To redirect spew output, call SpewOutput.
+//
+//     SpewOutputFunc( OutputFunc );
+//
+//     This will cause OutputFunc to be called every time a spew message is
+//     generated. OutputFunc will be passed a spew type and a message to print.
+//     It must return a value indicating whether the debugger should be invoked,
+//     whether the program should continue running, or whether the program 
+//     should abort. 
+//
+// 2. Code activation
+//
+//   To cause code to be run only in debug builds, use DBG_CODE:
+//   An example is below.
+//
+//   DBG_CODE(
+//				{
+//					int x = 5;
+//					++x;
+//				}
+//           ); 
+//
+//   Code can be activated based on the dynamic spew groups also. Use
+//  
+//   DBG_DCODE( "group", level,
+//              { int x = 5; ++x; }
+//            );
+//
+// 3. Breaking into the debugger.
+//
+//   To cause an unconditional break into the debugger in debug builds only, use DBG_BREAK
+//
+//   DBG_BREAK();
+//
+//	 You can force a break in any build (release or debug) using
+//
+//	 DebuggerBreak();
+//-----------------------------------------------------------------------------
+
+/* Various types of spew messages */
+// I'm sure you're asking yourself why SPEW_ instead of DBG_ ?
+// It's because DBG_ is used all over the place in windows.h
+// For example, DBG_CONTINUE is defined. Feh.
+enum SpewType_t
+{
+	SPEW_MESSAGE = 0,
+	SPEW_WARNING,
+	SPEW_ASSERT,
+	SPEW_ERROR,
+	SPEW_LOG,
+
+	SPEW_TYPE_COUNT
+};
+
+enum SpewRetval_t
+{
+	SPEW_DEBUGGER = 0,
+	SPEW_CONTINUE,
+	SPEW_ABORT
+};
+
+/* type of externally defined function used to display debug spew */
+typedef SpewRetval_t(*SpewOutputFunc_t)(SpewType_t spewType, char const *pMsg);
+
+/* Used to redirect spew output */
+void   SpewOutputFunc(SpewOutputFunc_t func);
+
+/* Used ot get the current spew output function */
+SpewOutputFunc_t GetSpewOutputFunc(void);
+
+/* Used to manage spew groups and subgroups */
+void   SpewActivate(char const* pGroupName, int level);
+bool   IsSpewActive(char const* pGroupName, int level);
+
+/* Used to display messages, should never be called directly. */
+void   _SpewInfo(SpewType_t type, char const* pFile, int line);
+SpewRetval_t   _SpewMessage(char const* pMsg, ...);
+SpewRetval_t   _DSpewMessage(char const *pGroupName, int level, char const* pMsg, ...);
+
+/* Used to define macros, never use these directly. */
+#define  _Assert( _exp )			do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										if (_SpewMessage("Assertion Failed: " #_exp) == SPEW_DEBUGGER)		\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertMsg( _exp, _msg )	do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										if (_SpewMessage(_msg) == SPEW_DEBUGGER)					\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertFunc( _exp, _f )	do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Assertion Failed!" #_exp);	\
+										_f;															\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertEquals( _exp, _expectedValue ) \
+									do {															\
+									if ((_exp) != (_expectedValue)) 								\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Expected %d but got %d!", (_expectedValue), (_exp));	\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+																											} while (0)
+
+#define  _AssertFloatEquals( _exp, _expectedValue, _tol ) \
+									do {															\
+									if (fabs((_exp) - (_expectedValue)) > (_tol))					\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Expected %f but got %f!", (_expectedValue), (_exp));	\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+																											} while (0)
+
+/* Spew macros... */
+
+#ifdef _DEBUG
+
+#define  Assert( _exp )           _Assert( _exp )
+#define  AssertMsg( _exp, _msg )  _AssertMsg( _exp, _msg )
+#define  AssertFunc( _exp, _f )   _AssertFunc( _exp, _f )
+#define  AssertEquals( _exp, _expectedValue )              _AssertEquals( _exp, _expectedValue ) 
+#define  AssertFloatEquals( _exp, _expectedValue, _tol )   _AssertFloatEquals( _exp, _expectedValue, _tol )
+#define  Verify( _exp )           _Assert( _exp )
+
+#define  AssertMsg1( _exp, _msg, a1 )									_AssertMsg( _exp, CDbgFmtMsg( _msg, a1 ) )
+#define  AssertMsg2( _exp, _msg, a1, a2 )								_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2 ) )
+#define  AssertMsg3( _exp, _msg, a1, a2, a3 )							_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3 ) )
+#define  AssertMsg4( _exp, _msg, a1, a2, a3, a4 )						_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4 ) )
+#define  AssertMsg5( _exp, _msg, a1, a2, a3, a4, a5 )					_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5 ) )
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6 ) )
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6 ) )
+#define  AssertMsg7( _exp, _msg, a1, a2, a3, a4, a5, a6, a7 )			_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7 ) )
+#define  AssertMsg8( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8 )		_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7, a8 ) )
+#define  AssertMsg9( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 )	_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
+
+
+#else /* Not _DEBUG */
+
+#define  Assert( _exp )           ((void)0)
+#define  AssertMsg( _exp, _msg )  ((void)0)
+#define  AssertFunc( _exp, _f )   ((void)0)
+#define  AssertEquals( _exp, _expectedValue )              ((void)0)
+#define  AssertFloatEquals( _exp, _expectedValue, _tol )   ((void)0)
+#define  Verify( _exp )			  (_exp)
+
+#define  AssertMsg1( _exp, _msg, a1 )									((void)0)
+#define  AssertMsg2( _exp, _msg, a1, a2 )								((void)0)
+#define  AssertMsg3( _exp, _msg, a1, a2, a3 )							((void)0)
+#define  AssertMsg4( _exp, _msg, a1, a2, a3, a4 )						((void)0)
+#define  AssertMsg5( _exp, _msg, a1, a2, a3, a4, a5 )					((void)0)
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				((void)0)
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				((void)0)
+#define  AssertMsg7( _exp, _msg, a1, a2, a3, a4, a5, a6, a7 )			((void)0)
+#define  AssertMsg8( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8 )		((void)0)
+#define  AssertMsg9( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 )	((void)0)
+
+#endif   /* _DEBUG */
+
+
+
+/* These are always compiled in */
+void Msg(char const* pMsg, ...);
+void DMsg(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Warning(char const *pMsg, ...);
+void DWarning(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Log(char const *pMsg, ...);
+void DLog(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Error(char const *pMsg, ...);
+
+// You can use this macro like a runtime assert macro.
+// If the condition fails, then Error is called with the message. This macro is called
+// like AssertMsg, where msg must be enclosed in parenthesis:
+//
+// ErrorIfNot( bCondition, ("a b c %d %d %d", 1, 2, 3) );
+#define ErrorIfNot( condition, msg ) \
+	if ( (condition) )		\
+		;					\
+				else 					\
+	{						\
+		Error msg;			\
+	}
+
+/* A couple of super-common dynamic spew messages, here for convenience */
+/* These looked at the "developer" group */
+void DevMsg(int level, char const* pMsg, ...);
+void DevWarning(int level, char const *pMsg, ...);
+void DevLog(int level, char const *pMsg, ...);
+
+/* default level versions (level 1) */
+void DevMsg(char const* pMsg, ...);
+void DevWarning(char const *pMsg, ...);
+void DevLog(char const *pMsg, ...);
+
+/* Code macros, debugger interface */
+
+#ifdef _DEBUG
+
+#define DBG_CODE( _code )            if (0) ; else { _code }
+#define DBG_DCODE( _g, _l, _code )   if (IsSpewActive( _g, _l )) { _code } else {}
+#define DBG_BREAK()                  DebuggerBreak()	/* defined in platform.h */ 
+
+#else /* not _DEBUG */
+
+#define DBG_CODE( _code )            ((void)0)
+#define DBG_DCODE( _g, _l, _code )   ((void)0)
+#define DBG_BREAK()                  ((void)0)
+
+#endif /* _DEBUG */
+
+//-----------------------------------------------------------------------------
+// Macro to assist in asserting constant invariants during compilation
+
+#define UID_PREFIX generated_id_
+#define UID_CAT1(a,c) a ## c
+#define UID_CAT2(a,c) UID_CAT1(a,c)
+#define UNIQUE_ID UID_CAT2(UID_PREFIX,__LINE__)
+
+
+#ifdef _DEBUG
+#define COMPILE_TIME_ASSERT( pred )	switch(0){case 0:case pred:;}
+#define ASSERT_INVARIANT( pred )	static void UNIQUE_ID() { COMPILE_TIME_ASSERT( pred ) }
+#else
+#define COMPILE_TIME_ASSERT( pred )
+#define ASSERT_INVARIANT( pred )
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Templates to assist in validating pointers:
+
+// Have to use these stubs so we don't have to include windows.h here.
+void _AssertValidReadPtr(void* ptr, int count = 1);
+void _AssertValidWritePtr(void* ptr, int count = 1);
+void _AssertValidReadWritePtr(void* ptr, int count = 1);
+
+ void AssertValidStringPtr(const char* ptr, int maxchar = 0xFFFFFF);
+template<class T> inline void AssertValidReadPtr(T* ptr, int count = 1)		     { _AssertValidReadPtr((void*)ptr, count); }
+template<class T> inline void AssertValidWritePtr(T* ptr, int count = 1)		     { _AssertValidWritePtr((void*)ptr, count); }
+template<class T> inline void AssertValidReadWritePtr(T* ptr, int count = 1)	     { _AssertValidReadWritePtr((void*)ptr, count); }
+
+#define AssertValidThis() AssertValidReadWritePtr(this,sizeof(*this))
+
+//-----------------------------------------------------------------------------
+// Macro to protect functions that are not reentrant
+
+#ifdef _DEBUG
+class CReentryGuard
+{
+public:
+	CReentryGuard(int *pSemaphore)
+		: m_pSemaphore(pSemaphore)
+	{
+		++(*m_pSemaphore);
+	}
+
+	~CReentryGuard()
+	{
+		--(*m_pSemaphore);
+	}
+
+private:
+	int *m_pSemaphore;
+};
+
+#define ASSERT_NO_REENTRY() \
+	static int fSemaphore##__LINE__; \
+	Assert( !fSemaphore##__LINE__ ); \
+	CReentryGuard ReentryGuard##__LINE__( &fSemaphore##__LINE__ )
+#else
+#define ASSERT_NO_REENTRY()
+#endif
+
+//-----------------------------------------------------------------------------
+//
+// Purpose: Inline string formatter
+//
+
+class CDbgFmtMsg
+{
+public:
+	CDbgFmtMsg(const char *pszFormat, ...)
+	{
+		va_list arg_ptr;
+
+		va_start(arg_ptr, pszFormat);
+		_vsnprintf(m_szBuf, sizeof(m_szBuf) - 1, pszFormat, arg_ptr);
+		va_end(arg_ptr);
+
+		m_szBuf[sizeof(m_szBuf) - 1] = 0;
+	}
+
+	operator const char *() const
+	{
+		return m_szBuf;
+	}
+
+private:
+	char m_szBuf[256];
+};
+
+//-----------------------------------------------------------------------------
+//
+// Purpose: Embed debug info in each file.
+//
+//#ifdef _WIN32
+//#ifdef _DEBUG
+//#pragma comment(compiler)
+//#pragma comment(exestr,"*** DEBUG file detected, Last Compile: " __DATE__ ", " __TIME__ " ***")
+//#endif
+//#endif
+
+#endif /* DBG_H */

include/cssdk/public/tier0/platform.h

@@ -0,0 +1,651 @@
+//=========== (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
+//=============================================================================
+
+
+#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>
+
+// for when we care about how many bits we use
+typedef signed char      int8;
+typedef signed short     int16;
+
+#ifdef _WIN32
+#ifdef _MSC_VER
+typedef signed __int64   int64;
+#endif
+#elif defined __linux__
+typedef long long	int64;
+#endif
+
+typedef unsigned char      uint8;
+typedef unsigned short     uint16;
+#ifdef _WIN32
+#ifdef _MSC_VER
+typedef unsigned __int64   uint64;
+#endif
+#elif defined __linux__
+typedef unsigned long long uint64;
+#endif
+
+
+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_t)~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
+#endif
+
+// Used to step into the debugger
+#define  DebuggerBreak()  __asm { int 3 }
+
+// C functions for external declarations that call the appropriate C++ methods
+#ifndef EXPORT
+#ifdef _WIN32
+#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 )
+
+// Can't use extern "C" when DLL exporting a class
+#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 )
+#elif defined __linux__
+
+// Used for dll exporting and importing
+#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  
+
+// Can't use extern "C" when DLL exporting a global
+#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
+#pragma warning(disable : 4100) // warning C4100: 'hwnd' : unreferenced formal parameter
+#pragma warning(disable : 4127) // warning C4127: conditional expression is constant
+#pragma warning(disable : 4512) // warning C4512: 'InFileRIFF' : assignment operator could not be generated
+#pragma warning(disable : 4611) // warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable
+#pragma warning(disable : 4706) // warning C4706: assignment within conditional expression
+#pragma warning(disable : 4710) // warning C4710: function 'x' not inlined
+#pragma warning(disable : 4702) // warning C4702: unreachable code
+#pragma warning(disable : 4505) // unreferenced local function has been removed
+#pragma warning(disable : 4239) // nonstandard extension used : 'argument' ( conversion from class Vector to class Vector& )
+#pragma warning(disable : 4097) // typedef-name 'BaseClass' used as synonym for class-name 'CFlexCycler::CBaseFlex'
+#pragma warning(disable : 4324) // Padding was added at the end of a structure
+#pragma warning(disable : 4244) // type conversion warning.
+#pragma warning(disable : 4305)	// truncation from 'const double ' to 'float '
+#pragma warning(disable : 4786)	// Disable warnings about long symbol names
+
+#if _MSC_VER >= 1300
+#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_t temp;
+	
+	temp = *((uint32_t *)&dw) >> 24;
+	temp |= ((*((uint32_t *)&dw) & 0x00FF0000) >> 8);
+	temp |= ((*((uint32_t *)&dw) & 0x0000FF00) << 8);
+	temp |= ((*((uint32_t *)&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_t BigDWord(uint32_t 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_t LittleDWord(uint32_t 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)
+{
+	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
+}
+
+
+//
+// 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 */

include/cssdk/public/utlmemory.h

@@ -34,6 +34,7 @@
 #endif
 
 #include "osconfig.h"
+#include "tier0/dbg.h"
 #include <string.h>
 
 #pragma warning (disable:4100)

msvc/refreelook.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.21005.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "refreelook", "refreelook.vcxproj", "{9A72E8DC-7667-46C1-899D-1E8B939564D2}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9A72E8DC-7667-46C1-899D-1E8B939564D2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9A72E8DC-7667-46C1-899D-1E8B939564D2}.Debug|Win32.Build.0 = Debug|Win32
+		{9A72E8DC-7667-46C1-899D-1E8B939564D2}.Release|Win32.ActiveCfg = Release|Win32
+		{9A72E8DC-7667-46C1-899D-1E8B939564D2}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal