Module:Lua call

 require[[strict]]
 localp={}

 functionp.main(frame)
 localparent=frame.getParent(frame)or{}
 localexplist={}
 localfnname,varlist
 localvars={}
 fork,vinpairs(_G)do
 vars[k]=v-- transfer every global directly to our variable table
 end
 fork,vinpairs(parent.argsor{})do
 vars[k]=tonumber(v)orv-- transfer every parameter directly to our variable table
 end
 fork,vinpairs(frame.argsor{})do
 vars[k]=tonumber(v)orv-- transfer every parameter directly to our variable table
 end
 --- Alas Scribunto does NOT implement coroutines, according to
 --- https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#string.format
 --- this will not stop us from trying to implement one single lousy function call
 ifvars[1]then
 fnname,varlist=mw.ustring.match(vars[1],"^%s*(%a[^%s%(]*)%(([^%)]*)%)%s*$")
 end
 ifvarlistthen
 localexpn=0
 repeat
 expn=expn+1
 explist[expn]=vars[mw.ustring.match(varlist,"([^%,]+)")]
 varlist=mw.ustring.match(varlist,"[^%,]+,(.*)$")
 untilnotvarlist
 end
 localscopetab=vars
 whilemw.ustring.match(fnname,"%.")do
 localscopekey
 scopekey,fnname=mw.ustring.match(fnname,"^(%a[^%.]*)%.(.*)$")
 scopetab=scopetab[scopekey]
 end
 localfn=scopetab[fnname]
 iftype(fn)~="function"then--XXX: What about callable tables?
 returntostring(fn)
 else
 localoutput={fn(unpack(explist))}
 returnoutput[vars.reserved_returnor1]
 end
 end

 localfunctiontonumberOrString(v)
 returntonumber(v)orv:gsub("^\\","",1)
 end

 localfunctioncallWithTonumberOrStringOnPairs(f,...)
 localargs={}
 for_,vin...do
 table.insert(args,tonumberOrString(v))
 end
 return(f(unpack(args)))
 end

 --[[
 ------------------------------------------------------------------------------------
 -- ipairsAtOffset

 -- This is an iterator for arrays. It can be used like ipairs, but with
 -- specified i as first index to iterate. i is an offset from 1
 --
 ------------------------------------------------------------------------------------
 --]]
 localfunctionipairsAtOffset(t,i)
 localf,s,i0=ipairs(t)
 returnf,s,i0+i
 end

 localfunctionget(s)
 localG=_G;for_inmw.text.gsplit(
 mw.text.trim(s,'%s'),'%s*%.%s*'
 )do
 G=G[_]
 end
 returnG
 end

 --[[
 ------------------------------------------------------------------------------------
 -- call
 --
 -- This function is usually useful for debugging template parameters.
 -- Prefix parameter with backslash (\) to force interpreting parameter as string.
 -- The leading backslash will be removed before passed to Lua function.
 --
 -- Example:
 -- {{#invoke:Lua call|call|mw.log|a|1|2|3}} will return results of mw.log('a', 1, 2, 3)
 -- {{#invoke:Lua call|call|mw.logObject|\a|321|321円| 321円 }} will return results of mw.logObject('a', 321, '321', ' \321円 ')
 --
 -- This example show the debugging to see which Unicode characters are allowed in template parameters,
 -- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0061}}}} return 97
 -- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0000}}}} return 65533
 -- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0001}}}} return 65533
 -- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0002}}}}}} return 0xfffd
 -- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x007e}}}}}} return 0x007e
 -- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x007f}}}}}} return 0x007f
 -- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0080}}}}}} return 0x0080
 -- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x00a0}}}}}} return 0x00a0
 --
 ------------------------------------------------------------------------------------
 --]]
 functionp.call(frame)
 returncallWithTonumberOrStringOnPairs(get(frame.args[1]),
 ipairsAtOffset(frame.args,1)
 )
 end

 --local TableTools = require('Module:TableTools')
 --[[
 ------------------------------------------------------------------------------------
 -- get
 --
 -- Example:
 -- {{#invoke:Lua call|get| math.pi }} will return value of math.pi
 -- {{#invoke:Lua call|get|math|pi}} will return value of math.pi
 -- {{#invoke:Lua call|get| math |pi}} will return value of _G[' math '].pi
 -- {{#invoke:Lua call|get|_G| math.pi }} will return value of _G[' math.pi ']
 -- {{#invoke:Lua call|get|obj.a.5.c}} will return value of obj.a['5'].c
 -- {{#invoke:Lua call|get|obj|a|5|c}} will return value of obj.a[5].c
 --
 ------------------------------------------------------------------------------------
 --]]
 functionp.get(frame)
 -- #frame.args always return 0, regardless of number of unnamed
 -- template parameters, so check manually instead
 ifframe.args[2]==nilthen
 -- not do tonumber() for this args style,
 -- always treat it as string,
 -- so 'obj.1' will mean obj['1'] rather obj[1]
 returnget(frame.args[1])
 else
 localG=_G
 for_,vinipairs(frame.args)do
 G=G[tonumberOrString(v)]
 end
 returnG
 end
 end

 --[[
 ------------------------------------------------------------------------------------
 -- invoke
 --
 -- This function is used by Template:Invoke
 --
 ------------------------------------------------------------------------------------
 --]]
 functionp.invoke(frame)
 localpframe,usedpargs=frame:getParent(),{}
 -- get module and function names from parent args if not provided
 localpfargs=setmetatable({frame.args[1],frame.args[2]},{__index=table})
 ifnotpfargs[1]then
 pfargs[1],usedpargs[1]=pframe.args[1],true
 ifnotpfargs[2]then
 pfargs[2],usedpargs[2]=pframe.args[2],true
 end
 elseifnotpfargs[2]then
 pfargs[2],usedpargs[1]=pframe.args[1],true
 end
 -- repack sequential args
 fori,vinipairs(pframe.args)do
 ifnotusedpargs[i]then
 pfargs:insert(v)
 usedpargs[i]=true
 end
 end
 -- copy other args
 fork,vinpairs(pframe.args)do
 ifnotpfargs[k]andnotusedpargs[k]then
 pfargs[k],usedpargs[k]=v,true
 end
 end
 -- #invoke off parent frame so the new frame has the same parent
 returnpframe:callParserFunction{name='#invoke',args=pfargs}
 end

 returnp