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