source/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-12-07 10:38:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Minor fixups

Browse Source
This commit is contained in:
GAMMACASE 2023-11-19 16:05:18 +03:00
parent bf82ba994d
commit dc3346780d
6 changed files with 90 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
public/tier1/KeyValues.h
View File

@ -377,7 +377,7 @@ public:
KeyValues *Element( int nIndex ) const; KeyValues *Element( int nIndex ) const;
CKeyValues_Data::types_t GetDataType( const char *keyName = NULL ); CKeyValues_Data::types_t GetDataType( const char *keyName = NULL ) const;
// unpack a key values list into a structure // unpack a key values list into a structure
void UnpackIntoStructure( struct KeyValuesUnpackStructure const *pUnpackTable, void *pDest ); void UnpackIntoStructure( struct KeyValuesUnpackStructure const *pUnpackTable, void *pDest );

5
public/tier1/mempool.h
View File

@ -85,12 +85,13 @@ protected:
int m_GrowMode; // GROW_ enum. int m_GrowMode; // GROW_ enum.
// FIXME: Change m_ppMemBlob into a growable array?
void *m_pHeadOfFreeList;
int m_BlocksAllocated; int m_BlocksAllocated;
int m_PeakAlloc; int m_PeakAlloc;
unsigned short m_nAlignment; unsigned short m_nAlignment;
unsigned short m_NumBlobs; unsigned short m_NumBlobs;
// FIXME: Change m_ppMemBlob into a growable array?
void *m_pHeadOfFreeList;
const char * m_pszAllocOwner; const char * m_pszAllocOwner;
// CBlob could be not a multiple of 4 bytes so stuff it at the end here to keep us otherwise aligned // CBlob could be not a multiple of 4 bytes so stuff it at the end here to keep us otherwise aligned
CBlob m_BlobHead; CBlob m_BlobHead;

162
public/tier1/utldelegateimpl.h
View File

