Changeset 341

Timestamp:

09/25/14 00:16:14 (11 years ago)

Author:

epyon

Message:

• lua_state - lua component support
• lua_state - call function from lua::ref
• lua_state - minor enhancements

Location:

trunk

Files:

• nv/lua/lua_state.hh (modified) (4 diffs)
• src/lua/lua_state.cc (modified) (1 diff)

trunk/nv/lua/lua_state.hh

@@ -18 +18 @@
 #include <map>
 
+#include <nv/lua/lua_handle.hh>
 #include <nv/lua/lua_path.hh>
 #include <nv/lua/lua_values.hh>
@@ -24 +25 @@
 
 #ifdef NV_DEBUG
-#define NV_LUA_STACK_ASSERT( state, value ) nv::lua::stack_assert __lua_stack_assert( state, value );
+#define NV_LUA_STACK_ASSERT( state, value ) nv::lua::stack_assert __lua_stack_assert( (state), (value) );
 #else
-#define NV_LUA_STACK_ASSERT( state, value )
+#define NV_LUA_STACK_ASSERT( (state), (value) )
 #endif
 
@@ -248 +249 @@
 
                         void register_enum( const char* name, int value );
+                        void register_singleton( const char* name, void* o );
 
                         void register_native_object_method( const char* lua_name, const char* name, lfunction f );
@@ -256 +258 @@
                         }
                         operator lua_State*() { return m_state; }
+
+                        template < typename H >
+                        void register_handle( const H& handle )
+                        {
+                                nv::lua::register_handle( m_state, handle, true );
+                        }
+                        template < typename H >
+                        void unregister_handle( const H& handle )
+                        {
+                                nv::lua::unregister_handle( m_state, handle );
+                        }
+                        template < typename H >
+                        ref register_handle_component( const H& handle, const std::string& id )
+                        {
+                                nv::lua::push_handle( m_state, handle );
+                                return register_handle_component_impl( id, true );
+                        }
+                        template < typename H >
+                        ref register_handle_component( const H& handle, const std::string& id, const path& proto )
+                        {
+                                if ( !proto.resolve( m_state, true ) )
+                                {
+                                        return ref();
+                                }
+                                nv::lua::push_handle( m_state, handle );
+                                return register_handle_component_impl( id, false );
+                        }
+                        template < typename H >
+                        void unregister_handle_component( const H& handle, const std::string& id )
+                        {
+                                nv::lua::push_handle( m_state, handle );
+                                unregister_handle_component_impl( id );
+                        }
+
+                        template < typename R >
+                        R call( ref table, const path& p )
+                        {
+                                stack_guard guard( this ); // TODO: remove
+                                detail::push_ref_object( m_state,table );
+                                if ( push_function( p, false ) )
+                                {
+                                        if ( call_function( 0, detail::return_count< R >::value ) == 0 )
+                                        {
+                                                return detail::pop_return_value<R>( m_state );
+                                        }
+                                }
+                                return R();
+                        }
+                        template < typename R, typename T1 >
+                        R call( ref table, const path& p, const T1& p1 )
+                        {
+                                stack_guard guard( this ); // TODO: remove
+                                detail::push_ref_object( m_state,table );
+                                if ( push_function( p, false ) )
+                                {
+                                        detail::push_value( m_state, p1 );
+                                        if ( call_function( 1, detail::return_count< R >::value ) == 0 )
+                                        {
+                                                return detail::pop_return_value<R>( m_state );
+                                        }
+                                }
+                                return R();
+                        }
+                        template < typename R, typename T1, typename T2 >
+                        R call( ref table, const path& p, const T1& p1, const T2& p2 )
+                        {
+                                stack_guard guard( this ); // TODO: remove
+                                detail::push_ref_object( m_state, table );
+                                if ( push_function( p, false ) )
+                                {
+                                        detail::push_values( m_state, p1, p2 );
+                                        if ( call_function( 2, detail::return_count< R >::value ) == 0 )
+                                        {
+                                                return detail::pop_return_value<R>( m_state );
+                                        }
+                                }
+                                return R();
+                        }
+                        template < typename R, typename T1, typename T2, typename T3 >
+                        R call( ref table, const path& p, const T1& p1, const T2& p2, const T3& p3 )
+                        {
+                                stack_guard guard( this ); // TODO: remove
+                                detail::push_ref_object( m_state, table );
+                                if ( push_function( p, false ) )
+                                {
+                                        detail::push_values( m_state, p1, p2, p3 );
+                                        if ( call_function( 3, detail::return_count< R >::value ) == 0 )
+                                        {
+                                                return detail::pop_return_value<R>( m_state );
+                                        }
+                                }
+                                return R();
+                        }
+                        template < typename R, typename T1, typename T2, typename T3, typename T4 >
+                        R call( ref table, const path& p, const T1& p1, const T2& p2, const T3& p3, const T4& p4 )
+                        {
+                                stack_guard guard( this ); // TODO: remove
+                                detail::push_ref_object( m_state, table );
+                                if ( push_function( p, false ) )
+                                {
+                                        detail::push_value( m_state, p1, p2, p3, p4 );
+                                        if ( call_function( 4, detail::return_count< R >::value ) == 0 )
+                                        {
+                                                return detail::pop_return_value<R>( m_state );
+                                        }
+                                }
+                                return R();
+                        }
+
                 private:
+                        ref register_handle_component_impl( const std::string& id, bool empty );
+                        void unregister_handle_component_impl( const std::string& id );
+
                         int load_string( const std::string& code, const std::string& name );
                         int load_stream( std::istream& stream, const std::string& name );

trunk/src/lua/lua_state.cc

@@ -515 +515 @@
 }
 
+nv::lua::ref nv::lua::state::register_handle_component_impl( const std::string& id, bool empty )
+{
+        int args = empty ? 1 : 2;
+        NV_LUA_STACK_ASSERT( m_state, -args );
+
+        if ( lua_isnil( m_state, -1 ) || (!empty && lua_isnil( m_state, -2 )) )
+        {
+                lua_pop( m_state, args );
+                return ref();
+        }
+        if (empty)
+                lua_createtable( m_state, 0, 0 );
+        else
+                nlua_deepcopy( m_state, -2 );
+        lua_pushstring( m_state, id.c_str() );
+        lua_pushvalue( m_state, -2 );
+        lua_rawset( m_state, -4 );
+        lua_replace( m_state, -2 );
+        ref result = lua::ref( luaL_ref( m_state, LUA_REGISTRYINDEX ) );
+        if (!empty) lua_pop( m_state, 1 );
+        return result;
+}
+
+void nv::lua::state::unregister_handle_component_impl( const std::string& id )
+{
+        NV_LUA_STACK_ASSERT( m_state, -1 );
+
+        if ( lua_isnil( m_state, -1 ) )
+        {
+                lua_pop( m_state, 1 );
+                return;
+        }
+        lua_pushstring( m_state, id.c_str() );
+        lua_pushnil( m_state );
+        lua_rawset( m_state, -3 );
+        lua_pop( m_state, 1 );
+}
+
+void nv::lua::state::register_singleton( const char* name, void* o )
+{
+        if ( o == nullptr ) return;
+        stack_guard guard( this );
+        lua_getglobal( m_state, name );
+        if ( lua_isnil( m_state, -1 ) )
+        {
+                NV_THROW( runtime_error, std::string( name ) + " type not registered!" );
+        }
+        deep_pointer_copy( -1, o );
+        lua_setglobal( m_state, name );
+}
+