luaEnv.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2009 K2FS Sistemas e Projetos Ltd.  
** All rights reserved.
**
************************************************************************/
 
#ifndef _LUAENV_H_
#define _LUAENV_H_
 
#include "luaConfig.h"
 
#include <assert.h>
#include <QVariant>
#include <lua.hpp>
 
#include <QStringList>
#include <QSet>
 
#define luaPrintable(string) QString(string).toLatin1().constData()
 
class LUAUTILS_API_EXPORT LuaEnv
{
public:
 
  enum StackOption 
  {
    STACK_POP,    
    STACK_NOPOP,  
    STACK_AUTO    
  };
 
  enum LibraryOptions
  {
    LIB_BASE    = 0x01,  
    LIB_TABLE   = 0x02,  
    LIB_IO      = 0x04,  
    LIB_OS      = 0x08,  
    LIB_STRING  = 0x10,  
    LIB_MATH    = 0x20,  
    LIB_DEBUG   = 0x40,  
    LIB_PACKAGE = 0x80,  
    LIB_ALL     = 0xFF   
  };
 
  typedef luaL_Reg FunctionRegister;
 
  typedef void (*RedirectedOutputCb)(void* context, QString str);
 
  typedef QString(*ScriptNameFilterCb)(void* context, QString scriptName);
 
  LuaEnv() : _l(NULL), _outputCb(NULL), _outputContext(NULL), _envTableRef(LUA_NOREF), 
             _dofileScriptNameFilter(NULL), _dofileScriptNameContext(NULL) {}
 
  LuaEnv(lua_State* state) : _l(state), _outputCb(NULL), _outputContext(NULL), _envTableRef(LUA_NOREF), 
                             _dofileScriptNameFilter(NULL), _dofileScriptNameContext(NULL) {}
 
  ~LuaEnv() {}
 
  bool newState(int libOptions = LIB_ALL);
  void closeState();
 
  void removeSymbols(const QStringList& symbolNames);
 
  void setState(lua_State* state) { _l = state; }
 
  lua_State* state() { return _l; }
 
  operator lua_State* () { return _l; }
 
  void redirectOutput(RedirectedOutputCb cb, void* context);
  void replaceDofile(QString table = "", ScriptNameFilterCb scriptNameFilter = NULL, void* scriptNameFilterContext = NULL);
 
  void setDofileTable(QString table) { _dofileTable = table; }
 
  void setRsrcPath(const QStringList& pathList);
 
  const QStringList& rsrcPath() const { return _rsrcPathList; }
 
  bool runScript            (QString     file,   QString table, QString& err);
  bool runRsrcScript        (QString     file,   QString table, QString& err);
  bool runVerifiedRsrcScript(QString     file,   QString table, QString hash, bool encoded, QString& err);
  bool runScriptStr         (QString     script, QString table, QString& err);
  bool runScriptStr         (QString     script, QString table, QString name, QString& err);
  bool runScriptStr         (QByteArray& script, QString table, QString name, QString& err);
 
  void setLoadTableEnv(int tableRef = LUA_NOREF) { _envTableRef = tableRef; }
 
  void registerFunctions(const FunctionRegister* reg, const char* table = NULL);
  void registerFunction (const char* globalName, lua_CFunction func, void* userdata_1 = NULL, void* userdata_2 = NULL);
 
  QVariant getGlobal(const char* name, StackOption opt = STACK_AUTO);
  
  QVariant getGlobal(QString name, StackOption opt = STACK_AUTO) { return getGlobal(luaPrintable(name), opt); }
 
  void setGlobal(const char* name, const QVariant& val);
 
  void setGlobal(QString name, const QVariant& val) { return setGlobal(luaPrintable(name), val); }
 
  QVariant toVariant(StackOption opt, int index = -1);
 
  void pushVariant(const QVariant& val);
  
  void pop(int num = 1) { assert(_l); lua_pop(_l, num); }
  
  int top() { assert(_l); return lua_gettop(_l); }
  
  void setTop(int index) { assert(_l); lua_settop(_l, index); }
 
  QVariant getLocal(const char* name, StackOption opt = STACK_AUTO);
 
  QVariant getLocal(QString name, StackOption opt = STACK_AUTO) { return getLocal(luaPrintable(name), opt); }
 
  static bool    isIdentifier(QString str);
  static QString quote(QString str);
 
  // Extra space support. 
  // Requires the Lua library to be compiled with additional space added 
  // to the begining of a lua_State through the LUAI_EXTRASPACE macro
  // This macro should define the size in bytes of the extra sapce and also 
  // be suitably aligned so that an allocated structure + the extra space 
  // ends up being a suitable pointer to a regular Lua state.
#ifdef LUAI_EXTRASPACE
 
  template <class T> T* extraSpace() const { return extraSpace<T>(_l); }
 
  template <class T> static T* extraSpace(lua_State* state)
  { 
    assert(sizeof(T) <= LUAI_EXTRASPACE);
    return (T*)((char*)state - LUAI_EXTRASPACE);
  }
 
  // Cancelation support. 
  // Requires the Lua library to be compiled with extra space to store the 
  // per Lua state cancelation flag and also to define the LUAUTILS_CANCEL 
  // macro.  This macro also affects method redirectors defined on luaMethod.h
#ifdef LUAUTILS_CANCEL
  static_assert(2 * sizeof(quint32) <= LUAI_EXTRASPACE, "Invalid extra space size to enable cancelation support");
 
  bool cancelRequested() const { return cancelRequested(_l); }
 
  void setCancelFlag(bool cancel) { setCancelFlag(_l, cancel); }
 
  void disableCancelation(bool mode) { disableCancelation(_l, mode); }
 
  static bool cancelRequested(lua_State* state) { quint32* p = extraSpace<quint32>(state); return p[0] && !p[1]; }
 
  static void setCancelFlag(lua_State* state, bool cancel) { extraSpace<quint32>(state)[0] = cancel; }
 
  static void disableCancelation(lua_State* state, bool mode) { extraSpace<quint32>(state)[1] = mode; }
#endif
#endif
 
  static QVariant& clearReferences(QVariant& obj, bool useLists, bool firstLevelIsMap, bool allowFunctions);
 
private:
  Q_DISABLE_COPY(LuaEnv)
 
  void initState(int libOptions);
  bool loadScriptData(QString file, QByteArray& script, QString& err);
  bool runScriptAux  (QString table, QString& err);
 
  static int printCb(lua_State* L);
  static int dofile (lua_State* L);
 
  lua_State* _l; 
 
  RedirectedOutputCb _outputCb;      
  void*              _outputContext; 
  QStringList        _rsrcPathList;  
  QString            _dofileTable;   
  ScriptNameFilterCb _dofileScriptNameFilter;  
  void*              _dofileScriptNameContext; 
  int                _envTableRef;   
};
 
 
class LUAUTILS_API_EXPORT AutoLuaEnv : public LuaEnv
{
public:
 
  AutoLuaEnv(int libOptions = LIB_ALL)
  {
    if(!newState(libOptions))
      throw std::bad_alloc();
  }
 
  ~AutoLuaEnv()
  {
    closeState();
  }
};
 
#endif