// ____ _ __ // / __ )____ _____ | | / /___ ___________ // / __ / __ \/ ___/ | | /| / / __ `/ ___/ ___/ // / /_/ / /_/ (__ ) | |/ |/ / /_/ / / (__ ) // /_____/\____/____/ |__/|__/\__,_/_/ /____/ // // A futuristic real-time strategy game. // This file is part of Bos Wars. // /**@name script.cpp - The configuration language. */ // // (c) Copyright 1998-2008 by Lutz Sammer, Jimmy Salmon and Joris Dauphin. // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; only version 2 of the License. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA // 02111-1307, USA. // //@{ /*---------------------------------------------------------------------------- -- Includes ----------------------------------------------------------------------------*/ #include #include #include #include "stratagus.h" #include "unittype.h" #include "iolib.h" #include "iocompat.h" #include "script.h" #include "missile.h" #include "upgrade.h" #include "construct.h" #include "map.h" #include "ui.h" #include "interface.h" #include "ai.h" #include "trigger.h" #include "editor.h" #include "sound.h" #include "netconnect.h" #include "network.h" #include "spells.h" #include "actions.h" #include "video.h" #include "upgrade_structs.h" #include "player.h" #include "replay.h" /*---------------------------------------------------------------------------- -- Variables ----------------------------------------------------------------------------*/ lua_State *Lua; /// Structure to work with lua files. std::string CclStartFile; /// CCL start file std::string UserDirectory; int CclInConfigFile; /// True while config file parsing bool SaveGameLoading; /// If a Saved Game is Loading std::string CurrentLuaFile; /// Lua file currently being interpreted int NoRandomPlacementMultiplayer = 0; /// Disable the random placement of players in muliplayer mode /*---------------------------------------------------------------------------- -- Functions ----------------------------------------------------------------------------*/ /** ** FIXME: docu */ static void lstop(lua_State *l, lua_Debug *ar) { (void)ar; // unused arg. lua_sethook(l, NULL, 0, 0); luaL_error(l, "interrupted!"); } /** ** FIXME: docu */ static void laction(int i) { // if another SIGINT happens before lstop, // terminate process (default action) signal(i, SIG_DFL); lua_sethook(Lua, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); } /** ** Print error message and possibly exit. ** ** @param pname Source of the error. ** @param msg error message to print. ** @param exit exit the program */ static void l_message(const char *pname, const char *msg, bool exit) { if (pname) { fprintf(stderr, "%s: ", pname); } fprintf(stderr, "%s\n", msg); if (exit) { ::exit(1); } } /** ** Check error status, and print error message and exit ** if status is different of 0. ** ** @param status status of the last lua call. (0: success) ** @param exitOnError exit the program on error ** ** @return 0 in success, else exit. */ static int report(int status, bool exitOnError) { const char *msg; if (status) { msg = lua_tostring(Lua, -1); if (msg == NULL) { msg = "(error with no message)"; } l_message(NULL, msg, exitOnError); lua_pop(Lua, 1); } return status; } /** ** Gets a backtrace of the Lua call stack, by calling the ** debug.traceback function. ** ** @return Number of return values in the Lua stack; always 1. ** ** @par Parameters in the Lua stack: ** @li message (string) The error message last thrown. ** ** @par Return values in the Lua stack: ** @li trace (string) Stack backtrace, with @a message prepended. */ int luatraceback(lua_State *L) { lua_pushliteral(L, "debug"); lua_gettable(L, LUA_GLOBALSINDEX); if (!lua_istable(L, -1)) { lua_pop(L, 1); return 1; } lua_pushliteral(L, "traceback"); lua_gettable(L, -2); if (!lua_isfunction(L, -1)) { lua_pop(L, 2); return 1; } lua_pushvalue(L, 1); // pass error message lua_pushnumber(L, 2); // skip this function and traceback lua_call(L, 2, 1); // call debug.traceback return 1; } /** ** Call a lua function ** ** @param narg Number of arguments ** @param clear Clear the return value(s) ** @param exitOnError Exit the program when an error occurs ** ** @return 0 in success, else exit. */ int LuaCall(int narg, int clear, bool exitOnError) { int status; int base; base = lua_gettop(Lua) - narg; // function index lua_pushcfunction(Lua, luatraceback); // push traceback function lua_insert(Lua, base); // put it under chunk and args signal(SIGINT, laction); status = lua_pcall(Lua, narg, (clear ? 0 : LUA_MULTRET), base); signal(SIGINT, SIG_DFL); lua_remove(Lua, base); // remove traceback function return report(status, exitOnError); } /** ** Load a file into a buffer */ static void LuaLoadBuffer(const std::string &file, std::string &buffer) { CFile fp; int size; int oldsize; int location; int read; char *buf; buffer.clear(); if (fp.open(file.c_str(), CL_OPEN_READ) == -1) { fprintf(stderr, "Can't open file '%s': %s\n", file.c_str(), strerror(errno)); return; } size = 10000; buf = new char[size]; if (!buf) { fprintf(stderr, "Out of memory\n"); ExitFatal(-1); } location = 0; for (;;) { read = fp.read(&buf[location], size - location); if (read != size - location) { location += read; break; } location += read; oldsize = size; size = size * 2; char *newb = new char[size]; if (!newb) { fprintf(stderr, "Out of memory\n"); ExitFatal(-1); } memcpy(newb, buf, oldsize); delete[] buf; buf = newb; } fp.close(); buffer.assign(buf, location); delete[] buf; } /** ** Load a file and execute it ** ** @param file File to load and execute ** ** @return 0 for success, else exit. */ int LuaLoadFile(const std::string &file) { int status; std::string PreviousLuaFile; std::string buf; PreviousLuaFile = CurrentLuaFile; CurrentLuaFile = file; LuaLoadBuffer(file, buf); if (buf.empty()) { return -1; } // "@" at the beginning of the chunk name makes Lua format // it as a file name in backtraces. if (!(status = luaL_loadbuffer(Lua, buf.c_str(), buf.size(), ('@' + file).c_str()))) { LuaCall(0, 1); } else { report(status, true); } CurrentLuaFile = PreviousLuaFile; return status; } /** ** Get the directory of the current lua file */ static int CclGetCurrentLuaPath(lua_State *l) { LuaCheckArgs(l, 0); std::string path = CurrentLuaFile; size_t index = path.rfind('/'); if (index != std::string::npos) { path = path.substr(0, index); lua_pushstring(l, path.c_str()); } else { lua_pushstring(l, ""); } return 1; } /** ** Save preferences ** ** @param l Lua state. */ static int CclSavePreferences(lua_State *l) { LuaCheckArgs(l, 0); SavePreferences(); return 0; } /** ** Load a file and execute it. ** ** @param l Lua state. ** ** @return 0 in success, else exit. */ static int CclLoad(lua_State *l) { char buf[1024]; LuaCheckArgs(l, 1); LibraryFileName(LuaToString(l, 1), buf, sizeof(buf)); if (LuaLoadFile(buf) == -1) { DebugPrint("Load failed: %s\n" _C_ LuaToString(l, 1)); } return 0; } /** ** Load a file into a buffer and return it. ** ** @param l Lua state. ** ** @return buffer or nil on failure */ static int CclLoadBuffer(lua_State *l) { char file[1024]; std::string buf; LuaCheckArgs(l, 1); LibraryFileName(LuaToString(l, 1), file, sizeof(file)); LuaLoadBuffer(file, buf); if (!buf.empty()) { lua_pushstring(l, buf.c_str()); return 1; } return 0; } /** ** Load the SavedGameInfo Header ** ** @param l Lua state. */ static int CclSavedGameInfo(lua_State *l) { const char *value; LuaCheckArgs(l, 1); LuaCheckTable(l, 1); lua_pushnil(l); while (lua_next(l, 1)) { value = LuaToString(l, -2); if (!strcmp(value, "SaveFile")) { if (strcpy_s(CurrentMapPath, sizeof(CurrentMapPath), LuaToString(l, -1)) != 0) { LuaError(l, "SaveFile too long"); } std::string buf = StratagusLibPath; buf += "/"; buf += LuaToString(l, -1); if (LuaLoadFile(buf) == -1) { DebugPrint("Load failed: %s\n" _C_ value); } } else if (!strcmp(value, "SyncHash")) { SyncHash = LuaToNumber(l, -1); } else if (!strcmp(value, "SyncRandSeed")) { SyncRandSeed = LuaToNumber(l, -1); } else { LuaError(l, "Unsupported tag: %s" _C_ value); } lua_pop(l, 1); } return 0; } /** ** Convert lua string to char*. ** It also checks the type and exits in case of error. ** ** @note char* could be invalidated with lua garbage collector. ** ** @param l Lua state. ** @param index Argument number. ** ** @return char* from lua. */ const char *LuaToString(lua_State *l, int index) { luaL_checktype(l, index, LUA_TSTRING); return lua_tostring(l, index); } /** ** Convert lua string in a table to char*. ** It also checks the type and exits in case of error. ** ** @note char* could be invalidated with lua garbage collector. ** ** @param l Lua state. ** @param tableIndex Index number of the table. ** @param stringIndex Index number of the string in the table. ** ** @return char* from lua. */ const char *LuaToString(lua_State *l, int tableIndex, int stringIndex) { const char *str; lua_rawgeti(l, tableIndex, stringIndex); luaL_checktype(l, -1, LUA_TSTRING); str = lua_tostring(l, -1); lua_pop(l, 1); return str; } /** ** Convert lua number to int. ** It also checks the type and exits in case of error. ** ** @param l Lua state. ** @param index Argument number. ** ** @return int from lua. */ int LuaToNumber(lua_State *l, int index) { luaL_checktype(l, index, LUA_TNUMBER); return static_cast(lua_tonumber(l, index)); } /** ** Convert lua number in a table to int. ** It also checks the type and exits in case of error. ** ** @param l Lua state. ** @param tableIndex Index number of the table ** @param numberIndex Index number of the string in the table. ** ** @return int from lua. */ int LuaToNumber(lua_State *l, int tableIndex, int numberIndex) { int num; lua_rawgeti(l, tableIndex, numberIndex); luaL_checktype(l, -1, LUA_TNUMBER); num = static_cast(lua_tonumber(l, -1)); lua_pop(l, 1); return num; } /** ** Convert lua boolean to bool. ** It also checks the type and exits in case of error. ** ** @param l Lua state. ** @param index Argument number. ** ** @return 1 for true, 0 for false from lua. */ bool LuaToBoolean(lua_State *l, int index) { luaL_checktype(l, index, LUA_TBOOLEAN); return lua_toboolean(l, index) != 0; } /** ** Perform CCL garbage collection ** ** @param fast set this flag to disable slow GC (during game) */ void CclGarbageCollect(int fast) { DebugPrint("Garbage collect (before): %d\n" _C_ lua_gc(Lua, LUA_GCCOUNT, 0)); lua_gc(Lua, LUA_GCCOLLECT, 0); DebugPrint("Garbage collect (after): %d\n" _C_ lua_gc(Lua, LUA_GCCOUNT, 0)); } /*............................................................................ .. Config ............................................................................*/ /** ** Return the stratagus library path. ** ** @param l Lua state. ** ** @return Current libray path. */ static int CclStratagusLibraryPath(lua_State *l) { lua_pushstring(l, StratagusLibPath.c_str()); return 1; } /** ** Return a table with the filtered items found in the subdirectory. */ static int CclFilteredListDirectory(lua_State *l, int type, int mask) { char directory[256]; const char *userdir; std::vector flp; int n; int i; int j; int pathtype; LuaCheckArgs(l, 1); userdir = lua_tostring(l, 1); n = strlen(userdir); pathtype = 0; // path relative to stratagus dir if (n > 0 && *userdir == '~') { // path relative to user preferences directory pathtype = 1; } // security: disallow all special characters if (strpbrk(userdir, ":*?\"<>|") != 0 || strstr(userdir, "..") != 0) { LuaError(l, "Forbidden directory"); } if (pathtype == 1) { ++userdir; sprintf_s(directory, sizeof(directory), "%s/%s", UserDirectory.c_str(), userdir); } else { sprintf_s(directory, sizeof(directory), "%s/%s", StratagusLibPath.c_str(), userdir); } lua_pop(l, 1); lua_newtable(l); n = ReadDataDirectory(directory, NULL, flp); for (i = 0, j = 0; i < n; ++i) { if ((flp[i].type & mask) == type) { lua_pushnumber(l, j + 1); lua_pushstring(l, flp[i].name); lua_settable(l, 1); ++j; } delete[] flp[i].name; } return 1; } /** ** Return a table with the files or directories found in the subdirectory. */ static int CclListDirectory(lua_State *l) { return CclFilteredListDirectory(l, 0, 0); } /** ** Return a table with the files found in the subdirectory. */ static int CclListFilesInDirectory(lua_State *l) { return CclFilteredListDirectory(l, 0x1, 0x1); } /** ** Return a table with the files found in the subdirectory. */ static int CclListDirsInDirectory(lua_State *l) { return CclFilteredListDirectory(l, 0x0, 0x1); } /** ** Set the local player name ** ** @param l Lua state. */ static int CclSetLocalPlayerName(lua_State *l) { LuaCheckArgs(l, 1); LocalPlayerName = LuaToString(l, 1); return 0; } /** ** Get the local player name ** ** @param l Lua state. */ static int CclGetLocalPlayerName(lua_State *l) { LuaCheckArgs(l, 0); lua_pushstring(l, LocalPlayerName.c_str()); return 1; } /** ** Removes Randomization of Player position in Multiplayer mode ** ** @param l Lua state. */ static int CclNoRandomPlacementMultiplayer(lua_State *l) { LuaCheckArgs(l, 0); NoRandomPlacementMultiplayer = 1; return 0; } /** ** Set God mode. ** ** @param l Lua state. */ static int CclSetGodMode(lua_State *l) { LuaCheckArgs(l, 1); GodMode = LuaToBoolean(l, 1); return 0; } /** ** Get God mode. ** ** @param l Lua state. ** ** @return God mode. */ static int CclGetGodMode(lua_State *l) { LuaCheckArgs(l, 0); lua_pushboolean(l, GodMode); return 1; } /** ** Set building speed. ** ** @param l Lua state. */ static int CclSetSpeedBuild(lua_State *l) { LuaCheckArgs(l, 1); SpeedBuild = LuaToNumber(l, 1); return 0; } /** ** Get building speed. ** ** @param l Lua state. ** ** @return Building speed. */ static int CclGetSpeedBuild(lua_State *l) { LuaCheckArgs(l, 0); lua_pushnumber(l, SpeedBuild); return 1; } /** ** Set training speed. ** ** @param l Lua state. */ static int CclSetSpeedTrain(lua_State *l) { LuaCheckArgs(l, 1); SpeedTrain = LuaToNumber(l, 1); return 0; } /** ** Get training speed. ** ** @param l Lua state. ** ** @return Training speed. */ static int CclGetSpeedTrain(lua_State *l) { LuaCheckArgs(l, 0); lua_pushnumber(l, SpeedTrain); return 1; } /** ** For debug increase all speeds. ** ** @param l Lua state. */ static int CclSetSpeeds(lua_State *l) { LuaCheckArgs(l, 1); SpeedBuild = SpeedTrain = LuaToNumber(l, 1); return 0; } /** ** Define default names for the resources. ** ** @param l Lua state. */ static int CclDefineDefaultResourceNames(lua_State *l) { int i; int args; for (i = 0; i < MaxCosts; ++i) { DefaultResourceNames[i].clear(); } args = lua_gettop(l); for (i = 0; i < MaxCosts && i < args; ++i) { DefaultResourceNames[i] = LuaToString(l, i + 1); } return 0; } /** ** Define default names for the resources. ** ** @param l Lua state. */ static int CclDefineDefaultDisplayResourceNames(lua_State *l) { int i; int args; for (i = 0; i < MaxCosts; ++i) { DefaultDisplayResourceNames[i].clear(); } args = lua_gettop(l); for (i = 0; i < MaxCosts && i < args; ++i) { DefaultDisplayResourceNames[i] = LuaToString(l, i + 1); } return 0; } /** ** Compiled with sound. ** ** @param l Lua state. */ static int CclGetCompileFeature(lua_State *l) { const char *str; LuaCheckArgs(l, 1); str = LuaToString(l, 1); if (CompileOptions.find(str) != std::string::npos) { lua_pushboolean(l, 1); } else { lua_pushboolean(l, 0); } return 1; } /*............................................................................ .. Commands ............................................................................*/ /** ** Send command to ccl. ** ** @param command Zero terminated command string. ** @param exitOnError Exit if an error occurs. */ int CclCommand(const std::string &command, bool exitOnError) { int status; if (!(status = luaL_loadbuffer(Lua, command.c_str(), command.size(), command.c_str()))) { LuaCall(0, 1, exitOnError); } else { report(status, exitOnError); } return status; } /*............................................................................ .. Setup ............................................................................*/ extern int tolua_stratagus_open(lua_State *tolua_S); /** ** Initialize Lua */ static void InitLua() { // For security we don't load all libs static const luaL_Reg lualibs[] = { {"", luaopen_base}, // {LUA_LOADLIBNAME, luaopen_package}, {LUA_TABLIBNAME, luaopen_table}, // {LUA_IOLIBNAME, luaopen_io}, // {LUA_OSLIBNAME, luaopen_os}, {LUA_STRLIBNAME, luaopen_string}, {LUA_MATHLIBNAME, luaopen_math}, {LUA_DBLIBNAME, luaopen_debug}, {NULL, NULL} }; Lua = luaL_newstate(); for (const luaL_Reg *lib = lualibs; lib->func; ++lib) { lua_pushcfunction(Lua, lib->func); lua_pushstring(Lua, lib->name); lua_call(Lua, 1, 0); } tolua_stratagus_open(Lua); lua_settop(Lua, 0); // discard any results } /** ** Initialize ccl and load the config file(s). */ void InitCcl(void) { InitLua(); lua_register(Lua, "CompileFeature", CclGetCompileFeature); lua_register(Lua, "LibraryPath", CclStratagusLibraryPath); lua_register(Lua, "ListDirectory", CclListDirectory); lua_register(Lua, "ListFilesInDirectory", CclListFilesInDirectory); lua_register(Lua, "ListDirsInDirectory", CclListDirsInDirectory); lua_register(Lua, "SetLocalPlayerName", CclSetLocalPlayerName); lua_register(Lua, "GetLocalPlayerName", CclGetLocalPlayerName); lua_register(Lua, "SetGodMode", CclSetGodMode); lua_register(Lua, "GetGodMode", CclGetGodMode); lua_register(Lua, "SetSpeedBuild", CclSetSpeedBuild); lua_register(Lua, "GetSpeedBuild", CclGetSpeedBuild); lua_register(Lua, "SetSpeedTrain", CclSetSpeedTrain); lua_register(Lua, "GetSpeedTrain", CclGetSpeedTrain); lua_register(Lua, "SetSpeeds", CclSetSpeeds); lua_register(Lua, "DefineDefaultResourceNames", CclDefineDefaultResourceNames); lua_register(Lua, "DefineDefaultDisplayResourceNames", CclDefineDefaultDisplayResourceNames); lua_register(Lua, "NoRandomPlacementMultiplayer", CclNoRandomPlacementMultiplayer); lua_register(Lua, "SavePreferences", CclSavePreferences); lua_register(Lua, "Load", CclLoad); lua_register(Lua, "LoadBuffer", CclLoadBuffer); lua_register(Lua, "GetCurrentLuaPath", CclGetCurrentLuaPath); lua_register(Lua, "SavedGameInfo", CclSavedGameInfo); ReplayCclRegister(); IconCclRegister(); MissileCclRegister(); PlayerCclRegister(); MapCclRegister(); ConstructionCclRegister(); DecorationCclRegister(); UnitTypeCclRegister(); UpgradesCclRegister(); SelectionCclRegister(); GroupCclRegister(); UnitCclRegister(); SoundCclRegister(); UserInterfaceCclRegister(); AiCclRegister(); TriggerCclRegister(); SpellCclRegister(); } /** ** Serializes Lua objects to Lua source code. */ class CSerializeLua { public: CSerializeLua(lua_State *l) : lstate(l), indent(0) {} /** Whether a value was successfully serialized. */ enum Result { /** The value was serialized as requested. */ OK, /** The value contains something that cannot be ** serialized. The caller should skip the global ** variable it is currently trying to serialize. */ SKIP, /** Something went seriously wrong and the whole ** serialization should be aborted. */ FAIL }; Result AppendLuaFields(int table_index, bool is_root); char *StrDupOutput() const; private: /** The Lua state from which we're serializing the values. */ lua_State *const lstate; /** The Lua source code being generated. ** ** This is an std::vector rather than an std::string ** because appending characters to std::string gets slow ** in some implementations when the string is long. */ std::vector output; /** Current indentation level. */ int indent; inline void AppendChar(char c); inline void AppendChars(const char *str, size_t len); inline void AppendCString(const char *str); inline void AppendIndent(); void AppendQuotedString(const char *str, size_t len); static bool IsBlacklistedGlobal(const char *key); static bool IsIdentifier(const char *key, size_t len); Result AppendLuaTable(int table_index); Result AppendLuaAsString(int index); Result AppendLuaValue(int index); }; /** ** Append a character to the Lua source code, ** without any kind of quoting or escaping. ** ** @param c ** The character. */ inline void CSerializeLua::AppendChar(char c) { this->output.push_back(c); } /** ** Append an array of characters to the Lua source code, ** without any kind of quoting or escaping. ** ** @param str ** The address of the first character. ** @param str ** The length of the array, in bytes. */ inline void CSerializeLua::AppendChars(const char *str, size_t len) { this->output.insert(this->output.end(), str, str + len); } /** ** Append a null-terminated string to the Lua source code, ** without any kind of quoting or escaping. ** ** @param str ** The address of the first character of the string. */ inline void CSerializeLua::AppendCString(const char *str) { this->AppendChars(str, strlen(str)); } /** ** Append the current indentation to the Lua source code. */ inline void CSerializeLua::AppendIndent() { this->output.insert(this->output.end(), this->indent, '\t'); } /** ** Append a string literal to the Lua source code, with quotes ** around it, and any unusual bytes encoded as backslash escapes. ** ** @param str ** The address of the first character of the string. ** @param len ** The length of the string, in bytes. */ void CSerializeLua::AppendQuotedString(const char *str, size_t len) { const unsigned char *src; this->AppendChar('"'); for (src = (const unsigned char *)str; len > 0; ++src, --len) { if (*src == '"' || *src == '\\') { // " -> \" this->AppendChar('\\'); this->AppendChar(*src); } else if (*src < 32 || *src > 127) { // 0xA -> \010 char esc[5]; sprintf_s(esc, 5, "\\%03d", *src); this->AppendChars(esc, 4); } else { this->AppendChar(*src); } } this->AppendChar('"'); } /** ** Check whether a global Lua variable is blacklisted from being saved. ** ** @param key name of the variable in the global environment. ** ** @return true if the variable is blacklisted and must not be saved. ** false if the variable may be saved. */ bool CSerializeLua::IsBlacklistedGlobal(const char *key) { return (!strcmp(key, "assert") || !strcmp(key, "gcinfo") || !strcmp(key, "getfenv") || !strcmp(key, "unpack") || !strcmp(key, "tostring") || !strcmp(key, "tonumber") || !strcmp(key, "setmetatable") || !strcmp(key, "require") || !strcmp(key, "pcall") || !strcmp(key, "rawequal") || !strcmp(key, "collectgarbage") || !strcmp(key, "type") || !strcmp(key, "getmetatable") || !strcmp(key, "next") || !strcmp(key, "print") || !strcmp(key, "xpcall") || !strcmp(key, "rawset") || !strcmp(key, "setfenv") || !strcmp(key, "rawget") || !strcmp(key, "newproxy") || !strcmp(key, "ipairs") || !strcmp(key, "loadstring") || !strcmp(key, "dofile") || !strcmp(key, "_VERSION") || !strcmp(key, "pairs") || !strcmp(key, "__pow") || !strcmp(key, "error") || !strcmp(key, "loadfile") || !strcmp(key, "arg") || !strcmp(key, "_LOADED") || !strcmp(key, "loadlib") || !strcmp(key, "string") || !strcmp(key, "os") || !strcmp(key, "io") || !strcmp(key, "debug") || !strcmp(key, "coroutine") || !strcmp(key, "_G") || !strcmp(key, "AiTypes") || // data-dep !strcmp(key, "AllowAll") || // Lua const !strcmp(key, "AllowedUnits") || // data-dep !strcmp(key, "DownButton") || // #define !strcmp(key, "EditorCommandLine") || // enum !strcmp(key, "EditorEditing") || // enum !strcmp(key, "EditorNotRunning") || // enum !strcmp(key, "EditorStarted") || // enum !strcmp(key, "EnergyCost") || // #define !strcmp(key, "FontColors") || // has meta !strcmp(key, "Fonts") || // has meta !strcmp(key, "ForbidAll") || // Lua const !strcmp(key, "GameDefeat") || // enum !strcmp(key, "GameDraw") || // enum !strcmp(key, "GameNoResult") || // enum !strcmp(key, "GameQuitToMenu") || // enum !strcmp(key, "GameRestart") || // enum !strcmp(key, "GameVictory") || // enum !strcmp(key, "Icons") || // has meta !strcmp(key, "LeftButton") || // #define !strcmp(key, "MagmaCost") || // #define !strcmp(key, "MaxCosts") || // #define !strcmp(key, "MaxFontColors") || // #define !strcmp(key, "MiddleButton") || // #define !strcmp(key, "NoButton") || // #define !strcmp(key, "PlayerComputer") || // enum !strcmp(key, "PlayerMax") || // #define !strcmp(key, "PlayerNeutral") || // enum !strcmp(key, "PlayerNobody") || // enum !strcmp(key, "PlayerNumNeutral") || // #define !strcmp(key, "PlayerPerson") || // enum !strcmp(key, "PlayerRescueActive") || // enum !strcmp(key, "PlayerRescuePassive") || // enum !strcmp(key, "RightButton") || // #define !strcmp(key, "SettingsGameTypeFreeForAll") || // enum !strcmp(key, "SettingsGameTypeLeftVsRight") || // enum !strcmp(key, "SettingsGameTypeManTeamVsMachine") || // enum !strcmp(key, "SettingsGameTypeManVsMachine") || // enum !strcmp(key, "SettingsGameTypeMapDefault") || // enum !strcmp(key, "SettingsGameTypeMelee") || // enum !strcmp(key, "SettingsGameTypeTopVsBottom") || // enum !strcmp(key, "SettingsPresetMapDefault") || // enum !strcmp(key, "UnitMax") || // #define !strcmp(key, "UpButton") || // #define !strcmp(key, "default_objectives") || // per-lang !strcmp(key, "playlist") || // per-user !strcmp(key, "preferences")); // per-user // other string to protected ? } /** ** Check whether the given string is valid for a Lua identifier. ** ** @param key ** The address of the first character of the string. ** @param len ** The length of the string, in bytes. ** ** The @a len parameter exists so that strings containing ** embedded null characters can be passed to this function ** and properly detected as invalid identifiers. ** ** @return ** true if the string is OK as a Lua identifier. ** false if the string cannot be used as a Lua identifier. */ bool CSerializeLua::IsIdentifier(const char *key, size_t len) { if (len < 1) { return false; } if (!isalpha(static_cast(key[0])) && key[0] != '_') { return false; } for (size_t i = 0; i < len; ++i) { if (!isalnum(static_cast(key[i])) && key[i] != '_') { return false; } } return true; } /** ** Append a Lua string or number value to the Lua source code. ** ** @param index ** The index of the value in the Lua stack. ** This function does not modify the value in the stack. ** ** @return ** CSerializeLua::OK or CSerializeLua::FAIL. ** This function never returns CSerializeLua::SKIP. */ CSerializeLua::Result CSerializeLua::AppendLuaAsString(int index) { // Make a copy so that lua_tolstring won't replace the // original number with a string. lua_pushvalue(this->lstate, index); size_t len; const char *str = lua_tolstring(this->lstate, -1, &len); if (str == NULL) { lua_pop(this->lstate, 1); return FAIL; } else { this->AppendChars(str, len); lua_pop(this->lstate, 1); return OK; } } /** ** Append a Lua table to the Lua source code, with braces around it. ** ** @param index ** The index of the table in the Lua stack. ** This function does not modify the value in the stack. ** ** @return ** CSerializeLua::OK, CSerializeLua::FAIL, or CSerializeLua::SKIP. */ CSerializeLua::Result CSerializeLua::AppendLuaTable(int index) { if (lua_getmetatable(this->lstate, index)) { lua_pop(this->lstate, 1); // pop the metatable return SKIP; } this->AppendChar('{'); this->indent++; Result result = this->AppendLuaFields(index, false); this->indent--; this->AppendChar('}'); return result; } /** ** Append a Lua value to the Lua source code. ** ** @param index ** The index of the value in the Lua stack. ** This function does not modify the value in the stack. ** ** @return ** CSerializeLua::OK, CSerializeLua::FAIL, or CSerializeLua::SKIP. */ CSerializeLua::Result CSerializeLua::AppendLuaValue(int index) { int type = lua_type(this->lstate, index); switch (type) { case LUA_TNIL: this->AppendCString("nil"); return OK; case LUA_TNUMBER: // Let Lua do the conversion. return this->AppendLuaAsString(index); case LUA_TBOOLEAN: if (lua_toboolean(this->lstate, index)) { this->AppendCString("true"); } else { this->AppendCString("false"); } return OK; case LUA_TSTRING: { size_t len; const char *str = lua_tolstring(this->lstate, index, &len); this->AppendQuotedString(str, len); return OK; } case LUA_TTABLE: return this->AppendLuaTable(index); case LUA_TFUNCTION: // Could be done with string.dump(function) // and debug.getinfo(function).name (could be nil for anonymous function) // But not useful yet. return SKIP; case LUA_TUSERDATA: case LUA_TTHREAD: case LUA_TLIGHTUSERDATA: case LUA_TNONE: default : // no other cases return SKIP; } } /** ** Append the fields (keys and values) of a Lua table to the Lua ** source code. ** ** @param table_index ** The index of the table in the Lua stack. ** @param is_root ** True if the table is a global environment and this function ** should generate a series of assignment statements. ** False if the table is something else and this function should ** generate a fieldlist for a tableconstructor. ** ** @return ** CSerializeLua::OK if it appended the fields as requested. ** CSerializeLua::FAIL if something went seriously wrong and the ** whole serialization should be aborted. ** CSerializeLua::SKIP if is_root is false and the table contains ** something that cannot be serialized. ** ** If is_root is true and the table contains a field that cannot be ** serialized, then this function just skips that field and continues ** serializing the rest of the table. This is so that the global ** environment can be serialized even though it contains functions. */ CSerializeLua::Result CSerializeLua::AppendLuaFields(int table_index, bool is_root) { if (!lua_checkstack(this->lstate, 10)) return FAIL; const int top_on_entry = lua_gettop(this->lstate); Assert(lua_istable(this->lstate, table_index)); lua_Number seq = 1; bool is_first = true; lua_pushnil(this->lstate); while (lua_next(this->lstate, table_index)) { const int key_index = top_on_entry + 1; const int value_index = top_on_entry + 2; Result result; // If there's any problem with the field, then we // remove it from the output vector by truncating // back to this size. const size_t undo = this->output.size(); if (!is_root) { if (is_first) { this->AppendChar('\n'); } else { this->AppendCString(",\n"); } this->AppendIndent(); } // Append the key and and equals sign, if necessary. bool increment_seq = false; const int key_type = lua_type(this->lstate, key_index); if (is_root) { if (key_type != LUA_TSTRING) { goto skip_field; } size_t key_len; const char *key_str = lua_tolstring(this->lstate, key_index, &key_len); if (!IsIdentifier(key_str, key_len) || IsBlacklistedGlobal(key_str)) { goto skip_field; } this->AppendChars(key_str, key_len); this->AppendCString(" = "); } else if (key_type == LUA_TSTRING) { size_t key_len; const char *key_str = lua_tolstring(this->lstate, key_index, &key_len); if (IsIdentifier(key_str, key_len)) { this->AppendChars(key_str, key_len); } else { this->AppendChar('['); this->AppendQuotedString(key_str, key_len); this->AppendChar(']'); } this->AppendCString(" = "); } else if (key_type == LUA_TNUMBER) { if (lua_tonumber(this->lstate, key_index) == seq) { // Increment seq only after the value // has been successfully serialized. increment_seq = true; } else { this->AppendChar('['); result = this->AppendLuaAsString(key_index); if (result != OK) { return result; } this->AppendCString("] = "); } } else { goto skip_field; } result = this->AppendLuaValue(value_index); switch (result) { case OK: if (is_root) { this->AppendCString(";\n"); } is_first = false; if (increment_seq) ++seq; break; case SKIP: skip_field: this->output.resize(undo); if (!is_root) { lua_settop(this->lstate, top_on_entry); return SKIP; } break; case FAIL: default: lua_settop(this->lstate, top_on_entry); return result; } lua_pop(this->lstate, 1); // pop the value } if (!is_first && !is_root) { this->AppendChar(' '); } return OK; } /** ** Copy the Lua source code to a new string. ** ** @return The Lua source code as a string. ** The caller must eventually free it with delete[]. */ char *CSerializeLua::StrDupOutput() const { const size_t size = this->output.size(); char *const str = new char[size + 1]; if (size > 0) { memcpy(str, &this->output[0], size); } str[size] = '\0'; return str; } /** ** For saving lua state (table, number, string, bool, not function). ** ** @param l lua_State to save. ** @param is_root true to save global variables, ** false to save and pop the table at top of stack. ** ** @return NULL if nothing could be saved. ** else a string that could be executed in lua to restore lua state */ char *SaveGlobal(lua_State *l, bool is_root) { CSerializeLua serialize(l); if (is_root) { lua_pushvalue(l, LUA_GLOBALSINDEX); } CSerializeLua::Result result = serialize.AppendLuaFields(lua_gettop(l), is_root); lua_pop(l, 1); if (result == CSerializeLua::OK) { return serialize.StrDupOutput(); } else { return NULL; } } /** ** Create directories containing user settings and data. ** ** More specifically: logs, saved games, preferences */ void CreateUserDirectories(void) { std::string directory; UserDirectory = ""; std::string s; #ifdef USE_WIN32 s = getenv("APPDATA"); #else s = getenv("HOME"); #endif if (!s.empty()) { UserDirectory = s + "/"; } UserDirectory += STRATAGUS_HOME_PATH; makedir(UserDirectory.c_str(), 0777); // Create specific subdirectories directory = UserDirectory + "logs/"; makedir(directory.c_str(), 0777); directory = UserDirectory + "save/"; makedir(directory.c_str(), 0777); directory = UserDirectory + "patches/"; makedir(directory.c_str(), 0777); } /** ** Save user preferences */ void SavePreferences(void) { FILE *fd; std::string path; lua_pushstring(Lua, "preferences"); lua_gettable(Lua, LUA_GLOBALSINDEX); if (lua_type(Lua, -1) == LUA_TTABLE) { path = UserDirectory + "preferences.lua"; fd = fopen(path.c_str(), "w"); if (!fd) { return; } char *s = SaveGlobal(Lua, false); fprintf(fd, "preferences = {%s}\n", s); delete[] s; fclose(fd); } } /** ** Load stratagus config file. */ void LoadCcl(void) { char buf[PATH_MAX]; // // Load and evaluate configuration file // CclInConfigFile = 1; LibraryFileName(CclStartFile.c_str(), buf, sizeof(buf)); if (access(buf, R_OK)) { fprintf(stderr, "Maybe you need to specify another gamepath with '-d /path/to/datadir'?\n"); ExitFatal(-1); } ShowLoadProgress("Script %s\n", buf); LuaLoadFile(buf); CclInConfigFile = 0; CclGarbageCollect(0); // Cleanup memory after load } /** ** Save CCL Module. ** ** @param file Save file. */ void SaveCcl(CFile *file) { file->printf("SetGodMode(%s)\n", GodMode ? "true" : "false"); file->printf("SetSpeedBuild(%d)\n", SpeedBuild); file->printf("SetSpeedTrain(%d)\n", SpeedTrain); } //@}