Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-09-19 03:56:10 +08:00
Code Activity

Update CTSListBase & various schema system naming changes (#253)

Browse Source
This commit is contained in:
vanz696
2024-06-03 19:46:16 +03:00
committed by GitHub
parent f919c628dc
commit cc207907f5
3 changed files with 89 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
public/schemasystem/schemasystem.h
View File

@ -20,9 +20,9 @@ struct ResourceManifestDesc_t;
enum SchemaTypeScope_t : uint8
{
SCHEMA_TYPESCOPE_GLOBAL = 0,
SCHEMA_TYPESCOPE_LOCAL,
SCHEMA_TYPESCOPE_DEFAULT,
SCHEMA_GLOBAL_TYPE_SCOPE = 0,
SCHEMA_MODULE_LOCAL_TYPE_SCOPE,
SCHEMA_DEFAULT_TYPE_SCOPE,
};
typedef void (*CompleteModuleRegistrationCallbackFn_t)(void*);
@ -42,7 +42,7 @@ public:
virtual SchemaMetaInfoHandle_t<CSchemaType_Ptr> Type_Ptr( CSchemaType* pObjectType ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic> Type_Atomic( const char* pszAtomicName, uint16 nSize, uint8 nAlignment ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_T> Type_Atomic_T( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, CSchemaType* pTemplateType ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> Type_Atomic_CollectionOfT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, uint16 nElementSize, CSchemaType* pTemplateType, SchemaAtomicManipulatorFn_t manipulator ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> Type_Atomic_CollectionOfT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, uint16 nElementSize, CSchemaType* pTemplateType, SchemaCollectionManipulatorFn_t manipulator ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_TT> Type_Atomic_TT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, CSchemaType* pTemplateType, CSchemaType* pTemplateType2 ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_I> Type_Atomic_I( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, int nInterger ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_DeclaredClass> Type_DeclaredClass( const char* pszClassName ) = 0;
@ -53,7 +53,7 @@ public:
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic> FindType_Atomic( int nAtomicID ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_T> FindType_Atomic_T( int nAtomicID, CSchemaType* pTemplateType ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> FindType_Atomic_CollectionOfT( int nAtomicID, CSchemaType* pTemplateType, SchemaAtomicManipulatorFn_t manipulator ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> FindType_Atomic_CollectionOfT( int nAtomicID, CSchemaType* pTemplateType, SchemaCollectionManipulatorFn_t manipulator ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_TT> FindType_Atomic_TT( int nAtomicID, CSchemaType* pTemplateType, CSchemaType* pTemplateType2 ) = 0;
virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_I> FindType_Atomic_I( int nAtomicID, int nInteger ) = 0;
@ -84,9 +84,9 @@ public:
CSchemaSystemTypeScope* m_pGlobalTypeScope;
bool m_bBuiltinTypesInitialized;
CSchemaType_Builtin m_BuiltinTypes[SCHEMA_BUILTIN_COUNT];
CSchemaType_Builtin m_BuiltinTypes[SCHEMA_BUILTIN_TYPE_COUNT];
CSchemaPtrMap<SchemaMetaInfoHandle_t<CSchemaType>, CSchemaType_Ptr*> m_Ptrs;
CSchemaPtrMap<SchemaMetaInfoHandle_t<CSchemaType>, CSchemaType_Ptr*> m_Pointers;
CSchemaPtrMap<int, CSchemaType_Atomic*> m_Atomics;
CSchemaPtrMap<AtomicTypeInfo_T_t, CSchemaType_Atomic_T*> m_AtomicsT;
CSchemaPtrMap<AtomicTypeInfo_T_t, CSchemaType_Atomic_CollectionOfT*> m_AtomicsCollectionOfT;

124
public/schemasystem/schematypes.h
View File

@ -54,44 +54,42 @@ enum SchemaEnumFlags_t
enum SchemaTypeCategory_t : uint8
{
SCHEMA_TYPE_BUILTIN = 0,
SCHEMA_TYPE_PTR,
SCHEMA_TYPE_POINTER,
SCHEMA_TYPE_BITFIELD,
SCHEMA_TYPE_FIXED_ARRAY,
SCHEMA_TYPE_ATOMIC,
SCHEMA_TYPE_DECLARED_CLASS,
SCHEMA_TYPE_DECLARED_ENUM,
SCHEMA_TYPE_NONE,
SCHEMA_TYPE_INVALID,
};
enum SchemaAtomicCategory_t : uint8
{
SCHEMA_ATOMIC_BASIC = 0,
SCHEMA_ATOMIC_PLAIN = 0,
SCHEMA_ATOMIC_T,
SCHEMA_ATOMIC_COLLECTION_OF_T,
SCHEMA_ATOMIC_TF,
SCHEMA_ATOMIC_TT,
SCHEMA_ATOMIC_TTF,
SCHEMA_ATOMIC_I,
SCHEMA_ATOMIC_NONE,
SCHEMA_ATOMIC_INVALID,
};
enum SchemaBuiltinType_t
{
SCHEMA_BUILTIN_INVALID = 0,
SCHEMA_BUILTIN_VOID,
SCHEMA_BUILTIN_CHAR,
SCHEMA_BUILTIN_INT8,
SCHEMA_BUILTIN_UINT8,
SCHEMA_BUILTIN_INT16,
SCHEMA_BUILTIN_UINT16,
SCHEMA_BUILTIN_INT32,
SCHEMA_BUILTIN_UINT32,
SCHEMA_BUILTIN_INT64,
SCHEMA_BUILTIN_UINT64,
SCHEMA_BUILTIN_FLOAT32,
SCHEMA_BUILTIN_FLOAT64,
SCHEMA_BUILTIN_BOOL,
SCHEMA_BUILTIN_COUNT,
SCHEMA_BUILTIN_TYPE_INVALID = 0,
SCHEMA_BUILTIN_TYPE_VOID,
SCHEMA_BUILTIN_TYPE_CHAR,
SCHEMA_BUILTIN_TYPE_INT8,
SCHEMA_BUILTIN_TYPE_UINT8,
SCHEMA_BUILTIN_TYPE_INT16,
SCHEMA_BUILTIN_TYPE_UINT16,
SCHEMA_BUILTIN_TYPE_INT32,
SCHEMA_BUILTIN_TYPE_UINT32,
SCHEMA_BUILTIN_TYPE_INT64,
SCHEMA_BUILTIN_TYPE_UINT64,
SCHEMA_BUILTIN_TYPE_FLOAT32,
SCHEMA_BUILTIN_TYPE_FLOAT64,
SCHEMA_BUILTIN_TYPE_BOOL,
SCHEMA_BUILTIN_TYPE_COUNT,
};
enum SchemaClassManipulatorAction_t
@ -105,19 +103,19 @@ enum SchemaClassManipulatorAction_t
SCHEMA_CLASS_MANIPULATOR_ACTION_GET_SCHEMA_BINDING,
};
enum SchemaAtomicManipulatorAction_t
enum SchemaCollectionManipulatorAction_t
{
SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_COUNT = 0,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_ELEMENT_CONST,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_ELEMENT,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_SWAP_ELEMENTS,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_INSERT_BEFORE,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_REMOVE_MULTIPLE,
SCHEMA_ATOMIC_MANIPULATOR_ACTION_SET_COUNT,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_COUNT = 0,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_ELEMENT_CONST,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_ELEMENT,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_SWAP_ELEMENTS,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_INSERT_BEFORE,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_REMOVE_MULTIPLE,
SCHEMA_COLLECTION_MANIPULATOR_ACTION_SET_COUNT,
};
typedef void* (*SchemaClassManipulatorFn_t)(SchemaClassManipulatorAction_t, void*, void*);
typedef void* (*SchemaAtomicManipulatorFn_t)(SchemaAtomicManipulatorAction_t, void*, void*, void*);
typedef void* (*SchemaCollectionManipulatorFn_t)(SchemaCollectionManipulatorAction_t, void*, void*, void*);
inline uint32 CSchemaType_Hash( const char *pString, int len )
{
@ -129,7 +127,8 @@ struct SchemaMetaInfoHandle_t
{
SchemaMetaInfoHandle_t() : m_pObj( NULL ) {}
SchemaMetaInfoHandle_t( T *obj ) : m_pObj( obj ) {}
T* Get() { return m_pObj; }
T* Get() const { return m_pObj; }
bool operator<( const SchemaMetaInfoHandle_t& rhs ) const { return m_pObj < rhs.m_pObj; }
T* m_pObj;
};
@ -204,7 +203,7 @@ public:
class CSchemaType_Atomic_CollectionOfT : public CSchemaType_Atomic_T
{
public:
SchemaAtomicManipulatorFn_t m_pfnManipulator;
SchemaCollectionManipulatorFn_t m_pfnManipulator;
uint16 m_nElementSize;
};
@ -246,7 +245,7 @@ public:
class CSchemaType_Bitfield : public CSchemaType
{
public:
int m_nSize;
int m_nBitfieldCount;
};
struct SchemaMetadataEntryData_t
@ -362,8 +361,8 @@ class CSchemaEnumInfo : public SchemaEnumInfoData_t
struct SchemaAtomicTypeInfo_t
{
const char* m_pszName1;
const char* m_pszName2;
const char* m_pszName;
const char* m_pszTokenName;
int m_nAtomicID;
@ -373,41 +372,64 @@ struct SchemaAtomicTypeInfo_t
struct AtomicTypeInfo_T_t
{
bool operator<( const AtomicTypeInfo_T_t& rhs ) const
{
if ( m_nAtomicID != rhs.m_nAtomicID )
return m_nAtomicID < rhs.m_nAtomicID;
if ( m_pTemplateType != rhs.m_pTemplateType )
return m_pTemplateType < rhs.m_pTemplateType;
return m_pfnManipulator < rhs.m_pfnManipulator;
}
int m_nAtomicID;
CSchemaType* m_pTemplateType;
SchemaAtomicManipulatorFn_t m_pfnManipulator;
};
struct AtomicTypeInfo_TF_t
{
int m_nAtomicID;
CSchemaType* m_pTemplateType;
int m_nFuncPtrSize;
SchemaCollectionManipulatorFn_t m_pfnManipulator;
};
struct AtomicTypeInfo_TT_t
{
bool operator<( const AtomicTypeInfo_TT_t& rhs ) const
{
if ( m_nAtomicID != rhs.m_nAtomicID )
return m_nAtomicID < rhs.m_nAtomicID;
if ( m_pTemplateType != rhs.m_pTemplateType )
return m_pTemplateType < rhs.m_pTemplateType;
return m_pTemplateType2 < rhs.m_pTemplateType2;
}
int m_nAtomicID;
CSchemaType* m_pTemplateType;
CSchemaType* m_pTemplateType2;
};
struct AtomicTypeInfo_TTF_t
{
int m_nAtomicID;
CSchemaType* m_pTemplateType;
CSchemaType* m_pTemplateType2;
int m_nFuncPtrSize;
};
struct AtomicTypeInfo_I_t
{
bool operator<( const AtomicTypeInfo_I_t& rhs ) const
{
if ( m_nAtomicID != rhs.m_nAtomicID )
return m_nAtomicID < rhs.m_nAtomicID;
return m_nInteger < rhs.m_nInteger;
}
int m_nAtomicID;
int m_nInteger;
};
struct TypeAndCountInfo_t
{
bool operator<( const TypeAndCountInfo_t& rhs ) const
{
if ( m_nElementCount != rhs.m_nElementCount )
return m_nElementCount < rhs.m_nElementCount;
return m_pElementType < rhs.m_pElementType;
}
int m_nElementCount;
CSchemaType* m_pElementType;
};

153
public/tier0/tslist.h
View File

@ -127,7 +127,7 @@ union TSLIST_HEAD_ALIGN TSLHead_t
#endif
//-------------------------------------
class TSLIST_HEAD_ALIGN CTSListBase
class TSLIST_HEAD_ALIGN PLATFORM_CLASS CTSListBase
{
public:
@ -159,153 +159,18 @@ private:
static void * operator new[] ( size_t size );
static void operator delete [] ( void *p);
void InternalPush( TSLNodeBase_t *pNode );
TSLNodeBase_t *InternalPop();
public:
CTSListBase()
{
if ( ((size_t)&m_Head) % TSLIST_HEAD_ALIGNMENT != 0 )
{
Plat_FatalErrorFunc( "CTSListBase: Misaligned list\n" );
DebuggerBreak();
}
CTSListBase();
~CTSListBase();
#ifdef USE_NATIVE_SLIST
InitializeSListHead( &m_Head );
#elif defined(PLATFORM_64BITS)
m_Head.value64x128 = int128_zero();
#else
m_Head.value64x128 = (int64)0;
#endif
}
void Push( TSLNodeBase_t *pNode ) { InternalPush( pNode ); }
TSLNodeBase_t *Pop() { return InternalPop(); }
~CTSListBase()
{
Detach();
}
TSLNodeBase_t *Push( TSLNodeBase_t *pNode )
{
#ifdef _DEBUG
if ( (size_t)pNode % TSLIST_NODE_ALIGNMENT != 0 )
{
Plat_FatalErrorFunc( "CTSListBase: Misaligned node\n" );
DebuggerBreak();
}
#endif
#ifdef USE_NATIVE_SLIST
#ifdef _X360
// integrated write-release barrier
return (TSLNodeBase_t *)InterlockedPushEntrySListRelease( &m_Head, pNode );
#else
return (TSLNodeBase_t *)InterlockedPushEntrySList( &m_Head, pNode );
#endif
#else
TSLHead_t oldHead;
TSLHead_t newHead;
#if defined( PLATFORM_PS3 ) || defined( PLATFORM_X360 )
__lwsync(); // write-release barrier
#endif
#ifdef PLATFORM_64BITS
newHead.value.Padding = 0;
#endif
for (;;)
{
oldHead.value64x128 = m_Head.value64x128;
pNode->Next = oldHead.value.Next;
newHead.value.Next = pNode;
newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence + 0x10001;
if ( ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) )
{
break;
}
ThreadPause();
};
return (TSLNodeBase_t *)oldHead.value.Next;
#endif
}
TSLNodeBase_t *Pop()
{
#ifdef USE_NATIVE_SLIST
#ifdef _X360
// integrated read-acquire barrier
TSLNodeBase_t *pNode = (TSLNodeBase_t *)InterlockedPopEntrySListAcquire( &m_Head );
#else
TSLNodeBase_t *pNode = (TSLNodeBase_t *)InterlockedPopEntrySList( &m_Head );
#endif
return pNode;
#else
TSLHead_t oldHead;
TSLHead_t newHead;
#ifdef PLATFORM_64BITS
newHead.value.Padding = 0;
#endif
for (;;)
{
oldHead.value64x128 = m_Head.value64x128;
if ( !oldHead.value.Next )
return NULL;
newHead.value.Next = oldHead.value.Next->Next;
newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence - 1;
if ( ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) )
{
#if defined( PLATFORM_PS3 ) || defined( PLATFORM_X360 )
__lwsync(); // read-acquire barrier
#endif
break;
}
ThreadPause();
};
return (TSLNodeBase_t *)oldHead.value.Next;
#endif
}
TSLNodeBase_t *Detach()
{
#ifdef USE_NATIVE_SLIST
TSLNodeBase_t *pBase = (TSLNodeBase_t *)InterlockedFlushSList( &m_Head );
#if defined( _X360 ) || defined( _PS3 )
__lwsync(); // read-acquire barrier
#endif
return pBase;
#else
TSLHead_t oldHead;
TSLHead_t newHead;
#ifdef PLATFORM_64BITS
newHead.value.Padding = 0;
#endif
do
{
ThreadPause();
oldHead.value64x128 = m_Head.value64x128;
if ( !oldHead.value.Next )
return NULL;
newHead.value.Next = NULL;
// <sergiy> the reason for AND'ing it instead of poking a short into memory
// is probably to avoid store forward issues, but I'm not sure because
// I didn't construct this code. In any case, leaving it as is on big-endian
newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence & 0xffff0000;
} while( !ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) );
return (TSLNodeBase_t *)oldHead.value.Next;
#endif
}
TSLNodeBase_t *Detach();
TSLHead_t *AccessUnprotected()
{