65 #define DBG_LUA LOG_STREAM(debug, log_scripting_lua)
66 #define LOG_LUA LOG_STREAM(info, log_scripting_lua)
67 #define WRN_LUA LOG_STREAM(warn, log_scripting_lua)
68 #define ERR_LUA LOG_STREAM(err, log_scripting_lua)
71 static const char *
Gen =
"name generator";
74 static const char *
Interp =
"lua interpreter";
83 template<VERSION_COMP_OP vop>
89 lua_pushboolean(L, result);
99 if(lua_isinteger(L, 2)) {
100 int n = lua_tointeger(L, 2) - 1;
102 if(
n >= 0 &&
size_t(
n) < components.size()) {
109 char const *m = luaL_checkstring(L, 2);
117 }
else if(strcmp(m,
"sep") == 0) {
126 static const std::vector<std::string> fields{
"major",
"minor",
"revision",
"is_canonical",
"special",
"sep"};
137 vers->~version_info();
157 if(luaL_testudata(L, 1,
Version)) {
163 if(lua_type(L, 1) == LUA_TSTRING) {
166 int major = luaL_checkinteger(L, 1), minor = luaL_optinteger(L, 2, 0), rev = luaL_optinteger(L, 3, 0);
167 std::string sep, special;
168 if(lua_type(L, -1) == LUA_TSTRING) {
169 special = lua_tostring(L, -1);
170 if(!special.empty() && std::isalpha(special[0])) {
173 sep.push_back(special[0]);
174 special = special.substr(1);
179 new(L)
version_info(major, minor, rev, sep[0], special);
181 if(luaL_newmetatable(L,
Version)) {
182 static const luaL_Reg metafuncs[] {
186 {
"__lt", &impl_version_compare<VERSION_COMP_OP::OP_LESS> },
187 {
"__le", &impl_version_compare<VERSION_COMP_OP::OP_LESS_OR_EQUAL> },
188 {
"__eq", &impl_version_compare<VERSION_COMP_OP::OP_EQUAL> },
192 luaL_setfuncs(L, metafuncs, 0);
193 luaW_table_set<std::string>(L, -1,
"__metatable",
Version);
195 lua_setmetatable(L, -2);
215 DBG_LUA <<
"intf_print called:";
216 std::size_t nargs = lua_gettop(L);
218 lua_getglobal(L,
"tostring");
219 for (std::size_t
i = 1;
i <= nargs; ++
i) {
220 lua_pushvalue(L, -1);
223 const char * str = lua_tostring(L, -1);
225 LOG_LUA <<
"'tostring' must return a value to 'print'";
244 static const char*
const prefix =
"Warning:\n ";
245 static std::ostringstream warning(prefix);
246 warning.seekp(0, std::ios::end);
247 warning <<
msg <<
' ';
249 auto L =
reinterpret_cast<lua_State*
>(
p);
252 lua_pushinteger(L, 2);
254 auto& lk = lua_kernel_base::get_lua_kernel<lua_kernel_base>(L);
255 lk.add_log_to_console(luaL_checkstring(L, -1));
271 std::string chunk = luaL_checkstring(L, 1);
272 const char* name = luaL_optstring(L, 2, chunk.c_str());
273 std::string mode = luaL_optstring(L, 3,
"t");
274 bool override_env = !lua_isnone(L, 4);
277 return luaL_argerror(L, 3,
"binary chunks are not allowed for security reasons");
280 int result = luaL_loadbufferx(L, chunk.data(), chunk.length(), name,
"t");
281 if(result != LUA_OK) {
293 const char* upvalue_name = lua_setupvalue(L, -2, 1);
294 if(upvalue_name ==
nullptr) {
308 lua_CFunction function = lua_tocfunction(L, lua_upvalueindex(1));
311 int nRets =
function(L);
323 std::string message =
"There is already an external logger attached to this lua kernel, you cannot open the lua console right now.";
335 lua_pushstring(L, gen->
generate().c_str());
348 std::string
type = luaL_checkstring(L, 1);
351 if(
type ==
"markov" ||
type ==
"markov_chain") {
352 std::vector<std::string> input;
353 if(lua_istable(L, 2)) {
354 input = lua_check<std::vector<std::string>>(L, 2);
358 int chain_sz = luaL_optinteger(L, 3, 2);
359 int max_len = luaL_optinteger(L, 4, 12);
363 }
else if(
type ==
"context_free" ||
type ==
"cfg" ||
type ==
"CFG") {
364 if(lua_istable(L, 2)) {
365 std::map<std::string, std::vector<std::string>>
data;
366 for(lua_pushnil(L); lua_next(L, 2); lua_pop(L, 1)) {
367 if(lua_type(L, -2) != LUA_TSTRING) {
368 lua_pushstring(L,
"CFG generator: invalid nonterminal name (must be a string)");
371 if(lua_isstring(L, -1)) {
373 if(productions.size() > 1) {
374 deprecated_message(
"wesnoth.name_generator('cfg', {nonterminal = 'a|b'})",
DEP_LEVEL::INDEFINITE,
"1.17",
"Non-terminals should now be assigned an array of productions instead of a single string containing productions separated by | - but a single string is fine if it's only one production");
376 }
else if(lua_istable(L, -1)) {
377 const auto&
split = lua_check<std::vector<t_string>>(L, -1);
378 auto& productions =
data[lua_tostring(L,-2)];
381 lua_pushstring(L,
"CFG generator: invalid nonterminal value (must be a string or list of strings)");
395 return luaL_argerror(L, 1,
"should be either 'markov_chain' or 'context_free'");
399 lua_pushstring(L, ex.
what());
405 luaL_getmetatable(L,
Gen);
406 lua_setmetatable(L, -2);
417 const std::string& logger = lua_isstring(L, 2) ? luaL_checkstring(L, 1) :
"";
418 std::string
msg = lua_isstring(L, 2) ? luaL_checkstring(L, 2) : luaL_checkstring(L, 1);
419 if(
msg.empty() ||
msg.back() !=
'\n') {
423 if(logger ==
"err" || logger ==
"error") {
425 }
else if(logger ==
"warn" || logger ==
"wrn" || logger ==
"warning") {
427 }
else if((logger ==
"debug" || logger ==
"dbg")) {
443 const std::string elem = luaL_checkstring(L, 1);
446 const std::string ver_str = lua_isnoneornil(L, 3) ?
"" : luaL_checkstring(L, 3);
455 lua_warning(L,
msg.c_str(),
false);
470 if(!lua_istable(L, 1)) {
473 auto names = lua_check<std::vector<std::string>>(L, 2);
475 int len = luaL_checkinteger(L, -1);
477 for(
int i = 1; i <= std::max<int>(len,
names.size());
i++) {
488 temp.
read(luaL_checkstring(L, 1));
489 std::set<map_location> locs;
490 for(
int x = 1; x <= temp.
width(); x++) {
491 for(
int y = 1; y <= temp.
height(); y++) {
492 if(!temp.
value(x, y)) {
506 for(
const auto& loc : locs) {
507 temp.
clear(loc.wml_x(), loc.wml_y());
518 lua_pushinteger(L, SDL_GetTicks());
530 switch(luaL_getmetafield(L, -1,
"__dir")) {
534 if(lua_pcall(L, 2, 1, 0) == LUA_OK) {
535 keys = lua_check<std::vector<std::string>>(L, -1);
537 lua_warning(L,
"wesnoth.print_attributes: __dir metamethod raised an error",
false);
541 auto dir_keys = lua_check<std::vector<std::string>>(L, -1);
542 std::copy(dir_keys.begin(), dir_keys.end(), std::back_inserter(keys));
551 auto key = luaL_checkstring(L, 2);
552 auto type = lua_getfield(L, 1, key);
553 if(
type == LUA_TTABLE) {
554 lua_pushliteral(L,
"__deprecated");
555 if(lua_rawget(L, -2) == LUA_TBOOLEAN) {
557 lua_pushboolean(L, deprecated);
562 lua_pushboolean(L,
false);
569 auto key = luaL_checkstring(L, 2);
570 std::string suffix =
" ";
571 auto type = lua_getfield(L, 1, key);
572 if(
type == LUA_TTABLE) {
574 }
else if(
type == LUA_TFUNCTION) {
576 }
else if(
type == LUA_TUSERDATA) {
577 lua_getglobal(L,
"getmetatable");
578 lua_pushvalue(L, -2);
580 if(lua_type(L, -1) == LUA_TSTRING) {
581 auto meta = lua_check<std::string>(L, -1);
582 if(meta ==
"function") {
587 if(suffix.size() == 1) {
589 if(
auto t = luaL_getmetafield(L, -1,
"__dir_tablelike");
t == LUA_TBOOLEAN) {
594 }
else if(
t != LUA_TNIL) {
599 suffix =
" " + suffix;
600 lua_pushlstring(L, suffix.c_str(), suffix.size());
610 if(idx < 0 && idx >= -lua_gettop(L)) {
611 idx = lua_absindex(L, idx);
613 std::vector<std::string> keys;
614 if(lua_istable(L, idx)) {
617 int save_top = lua_gettop(L);
618 lua_pushvalue(L, idx);
620 lua_settop(L, save_top);
623 int table_idx = lua_absindex(L, -1);
624 for(lua_pushnil(L); lua_next(L, table_idx); lua_pop(L, 1)) {
625 if(lua_type(L, -2) == LUA_TSTRING) {
626 keys.push_back(lua_tostring(L,-2));
634 if(luaL_getmetafield(L, table_idx,
"__index") == LUA_TNIL)
break;
635 }
while(lua_istable(L, -1));
636 if(lua_isfunction(L, -1)) {
640 }
else if(lua_isuserdata(L, idx) && !lua_islightuserdata(L, idx)) {
641 lua_pushvalue(L, idx);
646 std::sort(keys.begin(), keys.end());
647 auto new_end = std::unique(keys.begin(), keys.end());
648 new_end = std::remove_if(keys.begin(), new_end, [L, idx](
const std::string& key) {
649 if(key.compare(0, 2,
"__") == 0) {
652 int save_top = lua_gettop(L);
654 lua_settop(L, save_top);
661 lua_pushvalue(L, idx);
663 if(lua_pcall(L, 2, 1, 0) == LUA_OK) {
668 keys.erase(new_end, keys.end());
686 if(lua_isnil(L, 1))
return luaL_argerror(L, 1,
"Can't dir() nil");
687 if(!lua_isfunction(L, 2)) {
690 int fcn_idx = lua_gettop(L);
692 size_t max_len = std::accumulate(keys.begin(), keys.end(), 0, [](
size_t max,
const std::string& next) {
693 return std::max(max, next.size());
696 static const size_t MAX_WIDTH = 80, COL_PADDING = 3, SUFFIX_PADDING = 2;
697 size_t col_width = max_len + COL_PADDING + SUFFIX_PADDING;
698 size_t n_cols = (MAX_WIDTH + COL_PADDING) / col_width;
699 size_t n_rows = ceil(keys.size() /
double(n_cols));
700 for(
size_t i = 0;
i < n_rows;
i++) {
701 std::ostringstream
line;
703 line.setf(std::ios::left);
704 for(
size_t j = 0; j < n_cols && j + (
i * n_cols) < keys.size(); j++) {
705 int save_top = lua_gettop(L);
707 lua_settop(L, save_top);
711 const auto& key = keys[j +
i * n_cols];
712 lua_pushlstring(L, key.c_str(), key.size());
713 std::string suffix =
" !";
714 if(lua_pcall(L, 2, 1, 0) == LUA_OK) {
715 suffix = luaL_checkstring(L, -1);
719 line.width(col_width - SUFFIX_PADDING + suffix.size());
723 lua_pushvalue(L, fcn_idx);
735 template <member_callback method>
737 return ((lua_kernel_base::get_lua_kernel<lua_kernel_base>(L)).*method)(L);
742 : mState(luaL_newstate())
752 cmd_log_ <<
"Adding boost function proxy...\n";
758 cmd_log_ <<
"Adding standard libs...\n";
760 static const luaL_Reg safe_libs[] {
761 {
"", luaopen_base },
762 {
"table", luaopen_table },
763 {
"string", luaopen_string },
764 {
"math", luaopen_math },
765 {
"coroutine", luaopen_coroutine },
766 {
"debug", luaopen_debug },
767 {
"os", luaopen_os },
768 {
"utf8", luaopen_utf8 },
777 for (luaL_Reg
const *lib = safe_libs; lib->func; ++lib)
779 luaL_requiref(L, lib->name, lib->func, strlen(lib->name));
784 lua_getglobal(L,
"os");
786 while(lua_next(L, -2) != 0) {
788 char const*
function = lua_tostring(L, -1);
789 if(strcmp(
function,
"clock") == 0 || strcmp(
function,
"date") == 0
790 || strcmp(
function,
"time") == 0 || strcmp(
function,
"difftime") == 0)
continue;
792 lua_setfield(L, -3,
function);
798 lua_setglobal(L,
"dofile");
800 lua_setglobal(L,
"loadfile");
803 cmd_log_ <<
"Adding error handler...\n";
810 cmd_log_ <<
"Registering basic wesnoth API...\n";
812 static luaL_Reg
const callbacks[] {
815 {
"dofile", &dispatch<&lua_kernel_base::intf_dofile> },
816 {
"require", &dispatch<&lua_kernel_base::intf_require> },
817 {
"kernel_type", &dispatch<&lua_kernel_base::intf_kernel_type> },
831 lua_getglobal(L,
"wesnoth");
832 if (!lua_istable(L,-1)) {
835 luaL_setfuncs(L, callbacks, 0);
837 lua_setglobal(L,
"wesnoth");
847 cmd_log_ <<
"Redirecting print function...\n";
849 lua_getglobal(L,
"print");
850 lua_setglobal(L,
"std_print");
854 lua_pushcfunction(L, &dispatch<&lua_kernel_base::intf_print>);
855 lua_setglobal(L,
"print");
858 lua_setglobal(L,
"load");
860 lua_setglobal(L,
"loadstring");
863 cmd_log_ <<
"Wrapping pcall and xpcall functions...\n";
864 lua_getglobal(L,
"pcall");
866 lua_setglobal(L,
"pcall");
867 lua_getglobal(L,
"xpcall");
869 lua_setglobal(L,
"xpcall");
871 cmd_log_ <<
"Initializing package repository...\n";
873 lua_getglobal(L,
"wesnoth");
875 lua_setfield(L, -2,
"package");
878 lua_pushstring(L,
"lua/package.lua");
881 cmd_log_ <<
"Error: Failed to initialize package repository. Falling back to less flexible C++ implementation.\n";
885 cmd_log_ <<
"Adding map table...\n";
887 static luaL_Reg
const map_callbacks[] {
908 lua_getglobal(L,
"wesnoth");
910 luaL_setfuncs(L, map_callbacks, 0);
911 lua_setfield(L, -2,
"map");
915 cmd_log_ <<
"Adding game_config table...\n";
917 lua_getglobal(L,
"wesnoth");
918 lua_newuserdatauv(L, 0, 0);
919 lua_createtable(L, 0, 3);
920 lua_pushcfunction(L, &dispatch<&lua_kernel_base::impl_game_config_get>);
921 lua_setfield(L, -2,
"__index");
922 lua_pushcfunction(L, &dispatch<&lua_kernel_base::impl_game_config_set>);
923 lua_setfield(L, -2,
"__newindex");
924 lua_pushcfunction(L, &dispatch<&lua_kernel_base::impl_game_config_dir>);
925 lua_setfield(L, -2,
"__dir");
926 lua_pushboolean(L,
true);
927 lua_setfield(L, -2,
"__dir_tablelike");
928 lua_pushstring(L,
"game config");
929 lua_setfield(L, -2,
"__metatable");
930 lua_setmetatable(L, -2);
931 lua_setfield(L, -2,
"game_config");
935 cmd_log_ <<
"Adding rng tables...\n";
938 cmd_log_ <<
"Adding name generator metatable...\n";
939 luaL_newmetatable(L,
Gen);
953 cmd_log_ <<
"Sandboxing Lua interpreter...\nTo make variables visible outside the interpreter, assign to _G.variable.\n";
954 cmd_log_ <<
"The special variable _ holds the result of the last expression (if any).\n";
956 lua_createtable(L, 0, 1);
957 lua_getglobal(L,
"_G");
958 lua_setfield(L, -2,
"__index");
959 lua_setmetatable(L, -2);
961 lua_setfield(L, -2,
"dir");
962 lua_setfield(L, LUA_REGISTRYINDEX,
Interp);
969 lua_pushstring(L,
"lua/ilua.lua");
972 lua_pushstring(L,
"set_strict");
975 cmd_log_ <<
"Failed to activate strict mode.\n";
977 cmd_log_ <<
"Activated strict mode.\n";
980 lua_setglobal(L,
"ilua");
982 cmd_log_ <<
"Error: failed to load ilua.\n";
988 lua_getglobal(L,
"debug");
990 while(lua_next(L, -2) != 0) {
992 char const*
function = lua_tostring(L, -1);
993 if(strcmp(
function,
"traceback") == 0 || strcmp(
function,
"getinfo") == 0)
continue;
995 lua_setfield(L, -3,
function);
1039 if (errcode != LUA_OK) {
1040 char const *
msg = lua_tostring(L, -1);
1042 std::string context =
"When executing, ";
1043 if (errcode == LUA_ERRRUN) {
1044 context +=
"Lua runtime error: ";
1045 }
else if (errcode == LUA_ERRERR) {
1046 context +=
"Lua error in attached debugger: ";
1047 }
else if (errcode == LUA_ERRMEM) {
1048 context +=
"Lua out of memory error: ";
1050 context +=
"unknown lua error: ";
1052 if(lua_isstring(L, -1)) {
1053 context +=
msg ?
msg :
"null string";
1055 context += lua_typename(L, lua_type(L, -1));
1060 e_h(context.c_str(),
"Lua Error");
1071 int errcode = luaL_loadbufferx(
mState, prog, strlen(prog), name.empty() ? prog : name.c_str(),
"t");
1072 if (errcode != LUA_OK) {
1073 char const *
msg = lua_tostring(
mState, -1);
1074 std::string message =
msg ?
msg :
"null string";
1076 std::string context =
"When parsing a string to lua, ";
1078 if (errcode == LUA_ERRSYNTAX) {
1079 context +=
" a syntax error";
1080 }
else if(errcode == LUA_ERRMEM){
1081 context +=
" a memory error";
1083 context +=
" an unknown error";
1088 e_h(message.c_str(), context.c_str());
1102 this->
run(cfg[
"code"].str().c_str(), cfg[
"name"].str(), nArgs);
1111 if(in_interpreter) {
1113 if(lua_setupvalue(
mState, -2, 1) ==
nullptr)
1116 lua_insert(
mState, -nArgs - 1);
1117 this->
protected_call(nArgs, in_interpreter ? LUA_MULTRET : 0, eh);
1133 std::string experiment =
"return ";
1135 int top = lua_gettop(
mState);
1142 this->
load_string(experiment.c_str(),
"interactive", eh);
1144 if(lua_setupvalue(
mState, -2, 1) ==
nullptr)
1148 if(lua_gettop(
mState) == top + 1) {
1158 int nRets = lua_gettop(
mState) - top - 1;
1162 int env_idx = lua_gettop(
mState);
1163 lua_pushvalue(
mState, top + 2);
1164 lua_setfield(
mState, -2,
"_");
1167 for(
int i = top + 2;
i < env_idx;
i++)
1170 lua_setfield(
mState, -2,
"_all");
1183 luaL_checkstring(L, 1);
1184 lua_rotate(L, 1, -1);
1187 lua_rotate(L, 1, 1);
1191 lua_call(L, lua_gettop(L) - 1, LUA_MULTRET);
1192 return lua_gettop(L);
1203 const char * m = luaL_checkstring(L, 1);
1205 return luaL_argerror(L, 1,
"found a null string argument to wesnoth require");
1210 lua_getglobal(L,
"wesnoth");
1211 lua_pushstring(L,
"package");
1213 lua_pushvalue(L, 1);
1219 lua_pushvalue(L, 1);
1227 DBG_LUA <<
"require: loaded a file, now calling it";
1235 lua_pushvalue(L, 1);
1236 lua_pushvalue(L, -2);
1240 lua_settable(L, -4);
1250 lua_createtable(L,
palette.size(), 1);
1251 lua_rotate(L, -2, 1);
1252 lua_setfield(L, -2,
"name");
1256 lua_rawseti(L, -2, 1);
1258 lua_rawseti(L, -2, 2);
1260 lua_rawseti(L, -2, 3);
1262 lua_rawseti(L, -2, 4);
1263 lua_rawseti(L, -2,
i);
1268 char const *m = luaL_checkstring(L, 2);
1269 lua_pushvalue(L, 2);
1282 #define GAME_CONFIG_SIMPLE_GETTER(name) \
1283 GAME_CONFIG_GETTER(#name, decltype(game_config::name), lua_kernel_base) { \
1285 return game_config::name; \
1305 if(luaL_newmetatable(L,
"color palettes")) {
1307 lua_setfield(L, -2,
"__index");
1309 lua_setmetatable(L, -2);
1315 lua_pushstring(L,
"red_green_scale");
1322 lua_pushstring(L,
"red_green_scale_text");
1329 lua_pushstring(L,
"blue_white_scale");
1336 lua_pushstring(L,
"blue_white_scale_text");
1378 lua_pushcfunction(L, luaopen_package);
1379 lua_pushstring(L,
"package");
1389 lua_pushstring(L,
"lua/core");
1391 cmd_log_ <<
"Error: Failed to load core.\n";
1401 std::vector<std::string> ret;
1405 int idx = lua_gettop(L);
1406 lua_getglobal(L,
"_G");
1409 while (lua_next(L, idx+1) != 0) {
1410 if (lua_isstring(L, -2)) {
1411 ret.push_back(lua_tostring(L,-2));
1424 std::vector<std::string> ret;
1425 std::string base_path = input;
1426 std::size_t last_dot = base_path.find_last_of(
'.');
1427 std::string partial_name = base_path.substr(last_dot + 1);
1428 base_path.erase(last_dot);
1429 std::string
load =
"return " + base_path;
1432 int save_stack = lua_gettop(L);
1433 int result = luaL_loadstring(L,
load.c_str());
1434 if(result != LUA_OK) {
1436 LOG_LUA <<
"Error when attempting tab completion:";
1437 LOG_LUA << luaL_checkstring(L, -1);
1439 lua_settop(L, save_stack);
1444 if(lua_istable(L, -1) || lua_isuserdata(L, -1)) {
1445 int top = lua_gettop(L);
1446 int obj = lua_absindex(L, -1);
1447 if(luaL_getmetafield(L, obj,
"__tab_enum") == LUA_TFUNCTION) {
1448 lua_pushvalue(L, obj);
1449 lua_pushlstring(L, partial_name.c_str(), partial_name.size());
1451 ret = lua_check<std::vector<std::string>>(L, -1);
1452 }
else if(lua_type(L, -1) != LUA_TTABLE) {
1453 LOG_LUA <<
"Userdata missing __tab_enum meta-function for tab completion";
1454 lua_settop(L, save_stack);
1459 for(lua_pushnil(L); lua_next(L, obj); lua_pop(L, 1)) {
1460 if(lua_type(L, -2) == LUA_TSTRING) {
1461 std::string attr = lua_tostring(L, -2);
1465 if(!isalpha(attr[0]) && attr[0] !=
'_') {
1468 if(std::any_of(attr.begin(), attr.end(), [](
char c){
1469 return !isalpha(c) && !isdigit(c) && c !=
'_';
1473 if(attr.substr(0, partial_name.size()) == partial_name) {
1474 ret.push_back(base_path +
"." + attr);
1480 lua_settop(L, save_stack);
1487 #pragma GCC diagnostic push
1488 #pragma GCC diagnostic ignored "-Wold-style-cast"
1492 #pragma GCC diagnostic pop
std::vector< std::string > names
A config object defines a single node in a WML file, with access to child nodes.
optional_config_impl< config > optional_child(config_key_type key, int n=0)
Equivalent to mandatory_child, but returns an empty optional if the nth child was not found.
static void rethrow()
Rethrows the stored exception.
void load_core()
Loads the "core" library into the Lua environment.
void run(char const *prog, const std::string &name, int nArgs=0)
Runs a plain script.
virtual void log_error(char const *msg, char const *context="Lua error")
Error reporting mechanisms, used by virtual methods protected_call and load_string.
int intf_dofile(lua_State *L)
Loads and executes a Lua file.
int impl_game_config_get(lua_State *L)
Gets some game_config data (__index metamethod).
int intf_require(lua_State *L)
Loads and executes a Lua file, if there is no corresponding entry in wesnoth.package.
void throwing_run(char const *prog, const std::string &name, int nArgs, bool in_interpreter=false)
Runs a plain script, but reports errors by throwing lua_error.
int intf_kernel_type(lua_State *L)
int impl_game_config_set(lua_State *L)
Sets some game_config data (__newindex metamethod).
void load_package()
Loads the package library into lua environment.
bool protected_call(int nArgs, int nRets, error_handler)
void add_log_to_console(const std::string &msg)
int impl_game_config_dir(lua_State *L)
Gets a list of game_config data (__dir metamethod).
int intf_show_lua_console(lua_State *L)
bool load_string(char const *prog, const std::string &name, error_handler)
std::vector< std::tuple< std::string, std::string > > registered_widget_definitions_
static lua_kernel_base *& get_lua_kernel_base_ptr(lua_State *L)
std::vector< std::string > get_global_var_names()
Get tab completion strings.
std::function< void(char const *, char const *)> error_handler
void run_lua_tag(const config &cfg)
Runs a [lua] tag.
virtual ~lua_kernel_base()
int intf_print(lua_State *L)
Replacement print function – instead of printing to std::cout, print to the command log.
void interactive_run(char const *prog)
Tests if a program resolves to an expression, and pretty prints it if it is, otherwise it runs it nor...
std::vector< std::string > get_attribute_names(const std::string &var_path)
Gets all attribute names of an extended variable name.
virtual uint32_t get_random_seed()
virtual void throw_exception(char const *msg, char const *context="Lua error")
virtual std::string my_name()
User-visible name of the lua kernel that they are talking to.
const char * what() const noexcept
std::string generate(const std::map< std::string, std::string > &variables) const
virtual ~name_generator()
void read(const std::string &shroud_data)
void set_enabled(bool enabled)
bool value(int x, int y) const
std::string write() const
const std::string & str() const
Represents version numbers.
std::string str() const
Serializes the version number into string form.
unsigned int revision_level() const
Retrieves the revision level (x3 in "x1.x2.x3").
char special_version_separator() const
Retrieves the special version separator (e.g.
const std::string & special_version() const
Retrieves the special version suffix (e.g.
unsigned int minor_version() const
Retrieves the minor version number (x2 in "x1.x2.x3").
unsigned int major_version() const
Retrieves the major version number (x1 in "x1.x2.x3").
const std::vector< unsigned int > & components() const
Read-only access to all numeric components.
bool is_canonical() const
Whether the version number is considered canonical for mainline Wesnoth.
std::vector< color_t > palette(const color_range &cr)
Creates a reference color palette from a color range.
std::string deprecated_message(const std::string &elem_name, DEP_LEVEL level, const version_info &version, const std::string &detail)
DEP_LEVEL
See https://wiki.wesnoth.org/CompatibilityStandards for more info.
int(* lua_CFunction)(lua_State *L)
bool do_version_check(const version_info &a, VERSION_COMP_OP op, const version_info &b)
Interfaces for manipulating version numbers of engine, add-ons, etc.
const language_def & get_language()
Standard logging facilities (interface).
#define LOG_STREAM(level, domain)
void luaW_pushconfig(lua_State *L, const config &cfg)
Converts a config object to a Lua table pushed at the top of the stack.
int luaW_pcall_internal(lua_State *L, int nArgs, int nRets)
void push_error_handler(lua_State *L)
void luaW_push_namedtuple(lua_State *L, const std::vector< std::string > &names)
Push an empty "named tuple" onto the stack.
std::set< map_location > luaW_check_locationset(lua_State *L, int idx)
Converts a table of integer pairs to a set of map location objects.
bool luaW_toboolean(lua_State *L, int n)
int luaW_type_error(lua_State *L, int narg, const char *tname)
bool luaW_pcall(lua_State *L, int nArgs, int nRets, bool allow_wml_error)
Calls a Lua function stored below its nArgs arguments at the top of the stack.
int luaW_push_locationset(lua_State *L, const std::set< map_location > &locs)
Converts a set of map locations to a Lua table pushed at the top of the stack.
bool luaW_getglobal(lua_State *L, const std::vector< std::string > &path)
Pushes the value found by following the variadic names (char *), if the value is not nil.
t_string luaW_checktstring(lua_State *L, int index)
Converts a scalar to a translatable string.
#define return_string_attrib(name, accessor)
#define return_int_attrib(name, accessor)
#define return_bool_attrib(name, accessor)
static int intf_make_shroud_bitmap(lua_State *L)
static int impl_version_finalize(lua_State *L)
Destroy a version.
int dispatch(lua_State *L)
static int intf_name_generator(lua_State *L)
static lg::log_domain log_user("scripting/lua/user")
static int intf_current_version(lua_State *L)
Returns the current Wesnoth version.
static lg::log_domain log_scripting_lua("scripting/lua")
static int intf_parse_shroud_bitmap(lua_State *L)
static int intf_make_version(lua_State *L)
Builds a version from its component parts, or parses it from a string.
static int impl_version_dir(lua_State *L)
static int impl_version_get(lua_State *L)
Decomposes a version into its component parts.
static int impl_get_dir_suffix(lua_State *L)
static int impl_version_tostring(lua_State *L)
Convert a version to string form.
luaW_Registry & gameConfigReg()
static int intf_deprecated_message(lua_State *L)
Logs a deprecation message.
static int intf_pcall(lua_State *L)
Wrapper for pcall and xpcall functions to rethrow jailbreak exceptions.
static int intf_named_tuple(lua_State *L)
Converts a Lua array to a named tuple.
static void impl_warn(void *p, const char *msg, int tocont)
int(lua_kernel_base::* member_callback)(lua_State *L)
static const char * Version
static int intf_log(lua_State *L)
Logs a message Arg 1: (optional) Logger Arg 2: Message.
static int impl_palette_get(lua_State *L)
static int impl_is_deprecated(lua_State *L)
static const char * Interp
std::vector< std::string > luaW_get_attributes(lua_State *L, int idx)
This function does the actual work of grabbing all the attribute names.
static void push_color_palette(lua_State *L, const std::vector< color_t > &palette)
static int intf_load(lua_State *L)
Replacement load function.
static int intf_ms_since_init(lua_State *L)
Returns the time stamp, exactly as [set_variable] time=stamp does.
static int intf_get_language(lua_State *L)
static int impl_name_generator_call(lua_State *L)
static void dir_meta_helper(lua_State *L, std::vector< std::string > &keys)
static int intf_object_dir(lua_State *L)
Prints out a list of keys available in an object.
#define GAME_CONFIG_SIMPLE_GETTER(name)
static int impl_name_generator_collect(lua_State *L)
static int impl_version_compare(lua_State *L)
Compares two versions.
#define GAME_CONFIG_GETTER(name, type, kernel_type)
void line(int from_x, int from_y, int to_x, int to_y)
Draw a line.
std::vector< color_t > red_green_scale_text
const version_info wesnoth_version(VERSION)
const std::vector< color_t > & tc_info(std::string_view name)
std::vector< color_t > blue_white_scale
std::vector< color_t > red_green_scale
std::vector< color_t > blue_white_scale_text
std::vector< game_tip > load(const config &cfg)
Loads the tips from a config.
void remove_single_widget_definition(const std::string &widget_type, const std::string &definition_id)
Removes a widget definition from the default GUI.
std::string register_metatables(lua_State *L)
int intf_textdomain(lua_State *L)
Creates an interface for gettext.
std::string register_gettext_metatable(lua_State *L)
Adds the gettext metatable.
std::string register_tstring_metatable(lua_State *L)
Adds the tstring metatable.
void register_metatable(lua_State *L)
int luaW_open(lua_State *L)
int load_file(lua_State *L)
Loads a Lua file and pushes the contents on the stack.
int luaW_open(lua_State *L)
int show_lua_console(lua_State *, lua_kernel_base *lk)
int intf_get_relative_dir(lua_State *L)
Expose map_location get_relative_dir.
int intf_vector_negation(lua_State *L)
Expose map_location::vector_negation to lua.
int intf_distance_between(lua_State *L)
Expose map_location distance_between.
int intf_get_in_cubic(lua_State *L)
Expose map_location to_cubic.
int intf_tiles_adjacent(lua_State *L)
Expose map_location tiles_adjacent.
int intf_vector_diff(lua_State *L)
Expose map_location::vector_difference to lua.
int intf_get_from_cubic(lua_State *L)
Expose map_location from_cubic.
int intf_vector_sum(lua_State *L)
Expose map_location::vector_sum to lua.
int intf_get_tile_ring(lua_State *L)
Expose map_location get_tile_ring.
int intf_rotate_right_around_center(lua_State *L)
Expose map_location::rotate_right_around_center to lua.
int intf_get_tiles_in_radius(lua_State *L)
Expose map_location get_tiles_in_radius.
int intf_get_adjacent_tiles(lua_State *L)
Expose map_location get_adjacent_tiles.
int intf_get_direction(lua_State *L)
Expose map_location::get_direction function to lua Arg 1: a location Arg 2: a direction Arg 3: (optio...
int luaW_open(lua_State *L)
void load_tables(lua_State *L)
Creates the metatable for RNG objects, and adds the Rng table which contains the constructor.
int luaW_open(lua_State *L)
int luaW_open(lua_State *L)
rng * generator
This generator is automatically synced during synced context.
std::vector< std::string > parenthetical_split(std::string_view val, const char separator, std::string_view left, std::string_view right, const int flags)
Splits a string based either on a separator, except then the text appears within specified parenthesi...
std::vector< std::string > split(const config_attribute_value &val)
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
void lua_push(lua_State *L, const T &val)
static std::string flush(std::ostringstream &s)
#define ON_SCOPE_EXIT(...)
Run some arbitrary code (a lambda) when the current scope exits The lambda body follows this header,...
Error used to report an error in a lua script or in the lua interpreter.
Holds a lookup table for members of one type of object.
int dir(lua_State *L)
Implement __dir metamethod.
int set(lua_State *L)
Implement __newindex metamethod.
int get(lua_State *L)
Implement __index metamethod.
external_log_type external_log_
static map_location::DIRECTION n