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 #define LUABIND_BUILDING
  26
  27 #include <luabind/luabind.hpp>
  28 #include <utility>
  29
  30 using namespace luabind::detail;
  31
  32
  33 #ifndef LUABIND_NO_ERROR_CHECKING
  34
  35         std::string luabind::detail::get_overload_signatures_candidates(lua_State* L, std::vector<const overload_rep_base*>::iterator start, std::vector<const overload_rep_base*>::iterator end, std::string name)
  36         {
  37                 std::string s;
  38                 for (; start != end; ++start)
  39                 {
  40                         s += name;
  41                         (*start)->get_signature(L, s);
  42                         s += "\n";
  43                 }
  44                 return s;
  45         }
  46
  47 #endif
  48
  49
  50 luabind::detail::class_rep::class_rep(LUABIND_TYPE_INFO type
  51         , const char* name
  52         , lua_State* L
  53         ,  void(*destructor)(void*)
  54         ,  void(*const_holder_destructor)(void*)
  55         , LUABIND_TYPE_INFO holder_type
  56         , LUABIND_TYPE_INFO const_holder_type
  57         , void*(*extractor)(void*)
  58         , const void*(*const_extractor)(void*)
  59         , void(*const_converter)(void*,void*)
  60         , void(*construct_holder)(void*,void*)
  61         , void(*construct_const_holder)(void*,void*)
  62         , int holder_size
  63         , int holder_alignment)
  64
  65         : m_type(type)
  66         , m_holder_type(holder_type)
  67         , m_const_holder_type(const_holder_type)
  68         , m_extractor(extractor)
  69         , m_const_extractor(const_extractor)
  70         , m_const_converter(const_converter)
  71         , m_construct_holder(construct_holder)
  72         , m_construct_const_holder(construct_const_holder)
  73         , m_holder_size(holder_size)
  74         , m_holder_alignment(holder_alignment)
  75         , m_name(name)
  76         , m_table_ref(LUA_NOREF)
  77         , m_class_type(cpp_class)
  78         , m_destructor(destructor)
  79         , m_const_holder_destructor(const_holder_destructor)
  80         , m_operator_cache(0)
  81 {
  82         assert(m_holder_alignment >= 1 && "internal error");
  83
  84         lua_newtable(L);
  85         m_table_ref = detail::ref(L);
  86
  87         class_registry* r = class_registry::get_registry(L);
  88         assert((r->cpp_class() != LUA_NOREF) && "you must call luabind::open()");
  89
  90         detail::getref(L, r->cpp_class());
  91         lua_setmetatable(L, -2);
  92
  93         lua_pushvalue(L, -1); // duplicate our user data
  94         m_self_ref = detail::ref(L); // pop one of them
  95
  96         m_instance_metatable = r->cpp_instance();
  97 }
  98
  99 luabind::detail::class_rep::class_rep(lua_State* L, const char* name)
 100         : m_type(LUABIND_INVALID_TYPE_INFO)
 101         , m_holder_type(LUABIND_INVALID_TYPE_INFO)
 102         , m_const_holder_type(LUABIND_INVALID_TYPE_INFO)
 103         , m_extractor(0)
 104         , m_const_extractor(0)
 105         , m_const_converter(0)
 106         , m_construct_holder(0)
 107         , m_construct_const_holder(0)
 108         , m_holder_size(0)
 109         , m_holder_alignment(1)
 110         , m_class_type(lua_class)
 111         , m_destructor(0)
 112         , m_const_holder_destructor(0)
 113         , m_operator_cache(0)
 114 {
 115 #ifndef LUABIND_DONT_COPY_STRINGS
 116         m_strings.push_back(detail::dup_string(name));
 117         m_name = m_strings.back();
 118 #else
 119         m_name = name;
 120 #endif
 121         lua_newtable(L);
 122         m_table_ref = detail::ref(L);
 123
 124         class_registry* r = class_registry::get_registry(L);
 125         assert((r->cpp_class() != LUA_NOREF) && "you must call luabind::open()");
 126
 127         detail::getref(L, r->lua_class());
 128         lua_setmetatable(L, -2);
 129         lua_pushvalue(L, -1); // duplicate our user data
 130         m_self_ref = detail::ref(L); // pop one of them
 131
 132         m_instance_metatable = r->lua_instance();
 133 }
 134
 135 luabind::detail::class_rep::~class_rep()
 136 {
 137 #ifndef LUABIND_DONT_COPY_STRINGS
 138         for (std::vector<char*>::iterator i = m_strings.begin();
 139                         i != m_strings.end(); ++i)
 140         {
 141                         delete[] *i;
 142         }
 143 #endif
 144 }
 145
 146 std::pair<void*,void*>
 147 luabind::detail::class_rep::allocate(lua_State* L) const
 148 {
 149         const int overlap = sizeof(object_rep)&(m_holder_alignment-1);
 150         const int padding = overlap==0?0:m_holder_alignment-overlap;
 151         const int size = sizeof(object_rep) + padding + m_holder_size;
 152
 153         char* mem = static_cast<char*>(lua_newuserdata(L, size));
 154         char* ptr = mem + sizeof(object_rep) + padding;
 155
 156         return std::pair<void*,void*>(mem,ptr);
 157 }
 158
 159 //#include <iostream>
 160 // lua stack: userdata, key
 161 int luabind::detail::class_rep::gettable(lua_State* L)
 162 {
 163         // if key is nil, return nil
 164         if (lua_isnil(L, 2))
 165         {
 166                 lua_pushnil(L);
 167                 return 1;
 168         }
 169
 170         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 171
 172         // we have to ignore the first argument since this may point to
 173         // a method that is not present in this class (but in a subclass)
 174         const char* key = lua_tostring(L, 2);
 175
 176         // special case to see if this is a null-pointer
 177         if (key && !std::strcmp(key, "__ok"))
 178         {
 179                 class_rep* crep = obj->crep();
 180
 181                 void* p = crep->extractor() ? crep->extractor()(obj->ptr())
 182                         : obj->ptr();
 183
 184                 lua_pushboolean(L, p != 0);
 185                 return 1;
 186         }
 187
 188         detail::getref(L, obj->crep()->table_ref());
 189         lua_pushvalue(L, 2);
 190         lua_gettable(L, -2);
 191
 192         if (!lua_isnil(L, -1))
 193         {
 194 //              std::cout << "method found in lua table: " << key << "\n";
 195                 lua_remove(L, -2); // more table
 196                 return 1;
 197         }
 198
 199         lua_pop(L, 2);
 200 /*
 201         std::map<const char*, method_rep, ltstr>::iterator i = m_methods.find(key);
 202
 203         if (i != m_methods.end())
 204         {
 205                 // the name is a method, return it
 206                 lua_pushlightuserdata(L, &i->second);
 207                 lua_pushcclosure(L, function_dispatcher, 1);
 208                 return 1;
 209         }
 210 */
 211         std::map<const char*, callback, ltstr>::iterator j = m_getters.find(key);
 212         if (j != m_getters.end())
 213         {
 214                 // the name is a data member
 215                 return j->second.func(L, j->second.pointer_offset);
 216         }
 217
 218         lua_pushnil(L);
 219         return 1;
 220 }
 221
 222 // called from the metamethod for __newindex
 223 // the object pointer is passed on the lua stack
 224 // lua stack: userdata, key, value
 225 bool luabind::detail::class_rep::settable(lua_State* L)
 226 {
 227         // if the key is 'nil' fail
 228         if (lua_isnil(L, 2)) return false;
 229
 230         // we have to ignore the first argument since this may point to
 231         // a method that is not present in this class (but in a subclass)
 232         const char* key = lua_tostring(L, 2);
 233         std::map<const char*, callback, ltstr>::iterator j = m_setters.find(key);
 234         if (j != m_setters.end())
 235         {
 236                 // the name is a data member
 237                 j->second.func(L, j->second.pointer_offset);
 238                 return true;
 239         }
 240
 241         if (m_getters.find(key) != m_getters.end())
 242         {
 243                 // this means that we have a getter but no
 244                 // setter for an attribute. We will then fail
 245                 // because that attribute is read-only
 246                 return false;
 247         }
 248
 249         // set the attribute to the object's table
 250         getref(L, table_ref());
 251         lua_pushvalue(L, 2);
 252         lua_pushvalue(L, 3);
 253         lua_settable(L, 4);
 254         lua_pop(L, 3);
 255         return true;
 256 }
 257
 258  int class_rep::gettable_dispatcher(lua_State* L)
 259 {
 260         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 261         return obj->crep()->gettable(L);
 262 }
 263
 264 // this is called as __newindex metamethod on every instance of this class
 265  int luabind::detail::class_rep::settable_dispatcher(lua_State* L)
 266 {
 267         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
 268
 269         bool success = obj->crep()->settable(L);
 270
 271 #ifndef LUABIND_NO_ERROR_CHECKING
 272
 273         if (!success)
 274         {
 275                 // this block is needed to make sure the std::string is destructed before
 276                 // lua_error() is called
 277 #ifdef BOOST_MSVC
 278                 {
 279                         // msvc has a bug which deletes the string twice, that's
 280                         // why we have to create it on the heap
 281                         std::string* msg = new std::string("cannot set attribute '");
 282                         *msg += obj->crep()->m_name;
 283                         *msg += ".";
 284                         *msg += lua_tostring(L, -2);
 285                         *msg += "'";
 286                         lua_pushstring(L, msg->c_str());
 287                         delete msg;
 288                 }
 289 #else
 290                 {
 291                         std::string msg = "cannot set attribute '";
 292                         msg += obj->crep()->m_name;
 293                         msg += ".";
 294                         msg += lua_tostring(L, -2);
 295                         msg += "'";
 296                         lua_pushstring(L, msg.c_str());
 297                 }
 298 #endif
 299                 lua_error(L);
 300         }
 301
 302 #endif
 303
 304         return 0;
 305 }
 306
 307
 308  int luabind::detail::class_rep::operator_dispatcher(lua_State* L)
 309 {
 310         int id = static_cast<int>(lua_tonumber(L, lua_upvalueindex(1)));
 311
 312         int operand_id = 0;
 313
 314         object_rep* operand[2];
 315         for (int i = 0; i < 2; ++i)
 316                 operand[i] = detail::is_class_object(L, i + 1);
 317
 318         // we cannot compare the types here, we have to compare the pointers of the class_reps
 319         // since all lua-classes have the same type (LUABIND_INVALID_TYPE_INFO)
 320         if (operand[0] && operand[1])
 321                 if (operand[0]->crep() == operand[1]->crep()) operand[1] = 0;
 322
 323         std::vector<operator_callback>* overloads[2];
 324         for (int i = 0; i < 2; ++i)
 325                 if (operand[i]) overloads[i] = &operand[i]->crep()->m_operators[id]; else overloads[i] = 0;
 326
 327         std::size_t num_overloads[2];
 328         for (int i = 0; i < 2; ++i)
 329                 if (overloads[i]) num_overloads[i] = overloads[i]->size(); else num_overloads[i] = 0;
 330
 331         for (int i = 0; i < 2; ++i)
 332                 if (operand[i] && operand[i]->crep()->get_class_type() == class_rep::lua_class)
 333                 {
 334 /*                      // if this is a lua class we have to
 335                         // look in its table to see if there's
 336                         // any overload of this operator
 337                         detail::getref(L, operand[i]->crep()->table_ref());
 338                         lua_pushstring(L, get_operator_name(id));
 339                         lua_rawget(L, -2);
 340                         // if we have tha operator, set num_overloads to 1
 341                         if (lua_isfunction(L, -1)) num_overloads[i] = 1;
 342                         lua_pop(L, 2);*/
 343
 344                         if (operand[i]->crep()->has_operator_in_lua(L, id))
 345                                 num_overloads[i] = 1;
 346                 }
 347
 348         bool ambiguous = false;
 349         int match_index = -1;
 350         int min_match = std::numeric_limits<int>::max();
 351
 352 #ifdef LUABIND_NO_ERROR_CHECKING
 353
 354         if (num_overloads[0] == 1 && num_overloads[1] == 0)
 355         {
 356                 operand_id = 0;
 357                 match_index = 0;
 358         }
 359         else if (num_overloads[0] == 0 && num_overloads[1] == 1)
 360         {
 361                 operand_id = 1;
 362                 match_index = 0;
 363         }
 364         else
 365         {
 366
 367 #endif
 368
 369                 int num_params = lua_gettop(L);
 370
 371                 // have look at the right operand.
 372                 // if the right operand is a class and
 373                 // not the same class as this, we have to
 374                 // try to match it's operators too
 375                 for (int i = 0; i < 2; ++i)
 376                 {
 377                         if (num_overloads[i])
 378                         {
 379                                 if (operand[i]->crep()->get_class_type() == class_rep::lua_class)
 380                                 {
 381                                         // if this is a lua class
 382                                         // and num_overloads is > 0
 383                                         // it means that it has implemented
 384                                         // this operator. Set match_index to
 385                                         // 0 to signal that this operand has
 386                                         // an overload, but leave the min_match
 387                                         // at int-max to mark it as a last fallback
 388                                         operand_id = i;
 389                                         if (match_index == -1) match_index = 0;
 390                                 }
 391                                 else if (find_best_match(
 392                                         L
 393                                         , &overloads[i]->front()
 394                                         , overloads[i]->size()
 395                                         , sizeof(operator_callback)
 396                                         , ambiguous
 397                                         , min_match
 398                                         , match_index
 399                                         , num_params))
 400                                 {
 401                                         operand_id = i;
 402                                 }
 403                         }
 404                 }
 405
 406
 407 #ifdef LUABIND_NO_ERROR_CHECKING
 408
 409         }
 410
 411 #else
 412
 413         if (match_index == -1)
 414         {
 415                 // this block is needed to make sure the std::string is destructed before
 416                 // lua_error() is called
 417                 {
 418                         std::string msg = "no operator ";
 419                         msg += get_operator_symbol(id);
 420                         msg += " matched the arguments (";
 421                         msg += stack_content_by_name(L, 1);
 422                         msg += ")\ncandidates are:\n";
 423
 424                         for (int i = 0; i < 2; ++i)
 425                         {
 426                                 if (overloads[i])
 427                                 {
 428                                         msg += get_overload_signatures(
 429                                                         L
 430                                                         , overloads[i]->begin()
 431                                                         , overloads[i]->end()
 432                                                         , get_operator_symbol(id));
 433                                 }
 434                                 else
 435                                 {
 436                                         // if num_overloads is > 0 it would mean that this is
 437                                         // a lua class with this operator overloaded. And if
 438                                         // that's the case, it should always match (and if an
 439                                         // operator matches, we never come here).
 440                                         assert(num_overloads[i] == 0 && "internal error");
 441                                 }
 442                         }
 443
 444                         lua_pushstring(L, msg.c_str());
 445                 }
 446                 lua_error(L);
 447         }
 448         else if (ambiguous)
 449         {
 450                 // this block is needed to make sure the std::string is destructed before
 451                 // lua_error() is called
 452                 {
 453                         std::string msg = "call of overloaded operator ";
 454                         msg += get_operator_symbol(id);
 455                         msg += " (";
 456                         msg += stack_content_by_name(L, 1);
 457                         msg += ")' is ambiguous\nnone of the overloads have a best conversion:\n";
 458
 459                         std::vector<const overload_rep_base*> candidates;
 460                         if (overloads[0])
 461                                 find_exact_match(L, &overloads[0]->front(), overloads[0]->size(), sizeof(operator_callback), min_match, num_params, candidates);
 462
 463                         if (overloads[1])
 464                                 find_exact_match(L, &overloads[1]->front(), overloads[1]->size(), sizeof(operator_callback), min_match, num_params, candidates);
 465
 466                         msg += get_overload_signatures_candidates(L, candidates.begin(), candidates.end(), get_operator_symbol(id));
 467
 468                         lua_pushstring(L, msg.c_str());
 469                 }
 470                 lua_error(L);
 471         }
 472
 473 #endif
 474
 475         if (operand[operand_id]->crep()->get_class_type() == class_rep::lua_class)
 476         {
 477                 detail::getref(L, operand[operand_id]->crep()->table_ref());
 478                 lua_pushstring(L, get_operator_name(id));
 479                 lua_rawget(L, -2);
 480                 lua_insert(L, -4); // move the function to the bottom
 481                 lua_pop(L, 1); // remove the table
 482                 lua_call(L, 2, 1);
 483                 return 1;
 484         }
 485         else
 486         {
 487                 return (*overloads[operand_id])[match_index].call(L);
 488         }
 489 }
 490
 491 // this is called as metamethod __call on the class_rep.
 492  int luabind::detail::class_rep::constructor_dispatcher(lua_State* L)
 493 {
 494         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
 495         construct_rep* rep = &crep->m_constructor;
 496
 497         bool ambiguous = false;
 498         int match_index = -1;
 499         int min_match = std::numeric_limits<int>::max();
 500         bool found;
 501
 502 #ifdef LUABIND_NO_ERROR_CHECKING
 503
 504         if (rep->overloads.size() == 1)
 505         {
 506                 match_index = 0;
 507         }
 508         else
 509         {
 510
 511 #endif
 512
 513                 int num_params = lua_gettop(L) - 1;
 514                 found = find_best_match(L, &rep->overloads.front(), rep->overloads.size(), sizeof(construct_rep::overload_t), ambiguous, min_match, match_index, num_params);
 515
 516 #ifdef LUABIND_NO_ERROR_CHECKING
 517         }
 518
 519 #else
 520
 521         if (!found)
 522         {
 523                 // this block is needed to make sure the std::string is destructed before
 524                 // lua_error() is called
 525                 {
 526                         std::string msg = "no constructor of '";
 527                         msg += crep->name();
 528                         msg += "' matched the arguments (";
 529                         msg += stack_content_by_name(L, 2);
 530                         msg += ")\n candidates are:\n";
 531
 532                         msg += get_overload_signatures(L, rep->overloads.begin(), rep->overloads.end(), crep->name());
 533
 534                         lua_pushstring(L, msg.c_str());
 535                 }
 536                 lua_error(L);
 537         }
 538         else if (ambiguous)
 539         {
 540                 // this block is needed to make sure the std::string is destructed before
 541                 // lua_error() is called
 542                 {
 543                         std::string msg = "call of overloaded constructor '";
 544                         msg += crep->m_name;
 545                         msg +=  "(";
 546                         msg += stack_content_by_name(L, 2);
 547                         msg += ")' is ambiguous\nnone of the overloads have a best conversion:\n";
 548
 549                         std::vector<const overload_rep_base*> candidates;
 550                         find_exact_match(L, &rep->overloads.front(), rep->overloads.size(), sizeof(construct_rep::overload_t), min_match, num_params, candidates);
 551                         msg += get_overload_signatures_candidates(L, candidates.begin(), candidates.end(), crep->name());
 552
 553                         lua_pushstring(L, msg.c_str());
 554                 }
 555                 lua_error(L);
 556         }
 557
 558 #endif
 559
 560 #ifndef LUABIND_NO_EXCEPTIONS
 561
 562         try
 563         {
 564
 565 #endif
 566
 567                 void* object_ptr = rep->overloads[match_index].construct(L);
 568
 569                 void* obj_rep;
 570                 void* held;
 571
 572                 boost::tie(obj_rep,held) = crep->allocate(L);
 573
 574                 if (crep->has_holder())
 575                 {
 576                         crep->m_construct_holder(held, object_ptr);
 577                         object_ptr = held;
 578                 }
 579                 new(obj_rep) object_rep(object_ptr, crep, object_rep::owner, crep->destructor());
 580
 581                 detail::getref(L, crep->m_instance_metatable);
 582                 lua_setmetatable(L, -2);
 583                 return 1;
 584
 585 #ifndef LUABIND_NO_EXCEPTIONS
 586
 587         }
 588
 589         catch(const std::exception& e)
 590         {
 591                 lua_pushstring(L, e.what());
 592         }
 593         catch(const char* s)
 594         {
 595                 lua_pushstring(L, s);
 596         }
 597         catch(...)
 598         {
 599                 {
 600                         std::string msg = crep->name();
 601                         msg += "() threw an exception";
 602                         lua_pushstring(L, msg.c_str());
 603                 }
 604         }
 605
 606         // we can only reach this line if an exception was thrown
 607         lua_error(L);
 608         return 0; // will never be reached
 609
 610 #endif
 611
 612 }
 613
 614 // the functions dispatcher assumes the following:
 615 // there is one upvalue that points to the method_rep that this dispatcher is to call
 616 // the first parameter on the lua stack is an object_rep that points to the object the
 617 // call is being made on
 618 int luabind::detail::class_rep::function_dispatcher(lua_State* L)
 619 {
 620         method_rep* rep = static_cast<method_rep*>(lua_touserdata(L, lua_upvalueindex(1)));
 621         object_rep* obj = reinterpret_cast<object_rep*>(lua_touserdata(L, 1));
 622
 623 #ifndef LUABIND_NO_ERROR_CHECKING
 624
 625         if (is_class_object(L, 1) == 0)
 626         {
 627                 {
 628                         std::string msg = "No self reference given as first parameter to member function '";
 629                         msg += rep->crep->name();
 630                         msg += ":";
 631                         msg += rep->name;
 632                         msg += "'. Have you used '.' instead of ':'?";
 633
 634                         lua_pushstring(L, msg.c_str());
 635                 }
 636                 lua_error(L);
 637         }
 638
 639         int p;
 640         if (implicit_cast(obj->crep(), rep->crep->type(), p) < 0)
 641         {
 642                 {
 643                         std::string msg = "invalid self reference given to '";
 644                         msg += rep->crep->name();
 645                         msg += ":";
 646                         msg += rep->name;
 647                         msg += "'";
 648                         lua_pushstring(L, msg.c_str());
 649                 }
 650                 lua_error(L);
 651         }
 652
 653 #endif
 654
 655         bool ambiguous = false;
 656         int match_index = -1;
 657         int min_match = std::numeric_limits<int>::max();
 658         bool found;
 659
 660 #ifdef LUABIND_NO_ERROR_CHECKING
 661         if (rep->overloads().size() == 1)
 662         {
 663                 match_index = 0;
 664         }
 665         else
 666         {
 667 #endif
 668
 669                 int num_params = lua_gettop(L) - 1;
 670                 found = find_best_match(L, &rep->overloads().front(), rep->overloads().size(), sizeof(overload_rep), ambiguous, min_match, match_index, num_params);
 671
 672 #ifdef LUABIND_NO_ERROR_CHECKING
 673
 674         }
 675
 676 #else
 677
 678         if (!found)
 679         {
 680                 {
 681                         std::string msg = "no overload of  '";
 682                         msg += rep->crep->name();
 683                         msg += ":";
 684                         msg += rep->name;
 685                         msg += "' matched the arguments (";
 686                         msg += stack_content_by_name(L, 2);
 687                         msg += ")\ncandidates are:\n";
 688
 689                         std::string function_name;
 690                         function_name += rep->crep->name();
 691                         function_name += ":";
 692                         function_name += rep->name;
 693
 694                         msg += get_overload_signatures(L, rep->overloads().begin(), rep->overloads().end(), function_name);
 695
 696                         lua_pushstring(L, msg.c_str());
 697                 }
 698                 lua_error(L);
 699         }
 700         else if (ambiguous)
 701         {
 702                 {
 703                         std::string msg = "call of overloaded  '";
 704                         msg += rep->crep->name();
 705                         msg += ":";
 706                         msg += rep->name;
 707                         msg += "(";
 708                         msg += stack_content_by_name(L, 2);
 709                         msg += ")' is ambiguous\nnone of the overloads have a best conversion:\n";
 710
 711                         std::vector<const overload_rep_base*> candidates;
 712                         find_exact_match(L, &rep->overloads().front(), rep->overloads().size(), sizeof(overload_rep), min_match, num_params, candidates);
 713
 714                         std::string function_name;
 715                         function_name += rep->crep->name();
 716                         function_name += ":";
 717                         function_name += rep->name;
 718
 719                         msg += get_overload_signatures_candidates(L, candidates.begin(), candidates.end(), function_name);
 720
 721                         lua_pushstring(L, msg.c_str());
 722                 }
 723                 lua_error(L);
 724         }
 725
 726 #endif
 727
 728 #ifndef LUABIND_NO_EXCEPTIONS
 729
 730         try
 731         {
 732
 733 #endif
 734
 735                 const overload_rep& o = rep->overloads()[match_index];
 736                 return o.call(L, *obj);
 737
 738 #ifndef LUABIND_NO_EXCEPTIONS
 739
 740         }
 741         catch(const std::exception& e)
 742         {
 743                 lua_pushstring(L, e.what());
 744         }
 745         catch (const char* s)
 746         {
 747                 lua_pushstring(L, s);
 748         }
 749         catch(...)
 750         {
 751                 std::string msg = rep->crep->name();
 752                 msg += ":";
 753                 msg += rep->name;
 754                 msg += "() threw an exception";
 755                 lua_pushstring(L, msg.c_str());
 756         }
 757         // we can only reach this line if an exception was thrown
 758         lua_error(L);
 759         return 0; // will never be reached
 760
 761 #endif
 762
 763 }
 764
 765 void luabind::detail::class_rep::add_base_class(const luabind::detail::class_rep::base_info& binfo)
 766 {
 767         // If you hit this assert you are deriving from a type that is not registered
 768         // in lua. That is, in the class_<> you are giving a baseclass that isn't registered.
 769         // Please note that if you don't need to have access to the base class or the
 770         // conversion from the derived class to the base class, you don't need
 771         // to tell luabind that it derives.
 772         assert(binfo.base && "You cannot derive from an unregistered type");
 773
 774         class_rep* bcrep = binfo.base;
 775
 776         // import all functions from the base
 777         for (std::map<const char*, method_rep, ltstr>::const_iterator i = bcrep->m_methods.begin();
 778                         i != bcrep->m_methods.end(); ++i)
 779         {
 780                 // If we would assume that our base class will not be garbage collected until
 781                 // this class is collected, we wouldn't had to copy these strings.
 782 #ifndef LUABIND_DONT_COPY_STRINGS
 783                 m_strings.push_back(dup_string(i->first));
 784                 method_rep& m = m_methods[m_strings.back()];
 785 #else
 786                 method_rep& m = m_methods[i->first];
 787 #endif
 788                 m.name = i->first;
 789                 m.crep = this;
 790
 791                 for (std::vector<overload_rep>::const_iterator j = i->second.overloads().begin();
 792                                 j != i->second.overloads().end(); ++j)
 793                 {
 794                         overload_rep o = *j;
 795                         o.add_offset(binfo.pointer_offset);
 796                         m.add_overload(o);
 797                 }
 798         }
 799
 800         // import all getters from the base
 801         for (std::map<const char*, callback, ltstr>::const_iterator i = bcrep->m_getters.begin();
 802                         i != bcrep->m_getters.end(); ++i)
 803         {
 804 #ifndef LUABIND_DONT_COPY_STRINGS
 805                 m_strings.push_back(dup_string(i->first));
 806                 callback& m = m_getters[m_strings.back()];
 807 #else
 808                 callback& m = m_getters[i->first];
 809 #endif
 810                 m.pointer_offset = i->second.pointer_offset + binfo.pointer_offset;
 811                 m.func = i->second.func;
 812         }
 813
 814         // import all setters from the base
 815         for (std::map<const char*, callback, ltstr>::const_iterator i = bcrep->m_setters.begin();
 816                         i != bcrep->m_setters.end(); ++i)
 817         {
 818 #ifndef LUABIND_DONT_COPY_STRINGS
 819                 // TODO: optimize this by not copying the string if it already exists in m_setters.
 820                 // This goes for m_getters, m_static_constants and m_functions too. Both here
 821                 // in add_base() and in the add_function(), add_getter() ... functions.
 822                 m_strings.push_back(dup_string(i->first));
 823                 callback& m = m_setters[m_strings.back()];
 824 #else
 825                 callback& m = m_setters[i->first];
 826 #endif
 827                 m.pointer_offset = i->second.pointer_offset + binfo.pointer_offset;
 828                 m.func = i->second.func;
 829         }
 830
 831         // import all static constants
 832         for (std::map<const char*, int, ltstr>::const_iterator i = bcrep->m_static_constants.begin();
 833                         i != bcrep->m_static_constants.end(); ++i)
 834         {
 835 #ifndef LUABIND_DONT_COPY_STRINGS
 836                 m_strings.push_back(dup_string(i->first));
 837                 int& v = m_static_constants[m_strings.back()];
 838 #else
 839                 int& v = m_static_constants[i->first];
 840 #endif
 841                 v = i->second;
 842         }
 843
 844         // import all operators
 845         for (int i = 0; i < number_of_operators; ++i)
 846         {
 847                 for (std::vector<operator_callback>::const_iterator j = bcrep->m_operators[i].begin();
 848                                 j != bcrep->m_operators[i].end(); ++j)
 849                         m_operators[i].push_back(*j);
 850         }
 851
 852         // also, save the baseclass info to be used for typecasts
 853         m_bases.push_back(binfo);
 854 }
 855 /*
 856 void luabind::detail::class_rep::add_function(const char* name, const overload_rep& o)
 857 {
 858
 859 #ifdef LUABIND_DONT_COPY_STRINGS
 860         detail::method_rep& method = m_methods[name];
 861         method.name = name;
 862 #else
 863         m_strings.push_back(dup_string(name));
 864         detail::method_rep& method = m_methods[m_strings.back()];
 865         method.name = m_strings.back();
 866 #endif
 867
 868         method.add_overload(o);
 869         method.crep = this;
 870 }
 871
 872 void luabind::detail::class_rep::add_getter(const char* name, const boost::function2<int, lua_State*, int>& g)
 873 {
 874         callback c;
 875         c.func = g;
 876         c.pointer_offset = 0;
 877 #ifndef LUABIND_DONT_COPY_STRINGS
 878         m_strings.push_back(dup_string(name));
 879         m_getters[m_strings.back()] = c;
 880 #else
 881         m_getters[name] = c;
 882 #endif
 883 }
 884
 885 void luabind::detail::class_rep::add_setter(const char* name, const boost::function2<int, lua_State*, int>& s)
 886 {
 887         callback c;
 888         c.func = s;
 889         c.pointer_offset = 0;
 890 #ifndef LUABIND_DONT_COPY_STRINGS
 891         m_strings.push_back(dup_string(name));
 892         m_setters[m_strings.back()] = c;
 893 #else
 894         m_setters[name] = c;
 895 #endif
 896 }
 897
 898 #ifndef LUABIND_NO_ERROR_CHECKING
 899 void luabind::detail::class_rep::add_operator(lua_State*, int op_id,  int(*func)(lua_State*), int(*matcher)(lua_State*), void(*sig)(lua_State*, std::string&), int arity)
 900 #else
 901 void luabind::detail::class_rep::add_operator(lua_State*, int op_id,  int(*func)(lua_State*), int(*matcher)(lua_State*), int arity)
 902 #endif
 903 {
 904         operator_callback o;
 905         o.set_fun(func);
 906         o.set_match_fun(matcher);
 907         o.set_arity(arity);
 908
 909 #ifndef LUABIND_NO_ERROR_CHECKING
 910
 911         o.set_sig_fun(sig);
 912
 913 #endif
 914         m_operators[op_id].push_back(o);
 915 }
 916
 917 void luabind::detail::class_rep::add_static_constant(const char* name, int val)
 918 {
 919 #ifndef LUABIND_DONT_COPY_STRINGS
 920         m_strings.push_back(dup_string(name));
 921         m_static_constants[m_strings.back()] = val;
 922 #else
 923         m_static_constants[name] = val;
 924 #endif
 925 }
 926 */
 927  int luabind::detail::class_rep::super_callback(lua_State* L)
 928 {
 929         int args = lua_gettop(L);
 930
 931         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, lua_upvalueindex(2)));
 932         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, lua_upvalueindex(1)));
 933         class_rep* base = crep->bases()[0].base;
 934
 935         if (base->get_class_type() == class_rep::lua_class)
 936         {
 937                 if (base->bases().empty())
 938                 {
 939                         obj->set_flags(obj->flags() & ~object_rep::call_super);
 940
 941                         lua_pushstring(L, "super");
 942                         lua_pushnil(L);
 943                         lua_settable(L, LUA_GLOBALSINDEX);
 944                 }
 945                 else
 946                 {
 947                         lua_pushstring(L, "super");
 948                         lua_pushlightuserdata(L, base);
 949                         lua_pushvalue(L, lua_upvalueindex(2));
 950                         lua_pushcclosure(L, super_callback, 2);
 951                         lua_settable(L, LUA_GLOBALSINDEX);
 952                 }
 953
 954                 detail::getref(L, base->table_ref());
 955                 lua_pushstring(L, "__init");
 956                 lua_gettable(L, -2);
 957                 lua_insert(L, 1);
 958                 lua_pop(L, 1);
 959
 960                 lua_pushvalue(L, lua_upvalueindex(2));
 961                 lua_insert(L, 2);
 962
 963                 lua_call(L, args + 1, 0);
 964
 965                 // TODO: instead of clearing the global variable "super"
 966                 // store it temporarily in the registry. maybe we should
 967                 // have some kind of warning if the super global is used?
 968                 lua_pushstring(L, "super");
 969                 lua_pushnil(L);
 970                 lua_settable(L, LUA_GLOBALSINDEX);
 971         }
 972         else
 973         {
 974                 obj->set_flags(obj->flags() & ~object_rep::call_super);
 975
 976                 // we need to push some garbage at index 1 to make the construction work
 977                 lua_pushboolean(L, 1);
 978                 lua_insert(L, 1);
 979
 980                 construct_rep* rep = &base->m_constructor;
 981
 982                 bool ambiguous = false;
 983                 int match_index = -1;
 984                 int min_match = std::numeric_limits<int>::max();
 985                 bool found;
 986
 987 #ifdef LUABIND_NO_ERROR_CHECKING
 988
 989                 if (rep->overloads.size() == 1)
 990                 {
 991                         match_index = 0;
 992                 }
 993                 else
 994                 {
 995
 996 #endif
 997
 998                         int num_params = lua_gettop(L) - 1;
 999                         found = find_best_match(L, &rep->overloads.front(), rep->overloads.size(), sizeof(construct_rep::overload_t), ambiguous, min_match, match_index, num_params);
1000
1001 #ifdef LUABIND_NO_ERROR_CHECKING
1002
1003                 }
1004
1005 #else
1006
1007                 if (!found)
1008                 {
1009                         {
1010                                 std::string msg = "no constructor of '";
1011                                 msg += base->m_name;
1012                                 msg += "' matched the arguments (";
1013                                 msg += stack_content_by_name(L, 2);
1014                                 msg += ")";
1015                                 lua_pushstring(L, msg.c_str());
1016                         }
1017                         lua_error(L);
1018                 }
1019                 else if (ambiguous)
1020                 {
1021                         {
1022                                 std::string msg = "call of overloaded constructor '";
1023                                 msg += base->m_name;
1024                                 msg +=  "(";
1025                                 msg += stack_content_by_name(L, 2);
1026                                 msg += ")' is ambiguous";
1027                                 lua_pushstring(L, msg.c_str());
1028                         }
1029                         lua_error(L);
1030                 }
1031
1032                         // TODO: should this be a warning or something?
1033 /*
1034                         // since the derived class is a lua class
1035                         // it may have reimplemented virtual functions
1036                         // therefore, we have to instantiate the Basewrapper
1037                         // if there is no basewrapper, throw a run-time error
1038                         if (!rep->overloads[match_index].has_wrapped_construct())
1039                         {
1040                                 {
1041                                         std::string msg = "Cannot derive from C++ class '";
1042                                         msg += base->name();
1043                                         msg += "'. It does not have a wrapped type";
1044                                         lua_pushstring(L, msg.c_str());
1045                                 }
1046                                 lua_error(L);
1047                         }
1048 */
1049 #endif
1050
1051 #ifndef LUABIND_NO_EXCEPTIONS
1052
1053                 try
1054                 {
1055
1056 #endif
1057
1058                         if (!rep->overloads[match_index].has_wrapped_construct())
1059                         {
1060                                 // if the type doesn't have a wrapped type, use the ordinary constructor
1061                                 obj->set_object(rep->overloads[match_index].construct(L));
1062                         }
1063                         else
1064                         {
1065                                 // get reference to lua object
1066                                 lua_pushvalue(L, lua_upvalueindex(2));
1067                                 int ref = detail::ref(L);
1068                                 obj->set_object(rep->overloads[match_index].construct_wrapped(L, ref));
1069                         }
1070                         // TODO: is the wrapped type destructed correctly?
1071                         // it should, since the destructor is either the wrapped type's
1072                         // destructor or the base type's destructor, depending on wether
1073                         // the type has a wrapped type or not.
1074                         obj->set_destructor(base->destructor());
1075                         return 0;
1076
1077 #ifndef LUABIND_NO_EXCEPTIONS
1078
1079                 }
1080                 catch(const std::exception& e)
1081                 {
1082                         lua_pushstring(L, e.what());
1083                 }
1084                 catch(const char* s)
1085                 {
1086                         lua_pushstring(L, s);
1087                 }
1088                 catch(...)
1089                 {
1090                         std::string msg = base->m_name;
1091                         msg += "() threw an exception";
1092                         lua_pushstring(L, msg.c_str());
1093                 }
1094                 // can only be reached if an exception was thrown
1095                 lua_error(L);
1096 #endif
1097         }
1098
1099         return 0;
1100
1101 }
1102
1103
1104
1105  int luabind::detail::class_rep::lua_settable_dispatcher(lua_State* L)
1106 {
1107         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
1108         detail::getref(L, crep->m_table_ref);
1109         lua_replace(L, 1);
1110         lua_rawset(L, -3);
1111
1112         crep->m_operator_cache = 0; // invalidate cache
1113
1114         return 0;
1115 }
1116
1117  int luabind::detail::class_rep::construct_lua_class_callback(lua_State* L)
1118 {
1119         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
1120
1121         int args = lua_gettop(L);
1122
1123         // lua stack: crep <arguments>
1124
1125         lua_newtable(L);
1126         int ref = detail::ref(L);
1127
1128         bool has_bases = !crep->bases().empty();
1129
1130         if (has_bases)
1131         {
1132                 lua_pushstring(L, "super");
1133                 lua_pushvalue(L, 1); // crep
1134         }
1135
1136         // lua stack: crep <arguments> "super" crep
1137         // or
1138         // lua stack: crep <arguments>
1139
1140         // if we have a baseclass we set the flag to say that the super has not yet been called
1141         // we will use this flag later to check that it actually was called from __init()
1142         int flags = object_rep::lua_class | object_rep::owner | (has_bases ? object_rep::call_super : 0);
1143
1144         void* obj_ptr = lua_newuserdata(L, sizeof(object_rep));
1145         new(obj_ptr) object_rep(crep, flags, ref);
1146
1147         detail::getref(L, crep->metatable_ref());
1148         lua_setmetatable(L, -2);
1149
1150         // lua stack: crep <arguments> "super" crep obj_ptr
1151         // or
1152         // lua stack: crep <arguments> obj_ptr
1153
1154         if (has_bases)  lua_pushvalue(L, -1); // obj_ptr
1155         lua_replace(L, 1); // obj_ptr
1156
1157         // lua stack: obj_ptr <arguments> "super" crep obj_ptr
1158         // or
1159         // lua stack: obj_ptr <arguments>
1160
1161         if (has_bases)
1162         {
1163                 lua_pushcclosure(L, super_callback, 2);
1164                 // lua stack: crep <arguments> "super" function
1165                 lua_settable(L, LUA_GLOBALSINDEX);
1166         }
1167
1168         // lua stack: crep <arguments>
1169
1170         lua_pushvalue(L, 1);
1171         lua_insert(L, 1);
1172
1173         detail::getref(L, crep->table_ref());
1174         lua_pushstring(L, "__init");
1175         lua_gettable(L, -2);
1176
1177 #ifndef LUABIND_NO_ERROR_CHECKING
1178
1179         // TODO: should this be a run-time error?
1180         // maybe the default behavior should be to just call
1181         // the base calss' constructor. We should register
1182         // the super callback funktion as __init
1183         if (!lua_isfunction(L, -1))
1184         {
1185                 {
1186                         std::string msg = crep->name();
1187                         msg += ":__init is not defined";
1188                         lua_pushstring(L, msg.c_str());
1189                 }
1190                 lua_error(L);
1191         }
1192
1193 #endif
1194
1195         lua_insert(L, 2); // function first on stack
1196         lua_pop(L, 1);
1197         // TODO: lua_call may invoke longjump! make sure we don't have any memory leaks!
1198         // we don't have any stack objects here
1199         lua_call(L, args, 0);
1200
1201 #ifndef LUABIND_NO_ERROR_CHECKING
1202
1203         object_rep* obj = static_cast<object_rep*>(obj_ptr);
1204         if (obj->flags() & object_rep::call_super)
1205         {
1206                 lua_pushstring(L, "derived class must call super on base");
1207                 lua_error(L);
1208         }
1209
1210 #endif
1211
1212         return 1;
1213 }
1214
1215 // called from the metamethod for __index
1216 // obj is the object pointer
1217  int luabind::detail::class_rep::lua_class_gettable(lua_State* L)
1218 {
1219         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
1220         class_rep* crep = obj->crep();
1221
1222 #ifndef LUABIND_NO_ERROR_CHECKING
1223
1224         if (obj->flags() & object_rep::call_super)
1225         {
1226                 lua_pushstring(L, "derived class must call super on base");
1227                 lua_error(L);
1228         }
1229
1230 #endif
1231
1232         // we have to ignore the first argument since this may point to
1233         // a method that is not present in this class (but in a subclass)
1234         const char* key = lua_tostring(L, 2);
1235
1236         if (key && !std::strcmp(key, "__ok"))
1237         {
1238                 class_rep* crep = obj->crep();
1239
1240                 void* p = crep->extractor() ? crep->extractor()(obj->ptr())
1241                         : obj->ptr();
1242
1243                 lua_pushboolean(L, p != 0);
1244                 return 1;
1245         }
1246
1247         detail::getref(L, obj->lua_table_ref());
1248         lua_pushvalue(L, 2);
1249         lua_gettable(L, -2);
1250
1251         if (!lua_isnil(L, -1))
1252         {
1253                 lua_remove(L, -2); // remove table
1254                 return 1;
1255         }
1256
1257         lua_pop(L, 2);
1258
1259         detail::getref(L, crep->table_ref());
1260         lua_pushvalue(L, 2);
1261         lua_gettable(L, -2);
1262
1263         if (!lua_isnil(L, -1))
1264         {
1265                 lua_remove(L, -2); // more table
1266                 return 1;
1267         }
1268
1269         lua_pop(L, 2);
1270
1271         if (lua_isnil(L, 2))
1272         {
1273                 lua_pushnil(L);
1274                 return 1;
1275         }
1276
1277         std::map<const char*, method_rep, ltstr>::iterator i = crep->m_methods.find(key);
1278         if (i != crep->m_methods.end())
1279         {
1280                 // the name is a method, return it
1281                 lua_pushlightuserdata(L, &i->second);
1282                 lua_pushcclosure(L, class_rep::function_dispatcher, 1);
1283                 return 1;
1284         }
1285
1286         std::map<const char*, class_rep::callback, ltstr>::iterator j = crep->m_getters.find(key);
1287         if (j != crep->m_getters.end())
1288         {
1289                 // the name is a data member
1290                 return j->second.func(L, j->second.pointer_offset);
1291         }
1292
1293         lua_pushnil(L);
1294         return 1;
1295 }
1296
1297 // called from the metamethod for __newindex
1298 // obj is the object pointer
1299  int luabind::detail::class_rep::lua_class_settable(lua_State* L)
1300 {
1301         object_rep* obj = static_cast<object_rep*>(lua_touserdata(L, 1));
1302         class_rep* crep = obj->crep();
1303
1304 #ifndef LUABIND_NO_ERROR_CHECKING
1305
1306         if (obj->flags() & object_rep::call_super)
1307         {
1308                 // this block makes sure the std::string is destructed
1309                 // before lua_error is called
1310                 {
1311                         std::string msg = "derived class '";
1312                         msg += crep->name();
1313                         msg += "'must call super on base";
1314                         lua_pushstring(L, msg.c_str());
1315                 }
1316                 lua_error(L);
1317         }
1318
1319 #endif
1320
1321         // we have to ignore the first argument since this may point to
1322         // a method that is not present in this class (but in a subclass)
1323         const char* key = lua_tostring(L, 2);
1324         std::map<const char*, class_rep::callback, ltstr>::iterator j = crep->m_setters.find(key);
1325
1326         if (j == crep->m_setters.end())
1327         {
1328                 std::map<const char*, class_rep::callback, ltstr>::iterator k = crep->m_getters.find(key);
1329
1330 #ifndef LUABIND_NO_ERROR_CHECKING
1331
1332                 if (k != crep->m_getters.end())
1333                 {
1334                         {
1335                                 std::string msg = "cannot set property '";
1336                                 msg += crep->name();
1337                                 msg += ".";
1338                                 msg += key;
1339                                 msg += "', because it's read only";
1340                                 lua_pushstring(L, msg.c_str());
1341                         }
1342                         lua_error(L);
1343                 }
1344
1345 #endif
1346
1347                 detail::getref(L, obj->lua_table_ref());
1348                 lua_replace(L, 1);
1349                 lua_settable(L, 1);
1350         }
1351         else
1352         {
1353                 // the name is a data member
1354                 j->second.func(L, j->second.pointer_offset);
1355         }
1356
1357         return 0;
1358 }
1359
1360  int luabind::detail::class_rep::static_class_gettable(lua_State* L)
1361 {
1362         class_rep* crep = static_cast<class_rep*>(lua_touserdata(L, 1));
1363
1364 // this has changed! c++ classes now also store their methods in the table
1365 //      if (crep->get_class_type() == class_rep::lua_class)
1366         {
1367                 detail::getref(L, crep->m_table_ref);
1368                 lua_pushvalue(L, 2);
1369                 lua_gettable(L, -2);
1370                 if (!lua_isnil(L, -1)) return 1;
1371                 else lua_pop(L, 2);
1372         }
1373
1374         const char* key = lua_tostring(L, 2);
1375
1376         std::map<const char*, method_rep, ltstr>::iterator i = crep->m_methods.find(key);
1377         if (i != crep->m_methods.end())
1378         {
1379                 // the name is a method, return it
1380                 lua_pushlightuserdata(L, &i->second);
1381                 lua_pushcclosure(L, class_rep::function_dispatcher, 1);
1382                 return 1;
1383         }
1384
1385 #ifndef LUABIND_NO_ERROR_CHECKING
1386
1387         std::map<const char*, int, ltstr>::const_iterator j = crep->m_static_constants.find(key);
1388
1389         if (j != crep->m_static_constants.end())
1390         {
1391                 lua_pushnumber(L, j->second);
1392                 return 1;
1393         }
1394
1395         {
1396                 std::string msg = "no static '";
1397                 msg += key;
1398                 msg += "' in class '";
1399                 msg += crep->name();
1400                 msg += "'";
1401                 lua_pushstring(L, msg.c_str());
1402         }
1403         lua_error(L);
1404
1405 #endif
1406
1407         return 0;
1408 }
1409
1410 bool luabind::detail::is_class_rep(lua_State* L, int index)
1411 {
1412         if (lua_getmetatable(L, index) == 0) return false;
1413
1414         lua_pushstring(L, "__luabind_classrep");
1415         lua_gettable(L, -2);
1416         if (lua_toboolean(L, -1))
1417         {
1418                 lua_pop(L, 2);
1419                 return true;
1420         }
1421
1422         lua_pop(L, 2);
1423         return false;
1424 }
1425
1426 void luabind::detail::finalize(lua_State* L, class_rep* crep)
1427 {
1428         if (crep->get_class_type() != class_rep::lua_class) return;
1429
1430 //      lua_pushvalue(L, -1); // copy the object ref
1431         detail::getref(L, crep->table_ref());
1432         lua_pushstring(L, "__finalize");
1433         lua_gettable(L, -2);
1434         lua_remove(L, -2);
1435
1436         if (lua_isnil(L, -1))
1437         {
1438                 lua_pop(L, 1);
1439         }
1440         else
1441         {
1442                 lua_pushvalue(L, -2);
1443                 lua_call(L, 1, 0);
1444         }
1445
1446         for (std::vector<class_rep::base_info>::const_iterator
1447                         i = crep->bases().begin(); i != crep->bases().end(); ++i)
1448         {
1449                 if (i->base) finalize(L, i->base);
1450         }
1451 }
1452
1453 void* luabind::detail::class_rep::convert_to(LUABIND_TYPE_INFO target_type, const object_rep* obj, void* target_memory) const
1454 {
1455         // TODO: since this is a member function, we don't have to use the accesor functions for
1456         // the types and the extractor
1457
1458         int steps = 0;
1459         int offset = 0;
1460         if (!(LUABIND_TYPE_INFO_EQUAL(obj->crep()->holder_type(), target_type))
1461                 && !(LUABIND_TYPE_INFO_EQUAL(obj->crep()->const_holder_type(), target_type)))
1462         {
1463                 steps = implicit_cast(this, target_type, offset);
1464         }
1465
1466         // should never be called with a type that can't be cast
1467         assert((steps >= 0) && "internal error, please report");
1468
1469         if (LUABIND_TYPE_INFO_EQUAL(target_type, holder_type()))
1470         {
1471                 // if the type we are trying to convert to is the holder_type
1472                 // it means that his crep has a holder_type (since it would have
1473                 // been invalid otherwise, and T cannot be invalid). It also means
1474                 // that we need no conversion, since the holder_type is what the
1475                 // object points to.
1476                 return obj->ptr();
1477         }
1478
1479         if (LUABIND_TYPE_INFO_EQUAL(target_type, const_holder_type()))
1480         {
1481                 if (obj->flags() & object_rep::constant)
1482                 {
1483                         // we are holding a constant
1484                         return obj->ptr();
1485                 }
1486                 else
1487                 {
1488                         // we are holding a non-constant, we need to convert it
1489                         // to a const_holder.
1490                         m_const_converter(obj->ptr(), target_memory);
1491                         return target_memory;
1492                 }
1493         }
1494
1495         void* raw_pointer;
1496
1497         if (has_holder())
1498         {
1499                 // this means that we have a holder type where the
1500                 // raw-pointer needs to be extracted
1501                 raw_pointer = extractor()(obj->ptr());
1502         }
1503         else
1504         {
1505                 raw_pointer = obj->ptr();
1506         }
1507
1508         return static_cast<char*>(raw_pointer) + offset;
1509 }
1510
1511 void luabind::detail::class_rep::cache_operators(lua_State* L)
1512 {
1513         m_operator_cache = 0x1;
1514
1515         for (int i = 0; i < number_of_operators; ++i)
1516         {
1517                 getref(L, table_ref());
1518                 lua_pushstring(L, get_operator_name(i));
1519                 lua_rawget(L, -2);
1520
1521                 if (lua_isfunction(L, -1)) m_operator_cache |= 1 << (i + 1);
1522
1523                 lua_pop(L, 2);
1524         }
1525 }
1526
1527 bool luabind::detail::class_rep::has_operator_in_lua(lua_State* L, int id)
1528 {
1529         if ((m_operator_cache & 0x1) == 0)
1530                 cache_operators(L);
1531
1532         const int mask = 1 << (id + 1);
1533
1534         return (m_operator_cache & mask) != 0;
1535 }
1536
1537 void luabind::detail::class_rep::add_method(lua_State* L, const char* name, detail::method_rep& m)
1538 {
1539         detail::getref(L, table_ref());
1540         lua_pushstring(L, name);
1541         lua_gettable(L, -2);
1542
1543         if (lua_isnil(L, -1) || !lua_iscfunction(L, -1))
1544         {
1545                 lua_pop(L, 1);
1546                 lua_pushstring(L, name);
1547                 lua_pushlightuserdata(L, const_cast<void*>((const void*)&m));
1548                 lua_pushcclosure(L, function_dispatcher, 1);
1549                 lua_settable(L, -3);
1550                 lua_pop(L, 1);
1551         }
1552         else
1553         {
1554                 lua_getupvalue(L, -1, 1);
1555                 method_rep* inherited = static_cast<method_rep*>(lua_touserdata(L, -1));
1556
1557                 for (std::vector<overload_rep>::const_iterator i = inherited->overloads().begin();
1558                                 i !=  inherited->overloads().end(); ++i)
1559                 {
1560                         m.add_overload(*i);
1561                 }
1562
1563                 detail::getref(L, table_ref());
1564                 lua_pushstring(L, name);
1565                 lua_pushlightuserdata(L, const_cast<void*>((const void*)&m));
1566                 lua_pushcclosure(L, function_dispatcher, 1);
1567                 lua_settable(L, -3);
1568                 lua_pop(L, 4);
1569         }
1570 }
1571
1572 const class_rep::property_map& luabind::detail::class_rep::properties() const
1573 {
1574         return m_getters;
1575 }
1576