@ -141,8 +141,7 @@
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace utldelegate // we'll hide the implementation utldelegates in a nested namespace.
namespace detail // we'll hide the implementation details in a nested namespace.
{ {
// implicit_cast< > // implicit_cast< >
@ -537,7 +536,7 @@ struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 3*sizeof(int) >
#endif // MS/Intel hacks #endif // MS/Intel hacks
} // namespace detail } // namespace utldelegate
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Fast Delegates, part 2: // Fast Delegates, part 2:
@ -590,8 +589,8 @@ class CUtlAbstractDelegate
protected: protected:
// the data is protected, not private, because many // the data is protected, not private, because many
// compilers have problems with template friends. // compilers have problems with template friends.
typedef void (detail::GenericClass::*GenericMemFuncType)(); // arbitrary MFP. typedef void (utldelegate::GenericClass::*GenericMemFuncType)(); // arbitrary MFP.
detail::GenericClass *m_pthis; utldelegate::GenericClass *m_pthis;
GenericMemFuncType m_pFunction; GenericMemFuncType m_pFunction;
#if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK) #if !defined(FASTDELEGATE_USESTATICFUNCTIONHACK)
@ -683,7 +682,7 @@ public:
// It's used in cases where I've cached off a delegate previously // It's used in cases where I've cached off a delegate previously
void UnsafeThisPointerSlam( void *pThis ) void UnsafeThisPointerSlam( void *pThis )
{ {
m_pthis = (detail::GenericClass*)( pThis ); m_pthis = (utldelegate::GenericClass*)( pThis );
} }
void *UnsafeGetThisPtr() void *UnsafeGetThisPtr()
@ -718,7 +717,7 @@ protected:
// necessary typedefs. // necessary typedefs.
// This class does everything else. // This class does everything else.
namespace detail namespace utldelegate
{ {
template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr> template < class GenericMemFunc, class StaticFuncPtr, class UnvoidStaticFuncPtr>
@ -888,7 +887,7 @@ public:
}; };
} // namespace detail } // namespace utldelegate
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Fast Delegates, part 3: // Fast Delegates, part 3:
@ -930,15 +929,15 @@ public:
// allows "if (dg==0) ..." to compile. // allows "if (dg==0) ..." to compile.
//N=0 //N=0
template<class RetType=detail::DefaultVoid> template<class RetType=utldelegate::DefaultVoid>
class FastDelegate0 class FastDelegate0
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(); typedef DesiredRetType (*StaticFunctionPtr)();
typedef RetType (*UnvoidStaticFunctionPtr)(); typedef RetType (*UnvoidStaticFunctionPtr)();
typedef RetType (detail::GenericClass::*GenericMemFn)(); typedef RetType (utldelegate::GenericClass::*GenericMemFn)();
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -974,23 +973,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate0(Y *pthis, DesiredRetType (X::* function_to_bind)() ) FastDelegate0(Y *pthis, DesiredRetType (X::* function_to_bind)() )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)()) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)())
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate0(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) FastDelegate0(const Y *pthis, DesiredRetType (X::* function_to_bind)() const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)() const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1056,15 +1055,15 @@ private: // Invoker for static functions
}; };
//N=1 //N=1
template<class Param1, class RetType=detail::DefaultVoid> template<class Param1, class RetType=utldelegate::DefaultVoid>
class FastDelegate1 class FastDelegate1
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1100,23 +1099,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate1(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) ) FastDelegate1(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate1(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) FastDelegate1(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1182,15 +1181,15 @@ private: // Invoker for static functions
}; };
//N=2 //N=2
template<class Param1, class Param2, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class RetType=utldelegate::DefaultVoid>
class FastDelegate2 class FastDelegate2
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1226,23 +1225,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate2(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) ) FastDelegate2(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate2(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) FastDelegate2(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1308,15 +1307,15 @@ private: // Invoker for static functions
}; };
//N=3 //N=3
template<class Param1, class Param2, class Param3, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class RetType=utldelegate::DefaultVoid>
class FastDelegate3 class FastDelegate3
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1352,23 +1351,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate3(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) ) FastDelegate3(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate3(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) FastDelegate3(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1434,15 +1433,15 @@ private: // Invoker for static functions
}; };
//N=4 //N=4
template<class Param1, class Param2, class Param3, class Param4, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class Param4, class RetType=utldelegate::DefaultVoid>
class FastDelegate4 class FastDelegate4
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1478,23 +1477,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate4(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) ) FastDelegate4(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate4(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) FastDelegate4(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1560,15 +1559,15 @@ private: // Invoker for static functions
}; };
//N=5 //N=5
template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType=utldelegate::DefaultVoid>
class FastDelegate5 class FastDelegate5
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1604,23 +1603,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate5(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) ) FastDelegate5(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate5(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) FastDelegate5(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1686,15 +1685,15 @@ private: // Invoker for static functions
}; };
//N=6 //N=6
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType=utldelegate::DefaultVoid>
class FastDelegate6 class FastDelegate6
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1730,23 +1729,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate6(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) ) FastDelegate6(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate6(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) FastDelegate6(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1812,15 +1811,15 @@ private: // Invoker for static functions
}; };
//N=7 //N=7
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType=utldelegate::DefaultVoid>
class FastDelegate7 class FastDelegate7
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1856,23 +1855,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate7(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) ) FastDelegate7(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate7(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) FastDelegate7(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -1938,15 +1937,15 @@ private: // Invoker for static functions
}; };
//N=8 //N=8
template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType=detail::DefaultVoid> template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType=utldelegate::DefaultVoid>
class FastDelegate8 class FastDelegate8
{ {
private: private:
typedef typename detail::DefaultVoidToVoid<RetType>::type DesiredRetType; typedef typename utldelegate::DefaultVoidToVoid<RetType>::type DesiredRetType;
typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); typedef DesiredRetType (*StaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); typedef RetType (*UnvoidStaticFunctionPtr)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
typedef RetType (detail::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8); typedef RetType (utldelegate::GenericClass::*GenericMemFn)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
typedef detail::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType; typedef utldelegate::ClosurePtr<GenericMemFn, StaticFunctionPtr, UnvoidStaticFunctionPtr> ClosureType;
ClosureType m_Closure; ClosureType m_Closure;
public: public:
// Typedefs to aid generic programming // Typedefs to aid generic programming
@ -1982,23 +1981,23 @@ public:
template < class X, class Y > template < class X, class Y >
FastDelegate8(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) ) FastDelegate8(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) )
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)) inline void Bind(Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
{ {
m_Closure.bindmemfunc(detail::implicit_cast<X*>(pthis), function_to_bind); m_Closure.bindmemfunc(utldelegate::implicit_cast<X*>(pthis), function_to_bind);
} }
// Binding to const member functions. // Binding to const member functions.
template < class X, class Y > template < class X, class Y >
FastDelegate8(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) FastDelegate8(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X*>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X*>(pthis), function_to_bind);
} }
template < class X, class Y > template < class X, class Y >
inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const) inline void Bind(const Y *pthis, DesiredRetType (X::* function_to_bind)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
{ {
m_Closure.bindconstmemfunc(detail::implicit_cast<const X *>(pthis), function_to_bind); m_Closure.bindconstmemfunc(utldelegate::implicit_cast<const X *>(pthis), function_to_bind);
} }
// Static functions. We convert them into a member function call. // Static functions. We convert them into a member function call.
// This constructor also provides implicit conversion // This constructor also provides implicit conversion
@ -2470,7 +2469,7 @@ public:
// So, I have to use a macro. // So, I have to use a macro.
#ifdef FASTDLGT_VC6 #ifdef FASTDLGT_VC6
#define FASTDLGT_RETTYPE detail::VoidToDefaultVoid<RetType>::type #define FASTDLGT_RETTYPE utldelegate::VoidToDefaultVoid<RetType>::type
#else #else
#define FASTDLGT_RETTYPE RetType #define FASTDLGT_RETTYPE RetType
#endif #endif
@ -2648,7 +2647,6 @@ CUtlDelegate< FASTDLGT_RETTYPE ( Param1, Param2, Param3, Param4, Param5, Param6,
return CUtlDelegate< FASTDLGT_RETTYPE ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >(func); return CUtlDelegate< FASTDLGT_RETTYPE ( Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8 ) >(func);
} }
// clean up after ourselves... // clean up after ourselves...
#undef FASTDLGT_RETTYPE #undef FASTDLGT_RETTYPE

