EgtInterface/LUA_General.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_General.cpp       Data : 27.09.14        Versione : 1.5i5
// Contenuto : Funzioni generali per LUA.
//
//
//
// Modifiche : 27.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "LUA.h"
#include "API.h"
#include "API_Macro.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Extern/Lua/Include/lua.hpp"

using namespace std ;

//----------------------------------------------------------------------------
static lua_State*         s_L = nullptr ;
static int                s_nCurrGseCtx = 1 ;
static string             s_LastError ;
static PerformanceCounter s_Counter ;

//----------------------------------------------------------------------------
bool
LuaInit( void)
{
  // se già aperto, lo fermo per riavviarlo
   if ( s_L != nullptr) {
      lua_close( s_L) ;
      s_L = nullptr ;
   }
  // inizializzo Lua
   s_L = luaL_newstate() ;
   if ( s_L == nullptr) {
      LOG_ERROR( GetLogger(), "Error in Lua interpreter starting (" __FUNCTION__ ")")
      return false ;
   }
  // carico le librerie standard 
   luaL_openlibs( s_L) ;
  // carico le funzioni speciali
   if ( ! LuaInstallGeneral( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGeneral (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGeomDB( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGeomDB (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGdbCreate( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreate (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGdbModify( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModify (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGdbObjects( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjects (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGdbObjAttribs( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjAttribs (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallCurveModif( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallCurveModif (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGeoSnap( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGeoSnap (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallGeoTransform( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallGeoTransform (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallScene( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallScene (" __FUNCTION__ ")")
      return false ;
   }
   if ( ! LuaInstallExchange( s_L)) {
      LOG_ERROR( GetLogger(), "Error in LuaInstallExchange (" __FUNCTION__ ")")
      return false ;
   }

   LOG_INFO( GetLogger(), "Lua interpreter started")
   return true ;
}

//----------------------------------------------------------------------------
bool
LuaExit( void)
{
   if ( s_L == nullptr)
      return false ;
  // termino Lua
   lua_close( s_L) ;
   s_L = nullptr ;
   LOG_INFO( GetLogger(), "Lua interpreter closed")
   return true ;
}

//----------------------------------------------------------------------------
bool
LuaSetGseContext( int nGseCtx)
{
   GseContext* pGseCtx = GetGseContext( nGseCtx) ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   s_nCurrGseCtx = nGseCtx ;
   return true ;
}

//----------------------------------------------------------------------------
int
LuaGetGseContext( void)
{
   return s_nCurrGseCtx ;
}

//----------------------------------------------------------------------------
bool
LuaExecLine( const string& sLine)
{
  // eseguo la linea
   int nErr = luaL_loadstring( s_L, sLine.c_str())  ||  lua_pcall( s_L, 0, LUA_MULTRET, 0) ;
  // senza errori
   if ( nErr == 0) {
      s_LastError.clear() ;
      return true ;
   }
  // altrimenti, errore
   else {
     // recupero il messaggio di errore
      const char* szErr = lua_tostring( s_L, -1) ;
      s_LastError = ( szErr != nullptr) ? szErr : "Error unknown" ;
      lua_pop( s_L, 1) ;
     // lo scrivo nel log
      LOG_ERROR( GetLogger(), s_LastError.c_str())
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
LuaExecFile( const string& sFile)
{
  // eseguo la linea
   int nErr = luaL_loadfile( s_L, sFile.c_str())  ||  lua_pcall( s_L, 0, LUA_MULTRET, 0) ;
  // senza errori
   if ( nErr == 0) {
      s_LastError.clear() ;
      return true ;
   }
  // in caso di errore
   else {
     // recupero il messaggio di errore
      const char* szErr = lua_tostring( s_L, -1) ;
      s_LastError = ( szErr != nullptr) ? szErr : "Error unknown" ;
      lua_pop( s_L, 1) ;
     // lo scrivo nel log
      LOG_ERROR( GetLogger(), s_LastError.c_str())
      return false ;
   }
}

//----------------------------------------------------------------------------
const string&
LuaGetLastError( void)
{
   return s_LastError ;
}

//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
static int
MyPrint( lua_State* L)
{
   string sOut ;
   int n = lua_gettop( L) ;  /* number of arguments */
   lua_getglobal( L, "tostring") ;
   for ( int i = 1 ; i <= n ; ++ i) {
      const char* s ;
      lua_pushvalue( L, -1) ;  /* function to be called */
      lua_pushvalue( L, i) ;   /* value to print */
      lua_call( L, 1, 1) ;
      s = lua_tostring( L, -1) ;  /* get result */
      if ( s == nullptr)
         return luaL_error( L,
                            LUA_QL("tostring") " must return a string to " LUA_QL("print")) ;
      if ( i > 1)
         sOut += "\t" ;
      sOut += s ;
      lua_pop( L, 1) ;  /* pop result */
   }
   if ( ! sOut.empty())
      LOG_INFO( GetLogger(), sOut.c_str())

   return 0 ; 
}

//-------------------------------------------------------------------------------
static int
SetContext( lua_State* L)
{
  // un solo parametro intero
   int nGseCtx ;
   LuaCheckParam( L, 1, nGseCtx)
   LuaClearStack( L) ;
  // imposto il contesto
   bool bOk = LuaSetGseContext( nGseCtx) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
GetContext( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco l'indice del contesto
   LuaSetReturn( L, s_nCurrGseCtx) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaPause( lua_State* L)
{
  // 1 parametro : numero di millisecondi
   int nTime ;
   LuaCheckParam( L, 1, nTime)
   LuaClearStack( L) ;
  // controllo la durata della pausa e la eseguo
   const int MIN_TIME = 0 ;
   const int MAX_TIME = 10000 ;
   if ( nTime < MIN_TIME)
      nTime = MIN_TIME ;
   else if ( nTime > MAX_TIME)
      nTime = MAX_TIME ;
   Sleep( nTime) ;
  // restituisco il risultato
   LuaSetReturn( L, true) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaStartCounter( lua_State* L)
{
   s_Counter.Start() ;
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaStopCounter( lua_State* L)
{
   double dTime = s_Counter.Stop() ;
  // restituisco il risultato
   LuaSetReturn( L, dTime) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeneral( lua_State* L)
{
   try {
      lua_register( L, "print", MyPrint) ;
      lua_register( L, "EgtSetContext", SetContext) ;
      lua_register( L, "EgtGetContext", GetContext) ;
      lua_register( L, "EgtPause", LuaPause) ;
      lua_register( L, "EgtStartCounter", LuaStartCounter) ;
      lua_register( L, "EgtStopCounter", LuaStopCounter) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}