Simulated Non Local In Strings

wiki

Simulating non-local variables in compiled files or strings

By default the files or strings previously compiled by using loadfile and loadstring, respectively, and executed afterwards directly or by using pcall, work in the global environment. Their effects in the caller are only possible through the global table _G and the corresponding return var_list. In the following we work with the string case.

Therefore, the local and non-local variables of the caller function or chunk are not inherited by the string. Besides, non-local variables do not exist for the string (and we cannot use the string as a closure).

However we could wish to use and/or modify some non-local variable inside the string. The only way of doing it is through the design of a function that prepares a new environment with a table (now a global one inside the string) as a proxy with the required non-local variables. These must be used inside the string as if they were global, but with some prefix. We chose _U. Inside the function defined as a string they will be the fields of a global table _U. We also need some functions of the debug library (this is a necessary drawback) with the aim of modify the upvalues in the return.

Therefore, the use of non-local variables is simulated, but it works.

We need a function, callstring, with arguments:

proc, the compiled result of loadstring or loadfile.

_U, a table with the desired non-local variables; if nil then {} is supposed.

func, the caller to callstring; this is needed only if the invocation of callstring is in a tail return; otherwise it can be nil.

finally the arguments that will be passed to proc.

The return of callstring is a status with nil in case of error or true if all is correct, and the return of proc.

Let put a simple example:

s = [[ _U.c = 11; _U.d = 22; return ... ]]
proc = loadstring(s)

local c = 1

function example (proc)
   local d = 2
   local result = {callstring(proc, {c = c, d = d}}, nil, "a", "b")}}
   print(d)       -- possibly modified inside proc
   return result  -- a table with the status and the results of proc
end

example(proc)
print(c)          -- possibly modified inside proc

In this, c is a non-local variable in example because it is used inside example (if not Lua 'forgot' it for the moment). On the other hand, d is a local variable in example. Both behave like upvalues inside proc: they can be accessed and modified with the names _U.c and _U.d. Even more, the modified values are transferred to example.

The key is that the table _U will have two fields _U.c and _U.d, initialised with the values of c and d, respectively. Besides, by using c and d in the invocation of callstring we assure that both variables work like upvalues inside proc.

Other fields passed in _U to callstring are treated as local variables inside proc. In the calling:

callstring(proc, {c = c, d = d, x = "xx"}}, nil, "a", "b")

x is not an upvalue, because it does not exist in some place in the caller closure. In this case _U.x takes the value "xx" in the string, and it behaves like a local variable inside the string.

It is time to present callstring.

-- Calling a function obtained from a string or file
-- with simulated upvalues
--
-- Arguments:
-- proc    loaded string or file
-- _U      is a new local and non-local table;
--         if it is nil then we suppose it {}}
-- func    is the function from we invoked 'callstring';
--         can be nil if the invocation is not a tail return
-- ...     the arguments to string calling

function callstring (proc, _U, func, ...)

   _U = _U or {}}
   if type(_U) ~= "table" then
      return nil, "Second argument of callstring must be a table or nil"
   end

   -- determine the calling function
   func = func or debug.getinfo(2, "f").func

   -- count _U fields
   local nt = 0
   for _, _ in pairs(_U) do nt = nt+1 end

   if func == nil and nt ~= 0 then
      return nil, "Callstring invoked in a tail call cannot evaluate string"
   end

   -- both _G and _U are passed as global in the new environment
   -- the direct indexing of _G is permitted for accessing (not modifying)

   local newgt = {_U = _U}}
   setmetatable(newgt, {__index = _G}})
   setfenv(proc, newgt)

   -- proc is executed with arguments
   local result = {proc(...)}}

   -- when _U is {}} (no upvalues) the return is always possible 
   -- (even in a tail call)
   if nt == 0 then return true, unpack(result) end

   -- modify local and non-local variables of the calling routine
   -- (adapted from PIL2 chapter 23)
   for n, v in pairs(_U) do
      local found = false
      -- non-local variable
      for i = 1, math.huge do
         local m, _ = debug.getupvalue(func, i)
         if not m then break end
         if m == n then
            found = true
            debug.setupvalue(func, i, v)
            break
         end
      end
      if not found then
         -- local variable
         local ipos
         for i = 1, math.huge do
            local m, _ = debug.getlocal(2, i)
            if not m then break end
            if m == n then ipos = i end
            -- the last found is the correct
         end
         if ipos then debug.setlocal(2, ipos, v) end
      end
   end

   return true, unpack(result)
end

A more elaborate example of calling could be:

local c = 1
local h = 2
g = 3   -- global

local s = [[
     local f = 99           -- local inside the string
     _U.c = 11              -- non-local of something
     _U.h = 22              -- internal (not passed in table)
     _U.z = 4               -- internal (not passed in table)
     _U.d = 77              -- local of something
     _G.zzz = table.concat({...}}, "+") -- global of new creation
     print("_U.x = ", _U.x) -- internal (because in table does not
                            -- correspond to any local/non-local)
     _G.g = 33              -- previously existent global
     _G.v = f               -- global of new creation
     return 10*g, 10*v      -- return
]]

-- loading the string
local proc, msg = loadstring(s)

function something (proc)
   local d = 3

   if proc == nil then error(msg) end

   local r = {callstring(proc, {c = c, d = d, x = "xx"}}, nil, "a", "b")}}

   -- printing a local modified inside the string as an upvalue
   print("d = ", d)

   return unpack(r)
end

local r = {something(proc)}}

if not r[1] then
   print("error in callstring: " .. r[2])
else
   k1 = r[2]
   k2 = r[3]
end

print(c, h, g, v, z)
print(k1, k2)
print(zzz)

The output of this program is:

_U.x =          xx                  --< internal variable in the string
d =     77                          --< local variable in something
11      2       33      99      nil --< local, local, global, global, global
330     990                         --< return of string
a+b                                 --< global zzz modified inside the string

As a conclusion, it will be good if Lua executed compiled strings and files as other 'normal' function. But, for the moment we have to 'circumvent' Lua with some constructions like the one presented.

-- JulioFernandez

Simulated Non Local In Strings

Simulating non-local variables in compiled files or strings

See Also