lua.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_LUA_LUA_H
#define __SSRC_WSPR_LUA_LUA_H

namespace Lua {
#include <lua.hpp>
}

#include <ssrc/wispers-packages.h>

#include <string>
#include <stdexcept>

__BEGIN_NS_SSRC_WSPR_LUA

using namespace Lua;
using std::string;

template<typename R> inline R convert(lua_State *state, int index = -1);

template<> inline bool convert<bool>(lua_State *state, int index) {
  return lua_toboolean(state, index);
}

template<> inline int convert<int>(lua_State *state, int index) {
  return lua_tointeger(state, index);
}

template<> inline
unsigned int convert<unsigned int>(lua_State *state, int index) {
  return static_cast<unsigned int>(lua_tointeger(state, index));
}

template<> inline string convert<string>(lua_State *state, int index) {
  const char *str = lua_tolstring(state, index, static_cast<size_t*>(0));
  return (str != 0 ? str : string());
}

template<>
inline const char * convert<const char *>(lua_State *state, int index) {
  return lua_tolstring(state, index, static_cast<size_t*>(0));
}

template<> inline lua_Number convert<lua_Number>(lua_State *state, int index) {
  return lua_tonumber(state, index);
}

inline void push_value(lua_State *state, const bool value) {
  lua_pushboolean(state, value);
}

inline void push_value(lua_State *state, const int value) {
  lua_pushinteger(state, value);
}

inline void push_value(lua_State *state, const lua_Number value) {
  lua_pushnumber(state, value);
}

inline void push_value(lua_State *state, const char *value) {
  lua_pushstring(state, value);
}

inline void push_value(lua_State *state, const string & value) {
  lua_pushlstring(state, value.c_str(), value.size());
}

inline void push_value(lua_State *state, void *value) {
  lua_pushlightuserdata(state, value);
}

inline void push_value(lua_State *state, const void *value) {
  lua_pushlightuserdata(state, const_cast<void *>(value));
}

// This version is in order to support zero-arg pcall.
inline void push_values(lua_State *) { }

template<typename P>
inline void push_values(lua_State *state, const P & p) {
  push_value(state, p);
}

template<typename T, typename... P>
inline void push_values(lua_State *state, const T & t, const P & ...p) {
  push_value(state, t);
  push_values(state, p...);
}

template<typename V>
inline void set_field(lua_State* state, int index, const V & value,
                      const char * const field)
{
  push_value(state, value);
  lua_setfield(state, (index < 0 ? index - 1 : index), field);
}

template<typename V>
inline void set_field(lua_State* state, int index, const V & value,
                      const string & field)
{
  push_value(state, field);
  push_value(state, value);
  lua_settable(state, (index < 0 ? index - 2 : index));
}

template<typename V>
inline void set_field(lua_State* state, int index, const V & value, int n) {
  push_value(state, value);
  lua_rawseti(state, (index < 0 ? index - 1 : index), n);
}

namespace detail {
  inline
  void _get_field(lua_State* state, int index, const char * const field) {
    lua_getfield(state, index, field);
  }

  inline void _get_field(lua_State* state, int index, const string & field) {
    push_value(state, field);
    lua_gettable(state, (index < 0 ? index - 1 : index));
  }

  template<typename V>
  inline void _create_value(lua_State* state, const V & value,
                            const char * const field)
  {
    set_field(state, -1, value, field);
  }

  template<typename V>
  inline void _create_value(lua_State* state, const V & value,
                            const string & field)
  {
    set_field(state, -1, value, field);
  }

  template<typename V, typename... P> 
  inline void _create_value(lua_State* state, const V & value,
                            const char * const field, P...p)
  {
    lua_newtable(state);
    _create_value(state, value, p...);
    lua_setfield(state, -2, field);
  }

  template<typename V>
  inline void _set_value(lua_State* state, const V & value,
                         const char * const field)
  {
    set_field(state, -1, value, field);
  }

  template<typename V>
  inline void _set_value(lua_State* state, const V & value,
                         const string & field)
  {
    set_field(state, -1, value, field);
  }

  template<typename V, typename... P>
  inline void _set_value(lua_State* state, const V & value,
                         const char * const field, P...p)
  {
    _get_field(state, -1, field);
    _set_value(state, value, p...);
    lua_pop(state, 1);
  }
}

inline void get_global(lua_State* state, const char * const field) {
  lua_getglobal(state, field);
}

inline void get_global(lua_State* state, const string & field) {
  push_value(state, field);
  lua_gettable(state, LUA_GLOBALSINDEX);
}

template<typename V>
inline void set_global(lua_State* state, const V & value,
                       const char * const field)
{
  push_value(state, value);
  lua_setglobal(state, field);
}

template<typename V>
inline void set_global(lua_State* state, const V & value, const string & field)
{
  push_value(state, field);
  push_value(state, value);
  lua_settable(state, LUA_GLOBALSINDEX);
}

template<typename R>
inline const R get_field(const R & default_value,
                         lua_State* state,
                         int index,
                         const char * const field)
{
  lua_getfield(state, index, field);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : convert<R>(state));
  lua_pop(state, 1);
  return result;
}

template<typename R>
inline const R get_field(const R & default_value,
                         lua_State* state,
                         int index,
                         const string & field)
{
  detail::_get_field(state, index, field);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : convert<R>(state));
  lua_pop(state, 1);
  return result;
}

