src/class.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 #define LUABIND_BUILDING
  24
  25 #include <luabind/lua_include.hpp>
  26
  27 #include <luabind/config.hpp>
  28 #include <luabind/class.hpp>
  29 #include <luabind/nil.hpp>
  30
  31 #include <cstring>
  32 #include <iostream>
  33
  34 namespace luabind
  35 {
  36    LUABIND_API detail::nil_type nil;
  37 }
  38
  39 namespace luabind { namespace detail {
  40
  41     struct class_registration : registration
  42     {
  43         class_registration(char const* name);
  44
  45         void register_(lua_State* L) const;
  46
  47         const char* m_name;
  48
  49         // datamembers, some members may be readonly, and
  50         // only have a getter function
  51         mutable std::map<const char*, detail::class_rep::callback, detail::ltstr> m_getters;
  52         mutable std::map<const char*, detail::class_rep::callback, detail::ltstr> m_setters;
  53
  54         // the operators in lua
  55         mutable std::vector<detail::class_rep::operator_callback> m_operators[detail::number_of_operators];
  56         mutable std::map<const char*, int, detail::ltstr> m_static_constants;
  57
  58         mutable std::vector<class_base::base_desc> m_bases;
  59         mutable detail::construct_rep m_constructor;
  60
  61         void(*m_destructor)(void*);
  62         void(*m_const_holder_destructor)(void*);
  63
  64         void*(*m_extractor)(void*);
  65         const void*(*m_const_extractor)(void*);
  66
  67         void(*m_const_converter)(void*,void*);
  68
  69         void(*m_construct_holder)(void*, void*);
  70         void(*m_construct_const_holder)(void*, void*);
  71
  72         void(*m_default_construct_holder)(void*);
  73         void(*m_default_construct_const_holder)(void*);
  74
  75                 void(*m_adopt_fun)(void*);
  76
  77         int m_holder_size;
  78         int m_holder_alignment;
  79
  80         LUABIND_TYPE_INFO m_type;
  81         LUABIND_TYPE_INFO m_holder_type;
  82         LUABIND_TYPE_INFO m_const_holder_type;
  83
  84         scope m_scope;
  85         scope m_members;
  86         scope m_default_members;
  87     };
  88
  89     class_registration::class_registration(char const* name)
  90     {
  91         m_name = name;
  92     }
  93
  94     void class_registration::register_(lua_State* L) const
  95     {
  96         LUABIND_CHECK_STACK(L);
  97
  98         assert(lua_type(L, -1) == LUA_TTABLE);
  99
 100         lua_pushstring(L, m_name);
 101
 102         detail::class_rep* crep;
 103
 104         detail::class_registry* r = detail::class_registry::get_registry(L);
 105         // create a class_rep structure for this class.
 106         // allocate it within lua to let lua collect it on
 107         // lua_close(). This is better than allocating it
 108         // as a static, since it will then be destructed
 109         // when the program exits instead.
 110         // warning: we assume that lua will not
 111         // move the userdata memory.
 112         lua_newuserdata(L, sizeof(detail::class_rep));
 113         crep = reinterpret_cast<detail::class_rep*>(lua_touserdata(L, -1));
 114
 115         new(crep) detail::class_rep(
 116             m_type
 117             , m_name
 118             , L
 119             , m_destructor
 120             , m_const_holder_destructor
 121             , m_holder_type
 122             , m_const_holder_type
 123             , m_extractor
 124             , m_const_extractor
 125             , m_const_converter
 126             , m_construct_holder
 127             , m_construct_const_holder
 128             , m_default_construct_holder
 129             , m_default_construct_const_holder
 130                         , m_adopt_fun
 131             , m_holder_size
 132             , m_holder_alignment);
 133
 134         // register this new type in the class registry
 135         r->add_class(m_type, crep);
 136         if (!(LUABIND_TYPE_INFO_EQUAL(m_holder_type, LUABIND_INVALID_TYPE_INFO)))
 137         {
 138             // if we have a held type
 139             // we have to register it in the class-table
 140             // but only for the base class, if it already
 141             // exists, we don't have to register it
 142             detail::class_rep* c = r->find_class(m_holder_type);
 143             if (c == 0)
 144             {
 145                 r->add_class(m_holder_type, crep);
 146                 r->add_class(m_const_holder_type, crep);
 147             }
 148         }
 149
 150         // constructors
 151         m_constructor.swap(crep->m_constructor);
 152
 153         crep->m_getters.swap(m_getters);
 154         crep->m_setters.swap(m_setters);
 155
 156         for (int i = 0; i < detail::number_of_operators; ++i)
 157             crep->m_operators[i].swap(m_operators[i]);
 158
 159         crep->m_static_constants.swap(m_static_constants);
 160
 161                 detail::class_registry* registry = detail::class_registry::get_registry(L);
 162
 163         crep->get_default_table(L);
 164         m_scope.register_(L);
 165         m_default_members.register_(L);
 166         lua_pop(L, 1);
 167
 168         crep->get_table(L);
 169         m_members.register_(L);
 170         lua_pop(L, 1);
 171
 172         for (std::vector<class_base::base_desc>::iterator i = m_bases.begin();
 173             i != m_bases.end(); ++i)
 174         {
 175             LUABIND_CHECK_STACK(L);
 176
 177             // the baseclass' class_rep structure
 178             detail::class_rep* bcrep = registry->find_class(i->type);
 179
 180             detail::class_rep::base_info base;
 181             base.pointer_offset = i->ptr_offset;
 182             base.base = bcrep;
 183
 184             crep->add_base_class(base);
 185
 186             // copy base class table
 187                         crep->get_table(L);
 188                         bcrep->get_table(L);
 189             lua_pushnil(L);
 190
 191             while (lua_next(L, -2))
 192             {
 193                 lua_pushvalue(L, -2); // copy key
 194                 lua_gettable(L, -5);
 195
 196                 if (!lua_isnil(L, -1))
 197                 {
 198                     lua_pop(L, 2);
 199                     continue;
 200                 }
 201
 202                 lua_pop(L, 1);
 203                 lua_pushvalue(L, -2); // copy key
 204                 lua_insert(L, -2);
 205
 206                 lua_settable(L, -5);
 207             }
 208             lua_pop(L, 2);
 209
 210             // copy base class detaults table
 211                         crep->get_default_table(L);
 212                         bcrep->get_default_table(L);
 213             lua_pushnil(L);
 214
 215             while (lua_next(L, -2))
 216             {
 217                 lua_pushvalue(L, -2); // copy key
 218                 lua_gettable(L, -5);
 219
 220                 if (!lua_isnil(L, -1))
 221                 {
 222                     lua_pop(L, 2);
 223                     continue;
 224                 }
 225
 226                 lua_pop(L, 1);
 227                 lua_pushvalue(L, -2); // copy key
 228                 lua_insert(L, -2);
 229
 230                 lua_settable(L, -5);
 231             }
 232             lua_pop(L, 2);
 233
 234                 }
 235
 236         lua_settable(L, -3);
 237     }
 238
 239     // -- interface ---------------------------------------------------------
 240
 241     class_base::class_base(char const* name)
 242         : scope(std::auto_ptr<registration>(
 243                 m_registration = new class_registration(name))
 244           )
 245     {
 246     }
 247
 248     void class_base::init(
 249         LUABIND_TYPE_INFO type_id
 250         , LUABIND_TYPE_INFO holder_type
 251         , LUABIND_TYPE_INFO const_holder_type
 252         , void*(*extractor)(void*)
 253         , const void*(*const_extractor)(void*)
 254         , void(*const_converter_)(void*,void*)
 255         , void(*holder_constructor_)(void*,void*)
 256         , void(*const_holder_constructor_)(void*,void*)
 257         , void(*holder_default_constructor_)(void*)
 258         , void(*const_holder_default_constructor_)(void*)
 259                 , void(*adopt_fun)(void*)
 260         , void(*destructor)(void*)
 261         , void(*const_holder_destructor)(void*)
 262         , int holder_size
 263         , int holder_alignment)
 264     {
 265         m_registration->m_type = type_id;
 266         m_registration->m_holder_type = holder_type;
 267         m_registration->m_const_holder_type = const_holder_type;
 268         m_registration->m_extractor = extractor;
 269         m_registration->m_const_extractor = const_extractor;
 270         m_registration->m_const_converter = const_converter_;
 271         m_registration->m_construct_holder = holder_constructor_;
 272         m_registration->m_construct_const_holder = const_holder_constructor_;
 273         m_registration->m_default_construct_holder = holder_default_constructor_;
 274         m_registration->m_default_construct_const_holder = const_holder_default_constructor_;
 275         m_registration->m_destructor = destructor;
 276         m_registration->m_const_holder_destructor = const_holder_destructor;
 277                 m_registration->m_adopt_fun = adopt_fun;
 278         m_registration->m_holder_size = holder_size;
 279         m_registration->m_holder_alignment = holder_alignment;
 280     }
 281
 282     void class_base::add_getter(
 283         const char* name, const boost::function2<int, lua_State*, int>& g)
 284     {
 285         detail::class_rep::callback c;
 286         c.func = g;
 287         c.pointer_offset = 0;
 288
 289         const char* key = name;
 290         m_registration->m_getters[key] = c;
 291     }
 292
 293 #ifdef LUABIND_NO_ERROR_CHECKING
 294     void class_base::add_setter(
 295         const char* name
 296         , const boost::function2<int, lua_State*, int>& s)
 297 #else
 298     void class_base::add_setter(
 299         const char* name
 300         , const boost::function2<int, lua_State*, int>& s
 301         , int (*match)(lua_State*, int)
 302         , void (*get_sig_ptr)(lua_State*, std::string&))
 303 #endif
 304     {
 305         detail::class_rep::callback c;
 306         c.func = s;
 307         c.pointer_offset = 0;
 308
 309 #ifndef LUABIND_NO_ERROR_CHECKING
 310         c.match = match;
 311         c.sig = get_sig_ptr;
 312 #endif
 313
 314
 315         const char* key = name;
 316         m_registration->m_setters[key] = c;
 317     }
 318
 319     void class_base::add_base(const base_desc& b)
 320     {
 321         m_registration->m_bases.push_back(b);
 322     }
 323
 324     void class_base::add_constructor(const detail::construct_rep::overload_t& o)
 325     {
 326         m_registration->m_constructor.overloads.push_back(o);
 327     }
 328
 329         void class_base::add_member(registration* member)
 330         {
 331                 std::auto_ptr<registration> ptr(member);
 332                 m_registration->m_members.operator,(scope(ptr));
 333         }
 334
 335         void class_base::add_default_member(registration* member)
 336         {
 337                 std::auto_ptr<registration> ptr(member);
 338                 m_registration->m_default_members.operator,(scope(ptr));
 339         }
 340
 341 #ifndef LUABIND_NO_ERROR_CHECKING
 342     void class_base::add_operator(
 343         int op_id,  int(*func)(lua_State*), int(*matcher)(lua_State*)
 344         , void(*sig)(lua_State*, std::string&), int arity)
 345 #else
 346     void class_base::add_operator(
 347         int op_id,  int(*func)(lua_State*)
 348         , int(*matcher)(lua_State*), int arity)
 349 #endif
 350     {
 351         detail::class_rep::operator_callback o;
 352         o.set_fun(func);
 353         o.set_match_fun(matcher);
 354         o.set_arity(arity);
 355
 356 #ifndef LUABIND_NO_ERROR_CHECKING
 357
 358         o.set_sig_fun(sig);
 359
 360 #endif
 361         m_registration->m_operators[op_id].push_back(o);
 362     }
 363
 364     const char* class_base::name() const
 365     {
 366         return m_registration->m_name;
 367     }
 368
 369     void class_base::add_static_constant(const char* name, int val)
 370     {
 371         m_registration->m_static_constants[name] = val;
 372     }
 373
 374     void class_base::add_inner_scope(scope& s)
 375     {
 376         m_registration->m_scope.operator,(s);
 377     }
 378
 379         template<class T>
 380         void add_custom_name(T i, std::string& s) {}
 381
 382         void add_custom_name(std::type_info const* i, std::string& s)
 383         {
 384                 s += " [";
 385                 s += i->name();
 386                 s += "]";
 387         }
 388
 389     std::string get_class_name(lua_State* L, LUABIND_TYPE_INFO i)
 390     {
 391         std::string ret;
 392
 393                 assert(L);
 394
 395                 class_registry* r = class_registry::get_registry(L);
 396         class_rep* crep = r->find_class(i);
 397
 398         if (crep == 0)
 399         {
 400             ret = "custom";
 401                         add_custom_name(i, ret);
 402         }
 403         else
 404         {
 405             if (LUABIND_TYPE_INFO_EQUAL(i, crep->holder_type()))
 406             {
 407                 ret += "smart_ptr<";
 408                 ret += crep->name();
 409                 ret += ">";
 410             }
 411             else if (LUABIND_TYPE_INFO_EQUAL(i, crep->const_holder_type()))
 412             {
 413                 ret += "smart_ptr<const ";
 414                 ret += crep->name();
 415                 ret += ">";
 416             }
 417             else
 418             {
 419                 ret += crep->name();
 420             }
 421         }
 422         return ret;
 423     };
 424
 425 }} // namespace luabind::detail
 426