GitHub/amxmodx
2
0
Fork 0
mirror of https://github.com/alliedmodders/amxmodx.git synced 2024-12-27 07:15:37 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #257 from Arkshine/feature/remove-duplicated-handle-code

Browse Source 
Remove duplicated code of native handles
This commit is contained in:
Vincent Herbet 2015-07-11 19:58:02 +02:00
commit 3132e20fad
13 changed files with 330 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
amxmodx/CDataPack.cpp
View File

@ -27,8 +27,6 @@
* or <http://www.sourcemod.net/license.php>.
*/
#include <stdlib.h>
#include <string.h>
#include "CDataPack.h"
#define DATAPACK_INITIAL_SIZE 512

77
amxmodx/CDataPack.h
View File

@ -31,6 +31,7 @@
#define _INCLUDE_SOURCEMOD_CDATAPACK_H_
#include "amxmodx.h"
#include "natives_handles.h"
/**
* @brief Contains functions for packing data abstractly to/from plugins.
@ -174,81 +175,7 @@ private:
};
};
class CDataPackHandles
{
private:
CVector<CDataPack *> m_packs;
public:
CDataPackHandles() {}
~CDataPackHandles()
{
this->clear();
}
void clear()
{
for (size_t i = 0; i < m_packs.size(); i++)
{
if (m_packs[i] != NULL)
{
delete m_packs[i];
}
}
m_packs.clear();
}
CDataPack *lookup(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_packs.size()))
{
return NULL;
}
return m_packs[handle];
}
int create()
{
for (size_t i = 0; i < m_packs.size(); ++i)
{
if (m_packs[i] == NULL)
{
// reuse handle
m_packs[i] = new CDataPack;
return static_cast<int>(i) + 1;
}
}
m_packs.push_back(new CDataPack);
return m_packs.size();
}
bool destroy(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_packs.size()))
{
return false;
}
if (m_packs[handle] == NULL)
{
return false;
}
delete m_packs[handle];
m_packs[handle] = NULL;
return true;
}
};
extern CDataPackHandles g_DataPackHandles;
extern Handle<CDataPack> DataPackHandles;
extern AMX_NATIVE_INFO g_DatapackNatives[];
#endif //_INCLUDE_SOURCEMOD_CDATAPACK_H_

76
amxmodx/datapacks.cpp
View File

@ -29,18 +29,18 @@
#include "CDataPack.h"
CDataPackHandles g_DataPackHandles;
Handle<CDataPack> DataPackHandles;
static cell AMX_NATIVE_CALL CreateDataPack(AMX* amx, cell* params)
{
return static_cast<cell>(g_DataPackHandles.create());
return static_cast<cell>(DataPackHandles.create());
}
static cell AMX_NATIVE_CALL WritePackCell(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -53,9 +53,9 @@ static cell AMX_NATIVE_CALL WritePackCell(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL WritePackFloat(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -68,9 +68,9 @@ static cell AMX_NATIVE_CALL WritePackFloat(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL WritePackString(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -86,9 +86,9 @@ static cell AMX_NATIVE_CALL WritePackString(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL ReadPackCell(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -105,9 +105,9 @@ static cell AMX_NATIVE_CALL ReadPackCell(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL ReadPackFloat(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -126,9 +126,9 @@ static cell AMX_NATIVE_CALL ReadPackFloat(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL ReadPackString(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -148,9 +148,9 @@ static cell AMX_NATIVE_CALL ReadPackString(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL ResetPack(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -168,9 +168,9 @@ static cell AMX_NATIVE_CALL ResetPack(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL GetPackPosition(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -181,9 +181,9 @@ static cell AMX_NATIVE_CALL GetPackPosition(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL SetPackPosition(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -200,9 +200,9 @@ static cell AMX_NATIVE_CALL SetPackPosition(AMX* amx, cell* params)
static cell AMX_NATIVE_CALL IsPackEnded(AMX* amx, cell* params)
{
CDataPack *d = g_DataPackHandles.lookup(params[1]);
CDataPack *d = DataPackHandles.lookup(params[1]);
if (d == NULL)
if (!d)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid datapack handle provided (%d)", params[1]);
return 0;
@ -215,14 +215,14 @@ static cell AMX_NATIVE_CALL DestroyDataPack(AMX* amx, cell* params)
{
cell *ptr = get_amxaddr(amx, params[1]);
CDataPack *d = g_DataPackHandles.lookup(*ptr);
CDataPack *d = DataPackHandles.lookup(*ptr);
if (d == NULL)
if (!d)
{
return 0;
}
if (g_DataPackHandles.destroy(*ptr))
if (DataPackHandles.destroy(*ptr))
{
*ptr = 0;
return 1;
@ -234,17 +234,17 @@ static cell AMX_NATIVE_CALL DestroyDataPack(AMX* amx, cell* params)
AMX_NATIVE_INFO g_DatapackNatives[] =
{
{ "CreateDataPack", CreateDataPack },
{ "WritePackCell", WritePackCell },
{ "WritePackFloat", WritePackFloat },
{ "WritePackString", WritePackString },
{ "ReadPackCell", ReadPackCell },
{ "ReadPackFloat", ReadPackFloat },
{ "ReadPackString", ReadPackString },
{ "ResetPack", ResetPack },
{ "GetPackPosition", GetPackPosition },
{ "SetPackPosition", SetPackPosition },
{ "IsPackEnded", IsPackEnded },
{ "DestroyDataPack", DestroyDataPack },
{NULL, NULL}
{ "CreateDataPack" , CreateDataPack },
{ "WritePackCell" , WritePackCell },
{ "WritePackFloat" , WritePackFloat },
{ "WritePackString", WritePackString },
{ "ReadPackCell" , ReadPackCell },
{ "ReadPackFloat" , ReadPackFloat },
{ "ReadPackString" , ReadPackString },
{ "ResetPack" , ResetPack },
{ "GetPackPosition", GetPackPosition },
{ "SetPackPosition", SetPackPosition },
{ "IsPackEnded" , IsPackEnded },
{ "DestroyDataPack", DestroyDataPack },
{ nullptr , nullptr}
};

253
amxmodx/datastructs.cpp
View File

@ -11,12 +11,7 @@
#include "datastructs.h"
#include <am-utility.h>
// Note: All handles start at 1. 0 and below are invalid handles.
// This way, a plugin that doesn't initialize a vector or
// string will not be able to modify another plugin's data
// on accident.
ke::Vector<CellArray*> VectorHolder;
Handle<CellArray> ArrayHandles;
// Array:ArrayCreate(cellsize=1, reserved=32);
static cell AMX_NATIVE_CALL ArrayCreate(AMX* amx, cell* params)
@ -40,32 +35,17 @@ static cell AMX_NATIVE_CALL ArrayCreate(AMX* amx, cell* params)
reserved = 0;
}
// Scan through the vector list to see if any are NULL.
// NULL means the vector was previously destroyed.
for (unsigned int i=0; i < VectorHolder.length(); ++i)
{
if (VectorHolder[i]==NULL)
{
VectorHolder[i] = new CellArray(cellsize, reserved);
return i + 1;
}
}
// None are NULL, create a new vector
CellArray* NewVector = new CellArray(cellsize, reserved);
VectorHolder.append(NewVector);
return VectorHolder.length();
return ArrayHandles.create(cellsize, reserved);
}
// native ArrayClear(Array:which);
static cell AMX_NATIVE_CALL ArrayClear(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -77,10 +57,11 @@ static cell AMX_NATIVE_CALL ArrayClear(AMX* amx, cell* params)
// native ArraySize(Array:which);
static cell AMX_NATIVE_CALL ArraySize(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -90,10 +71,11 @@ static cell AMX_NATIVE_CALL ArraySize(AMX* amx, cell* params)
// native bool:ArrayResize(Array:which, newsize);
static cell AMX_NATIVE_CALL ArrayResize(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -109,38 +91,25 @@ static cell AMX_NATIVE_CALL ArrayResize(AMX* amx, cell* params)
// native Array:ArrayClone(Array:which);
static cell AMX_NATIVE_CALL ArrayClone(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
CellArray *clonevec = vec->clone();
// Scan through the vector list to see if any are NULL.
// NULL means the vector was previously destroyed.
for (unsigned int i = 0; i < VectorHolder.length(); ++i)
{
if (VectorHolder[i] == NULL)
{
VectorHolder[i] = clonevec;
return i + 1;
}
}
VectorHolder.append(clonevec);
return VectorHolder.length();
return ArrayHandles.clone(vec->clone());
}
// native ArrayGetArray(Array:which, item, any:output[], size = -1);
static cell AMX_NATIVE_CALL ArrayGetArray(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -173,10 +142,11 @@ static cell AMX_NATIVE_CALL ArrayGetArray(AMX* amx, cell* params)
// native any:ArrayGetCell(Array:which, item, block = 0, bool:asChar = false);
static cell AMX_NATIVE_CALL ArrayGetCell(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -224,10 +194,11 @@ static cell AMX_NATIVE_CALL ArrayGetCell(AMX* amx, cell* params)
// native ArrayGetString(Array:which, item, output[], size);
static cell AMX_NATIVE_CALL ArrayGetString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -246,10 +217,11 @@ static cell AMX_NATIVE_CALL ArrayGetString(AMX* amx, cell* params)
// native ArraySetArray(Array:which, item, const any:input[], size =-1);
static cell AMX_NATIVE_CALL ArraySetArray(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -282,10 +254,11 @@ static cell AMX_NATIVE_CALL ArraySetArray(AMX* amx, cell* params)
// native ArraySetCell(Array:which, item, any:input, block = 0, bool:asChar = false);
static cell AMX_NATIVE_CALL ArraySetCell(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -331,10 +304,11 @@ static cell AMX_NATIVE_CALL ArraySetCell(AMX* amx, cell* params)
// native ArraySetString(Array:which, item, const input[]);
static cell AMX_NATIVE_CALL ArraySetString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -357,10 +331,11 @@ static cell AMX_NATIVE_CALL ArraySetString(AMX* amx, cell* params)
// native ArrayPushArray(Array:which, const any:input[], size = -1);
static cell AMX_NATIVE_CALL ArrayPushArray(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -391,10 +366,11 @@ static cell AMX_NATIVE_CALL ArrayPushArray(AMX* amx, cell* params)
// native ArrayPushCell(Array:which, any:input);
static cell AMX_NATIVE_CALL ArrayPushCell(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -414,10 +390,11 @@ static cell AMX_NATIVE_CALL ArrayPushCell(AMX* amx, cell* params)
// native ArrayPushString(Array:which, const input[]);
static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -436,10 +413,11 @@ static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
// native DoNotUse : ArrayGetStringHandle(Array : which, item);
static cell AMX_NATIVE_CALL ArrayGetStringHandle(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -464,10 +442,11 @@ static cell AMX_NATIVE_CALL ArrayGetStringHandle(AMX* amx, cell* params)
// native ArrayInsertArrayAfter(Array:which, item, const any:input[]);
static cell AMX_NATIVE_CALL ArrayInsertArrayAfter(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -489,10 +468,11 @@ static cell AMX_NATIVE_CALL ArrayInsertArrayAfter(AMX* amx, cell* params)
// native ArrayInsertCellAfter(Array:which, item, any:input);
static cell AMX_NATIVE_CALL ArrayInsertCellAfter(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -512,10 +492,11 @@ static cell AMX_NATIVE_CALL ArrayInsertCellAfter(AMX* amx, cell* params)
// native ArrayInsertStringAfter(Array:which, item, const input[]);
static cell AMX_NATIVE_CALL ArrayInsertStringAfter(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -536,10 +517,11 @@ static cell AMX_NATIVE_CALL ArrayInsertStringAfter(AMX* amx, cell* params)
// native ArrayInsertArrayBefore(Array:which, item, const any:input[]);
static cell AMX_NATIVE_CALL ArrayInsertArrayBefore(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -561,10 +543,11 @@ static cell AMX_NATIVE_CALL ArrayInsertArrayBefore(AMX* amx, cell* params)
// native ArrayInsertCellBefore(Array:which, item, const any:input);
static cell AMX_NATIVE_CALL ArrayInsertCellBefore(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -583,10 +566,11 @@ static cell AMX_NATIVE_CALL ArrayInsertCellBefore(AMX* amx, cell* params)
// native ArrayInsertStringBefore(Array:which, item, const input[]);
static cell AMX_NATIVE_CALL ArrayInsertStringBefore(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -607,10 +591,11 @@ static cell AMX_NATIVE_CALL ArrayInsertStringBefore(AMX* amx, cell* params)
// native ArraySwap(Array:which, item1, item2);
static cell AMX_NATIVE_CALL ArraySwap(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -637,10 +622,11 @@ static cell AMX_NATIVE_CALL ArraySwap(AMX* amx, cell* params)
// native ArrayDeleteItem(Array:which, item);
static cell AMX_NATIVE_CALL ArrayDeleteItem(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -660,26 +646,21 @@ static cell AMX_NATIVE_CALL ArrayDeleteItem(AMX* amx, cell* params)
// native ArrayDestroy(&Array:which);
static cell AMX_NATIVE_CALL ArrayDestroy(AMX* amx, cell* params)
{
cell* handle = get_amxaddr(amx, params[1]);
cell *handle = get_amxaddr(amx, params[1]);
if (*handle == 0)
CellArray* vec = ArrayHandles.lookup(*handle);
if (!vec)
{
return 0;
}
CellArray* vec = HandleToVector(amx, *handle);
if (vec == NULL)
if (ArrayHandles.destroy(*handle))
{
return 0;
*handle = 0;
return 1;
}
delete vec;
VectorHolder[*handle-1] = NULL;
*handle = 0;
return 1;
}
@ -714,11 +695,12 @@ int SortArrayList(const void *elem1, const void *elem2)
// native ArraySort(Array:array, const comparefunc[], data[]="", data_size=0);
static cell AMX_NATIVE_CALL ArraySort(AMX* amx, cell* params)
{
int handle = params[1];
CellArray* vec = HandleToVector(amx, handle);
cell handle = params[1];
CellArray* vec = ArrayHandles.lookup(handle);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
return 0;
}
@ -795,11 +777,11 @@ int SortArrayListExArray(const void *elem1, const void *elem2)
// native ArraySortEx(Array:array, const comparefunc[], data[]="", data_size=0);
static cell AMX_NATIVE_CALL ArraySortEx(AMX* amx, cell* params)
{
int handle = params[1];
CellArray* vec = HandleToVector(amx, handle);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -863,10 +845,11 @@ extern int amxstring_len(cell* a);
// native ArrayFindString(Array:which, const item[]);
static cell AMX_NATIVE_CALL ArrayFindString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return -1;
}
@ -891,10 +874,11 @@ static cell AMX_NATIVE_CALL ArrayFindString(AMX* amx, cell* params)
// native ArrayFindValue(Array:which, any:item);
static cell AMX_NATIVE_CALL ArrayFindValue(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return -1;
}
@ -911,34 +895,33 @@ static cell AMX_NATIVE_CALL ArrayFindValue(AMX* amx, cell* params)
AMX_NATIVE_INFO g_DataStructNatives[] =
{
{ "ArrayCreate", ArrayCreate },
{ "ArrayClear", ArrayClear },
{ "ArrayClone", ArrayClone },
{ "ArraySize", ArraySize },
{ "ArrayResize", ArrayResize },
{ "ArrayGetArray", ArrayGetArray },
{ "ArrayGetCell", ArrayGetCell },
{ "ArrayGetString", ArrayGetString },
{ "ArraySetArray", ArraySetArray },
{ "ArraySetCell", ArraySetCell },
{ "ArraySetString", ArraySetString },
{ "ArrayPushArray", ArrayPushArray },
{ "ArrayPushCell", ArrayPushCell },
{ "ArrayPushString", ArrayPushString },
{ "ArrayInsertArrayAfter", ArrayInsertArrayAfter },
{ "ArrayInsertCellAfter", ArrayInsertCellAfter },
{ "ArrayInsertStringAfter", ArrayInsertStringAfter },
{ "ArrayInsertArrayBefore", ArrayInsertArrayBefore },
{ "ArrayInsertCellBefore", ArrayInsertCellBefore },
{ "ArrayInsertStringBefore", ArrayInsertStringBefore },
{ "ArraySwap", ArraySwap },
{ "ArrayDeleteItem", ArrayDeleteItem },
{ "ArrayGetStringHandle", ArrayGetStringHandle },
{ "ArrayDestroy", ArrayDestroy },
{ "ArraySort", ArraySort },
{ "ArraySortEx", ArraySortEx },
{ "ArrayFindString", ArrayFindString },
{ "ArrayFindValue", ArrayFindValue },
{ NULL, NULL }
{ "ArrayCreate" , ArrayCreate },
{ "ArrayClear" , ArrayClear },
{ "ArrayClone" , ArrayClone },
{ "ArraySize" , ArraySize },
{ "ArrayResize" , ArrayResize },
{ "ArrayGetArray" , ArrayGetArray },
{ "ArrayGetCell" , ArrayGetCell },
{ "ArrayGetString" , ArrayGetString },
{ "ArraySetArray" , ArraySetArray },
{ "ArraySetCell" , ArraySetCell },
{ "ArraySetString" , ArraySetString },
{ "ArrayPushArray" , ArrayPushArray },
{ "ArrayPushCell" , ArrayPushCell },
{ "ArrayPushString" , ArrayPushString },
{ "ArrayInsertArrayAfter" , ArrayInsertArrayAfter },
{ "ArrayInsertCellAfter" , ArrayInsertCellAfter },
{ "ArrayInsertStringAfter" , ArrayInsertStringAfter },
{ "ArrayInsertArrayBefore" , ArrayInsertArrayBefore },
{ "ArrayInsertCellBefore" , ArrayInsertCellBefore },
{ "ArrayInsertStringBefore", ArrayInsertStringBefore },
{ "ArraySwap" , ArraySwap },
{ "ArrayDeleteItem" , ArrayDeleteItem },
{ "ArrayGetStringHandle" , ArrayGetStringHandle },
{ "ArrayDestroy" , ArrayDestroy },
{ "ArraySort" , ArraySort },
{ "ArraySortEx" , ArraySortEx },
{ "ArrayFindString" , ArrayFindString },
{ "ArrayFindValue" , ArrayFindValue },
{ nullptr , nullptr }
};

31
amxmodx/datastructs.h
View File

@ -10,12 +10,12 @@
#ifndef DATASTRUCTS_H
#define DATASTRUCTS_H
#include <am-vector.h>
#include "natives_handles.h"
class CellArray
{
public:
CellArray(size_t blocksize, size_t basesize = 0) : m_Data(NULL), m_BlockSize(blocksize), m_AllocSize(0), m_BaseSize(basesize > 0 ? basesize : 8), m_Size(0)
CellArray(size_t blocksize, size_t basesize = 0) : m_Data(nullptr), m_BlockSize(blocksize), m_AllocSize(0), m_BaseSize(basesize > 0 ? basesize : 8), m_Size(0)
{
}
@ -99,7 +99,7 @@ public:
/* Make sure it'll fit */
if (!GrowIfNeeded(1))
{
return NULL;
return nullptr;
}
/* move everything up */
@ -185,29 +185,6 @@ private:
size_t m_Size;
};
extern ke::Vector<CellArray*> VectorHolder;
inline CellArray* HandleToVector(AMX* amx, int handle)
{
if (handle <= 0 || handle > (int)VectorHolder.length())
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
return NULL;
}
CellArray* ret = VectorHolder[handle - 1];
if (ret == NULL)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
return NULL;
}
return ret;
}
extern Handle<CellArray> ArrayHandles;
#endif

