luaxx.cc

Go to the documentation of this file.

/* vim: set et sw=3 tw=0 fo=croqlaw cino=t0:
 *
 * Luaxx, the C++ Lua wrapper library.
 * Copyright (c) 2006-2008 Matthew Nicholson
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy 
 * of this software and associated documentation files (the "Software"), to 
 * deal in the Software without restriction, including without limitation the 
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
 * sell copies of the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
 * IN THE SOFTWARE. 
 */

#include <luaxx/luaxx.hpp>

namespace lua
{
   state::state() : L(luaL_newstate()), managed(true) {
      if (L == NULL)
         throw bad_alloc("Error creating lua state");
   }

   state::state(lua_State* L) :
      L(L), managed(false) {
   }

   state::~state() {
      if (managed)
         lua_close(L);
   }

   state& state::push() {
      lua_pushnil(L);
      return *this;
   }
   
   state& state::push(nil) {
      lua_pushnil(L);
      return *this;
   }

   state& state::push(bool boolean) {
      lua_pushboolean(L, boolean);
      return *this;
   }
   
   state& state::push(const char* s, size_t length) {
      lua_pushlstring(L, s, length);
      return *this;
   }

   state& state::push(const char* s) {
      lua_pushstring(L, s);
      return *this;
   }

   state& state::push(const std::string& s) {
      lua_pushlstring(L, s.c_str(), s.size());
      return *this;
   }
   
   state& state::push(cfunction f) {
      lua_pushcfunction(L, f);
      return *this;
   }
   
   state& state::push(table) {
      lua_newtable(L);
      return *this;
   }

   state& state::push(void* p) {
      lua_pushlightuserdata(L, p);
      return *this;
   }

   template<>
   std::string state::as(std::string default_value, int index) {
      if (lua_isstring(L, index))
         return std::string(lua_tostring(L, index), lua_strlen(L, index));
      else
         return default_value;
   }
   
   state& state::check(int narg) {
      luaL_checkany(L, narg);
      return *this;
   }
   
#if lua_Integer != int

   state& state::check(int& i, int narg) {
      i = luaL_checkint(L, narg);
      return *this;
   }
#endif

   state& state::check(integer& i, int narg) {
      i = luaL_checkinteger(L, narg);
      return *this;
   }

#if lua_Integer != long

   state& state::check(long& l, int narg) {
      l = luaL_checklong(L, narg);
      return *this;
   }
#endif

   state& state::check(std::string& s, int narg) {
      const char* c;
      size_t l;
      c = luaL_checklstring(L, narg, &l);

      s.assign(c, l);

      return *this;
   }

   state& state::check(number& n, int narg) {
      n = luaL_checknumber(L, narg);
      return *this;
   }

#if 0

   template<>
   void state::error(const std::string& message) {
      push(message);
      lua_error(L);
   }
#endif

   state& state::pcall(int nargs, int nresults, int on_error) {
      throw_error(lua_pcall(L, nargs, nresults, on_error));
      return *this;
   }
   
   state& state::call(int nargs, int nresults) {
      lua_call(L, nargs, nresults);
      return *this;
   }
   
   state& state::checkstack(int size) {
      if (!lua_checkstack(L, size))
         throw lua::exception("Error growing the stack");
      return *this;
   }

   state& state::settop(int index) {
      lua_settop(L, index);
      return *this;
   }

   int state::gettop() {
      return lua_gettop(L);
   }

   int state::size() {
      return lua_gettop(L);
   }
   
   bool state::empty() {
      return !lua_gettop(L);
   }

   state& state::insert(int index) {
      lua_insert(L, index);
      return *this;
   }
   
   state& state::replace(int index) {
      lua_replace(L, index);
      return *this;
   }

   state& state::remove(int index) {
      lua_remove(L, index);
      return *this;
   }

   state& state::pop(int elements) {
      lua_pop(L, elements);
      return *this;
   }

   state& state::pushvalue(int index) {
      lua_pushvalue(L, index);
      return *this;
   }
   
   state& state::newtable() {
      lua_newtable(L);
      return *this;
   }

   bool state::newmetatable(const std::string& tname) {
      return luaL_newmetatable(L, tname.c_str());
   }

   void* state::newuserdata(size_t nbytes) {
      return lua_newuserdata(L, nbytes);
   }

   state& state::gettable(int index) {
      lua_gettable(L, index);
      return *this;
   }
   
   state& state::getfield(const std::string& k, int index) {
      lua_getfield(L, index, k.c_str());
      return *this;
   }
   
   state& state::settable(int index) {
      lua_settable(L, index);
      return *this;
   }

   state& state::setfield(const std::string& k, int index) {
      lua_setfield(L, index, k.c_str());
      return *this;
   }

   state& state::getmetatable(const std::string& tname) {
      luaL_getmetatable(L, tname.c_str());
      return *this;
   }

   bool state::getmetatable(int index) {
      return lua_getmetatable(L, index);
   }

   bool state::next(int index) {
      return lua_next(L, index);
   }

   state& state::getglobal(const std::string& name) {
      lua_getglobal(L, name.c_str());
      return *this;
   }

   state& state::setglobal(const std::string& name) {
      lua_setglobal(L, name.c_str());
      return *this;
   }

   state& state::loadfile(const std::string& filename) {
      throw_error(luaL_loadfile(L, filename.c_str()));
      return *this;
   }

   state& state::loadstring(const std::string& s) {
      throw_error(luaL_loadstring(L, s.c_str()));
      return *this;
   }

   size_t state::objlen(int index) {
      return lua_objlen(L, index);
   }

   template<>
   state& state::to(bool& boolean, int index) {
      if (lua_isboolean(L, index))
         boolean = lua_toboolean(L, index);
      else
         throw bad_conversion("Cannot convert non 'boolean' value to bool");

      return *this;
   }
         
   template<>
   state& state::to(std::string& string, int index) {
      if (lua_isstring(L, index))
         string.replace(0, std::string::npos, lua_tostring(L, index), lua_strlen(L, index));
      else
         throw bad_conversion("Cannot convert value to string");

      return *this;
   }

   template<>
   bool state::as(bool default_value, int index) {
      if (lua_isboolean(L, index))
         return lua_toboolean(L, index);
      else
         return default_value;
   }
   
   template<>
   bool state::as(int index) {
      if (lua_isboolean(L, index))
         return lua_toboolean(L, index);
      else
         throw bad_conversion("Cannot convert non 'boolean' value to bool");
   }
         
   template<>
   std::string state::as(int index) {
      if (lua_isstring(L, index))
         return std::string(lua_tostring(L, index), lua_strlen(L, index));
      else
         throw bad_conversion("Cannot convert value to string");
   }
         
   template<>
   bool state::is<nil>(int index) {
      return lua_isnil(L, index);
   }
   
   template<>
   bool state::is<bool>(int index) {
      return lua_isboolean(L, index);
   }

   template<>
   bool state::is<std::string>(int index) {
      return lua_isstring(L, index);
   }
   
   template<>
   bool state::is<table>(int index) {
      return lua_istable(L, index);
   }
   
   template<>
   bool state::is<cfunction>(int index) {
      return lua_iscfunction(L, index);
   }
   
   template<>
   bool state::is<function>(int index) {
      return lua_isfunction(L, index);
   }

   template<>
   bool state::is<userdata>(int index) {
      return lua_isuserdata(L, index);
   }

   template<>
   bool state::is<lightuserdata>(int index) {
      return lua_islightuserdata(L, index);
   }

}

---