I"m using LUA to extend a game engine. It's generally working OK (could wish for static type checking though...), but I've run into something I can't work out, and searching the list archives hasn't turned up an answer for any search I've tried so far.
The behavior I'm after seems like it should be very simple, maybe the most common thing to want, but I can't find a combination of metatable/setfenv behaviors to do it. I have a bunch of C++ internal game objects. Each of these C++ objects has a Lua table associated with it which defines a desired Lua global environment. All I want is to call a Lua fn from C++, and have this environment table be used for the Lua fn I call, and anything that *it* calls, recursively for the entire call stack. In other words, I
want my environment to be inherited.
I started out by trying to use setfenv on the Lua fn from C++ before I call it, pointing to my environment. For example, let's call this lua function LuaTest. I quickly discovered that the setfenv is not inherited through the call stack! I had to call setfenv in *every* Lua function called in the entire tree that LuaTest might call, which worked, but was not practical at all.
My second atttempt, and the one I have limping along now, was to define a metatable with __index and __newindex entries pointing to my desired environment for LuaTest, and setting this as the metatable for the module that contains LuaTest (*). This *almost* works. Every Lua fn called by LuaTest sees my environment table exactly as I wish but *only* within the module defining LuaTest. Once any function is called outside that module, my environment is
lost, replaced with the one defined by the setfenv of the called Lua function.
That's where I'm at now: I have the behavior I want but only within a single module. What I really wish is something that seems so very simple: I want the environment i set to be inherited by anything called by LuaTest. But I can't seem to get that behavior! I've tried some of the "pseudo-index" things too, but whatever I try, it seems some "function environment" always clobbers the real environment I'm trying to have inherited down through the Lua call stack.
Is there a nice simple way to do this?
For a while I was just setting a global "E" with my desired environment, and everybody had to say "E.myvar ...". That also works, even across modules, but it's a pain, and fragile: if anyone forgets to say "E.myvar", even just once, there's a bug. With the
metatable approach, at least I *know* variables are going into the environment I want them to.
Thanks!
(*) Actually I'm not using the Lua module system, but my own, but that's not related to my query above: I see the same troubles when using Lua's module system. Mine provides more private module behavior than the Lua module system, so you can say:
local my_module = Game.require('some/file.lua')
Your handle to it is private, and you can say my_module.some_function(). But I want some_function() to see the same Lua environment that its caller does!