17
amxmodx/meta_api.cpp
View File

@ -399,16 +399,11 @@ int C_Spawn(edict_t *pent)
FlagMan.LoadFile();
for (unsigned int i=0; i<VectorHolder.length(); i++)
{
delete VectorHolder[i];
};
VectorHolder.clear();
g_TrieHandles.clear();
g_TrieSnapshotHandles.clear();
g_DataPackHandles.clear();
g_TextParsersHandles.clear();
ArrayHandles.clear();
TrieHandles.clear();
TrieSnapshotHandles.clear();
DataPackHandles.clear();
TextParsersHandles.clear();
GameConfigHandle.clear();
char map_pluginsfile_path[256];
@ -1330,7 +1325,7 @@ void C_AlertMessage(ALERT_TYPE atype, const char *szFmt, ...)
RETURN_META(MRES_SUPERCEDE);
}
RETURN_META(MRES_IGNORED);
RETURN_META(MRES_IGNORED);
}
void C_ChangeLevel(const char *map, const char *what)

34
amxmodx/natives_handles.h
View File

@ -7,8 +7,16 @@
// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
// https://alliedmods.net/amxmodx-license
#ifndef _NATIVES_HANDLES_H_
#define _NATIVES_HANDLES_H_
#include <am-vector.h>
// Note: All handles start at 1. 0 and below are invalid handles.
// This way, a plugin that doesn't initialize a vector or
// string will not be able to modify another plugin's data
// on accident.
template <typename T>
class Handle
{
@ -49,19 +57,37 @@ class Handle
return m_handles[handle];
}
int create()
template <typename... Targs>
int create(Targs... Fargs)
{
for (size_t i = 0; i < m_handles.length(); ++i)
{
if (!m_handles[i])
{
m_handles[i] = new T;
m_handles[i] = new T(Fargs...);
return static_cast<int>(i) + 1;
}
}
m_handles.append(new T);
m_handles.append(new T(Fargs...));
return m_handles.length();
}
int clone(T *data)
{
for (size_t i = 0; i < m_handles.length(); ++i)
{
if (!m_handles[i])
{
m_handles[i] = data;
return static_cast<int>(i) + 1;
}
}
m_handles.append(data);
return m_handles.length();
}
@ -86,3 +112,5 @@ class Handle
return true;
}
};
#endif // _NATIVE_HANDLES_H_

