std::cout << s << "\n";
}
+luabridge::LuaRef::Proxy&
+luabridge::LuaRef::Proxy::clone_instance (const void* classkey, void* p) {
+ lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_tableRef);
+ lua_rawgeti (m_L, LUA_REGISTRYINDEX, m_keyRef);
+
+ luabridge::UserdataPtr::push_raw (m_L, p, classkey);
+
+ lua_rawset (m_L, -3);
+ lua_pop (m_L, 1);
+ return *this;
+}
+
+
class A {
public:
- A() { printf ("CTOR\n"); _int = 4; for (int i = 0; i < 256; ++i) {arr[i] = i; ar2[i] = i/256.0; ar3[i] = i;} }
+ A() { printf ("CTOR %p\n", this); _int = 4; for (int i = 0; i < 256; ++i) {arr[i] = i; ar2[i] = i/256.0; ar3[i] = i;} }
~A() { printf ("DTOR\n"); }
void set_int (int a) { _int = a; }
std::list<std::string>& get_list () { return _sl; }
uint32_t minone() { return -1; }
+ void pointer (float*f) const { printf ("PTR %p", f); }
enum EN {
RV1 = 1, RV2, RV3
int ar3[256];
};
-int main (int argc, char **argv)
+
+class LuaTableRef {
+ public:
+ LuaTableRef () {}
+ ~LuaTableRef () {}
+
+ int get (lua_State* L) {
+ luabridge::LuaRef rv (luabridge::newTable (L));
+ for (std::vector<LuaTableEntry>::const_iterator i = _data.begin (); i != _data.end (); ++i) {
+ switch ((*i).keytype) {
+ case LUA_TSTRING:
+ assign(&rv, i->k_s, *i);
+ break;
+ case LUA_TNUMBER:
+ assign(&rv, i->k_n, *i);
+ break;
+ }
+ }
+ luabridge::push (L, rv);
+ return 1;
+ }
+
+ int set (lua_State* L) {
+ if (!lua_istable (L, -1)) { return luaL_error (L, "argument is not a table"); }
+ _data.clear ();
+
+ lua_pushvalue (L, -1);
+ lua_pushnil (L);
+ while (lua_next (L, -2)) {
+ lua_pushvalue (L, -2);
+
+ LuaTableEntry s (lua_type(L, -1), lua_type(L, -2));
+ switch (lua_type(L, -1)) {
+ case LUA_TSTRING:
+ s.k_s = luabridge::Stack<std::string>::get (L, -1);
+ break;
+ ;
+ case LUA_TNUMBER:
+ s.k_n = luabridge::Stack<unsigned int>::get (L, -1);
+ break;
+ default:
+ // invalid key
+ lua_pop (L, 2);
+ continue;
+ }
+
+ switch(lua_type(L, -2)) {
+ case LUA_TSTRING:
+ s.s = luabridge::Stack<std::string>::get (L, -2);
+ break;
+ case LUA_TBOOLEAN:
+ s.b = lua_toboolean (L, -2);
+ break;
+ case LUA_TNUMBER:
+ s.n = lua_tonumber (L, -2);
+ break;
+ case LUA_TUSERDATA:
+ {
+ bool ok = false;
+ lua_getmetatable (L, -2);
+ lua_rawgetp (L, -1, luabridge::getIdentityKey ());
+ if (lua_isboolean (L, -1)) {
+ lua_pop (L, 1);
+ const void* key = lua_topointer (L, -1);
+ lua_pop (L, 1);
+ void const* classkey = findclasskey (L, key);
+
+ if (classkey) {
+ ok = true;
+ s.c = classkey;
+ s.p = luabridge::Userdata::get_ptr (L, -2);
+ }
+ } else {
+ lua_pop (L, 2);
+ }
+
+ if (ok) {
+ break;
+ }
+ // invalid userdata -- fall through
+ }
+ // no break
+ case LUA_TFUNCTION: // no support -- we could... string.format("%q", string.dump(value, true))
+ case LUA_TTABLE: // no nested tables, sorry.
+ case LUA_TNIL: // fallthrough
+ default:
+ // invalid value
+ lua_pop (L, 2);
+ continue;
+ }
+
+ _data.push_back(s);
+ lua_pop (L, 2);
+ }
+ return 0;
+ }
+
+ static void* findclasskey (lua_State *L, const void* key)
+ {
+ lua_pushvalue(L, LUA_REGISTRYINDEX);
+ lua_pushnil (L);
+ while (lua_next (L, -2)) {
+ lua_pushvalue (L, -2);
+ if (lua_topointer(L, -2) == key) {
+ void* rv = lua_touserdata (L, -1);
+ lua_pop (L, 4);
+ return rv;
+ }
+ lua_pop (L, 2);
+ }
+ lua_pop (L, 1);
+ return NULL;
+ }
+
+ private:
+ struct LuaTableEntry {
+ LuaTableEntry (int kt, int vt)
+ : keytype (kt)
+ , valuetype (vt)
+ { }
+
+ int keytype;
+ std::string k_s;
+ unsigned int k_n;
+
+ int valuetype;
+ // LUA_TUSERDATA
+ const void* c;
+ void* p;
+ // LUA_TBOOLEAN
+ bool b;
+ // LUA_TSTRING:
+ std::string s;
+ // LUA_TNUMBER:
+ double n;
+ };
+
+ template<typename T>
+ static void assign (luabridge::LuaRef* rv, T key, const LuaTableEntry& s)
+ {
+ switch (s.valuetype) {
+ case LUA_TSTRING:
+ (*rv)[key] = s.s;
+ break;
+ case LUA_TBOOLEAN:
+ (*rv)[key] = s.b;
+ break;
+ case LUA_TNUMBER:
+ (*rv)[key] = s.n;
+ break;
+ case LUA_TUSERDATA:
+ (*rv)[key].clone_instance (s.c, s.p);
+ break;
+ default:
+ assert (0);
+ break;
+ }
+ }
+
+ std::vector<LuaTableEntry> _data;
+};
+
+
+#if 0
+static void* findclasskey (lua_State *L, const void* key)
+{
+ lua_pushvalue(L, LUA_REGISTRYINDEX);
+ lua_pushnil (L);
+ while (lua_next (L, -2)) {
+ lua_pushvalue (L, -2);
+ if (lua_topointer(L, -2) == key) {
+ void* rv = lua_touserdata (L, -1);
+ lua_pop (L, 4);
+ return rv;
+ }
+ lua_pop (L, 2);
+ }
+ lua_pop (L, 1);
+ return NULL;
+}
+
+static int tableSerialize (lua_State *L)
+{
+ if (!lua_istable (L, -1)) { return luaL_error (L, "argument is not a table"); }
+
+ luabridge::LuaRef rv (luabridge::newTable (L));
+ std::cout << "CLASS A KEY: " << luabridge::ClassInfo <A>::getClassKey () << "\n";
+ lua_rawgetp (L, LUA_REGISTRYINDEX, luabridge::ClassInfo <A>::getClassKey ());
+ std::cout << " CLASS A TABLE PTR=" << lua_topointer (L, -1) << "\n";
+ lua_pop (L, 1);
+ // for k,v in pairs (debug.getregistry ()) do print (k,v) end
+
+ lua_pushvalue (L, -1);
+ lua_pushnil (L);
+ while (lua_next (L, -2)) {
+ lua_pushvalue (L, -2);
+ unsigned int const i = luabridge::Stack<unsigned int>::get (L, -1);
+ int t = lua_type(L, -2);
+ switch(t) {
+ case LUA_TSTRING:
+ std::cout << " " << i << ": '" << lua_tostring(L, -2) << "'\n";
+ rv[i] = lua_tostring(L, -2);
+ break;
+ case LUA_TBOOLEAN:
+ std::cout << " " << i << ": " <<
+ (lua_toboolean(L, -2) ? "true" : "false") << "\n";
+ rv[i] = lua_toboolean(L, -2);
+ break;
+ case LUA_TNUMBER:
+ std::cout << " " << i << ": " << lua_tonumber(L, -2) << "\n";
+ rv[i] = lua_tonumber(L, -2);
+ break;
+ case LUA_TUSERDATA:
+ {
+ lua_getmetatable (L, -2);
+ lua_rawgetp (L, -1, luabridge::getIdentityKey ());
+ if (lua_isboolean (L, -1)) {
+ lua_pop (L, 1);
+ const void* key = lua_topointer (L, -1);
+ lua_pop (L, 1);
+ void const* classkey = findclasskey (L, key);
+
+ if (classkey) {
+ void* p = luabridge::Userdata::get_ptr (L, -2);
+ rv[i].clone_instance (classkey, p);
+ }
+ } else {
+ lua_pop (L, 2);
+ }
+ }
+ break;
+ case LUA_TNIL:
+ case LUA_TTABLE:
+ case LUA_TFUNCTION:
+ case LUA_TLIGHTUSERDATA:
+ default:
+ std::cout << " " << i << ": TYPE=" << t << ": " << lua_topointer(L, -2)<< "\n";
+ break;
+ }
+ lua_pop (L, 2);
+ }
+ lua_pop (L, 1);
+ lua_pop (L, 2);
+
+ luabridge::push (L, rv);
+ return 1;
+}
+#endif
+
+LuaTableRef globalref;
+
+int runone (LuaState& lua)
{
#if 0
- LuaState lua;
-#else
+ LuaState lua (*new LuaState);
+#elif 0
PBD::ReallocPool _mempool ("Devel", 1048576);
LuaState lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool));
#endif
luabridge::getGlobalNamespace (L)
.beginNamespace ("Test")
.beginClass <A> ("A")
+ .addFunction ("pointer", &A::pointer)
.addFunction ("minone", &A::minone)
.addConst ("cologne", 4711)
.endClass ()
.addConst ("koln", 4711)
.endNamespace ();
#endif
+ luabridge::getGlobalNamespace (L)
+ .beginNamespace ("Dump")
+
+ .beginClass <LuaTableRef> ("TableRef")
+ .addCFunction ("get", &LuaTableRef::get)
+ .addCFunction ("set", &LuaTableRef::set)
+ .endClass ()
+
+ //.addCFunction ("dump", tableSerialize)
+ .endNamespace ();
+
+ luabridge::push <LuaTableRef *> (L, &globalref);
+ lua_setglobal (L, "ref");
+
+
#if 0 // session script test
lua.do_command (
"function ArdourSession ()"
add_history("a = Test:A() b = 2 c = 3 d = 'a'");
add_history("x = a:get_arg(b) y = a:get_arg2(b, c) z = a:get_args(d) ");
add_history("for i,n in ipairs(y) do print (i, n); end");
+ add_history("t = {} t[2] = 7; t[3] = Test:A() t[4] = Test:A() ref:set (t); f = ref:get()");
/////////////////////////////////////////////////////////////////////////////
char *line;
printf("\n");
return 0;
}
+
+int main (int argc, char **argv)
+{
+ LuaState lua1;
+ LuaState lua2;
+ runone (lua1);
+ printf ("=====\n");
+ runone (lua2);
+}
projects / ardour.git / commitdiff