void ToggleDetour_ClientCommands(bool enable)
{
if (ClientCommandDetour)
{
(enable) ? ClientCommandDetour->EnableDetour() : ClientCommandDetour->DisableDetour();
}
if (enable)
{
// Build the item alias list.
// Used in ClientCommand to check and get fastly item id from alias name.
typedef struct
{
const char *alias;
int id;
} itemBuyAliasInfo;
itemBuyAliasInfo aliasToId[] =
{
{ "p228" , CSI_P228 }, { "228compact" , CSI_P228 },
{ "scout" , CSI_SCOUT }, { "hegren" , CSI_HEGRENADE },
{ "xm1014" , CSI_XM1014 }, { "autoshotgun", CSI_XM1014 },
{ "mac10" , CSI_MAC10 }, { "aug" , CSI_AUG },
{ "bullpup" , CSI_AUG }, { "sgren" , CSI_SMOKEGRENADE },
{ "elites" , CSI_ELITE }, { "fn57" , CSI_FIVESEVEN },
{ "fiveseven" , CSI_FIVESEVEN }, { "ump45" , CSI_UMP45 },
{ "sg550" , CSI_SG550 }, { "krieg550" , CSI_SG550 },
{ "galil" , CSI_GALIL }, { "defender" , CSI_GALIL },
{ "famas" , CSI_FAMAS }, { "clarion" , CSI_FAMAS },
{ "usp" , CSI_USP }, { "km45" , CSI_USP },
{ "glock" , CSI_GLOCK18 }, { "9x19mm" , CSI_GLOCK18 },
{ "awp" , CSI_AWP }, { "magnum" , CSI_AWP },
{ "mp5" , CSI_MP5NAVY }, { "smg" , CSI_MP5NAVY },
{ "m249" , CSI_M249 }, { "m3" , CSI_M3 },
{ "12gauge" , CSI_M3 }, { "m4a1" , CSI_M4A1 },
{ "tmp" , CSI_TMP }, { "mp" , CSI_TMP },
{ "g3sg1" , CSI_G3SG1 }, { "d3au1" , CSI_G3SG1 },
{ "flash" , CSI_FLASHBANG }, { "deagle" , CSI_DEAGLE },
{ "nighthawk" , CSI_DEAGLE }, { "sg552" , CSI_SG552 },
{ "krieg552" , CSI_SG552 }, { "ak47" , CSI_AK47 },
{ "cv47" , CSI_AK47 }, { "p90" , CSI_P90 },
{ "c90" , CSI_P90 }, { "vest" , CSI_VEST },
{ "vesthelm" , CSI_VESTHELM }, { "defuser" , CSI_DEFUSER },
{ "nvgs" , CSI_NVGS }, { "shield" , CSI_SHIELDGUN },
{ "buyammo1" , CSI_PRIAMMO }, { "primammo" , CSI_PRIAMMO },
{ "buyammo2" , CSI_SECAMMO }, { "secammo" , CSI_SECAMMO },
{ nullptr , 0 }
};
for (size_t i = 0; aliasToId[i].alias != nullptr; ++i)
{
ItemAliasList.insert(aliasToId[i].alias, aliasToId[i].id);
}
}
else
{
ItemAliasList.clear();
}
}
void visit(StringHashMap<int>& map)
{
StringHashMap<int>::Iterator it = map.begin();
for (; it != map.end(); ++it)
{
value_sum += (*it).second;
}
}
void CtrlDetours_BuyCommands(bool set)
{
if (set)
{
void *giveShieldAddress = UTIL_FindAddressFromEntry(CS_IDENT_GIVENSHIELD , CS_IDENT_HIDDEN_STATE);
void *giveNamedItemAddress = UTIL_FindAddressFromEntry(CS_IDENT_GIVENAMEDITEM, CS_IDENT_HIDDEN_STATE);
void *addAccountAddress = UTIL_FindAddressFromEntry(CS_IDENT_ADDACCOUNT , CS_IDENT_HIDDEN_STATE);
GiveShieldDetour = DETOUR_CREATE_MEMBER_FIXED(GiveShield, giveShieldAddress);
GiveNamedItemDetour = DETOUR_CREATE_MEMBER_FIXED(GiveNamedItem, giveNamedItemAddress);
AddAccountDetour = DETOUR_CREATE_MEMBER_FIXED(AddAccount, addAccountAddress);
if (GiveNamedItemDetour == NULL || AddAccountDetour == NULL)
{
MF_Log("No Buy Commands detours could be initialized - Disabled Buy forward.");
}
}
else
{
if (GiveShieldDetour)
GiveShieldDetour->Destroy();
if (GiveNamedItemDetour)
GiveNamedItemDetour->Destroy();
if (AddAccountDetour)
AddAccountDetour->Destroy();
ItemAliasList.clear();
}
}
void CtrlDetours_ClientCommand(bool set)
{
if (set)
{
void *target = (void *)MDLL_ClientCommand;
#if defined(WIN32)
UseBotArgs = *(int **)((unsigned char *)target + CS_CLICMD_OFFS_USEBOTARGS);
BotArgs = (const char **)*(const char **)((unsigned char *)target + CS_CLICMD_OFFS_BOTARGS);
#elif defined(__linux__) || defined(__APPLE__)
UseBotArgs = (int *)UTIL_FindAddressFromEntry(CS_IDENT_USEBOTARGS, CS_IDENT_HIDDEN_STATE);
BotArgs = (const char **)UTIL_FindAddressFromEntry(CS_IDENT_BOTARGS, CS_IDENT_HIDDEN_STATE);
#endif
ClientCommandDetour = DETOUR_CREATE_STATIC_FIXED(C_ClientCommand, target);
if (ClientCommandDetour == NULL)
{
MF_Log("No Client Commands detour could be initialized - Disabled Client Command forward.");
}
}
else
{
if (ClientCommandDetour)
ClientCommandDetour->Destroy();
ItemAliasList.clear();
}
}
void FileTreeWalker::traverseArgv(const StringArray &a, FileNameHandler &nameHandler, bool recurse) { // static
StringHashMap<IndexedStringArray> dirMap;
int arrayIndex = 0;
for(size_t i = 0; i < a.size(); i++) {
String name = a[i];
if(name[name.length()-1] == '\\') {
name = left(name,name.length()-1);
}
if(hasWildCard(name)) {
FileNameSplitter info(name);
String path = toLowerCase(info.getDrive() + info.getDir());
String wildCard = toLowerCase(info.getFileName() + info.getExtension());
IndexedStringArray *wcArray = dirMap.get(path);
if(wcArray == NULL) {
IndexedStringArray ia(path, arrayIndex++, true);
ia.add(wildCard);
dirMap.put(path,ia);
} else {
wcArray->add(wildCard);
}
} else { // no wildCards
struct _stat st;
if(stat(name,st) < 0) {
continue;
}
dirMap.put(name,IndexedStringArray(name, arrayIndex++, (st.st_mode & _S_IFDIR) ? true : false));
}
}
CompactArray<IndexedStringArray*> a1;
for(Iterator<IndexedStringArray> it = dirMap.values().getIterator(); it.hasNext();) {
a1.add(&it.next());
}
a1.sort(compareByIndex);
for(size_t i = 0; i < a1.size(); i++) {
const IndexedStringArray *ia = a1[i];
if(ia->isDir()) {
handleDir(ia->getPath(), nameHandler, *ia, recurse);
} else {
handleSingleFile(ia->getPath(), nameHandler);
}
}
}
void CtrlDetours_ClientCommand(bool set)
{
if (set)
{
void *base = reinterpret_cast<void *>(MDLL_ClientCommand);
#if defined(WIN32)
int offset = 0;
if (MainConfig->GetOffset("UseBotArgs", &offset))
{
UseBotArgs = get_pdata<int*>(base, offset);
}
if (MainConfig->GetOffset("BotArgs", &offset))
{
BotArgs = get_pdata<const char**>(base, offset);
}
#elif defined(__linux__) || defined(__APPLE__)
void *address = nullptr;
if (MainConfig->GetMemSig("UseBotArgs", &address))
{
UseBotArgs = reinterpret_cast<int *>(address);
}
if (MainConfig->GetMemSig("BotArgs", &address))
{
BotArgs = reinterpret_cast<const char **>(address);
}
#endif
ClientCommandDetour = DETOUR_CREATE_STATIC_FIXED(C_ClientCommand, base);
CommonConfig->GetOffsetByClass("CBasePlayer", "m_iTeam", &TeamOffset);
CommonConfig->GetOffsetByClass("CBasePlayer", "m_iMenu", &MenuOffset);
if (!ClientCommandDetour || !UseBotArgs || !BotArgs || !TeamOffset || !MenuOffset)
{
MF_Log("ClientCommand is not available - forward client_command has been disabled");
}
}
else
{
if (ClientCommandDetour)
{
ClientCommandDetour->Destroy();
}
ItemAliasList.clear();
}
}
void test_StringHashMap()
{
test_category("StringHashMap");
StringHashMap<int> M;
M["eight"] = 8;
M["five"] = 5;
M["one"] = 1;
M["nine"] = 9;
M["two"] = 2;
M["four"] = 4;
M["ten"] = 10;
M["six"] = 6;
M["three"] = 3;
M["seven"] = 7;
assert(M.contains("three"));
assert(M.contains("five"));
assert(M.contains("ten"));
assert_false(M.contains(""));
assert_false(M.contains("twenty"));
assert_false(M.contains("!@#%^"));
assert(M["one"] == 1, "lookup");
assert(M["two"] == 2, "lookup");
assert(M["three"] == 3, "lookup");
assert(M["four"] == 4, "lookup");
assert(M["five"] == 5, "lookup");
assert(M["six"] == 6, "lookup");
assert(M["seven"] == 7, "lookup");
assert(M["eight"] == 8, "lookup");
assert(M["nine"] == 9, "lookup");
assert(M["ten"] == 10, "lookup");
M["foo"] = 50;
M["foo"] = 80;
M["foo"] = M["foo"] = 42;
M["foo"] = M["foo"] = M["foo"] = M["foo"];
assert(M["foo"] == 42, "foo");
}
DETOUR_DECL_STATIC1(C_ClientCommand, void, edict_t*, pEdict) // void ClientCommand(edict_t *pEntity)
{
const char *command = CMD_ARGV(0);
// A new command is triggered, reset variable, always.
CurrentItemId = 0;
// Purpose is to retrieve an item id based on alias name or selected item from menu,
// to be used in OnBuy* forwards.
if ((ForwardOnBuyAttempt != -1 || ForwardOnBuy != -1) && command && *command)
{
int itemId = 0;
// Handling buy via menu.
if (!strcmp(command, "menuselect"))
{
int slot = atoi(CMD_ARGV(1));
if (slot > 0 && slot < 9)
{
static const int menuItemsTe[][9] =
{
/* Menu_Buy */ { 0, 0, 0, 0, 0, 0, CSI_PRIAMMO, CSI_SECAMMO, 0 },
/* Menu_BuyPistol */ { 0, CSI_GLOCK18, CSI_USP, CSI_P228, CSI_DEAGLE, CSI_ELITE, 0, 0, 0 },
/* Menu_BuyRifle */ { 0, CSI_GALIL, CSI_AK47, CSI_SCOUT, CSI_SG552, CSI_AWP, CSI_G3SG1, 0, 0 },
/* Menu_BuyMachineGun */ { 0, CSI_M249, 0, 0, 0, 0, 0, 0, 0 },
/* Menu_BuyShotgun */ { 0, CSI_M3, CSI_XM1014, 0, 0, 0, 0, 0, 0 },
/* Menu_BuySubMachineGun */ { 0, CSI_MAC10, CSI_MP5NAVY, CSI_UMP45, CSI_P90, 0, 0, 0, 0 },
/* Menu_BuyItem */ { 0, CSI_VEST, CSI_VESTHELM, CSI_FLASHBANG, CSI_HEGRENADE, CSI_SMOKEGRENADE, CSI_NVGS, 0, 0 }
};
static const int menuItemsCt[][9] =
{
/* Menu_Buy */ { 0, 0, 0, 0, 0, 0, CSI_PRIAMMO, CSI_SECAMMO, 0 },
/* Menu_BuyPistol */ { 0, CSI_GLOCK18, CSI_USP, CSI_P228, CSI_DEAGLE, CSI_FIVESEVEN, 0, 0, 0 },
/* Menu_BuyRifle */ { 0, CSI_FAMAS, CSI_SCOUT, CSI_M4A1, CSI_AUG, CSI_SG550, CSI_AWP, 0, 0 },
/* Menu_BuyMachineGun */ { 0, CSI_M249, 0, 0, 0, 0, 0, 0, 0 },
/* Menu_BuyShotgun */ { 0, CSI_M3, CSI_XM1014, 0, 0, 0, 0, 0, 0 },
/* Menu_BuySubMachineGun */ { 0, CSI_TMP, CSI_MP5NAVY, CSI_UMP45, CSI_P90, 0, 0, 0, 0 },
/* Menu_BuyItem */ { 0, CSI_VEST, CSI_VESTHELM, CSI_FLASHBANG, CSI_HEGRENADE, CSI_SMOKEGRENADE, CSI_NVGS, CSI_DEFUSER, CSI_SHIELDGUN }
};
int menuId = get_pdata<int>(pEdict, MenuOffset);
if (menuId >= Menu_Buy && menuId <= Menu_BuyItem)
{
switch (get_pdata<int>(pEdict, TeamOffset))
{
case TEAM_T: itemId = menuItemsTe[menuId - 4][slot]; break; // -4 because array is zero-based and Menu_Buy* constants starts from 4.
case TEAM_CT:itemId = menuItemsCt[menuId - 4][slot]; break;
}
if (itemId)
{
CurrentItemId = itemId;
}
}
}
}
else // Handling buy via alias
{
if (ItemAliasList.retrieve(command, &itemId))
{
CurrentItemId = itemId;
}
}
}
int client = ENTINDEX(pEdict);
if (ForwardInternalCommand != -1 && *UseBotArgs)
{
const char *args = *BotArgs;
if (MF_ExecuteForward(ForwardInternalCommand, static_cast<cell>(client), args) > 0)
{
return;
}
}
if (ForwardOnBuyAttempt != -1 &&
CurrentItemId &&
MF_IsPlayerAlive(client) &&
MF_ExecuteForward(ForwardOnBuyAttempt, static_cast<cell>(client), static_cast<cell>(CurrentItemId)) > 0)
{
return;
}
DETOUR_STATIC_CALL(C_ClientCommand)(pEdict);
}
void CtrlDetours_BuyCommands(bool set)
{
if (set)
{
void *address = nullptr;
if (MainConfig->GetMemSig("GiveShield", &address))
{
GiveShieldDetour = DETOUR_CREATE_MEMBER_FIXED(GiveShield, address);
}
if (MainConfig->GetMemSig("GiveNamedItem", &address))
{
GiveNamedItemDetour = DETOUR_CREATE_MEMBER_FIXED(GiveNamedItem, address);
}
if (MainConfig->GetMemSig("AddAccount", &address))
{
AddAccountDetour = DETOUR_CREATE_MEMBER_FIXED(AddAccount, address);
}
if (!GiveShieldDetour || !GiveNamedItemDetour || !AddAccountDetour)
{
if (!GiveShieldDetour)
{
MF_Log("GiveShield is not available");
}
if (!GiveNamedItemDetour)
{
MF_Log("GiveNamedItem is not available");
}
if (!AddAccountDetour)
{
MF_Log("AddAccount is not available");
}
MF_Log("Some functions are not available - forward CS_OnBuyAttempt and CS_OnBuy have been disabled");
}
}
else
{
if (GiveShieldDetour)
{
GiveShieldDetour->Destroy();
}
if (GiveNamedItemDetour)
{
GiveNamedItemDetour->Destroy();
}
if (AddAccountDetour)
{
AddAccountDetour->Destroy();
}
ItemAliasList.clear();
}
}
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
StringHashMap<int>* map_ptr;
CHECK(StringHashMap() throw())
map_ptr = new StringHashMap<int>;
TEST_NOT_EQUAL(map_ptr, 0)
RESULT
CHECK(~StringHashMap() throw())
delete map_ptr;
RESULT
CHECK(Size getSize() const throw())
StringHashMap<int> hm;
TEST_EQUAL(hm.getSize(), 0)
RESULT
CHECK((std::pair<Iterator, bool> insert(const ValueType& obj) throw()))
StringHashMap<int> hm;
TEST_EQUAL(hm.getSize(), 0)
pair<String, int> p("a", 0);
hm.insert(p);
TEST_EQUAL(hm.getSize(), 1)
hm.insert(p);
TEST_EQUAL(hm.getSize(), 1)
pair<String, int> p2("b", 1);
hm.insert(p2);
TEST_EQUAL(hm.getSize(), 2)
TEST_EQUAL(hm.has("a"), true)
void Generate(const char* pcName, const vector<const char*>& kNameList)
{
funcName.clear();
funcName["glXCreateContext"] = 1;
funcName["glXMakeCurrent"] = 1;
funcName["glXSwapBuffers"] = 1;
funcName["glXGetProcAddressARB"] = 1;
funcName["wglGetProcAddress"] = 1;
funcName["wglCreateContext"] = 1;
funcName["wglMakeCurrent"] = 1;
funcName["wglDeleteContext"] = 1;
LoadContext = "";
UnloadContext = "";
smallPre = pcName;
bigPre = pcName;
int i(0);
while(pcName[i])
{
if(pcName[i] >= 'a' && pcName[i] <= 'z')
bigPre[i] = pcName[i] - 0x20;
else
bigPre[i] = pcName[i];
++i;
}
macro = "VE_";
macro += bigPre;
bigPre += "_";
if(bigPre == "WGL_") bigPre = "";
size_t stLen;
char acBuffer[1024];
sprintf_s(acBuffer, "%s.tm", pcName);
char* pcFile = OpenFile(acBuffer, stLen);
Load_tm(pcFile, stLen, g_kTypeMap);
CloseFile(pcFile);
string kGlHeader;
string kGlSource;
kGlHeader +=
"////////////////////////////////////////////////////////////////////////////\n" \
"//\n" \
"// Venus Engine Header File.\n" \
"// Copyright (C), Venus Interactive Entertainment.2012\n" \
"// -------------------------------------------------------------------------\n" \
"// File name: ";
kGlHeader += pcName;
kGlHeader += ".h\n";
kGlHeader +=
"// Version: v1.00\n" \
"// Created: by GlSpecLoader\n" \
"// Compilers: Visual Studio.NET\n" \
"// Description: \n" \
"// -------------------------------------------------------------------------\n" \
"// History:\n" \
"// http://www.venusie.com\n" \
"////////////////////////////////////////////////////////////////////////////\n\n";
kGlHeader += "#pragma once\n\n" \
"#ifdef ";
kGlHeader += macro;
kGlHeader += "\n\n" \
"extern \"C\"\n" \
"{\n\n";
kGlSource +=
"////////////////////////////////////////////////////////////////////////////\n" \
"//\n" \
"// Venus Engine Source File.\n" \
"// Copyright (C), Venus Interactive Entertainment.2012\n" \
"// -------------------------------------------------------------------------\n" \
"// File name: ";
kGlSource += pcName;
kGlSource += ".cpp\n";
kGlSource +=
"// Version: v1.00\n" \
"// Created: by GlSpecLoader\n" \
"// Compilers: Visual Studio.NET\n" \
"// Description: \n" \
"// -------------------------------------------------------------------------\n" \
"// History:\n" \
"// http://www.venusie.com\n" \
"////////////////////////////////////////////////////////////////////////////\n\n";
kGlSource +=
"#include \"VeMainPCH.h\"\n" \
"#include \"_VeGlLoader.h\"\n\n";
kGlSource += "#ifdef ";
kGlSource += macro;
kGlSource += "\n\n";
for(size_t i(0); i < kNameList.size(); ++i)
{
pcFile = OpenFile(kNameList[i], stLen);
Load_spec(pcFile, stLen, g_kTypeMap, kGlHeader, kGlSource);
CloseFile(pcFile);
}
kGlHeader += "\nvoid ";
kGlHeader += smallPre;
kGlHeader += "Funcload();\n";
kGlHeader += "\nvoid ";
kGlHeader += smallPre;
kGlHeader += "FuncUnload();\n\n";
kGlHeader += "}\n\n";
kGlHeader += "#endif\n";
kGlSource += "\nvoid ";
kGlSource += smallPre;
kGlSource += "Funcload()\n{\n";
kGlSource += LoadContext;
kGlSource += "}\n";
kGlSource += "\nvoid ";
kGlSource += smallPre;
kGlSource += "FuncUnload()\n{\n";
kGlSource += UnloadContext;
kGlSource += "}\n\n";
kGlSource += "#endif\n";
_chdir(g_acSave);
FILE* pfHeaderFile;
sprintf_s(acBuffer, "%s.h", pcName);
fopen_s(&pfHeaderFile, acBuffer, "w");
fwrite(kGlHeader.c_str(), 1, kGlHeader.length(), pfHeaderFile);
fclose(pfHeaderFile);
FILE* pfSourceFile;
sprintf_s(acBuffer, "%s.cpp", pcName);
fopen_s(&pfSourceFile, acBuffer, "w");
fwrite(kGlSource.c_str(), 1, kGlSource.length(), pfSourceFile);
fclose(pfSourceFile);
_chdir(g_acLoad);
}
void Load_spec(const char* pcBuffer, size_t stLen, StringHashMap<string>& kTypeMap, string& outHeader, string& outSource)
{
const char* pcStart = pcBuffer;
char acLineBuffer[2048];
SpecType eState = SPEC_TYPE_MAX;
SpecType eLastState = SPEC_TYPE_MAX;
string func_name;
string return_name;
vector<string> params;
StringHashMap<pair<string,bool>> paramsType;
int i(0);
while(GetLine(&pcStart, acLineBuffer))
{
++i;
switch(eState)
{
case SPEC_ENUM:
if(eState == SPEC_ENUM)
{
if(acLineBuffer[0] == '\t')
{
char acMacro[1024], acValue[1024];
GetDefine(acLineBuffer, acMacro, acValue);
if(strcmp(acMacro, "use") != 0)
{
outHeader += "#ifndef ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += "\n#define ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += " ";
outHeader += acValue;
outHeader += "\n#endif\n\n";
}
break;
}
else
{
eState = SPEC_TYPE_MAX;
eLastState = SPEC_ENUM;
}
}
case SPEC_DEFINE:
if(eState == SPEC_DEFINE)
{
if(acLineBuffer[0] == '\t')
{
char acMacro[1024], acValue[1024];
GetDefine(acLineBuffer, acMacro, acValue);
if(strcmp(acMacro, "use") != 0)
{
outHeader += "#ifndef ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += "\n#define ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += " ";
outHeader += acValue;
outHeader += "\n#endif\n\n";
}
break;
}
else
{
eState = SPEC_TYPE_MAX;
eLastState = SPEC_DEFINE;
}
}
case SPEC_FUNC:
if(eState == SPEC_FUNC)
{
if(acLineBuffer[0] == '\t')
{
char acWord0[128], acWord1[128], acWord2[128];
char* pcSrc;
char* pcDst;
{
pcSrc = acLineBuffer;
pcDst = acWord0;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
}
StringHashMap<FuncType>::iterator it = func_Type.find(acWord0);
if(it != func_Type.end())
{
switch(it->second)
{
case FUNC_RETURN:
{
pcDst = acWord1;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
return_name = acWord1;
}
break;
case FUNC_PARAM:
{
pcDst = acWord1;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
pcDst = acWord2;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
if(strstr(pcSrc, "value"))
{
paramsType[acWord1] = make_pair(string(acWord2), false);
}
else
{
paramsType[acWord1] = make_pair(string(acWord2), true);
}
}
break;
}
}
break;
}
else
{
if(funcName.find(func_name.c_str()) == funcName.end())
{
string strTemp;
outHeader += "typedef ";
strTemp = kTypeMap[return_name];
if(strTemp == "") strTemp = "void";
outHeader += strTemp;
outHeader += " (APIENTRY *";
outHeader += func_name;
outHeader += "Func)(";
for(size_t i(0); i < params.size(); ++i)
{
strTemp = paramsType[params[i]].first;
strTemp = kTypeMap[strTemp];
if(strTemp == "")
{
strTemp = "void";
}
if(paramsType[params[i]].second)
{
strTemp += "*";
}
outHeader += strTemp;
outHeader += " ";
StringHashMap<string>::iterator it = trans.find(params[i]);
if(it != trans.end())
{
outHeader += it->second;
}
else
{
outHeader += params[i];
}
if(i < (params.size() - 1))
{
outHeader += ", ";
}
}
outHeader += ");\n";
outHeader += "extern ";
outHeader += func_name;
outHeader += "Func _";
outHeader += func_name;
outHeader += ";\n";
outHeader += "#define ";
outHeader += func_name;
if(return_name == "void")
{
outHeader += " VE_ASSERT(_";
outHeader += func_name;
outHeader += ");_";
}
else
{
outHeader += " _";
}
outHeader += func_name;
outHeader += "\n";
outSource += "#ifdef ";
outSource += func_name;
outSource += "\n";
outSource += func_name;
outSource += "Func _";
outSource += func_name;
outSource += " = NULL;\n";
outSource += "#endif\n";
LoadContext += "#\tifdef ";
LoadContext += func_name;
LoadContext += "\n";
LoadContext += "\t_";
LoadContext += func_name;
LoadContext += " = (";
LoadContext += func_name;
LoadContext += "Func)";
LoadContext += smallPre;
LoadContext += "GetFunction(\"";
LoadContext += func_name;
LoadContext += "\");\n";
LoadContext += "#\tendif\n";
UnloadContext += "#\tifdef ";
UnloadContext += func_name;
UnloadContext += "\n";
UnloadContext += "\t_";
UnloadContext += func_name;
UnloadContext += " = NULL;\n";
UnloadContext += "#\tendif\n";
funcName[func_name] = 1;
}
eState = SPEC_TYPE_MAX;
eLastState = SPEC_TYPE_MAX;
}
}
case SPEC_TYPE_MAX:
if(eState == SPEC_TYPE_MAX)
{
if(acLineBuffer[0] < 0x30 || acLineBuffer[0] > 0x7A)
{
continue;
}
char acTemp[1024];
const char* pcNext = GetSpecType(acLineBuffer, acTemp);
{
bool bFunc = false;
{
const char* pcTempPointer = acTemp;
while(*pcTempPointer)
{
if(*pcTempPointer == ')')
{
bFunc = true;
}
++pcTempPointer;
}
}
if(bFunc)
{
char acTempBuffer[128];
char* pcDst = acTempBuffer;
char* pcSrc = acLineBuffer;
while(*pcSrc)
{
*pcDst = *pcSrc;
if(*pcDst == '(')
{
++pcSrc;
break;
}
++pcDst;
++pcSrc;
}
*pcDst = 0;
func_name = smallPre + acTempBuffer;
return_name = "";
params.clear();
paramsType.clear();
while(*pcSrc)
{
pcDst = acTempBuffer;
while(*pcSrc)
{
*pcDst = *pcSrc;
if(*pcSrc == ')')
{
break;
}
else if(*pcSrc == ' ' || *pcSrc == '\t' || *pcSrc == ',')
{
++pcSrc;
break;
}
++pcSrc;
++pcDst;
}
*pcDst = 0;
if(strlen(acTempBuffer))
{
params.push_back(acTempBuffer);
}
while(*pcSrc == ' ' || *pcSrc == '\t' || *pcSrc == ',')
{
++pcSrc;
}
if(*pcSrc == ')')
{
break;
}
}
eState = SPEC_FUNC;
}
else
{
StringHashMap<SpecType>::iterator it = spec_Type.find(acTemp);
if(it != spec_Type.end())
{
if(it->second == SPEC_PASSTHRU)
{
while(*pcNext == ' ' || *pcNext == '\t')
{
++pcNext;
}
outHeader += pcNext;
outHeader += "\n";
eState = eLastState;
}
else
{
eState = it->second;
}
}
else
{
eState = SPEC_ENUM;
}
}
}
}
break;
}
}
}