5
amxmodx/sorting.cpp
View File

@ -428,10 +428,11 @@ void sort_adt_random(CellArray *cArray)
static cell AMX_NATIVE_CALL SortADTArray(AMX *amx, cell *params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}

73
amxmodx/stackstructs.cpp
View File

@ -6,6 +6,7 @@
// This software is licensed under the GNU General Public License, version 3 or higher.
// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
// https://alliedmods.net/amxmodx-license
#include "amxmodx.h"
#include "datastructs.h"
@ -20,32 +21,17 @@ static cell AMX_NATIVE_CALL CreateStack(AMX* amx, cell* params)
return -1;
}
// Scan through the vector list to see if any are NULL.
// NULL means the vector was previously destroyed.
for (unsigned int i = 0; i < VectorHolder.length(); ++i)
{
if (VectorHolder[i] == NULL)
{
VectorHolder[i] = new CellArray(cellsize);
return i + 1;
}
}
// None are NULL, create a new vector
CellArray* NewVector = new CellArray(cellsize);
VectorHolder.append(NewVector);
return VectorHolder.length();
return ArrayHandles.create(cellsize);
}
// native PushStackCell(Stack:handle, any:value);
static cell AMX_NATIVE_CALL PushStackCell(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -65,10 +51,11 @@ static cell AMX_NATIVE_CALL PushStackCell(AMX* amx, cell* params)
// native PushStackString(Stack:handle, const value[]);
static cell AMX_NATIVE_CALL PushStackString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -91,10 +78,11 @@ static cell AMX_NATIVE_CALL PushStackString(AMX* amx, cell* params)
// native PushStackArray(Stack:handle, const any:values[], size= -1);
static cell AMX_NATIVE_CALL PushStackArray(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -122,10 +110,11 @@ static cell AMX_NATIVE_CALL PushStackArray(AMX* amx, cell* params)
// native bool:PopStackCell(Stack:handle, &any:value, block = 0, bool:asChar = false);
static cell AMX_NATIVE_CALL PopStackCell(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -169,10 +158,11 @@ static cell AMX_NATIVE_CALL PopStackCell(AMX* amx, cell* params)
// native bool:PopStackString(Stack:handle, buffer[], maxlength, &written = 0);
static cell AMX_NATIVE_CALL PopStackString(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -195,10 +185,11 @@ static cell AMX_NATIVE_CALL PopStackString(AMX* amx, cell* params)
// native bool:PopStackArray(Stack:handle, any:buffer[], size=-1);
static cell AMX_NATIVE_CALL PopStackArray(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -227,10 +218,11 @@ static cell AMX_NATIVE_CALL PopStackArray(AMX* amx, cell* params)
// native bool:IsStackEmpty(Stack:handle);
static cell AMX_NATIVE_CALL IsStackEmpty(AMX* amx, cell* params)
{
CellArray* vec = HandleToVector(amx, params[1]);
CellArray* vec = ArrayHandles.lookup(params[1]);
if (vec == NULL)
if (!vec)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", params[1]);
return 0;
}
@ -242,24 +234,19 @@ static cell AMX_NATIVE_CALL DestroyStack(AMX* amx, cell* params)
{
cell *handle = get_amxaddr(amx, params[1]);
if (*handle == 0)
CellArray* vec = ArrayHandles.lookup(*handle);
if (!vec)
{
return 0;
}
CellArray *vec = HandleToVector(amx, *handle);
if (vec == NULL)
if (ArrayHandles.destroy(*handle))
{
return 0;
*handle = 0;
return 1;
}
delete vec;
VectorHolder[*handle - 1] = NULL;
*handle = 0;
return 1;
}
@ -274,5 +261,5 @@ AMX_NATIVE_INFO g_StackNatives[] =
{ "PushStackCell", PushStackCell },
{ "PushStackString", PushStackString },
{ "DestroyStack", DestroyStack },
{ NULL, NULL },
{ nullptr, nullptr },
};

72
amxmodx/textparse.cpp
View File

@ -9,27 +9,25 @@
* https://alliedmods.net/amxmodx-license
*/
#include "amxmodx.h"
#include <textparse.h>
#include <am-vector.h>
#include "textparse.h"
TextParserHandles<ParseInfo> g_TextParsersHandles;
Handle<ParseInfo> TextParsersHandles;
cell createParser()
{
return g_TextParsersHandles.create();
return TextParsersHandles.create();
}
cell destroyParser(cell *handle)
{
ParseInfo *p = g_TextParsersHandles.lookup(*handle);
ParseInfo *p = TextParsersHandles.lookup(*handle);
if (p == NULL)
if (!p)
{
return 0;
}
if (g_TextParsersHandles.destroy(*handle))
if (TextParsersHandles.destroy(*handle))
{
*handle = 0;
return 1;
@ -52,16 +50,16 @@ static cell AMX_NATIVE_CALL SMC_CreateParser(AMX *amx, cell *params)
// native SMC_SetParseStart(SMCParser:handle, const func[]);
static cell AMX_NATIVE_CALL SMC_SetParseStart(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid SMC parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)) && length)
{
@ -80,16 +78,16 @@ static cell AMX_NATIVE_CALL SMC_SetParseStart(AMX *amx, cell *params)
// native SMC_SetParseEnd(SMCParser:handle, const func[]);
static cell AMX_NATIVE_CALL SMC_SetParseEnd(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid SMC parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)) && length)
{
@ -108,16 +106,16 @@ static cell AMX_NATIVE_CALL SMC_SetParseEnd(AMX *amx, cell *params)
// native SMC_SetReaders(SMCParser:smc, const kvFunc[], const nsFunc[] = "", const esFunc[] = "");
static cell AMX_NATIVE_CALL SMC_SetReaders(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid SMC parse handle (%d)", params[1]);
return 0;
}
int kvLength = 0, nsLength = 0, esLength = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, kvLength)) && kvLength)
{
@ -146,16 +144,16 @@ static cell AMX_NATIVE_CALL SMC_SetReaders(AMX *amx, cell *params)
// native SMC_SetRawLine(SMCParser:handle, const func[]);
static cell AMX_NATIVE_CALL SMC_SetRawLine(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid SMC parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)) && length)
{
@ -174,9 +172,9 @@ static cell AMX_NATIVE_CALL SMC_SetRawLine(AMX *amx, cell *params)
// native SMCError:SMC_ParseFile(SMCParser:handle, const file[], &line = 0, &col = 0);
static cell AMX_NATIVE_CALL SMC_ParseFile(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid SMC parse handle (%d)", params[1]);
return 0;
@ -227,9 +225,9 @@ static cell AMX_NATIVE_CALL INI_CreateParser(AMX *amx, cell *params)
// native bool:INI_ParseFile(INIParser:handle, const file[], &line = 0, &col = 0);
static cell AMX_NATIVE_CALL INI_ParseFile(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid INI parse handle (%d)", params[1]);
return 0;
@ -250,16 +248,16 @@ static cell AMX_NATIVE_CALL INI_ParseFile(AMX *amx, cell *params)
// native INI_SetParseStart(INIParser:handle, const func[]);
static cell AMX_NATIVE_CALL INI_SetParseStart(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid INI parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)) && length)
{
@ -278,16 +276,16 @@ static cell AMX_NATIVE_CALL INI_SetParseStart(AMX *amx, cell *params)
// native INI_SetParseEnd(INIParser:handle, const func[]);
static cell AMX_NATIVE_CALL INI_SetParseEnd(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid INI parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)))
{
@ -306,16 +304,16 @@ static cell AMX_NATIVE_CALL INI_SetParseEnd(AMX *amx, cell *params)
// native INI_SetReaders(INIParser:smc, const kvFunc[], const nsFunc[] = "" );
static cell AMX_NATIVE_CALL INI_SetReaders(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid INI parse handle (%d)", params[1]);
return 0;
}
int kvLength = 0, nsLength = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, kvLength)) && kvLength)
{
@ -339,16 +337,16 @@ static cell AMX_NATIVE_CALL INI_SetReaders(AMX *amx, cell *params)
// native INI_SetRawLine(INIParser:handle, const func[]);
static cell AMX_NATIVE_CALL INI_SetRawLine(AMX *amx, cell *params)
{
ParseInfo *p = g_TextParsersHandles.lookup(params[1]);
ParseInfo *p = TextParsersHandles.lookup(params[1]);
if (p == NULL)
if (!p)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid INI parse handle (%d)", params[1]);
return 0;
}
int length = 0;
const char *funcName = NULL;
const char *funcName = nullptr;
if ((funcName = get_amxstring(amx, params[2], 0, length)) && length)
{
@ -390,5 +388,5 @@ AMX_NATIVE_INFO g_TextParserNatives[] =
{ "INI_SetRawLine" , INI_SetRawLine },
{ "INI_DestroyParser" , INI_DestroyParser },
{ NULL, NULL },
{ nullptr , nullptr },
};

74
amxmodx/textparse.h
View File

@ -14,6 +14,7 @@
#include "amxmodx.h"
#include "CTextParsers.h"
#include "natives_handles.h"
class ParseInfo :
public ITextListener_SMC,
@ -131,77 +132,6 @@ public:
int handle;
};
template <typename T>
class TextParserHandles
{
private:
ke::Vector<T *> m_textparsers;
public:
TextParserHandles() { }
~TextParserHandles()
{
this->clear();
}
void clear()
{
for (size_t i = 0; i < m_textparsers.length(); i++)
{
if (m_textparsers[i] != NULL)
{
delete m_textparsers[i];
}
}
m_textparsers.clear();
}
T *lookup(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_textparsers.length()))
{
return NULL;
}
return m_textparsers[handle];
}
int create()
{
for (size_t i = 0; i < m_textparsers.length(); i++)
{
if (m_textparsers[i] == NULL)
{
// reuse handle
m_textparsers[i] = new T;
return static_cast<int>(i)+1;
}
}
m_textparsers.append(new T);
return m_textparsers.length();
}
bool destroy(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_textparsers.length()))
{
return false;
}
if (m_textparsers[handle] == NULL)
{
return false;
}
delete m_textparsers[handle];
m_textparsers[handle] = NULL;
return true;
}
};
extern TextParserHandles<ParseInfo> g_TextParsersHandles;
extern Handle<ParseInfo> TextParsersHandles;
#endif // _INCLUDE_TEXTPARSE_H_

