src/class_rep.cpp

   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 #include <luabind/lua_include.hpp>
  24
  25 #include <luabind/detail/stack_utils.hpp>
  26 #include <luabind/detail/conversion_storage.hpp>
  27 #include <luabind/luabind.hpp>
  28 #include <luabind/exception_handler.hpp>
  29 #include <utility>
  30
  31 using namespace luabind::detail;
  32
  33 #ifndef LUABIND_NO_ERROR_CHECKING
  34
  35         std::string luabind::detail::get_overload_signatures_candidates(
  36                         lua_State* L
  37                         , std::vector<const overload_rep_base*>::iterator start
  38                         , std::vector<const overload_rep_base*>::iterator end
  39                         , std::string name)
  40         {
  41                 std::string s;
  42                 for (; start != end; ++start)
  43                 {
  44                         s += name;
  45                         (*start)->get_signature(L, s);
  46                         s += "\n";
  47                 }
  48                 return s;
  49         }
  50
  51 #endif
  52
  53
  54 luabind::detail::class_rep::class_rep(LUABIND_TYPE_INFO type
  55         , const char* name
  56         , lua_State* L
  57         ,  void(*destructor)(void*)
  58         ,  void(*const_holder_destructor)(void*)
  59         , LUABIND_TYPE_INFO holder_type
  60         , LUABIND_TYPE_INFO const_holder_type
  61         , void*(*extractor)(void*)
  62         , const void*(*const_extractor)(void*)
  63         , void(*const_converter)(void*,void*)
  64         , void(*construct_holder)(void*,void*)
  65         , void(*construct_const_holder)(void*,void*)
  66         , void(*default_construct_holder)(void*)
  67         , void(*default_construct_const_holder)(void*)
  68         , void(*adopt_fun)(void*)
  69         , int holder_size
  70         , int holder_alignment)
  71
  72         : m_type(type)
  73         , m_holder_type(holder_type)
  74         , m_const_holder_type(const_holder_type)
  75         , m_extractor(extractor)
  76         , m_const_extractor(const_extractor)
  77         , m_const_converter(const_converter)
  78         , m_construct_holder(construct_holder)
  79         , m_construct_const_holder(construct_const_holder)
  80         , m_default_construct_holder(default_construct_holder)
  81         , m_default_construct_const_holder(default_construct_const_holder)
  82         , m_adopt_fun(adopt_fun)
  83         , m_holder_size(holder_size)
  84         , m_holder_alignment(holder_alignment)
  85         , m_name(name)
  86         , m_class_type(cpp_class)
  87         , m_destructor(destructor)
  88         , m_const_holder_destructor(const_holder_destructor)
  89         , m_operator_cache(0)
  90 {
  91         assert(m_holder_alignment >= 1 && "internal error");
  92
  93         lua_newtable(L);
  94         handle(L, -1).swap(m_table);
  95         lua_newtable(L);
  96         handle(L, -1).swap(m_default_table);
  97         lua_pop(L, 2);
  98
  99         class_registry* r = class_registry::get_registry(L);
 100         assert((r->cpp_class() != LUA_NOREF) && "you must call luabind::open()");
 101
 102         detail::getref(L, r->cpp_class());
 103         lua_setmetatable(L, -2);
 104
 105         lua_pushvalue(L, -1); // duplicate our user data
 106         m_self_ref.set(L);
 107
 108         m_instance_metatable = r->cpp_instance();
 109 }
 110
 111 luabind::detail::class_rep::class_rep(lua_State* L, const char* name)
 112         : m_type(LUABIND_INVALID_TYPE_INFO)
 113         , m_holder_type(LUABIND_INVALID_TYPE_INFO)
 114         , m_const_holder_type(LUABIND_INVALID_TYPE_INFO)
 115         , m_extractor(0)
 116         , m_const_extractor(0)
 117         , m_const_converter(0)
 118         , m_construct_holder(0)
 119         , m_construct_const_holder(0)
 120         , m_default_construct_holder(0)
 121         , m_default_construct_const_holder(0)
 122         , m_adopt_fun(0)
 123         , m_holder_size(0)
 124         , m_holder_alignment(1)
 125         , m_name(name)
 126         , m_class_type(lua_class)
 127         , m_destructor(0)
 128         , m_const_holder_destructor(0)
 129         , m_operator_cache(0)
 130 {
 131         lua_newtable(L);
 132         handle(L, -1).swap(m_table);
 133         lua_newtable(L);
 134         handle(L, -1).swap(m_default_table);
 135         lua_pop(L, 2);
 136
 137         class_registry* r = class_registry::get_registry(L);
 138         assert((r->cpp_class() != LUA_NOREF) && "you must call luabind::open()");
 139
 140         detail::getref(L, r->lua_class());
 141         lua_setmetatable(L, -2);
 142         lua_pushvalue(L, -1); // duplicate our user data
 143         m_self_ref.set(L);
 144
 145         m_instance_metatable = r->lua_instance();
 146 }
 147
 148 luabind::detail::class_rep::~class_rep()
 149 {
 150 }
 151
 152 // leaves object on lua stack
 153 std::pair<void*,void*>
 154 luabind::detail::class_rep::allocate(lua_State* L) const
 155 {
 156         const int overlap = sizeof(object_rep)&(m_holder_alignment-1);
 157         const int padding = overlap==0?0:m_holder_alignment-overlap;
 158         const int size = sizeof(object_rep) + padding + m_holder_size;
 159
 160         char* mem = static_cast<char*>(lua_newuserdata(L, size));
 161         char* ptr = mem + sizeof(object_rep) + padding;
 162
 163         return std::pair<void*,void*>(mem,ptr);
 164 }
 165
 166 void luabind::detail::class_rep::adopt(bool const_obj, void* obj)
 167 {
 168         if (m_adopt_fun == 0) return;
 169
 170         if (m_extractor)
 171         {
 172                 assert(m_const_extractor);
 173                 if (const_obj)
 174                         m_adopt_fun(const_cast<void*>(m_const_extractor(obj)));
 175                 else
 176                         m_adopt_fun(m_extractor(obj));
 177         }
 178         else
 179         {
 180                 m_adopt_fun(obj);
 181         }
 182 }
 183
 184 // lua stack: userdata, key
 185 int luabind::detail::class_rep::gettable(lua_State* L)
 186 {
 187         // if key is nil, return nil
 188         if (lua_isnil(L, 2))
 189         {
 190                 lua_pushnil(L);
 191                 return 1;
 192         }
 193
 194         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 195
 196         // we have to ignore the first argument since this may point to
 197         // a method that is not present in this class (but in a subclass)
 198         const char* key = lua_tostring(L, 2);
 199
 200 #ifndef LUABIND_NO_ERROR_CHECKING
 201
 202         if (std::strlen(key) != lua_strlen(L, 2))
 203         {
 204                 {
 205                         std::string msg("luabind does not support "
 206                                 "member names with extra nulls:\n");
 207                         msg += std::string(lua_tostring(L, 2), lua_strlen(L, 2));
 208                         lua_pushstring(L, msg.c_str());
 209                 }
 210                 lua_error(L);
 211         }
 212
 213 #endif
 214
 215         // special case to see if this is a null-pointer
 216         if (key && !std::strcmp(key, "__ok"))
 217         {
 218                 class_rep* crep = obj->crep();
 219
 220                 void* p = crep->extractor() ? crep->extractor()(obj->ptr())
 221                         : obj->ptr();
 222
 223                 lua_pushboolean(L, p != 0);
 224                 return 1;
 225         }
 226
 227 // First, look in the instance's table
 228         detail::lua_reference const& tbl = obj->get_lua_table();
 229         if (tbl.is_valid())
 230         {
 231                 tbl.get(L);
 232                 lua_pushvalue(L, 2);
 233                 lua_gettable(L, -2);
 234                 if (!lua_isnil(L, -1))
 235                 {
 236                         lua_remove(L, -2); // remove table
 237                         return 1;
 238                 }
 239                 lua_pop(L, 2);
 240         }
 241
 242 // Then look in the class' table for this member
 243         obj->crep()->get_table(L);
 244         lua_pushvalue(L, 2);
 245         lua_gettable(L, -2);
 246
 247         if (!lua_isnil(L, -1))
 248         {
 249                 lua_remove(L, -2); // remove table
 250                 return 1;
 251         }
 252         lua_pop(L, 2);
 253
 254         std::map<const char*, callback, ltstr>::iterator j = m_getters.find(key);
 255         if (j != m_getters.end())
 256         {
 257                 // the name is a data member
 258                 return j->second.func(L, j->second.pointer_offset);
 259         }
 260
 261         lua_pushnil(L);
 262         return 1;
 263 }
 264
 265 // called from the metamethod for __newindex
 266 // the object pointer is passed on the lua stack
 267 // lua stack: userdata, key, value
 268 bool luabind::detail::class_rep::settable(lua_State* L)
 269 {
 270         // if the key is 'nil' fail
 271         if (lua_isnil(L, 2)) return false;
 272
 273         // we have to ignore the first argument since this may point to
 274         // a method that is not present in this class (but in a subclass)
 275
 276         const char* key = lua_tostring(L, 2);
 277
 278         if (std::strlen(key) == lua_strlen(L, 2))
 279         {
 280                 std::map<const char*, callback, ltstr>::iterator j = m_setters.find(key);
 281                 if (j != m_setters.end())
 282                 {
 283                         // the name is a data member
 284 #ifndef LUABIND_NO_ERROR_CHECKING
 285                         if (j->second.match(L, 3) < 0)
 286                         {
 287                                 std::string msg("the attribute '");
 288                                 msg += m_name;
 289                                 msg += ".";
 290                                 msg += key;
 291                                 msg += "' is of type: ";
 292                                 j->second.sig(L, msg);
 293                                 msg += "\nand does not match: (";
 294                                 msg += stack_content_by_name(L, 3);
 295                                 msg += ")";
 296                                 lua_pushstring(L, msg.c_str());
 297                                 return false;
 298                         }
 299 #endif
 300                         j->second.func(L, j->second.pointer_offset);
 301                         return true;
 302                 }
 303
 304                 if (m_getters.find(key) != m_getters.end())
 305                 {
 306                         // this means that we have a getter but no
 307                         // setter for an attribute. We will then fail
 308                         // because that attribute is read-only
 309                         std::string msg("the attribute '");
 310                         msg += m_name;
 311                         msg += ".";
 312                         msg += key;
 313                         msg += "' is read only";
 314                         lua_pushstring(L, msg.c_str());
 315                         return false;
 316                 }
 317         }
 318
 319         // set the attribute to the object's table
 320         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 321         detail::lua_reference& tbl = obj->get_lua_table();
 322         if (!tbl.is_valid())
 323         {
 324                 // this is the first time we are trying to add
 325                 // a member to this instance, create the table.
 326                 lua_newtable(L);
 327                 lua_pushvalue(L, -1);
 328                 tbl.set(L);
 329         }
 330         else
 331         {
 332                 tbl.get(L);
 333         }
 334         lua_pushvalue(L, 2);
 335         lua_pushvalue(L, 3);
 336         lua_settable(L, 4);
 337         lua_pop(L, 3);
 338         return true;
 339 }
 340
 341 int class_rep::gettable_dispatcher(lua_State* L)
 342 {
 343         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 344         return obj->crep()->gettable(L);
 345 }
 346
 347 // this is called as __newindex metamethod on every instance of this class
 348 int luabind::detail::class_rep::settable_dispatcher(lua_State* L)
 349 {
 350         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 351
 352         bool success = obj->crep()->settable(L);
 353
 354 #ifndef LUABIND_NO_ERROR_CHECKING
 355
 356         if (!success)
 357         {
 358                 // class_rep::settable() will leave
 359                 // error message on the stack in case
 360                 // of failure
 361                 lua_error(L);
 362         }
 363
 364 #endif
 365
 366         return 0;
 367 }
 368
 369
 370 int luabind::detail::class_rep::operator_dispatcher(lua_State* L)
 371 {
 372         for (int i = 0; i < 2; ++i)
 373         {
 374                 if (is_class_object(L, 1 + i))
 375                 {
 376             int nargs = lua_gettop(L);
 377
 378             lua_pushvalue(L, lua_upvalueindex(1));
 379                         lua_gettable(L, 1 + i);
 380
 381                         if (lua_isnil(L, -1))
 382                         {
 383                                 lua_pop(L, 1);
 384                                 continue;
 385                         }
 386
 387                         lua_insert(L, 1); // move the function to the bottom
 388
 389             nargs = lua_toboolean(L, lua_upvalueindex(2)) ? 1 : nargs;
 390
 391             if (lua_toboolean(L, lua_upvalueindex(2))) // remove trailing nil
 392                 lua_remove(L, 3);
 393
 394             lua_call(L, nargs, 1);
 395             return 1;
 396                 }
 397         }
 398
 399         lua_pop(L, lua_gettop(L));
 400         lua_pushstring(L, "No such operator defined");
 401         lua_error(L);
 402
 403         return 0;
 404 }
 405
 406 // this is called as metamethod __call on the class_rep.
 407 int luabind::detail::class_rep::constructor_dispatcher(lua_State* L)
 408 {
 409     class_rep* cls = static_cast<class_rep*>(lua_touserdata(L, 1));
 410
 411     int args = lua_gettop(L);
 412
 413     lua_newtable(L);
 414     lua_reference ref;
 415     ref.set(L);
 416
 417     void* obj_ptr;
 418     void* held_storage;
 419
 420     int flags = object_rep::lua_class | object_rep::owner;
 421
 422     boost::tie(obj_ptr, held_storage) = cls->allocate(L);
 423     (new(obj_ptr) object_rep(cls, flags, ref))->set_object(held_storage);
 424
 425     detail::getref(L, cls->metatable_ref());
 426     lua_setmetatable(L, -2);
 427
 428     lua_pushvalue(L, -1);
 429     lua_replace(L, 1);
 430
 431     cls->get_table(L);
 432     lua_pushstring(L, "__init");
 433     lua_gettable(L, -2);
 434
 435     lua_insert(L, 1);
 436
 437     lua_pop(L, 1);
 438     lua_insert(L, 1);
 439
 440     lua_call(L, args, 0);
 441
 442     return 1;
 443 }
 444
 445 void luabind::detail::class_rep::add_base_class(const luabind::detail::class_rep::base_info& binfo)
 446 {
 447         // If you hit this assert you are deriving from a type that is not registered
 448         // in lua. That is, in the class_<> you are giving a baseclass that isn't registered.
 449         // Please note that if you don't need to have access to the base class or the
 450         // conversion from the derived class to the base class, you don't need
 451         // to tell luabind that it derives.
 452         assert(binfo.base && "You cannot derive from an unregistered type");
 453
 454         class_rep* bcrep = binfo.base;
 455
 456         // import all getters from the base
 457         for (std::map<const char*, callback, ltstr>::const_iterator i = bcrep->m_getters.begin();
 458                         i != bcrep->m_getters.end(); ++i)
 459         {
 460                 callback& m = m_getters[i->first];
 461                 m.pointer_offset = i->second.pointer_offset + binfo.pointer_offset;
 462                 m.func = i->second.func;
 463
 464 #ifndef LUABIND_NO_ERROR_CHECKING
 465                 m.match = i->second.match;
 466                 m.sig = i->second.sig;
 467 #endif
 468         }
 469
 470         // import all setters from the base
 471         for (std::map<const char*, callback, ltstr>::const_iterator i = bcrep->m_setters.begin();
 472                         i != bcrep->m_setters.end(); ++i)
 473         {
 474                 callback& m = m_setters[i->first];
 475                 m.pointer_offset = i->second.pointer_offset + binfo.pointer_offset;
 476                 m.func = i->second.func;
 477
 478 #ifndef LUABIND_NO_ERROR_CHECKING
 479                 m.match = i->second.match;
 480                 m.sig = i->second.sig;
 481 #endif
 482         }
 483
 484         // import all static constants
 485         for (std::map<const char*, int, ltstr>::const_iterator i = bcrep->m_static_constants.begin();
 486                         i != bcrep->m_static_constants.end(); ++i)
 487         {
 488                 int& v = m_static_constants[i->first];
 489                 v = i->second;
 490         }
 491
 492         // import all operators
 493         for (int i = 0; i < number_of_operators; ++i)
 494         {
 495                 for (std::vector<operator_callback>::const_iterator j = bcrep->m_operators[i].begin();
 496                                 j != bcrep->m_operators[i].end(); ++j)
 497                         m_operators[i].push_back(*j);
 498         }
 499
 500         // also, save the baseclass info to be used for typecasts
 501         m_bases.push_back(binfo);
 502
 503     if (!m_destructor)
 504         m_destructor = bcrep->m_destructor;
 505 }
 506
 507 int luabind::detail::class_rep::super_callback(lua_State* L)
 508 {
 509         int args = lua_gettop(L);
 510
 511         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, lua_upvalueindex(2)));
 512         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, lua_upvalueindex(1)));
 513         class_rep* base = crep->bases()[0].base;
 514
 515         if (base->bases().empty())
 516         {
 517                 obj->set_flags(obj->flags() & ~object_rep::call_super);
 518
 519                 lua_pushstring(L, "super");
 520                 lua_pushnil(L);
 521                 lua_settable(L, LUA_GLOBALSINDEX);
 522         }
 523         else
 524         {
 525                 lua_pushstring(L, "super");
 526                 lua_pushlightuserdata(L, base);
 527                 lua_pushvalue(L, lua_upvalueindex(2));
 528                 lua_pushcclosure(L, super_callback, 2);
 529                 lua_settable(L, LUA_GLOBALSINDEX);
 530         }
 531
 532         base->get_table(L);
 533         lua_pushstring(L, "__init");
 534         lua_gettable(L, -2);
 535         lua_insert(L, 1);
 536         lua_pop(L, 1);
 537
 538         lua_pushvalue(L, lua_upvalueindex(2));
 539         lua_insert(L, 2);
 540
 541         lua_call(L, args + 1, 0);
 542
 543         // TODO: instead of clearing the global variable "super"
 544         // store it temporarily in the registry. maybe we should
 545         // have some kind of warning if the super global is used?
 546         lua_pushstring(L, "super");
 547         lua_pushnil(L);
 548         lua_settable(L, LUA_GLOBALSINDEX);
 549
 550         return 0;
 551 }
 552
 553
 554
 555 int luabind::detail::class_rep::lua_settable_dispatcher(lua_State* L)
 556 {
 557         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
 558
 559         // get first table
 560         crep->get_table(L);
 561
 562         // copy key, value
 563         lua_pushvalue(L, -3);
 564         lua_pushvalue(L, -3);
 565         lua_rawset(L, -3);
 566         // pop table
 567         lua_pop(L, 1);
 568
 569         // get default table
 570         crep->get_default_table(L);
 571         lua_replace(L, 1);
 572         lua_rawset(L, -3);
 573
 574         crep->m_operator_cache = 0; // invalidate cache
 575
 576         return 0;
 577 }
 578
 579 int luabind::detail::class_rep::construct_lua_class_callback(lua_State* L)
 580 {
 581         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
 582
 583         int args = lua_gettop(L);
 584
 585         // lua stack: crep <arguments>
 586
 587         lua_newtable(L);
 588         detail::lua_reference ref;
 589         ref.set(L);
 590
 591         bool has_bases = !crep->bases().empty();
 592
 593         if (has_bases)
 594         {
 595                 lua_pushstring(L, "super");
 596                 lua_pushvalue(L, 1); // crep
 597         }
 598
 599         // lua stack: crep <arguments> "super" crep
 600         // or
 601         // lua stack: crep <arguments>
 602
 603         // if we have a baseclass we set the flag to say that the super has not yet been called
 604         // we will use this flag later to check that it actually was called from __init()
 605         int flags = object_rep::lua_class | object_rep::owner | (has_bases ? object_rep::call_super : 0);
 606
 607 //      void* obj_ptr = lua_newuserdata(L, sizeof(object_rep));
 608         void* obj_ptr;
 609         void* held_storage;
 610
 611         boost::tie(obj_ptr, held_storage) = crep->allocate(L);
 612         (new(obj_ptr) object_rep(crep, flags, ref))->set_object(held_storage);
 613
 614         detail::getref(L, crep->metatable_ref());
 615         lua_setmetatable(L, -2);
 616
 617         // lua stack: crep <arguments> "super" crep obj_ptr
 618         // or
 619         // lua stack: crep <arguments> obj_ptr
 620
 621         if (has_bases)  lua_pushvalue(L, -1); // obj_ptr
 622         lua_replace(L, 1); // obj_ptr
 623
 624         // lua stack: obj_ptr <arguments> "super" crep obj_ptr
 625         // or
 626         // lua stack: obj_ptr <arguments>
 627
 628         if (has_bases)
 629         {
 630                 lua_pushcclosure(L, super_callback, 2);
 631                 // lua stack: crep <arguments> "super" function
 632                 lua_settable(L, LUA_GLOBALSINDEX);
 633         }
 634
 635         // lua stack: crep <arguments>
 636
 637         lua_pushvalue(L, 1);
 638         lua_insert(L, 1);
 639
 640         crep->get_table(L);
 641         lua_pushstring(L, "__init");
 642         lua_gettable(L, -2);
 643
 644 #ifndef LUABIND_NO_ERROR_CHECKING
 645
 646         // TODO: should this be a run-time error?
 647         // maybe the default behavior should be to just call
 648         // the base calss' constructor. We should register
 649         // the super callback funktion as __init
 650         if (!lua_isfunction(L, -1))
 651         {
 652                 {
 653                         std::string msg = crep->name();
 654                         msg += ":__init is not defined";
 655                         lua_pushstring(L, msg.c_str());
 656                 }
 657                 lua_error(L);
 658         }
 659
 660 #endif
 661
 662         lua_insert(L, 2); // function first on stack
 663         lua_pop(L, 1);
 664         // TODO: lua_call may invoke longjump! make sure we don't have any memory leaks!
 665         // we don't have any stack objects here
 666         lua_call(L, args, 0);
 667
 668         return 1;
 669 }
 670
 671 // called from the metamethod for __index
 672 // obj is the object pointer
 673 int luabind::detail::class_rep::lua_class_gettable(lua_State* L)
 674 {
 675         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 676         class_rep* crep = obj->crep();
 677
 678         // we have to ignore the first argument since this may point to
 679         // a method that is not present in this class (but in a subclass)
 680
 681         // BUG: This might catch members called "__ok\0foobar"
 682         const char* key = lua_tostring(L, 2);
 683
 684         if (key && !std::strcmp(key, "__ok"))
 685         {
 686                 class_rep* crep = obj->crep();
 687
 688                 void* p = crep->extractor() ? crep->extractor()(obj->ptr())
 689                         : obj->ptr();
 690
 691                 lua_pushboolean(L, p != 0);
 692                 return 1;
 693         }
 694
 695         // first look in the instance's table
 696         detail::lua_reference const& tbl = obj->get_lua_table();
 697         assert(tbl.is_valid());
 698         tbl.get(L);
 699         lua_pushvalue(L, 2);
 700         lua_gettable(L, -2);
 701         if (!lua_isnil(L, -1))
 702         {
 703                 lua_remove(L, -2); // remove table
 704                 return 1;
 705         }
 706         lua_pop(L, 2);
 707
 708         // then look in the class' table
 709         crep->get_table(L);
 710         lua_pushvalue(L, 2);
 711         lua_gettable(L, -2);
 712
 713         if (!lua_isnil(L, -1))
 714         {
 715                 lua_remove(L, -2); // more table
 716                 return 1;
 717         }
 718
 719         lua_pop(L, 2);
 720
 721         if (lua_isnil(L, 2))
 722         {
 723                 lua_pushnil(L);
 724                 return 1;
 725         }
 726
 727         std::map<const char*, class_rep::callback, ltstr>::iterator j = crep->m_getters.find(key);
 728         if (j != crep->m_getters.end())
 729         {
 730                 // the name is a data member
 731                 return j->second.func(L, j->second.pointer_offset);
 732         }
 733
 734         lua_pushnil(L);
 735         return 1;
 736 }
 737
 738 // called from the metamethod for __newindex
 739 // obj is the object pointer
 740 int luabind::detail::class_rep::lua_class_settable(lua_State* L)
 741 {
 742         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 743         class_rep* crep = obj->crep();
 744
 745         // we have to ignore the first argument since this may point to
 746         // a method that is not present in this class (but in a subclass)
 747         // BUG: This will not work with keys with extra nulls in them
 748         const char* key = lua_tostring(L, 2);
 749
 750
 751         std::map<const char*, class_rep::callback, ltstr>::iterator j = crep->m_setters.find(key);
 752
 753         // if the strlen(key) is not the true length,
 754         // it means that the member-name contains
 755         // extra nulls. luabind does not support such
 756         // names as member names. So, use the lua
 757         // table as fall-back
 758         if (j == crep->m_setters.end()
 759                 || std::strlen(key) != lua_strlen(L, 2))
 760         {
 761                 std::map<const char*, class_rep::callback, ltstr>::iterator k = crep->m_getters.find(key);
 762
 763 #ifndef LUABIND_NO_ERROR_CHECKING
 764
 765                 if (k != crep->m_getters.end())
 766                 {
 767                         {
 768                                 std::string msg = "cannot set property '";
 769                                 msg += crep->name();
 770                                 msg += ".";
 771                                 msg += key;
 772                                 msg += "', because it's read only";
 773                                 lua_pushstring(L, msg.c_str());
 774                         }
 775                         lua_error(L);
 776                 }
 777
 778 #endif
 779
 780                 detail::lua_reference const& tbl = obj->get_lua_table();
 781                 assert(tbl.is_valid());
 782                 tbl.get(L);
 783                 lua_replace(L, 1);
 784                 lua_settable(L, 1);
 785         }
 786         else
 787         {
 788                 // the name is a data member
 789                 j->second.func(L, j->second.pointer_offset);
 790         }
 791
 792         return 0;
 793 }
 794
 795 /*
 796         stack:
 797         1: class_rep
 798         2: member name
 799 */
 800 int luabind::detail::class_rep::static_class_gettable(lua_State* L)
 801 {
 802         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
 803
 804         // look in the static function table
 805         crep->get_default_table(L);
 806         lua_pushvalue(L, 2);
 807         lua_gettable(L, -2);
 808         if (!lua_isnil(L, -1)) return 1;
 809         else lua_pop(L, 2);
 810
 811         const char* key = lua_tostring(L, 2);
 812
 813         if (std::strlen(key) != lua_strlen(L, 2))
 814         {
 815                 lua_pushnil(L);
 816                 return 1;
 817         }
 818
 819         std::map<const char*, int, ltstr>::const_iterator j = crep->m_static_constants.find(key);
 820
 821         if (j != crep->m_static_constants.end())
 822         {
 823                 lua_pushnumber(L, j->second);
 824                 return 1;
 825         }
 826
 827 #ifndef LUABIND_NO_ERROR_CHECKING
 828
 829         {
 830                 std::string msg = "no static '";
 831                 msg += key;
 832                 msg += "' in class '";
 833                 msg += crep->name();
 834                 msg += "'";
 835                 lua_pushstring(L, msg.c_str());
 836         }
 837         lua_error(L);
 838
 839 #endif
 840
 841         lua_pushnil(L);
 842
 843         return 1;
 844 }
 845
 846 bool luabind::detail::is_class_rep(lua_State* L, int index)
 847 {
 848         if (lua_getmetatable(L, index) == 0) return false;
 849
 850         lua_pushstring(L, "__luabind_classrep");
 851         lua_gettable(L, -2);
 852         if (lua_toboolean(L, -1))
 853         {
 854                 lua_pop(L, 2);
 855                 return true;
 856         }
 857
 858         lua_pop(L, 2);
 859         return false;
 860 }
 861
 862 void luabind::detail::finalize(lua_State* L, class_rep* crep)
 863 {
 864         if (crep->get_class_type() != class_rep::lua_class) return;
 865
 866 //      lua_pushvalue(L, -1); // copy the object ref
 867         crep->get_table(L);
 868         lua_pushstring(L, "__finalize");
 869         lua_gettable(L, -2);
 870         lua_remove(L, -2);
 871
 872         if (lua_isnil(L, -1))
 873         {
 874                 lua_pop(L, 1);
 875         }
 876         else
 877         {
 878                 lua_pushvalue(L, -2);
 879                 lua_call(L, 1, 0);
 880         }
 881
 882         for (std::vector<class_rep::base_info>::const_iterator
 883                         i = crep->bases().begin(); i != crep->bases().end(); ++i)
 884         {
 885                 if (i->base) finalize(L, i->base);
 886         }
 887 }
 888
 889 void* luabind::detail::class_rep::convert_to(
 890         LUABIND_TYPE_INFO target_type
 891         , const object_rep* obj
 892         , conversion_storage& storage) const
 893 {
 894         // TODO: since this is a member function, we don't have to use the accesor functions for
 895         // the types and the extractor
 896
 897         assert(obj == 0 || obj->crep() == this);
 898
 899         int steps = 0;
 900         int offset = 0;
 901         if (!(LUABIND_TYPE_INFO_EQUAL(holder_type(), target_type))
 902                 && !(LUABIND_TYPE_INFO_EQUAL(const_holder_type(), target_type)))
 903         {
 904                 steps = implicit_cast(this, target_type, offset);
 905         }
 906
 907         // should never be called with a type that can't be cast
 908         assert((steps >= 0) && "internal error, please report");
 909
 910         if (LUABIND_TYPE_INFO_EQUAL(target_type, holder_type()))
 911         {
 912                 if (obj == 0)
 913                 {
 914                         // we are trying to convert nil to a holder type
 915                         m_default_construct_holder(&storage.data);
 916                         storage.destructor = m_destructor;
 917                         return &storage.data;
 918                 }
 919                 // if the type we are trying to convert to is the holder_type
 920                 // it means that his crep has a holder_type (since it would have
 921                 // been invalid otherwise, and T cannot be invalid). It also means
 922                 // that we need no conversion, since the holder_type is what the
 923                 // object points to.
 924                 return obj->ptr();
 925         }
 926
 927         if (LUABIND_TYPE_INFO_EQUAL(target_type, const_holder_type()))
 928         {
 929                 if (obj == 0)
 930                 {
 931                         // we are trying to convert nil to a const holder type
 932                         m_default_construct_const_holder(&storage.data);
 933                         storage.destructor = m_const_holder_destructor;
 934                         return &storage.data;
 935                 }
 936
 937                 if (obj->flags() & object_rep::constant)
 938                 {
 939                         // we are holding a constant
 940                         return obj->ptr();
 941                 }
 942                 else
 943                 {
 944                         // we are holding a non-constant, we need to convert it
 945                         // to a const_holder.
 946                         m_const_converter(obj->ptr(), &storage.data);
 947                         storage.destructor = m_const_holder_destructor;
 948                         return &storage.data;
 949                 }
 950         }
 951
 952         void* raw_pointer;
 953
 954         if (has_holder())
 955         {
 956                 assert(obj);
 957                 // this means that we have a holder type where the
 958                 // raw-pointer needs to be extracted
 959                 raw_pointer = extractor()(obj->ptr());
 960         }
 961         else
 962         {
 963                 if (obj == 0) raw_pointer = 0;
 964                 else raw_pointer = obj->ptr();
 965         }
 966
 967         return static_cast<char*>(raw_pointer) + offset;
 968 }
 969
 970 void luabind::detail::class_rep::cache_operators(lua_State* L)
 971 {
 972         m_operator_cache = 0x1;
 973
 974         for (int i = 0; i < number_of_operators; ++i)
 975         {
 976                 get_table(L);
 977                 lua_pushstring(L, get_operator_name(i));
 978                 lua_rawget(L, -2);
 979
 980                 if (lua_isfunction(L, -1)) m_operator_cache |= 1 << (i + 1);
 981
 982                 lua_pop(L, 2);
 983         }
 984 }
 985
 986 bool luabind::detail::class_rep::has_operator_in_lua(lua_State* L, int id)
 987 {
 988         if ((m_operator_cache & 0x1) == 0)
 989                 cache_operators(L);
 990
 991         const int mask = 1 << (id + 1);
 992
 993         return (m_operator_cache & mask) != 0;
 994 }
 995
 996 const class_rep::property_map& luabind::detail::class_rep::properties() const
 997 {
 998         return m_getters;
 999 }
1000