From d83be1baa3041975a1b0458a5b6b9a3b1178ab84 Mon Sep 17 00:00:00 2001 From: Robin Gareus Date: Thu, 7 Jul 2016 15:33:45 +0200 Subject: backup lua-test/devel util code --- tools/luadevel/devel.cc | 299 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 295 insertions(+), 4 deletions(-) (limited to 'tools') diff --git a/tools/luadevel/devel.cc b/tools/luadevel/devel.cc index 3caa0513f3..9bbe313810 100644 --- a/tools/luadevel/devel.cc +++ b/tools/luadevel/devel.cc @@ -19,10 +19,23 @@ static void my_lua_print (std::string s) { 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; } @@ -42,6 +55,7 @@ class A { std::list& get_list () { return _sl; } uint32_t minone() { return -1; } + void pointer (float*f) const { printf ("PTR %p", f); } enum EN { RV1 = 1, RV2, RV3 @@ -59,11 +73,262 @@ class A { 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::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::get (L, -1); + break; + ; + case LUA_TNUMBER: + s.k_n = luabridge::Stack::get (L, -1); + break; + default: + // invalid key + lua_pop (L, 2); + continue; + } + + switch(lua_type(L, -2)) { + case LUA_TSTRING: + s.s = luabridge::Stack::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 + 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 _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 ::getClassKey () << "\n"; + lua_rawgetp (L, LUA_REGISTRYINDEX, luabridge::ClassInfo ::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::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 @@ -122,12 +387,28 @@ int main (int argc, char **argv) luabridge::getGlobalNamespace (L) .beginNamespace ("Test") .beginClass ("A") + .addFunction ("pointer", &A::pointer) .addFunction ("minone", &A::minone) .addConst ("cologne", 4711) .endClass () .addConst ("koln", 4711) .endNamespace (); #endif + luabridge::getGlobalNamespace (L) + .beginNamespace ("Dump") + + .beginClass ("TableRef") + .addCFunction ("get", &LuaTableRef::get) + .addCFunction ("set", &LuaTableRef::set) + .endClass () + + //.addCFunction ("dump", tableSerialize) + .endNamespace (); + + luabridge::push (L, &globalref); + lua_setglobal (L, "ref"); + + #if 0 // session script test lua.do_command ( "function ArdourSession ()" @@ -274,6 +555,7 @@ int main (int argc, char **argv) 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; @@ -294,3 +576,12 @@ int main (int argc, char **argv) printf("\n"); return 0; } + +int main (int argc, char **argv) +{ + LuaState lua1; + LuaState lua2; + runone (lua1); + printf ("=====\n"); + runone (lua2); +} -- cgit v1.2.3