117
amxmodx/trie_natives.cpp
View File

@ -7,28 +7,23 @@
// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
// https://alliedmods.net/amxmodx-license
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include "amxmodx.h"
#include "trie_natives.h"
TrieHandles<CellTrie> g_TrieHandles;
TrieHandles<TrieSnapshot> g_TrieSnapshotHandles;
Handle<CellTrie> TrieHandles;
Handle<TrieSnapshot> TrieSnapshotHandles;
// native Trie:TrieCreate();
static cell AMX_NATIVE_CALL TrieCreate(AMX *amx, cell *params)
{
return static_cast<cell>(g_TrieHandles.create());
return static_cast<cell>(TrieHandles.create());
}
// native Trie::TrieClear(Trie:handle);
static cell AMX_NATIVE_CALL TrieClear(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -40,9 +35,9 @@ static cell AMX_NATIVE_CALL TrieClear(AMX *amx, cell *params)
// native TrieSetCell(Trie:handle, const key[], any:value, bool:replace = true);
static cell AMX_NATIVE_CALL TrieSetCell(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -76,9 +71,9 @@ static cell AMX_NATIVE_CALL TrieSetCell(AMX *amx, cell *params)
// native TrieSetString(Trie:handle, const key[], const data[], bool:replace = true);
static cell AMX_NATIVE_CALL TrieSetString(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -113,9 +108,9 @@ static cell AMX_NATIVE_CALL TrieSetString(AMX *amx, cell *params)
// native TrieSetArray(Trie:handle, const key[], const any:buffer[], buffsize, bool:replace = true)
static cell AMX_NATIVE_CALL TrieSetArray(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -157,9 +152,9 @@ static cell AMX_NATIVE_CALL TrieSetArray(AMX *amx, cell *params)
// native bool:TrieGetCell(Trie:handle, const key[], &any:value);
static cell AMX_NATIVE_CALL TrieGetCell(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -189,9 +184,9 @@ static cell AMX_NATIVE_CALL TrieGetCell(AMX *amx, cell *params)
// native bool:TrieGetString(Trie:handle, const key[], buff[], len, &size = 0);
static cell AMX_NATIVE_CALL TrieGetString(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -221,9 +216,9 @@ static cell AMX_NATIVE_CALL TrieGetString(AMX *amx, cell *params)
// native bool:TrieGetArray(Trie:handle, const key[], any:buff[], len, &size = 0);
static cell AMX_NATIVE_CALL TrieGetArray(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -272,9 +267,9 @@ static cell AMX_NATIVE_CALL TrieGetArray(AMX *amx, cell *params)
// native bool:TrieKeyExists(Trie:handle, const key[]);
static cell AMX_NATIVE_CALL TrieKeyExists(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -289,9 +284,9 @@ static cell AMX_NATIVE_CALL TrieKeyExists(AMX *amx, cell *params)
// native bool:TrieDeleteKey(Trie:handle, const key[]);
static cell AMX_NATIVE_CALL TrieDeleteKey(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -317,14 +312,14 @@ static cell AMX_NATIVE_CALL TrieDestroy(AMX *amx, cell *params)
{
cell *ptr = get_amxaddr(amx, params[1]);
CellTrie *t = g_TrieHandles.lookup(*ptr);
CellTrie *t = TrieHandles.lookup(*ptr);
if (t == NULL)
if (!t)
{
return 0;
}
if (g_TrieHandles.destroy(*ptr))
if (TrieHandles.destroy(*ptr))
{
*ptr = 0;
return 1;
@ -336,9 +331,9 @@ static cell AMX_NATIVE_CALL TrieDestroy(AMX *amx, cell *params)
// native TrieGetSize(Trie:handle);
static cell AMX_NATIVE_CALL TrieGetSize(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
@ -349,16 +344,16 @@ static cell AMX_NATIVE_CALL TrieGetSize(AMX *amx, cell *params)
static cell AMX_NATIVE_CALL TrieSnapshotCreate(AMX *amx, cell *params)
{
CellTrie *t = g_TrieHandles.lookup(params[1]);
CellTrie *t = TrieHandles.lookup(params[1]);
if (t == NULL)
if (!t)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
return 0;
}
int index = g_TrieSnapshotHandles.create();
TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(index);
int index = TrieSnapshotHandles.create();
TrieSnapshot *snapshot = TrieSnapshotHandles.lookup(index);
snapshot->length = t->map.elements();
snapshot->keys = new int[snapshot->length];
@ -374,9 +369,9 @@ static cell AMX_NATIVE_CALL TrieSnapshotCreate(AMX *amx, cell *params)
static cell AMX_NATIVE_CALL TrieSnapshotLength(AMX *amx, cell *params)
{
TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
TrieSnapshot *snapshot = TrieSnapshotHandles.lookup(params[1]);
if (snapshot == NULL)
if (!snapshot)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
return 0;
@ -387,9 +382,9 @@ static cell AMX_NATIVE_CALL TrieSnapshotLength(AMX *amx, cell *params)
static cell AMX_NATIVE_CALL TrieSnapshotKeyBufferSize(AMX *amx, cell *params)
{
TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
TrieSnapshot *snapshot = TrieSnapshotHandles.lookup(params[1]);
if (snapshot == NULL)
if (!snapshot)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
return 0;
@ -408,9 +403,9 @@ static cell AMX_NATIVE_CALL TrieSnapshotKeyBufferSize(AMX *amx, cell *params)
static cell AMX_NATIVE_CALL TrieSnapshotGetKey(AMX *amx, cell *params)
{
TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
TrieSnapshot *snapshot = TrieSnapshotHandles.lookup(params[1]);
if (snapshot == NULL)
if (!snapshot)
{
LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
return 0;
@ -433,14 +428,14 @@ static cell AMX_NATIVE_CALL TrieSnapshotDestroy(AMX *amx, cell *params)
{
cell *ptr = get_amxaddr(amx, params[1]);
TrieSnapshot *t = g_TrieSnapshotHandles.lookup(*ptr);
TrieSnapshot *t = TrieSnapshotHandles.lookup(*ptr);
if (t == NULL)
if (!t)
{
return 0;
}
if (g_TrieSnapshotHandles.destroy(*ptr))
if (TrieSnapshotHandles.destroy(*ptr))
{
*ptr = 0;
return 1;
@ -451,28 +446,28 @@ static cell AMX_NATIVE_CALL TrieSnapshotDestroy(AMX *amx, cell *params)
AMX_NATIVE_INFO trie_Natives[] =
{
{ "TrieCreate", TrieCreate },
{ "TrieClear", TrieClear },
{ "TrieCreate" , TrieCreate },
{ "TrieClear" , TrieClear },
{ "TrieSetCell", TrieSetCell },
{ "TrieSetString", TrieSetString },
{ "TrieSetArray", TrieSetArray },
{ "TrieSetCell" , TrieSetCell },
{ "TrieSetString" , TrieSetString },
{ "TrieSetArray" , TrieSetArray },
{ "TrieGetCell", TrieGetCell },
{ "TrieGetString", TrieGetString },
{ "TrieGetArray", TrieGetArray },
{ "TrieGetCell" , TrieGetCell },
{ "TrieGetString" , TrieGetString },
{ "TrieGetArray" , TrieGetArray },
{ "TrieDeleteKey", TrieDeleteKey },
{ "TrieKeyExists", TrieKeyExists },
{ "TrieDestroy", TrieDestroy },
{ "TrieGetSize", TrieGetSize },
{ "TrieDeleteKey" , TrieDeleteKey },
{ "TrieKeyExists" , TrieKeyExists },
{ "TrieDestroy" , TrieDestroy },
{ "TrieGetSize" , TrieGetSize },
{ "TrieSnapshotCreate", TrieSnapshotCreate },
{ "TrieSnapshotLength", TrieSnapshotLength },
{ "TrieSnapshotCreate" , TrieSnapshotCreate },
{ "TrieSnapshotLength" , TrieSnapshotLength },
{ "TrieSnapshotKeyBufferSize", TrieSnapshotKeyBufferSize },
{ "TrieSnapshotGetKey", TrieSnapshotGetKey },
{ "TrieSnapshotDestroy", TrieSnapshotDestroy },
{ "TrieSnapshotGetKey" , TrieSnapshotGetKey },
{ "TrieSnapshotDestroy" , TrieSnapshotDestroy },
{ NULL, NULL }
{ nullptr , nullptr}
};

78
amxmodx/trie_natives.h
View File

@ -13,7 +13,7 @@
#include "amxmodx.h"
#include <sm_stringhashmap.h>
#include <sm_memtable.h>
#include "CVector.h"
#include "natives_handles.h"
enum EntryType
{
@ -159,80 +159,8 @@ struct TrieSnapshot
BaseStringTable strings;
};
template <typename T>
class TrieHandles
{
private:
CVector<T *> m_tries;
public:
TrieHandles() { }
~TrieHandles()
{
this->clear();
}
void clear()
{
for (size_t i = 0; i < m_tries.size(); i++)
{
if (m_tries[i] != NULL)
{
delete m_tries[i];
}
}
m_tries.clear();
}
T *lookup(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_tries.size()))
{
return NULL;
}
return m_tries[handle];
}
int create()
{
for (size_t i = 0; i < m_tries.size(); i++)
{
if (m_tries[i] == NULL)
{
// reuse handle
m_tries[i] = new T;
return static_cast<int>(i) + 1;
}
}
m_tries.push_back(new T);
return m_tries.size();
}
bool destroy(int handle)
{
handle--;
if (handle < 0 || handle >= static_cast<int>(m_tries.size()))
{
return false;
}
if (m_tries[handle] == NULL)
{
return false;
}
delete m_tries[handle];
m_tries[handle] = NULL;
return true;
}
};
extern TrieHandles<CellTrie> g_TrieHandles;
extern TrieHandles<TrieSnapshot> g_TrieSnapshotHandles;
extern Handle<CellTrie> TrieHandles;
extern Handle<TrieSnapshot> TrieSnapshotHandles;
extern AMX_NATIVE_INFO trie_Natives[];
#endif