amxmodx/dlls/arrayx/CArray.h

734 lines
19 KiB
C
Raw Normal View History

Pvoid_t MasterArray = (Pvoid_t) NULL; //Create the control array
//Create an array that stores whether or not indices are used.
Pvoid_t MasterArray_Binary = (Pvoid_t) NULL;
void DeleteMasterArray(void);
Word_t NewArray(Word_t Index, Word_t reserve = 0);
PPvoid_t Find_Array(Word_t Index, Word_t disable_check = 1, AMX *amx = 0);
void DeleteArray(Word_t Index);
void ClearArray(Word_t Index);
template <class Type>
void Array_Set(PPvoid_t Array, char* Index, Type value);
PPvoid_t Array_Get(AMX* amx, PPvoid_t Array, Word_t Index, int ignore_error = 0);
void DeleteCell(Pvoid_t* Array, Word_t Index);
void Delete_MasterArray(void)
{
Word_t
Index = 0,
success = 0;
J1F(success, MasterArray_Binary, Index);
while( success )
{
DeleteArray( Index ); //Delete array.
J1F(success, MasterArray_Binary, Index); //Get next array
}
}
Word_t NewArray(Word_t Index, Word_t reserve)
{
Word_t success; //Dummy for macros.
J1T(success, MasterArray_Binary, Index); //Check if bit is already set.
if (success && reserve)
return Index; //If the bit is set but it's 'reserved', return the index.
//Only do this if the bit is not set.
J1FE(success, MasterArray_Binary, Index);
J1S(success, MasterArray_Binary, Index);
PPvoid_t Array = JudyLIns(&MasterArray, Index, PJE0);
*Array = (PWord_t) NULL;
return Index;
}
PPvoid_t Find_Array(Word_t Index, Word_t disable_check, AMX *amx)
{
Word_t success;
J1T(success, MasterArray_Binary, Index);
if (success || disable_check)
{ //Bit is valid
if(!success)
NewArray(Index);
return JudyLGet( MasterArray, Index, PJE0);
}
MF_LogError(amx,AMX_ERR_NATIVE,"Array %d is invalid", Index);
return NULL;
}
void DeleteArray(Word_t Index)
{
int success;
J1T(success, MasterArray_Binary, Index);
if (success)
{ //If the bit is set, clear and delete array.
ClearArray(Index);
J1U(success, MasterArray_Binary, Index);
JudyLDel(&MasterArray, Index, PJE0);
}
}
void ClearArray(Word_t Index)
{
int success;
J1T(success, MasterArray_Binary, Index);
if (success) //dont bother with unset arrays.
{
PPvoid_t Array = Find_Array(Index);
Word_t index = 0;
PPvoid_t PValue = JudyLFirst(*Array, &index, PJE0);
while (PValue != NULL)
{
element elem_value = *reinterpret_cast<element*>(*PValue);
elem_value.delete_element();
PValue = JudyLNext(*Array, &index, PJE0);
}
JudyLFreeArray(Array, PJE0);
}
}
static cell AMX_NATIVE_CALL new_array(AMX *amx,cell *params)
{
return NewArray(params[1], params[2]);
}
template <class Type> //This will support input char*, Vector*, int, and cell_real*.
void Array_Set(PPvoid_t Array, int Index, Type value)
{
PPvoid_t PValue; // pointer to array element value
PValue = JudyLIns(Array, Index, PJE0);
*PValue = reinterpret_cast<void*>(value);
}
PPvoid_t Array_Get(AMX* amx, PPvoid_t Array, int Index, int ignore_error = 0)
{
PPvoid_t PValue = JudyLGet( *Array, Index, PJE0 );
if (PValue == NULL && !ignore_error)
MF_LogError(amx, AMX_ERR_NATIVE, "Array index %d is invalid", Index);
return PValue;
}
void DeleteCell(PPvoid_t Array, Word_t Index)
{
JudyLDel(Array, Index, PJE0);
}
static cell AMX_NATIVE_CALL delete_array(AMX *amx,cell *params)
{
DeleteArray( params[1] );
return 1;
}
static cell AMX_NATIVE_CALL clear_array(AMX *amx,cell *params)
{
ClearArray( params[1] );
return 1;
}
static cell AMX_NATIVE_CALL Array_Save(AMX *amx, cell *params)
{
PPvoid_t Array = Find_Array(params[1], params[3], amx);
if (Array == NULL) return 0;
int filename_length;
char *file = MF_GetAmxString(amx, params[2], 0, &filename_length);
file = MF_BuildPathname("%s", file);
unlink(file);
FILE *ArrayDB = fopen(file,"w");
if (!ArrayDB)
return 0;
Word_t Index = 0;
PPvoid_t PValue = JudyLFirst(*Array, &Index, PJE0);
element elem = NULL;
char elem_type = 0;
int error;
REAL vector_data[3] = { 0.0, 0.0, 0.0 };
while (PValue)
{
elem = *reinterpret_cast<element*>(*PValue);
elem_type = elem.get_type();
if (elem_type < elem_type_int || elem_type > elem_type_vector)
continue;
fwrite(&Index, sizeof(int), 1, ArrayDB);
fwrite(&elem_type, sizeof(char), 1, ArrayDB);
if (elem_type == elem_type_int)
{
int int_buffer = elem.get_int(error);
fwrite(&int_buffer, sizeof(int), 1, ArrayDB);
}
else if (elem_type == elem_type_real)
{
REAL flo_buffer = elem.get_flo(error);
fwrite(&flo_buffer, sizeof(REAL), 1, ArrayDB);
}
else if (elem_type == elem_type_char)
{
const char* str_buffer = elem.get_str(error);
short buf_len = strlen(str_buffer);
fwrite(&buf_len, sizeof(short), 1, ArrayDB);
fwrite(str_buffer, sizeof(char), buf_len, ArrayDB);
}
else if (elem_type == elem_type_vector)
{
const Vector* vec_buffer = elem.get_vec(error);
fwrite(vec_buffer, sizeof(Vector), 1, ArrayDB);
}
PValue = JudyLNext(*Array, &Index, PJE0);
}
fclose(ArrayDB);
return 1;
}
static cell AMX_NATIVE_CALL Array_Load(AMX *amx, cell *params)
{
//params[1]: file
int filename_length;
char *file = MF_GetAmxString(amx, params[1], 0, &filename_length);
file = MF_BuildPathname("%s", file);
FILE *ArrayDB = fopen(file, "a+");
if (!ArrayDB)
return 0;
//params[2]: array to create (optional index supplied)
int ArrayIndex = NewArray(params[2], params[3]);
ClearArray(ArrayIndex); //make sure the array is empty.
PPvoid_t Array = Find_Array(ArrayIndex);
while(!feof(ArrayDB))
{
int index = 0; char type = 0;
element *elem_value = NULL;
fread(&index, sizeof(int), 1, ArrayDB);
if (feof(ArrayDB) || ferror(ArrayDB))
break;
fread(&type, sizeof(char), 1, ArrayDB);
if (type < elem_type_int || type > elem_type_vector)
{
MF_LogError(amx, AMX_ERR_FORMAT, "Error loading array database \"%s\" into array %d. Bad file.", file, ArrayIndex);
return ArrayIndex;
}
else if (type == elem_type_int)
{
int value = 0; fread(&value, sizeof(int), 1, ArrayDB);
elem_value = new element(value);
}
else if (type == elem_type_real)
{
REAL value = 0; fread(&value, sizeof(REAL), 1, ArrayDB);
elem_value = new element(value);
}
else if (type == elem_type_char)
{
short length; fread(&length, sizeof(short), 1, ArrayDB);
char* value = new char[length+1]; fgets(value, length+1, ArrayDB);
elem_value = new element(value);
delete(value);
}
else if (type == elem_type_vector)
{
Vector *value = new Vector(); fread(value, sizeof(Vector), 1, ArrayDB);
elem_value = new element(value);
}
Array_Set(Array,index,elem_value);
}
fclose(ArrayDB);
return ArrayIndex;
}
static cell AMX_NATIVE_CALL Array_Save_ASCII(AMX *amx, cell *params)
{
//params[1]: file
int filename_length;
char *inputfile = MF_GetAmxString(amx, params[1], 0, &filename_length);
inputfile = MF_BuildPathname("%s", inputfile);
FILE *ArrayDB = fopen(inputfile, "a+");
if (!ArrayDB)
return 0;
char *outputfile = MF_GetAmxString(amx, params[2], 0, &filename_length);
outputfile = MF_BuildPathname("%s", outputfile);
FILE *ReadableDB = fopen(outputfile, "w");
char *buffer = "\0";
char *buffer_two = "\0";
while(!feof(ArrayDB))
{
Word_t index = 0; char type = 0;
fread(&index, sizeof(int), 1, ArrayDB);
if (feof(ArrayDB) || ferror(ArrayDB))
break;
fread(&type, sizeof(char), 1, ArrayDB);
sprintf(buffer, "Index % 11d\tType %7s,", index, elem_types[type]);
if (type < elem_type_int || type > elem_type_vector)
{
MF_LogError(amx, AMX_ERR_FORMAT, "Error loading array database \"%s\" into readable format. Bad file.", inputfile);
return 0;
}
else if (type == elem_type_int)
{
int value = 0; fread(&value, sizeof(int), 1, ArrayDB);
sprintf(buffer, "%s\t\t\tValue: %d\n", buffer, value);
}
else if (type == elem_type_real)
{
REAL value = 0; fread(&value, sizeof(REAL), 1, ArrayDB);
sprintf(buffer, "%s\t\t\tValue: %f\n", buffer, value);
}
else if (type == elem_type_char)
{
short length; fread(&length, sizeof(short), 1, ArrayDB);
char* value = new char[length+1]; fgets(value, length+1, ArrayDB);
sprintf(buffer, "%s Length: %d\tValue: \"%s\"\n", buffer, length, value);
delete value;
}
else if (type == elem_type_vector)
{
Vector *value = new Vector(); fread(value, sizeof(Vector), 1, ArrayDB);
sprintf(buffer, "%s\t\t\tValue: {%f,%f,%f}\n", buffer, (*value).x, (*value).y, (*value).z);
delete value;
}
fwrite(buffer, sizeof(char), strlen(buffer), ReadableDB);
}
fclose(ArrayDB);
fclose(ReadableDB);
return 1;
}
static cell AMX_NATIVE_CALL Array_SetVector(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1], params[4], amx);
if (Array == NULL) return 0;
cell *input_vec = MF_GetAmxAddr(amx, params[3]);
Vector *value = new Vector(
amx_ctof(input_vec[0]),
amx_ctof(input_vec[1]),
amx_ctof(input_vec[2])
);
int Index = params[2];
PPvoid_t PValue = Array_Get(amx, Array, Index, 1);
element *elem_value = NULL;
if ( PValue == NULL )
elem_value = new element(value);
else
{
elem_value = reinterpret_cast<element*>(*PValue);
(*elem_value).set_vec(value);
}
Array_Set(Array,Index,elem_value);
return 1;
}
static cell AMX_NATIVE_CALL Array_GetVector(AMX *amx, cell *params)
{
PPvoid_t Array = Find_Array(params[1], params[4], amx);
if (Array == NULL) return 0;
int Index = params[2];
PPvoid_t PValue = Array_Get(amx, Array, Index, params[4]);
cell *vAmx = MF_GetAmxAddr(amx, params[3]);
if( PValue == NULL ) {
vAmx[0] = amx_ftoc(0);
vAmx[1] = amx_ftoc(0);
vAmx[2] = amx_ftoc(0);
return 0;
}
element elem_value = *reinterpret_cast<element*>(*PValue);
int error = 0;
const Vector retr_vec = *elem_value.get_vec(error);
if (error)
elem_value.issue_type_error(amx, params[1], Index);
vAmx[0] = amx_ftoc(retr_vec.x);
vAmx[1] = amx_ftoc(retr_vec.y);
vAmx[2] = amx_ftoc(retr_vec.z);
return 1;
}
static cell AMX_NATIVE_CALL Array_SetString(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[4], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
//params[3]: value
int iLen = 0;
char *value = MF_GetAmxString(amx,params[3],1,&iLen);
//element that is stored at index
PPvoid_t PValue = Array_Get(amx, Array, Index, 1);
element *elem_value = NULL;
if ( PValue == NULL )
elem_value = new element(value);
else
{
elem_value = reinterpret_cast<element*>(*PValue);
(*elem_value).set_str(value);
}
Array_Set(Array,Index,elem_value);
return 1;
}
static cell AMX_NATIVE_CALL Array_GetString(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[5], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
Pvoid_t * PValue = Array_Get(amx, Array, Index, params[5]);
//params[3] and params[4] are the return string and length respectively.
if( PValue == NULL ) return MF_SetAmxString( amx , params[3] , "dne", params[4] );
element elem_value = *reinterpret_cast<element*>(*PValue);
int error = 0;
const char* str_out = elem_value.get_str(error);
if (error)
elem_value.issue_type_error(amx, params[1], Index);
return MF_SetAmxString( amx , params[3] , str_out, params[4] );
}
static cell AMX_NATIVE_CALL Array_SetFloat(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[4], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
//params[3]: value
PPvoid_t PValue = Array_Get(amx, Array, Index, 1);
element *elem_value = NULL;
if ( PValue == NULL )
elem_value = new element(amx_ctof(params[3]));
else
{
elem_value = reinterpret_cast<element*>(*PValue);
(*elem_value).set_flo(amx_ctof(params[3]));
}
Array_Set(Array,Index,elem_value);
return 1;
}
static cell AMX_NATIVE_CALL Array_GetFloat(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[3], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
PPvoid_t PValue = Array_Get(amx, Array, Index, params[3]);
if( PValue == NULL ) return amx_ftoc(0.0);
element elem_value = *reinterpret_cast<element*>(*PValue);
int error = 0;
cell retr_float = amx_ftoc(elem_value.get_flo(error));
if (error)
elem_value.issue_type_error(amx, params[1], Index);
return retr_float;
}
static cell AMX_NATIVE_CALL Array_SetInt(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[3], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
PPvoid_t PValue = Array_Get(amx, Array, Index, 1);
element *elem_value = NULL;
if ( PValue == NULL )
elem_value = new element(params[3]);
else
{
elem_value = reinterpret_cast<element*>(*PValue);
(*elem_value).set_int(params[3]);
}
Array_Set(Array,Index,elem_value);
return 1;
}
static cell AMX_NATIVE_CALL Array_GetInt(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1], params[3], amx);
if (Array == NULL) return 0;
//params[2]: index
int Index = params[2];
Pvoid_t * PValue = Array_Get(amx, Array, Index, params[3]);
if( PValue == NULL ) return 0;
element elem_value = *reinterpret_cast<element*>(*PValue);
int error = 0;
cell retr_int = elem_value.get_int(error);
if (error)
elem_value.issue_type_error(amx, params[1], Index);
return retr_int;
}
static cell AMX_NATIVE_CALL array_size(AMX *amx,cell *params)
{
Pvoid_t * Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
return JudyLCount( *Array, params[2], params[3],PJE0);
}
static cell AMX_NATIVE_CALL array_count(AMX *amx,cell *params)
{
return JudyLCount( MasterArray, params[1], params[2],PJE0);
}
static cell AMX_NATIVE_CALL array_memory(AMX *amx,cell *params)
{
Pvoid_t * Array = Find_Array(params[1],params[2],amx);
if (Array == NULL) return 0;
return JudyLMemUsed(*Array);
}
static cell AMX_NATIVE_CALL delete_cell(AMX *amx,cell *params)
{
Pvoid_t * Array = Find_Array(params[1]);
if (Array == NULL) return 0;
DeleteCell( Array, params[2] );
return 1;
}
static cell AMX_NATIVE_CALL array_next(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = Word_t(params[2]);
cell *success = MF_GetAmxAddr(amx, params[3]);
PPvoid_t pointer;
pointer = JudyLNext(*Array, &Index, PJE0);
*success = (pointer == NULL) ? 0 : 1;
return cell(Index);
}
static cell AMX_NATIVE_CALL array_prev(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = Word_t(params[2]);
cell *success = MF_GetAmxAddr(amx, params[3]);
PPvoid_t pointer;
pointer = JudyLPrev(*Array, &Index, PJE0);
*success = (pointer == NULL) ? 0 : 1;
return cell(Index);
}
static cell AMX_NATIVE_CALL array_first(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = Word_t(params[2]);
cell *success = MF_GetAmxAddr(amx, params[3]);
PPvoid_t pointer;
pointer = JudyLFirst(*Array, &Index, PJE0);
*success = (pointer == NULL) ? 0 : 1;
return cell(Index);
}
static cell AMX_NATIVE_CALL array_last(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = Word_t(params[2]);
cell *success = MF_GetAmxAddr(amx, params[3]);
PPvoid_t pointer;
pointer = JudyLLast(*Array, &Index, PJE0);
*success = (pointer == NULL) ? 0 : 1;
return cell(Index);
}
static cell AMX_NATIVE_CALL array_nextempty(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = (Word_t)params[2];
cell *success = MF_GetAmxAddr(amx, params[3]);
*success = JudyLNextEmpty(*Array, &Index, PJE0);
return (cell)Index;
}
static cell AMX_NATIVE_CALL array_prevempty(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = (Word_t)params[2];
cell *success = MF_GetAmxAddr(amx, params[3]);
*success = JudyLPrevEmpty(*Array, &Index, PJE0);
return (cell)Index;
}
static cell AMX_NATIVE_CALL array_firstempty(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = (Word_t)params[2];
cell *success = MF_GetAmxAddr(amx, params[3]);
*success = JudyLFirstEmpty(*Array, &Index, PJE0);
return (cell)Index;
}
static cell AMX_NATIVE_CALL array_lastempty(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = (Word_t)params[2];
cell *success = MF_GetAmxAddr(amx, params[3]);
*success = JudyLLastEmpty(*Array, &Index, PJE0);
return (cell)Index;
}
static cell AMX_NATIVE_CALL array_isempty(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[3],amx);
if (Array == NULL) return 0;
PPvoid_t pointer;
pointer = JudyLGet(*Array, params[2], PJE0);
return (pointer == NULL) ? 1 : 0;
}
static cell AMX_NATIVE_CALL array_isfilled(AMX *amx,cell *params)
{
//params[1]: array
PPvoid_t Array = Find_Array(params[1],params[3],amx);
if (Array == NULL) return 0;
//params[2]: index
PPvoid_t pointer;
pointer = JudyLGet(*Array, params[2], PJE0);
return (pointer != NULL) ? 1 : 0;
}
static cell AMX_NATIVE_CALL Array_ByCount(AMX *amx,cell *params)
{
PPvoid_t Array = Find_Array(params[1],params[4],amx);
if (Array == NULL) return 0;
Word_t Index = Word_t(params[3]);
cell *success = MF_GetAmxAddr(amx, params[4]);
PPvoid_t pointer;
pointer = JudyLByCount(*Array, params[2], &Index, PJE0);
*success = (pointer == NULL) ? 0 : 1;
return cell(Index);
}
AMX_NATIVE_INFO array_exports[] = {
{ "array_set_string", Array_SetString },
{ "array_get_string", Array_GetString },
{ "array_set_int", Array_SetInt },
{ "array_get_int", Array_GetInt },
{ "array_set_float", Array_SetFloat },
{ "array_get_float", Array_GetFloat },
{ "array_set_vector", Array_SetVector },
{ "array_get_vector", Array_GetVector },
{ "array_isempty", array_isempty },
{ "array_isfilled", array_isfilled },
{ "array_remove", delete_cell },
{ "array_create", new_array },
{ "array_delete", delete_array },
{ "array_clear", clear_array },
{ "array_size", array_size },
{ "array_count", array_count },
{ "array_memory", array_memory },
{ "array_nextempty", array_nextempty },
{ "array_prevempty", array_prevempty },
{ "array_firstempty", array_firstempty },
{ "array_lastempty", array_lastempty },
{ "array_next", array_next },
{ "array_prev", array_prev },
{ "array_first", array_first },
{ "array_last", array_last },
{ "array_save", Array_Save },
{ "array_load", Array_Load },
{ "array_get_nth", Array_ByCount },
{ "array_save_ascii", Array_Save_ASCII },
{ NULL, NULL }
};