luabind/scope.hpp

   1 // Copyright (c) 2003 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23
  24 #ifndef LUABIND_SCOPE_HPP_INCLUDED
  25 #define LUABIND_SCOPE_HPP_INCLUDED
  26
  27 #include <vector>
  28 #include <string>
  29 #include <stack>
  30
  31 #include <luabind/detail/ref.hpp>
  32
  33 namespace luabind
  34 {
  35         namespace detail
  36         {
  37                 struct scoped_sequence;
  38
  39                 struct scoped_object
  40                 {
  41                         scoped_object() {}
  42                         virtual ~scoped_object() {}
  43
  44                         virtual void commit(lua_State*) = 0;
  45                         virtual scoped_object* clone() = 0;
  46
  47                         scoped_sequence operator,(const scoped_object& rhs) const;
  48                 };
  49
  50                 struct scoped_sequence : scoped_object
  51                 {
  52                         scoped_sequence(scoped_object* a, scoped_object* b)
  53                         {
  54 #ifndef NDEBUG
  55                                 m_cloned = false;
  56 #endif
  57                                 this->objects.push_back(a);
  58                                 this->objects.push_back(b);
  59                         }
  60
  61                         scoped_sequence()
  62                         {
  63 #ifndef NDEBUG
  64                                 m_cloned = false;
  65 #endif
  66                         }
  67
  68                         virtual ~scoped_sequence()
  69                         {
  70                                         for (std::vector<scoped_object*>
  71                                                         ::const_iterator i = this->objects.begin()
  72                                                                                                 ; i != this->objects.end()
  73                                                                                                 ; ++i)
  74                                         {
  75                                                 scoped_object* ptr = *i;
  76                                                 delete ptr;
  77                                         }
  78                         }
  79
  80                         scoped_sequence& operator,(const scoped_object& rhs)
  81                         {
  82                                 objects.push_back(const_cast<scoped_object&>(rhs).clone());
  83                                 return *this;
  84                         }
  85
  86                         virtual scoped_object* clone()
  87                         {
  88                                 scoped_sequence* copy = new scoped_sequence();
  89                                 copy->objects.swap(this->objects);
  90
  91                                 assert(!m_cloned && "You cannot register the scoped_object twice");
  92 #ifndef NDEBUG
  93                                 m_cloned = true;
  94 #endif
  95                                 return copy;
  96                         }
  97
  98                         virtual void commit(lua_State* L)
  99                         {
 100                                 assert(!m_cloned && "You cannot register the scoped_object twice");
 101
 102                                 for (std::vector<scoped_object*>
 103                                                         ::const_iterator i = this->objects.begin()
 104                                                                                                 ; i != this->objects.end()
 105                                                                                                 ; ++i)
 106                                 {
 107                                         scoped_object* ptr = *i;
 108                                         ptr->commit(L);
 109                                 }
 110 #ifndef NDEBUG
 111                                 m_cloned = false;
 112 #endif
 113
 114                         }
 115
 116                 private:
 117 #ifndef NDEBUG
 118                         bool m_cloned;
 119 #endif
 120                         mutable std::vector<scoped_object*> objects;
 121
 122                 };
 123
 124                 inline scoped_sequence scoped_object::operator,(const scoped_object& rhs) const
 125                 {
 126                         return scoped_sequence(const_cast<scoped_object*>(this)->clone(), const_cast<scoped_object&>(rhs).clone());
 127                 }
 128
 129         }
 130
 131         struct scope_stack
 132         {
 133                 std::stack<int> scopes;
 134
 135                 static int gc(lua_State* L)
 136                 {
 137                         scope_stack* scopes = static_cast<scope_stack*>(
 138                                 lua_touserdata(L, -1)
 139                         );
 140
 141                         assert(scopes->scopes.size() == 0);
 142
 143                         scopes->~scope_stack();
 144
 145                         return 0;
 146                 }
 147
 148                 static int top(lua_State* L)
 149                 {
 150                         lua_pushstring(L, "__luabind_scope_stack");
 151                         lua_gettable(L, LUA_REGISTRYINDEX);
 152
 153                         scope_stack* scopes = static_cast<scope_stack*>(
 154                                 lua_touserdata(L, -1)
 155                         );
 156
 157                         lua_pop(L, 1);
 158
 159                         return scopes->scopes.top();
 160                 }
 161
 162                 static void push(lua_State* L)
 163                 {
 164                         lua_pushstring(L, "__luabind_scope_stack");
 165                         lua_gettable(L, LUA_REGISTRYINDEX);
 166
 167                         scope_stack* scopes = static_cast<scope_stack*>(
 168                                 lua_touserdata(L, -1)
 169                         );
 170
 171                         lua_pop(L, 1);
 172
 173                         scopes->scopes.push(detail::ref(L));
 174                 }
 175
 176                 static void pop(lua_State* L)
 177                 {
 178                         lua_pushstring(L, "__luabind_scope_stack");
 179                         lua_gettable(L, LUA_REGISTRYINDEX);
 180
 181                         scope_stack* scopes = static_cast<scope_stack*>(
 182                                 lua_touserdata(L, -1)
 183                         );
 184
 185                         lua_pop(L, 1);
 186
 187                         int n = scopes->scopes.top();
 188                         scopes->scopes.pop();
 189                         detail::unref(L, n);
 190                 }
 191         };
 192
 193         class scope : public detail::scoped_object
 194         {
 195         public:
 196
 197                 static void init(lua_State* L)
 198                 {
 199                         lua_pushstring(L, "__luabind_scope_stack");
 200                         lua_gettable(L, LUA_REGISTRYINDEX);
 201
 202                         scope_stack* scopes = static_cast<scope_stack*>(
 203                                 lua_touserdata(L, -1)
 204                         );
 205
 206                         lua_pop(L, 1);
 207
 208                         if (scopes == 0)
 209                         {
 210                                 scopes = static_cast<scope_stack*>(
 211                                         lua_newuserdata(L, sizeof(scope_stack))
 212                                 );
 213
 214                                 lua_pushstring(L, "__luabind_scope_stack");
 215                                 lua_pushvalue(L, -2);
 216                                 lua_settable(L, LUA_REGISTRYINDEX);
 217
 218                                 new (scopes) scope_stack();
 219
 220                                 lua_newtable(L);
 221                                 lua_pushstring(L, "__gc");
 222                                 lua_pushcclosure(L, scope_stack::gc, 0);
 223                                 lua_settable(L, -3);
 224                                 lua_setmetatable(L, -2);
 225
 226                                 lua_pop(L, 1);
 227                         }
 228                 }
 229
 230                 scope(const char* name)
 231                         : m_name(name)
 232                 {
 233 #ifndef NDEBUG
 234                         m_cloned = false;
 235 #endif
 236                 }
 237
 238                 ~scope()
 239                 {
 240                         for (std::vector<detail::scoped_object*>::iterator
 241                                         i = m_children.begin(); i != m_children.end(); ++i)
 242                         {
 243                                 delete *i;
 244                         }
 245                 }
 246
 247                 scope& operator[](const detail::scoped_object& x)
 248                 {
 249                         detail::scoped_object* ptr = &const_cast<detail::scoped_object&>(x);
 250                         m_children.push_back(ptr->clone());
 251                         return *this;
 252                 }
 253
 254                 virtual detail::scoped_object* clone()
 255                 {
 256                         assert(!m_cloned && "cannot register the same namespace twice");
 257 #ifndef NDEBUG
 258                         m_cloned = true;
 259 #endif
 260                         std::vector<detail::scoped_object*> tmp;
 261                         tmp.swap(this->m_children);
 262                         scope* copy = new scope(m_name);
 263                         copy->m_children.swap(tmp);
 264                         return copy;
 265                 }
 266
 267                 virtual void commit(lua_State* L)
 268                 {
 269                         assert(!m_cloned && "cannot register the same namespace twice");
 270 #ifndef NDEBUG
 271                         m_cloned = true;
 272 #endif
 273                         init(L);
 274
 275                         detail::getref(L, scope_stack::top(L)); // get current scope
 276                         lua_pushstring(L, m_name);
 277                         lua_gettable(L, -2);
 278                         lua_remove(L, -2); // remove scope
 279
 280                         if (lua_isnil(L, -1))
 281                         {
 282                                 lua_pop(L, 1);
 283
 284                                 lua_newtable(L);
 285                                 detail::getref(L, scope_stack::top(L));
 286                                 lua_pushstring(L, m_name);
 287                                 lua_pushvalue(L, -3);
 288                                 lua_settable(L, -3);
 289                                 lua_pop(L, 1);
 290                         }
 291
 292                         scope_stack::push(L);
 293
 294                         for (std::vector<detail::scoped_object*>
 295                                                 ::const_iterator i = m_children.begin()
 296                                                                                         ; i != m_children.end()
 297                                                                                         ; ++i)
 298                         {
 299                                 detail::scoped_object* ptr = *i;
 300                                 ptr->commit(L);
 301                                 delete ptr;
 302                         }
 303
 304 #ifndef NDEBUG
 305                         m_children.clear();
 306 #endif
 307
 308                         scope_stack::pop(L);
 309                 }
 310
 311         private:
 312 #ifndef NDEBUG
 313                 bool m_cloned;
 314 #endif
 315                 mutable std::vector<detail::scoped_object*> m_children;
 316                 const char* m_name;
 317         };
 318
 319
 320
 321
 322
 323
 324
 325         class module_proxy
 326         {
 327         public:
 328
 329                 module_proxy(lua_State* L, const char* name)
 330                         : m_state(L)
 331                         , m_name(name)
 332                 {
 333                         scope::init(L);
 334                 }
 335
 336                 void operator[](const detail::scoped_object& x) const
 337                 {
 338                         lua_State* L = m_state;
 339                         if (m_name)
 340                         {
 341                                 lua_pushstring(L, m_name);
 342                                 lua_gettable(L, LUA_GLOBALSINDEX);
 343                                 if (lua_isnil(L, -1))
 344                                 {
 345                                         lua_pop(L, 1);
 346                                         // see if the table already exists
 347                                         lua_newtable(L);
 348                                         lua_pushstring(L, m_name);
 349                                         lua_pushvalue(L, -2);
 350                                         lua_settable(L, LUA_GLOBALSINDEX);
 351                                 }
 352                         }
 353                         else
 354                         {
 355                                 lua_pushvalue(L, LUA_GLOBALSINDEX);
 356                         }
 357
 358                         scope_stack::push(L);
 359
 360                         detail::scoped_object* ptr = &const_cast<detail::scoped_object&>(x);
 361                         ptr->commit(L);
 362
 363                         scope_stack::pop(L);
 364                 }
 365
 366         private:
 367
 368                 lua_State* m_state;
 369                 const char* m_name;
 370         };
 371
 372
 373         inline module_proxy module(lua_State* L) { return module_proxy(L,0); }
 374         inline module_proxy module(lua_State* L, const char* name) { return module_proxy(L, name); }
 375
 376         typedef scope namespace_;
 377 }
 378
 379 #endif // LUABIND_SCOPE_HPP_INCLUDED
 380