src/luabind/scope.cpp

   1 // Copyright (c) 2004 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 #include <luabind/lua_include.hpp>
  24
  25 #include <luabind/scope.hpp>
  26 #include <luabind/detail/debug.hpp>
  27 #include <luabind/detail/stack_utils.hpp>
  28 #include <cassert>
  29
  30 namespace luabind { namespace detail {
  31
  32     registration::registration()
  33         : m_next(0)
  34     {
  35     }
  36
  37     registration::~registration()
  38     {
  39         delete m_next;
  40     }
  41
  42     } // namespace detail
  43
  44     scope::scope()
  45         : m_chain(0)
  46     {
  47     }
  48
  49     scope::scope(std::auto_ptr<detail::registration> reg)
  50         : m_chain(reg.release())
  51     {
  52     }
  53
  54     scope::scope(scope const& other)
  55         : m_chain(other.m_chain)
  56     {
  57         const_cast<scope&>(other).m_chain = 0;
  58     }
  59
  60     scope::~scope()
  61     {
  62         delete m_chain;
  63     }
  64
  65     scope& scope::operator,(scope s)
  66     {
  67         if (!m_chain)
  68         {
  69             m_chain = s.m_chain;
  70             s.m_chain = 0;
  71             return *this;
  72         }
  73
  74         for (detail::registration* c = m_chain;; c = c->m_next)
  75         {
  76             if (!c->m_next)
  77             {
  78                 c->m_next = s.m_chain;
  79                 s.m_chain = 0;
  80                 break;
  81             }
  82         }
  83
  84         return *this;
  85     }
  86
  87     void scope::register_(lua_State* L) const
  88     {
  89         for (detail::registration* r = m_chain; r != 0; r = r->m_next)
  90         {
  91                         LUABIND_CHECK_STACK(L);
  92             r->register_(L);
  93         }
  94     }
  95
  96 } // namespace luabind
  97
  98 namespace luabind {
  99
 100     namespace {
 101
 102         struct lua_pop_stack
 103         {
 104             lua_pop_stack(lua_State* L)
 105                 : m_state(L)
 106             {
 107             }
 108
 109             ~lua_pop_stack()
 110             {
 111                 lua_pop(m_state, 1);
 112             }
 113
 114             lua_State* m_state;
 115         };
 116
 117     } // namespace unnamed
 118
 119     module_::module_(lua_State* L, char const* name = 0)
 120         : m_state(L)
 121         , m_name(name)
 122     {
 123     }
 124
 125     void module_::operator[](scope s)
 126     {
 127         if (m_name)
 128         {
 129             lua_pushstring(m_state, m_name);
 130             lua_gettable(m_state, LUA_GLOBALSINDEX);
 131
 132             if (!lua_istable(m_state, -1))
 133             {
 134                 lua_pop(m_state, 1);
 135
 136                 lua_newtable(m_state);
 137                 lua_pushstring(m_state, m_name);
 138                 lua_pushvalue(m_state, -2);
 139                 lua_settable(m_state, LUA_GLOBALSINDEX);
 140             }
 141         }
 142         else
 143         {
 144             lua_pushvalue(m_state, LUA_GLOBALSINDEX);
 145         }
 146
 147         lua_pop_stack guard(m_state);
 148
 149         s.register_(m_state);
 150     }
 151
 152     struct namespace_::registration_ : detail::registration
 153     {
 154         registration_(char const* name)
 155             : m_name(name)
 156         {
 157         }
 158
 159         void register_(lua_State* L) const
 160         {
 161                         LUABIND_CHECK_STACK(L);
 162             assert(lua_gettop(L) >= 1);
 163
 164             lua_pushstring(L, m_name);
 165             lua_gettable(L, -2);
 166
 167                         detail::stack_pop p(L, 1); // pops the table on exit
 168
 169             if (!lua_istable(L, -1))
 170             {
 171                 lua_pop(L, 1);
 172
 173                 lua_newtable(L);
 174                 lua_pushstring(L, m_name);
 175                 lua_pushvalue(L, -2);
 176                 lua_settable(L, -4);
 177             }
 178
 179             m_scope.register_(L);
 180         }
 181
 182         char const* m_name;
 183         scope m_scope;
 184     };
 185
 186     namespace_::namespace_(char const* name)
 187         : scope(std::auto_ptr<detail::registration>(
 188               m_registration = new registration_(name)))
 189     {
 190     }
 191
 192     namespace_& namespace_::operator[](scope s)
 193     {
 194         m_registration->m_scope.operator,(s);
 195         return *this;
 196     }
 197
 198 } // namespace luabind
 199