Anonymissimus' lua thread

[silene]

-I see that many wml action functionalities are currently being exported from the C++ engine to the external lua files - just curious: why ? (it's not that I have an opinion about it...)

• It's a good way to check that the Lua engine is robust.
• It ensures that the Lua engine is not missing core functionalities.
• It's a good time for reviewing all the WML tags and extracting its basic functionalities. For instance, there are two tags [scroll_to] and [scroll_to_unit], but they are morally the same thing. (I'm not sure I'm making much sense there. Let's just say it's a way to straighten WML semantics as a whole.)
• It avoids the cost of converting objects forth and back between C++ and Lua.
• It simplifies the code considerably in some cases. I'm thinking about my getting rid of wesnoth.register_wml_action for instance.
• And probably lots of other good and bad reasons.

By the way, it's a good time to point things that are not currently possible in WML but that the engine already handles. For instance, I have on my TODO list a way for scripts to dynamically modify theme elements (e.g. status display). But there are probably other features people would like.

-You didn't yet disable the math.random() function (and add a replacement to helper), or is it wired to set_variable's implementation ?

I must admit I had forgotten about this one.

Ultimately, I want clients to communicate between them. (So it covers random, but also [message]). A Gsoc student is working on persistent variables, so I'm waiting to see how it evolves, since there is some overlap about these two functionalities.

Concerning the helper function, I will add it for 1.9 if I don't get to implement the mechanism above. I think there is already a version of it on the wiki.

-I suggest adding the get_locations functionality to helper which you've posted somewhen earlier in this thread

This one is on my TODO list, but as a core function. (So [store_locations] would rely on it, instead of the contrary.) Actually, earlier today on IRC, someone proposed to code it. So it may arrive sooner than I expected.

[Anonymissimus]

Could you describe the security aspect of :unsafe_lua better ?
Let's say I have some add-ons installed, one of them is from an author with criminal intention who wants to scan my pc an email my bank account data to him (would soon disappear from the server...) Doesn't the lua code that does this need to be called ? So if there are no dependencies other than to own add-ons and core files it should be save ? Since from the warning that pops up it looks like such malicious code could be executed immediately, even if the campaign isn't loaded at all.

[silene]

even if the campaign isn't loaded at all.

That's the main issue. You have no way to ensure that an addon didn't load something (except by opening its code and checking for yourself). Wesnoth doesn't enforce anything more than what authors make of #ifdef. (For instance, any multiplayer game is launched with the Legend of Wesmere Lua code running. That was quite a shock the first time I looked at such a MP savegame.) For instance, there may well be a moveto event lying around that constantly tests whether the engine has switched in unsafe mode.

Anyway, I'm not happy with the unsafe mode. I intend to replace it by an implementation of remdebug directly in the engine, so that Lua doesn't need more rights. But this is no small work and it will take a bit of time for me to finish it.

[Anonymissimus]

(For instance, any multiplayer game is launched with the Legend of Wesmere Lua code running. That was quite a shock the first time I looked at such a MP savegame.)

That's because it's also loaded from the MULTIPLAYER preprocessor scope in LoW's _main I'm guessing.

For instance, there may well be a moveto event lying around that constantly tests whether the engine has switched in unsafe mode.

Can it be activated from outside that add-ons's #ifdef ? So one is forced to have a separate BfW installation for installing add-ons where :unsafe_lua is never used.

[silene]

That's because it's also loaded from the MULTIPLAYER preprocessor scope in LoW's _main I'm guessing.

You are guessing right. My point was that, if the author didn't put #ifdef around its code, then it will get load, even if you are not interested in that particular addon. The engine doesn't try to enforce that there is nothing outside the #ifdef/#endif section of an addon. (Agreed, the MULTIPLAYER thing was a bad example, but hopefully it's clearer now.)

So one is forced to have a separate BfW installation for installing add-ons where :unsafe_lua is never used.

Yes, that's what I was trying to convey in the warning for :unsafe_lua. Before enabling it, you have to make sure you have removed all the addons you don't trust. For instance, you could use the --config-dir option to point Wesnoth to an alternate userdata directory that would contain your own addon only.

[Anonymissimus]

I've been working on a universal debug message function, intended to ease lua programming in a wesnoth environment. Functionality (partly aimed for):
-For the primitive types nil, boolean, number and string it outputs their types and values (maybe for string also the length); that's the easy part.
-For function it would be nice to get it's code displayed (possible ?) although the lua author may already have written that function onself so the code is there.
-For any table I want an output that can be just copied into the code to assign it to the variable and "produces itself again", the code from the tutorial

Spoiler:

Code: Select all

	local obj = {
		foo = 42,
		{ "bar", { v = 1, w = 2 } },
		{ "foo", { x = false } },
		{ "bar", { y = "foo" } },
		{ "foobar", { { "barfoo", {} } } },
		bar = 2
	}

currently procuces this output:

Spoiler:

Code: Select all

obj is of type table, value table: 07E3B6E0, length 4:

{
	{1 = bar, 
		{w = 2, v = 1}

	}, 
	{1 = foo, 
		{x = false}

	}, 
	{1 = bar, 
		{y = foo}

	}, 
	{1 = foobar, 
		{
			{1 = barfoo, 
				{}

			}
		}
	}, bar = 2, foo = 42
}

-For any userdata value (also if it appears not at the toplevel), it is attempted to dump it with __cfg and __literal, if one of them succeeds it's treated like a table above. If not, it calls tostring() for the userdata object (this still works for translatable strings then such as unit names).
-I want an option to limit the output if e.g. it is an array from get_units. Currently it's a number that limits both the absolute number of tables shown as well as the number of named fields per table.
code:

Spoiler:

Code: Select all

function debug_msg(lua_var, name, onscreen, max_items)
	local var_type = type(lua_var)
	local value = tostring(lua_var)
	if not name then name = "lua_var" end
	if onscreen == nil then onscreen = true end
	if not max_items then max_items = 14 end
	if max_items == "inf" then max_items = math.huge end

	local function message(msg)
		wesnoth.message(msg); print(msg)
		if onscreen then wesnoth.wml_actions.message({speaker = "narrator", message = msg}) end
	end

	local function dump_userdata(data)
		if type(data) ~= "userdata" then return data end

		local result
		local function try_dumping()
			result = data.__cfg or nil
			if not result then result = data.__literal end
			return result
		end
		if pcall(try_dumping) then return result else return tostring(data) end
	end

	local msg_string = "%s is of type %s, value %s"
	local msg
	lua_var = dump_userdata(lua_var)
	if type(lua_var) ~= "table" then
		msg = string.format(msg_string, name, var_type, value)
		message(msg)
		return
	else
		msg = string.format(msg_string .. ", length %u:", name, var_type, value, #lua_var)
		message(msg)
	end

	local tables = 1
	local function handle_table(lua_var, depth, indent)
		local last_field, last_value = nil, nil
		local result = string.format("\n%s{", indent)
		local is_deepest =  true
		local fields = 0

		local function handle_content(last_characters)
			if last_field then
				last_value = dump_userdata(last_value)
				var_type = type(last_value)
				if var_type ~= "table" then
					fields = fields + 1
					if fields <= max_items then
--~ 						if type(last_field) == "number" then

--~ 						else
							result = string.format("%s%s = %s%s", result, tostring(last_field), tostring(last_value), last_characters)
--~ 						end
					end
				else
					tables = tables + 1
					is_deepest = false
					if tables <= max_items then
						result = string.format("%s%s%s", result, handle_table(last_value, depth + 1, indent .. "\t"), last_characters)
					end
				end
			end
		end

		for current_field, current_value in pairs(lua_var) do
			handle_content(", ")
			last_field, last_value = current_field, current_value
		end
		handle_content("")

		if is_deepest then
			result = result .. "}\n"
		else
			result = string.format("%s\n%s}", result, indent)
		end

		return result
	end

	message(handle_table(lua_var, 0, ""))
end

EDIT
I know that melinath has something similar in the lua pack; that code looks easier, I think I'll continue by improving that...

[Anonymissimus]

Are the following conclusions about tables correct ? Let's stay in a wesnoth environment and there are only tables created with the intention to make them understandable by the engine.

- (When iterating over any table with pairs) Every field encountered (all fields) is either named (a string) or unnamed (can be written as [1] or [2] etc), so that tables have the structure (sort of regexp, * = variable, | = or)

Code: Select all

{(([1] = any lua type)|([string] = any lua type))*}

-These are equivalent:

Code: Select all

{[1] = { [1] = "bar", [2] = { v = 1, w = 2 } }}

Code: Select all

{{ "bar", { v = 1, w = 2 } }}

A table is not a wml table if
1. Any named field's value is not one of the types nil, boolean, string, number (scalars), or it is of type userdata which becomes a table when dumped with .__cfg or .__literal
2. Any unnamed field's value (at the same depth as 1.) is neither of type table nor userdata (try dumping, if still userdata => wml_table = false)
3. Any unnamed field's value does not consist of a pair/table of unnamed fields holding a string and a table as their values. (introduction of a subtag)
4. The subtable from 3. doesn't comply with rule 1 to 4.

I can produce syntactically correct output and I intend on adding the debug_msg function to helper.lua. Ideally, I want to check whether a table passed is a wml table, and if it isn't the output shall indicate why. This makes lua coding substantially easier.

[silene]

- (When iterating over any table with pairs) Every field encountered (all fields) is either named (a string) or unnamed (can be written as [1] or [2] etc), so that tables have the structure (sort of regexp, * = variable, | = or)

Code: Select all

{(([1] = any lua type)|([string] = any lua type))*}

Yes.

-These are equivalent:

Code: Select all

{[1] = { [1] = "bar", [2] = { v = 1, w = 2 } }}

Code: Select all

{{ "bar", { v = 1, w = 2 } }}

Yes. (And not just WML tables; Lua tables satisfy this property too.)

A table is not a wml table if
1. Any named field's value is not one of the types nil, boolean, string, number (scalars), or it is of type userdata which becomes a table when dumped with .__cfg or .__literal

Concerning userdata, the only possible ones have the metatable of translatable strings. The previous sentence may confuse you, so hopefully the following line will make it clearer:

Code: Select all

if type(value) == "userdata" and getmetatable(value) ~= "translatable string" then error "invalid userdata (not a translatable string)" end

2. Any unnamed field's value (at the same depth as 1.) is neither of type table nor userdata (try dumping, if still userdata => wml_table = false)

Again, a better test for these userdata is to check that they have a "wml object" metatable.

3. Any unnamed field's value does not consist of a pair/table of unnamed fields holding a string and a table as their values. (introduction of a subtag)
4. The subtable from 3. doesn't comply with rule 1 to 4.

Yes.

[Anonymissimus]

It catches many common mistakes, but the third condition is difficult (how can one compare the structure of a table to a regexp ?) The output works well in any case.
Are wml tables including translatable strings (other userdata ?) still considered wml tables ?
Is there a way to retrieve the named fields of a table (their values and/or only the names) without knowing these names and without pairs ?
If it's neccessary to do .__cfg or .__literal for any conained value it's no longer considered a wml table however.

Spoiler:

Code: Select all

obj is of type table, value table: 05B74F40, length 4, but no WML table: value at [4][2][1]: table expected, got string:
{
    [1] = {
                  [1] = "bar",
                  [2] = {
                                w = 2,
                                v = 1
                            }
              },
    [2] = {
                  [1] = "foo",
                  [2] = {
                                x = false
                            }
              },
    [3] = {
                  [1] = "bar",
                  [2] = {
                                y = "foo"
                            }
              },
    [4] = {
                  [1] = "foobar",
                  [2] = {
                                [1] = "barfoo",
                                [2] = {
                                          }
                            }
              },
    foo = 42
}

Spoiler:

Code: Select all

function db_msg(lua_var, name, onscreen)
	if type(name) ~= "string" then name = "lua_var" end
	if type(onscreen) ~= "boolean" then onscreen = true end

	local is_wml_table
	local function dump_userdata(data)
		local metatable = getmetatable(data)
		local invalidate_wml_table = is_wml_table == true
		if metatable == "unit" then return data.__cfg, invalidate_wml_table end
		if metatable == "wml object" then return data.__literal, invalidate_wml_table end
		local data_to_string = tostring(data)
		if metatable == "translatable string" then return data_to_string, false end
		return data_to_string, invalidate_wml_table
	end

	local result
	local wml_table_error
	local base_indent = "    "
	local function table_to_string(arg_table, indent, introduces_subtag, indices)
		local is_filled = false
		local index = 1
		for current_key, current_value in pairs(arg_table) do
			is_filled = true

			local function no_wml_table(element, index, expected, actual)
				wml_table_error = string.format("%s at %s%s: %s expected, got %s", element, indices, index, expected, actual)
				is_wml_table = false
			end

			local current_key_type = type(current_key)
			local current_key_to_string = tostring(current_key)
			local current_type = type(current_value)
			if current_type == "userdata" then
				local  invalidate_wml_table
				current_value, invalidate_wml_table = dump_userdata(current_value)
				if invalidate_wml_table
					then no_wml_table("value", string.format("[%s]", current_key_to_string), "nil, boolean, number, string or table", "userdata")
				end
				current_type = type(current_value)
			end

			if is_wml_table then
				if introduces_subtag then
--~ 					dbms(current_key)
--~ 					dbms(current_value)
					if index == 1 then
						if current_key ~= 1 then no_wml_table("key", "[1]", "[1] with value string of subtag name", string.format("%s with %s", current_key_type, current_type))
						elseif current_type ~= "string" then no_wml_table("value", "[1]", "string of subtag name", current_type) end
					elseif index == 2 then
						if current_key ~= 2 then no_wml_table("key", "[2]", "[2] with value table of subtag", string.format("%s with %s", current_key_type, current_type))
						elseif current_type ~= "table" then no_wml_table("value", "[2]", "table", current_type) end
					else
						no_wml_table("element", "[3]", "nil", current_type)
					end
					index = index + 1
				elseif current_key_type == "string" then
					if current_type == "table" or current_type == "function" or current_type == "thread" then
						no_wml_table("value", string.format("[%s]", current_key_to_string), "nil, boolean, number or string", current_type)
					end
				elseif current_type ~= "table" then no_wml_table("value", string.format("[%s]", current_key_to_string), "table", current_type) end
			end

			local length = 9
			local left_bracket, right_bracket = "[", "]"
			if current_key_type == "string" then
				left_bracket, right_bracket = "", ""; length = length - 2
			end
			if current_type == "table" then
				result = string.format("%s%s%s%s%s = {\n", result, indent, left_bracket, current_key_to_string, right_bracket)
				table_to_string(current_value, string.format("%s%s%s", base_indent, indent, string.rep(" ", string.len(current_key_to_string) + length)),
					not introduces_subtag, string.format("%s[%s]", indices, current_key_to_string))
				result = string.format("%s%s%s},\n", result, indent, string.rep(" ", string.len(current_key_to_string) + length))
			else
				local quote = ""; if current_type == "string" then quote = "\"" end
				result = string.format("%s%s%s%s%s = %s%s%s,\n", result, indent, left_bracket, current_key_to_string, right_bracket, quote, tostring(current_value), quote)
			end
		end
		if is_filled then result = string.sub(result, 1, string.len(result) - 2) .. "\n" end
	end

	local var_type, var_value = type(lua_var), tostring(lua_var)
	if var_type == "userdata" then lua_var = dump_userdata(lua_var) end
	local new_var_type = type(lua_var)

	local format_string = "%s is of type %s, value %s"
	local format_string_length = format_string .. ", length %u"
	local format_string_length_newline = format_string_length .. ":\n%s"

	if new_var_type == "table" then
		local var_length = #lua_var
		is_wml_table = var_type == "table"
		result = "{\n"
		table_to_string(lua_var, base_indent, false, "")
		result = result .. "}"

		if is_wml_table then
			result = string.format(format_string_length_newline, name, "WML table", var_value, var_length, result)
		elseif wml_table_error then
			result = string.format(format_string_length .. ", but no WML table: %s:\n%s", name, "table", var_value, var_length, wml_table_error, result)
		else
			result = string.format(format_string_length_newline, name, var_type, var_value, var_length, result)
		end
	elseif new_var_type == "string" then
		result = string.format(format_string_length, name, var_type, var_value, #lua_var)
	else
		result = string.format(format_string, name, var_type, var_value)
	end

	wesnoth.message(result); print(result)
	if onscreen then wesnoth.wml_actions.message({speaker = "narrator", message = result}) end
end

[silene]

It catches many common mistakes, but the third condition is difficult (how can one compare the structure of a table to a regexp ?)

You may try to check that "pairs" (or "next") doesn't return more than two elements. If there are only two and you know (because of your other checks) that [1] is a string and [2] is a WML table, you are done. The engine doesn't even try that far. It complains only when it doesn't understand what it sees. If the table wasn't a pair but still had correct [1] and [2] fields, the mistake would go unnoticed by the engine.

I haven't looked in-depth to your code, but you seem to have an issue there. "pairs" doesn't return elements in numerical order for hash tables. So, depending on the way the pair was created, you may get [2] before [1]. Your code works because the pair will happen to be a proper array most of the times. But if it isn't, it will break.

The behavior above may seem strange if you don't know how tables are stored internally, and I don't think it is explained in the official documentation. (I think there are only some cryptic comments about "array and nonarray elements".) So let me try to explain a bit more. A proper array is created when only numerical keys are added and they are added in increasing order starting from 1. It's a contiguous storage with a small memory footprint and instant access to elements. (It's the kind of arrays you find in most programming languages, but 1-based.) But if you start adding nonnumerical keys, or if you had them in a different order, Lua switches to a hash implementation. Even if there are only numerical keys in the end, the storage may still be a hash table. The keys are then iterated with respect to their hash buckets, and there is no reason for increasing keys to fall into increasing buckets.

That's not really important anyway. If you don't feel like fixing it, you can always assume that only perverted programmers will hit this corner case.

Are wml tables including translatable strings (other userdata ?) still considered wml tables ?

The answer seems obvious, so perhaps I didn't understand your question. Named fields containing translatable strings do not prevent a table to be a WML table, fortunately. (No other userdata are possible as named fields.)

Is there a way to retrieve the named fields of a table (their values and/or only the names) without knowing these names and without pairs ?

I only know of "pairs" and "next" for this purpose.

If it's neccessary to do .__cfg or .__literal for any conained value it's no longer considered a wml table however.

For __cfg, that's right. For __literal, not so. As their name implies, "wml object" userdata do represent WML objects, yet they provide a "__literal" field. (And they are the only userdata currently providing this field.) So the corresponding line of "dump_user_data" is not correct.

[Dixie]

Is there a way to retrieve the named fields of a table (their values and/or only the names) without knowing these names and without pairs ?

I only know of "pairs" and "next" for this purpose.

Well, I guess you could rewrite the next function or something. I stumbled upon that yesterday while searching infos and examples for the for iterator and pairs function. It was a bit advanced for me so I didn't get all of it, but maybe it can be of some use for you

That Lua-users wiki is a great mine of infos btw! Maybe it should be linked in our LuaWML wiki along with the Lua user manual?

[Anonymissimus]

Spoiler:

Code: Select all

function db_ms(lua_var, name, onscreen)
	if type(name) ~= "string" then name = "lua_var" end
	if type(onscreen) ~= "boolean" then onscreen = true end

	local function dump_userdata(data)
		local metatable = getmetatable(data)
		if metatable == "unit" then return data.__cfg, true end
		if metatable == "wml object" then return data.__literal, false end
		local data_to_string = tostring(data)
		if metatable == "translatable string" then return data_to_string, false end
		return data_to_string, true
	end

	local is_wml_table = true
	local result
	local wml_table_error
	local base_indent = "    "
	local function table_to_string(arg_table, indent, introduces_subtag, indices)
		local is_filled = false

		local function check_subtag()
			local one, two = arg_table[1], arg_table[2]
			if type(two) == "userdata" then
				local invalidate_wml_table
				two, invalidate_wml_table = dump_userdata(two)
				if invalidate_wml_table then return false end
			end
			if type(one) ~= "string" or type(two) ~= "table" then return false end
			return true
		end
		if is_wml_table and introduces_subtag then
			if not check_subtag() then
				wml_table_error = string.format("table introducing subtag at %s is not of the form {\"tag_name\", {}}", indices)
				is_wml_table = false
			end
		end

		local index = 1
		for current_key, current_value in pairs(arg_table) do
			is_filled = true

			local current_key_type = type(current_key)
			local current_key_to_string = tostring(current_key)
			local current_type = type(current_value)
			local function no_wml_table(expected, index, type)
				if not index then index = current_key_to_string end
				if not type then type = current_type end
				wml_table_error = string.format("value at %s[%s]: %s expected, got %s", indices, index, expected, type)
				is_wml_table = false
			end

			if current_type == "userdata" then
				local  invalidate_wml_table
				current_value, invalidate_wml_table = dump_userdata(current_value)
				current_type = type(current_value)
				if is_wml_table and invalidate_wml_table then
					wml_table_error = string.format("userdata at %s[%s]", indices, current_key_to_string)
					is_wml_table = false
				end
			end

			if is_wml_table and not introduces_subtag then
				if current_key_type == "string" and (current_type == "table" or current_type == "function" or current_type == "thread") then
					no_wml_table("nil, boolean, number or string")
				elseif current_key_type == "number" then
					if current_type ~= "table" then
						no_wml_table("table")
					elseif current_key ~= index then
						no_wml_table("value", tostring(index), "nil")
					end
					index = index + 1
				end
			end

			local length = 9
			local left_bracket, right_bracket = "[", "]"
			if current_key_type == "string" then
				left_bracket, right_bracket = "", ""; length = length - 2
			end
			if current_type == "table" then
				result = string.format("%s%s%s%s%s = {\n", result, indent, left_bracket, current_key_to_string, right_bracket)
				table_to_string(current_value, string.format("%s%s%s", base_indent, indent, string.rep(" ", string.len(current_key_to_string) + length)),
					not introduces_subtag, string.format("%s[%s]", indices, current_key_to_string))
				result = string.format("%s%s%s},\n", result, indent, string.rep(" ", string.len(current_key_to_string) + length))
			else
				local quote = ""; if current_type == "string" then quote = "\"" end
				result = string.format("%s%s%s%s%s = %s%s%s,\n", result, indent, left_bracket, current_key_to_string, right_bracket, quote, tostring(current_value), quote)
			end
		end
		if is_filled then result = string.sub(result, 1, string.len(result) - 2) .. "\n" end
	end

	local engine_is_wml_table = pcall(wesnoth.set_variable, "LUA_debug_msg", lua_var); wesnoth.set_variable("LUA_debug_msg")

	local var_type, var_value = type(lua_var), tostring(lua_var)
	is_wml_table = var_type == "table"
	local invalidate_wml_table
	if var_type == "userdata" then lua_var, invalidate_wml_table= dump_userdata(lua_var)
		is_wml_table = not invalidate_wml_table
	end
	local new_var_type = type(lua_var)

	local format_string = "%s is of type %s, value %s"
	local format_string_length = format_string .. ", length %u"
	local format_string_length_newline = format_string_length .. ":\n%s"

	if new_var_type == "table" then
		local var_length = #lua_var
		result = "{\n"
		table_to_string(lua_var, base_indent, false, "")
		result = result .. "}"

		if is_wml_table then
			result = string.format(format_string_length_newline, name, "WML table", var_value, var_length, result)
		elseif wml_table_error then
			result = string.format(format_string_length .. ", but no WML table: %s:\n%s", name, "table", var_value, var_length, wml_table_error, result)
		else
			result = string.format(format_string_length_newline, name, var_type, var_value, var_length, result)
		end
	elseif new_var_type == "string" then
		result = string.format(format_string_length, name, var_type, var_value, #lua_var)
	else
		result = string.format(format_string, name, var_type, var_value)
	end

	if is_wml_table ~= engine_is_wml_table  and (var_type == "table" or var_type == "userdata" or var_type == "function" or var_type == "thread") then
		result = string.format("warning: WML table inconsistently predicted, script says %s , engine %s \n%s", tostring(is_wml_table), tostring(engine_is_wml_table), result)
	end

	wesnoth.message(result); print(result)
	if onscreen then wesnoth.wml_actions.message({speaker = "narrator", message = result}) end
end

I think I'll rather leave it this way now. Error messages ar no longer that verbose but there seem to be no false positives, only some false negatives which don't hurt. (for tables introducing subtables, the {"tag", {}} structure is enforced)
Could the function that's called by :clear be made available to lua ? I don't suppose it would be problematic...
Btw the sript should work in 1.8 too, the last line with wesnoth.wml_actions must be wesnoth.fire(... then.

EDIT
Code updated, there are corner cases left that I fix one after another...

[Anonymissimus]

I hope I've included everything that's relevant.

Spoiler:

Code: Select all

#define LUA TABLE FUNCTION ARGS
	[lua]
		code = "{TABLE}.{FUNCTION}(...)"
		[args]
			{ARGS}
		[/args]
	[/lua]
#enddef

Code: Select all

	#ifdef DEBUG_MODE
	[event]
		name=prestart
...
		[set_menu_item]
			id=breakpoint
			# wmllint: local spelling [inspect]
			description=_"set an [inspect] tag"
			[command]
				[message]
					message=_"Before which action tag ? example: 'kill'"
					speaker=narrator
					image="wesnoth-icon.png"
					[text_input]
						variable=sActionTag
						text=_"kill"
					[/text_input]
				[/message]
				{LUA mydebug set_breakpoint (variable=$sActionTag)}
				{CLEAR_VARIABLE sActionTag}
			[/command]
		[/set_menu_item]
	[/event]
	#endif

Code: Select all

	function mydebug.set_breakpoint(wtArgs)
		wesnoth.message(type(wtArgs))
		local tag = wesnoth.tovconfig(wtArgs).variable
		local old_handler = wml_actions[tag]
		local function new_handler(cfg)
			wml_actions.inspect({})
			old_handler(cfg)
		end
		wml_actions[tag] = new_handler
	end

This outputs "table" for the parameter type, although the function is called by wml directly.

EDIT
For anyone interested in the answer and related discussion, read the irc log #wesnoth-dev from about date and time the posting was made.

[Anonymissimus]

I'd like to point out that lua can be used to perform wmllint-wmlscope-ish operations on wml or lua files. The script below can read macro definitions from a file and replaces all calls to these macros in another file while inserting arguments correctly. It's meant to be run independently from the wesnoth engine. It's far from being perfect and I have a hard time to get all possible cases working... The biggest problem is that "" and () can make macro arguments span over spaces. # characters anywhere in the macro definition or call break this currently and indentation gets completely messed up, but emacs can reindent whole files so it's not so important.

Spoiler:

Code: Select all

require("mydebug")
-----------------------------------------------------
--~ constants
local macro_filename = "dialogue"
macro_filename = macro_filename .. ".cfg"
local filename = "07_The_bridge_is_broken.cfg"
local overwrite = true

local new_filename = filename
if not overwrite then new_filename = string.format("new_%s", filename) end
-----------------------------------------------------
--~ open the files
local macro = io.open(macro_filename, "r")
local macro_string = macro:read("*a")
io.close(macro)

local file = io.open(filename, "r")
local file_string = file:read("*a")
io.close(file)

local new_file = io.open(new_filename, "w")
-----------------------------------------------------
--~ macro analysis
local macros = {}
for macro_definition in string.gmatch(macro_string, "#define[%p%w%s]-#enddef") do
	local macro_definition = string.sub(macro_definition, 9, string.len(macro_definition) - 7)

	local macro = {}
	local arguments = {}
	local newline_index = string.find(macro_definition, "\n")
	local next_name_or_argument = string.gmatch(string.sub(macro_definition, 1, newline_index - 1), "[^%s%\n]+")
	macro.name = next_name_or_argument()
	for argument in next_name_or_argument do
		table.insert(arguments, argument)
	end
	macro.content = string.sub(macro_definition, newline_index + 1, string.len(macro_definition) - 1)
	table.insert(macro, arguments)

	table.insert(macros, macro)
end
-----------------------------------------------------
--~ file analysis
for macro_call in string.gmatch(file_string, "{[^}]*") do
	macro_call = string.sub(macro_call, 2)

	local new_content
	local name_end = string.find(macro_call, "%s")
	local macro_name = macro_call
	local macro_arguments
	if name_end then
		macro_name = string.sub(macro_call, 1, name_end - 1)
		macro_arguments = string.sub(macro_call, name_end + 1)

		local function handle_delimited_arguments(argument)
			argument = "##" .. string.sub(argument, 2)
			argument = string.sub(argument, 1, string.len(argument) - 1) .. "##"
			argument = string.gsub(argument, "%s", "#")
			return argument
		end
		macro_arguments = string.gsub(macro_arguments, "\"[%w%p%s]+\"", handle_delimited_arguments)
		macro_arguments = string.gsub(macro_arguments, "%([%w%p%s]+%)", handle_delimited_arguments)
	end

	for macro_index, macro in ipairs(macros) do
		if macro.name == macro_name then
			 new_content = macro.content
			local current_argument = 1
			for argument in string.gmatch(macro_arguments, "[^%s\n]+") do
				new_content = string.gsub(new_content, string.format("{%s}", macro[1][current_argument]), argument)
				current_argument = current_argument + 1
			end
			break
		end
	end
	if new_content then
		new_content = string.gsub(new_content, "##", "\"")
		new_content = string.gsub(new_content, "#", " ")
		file_string = string.gsub(file_string, string.format("{%s[%%w%%p%%s]-}", macro_name), new_content, 1)
	end
end

new_file:write(file_string)
io.close(new_file)

[Anonymissimus]

a question for silene:
For C++ I've been told that in these code snippets it's better to use the first variant due to memory allocation (for the variable j, it needs some time to reserve the memory every time it is declared):
lua:

Code: Select all

		local j
		for i = 2, 5 do
			j = i
		end

		for i = 2, 5 do
			local j = i
		end

C++:

Code: Select all

	int j;
	for(int i = 2; i <= 5; ++i) {
		j = i;
	}

	for(int i = 2; i <= 5; ++i) {
		int j = i;
	}

(And let's say that we need "j" only within each step of that loop, so we declare it outside only because of efficiency.)
That is, declare variables outside of loops, only assign them within, and it's what I tend to do in all languages, but the core lua codings don't hesitate to declare variables locally within loops.