2
public/tier1/utlhashtable.h
View File

@ -747,7 +747,7 @@ void CUtlHashtable<KeyT, ValueT, KeyHashT, KeyIsEqualT, AltKeyT, TableT>::DbgChe
// and also the validity of the user's Hash and Equal function objects. // and also the validity of the user's Hash and Equal function objects.
// NOTE: will fail if function objects require any sort of state! // NOTE: will fail if function objects require any sort of state!
CUtlHashtable clone; CUtlHashtable clone;
unsigned int bytes = sizeof(entry_t)*max(16,m_nTableSize); unsigned int bytes = sizeof(entry_t)*MAX(16,m_nTableSize);
byte* tempbuf = (byte*) malloc(bytes); byte* tempbuf = (byte*) malloc(bytes);
clone.SetExternalBuffer( tempbuf, bytes, false, false ); clone.SetExternalBuffer( tempbuf, bytes, false, false );
clone = *this; clone = *this;

3
public/vstdlib/IKeyValuesSystem.h
View File

@ -1,4 +1,4 @@
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// //========= Copyright <EFBFBD> 1996-2005, Valve Corporation, All rights reserved. ============//
// //
// Purpose: // Purpose:
// //
@ -16,6 +16,7 @@ class KeyValues;
class HKeySymbol class HKeySymbol
{ {
public:
HKeySymbol() : nIndex(~0) { } HKeySymbol() : nIndex(~0) { }
HKeySymbol(uint32 idx) : nIndex(idx) { } HKeySymbol(uint32 idx) : nIndex(idx) { }

6
tier1/keyvalues3.cpp
View File

@ -1255,7 +1255,7 @@ void CKeyValues3Cluster::Free( int element )
{ {
KeyValues3* kv = &m_KeyValues[ element ]; KeyValues3* kv = &m_KeyValues[ element ];
Destruct( kv ); Destruct( kv );
memset( kv, 0, sizeof( KeyValues3 ) ); memset( (void *)kv, 0, sizeof( KeyValues3 ) );
m_nAllocatedElements &= ~( 1ull << element ); m_nAllocatedElements &= ~( 1ull << element );
} }
@ -1340,7 +1340,7 @@ void CKeyValues3ArrayCluster::Free( int element )
{ {
CKeyValues3Array* arr = &m_Arrays[ element ]; CKeyValues3Array* arr = &m_Arrays[ element ];
Destruct( arr ); Destruct( arr );
memset( arr, 0, sizeof( CKeyValues3Array ) ); memset( (void *)arr, 0, sizeof( CKeyValues3Array ) );
m_nAllocatedElements &= ~( 1ull << element ); m_nAllocatedElements &= ~( 1ull << element );
} }
@ -1375,7 +1375,7 @@ void CKeyValues3TableCluster::Free( int element )
{ {
CKeyValues3Table* table = &m_Tables[ element ]; CKeyValues3Table* table = &m_Tables[ element ];
Destruct( table ); Destruct( table );
memset( table, 0, sizeof( CKeyValues3Table ) ); memset( (void *)table, 0, sizeof( CKeyValues3Table ) );
m_nAllocatedElements &= ~( 1ull << element ); m_nAllocatedElements &= ~( 1ull << element );
} }