#include <vector>
#include <algorithm>
namespace NAMESPACE
{
void PushInt(const int& value)
{
parser->datastack.Push(value);
parser->datastack.Push(zPAR_TOK_PUSHINT);
}
void PushString(const zSTRING& value)
{
parser->datastack.Push(reinterpret_cast<int>(&value));
parser->datastack.Push(zPAR_TOK_PUSHVAR);
}
void PushFloat(const float& value)
{
parser->datastack.Push(reinterpret_cast<const int&>(value));
parser->datastack.Push(zPAR_TOK_PUSHINT);
}
void Call(const int& funcIndex)
{
parser->DoStack(parser->GetSymbol(funcIndex)->single_intdata);
}
int GetFuncAddress(zCPar_Symbol* sym)
{
if (!sym->HasFlag(zPAR_FLAG_CONST) || sym->HasFlag(zPAR_FLAG_EXTERNAL) || sym->HasFlag(zPAR_FLAG_MERGED))
{
return -1;
}
if (sym->type != zPAR_TYPE_FUNC && sym->type != zPAR_TYPE_INSTANCE && sym->type != zPAR_TYPE_PROTOTYPE)
{
return -1;
}
const char* name = sym->name.ToChar();
for (int i = 0; name[i] != '\0' && name[i] != '\n'; i++)
{
if (name[i] == '.')
{
return -1;
}
}
return sym->single_intdata;
}
struct FuncEntity
{
int index;
int address;
FuncEntity(int index, int address) :
index(index),
address(address)
{
}
};
std::vector<FuncEntity> functions;
bool initialized = false;
void InitFunctions()
{
if (initialized)
{
return;
}
for (int i = 0; i < parser->symtab.GetNumInList(); i++)
{
int address = GetFuncAddress(parser->GetSymbol(i));
if (address == -1)
{
continue;
}
functions.push_back(FuncEntity(i, address));
}
std::sort(functions.begin(), functions.end(), [](const FuncEntity & x, const FuncEntity & y) { return x.address < y.address; });
initialized = true;
}
const zSTRING& GetFuncNameByAddress(int address)
{
auto it = std::lower_bound(functions.begin(), functions.end(), FuncEntity(-1, address), [](const FuncEntity& x, const FuncEntity& y) { return x.address <= y.address; });
it--;
return parser->GetSymbol(it->index)->name;
}
void TerminateGame()
{
gameMan->ExitGame();
}
void ExtractSegments(string name, zCArray<string>& segments)
{
int nextStart = 0;
for (size_t i = 0; i <= name.Length(); i++)
{
if (i == name.Length() || name[i] == '.')
{
segments.InsertEnd(name.Copy(nextStart, i - nextStart));
nextStart = i + 1;
}
}
}
bool ValidateSegments(const zCArray<string> & segments)
{
if (segments.GetNum() < 1 || segments.GetNum() > 2)
{
return false;
}
for (int i = 0; i < segments.GetNum(); i++)
{
if (segments[i].IsEmpty())
{
return false;
}
}
return true;
}
void ShowParserError(string data)
{
const zSTRING& func = GetFuncNameByAddress(parser->stack.stackptr - parser->stack.stack);
Message::Error((string)"Error in function " + func.ToChar() + ".\n" + data + ".", "Loops Error");
TerminateGame();
}
bool ValidateArrayType(int type)
{
switch (type)
{
case zPAR_TYPE_INT:
case zPAR_TYPE_FLOAT:
case zPAR_TYPE_FUNC:
case zPAR_TYPE_STRING:
return true;
default:
return false;
}
}
zSTRING& GetInstanceClassName(zCPar_Symbol * instance)
{
while (instance->GetParent())
{
instance = instance->GetParent();
}
return instance->name;
}
void GetArray(zSTRING& arrayName, zCPar_Symbol*& arrayDesc, void*& pointer, int& size)
{
InitFunctions();
arrayDesc = nullptr;
pointer = nullptr;
size = 0;
string name = arrayName.ToChar();
name.Upper();
zCArray<string> segments;
ExtractSegments(name, segments);
if (!ValidateSegments(segments))
{
return ShowParserError((string)"Invalid array name: " + arrayName.ToChar());
}
string funcName = GetFuncNameByAddress(parser->stack.stackptr - parser->stack.stack).ToChar();
zCPar_Symbol* symbol = parser->GetSymbol((funcName + "." + segments[0]).GetVector());
if (!symbol)
{
symbol = parser->GetSymbol(segments[0].GetVector());
}
if (!symbol)
{
return ShowParserError((string)"Variable not found: " + segments[0]);
}
if (segments.GetNum() == 1)
{
if (!ValidateArrayType(symbol->type))
{
return ShowParserError((string)"Invalid array type: " + symbol->type);
}
arrayDesc = symbol;
size = arrayDesc->ele;
switch (arrayDesc->type)
{
case zPAR_TYPE_INT:
case zPAR_TYPE_FUNC:
pointer = (size == 1) ? &arrayDesc->single_intdata : arrayDesc->intdata;
break;
case zPAR_TYPE_FLOAT:
pointer = (size == 1) ? &arrayDesc->single_floatdata : arrayDesc->floatdata;
break;
case zPAR_TYPE_STRING:
pointer = arrayDesc->stringdata;
break;
}
return;
}
if (symbol->type != zPAR_TYPE_INSTANCE)
{
return ShowParserError(segments[0] + " is not instance");
}
string className = GetInstanceClassName(symbol).ToChar();
string classVarName = className + "." + segments[1];
zCPar_Symbol* classVarSymbol = parser->GetSymbol(classVarName.GetVector());
if (!classVarSymbol)
{
return ShowParserError((string)"Can't find class member: " + classVarName);
}
if (!ValidateArrayType(classVarSymbol->type))
{
return ShowParserError((string)"Invalid array type: " + classVarSymbol->type);
}
arrayDesc = classVarSymbol;
pointer = (byte*)symbol->GetInstanceAdr() + arrayDesc->GetOffset();
size = arrayDesc->ele;
}
void GetIntArray(zSTRING& arrayName, zCPar_Symbol*& arrayDesc, int*& pointer, int& size)
{
void* ptr;
GetArray(arrayName, arrayDesc, ptr, size);
pointer = (int*)ptr;
if (!pointer)
{
ShowParserError("GetArray failed");
return;
}
if (arrayDesc->type != zPAR_TYPE_INT && arrayDesc->type != zPAR_TYPE_FUNC)
{
ShowParserError((string)"Array type mistmatch.\nExpected: " + zPAR_TYPE_INT + " or " + zPAR_TYPE_FUNC +
".\nGot: " + arrayDesc->type);
return;
}
}
void GetFloatArray(zSTRING& arrayName, zCPar_Symbol*& arrayDesc, float*& pointer, int& size)
{
void* ptr;
GetArray(arrayName, arrayDesc, ptr, size);
pointer = (float*)ptr;
if (!pointer)
{
ShowParserError("GetArray failed");
return;
}
if (arrayDesc->type != zPAR_TYPE_FLOAT)
{
ShowParserError((string)"Array type mistmatch.\nExpected: " + zPAR_TYPE_FLOAT +
".\nGot: " + arrayDesc->type);
return;
}
}
void GetStringArray(zSTRING& arrayName, zCPar_Symbol*& arrayDesc, zSTRING*& pointer, int& size)
{
void* ptr;
GetArray(arrayName, arrayDesc, ptr, size);
pointer = (zSTRING*)ptr;
if (!pointer)
{
ShowParserError("GetArray failed");
return;
}
if (arrayDesc->type != zPAR_TYPE_STRING)
{
ShowParserError((string)"Array type mistmatch.\nExpected: " + zPAR_TYPE_STRING +
".\nGot: " + arrayDesc->type);
return;
}
}
void ValidateIndex(int index, int size)
{
if (index < 0 || index >= size)
{
ShowParserError((string)"Index out of range: " + index + ".\nArray size is " + size);
ogame->Done();
}
}
int __cdecl GetArrInt()
{
int index;
zSTRING arrayName;
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
int* pointer;
int size;
GetIntArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
parser->SetReturn(pointer[index]);
return 0;
}
int __cdecl SetArrInt()
{
int value;
int index;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
int* pointer;
int size;
GetIntArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
pointer[index] = value;
return 0;
}
int __cdecl GetArrFloat()
{
int index;
zSTRING arrayName;
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
float* pointer;
int size;
GetFloatArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
parser->SetReturn(pointer[index]);
return 0;
}
int __cdecl SetArrFloat()
{
float value;
int index;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
float* pointer;
int size;
GetFloatArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
pointer[index] = value;
return 0;
}
int __cdecl GetArrStr()
{
int index;
zSTRING arrayName;
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
zSTRING* pointer;
int size;
GetStringArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
parser->SetReturn(pointer[index]);
return 0;
}
int __cdecl SetArrStr()
{
zSTRING value;
int index;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(index);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
zSTRING* pointer;
int size;
GetStringArray(arrayName, arrayDesc, pointer, size);
ValidateIndex(index, size);
pointer[index] = value;
return 0;
}
// While(LoopBody_Func);
int __cdecl While()
{
int funcIndex;
parser->GetParameter(funcIndex);
int index = 0;
while (true)
{
int result = *(int*)parser->CallFunc(funcIndex, index++);
if (!result)
{
return 0;
}
}
}
// FillArrInt("self.HitChance", 95);
int __cdecl FillArrInt()
{
int value;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
int* pointer;
int size;
GetIntArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
pointer[i] = value;
}
return 0;
}
int __cdecl FillArrFloat()
{
float value;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
float* pointer;
int size;
GetFloatArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
pointer[i] = value;
}
return 0;
}
int __cdecl FillArrStr()
{
zSTRING value;
zSTRING arrayName;
parser->GetParameter(value);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
zSTRING* pointer;
int size;
GetStringArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
pointer[i] = value;
}
return 0;
}
int __cdecl ForEachInt()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
int* pointer;
int size;
GetIntArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushInt(pointer[i]);
Call(funcIndex);
}
return 0;
}
int __cdecl ForEachFloat()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
float* pointer;
int size;
GetFloatArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushFloat(pointer[i]);
Call(funcIndex);
}
return 0;
}
int __cdecl ForEachStr()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
zSTRING* pointer;
int size;
GetStringArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushString(pointer[i]);
Call(funcIndex);
}
return 0;
}
int __cdecl AlterEachInt()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
int* pointer;
int size;
GetIntArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushInt(pointer[i]);
Call(funcIndex);
parser->GetParameter(pointer[i]);
}
return 0;
}
int __cdecl AlterEachFloat()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
float* pointer;
int size;
GetFloatArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushFloat(pointer[i]);
Call(funcIndex);
parser->GetParameter(pointer[i]);
}
return 0;
}
int __cdecl AlterEachStr()
{
int funcIndex;
zSTRING arrayName;
parser->GetParameter(funcIndex);
parser->GetParameter(arrayName);
zCPar_Symbol* arrayDesc;
zSTRING* pointer;
int size;
GetStringArray(arrayName, arrayDesc, pointer, size);
for (int i = 0; i < size; i++)
{
PushInt(i);
PushString(pointer[i]);
Call(funcIndex);
parser->GetParameter(pointer[i]);
}
return 0;
}
void Attach()
{
parser->DefineExternal("GetArrInt", &GetArrInt, zPAR_TYPE_STRING, zPAR_TYPE_INT, 0);
parser->DefineExternal("SetArrInt", &SetArrInt, zPAR_TYPE_STRING, zPAR_TYPE_INT, zPAR_TYPE_INT, 0);
parser->DefineExternal("GetArrFloat", &GetArrFloat, zPAR_TYPE_STRING, zPAR_TYPE_INT, 0);
parser->DefineExternal("SetArrFloat", &SetArrFloat, zPAR_TYPE_STRING, zPAR_TYPE_INT, zPAR_TYPE_FLOAT, 0);
parser->DefineExternal("GetArrStr", &GetArrStr, zPAR_TYPE_STRING, zPAR_TYPE_INT, 0);
parser->DefineExternal("SetArrStr", &SetArrStr, zPAR_TYPE_STRING, zPAR_TYPE_INT, zPAR_TYPE_STRING, 0);
parser->DefineExternal("While", &While, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("FillArrInt", &FillArrInt, zPAR_TYPE_INT, 0);
parser->DefineExternal("FillArrFloat", &FillArrFloat, zPAR_TYPE_FLOAT, 0);
parser->DefineExternal("FillArrStr", &FillArrStr, zPAR_TYPE_STRING, 0);
parser->DefineExternal("ForEachInt", &ForEachInt, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("ForEachFloat", &ForEachFloat, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("ForEachStr", &ForEachStr, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("AlterEachInt", &AlterEachInt, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("AlterEachFloat", &AlterEachFloat, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
parser->DefineExternal("AlterEachStr", &AlterEachStr, zPAR_TYPE_STRING, zPAR_TYPE_FUNC, 0);
}
}