template<typename R>
inline const R get_field(const R & default_value,
                         lua_State* state,
                         int index,
                         int n)
{
  lua_rawgeti(state, index, n);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : convert<R>(state));
  lua_pop(state, 1);
  return result;
}

template<typename R, typename... P>
inline const R get_field(const R & default_value,
                         lua_State* state,
                         int index,
                         const char * const field,
                         P ...p)
{
  lua_getfield(state, index, field);
  const R & result = 
    (lua_isnoneornil(state, -1) ?
     default_value : get_field<R>(default_value, state, -1, p...));
  lua_pop(state, 1);
  return result;
}

template<typename R> inline
const R get_field(lua_State* state, int index, const char * const field) {
  return get_field(R(), state, index, field);
}

template<typename R> inline
const R get_field(lua_State* state, int index, const string & field) {
  return get_field(R(), state, index, field);
}

template<typename R> inline
const R get_field(lua_State* state, int index, int n) {
  return get_field(R(), state, index, n);
}

template<typename R, typename... P>
inline const R get_field(lua_State* state,
                         int index,
                         const char * const field,
                         P ...p)
{
  return get_field(R(), state, index, field, p...);
}

template<typename R>
inline const R get_value(const R & default_value,
                         lua_State* state,
                         const char * const var)
{
  get_global(state, var);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : convert<R>(state));
  lua_pop(state, 1);
  return result;
}

template<typename R>
inline const R get_value(const R & default_value,
                         lua_State* state,
                         const string & var)
{
  get_global(state, var);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : convert<R>(state));
  lua_pop(state, 1);
  return result;
}

template<typename R, typename... P>
inline const R get_value(const R & default_value,
                         lua_State* state,
                         const char * const var,
                         P ...p)
{
  get_global(state, var);
  const R & result =
    (lua_isnoneornil(state, -1) ? default_value : get_field<R>(state, -1, p...));
  lua_pop(state, 1);
  return result;
}

template<typename R>
inline const R get_value(lua_State* state, const char * const var) {
  return get_value(R(), state, var);
}

template<typename R>
inline const R get_value(lua_State* state, const string & var) {
  return get_value(R(), state, var);
}

template<typename R, typename... P>
inline const R get_value(lua_State* state, const char * const var, P ...p) {
  return get_value(R(), state, var, p...);
}

template<typename V>
inline void create_value(lua_State* state, const V & value,
                         const char * const var)
{
  set_global(state, value, var);
}

template<typename V>
inline void create_value(lua_State* state, const V & value,
                         const string & var)
{
  set_global(state, value, var);
}

template<typename V, typename... P> 
inline void create_value(lua_State* state, const V & value,
                         const char * const var, P ...p)
{
  lua_newtable(state);
  detail::_create_value(state, value, p...);
  lua_setglobal(state, var);
}

template<typename V, typename... P> 
inline void set_field(lua_State* state, int index, const V & value,
                      const char * const field, P ...p)
{
  lua_getfield(state, index, field);
  if(!lua_istable(state, -1)) {
    lua_pop(state, 1);
    lua_newtable(state);
    lua_setfield(state, (index < 0 ? index - 1 : index), field);
    lua_getfield(state, index, field);
  }
  set_field(state, -1, value, p...);
  lua_pop(state, 1);
}

template<typename V>
inline void set_value(lua_State* state, const V & value,
                      const char * const var)
{
  set_global(state, value, var);
}

template<typename V>
inline void set_value(lua_State* state, const V & value, const string & var) {
  set_global(state, value, var);
}

template<typename V, typename... P> 
inline void set_value(lua_State* state, const V & value,
                      const char * const var, P ...p)
{
  get_global(state, var);
  detail::_set_value(state, value, p...);
  lua_pop(state, 1);
}

template<typename I>
inline void
prepend_package_path(lua_State* state, const I & begin, const I & end) {
  string lua_path_str;
  lua_path_str.reserve(256);

  for(I it = begin; it != end; ++it) {
    lua_path_str.append(*it).append("/?.lua;");
  }

  get_global(state, "package");
  lua_getfield(state, -1, "path");
  lua_path_str.append(lua_tostring(state, -1));
  set_field(state, -2, lua_path_str, "path");
  lua_pop(state, 2);
}

struct LuaCallError : std::runtime_error {
  int lua_error;

  explicit LuaCallError(const string & message, const int lua_error) :
    std::runtime_error(message), lua_error(lua_error)
  {}
};

template<typename... P>
inline
void pcall_nopop(const int nargs, const int nresults, lua_State* state, P ...p)
  SSRC_DECL_THROW(LuaCallError)
{
  push_values(state, p...);

  int err = lua_pcall(state, nargs, nresults, 0);

  if(err) {
    string msg(lua_tostring(state, -1));
    lua_pop(state, 1);
    throw LuaCallError(msg, err);
  }
}

template<typename... P>
inline void pcall_nopop(const int nresults, lua_State* state, P ...p)
  SSRC_DECL_THROW(LuaCallError)
{
  pcall_nopop(sizeof...(P), nresults, state, p...);
}

template<typename R, typename... P>
inline R pcall_ret(lua_State* state, const P & ...p)
  SSRC_DECL_THROW(LuaCallError)
{
  pcall_nopop(1, state, p...);
  const R & result = convert<R>(state);
  lua_pop(state, 1);
  return result;
}

template<typename... P>
inline void pcall(lua_State* state, const P & ...p)
  SSRC_DECL_THROW(LuaCallError)
{
  pcall_nopop(0, state, p...);
}

__END_NS_SSRC_WSPR_LUA

#endif