luabind/scope.hpp

   1 #ifndef LUABIND_SCOPE_HPP_INCLUDED
   2 #define LUABIND_SCOPE_HPP_INCLUDED
   3
   4 #include <vector>
   5 #include <string>
   6 #include <stack>
   7
   8 #include <luabind/detail/ref.hpp>
   9
  10 namespace luabind
  11 {
  12         namespace detail
  13         {
  14                 struct scoped_sequence;
  15
  16                 struct scoped_object
  17                 {
  18                         scoped_object()
  19                         {
  20                         }
  21
  22                         virtual ~scoped_object() {}
  23
  24                         virtual void commit(lua_State*) const = 0;
  25                         virtual scoped_object* clone() const = 0;
  26
  27                         scoped_sequence operator,(const scoped_object& rhs) const;
  28                 };
  29
  30                 struct scoped_sequence : scoped_object
  31                 {
  32                         scoped_sequence(scoped_object* a, scoped_object* b)
  33                         {
  34                                 this->objects.push_back(a);
  35                                 this->objects.push_back(b);
  36                         }
  37
  38                         scoped_sequence() {}
  39
  40                         virtual ~scoped_sequence()
  41                         {
  42                                         for (std::vector<scoped_object*>
  43                                                         ::const_iterator i = this->objects.begin()
  44                                                                                                 ; i != this->objects.end()
  45                                                                                                 ; ++i)
  46                                         {
  47                                                 scoped_object* ptr = *i;
  48                                                 delete ptr;
  49                                         }
  50                         }
  51
  52                         scoped_sequence& operator,(const scoped_object& rhs)
  53                         {
  54                                 objects.push_back(rhs.clone());
  55                                 return *this;
  56                         }
  57
  58                         virtual scoped_object* clone() const
  59                         {
  60                                 scoped_sequence* copy = new scoped_sequence();
  61                                 copy->objects.swap(this->objects);
  62                                 return copy;
  63                         }
  64
  65                         virtual void commit(lua_State* L) const
  66                         {
  67                                 for (std::vector<scoped_object*>
  68                                                         ::const_iterator i = this->objects.begin()
  69                                                                                                 ; i != this->objects.end()
  70                                                                                                 ; ++i)
  71                                 {
  72                                         scoped_object* ptr = *i;
  73                                         ptr->commit(L);
  74                                 }
  75                         }
  76
  77                         mutable std::vector<scoped_object*> objects;
  78                 };
  79
  80                 inline scoped_sequence scoped_object::operator,(const scoped_object& rhs) const
  81                 {
  82                         return scoped_sequence(this->clone(), rhs.clone());
  83                 }
  84         }
  85 /*
  86         def(..),
  87         def(..)
  88
  89         function_obj1, function_obj2
  90         function_obj1.push_back(function_obj2.doclone());
  91 */
  92         struct scope_stack
  93         {
  94                 std::stack<int> scopes;
  95
  96                 static int gc(lua_State* L)
  97                 {
  98                         scope_stack* scopes = static_cast<scope_stack*>(
  99                                 lua_touserdata(L, -1)
 100                         );
 101
 102                         assert(scopes->scopes.size() == 1);
 103
 104                         int top = scopes->scopes.top();
 105                         scopes->scopes.pop();
 106
 107                         detail::unref(L, top);
 108
 109                         scopes->~scope_stack();
 110
 111                         return 0;
 112                 }
 113
 114                 static int top(lua_State* L)
 115                 {
 116                         lua_pushstring(L, "__luabind_scope_stack");
 117                         lua_gettable(L, LUA_REGISTRYINDEX);
 118
 119                         scope_stack* scopes = static_cast<scope_stack*>(
 120                                 lua_touserdata(L, -1)
 121                         );
 122
 123                         lua_pop(L, 1);
 124
 125                         return scopes->scopes.top();
 126                 }
 127
 128                 static void push(lua_State* L)
 129                 {
 130                         lua_pushstring(L, "__luabind_scope_stack");
 131                         lua_gettable(L, LUA_REGISTRYINDEX);
 132
 133                         scope_stack* scopes = static_cast<scope_stack*>(
 134                                 lua_touserdata(L, -1)
 135                         );
 136
 137                         lua_pop(L, 1);
 138
 139                         return scopes->scopes.push(detail::ref(L));
 140                 }
 141
 142                 static void pop(lua_State* L)
 143                 {
 144                         lua_pushstring(L, "__luabind_scope_stack");
 145                         lua_gettable(L, LUA_REGISTRYINDEX);
 146
 147                         scope_stack* scopes = static_cast<scope_stack*>(
 148                                 lua_touserdata(L, -1)
 149                         );
 150
 151                         lua_pop(L, 1);
 152
 153                         int n = scopes->scopes.top();
 154                         scopes->scopes.pop();
 155                         detail::unref(L, n);
 156                 }
 157         };
 158
 159         class scope : public detail::scoped_object
 160         {
 161         public:
 162
 163                 static void init(lua_State* L)
 164                 {
 165                         lua_pushstring(L, "__luabind_scope_stack");
 166                         lua_gettable(L, LUA_REGISTRYINDEX);
 167
 168                         scope_stack* scopes = static_cast<scope_stack*>(
 169                                 lua_touserdata(L, -1)
 170                         );
 171
 172                         lua_pop(L, 1);
 173
 174                         if (scopes == 0)
 175                         {
 176                                 scopes = static_cast<scope_stack*>(
 177                                         lua_newuserdata(L, sizeof(scope_stack))
 178                                 );
 179
 180                                 lua_pushstring(L, "__luabind_scope_stack");
 181                                 lua_pushvalue(L, -2);
 182                                 lua_settable(L, LUA_REGISTRYINDEX);
 183
 184                                 new (scopes) scope_stack();
 185
 186                                 lua_pushvalue(L, LUA_GLOBALSINDEX);
 187                                 scopes->scopes.push(detail::ref(L));
 188
 189                                 lua_newtable(L);
 190                                 lua_pushstring(L, "__gc");
 191                                 lua_pushcclosure(L, scope_stack::gc, 0);
 192                                 lua_settable(L, -3);
 193                                 lua_setmetatable(L, -2);
 194
 195                                 lua_pop(L, 1);
 196                         }
 197                 }
 198
 199                 scope(lua_State* L, const char* name)
 200                         : m_state(L)
 201                         , m_name(name)
 202                 {
 203                         init(L);
 204                 }
 205
 206                 scope(const char* name)
 207                         : m_state(0)
 208                         , m_name(name)
 209                 {
 210                 }
 211
 212                 virtual ~scope()
 213                 {
 214                         for (std::vector<scoped_object*>
 215                                         ::const_iterator i = m_children.begin()
 216                                                                                 ; i != m_children.end()
 217                                                                                 ; ++i)
 218                         {
 219                                 scoped_object* ptr = *i;
 220                                 delete ptr;
 221                         }
 222                 }
 223
 224                 scope& operator[](const detail::scoped_object& x)
 225                 {
 226                         m_children.push_back(x.clone());
 227
 228                         if (m_state)
 229                         {
 230                                 this->commit(m_state);
 231
 232                                 for (std::vector<scoped_object*>
 233                                                 ::const_iterator i = m_children.begin()
 234                                                                                         ; i != m_children.end()
 235                                                                                         ; ++i)
 236                                 {
 237                                         scoped_object* ptr = *i;
 238                                         delete ptr;
 239                                 }
 240
 241                                 m_children.clear();
 242                         }
 243
 244                         return *this;
 245                 }
 246
 247                 virtual detail::scoped_object* clone() const
 248                 {
 249                         std::vector<detail::scoped_object*> tmp;
 250                         tmp.swap(this->m_children);
 251                         scope* copy = new scope(*this);
 252                         copy->m_children.swap(tmp);
 253                         return copy;
 254                 }
 255
 256                 virtual void commit(lua_State* L) const
 257                 {
 258                         init(L);
 259
 260                         detail::getref(L, scope_stack::top(L)); // get current scope
 261                         lua_pushstring(L, m_name.c_str());
 262                         lua_gettable(L, -2);
 263                         lua_remove(L, -2); // remove scope
 264
 265                         if (lua_isnil(L, -1))
 266                         {
 267                                 lua_pop(L, 1);
 268
 269                                 lua_newtable(L);
 270                                 detail::getref(L, scope_stack::top(L));
 271                                 lua_pushstring(L, m_name.c_str());
 272                                 lua_pushvalue(L, -3);
 273                                 lua_settable(L, -3);
 274                                 lua_pop(L, 1);
 275                         }
 276
 277                         scope_stack::push(L);
 278
 279                         for (std::vector<detail::scoped_object*>
 280                                                 ::const_iterator i = m_children.begin()
 281                                                                                         ; i != m_children.end()
 282                                                                                         ; ++i)
 283                         {
 284                                 scoped_object* ptr = *i;
 285                                 ptr->commit(L);
 286                         }
 287
 288                         scope_stack::pop(L);
 289                 }
 290
 291         private:
 292
 293                 mutable std::vector<scoped_object*> m_children;
 294                 lua_State* m_state;
 295                 std::string m_name;
 296         };
 297
 298         typedef scope namespace_;
 299 }
 300 /*
 301 scope dwarf("dwarf");
 302
 303 dwarf
 304 [
 305         def(..),
 306         def(..),
 307
 308         class<vec3>("vec3")
 309                 .def(constructor<float,float,float>())
 310                 .def(self + self)
 311                 .def(self - self)
 312                 .def(self == self)
 313                 ,
 314
 315         def("getDirection", &get_direction),
 316         def("getPosition", &get_position)
 317 ];
 318
 319 dwarf
 320 [
 321         def(..)
 322 ];
 323
 324 dwarf.commit(L);
 325
 326 */
 327 #endif
 328