Re: test

[Mike Ferenduros <mike@...>]

Hello,

I had the same problem, and solved it thusly (although I'm also fairly 
new to Lua so there's probably a better way).

Each Lua-visible object has a pointer to a linked-list of Lua references 
to it. So each userdata  contains not just a pointer to the object, but 
also prev and next pointers linking it into that object's list of userdatas.
When the userdata gets garbage-collected, you unlink it from the list, 
and when the C object is deleted, you walk through its list of userdatas 
and NULL out the object pointer inside each one.
So now when a script passes a stale userdata into a C function, you can 
easily detect it because the userdata's enemy pointer will be NULL.

Something like this should work:

typedef struct enemy_ref_s
{
   struct userdata_s *prev;
   struct userdata_s *next;
   class Enemy *enemy;
}
enemy_ref_t;

class Enemy
{
public:
   enemy_ref_t *m_refs;

   Enemy( void )
   {
      //Initially has no userdatas pointing to it
      m_refs = 0;
   }

   ~Enemy( void )
   {
      //Invalidate all userdatas pointing to this enemy
      for( enemy_ref_t *ref=m_refs; ref; ref=ref->next )
         ref->enemy =  0;
   }
};

void new_enemy_ud( lua_State *l, Enemy *enemy )
{
   //Creates a new Enemy userdata on the stack
   enemy_ref_t *ref = (enemy_ref_t *)lua_newuserdata( l, 
sizeof(enemy_ref_t) );

   luaL_getmetatable( l, "Enemy" );      //this metatable's __gc should 
point to 'enemy_ud_gc'
   lua_setmetatable( l, -2 );

   //Add this ud to the list of refs to this enemy
   ref->enemy = enemy;
   ref->prev = 0;
   ref->next = enemy->m_refs;
   if( ref->next )      ref->next->prev = ref;
   enemy->m_refs = ref;
}

int enemy_ud_gc( lua_State *l )
{
   //Remove from list of userdatas pointing to this enemy
   struct userdata_s *ref = (enemy_ref_t *)luaL_checkudata( l, 1, 
"Enemy" );
   if( ref->prev )      ref->prev->next = ref->next;
   if( ref->next )      ref->next->prev = ref->prev;
   if( ref->enemy && ud==ud->enemy->m_refs )
      ref->enemy->m_refs = ref->next;
   return( 0 );
}

This code assumes you've set up a metatable called "Enemy", and it's 
__gc points to 'enemy_ud_gc'.
It's a bit long-winded, but it works ok (and should be a lot faster than 
scanning all Luas globals).
It might be nicer if each enemy could only have a single userdata 
pointing to it, and you always returned the existing reference to a 
given enemy instead of creating new ones. However, as a relative newbie 
I'm not sure how easy that is to do.

Anyway, hope this helps (or makes sense at least).

Perhaps this is something to address on lua-users.org?



Jens Hassler wrote:

> Hi there,
>
> I am using Lua a lot in my game with great success. I exposed my game  
> API via toLua to my scripts. But now I have a "typical" C/pointer  
> problem:
>
> In my script I do something like that:
>
> my_enemy = enemy_class:create_enemy()
>
> This returns a userdata (?) pointing to the enemy object which was  
> created by the C++ function create_enemy.
>
> Now this enemy is destroyed and deleted inside the C++ code and  
> "my_enemy" is pointing to neverland (and causing a crash when accessed).
>
> So, is there an "elegant" way to set such rogue userdata objects to nil?
>
> Actually I work around this problem with calling a "enemy_dead()" LUA  
> function from C code when an enemy object is about to be destroyed. In  
> this function I'm looping through my globals and set the ones pointing  
> to the enemy to nil.
>
> It'd be perfect If I could reset these variables directly from my C++  
> code so that all Lua userdata objects will point to nil when the enemy  
> is destroyed.
>
> Thanks for your help.
> Jens
>
>
>