Getting Variables From Values

wiki

If we have a value, can we obtain its variable? For example, can a function return the names of the variables passed to it?

f(x,y) --> 'x', 'y'

Or can Lua support "pass-by-reference" (or maybe even "pass-by-name") calling semantics?

local a = 10; local b = 11
print(a,b) --> 10,11
swap(a,b)
print(a,b) --> 11,10

The answer is not normally. However, with some byte code inspection (using the lbci library [1]) and Lua debug library hackery, it may be possible...

Note first the bytecode in a typical function call:

$ echo -e 'local x = {2,3};\n local y = 4;\n f(x,y,z)' | luac -p -l -
main <stdin:0,0> (11 instructions, 44 bytes at 0x6d0ea8)
0+ params, 6 slots, 0 upvalues, 2 locals, 5 constants, 0 functions
        1       [1]     NEWTABLE        0 2 0
        2       [1]     LOADK           1 -1    ; 2
        3       [1]     LOADK           2 -2    ; 3
        4       [1]     SETLIST         0 2 1   ; 1
        5       [2]     LOADK           1 -3    ; 4
        6       [3]     GETGLOBAL       2 -4    ; f
        7       [3]     MOVE            3 0
        8       [3]     MOVE            4 1
        9       [3]     GETGLOBAL       5 -5    ; z
        10      [3]     CALL            2 4 1
        11      [3]     RETURN          0 1

The instructions prior to the CALL move the variables into place. Here's how we might make use of that:

-- D.Manura, 2009-10. Public domain.

require "bci"

-- Returns list of variables passed to function at given
-- stack level number `level`.  `level` defaults to 1, the calling
-- function, if omitted. If confused, returns nothing.
-- See code for format of variables.
-- WARNING: This code is experimental.  Not intended for production use.
local mt
local function getargvariables(level)
  mt = mt or {__tostring = function(t)
    local s = '{'
    for i=1,#t do
      s = s .. (i==1 and '' or ',') .. tostring(t[i])
    end
    s = s .. '}'
    return s
  end}

  -- Get function info.
  level = (level or 1) + 2
  local f = debug.getinfo(level,'f').func
  if not f then return end -- could be a tail call
  local currentline = debug.getinfo(level,'l').currentline
  local F = inspector.getheader(f)

  -- Get instruction pointer of call.
  -- Unfortunately, we only have the line number from which to infer the
  -- instruction pointer.  So, we can only do this unambiguously when the
  -- call is the only call on its line.  Perhaps bci or debug.getinfo
  -- could be patched to return the exact instruction pointer.
  local count = 0
  local currentip
  for i=1,F.instructions do
    local line, opcode, a, b, c = inspector.getinstruction(f,i)
    if line == currentline and opcode == "CALL" then
      currentip = i
      count = count + 1
    end
  end
  if count ~= 1 then return end -- ambiguous, return nothing

  -- Get CALL opcode data
  local _,_,idxfunc,nparamsp,_ = inspector.getinstruction(f,currentip)

  -- Get arguments.
  local names = {}
  for i=1,nparamsp-1 do
    local _,opcode,a,b,c = inspector.getinstruction(f,currentip-i)
    if opcode == 'MOVE' and a == idxfunc + nparamsp - i then -- local
      local varname,_,_ = inspector.getlocal(f,b+1)
      names[nparamsp - i] = setmetatable({'local', varname, b+1}, mt)
    elseif opcode == 'GETGLOBAL' and b < 0 then -- global
      local varname = inspector.getconstant(f,-b)
      names[nparamsp - i] = setmetatable({'global', varname}, mt)
    else
      return -- other possibilities not currently implemented
    end
  end
  return unpack(names, 1, nparamsp-1)
end

-- Set variable `var` (as returned by `getargvariables`) in context of
-- stack level number `level` to value `value`.
local function setvariable(level, var, value)
  level = (level or 1) + 1
  if var[1] == 'local' then
    local varname, idx = var[2], var[3]
    debug.setlocal(level, idx, value)
  elseif var[1] == 'global' then
    local varname = var[2]
    getfenv(2)[varname] = value
  else
    assert(false)
  end
end

-- TESTS

local function f(a,b)
  print(getargvariables()) --> {local,y,5} {local,z,6} {global,w}
end

do
  local y=1
  local z=2
  f(y,z,w)
end

local function swap(x,y)
  local xvar, yvar = getargvariables()
  assert(xvar and yvar)
  setvariable(2, xvar, y)
  setvariable(2, yvar, x)
end

a = 10
local b = 11
print(a,b) --> 10,11
swap(a,b)
print(a,b) --> 11,10

print 'DONE'

As is, the above is not intended for production use. The above could be generalized further. Please do so if you are so inclined.

--DavidManura

Getting Variables From Values

See Also