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