//----------------------------------------------------------------------------
//  EgalTech 2015-2024
//----------------------------------------------------------------------------
// File : MachineLua.cpp       Data : 01.09.24          Versione : 2.6i1
// Contenuto : Implementazione gestione macchina : funzioni Lua.
//
//
//
// Modifiche : 06.05.15 DS Creazione modulo.
//             26.04.20 DS Aggiunta gestione TcPos.
//             05.08.24 DS Aggiunta gestione SpecialEstimate.
//             01.09.24 DS SpecialEstimate è diventato MultiProcess.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeSetModifiedOff.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnFileUtils.h"

using namespace std ;

//----------------------------------------------------------------------------
static const string FLD_FILE = "File" ;
static const string FLD_OFFSET = "Offset" ;
static const string FLD_SPECIAL = "Special" ;
static const string FLD_PROCESSOR = "Processor" ;
static const string FLD_AXISMAXADJUST = "AxisMaxAdjust" ;
static const string FLD_AXISMAXROTADJ = "AxisMaxRotAdj" ;
static const string FLD_EXITMAXADJUST = "ExitMaxAdjust" ;
static const string FLD_EXITMAXROTADJ = "ExitMaxRotAdj" ;
static const string FLD_ANGDELTAMINFORHOME = "AngDeltaMinForHome" ;
static const string FLD_MULTIPROCESS = "MultiProcess" ;
static const string FLD_LINKAXESMOVEORDER = "LinkAxesMoveOrder" ;
static const string FLD_NEWLINKMGR = "NewLinkMgr" ;
static const string FLD_NAME = "Name" ;
static const string FLD_PARENT = "Parent" ;
static const string FLD_GEO = "Geo" ;
static const string FLD_AUX = "Aux" ;
static const string FLD_TOKEN = "Token" ;
static const string FLD_TYPE = "Type" ;
static const string FLD_USE = "Use" ;
static const string FLD_INVERT = "Invert" ;
static const string FLD_AXIS_OFFSET = "Offset" ;
static const string FLD_REF1 = "Ref1" ;
static const string FLD_SCALE = "Scale" ;
static const string FLD_EXIT_NBR = "ExitNbr" ;
static const string FLD_POS = "Pos" ;
static const string FLD_DIR = "Dir" ;
static const string FLD_STROKE = "Stroke" ;
static const string FLD_HOME = "Home" ;
static const string FLD_ADJUSTAUX = "AdjustAux" ;
static const string FLD_HSET = "HSet" ;
static const string FLD_SEL_TYPE = "SelType" ;
static const string FLD_TDIR = "TDir" ;
static const string FLD_ADIR = "ADir" ;
static const string FLD_ROT1W = "Rot1W" ;
static const string FLD_MAXDELTAR2ON1 = "MaxDeltaR2OnFirst" ;
static const string FLD_ROT2STROKE = "Rot2Stroke" ;
static const string FLD_SOLCH = "SolCh" ;
static const string FLD_OTHCOLL = "OthColl" ;
static const string FLD_COLL = "Coll" ;

//----------------------------------------------------------------------------
Machine* Machine::m_pMchLua = nullptr ;

//----------------------------------------------------------------------------
bool
Machine::LuaInit( const string& sMachineName)
{
  // inizializzo l'interprete lua
   if ( ! m_LuaMgr.Init())
      return false ;
  // carico le funzioni speciali
   if ( ! LuaInstallEgtFunctions( m_LuaMgr))
      return false ;
  // recupero la versione di Lua
   string sLua ;
   if ( m_LuaMgr.GetVersion( sLua))
      sLua += " machine interpreter started" ;
   else
      sLua = "Lua *.* machine interpreter started" ;
   sLua += " (" + sMachineName + ")" ;
   LOG_INFO( GetEMkLogger(), sLua.c_str())
  // imposto il direttorio delle librerie
   m_LuaMgr.SetLuaLibsDir( m_pMchMgr->GetLuaLibsDir()) ;
  // carico la libreria standard
   m_LuaMgr.Require( m_pMchMgr->GetLuaLastRequire()) ;
  // registro le funzioni di lettura macchina per lua
   m_LuaMgr.RegisterFunction( "EmtGeneral", Machine::LuaEmtGeneral) ;
   m_LuaMgr.RegisterFunction( "EmtBase", Machine::LuaEmtBase) ;
   m_LuaMgr.RegisterFunction( "EmtTable", Machine::LuaEmtTable) ;
   m_LuaMgr.RegisterFunction( "EmtAxis", Machine::LuaEmtAxis) ;
   m_LuaMgr.RegisterFunction( "EmtHead", Machine::LuaEmtHead) ;
   m_LuaMgr.RegisterFunction( "EmtTcPos", Machine::LuaEmtTcPos) ;
  // registro le funzioni di modifica macchina per lua
   m_LuaMgr.RegisterFunction( "EmtModifyAxisPosition", Machine::LuaEmtModifyAxisPosition) ;
   m_LuaMgr.RegisterFunction( "EmtModifyAxisDirection", Machine::LuaEmtModifyAxisDirection) ;
   m_LuaMgr.RegisterFunction( "EmtModifyAxisStroke", Machine::LuaEmtModifyAxisStroke) ;
   m_LuaMgr.RegisterFunction( "EmtModifyAxisHome", Machine::LuaEmtModifyAxisHome) ;
   m_LuaMgr.RegisterFunction( "EmtModifyHeadAuxDirection", Machine::LuaEmtModifyHeadAuxDirection) ;
   m_LuaMgr.RegisterFunction( "EmtModifyExitPosition", Machine::LuaEmtModifyExitPosition) ;
   m_LuaMgr.RegisterFunction( "EmtLinkRawPartToGroup", Machine::LuaEmtLinkRawPartToGroup) ;
   m_LuaMgr.RegisterFunction( "EmtGetAllLinkedRawParts", Machine::LuaEmtGetAllLinkedRawParts) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkRawPartFromGroup", Machine::LuaEmtUnlinkRawPartFromGroup) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkAllRawPartsFromGroups", Machine::LuaEmtUnlinkAllRawPartsFromGroups) ;
   m_LuaMgr.RegisterFunction( "EmtLinkFixtureToGroup", Machine::LuaEmtLinkFixtureToGroup) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkFixtureFromGroup", Machine::LuaEmtUnlinkFixtureFromGroup) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkAllFixturesFromGroups", Machine::LuaEmtUnlinkAllFixturesFromGroups) ;
   m_LuaMgr.RegisterFunction( "EmtLinkPartToGroup", Machine::LuaEmtLinkPartToGroup) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkPartFromGroup", Machine::LuaEmtUnlinkPartFromGroup) ;
   m_LuaMgr.RegisterFunction( "EmtUnlinkAllPartsFromGroups", Machine::LuaEmtUnlinkAllPartsFromGroups) ;
  // registro le funzioni di definizione entità CL per lua
   m_LuaMgr.RegisterFunction( "EmtAddRapidStart", Machine::LuaEmtAddRapidStart) ;
   m_LuaMgr.RegisterFunction( "EmtAddRapidMove", Machine::LuaEmtAddRapidMove) ;
   m_LuaMgr.RegisterFunction( "EmtAddLinearMove", Machine::LuaEmtAddLinearMove) ;
   m_LuaMgr.RegisterFunction( "EmtAddArcMove", Machine::LuaEmtAddArcMove) ;
   m_LuaMgr.RegisterFunction( "EmtAddClimb", Machine::LuaEmtAddClimb) ;
   m_LuaMgr.RegisterFunction( "EmtRemoveClimb", Machine::LuaEmtRemoveClimb) ;
   m_LuaMgr.RegisterFunction( "EmtAddRise", Machine::LuaEmtAddRise) ;
   m_LuaMgr.RegisterFunction( "EmtRemoveRise", Machine::LuaEmtRemoveRise) ;
   m_LuaMgr.RegisterFunction( "EmtGetInitialAxesPos", Machine::LuaEmtGetInitialAxesPos) ;
   m_LuaMgr.RegisterFunction( "EmtGetFinalAxesPos", Machine::LuaEmtGetFinalAxesPos) ;
   m_LuaMgr.RegisterFunction( "EmtGetCurrAxesHomePos", Machine::LuaEmtGetCurrAxesHomePos) ;
  // registro le funzioni di lettura entità CL per lua
   m_LuaMgr.RegisterFunction( "EmtGetMoveType", Machine::LuaEmtGetMoveType) ;
   m_LuaMgr.RegisterFunction( "EmtGetAxesPos", Machine::LuaEmtGetAxesPos) ;
   m_LuaMgr.RegisterFunction( "EmtGetBackAuxDir", Machine::LuaEmtGetBackAuxDir) ;
  // registro le funzioni di scrittura part program per lua
   m_LuaMgr.RegisterFunction( "EmtWrite", Machine::LuaEmtWrite) ;
  // registro la funzione per impostare informazioni di outstroke
   m_LuaMgr.RegisterFunction( "EmtSetOutstrokeInfo", Machine::LuaEmtSetOutstrokeInfo) ;
  // registro la funzione per impostare informazioni di errore
   m_LuaMgr.RegisterFunction( "EmtSetLastError", Machine::LuaEmtSetLastError) ;
  // registro la funzione per aggiungere informazioni di warning
   m_LuaMgr.RegisterFunction( "EmtSetWarning", Machine::LuaEmtSetWarning) ;
  // registro la funzione per aggiungere un oggetto da verificare per la collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtAddCollisionObj", Machine::LuaEmtAddCollisionObj) ;
  // registro la funzione estesa per aggiungere un oggetto da verificare per la collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtAddCollisionObjEx", Machine::LuaEmtAddCollisionObjEx) ;
  // registro la funzione per rimuovere oggetti con dato FrameId da verificare per la collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtRemoveCollisionObj", Machine::LuaEmtRemoveCollisionObj) ;
  // registro la funzione per avere i dati dell'oggetto con posizione indicata nel vettore da verificare per la collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtGetCollisionObj", Machine::LuaEmtGetCollisionObj) ;
  // registro la funzione di esecuzione della verifica di collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtExecCollisionCheck", Machine::LuaEmtExecCollisionCheck) ;
  // registro la funzione di gestione della collisione in simulazione
   m_LuaMgr.RegisterFunction( "EmtOnCollision", Machine::LuaEmtOnCollision) ;
  // registro la funzione di impostazione del primo utensile per virtual milling in simulazione
   m_LuaMgr.RegisterFunction( "EmtSetToolForVmill", Machine::LuaEmtSetToolForVmill) ;
  // registro la funzione di impostazione di utensile aggiuntivo per virtual milling in simulazione
   m_LuaMgr.RegisterFunction( "EmtAddToolForVmill", Machine::LuaEmtAddToolForVmill) ;
  // registro la funzione per abilitare/disabilitare l'esecuzione del virtual milling
   m_LuaMgr.RegisterFunction( "EmtEnableToolsForVmill", Machine::LuaEmtEnableToolsForVmill) ;
  // registro la funzione di movimento assi in simulazione
   m_LuaMgr.RegisterFunction( "EmtMoveAxes", Machine::LuaEmtMoveAxes) ;
  // registro la funzione di salvataggio comandi in simulazione MP
   m_LuaMgr.RegisterFunction( "EmtSaveCmd", Machine::LuaEmtSaveCmd) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaExit( void)
{
  // chiudo lua ( se era aperto)
   if ( m_LuaMgr.Exit()) {
      string sLua = "Lua machine interpreter closed (" + m_sName + ")" ;
      LOG_INFO( GetEMkLogger(), sLua.c_str())
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaExistsFunction( const string& sFun) const
{
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = const_cast<Machine*>( this) ;
  // verifico esistenza della funzione
   bool bOk = m_LuaMgr.ExistsFunction( sFun) ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaCallFunction( const string& sFun, bool bSetModifiedOff)
{
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // se richiesto, disabilito gestione segnalazione modifiche progetto
   bool bOldMod = false ;
   if ( bSetModifiedOff) {
      bOldMod = ExeGetEnableModified() ;
      ExeDisableModified() ;
   }
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = this ;
  // eseguo la funzione
   bool bOk = m_LuaMgr.CallFunction( sFun, 0) ;
  // ripristino gestione segnalazione modifiche progetto
   if ( bSetModifiedOff  &&  bOldMod)
      ExeEnableModified() ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaCreateGlobTable( const string& sName)
{
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = this ;
  // eseguo la funzione
   bool bOk = ::LuaCreateGlobTable( m_LuaMgr.GetLuaState(), sName) ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaResetGlobVar( const string& sName)
{
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = this ;
  // eseguo la funzione
   bool bOk = ::LuaResetGlobVar( m_LuaMgr.GetLuaState(), sName) ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaChangeNameGlobVar( const string& sOldName, const string& sNewName)
{
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = this ;
  // eseguo la funzione
   bool bExists = ::LuaChangeNameGlobVar( m_LuaMgr.GetLuaState(), sOldName, sNewName) ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bExists ;
}

//----------------------------------------------------------------------------
bool
Machine::LuaLoadMachine( const string& sFile)
{
  // info
   string sOut = "LuaLoadMachine : " + sFile ;
   LOG_INFO( GetEMkLogger(), sOut.c_str())
  // imposto contesto corretto
   int nOldCtx = ExeGetCurrentContext() ;
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
  // disabilito gestione segnalazione modifiche progetto
   SetModifiedOff modOff ;
  // imposto l'oggetto corrente per Lua
   Machine* pOldMchLua = m_pMchLua ;
   m_pMchLua = this ;
  // carico la macchina
   bool bOk = m_LuaMgr.ExecFile( sFile) ;
  // verifico sia stato caricato effettivamente qualcosa
   if ( bOk) {
      if ( m_pGeomDB == nullptr  ||  m_pGeomDB->GetGroupObjs( m_nGroupId) == 0) {
         LOG_ERROR( GetEMkLogger(), "Error : mlde file is empty")
         bOk = false ;
      }
   }
  // ripristino gestione segnalazione modifiche progetto
   modOff.Reset() ;
  // ripristino contesto originale
   if ( nOldCtx != m_pMchMgr->GetContextId())
      ExeSetCurrentContext( nOldCtx) ;
  // ripristino dell'oggetto corrente per Lua
   m_pMchLua = pOldMchLua ;
   return bOk ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtGeneral( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'File' dalla tabella
   string sFile ;
   LuaCheckTabFieldParam( L, 1, FLD_FILE, sFile)
  // lettura eventuale campo 'Offset' dalla tabella (default 0,0,0)
   Vector3d vtOffset ;
   LuaGetTabFieldParam( L, 1, FLD_OFFSET, vtOffset) ;
  // lettura eventuale campo 'Special' dalla tabella
   string sSpecial ;
   LuaGetTabFieldParam( L, 1, FLD_SPECIAL, sSpecial) ;
  // lettura eventuale campo 'Processor' dalla tabella
   string sProcessor ;
   LuaGetTabFieldParam( L, 1, FLD_PROCESSOR, sProcessor) ;
  // lettura eventuale campo 'AxisMaxAdjust' dalla tabella (default EPS_SMALL)
   double dAxisMaxAdjust = EPS_SMALL ;
   LuaGetTabFieldParam( L, 1, FLD_AXISMAXADJUST, dAxisMaxAdjust) ;
  // lettura eventuale campo 'AxisMaxRotAdj' dalla tabella (default 10 * EPS_ANG_SMALL)
   double dAxisMaxRotAdj = 10 * EPS_ANG_SMALL ;
   LuaGetTabFieldParam( L, 1, FLD_AXISMAXROTADJ, dAxisMaxRotAdj) ;
  // lettura eventuale campo 'ExitMaxAdjust' dalla tabella (default EPS_SMALL)
   double dExitMaxAdjust = EPS_SMALL ;
   LuaGetTabFieldParam( L, 1, FLD_EXITMAXADJUST, dExitMaxAdjust) ;
  // lettura eventuale campo 'ExitMaxRotAdj' dalla tabella (default 10 * EPS_ANG_SMALL)
   double dExitMaxRotAdj = 10 * EPS_ANG_SMALL ;
   LuaGetTabFieldParam( L, 1, FLD_EXITMAXROTADJ, dExitMaxRotAdj) ;
  // lettura eventuale campo 'AngDeltaForHome' dalla tabella (default INFINITO)
   double dAngDeltaMinForHome = INFINITO ;
   LuaGetTabFieldParam( L, 1, FLD_ANGDELTAMINFORHOME, dAngDeltaMinForHome) ;
  // lettura eventuale campo 'MultiProcess' dalla tabella (0=no, 1=si, 2=si con simulazione MP)
   int nMultiProcess = 0 ;
   LuaGetTabFieldParam( L, 1, FLD_MULTIPROCESS, nMultiProcess) ;
  // lettura eventuale campo "LinkAxesMoveOrder" dalla tabella(0=interpolati, ...)
   int nLinkAxesMoveOrder = 0 ;
   LuaGetTabFieldParam( L, 1, FLD_LINKAXESMOVEORDER, nLinkAxesMoveOrder) ;
  // lettura eventuale campo 'NewLinkMgr' dalla tabella (0=old, 1 =new)
   int nNewLinkMgr = 0 ;
   LuaGetTabFieldParam( L, 1, FLD_NEWLINKMGR, nNewLinkMgr) ;
  // pulizia stack    
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtGeneral : " + sFile ;
   if ( ! sSpecial.empty())
      sOut += ", " + sSpecial ;
   if ( ! sProcessor.empty())
      sOut += ", " + sProcessor ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico la geometria della macchina
   if ( ! m_pMchLua->LoadMachineGeometry( sFile, vtOffset))
      return luaL_error( L, " Load Machine failed") ;

  // carico il gestore delle azioni speciali della macchina
   if ( ! sSpecial.empty()) {
     // carico il file lua dello special
      string sSpecPath = m_pMchLua->m_sMachineDir + "\\" + sSpecial ;
      if ( ! m_pMchLua->m_LuaMgr.ExecFile( sSpecPath))
         return luaL_error( L, " Load Special failed") ;
   }
   else {
      LOG_DBG_INFO( GetEMkLogger(), " Special file not specified")
   }

  // carico il processore della macchina
   if ( ! sProcessor.empty()) {
     // carico il file lua del processore
      string sProcPath = m_pMchLua->m_sMachineDir + "\\" + sProcessor ;
      if ( ! m_pMchLua->m_LuaMgr.ExecFile( sProcPath))
         return luaL_error( L, " Load Processor failed") ;
   }
   else {
      LOG_DBG_INFO( GetEMkLogger(), " Processor file not specified")
   }

  // imposto massimo spostamento assi e uscite tra definizione cinematica e geometria
   m_pMchLua->m_dAxisMaxAdjust = dAxisMaxAdjust ;
   m_pMchLua->m_dAxisMaxRotAdj = dAxisMaxRotAdj ;
   m_pMchLua->m_dExitMaxAdjust = dExitMaxAdjust ;
   m_pMchLua->m_dExitMaxRotAdj = dExitMaxRotAdj ;

  // imposto minima differenza angolare da posizione precedente per stare vivino a posizione home
   m_pMchLua->m_dAngDeltaMinForHome = dAngDeltaMinForHome ;

  // imposto codice per macchina multiprocesso
   m_pMchLua->m_nMultiProcess = nMultiProcess ;
  // imposto codice per ordine interpolazione assi nei collegamenti
   m_pMchLua->m_nLinkAxesMoveOrder = nLinkAxesMoveOrder ;
  // imposto codice per gestione link tra lavorazioni
   m_pMchLua->m_nNewLinkMgr = nNewLinkMgr ;

   return 0 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtBase( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtBase : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della base
   if ( ! m_pMchLua->LoadMachineBase( sName, sGeo, vsAux))
      return luaL_error( L, " Load Machine Base failed") ;

  // restituisco l'indice della base
   int nBaseId = m_pMchLua->GetBaseId( sName) ;
   if ( nBaseId != GDB_ID_NULL)
      LuaSetParam( L, nBaseId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtTable( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'Type' dalla tabella
   int nType ;
   LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
  // lettura campo 'Ref1' dalla tabella
   Point3d Ref1 ;
   LuaCheckTabFieldParam( L, 1, FLD_REF1, Ref1)
  // lettura eventuale campo 'Scale' dalla tabella
   double vScale[3] = {1.0, 1.0, 1.0} ;
   LuaGetTabFieldParam( L, 1, FLD_SCALE, vScale) ;
  // lettura eventuale campo 'Coll' dalla tabella
   STRVECTOR vsColl ;
   LuaGetTabFieldParam( L, 1, FLD_COLL, vsColl) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtTable : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della tavola
   if ( ! m_pMchLua->LoadMachineTable( sName, sParent, nType, Ref1, vScale[0], vScale[1], vScale[2], vsColl, sGeo, vsAux))
      return luaL_error( L, " Load Machine Table failed") ;

  // restituisco l'indice della tavola
   int nTableId = m_pMchLua->GetTableId( sName) ;
   if ( nTableId != GDB_ID_NULL)
      LuaSetParam( L, nTableId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtAxis( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura eventuale campo 'Token' dalla tabella (default Name)
   string sToken = sName ;
   LuaGetTabFieldParam( L, 1, FLD_TOKEN, sToken) ;
  // lettura eventuale campo 'Invert' dalla tabella (default false)
   bool bInvert = false ;
   LuaGetTabFieldParam( L, 1, FLD_INVERT, bInvert) ;
  // lettura eventuale campo 'Offset' dalla tabella (default 0)
   double dOffset = 0 ;
   LuaGetTabFieldParam( L, 1, FLD_AXIS_OFFSET, dOffset) ;
  // lettura campo 'Type' dalla tabella
   int nType ;
   LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
  // lettura eventuale campo 'Use' della tabella (default General)
   int nUse = MCH_AU_GENERAL ;
   LuaGetTabFieldParam( L, 1, FLD_USE, nUse) ;
  // lettura campo 'Pos' dalla tabella
   Point3d ptPos ;
   LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
  // lettura campo 'Dir' dalla tabella
   Vector3d vtDir ;
   LuaCheckTabFieldParam( L, 1, FLD_DIR, vtDir)
  // lettura campo 'Stroke' dalla tabella
   STROKE Stroke ;
   LuaCheckTabFieldParam( L, 1, FLD_STROKE, Stroke.v)
  // lettura eventuale campo 'Home' dalla tabella (default 0)
   double dHome = 0 ;
   LuaGetTabFieldParam( L, 1, FLD_HOME, dHome) ;
  // lettura eventuale campo 'AdjustAux' dalla tabella (default false)
   bool bAdjustAux = false ;
   LuaGetTabFieldParam( L, 1, FLD_ADJUSTAUX, bAdjustAux) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtAxis : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati dell'asse
   if ( ! m_pMchLua->LoadMachineAxis( sName, sParent, sToken, bInvert, dOffset,
                                      nType, nUse, ptPos, vtDir, Stroke, dHome, bAdjustAux, sGeo, vsAux))
      return luaL_error( L, " Load Machine Axis failed") ;

  // restituisco l'indice dell'asse
   int nAxisId = m_pMchLua->GetAxisId( sName) ;
   if ( nAxisId != GDB_ID_NULL)
      LuaSetParam( L, nAxisId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtHead( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Type' dalla tabella
   int nType ;
   LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)

  // Procedo alla lettura a seconda del tipo
   switch ( nType) {
   case MCH_HT_STD :
      return LuaEmtStdHead( L) ;
   case MCH_HT_MULTI :
      return LuaEmtMultiHead( L) ;
   case MCH_HT_SPECIAL :
      return LuaEmtSpecialHead( L) ;
   default :
      return luaL_error( L, " Head type unknown") ;
   }
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtStdHead( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'HSet' dalla tabella
   string sHSet ;
   LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
  // lettura campo 'Pos' dalla tabella
   Point3d ptPos ;
   LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
  // lettura campo 'TDir' dalla tabella
   Vector3d vtTDir ;
   LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
  // lettura eventuale campo 'ADir' dalla tabella
   Vector3d vtADir ;
   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
  // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
   double dRot1W = 1 ;
   LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
   bool bMaxDeltaR2On1 = true ;
   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
  // lettura eventuale campo 'Rot2Stroke' dalla tabella
   STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
   LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
  // lettura eventuale campo 'SolCh' dalla tabella
   int nSolCh = MCH_SCC_NONE ;
   LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
  // lettura eventuale campo 'OthColl' dalla tabella
   STRVECTOR vsOthColl ;
   LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtStdHead : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della testa standard
   if ( ! m_pMchLua->LoadMachineStdHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
                                         dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
      return luaL_error( L, " Load Machine Standard Head failed") ;

  // restituisco l'indice della testa
   int nHeadId = m_pMchLua->GetHeadId( sName) ;
   if ( nHeadId != GDB_ID_NULL)
      LuaSetParam( L, nHeadId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtMultiHead( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'HSet' dalla tabella
   string sHSet ;
   LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
  // lettura eventuale campo tipo di selezione ammessa per le uscite
   int nSelectType = MCH_SLT_FIXEDEXITS ;
   LuaGetTabFieldParam( L, 1, FLD_SEL_TYPE, nSelectType) ;
  // lettura campo 'ExitNbr' dalla tabella
   int nExitNbr ;
   LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
  // lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
   MUEXITVECTOR vMuExit ;
   vMuExit.reserve( nExitNbr) ;
   for ( int i = 0 ; i < nExitNbr ;  ++ i) {
     // lettura
      string sPos = FLD_POS + ToString( i + 1) ;
      Point3d ptPos ;
      LuaCheckTabFieldParam( L, 1, sPos.c_str(), ptPos)
      string sTDir = FLD_TDIR + ToString( i + 1) ;
      Vector3d vtTDir ;
      LuaCheckTabFieldParam( L, 1, sTDir.c_str(), vtTDir)
     // inserimento nell'array
      vMuExit.emplace_back( ptPos, vtTDir) ;
   }
  // lettura eventuale campo 'ADir' dalla tabella
   Vector3d vtADir ;
   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
  // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
   double dRot1W = 1 ;
   LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
   bool bMaxDeltaR2On1 = true ;
   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
  // lettura eventuale campo 'Rot2Stroke' dalla tabella
   STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
   LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
  // lettura eventuale campo 'SolCh' dalla tabella
   int nSolCh = MCH_SCC_NONE ;
   LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
  // lettura eventuale campo 'OthColl' dalla tabella
   STRVECTOR vsOthColl ;
   LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtMultiHead : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della testa multipla
   if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, nSelectType, vMuExit, vtADir,
                                           dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
      return luaL_error( L, " Load Machine Multi Head failed") ;

  // restituisco l'indice della testa
   int nHeadId = m_pMchLua->GetHeadId( sName) ;
   if ( nHeadId != GDB_ID_NULL)
      LuaSetParam( L, nHeadId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSpecialHead( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'HSet' dalla tabella
   string sHSet ;
   LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
  // lettura campo 'Pos' dalla tabella
   Point3d ptPos ;
   LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
  // lettura campo 'TDir' dalla tabella
   Vector3d vtTDir ;
   LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
  // lettura eventuale campo 'ADir' dalla tabella
   Vector3d vtADir ;
   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
  // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
   double dRot1W = 1 ;
   LuaGetTabFieldParam( L, 1, FLD_ROT1W, dRot1W) ;
  // lettura eventuale campo 'MaxDeltaR2OnFirst' dalla tabella (default true)
   bool bMaxDeltaR2On1 = true ;
   LuaGetTabFieldParam( L, 1, FLD_MAXDELTAR2ON1, bMaxDeltaR2On1) ;
  // lettura eventuale campo 'Rot2Stroke' dalla tabella
   STROKE Rot2Stroke{{ -INFINITO, INFINITO}} ;
   LuaGetTabFieldParam( L, 1, FLD_ROT2STROKE, Rot2Stroke.v) ;
  // lettura eventuale campo 'SolCh' dalla tabella
   int nSolCh = MCH_SCC_NONE ;
   LuaGetTabFieldParam( L, 1, FLD_SOLCH, nSolCh) ;
  // lettura eventuale campo 'OthColl' dalla tabella
   STRVECTOR vsOthColl ;
   LuaGetTabFieldParam( L, 1, FLD_OTHCOLL, vsOthColl) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtSpecialHead : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della testa standard
   if ( ! m_pMchLua->LoadMachineSpecialHead( sName, sParent, sHSet, ptPos, vtTDir, vtADir,
                                             dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
      return luaL_error( L, " Load Machine Special Head failed") ;

  // restituisco l'indice della testa
   int nHeadId = m_pMchLua->GetHeadId( sName) ;
   if ( nHeadId != GDB_ID_NULL)
      LuaSetParam( L, nHeadId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtTcPos( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo opzionale 'ExitNbr' dalla tabella
   int nExitNbr = 1 ;
   LuaGetTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr) ;

  // Procedo alla lettura a seconda del tnumero di uscite
   if ( nExitNbr == 1)
      return LuaEmtStdTcPos( L) ;
   else if ( nExitNbr > 1)
      return LuaEmtMultiTcPos( L) ;
   else
      return luaL_error( L, " Tc Position type unknown") ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtStdTcPos( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'Pos' dalla tabella
   Point3d ptPos ;
   LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
  // lettura campo 'TDir' dalla tabella
   Vector3d vtTDir ;
   LuaCheckTabFieldParam( L, 1, FLD_TDIR, vtTDir)
  // lettura eventuale campo 'ADir' dalla tabella
   Vector3d vtADir ;
   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtTcPos : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della posizione cambio utensile
   if ( ! m_pMchLua->LoadMachineStdTcPos( sName, sParent, ptPos, vtTDir, vtADir, sGeo, vsAux))
      return luaL_error( L, " Load Machine Standard Tc Position failed") ;

  // restituisco l'indice della posizione cambio utensile
   int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
   if ( nTcPosId != GDB_ID_NULL)
      LuaSetParam( L, nTcPosId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtMultiTcPos( lua_State* L)
{
  // Il parametro 1 deve essere una tabella
   if ( ! lua_istable( L, 1))
      return luaL_error( L, " Invalid Parameter, required a table") ;
  // lettura campo 'Name' dalla tabella
   string sName ;
   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
  // lettura campo 'Parent' dalla tabella
   string sParent ;
   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
  // lettura campo 'ExitNbr' dalla tabella
   int nExitNbr ;
   LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
  // lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
   MUEXITVECTOR vMuExit ;
   vMuExit.reserve( nExitNbr) ;
   for ( int i = 0 ; i < nExitNbr ;  ++ i) {
     // lettura
      string sPos = FLD_POS + ToString( i + 1) ;
      Point3d ptPos ;
      LuaCheckTabFieldParam( L, 1, sPos.c_str(), ptPos)
      string sTDir = FLD_TDIR + ToString( i + 1) ;
      Vector3d vtTDir ;
      LuaCheckTabFieldParam( L, 1, sTDir.c_str(), vtTDir)
     // inserimento nell'array
      vMuExit.emplace_back( ptPos, vtTDir) ;
   }
  // lettura eventuale campo 'ADir' dalla tabella
   Vector3d vtADir ;
   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
  // lettura campo 'Geo' dalla tabella
   string sGeo ;
   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
  // lettura eventuale campo 'Aux' dalla tabella
   STRVECTOR vsAux ;
   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
   LuaClearStack( L) ;

  // info
   string sOut = "LuaEmtTcPos : " + sName ;
   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())

  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;

  // carico i dati della posizione cambio utensile
   if ( ! m_pMchLua->LoadMachineMultiTcPos( sName, sParent, vMuExit, vtADir, sGeo, vsAux))
      return luaL_error( L, " Load Machine Multi Tc Position failed") ;

  // restituisco l'indice della posizione cambio utensile
   int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
   if ( nTcPosId != GDB_ID_NULL)
      LuaSetParam( L, nTcPosId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisPosition( lua_State* L)
{
  // 2 parametri : sAxisName, ptPos
   string sAxisName ;
   LuaCheckParam( L, 1, sAxisName)
   Point3d ptPos ;
   LuaCheckParam( L, 2, ptPos)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico la posizione dell'asse
   bool bOk = m_pMchLua->ModifyMachineAxisPosition( sAxisName, ptPos) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisDirection( lua_State* L)
{
  // 2 parametri : sAxisName, vtDir
   string sAxisName ;
   LuaCheckParam( L, 1, sAxisName)
   Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico la direzione dell'asse
   bool bOk = m_pMchLua->ModifyMachineAxisDirection( sAxisName, vtDir) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisStroke( lua_State* L)
{
  // 2 parametri : sAxisName, {dMin, dMax}
   string sAxisName ;
   LuaCheckParam( L, 1, sAxisName)
   STROKE Stroke ;
   LuaCheckParam( L, 2, Stroke.v)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico i limiti di corsa dell'asse
   bool bOk = m_pMchLua->ModifyMachineAxisStroke( sAxisName, Stroke) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyAxisHome( lua_State* L)
{
  // 2 parametri : sAxisName, dHome
   string sAxisName ;
   LuaCheckParam( L, 1, sAxisName)
   double dHome ;
   LuaCheckParam( L, 2, dHome)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico la posizione home dell'asse
   bool bOk = m_pMchLua->ModifyMachineAxisHome( sAxisName, dHome) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyHeadAuxDirection( lua_State* L)
{
  // 2 parametri : sHead, vtADir
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   Vector3d vtADir ;
   LuaCheckParam( L, 2, vtADir)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico la direzione ausiliaria della testa
   bool bOk = m_pMchLua->ModifyMachineHeadAuxDirection( sHead, vtADir) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtModifyExitPosition( lua_State* L)
{
  // 3 parametri : sHead, nExit, ptPos
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   int nExit ;
   LuaCheckParam( L, 2, nExit)
   Point3d ptPos ;
   LuaCheckParam( L, 3, ptPos)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // modifico la posizione dell'uscita della testa
   bool bOk = m_pMchLua->ModifyMachineExitPosition( sHead, nExit, ptPos) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkRawPartToGroup( lua_State* L)
{
  // 2 parametri : nRawId, sGroupName
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   string sGroupName ;
   LuaCheckParam( L, 2, sGroupName)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // aggancio il grezzo al gruppo
   bool bOk = m_pMchLua->LinkRawPartToGroup( nRawId, sGroupName) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkRawPartFromGroup( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto il grezzo nel gruppo dei grezzi
   bool bOk = m_pMchLua->UnlinkRawPartFromGroup( nRawId) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtGetAllLinkedRawParts( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // recupero l'elenco dei grezzi agganciati ad un gruppo macchina
   const INTVECTOR& vLinkedRawParts = m_pMchLua->GetAllLinkedRawParts() ;
  // assegno risultato
   LuaSetParam( L, vLinkedRawParts) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllRawPartsFromGroups( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto tutti i grezzi linkati nel gruppo dei grezzi
   bool bOk = m_pMchLua->UnlinkAllRawPartsFromGroups() ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkFixtureToGroup( lua_State* L)
{
  // 2 parametri : nFxtId, sGroupName
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   string sGroupName ;
   LuaCheckParam( L, 2, sGroupName)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // aggancio il bloccaggio al gruppo
   bool bOk = m_pMchLua->LinkFixtureToGroup( nFxtId, sGroupName) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkFixtureFromGroup( lua_State* L)
{
  // 1 parametro : nFxtId
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto il bloccaggio nel gruppo delle fixtures
   bool bOk = m_pMchLua->UnlinkFixtureFromGroup( nFxtId) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllFixturesFromGroups( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto tutti i bloccaggi linkati nel gruppo delle fixtures
   bool bOk = m_pMchLua->UnlinkAllFixturesFromGroups() ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtLinkPartToGroup( lua_State* L)
{
  // 2 parametri : nPartId, sGroupName
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   string sGroupName ;
   LuaCheckParam( L, 2, sGroupName)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // aggancio il pezzo al gruppo
   bool bOk = m_pMchLua->LinkPartToGroup( nPartId, sGroupName) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkPartFromGroup( lua_State* L)
{
  // 1 parametro : nRawId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto il pezzo nel suo grezzo
   bool bOk = m_pMchLua->UnlinkPartFromGroup( nPartId) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtUnlinkAllPartsFromGroups( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // riporto tutti i pezzi linkati nel loro grezzo
   bool bOk = m_pMchLua->UnlinkAllPartsFromGroups() ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtWrite( lua_State* L)
{
  // 1 parametro : string
   string sOut ;
   LuaCheckParam( L, 1, sOut)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // emetto stringa
   bool bOk = m_pMchLua->WriterEmit( sOut) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSetOutstrokeInfo( lua_State* L)
{
  // 5 parametri : sAxName, sAxToken, bLinear, dExtra, sAuxInfo 
   string sAxName ;
   LuaCheckParam( L, 1, sAxName)
   string sAxToken ;
   LuaCheckParam( L, 2, sAxToken)
   bool bLinear ;
   LuaCheckParam( L, 3, bLinear)
   double dExtra ;
   LuaCheckParam( L, 4, dExtra)
   string sAuxInfo ;
   LuaCheckParam( L, 5, sAuxInfo)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // assegno i dati
   m_pMchLua->m_OutstrokeInfo.sAxName = sAxName ;
   m_pMchLua->m_OutstrokeInfo.sAxToken = sAxToken ;
   m_pMchLua->m_OutstrokeInfo.bLinear = bLinear ;
   m_pMchLua->m_OutstrokeInfo.dExtra = dExtra ;
   m_pMchLua->m_OutstrokeInfo.sAuxInfo = sAuxInfo ;
  // assegno risultato
   LuaSetParam( L, true) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSetLastError( lua_State* L)
{
  // 2 o 3 parametri : nErrId, sErrDesc [, bSoftExit = false]
   int nErrId ;
   LuaCheckParam( L, 1, nErrId)
   string sErrDesc ;
   LuaCheckParam( L, 2, sErrDesc)
   bool bSoftExit = false ;
   LuaGetParam( L, 3, bSoftExit) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // imposto informazioni di errore
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SetLastError( nErrId, sErrDesc)) ;
   string sOut = "(" + ToString( nErrId) + ") " + sErrDesc ;
  // se uscita dolce
   if ( bSoftExit) {
      LuaSetParam( L, true) ;
      return 1 ;
   }
   else
      return luaL_error( L, sOut.c_str()) ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSetWarning( lua_State* L)
{
  // 2 parametri : nWarnId, sWarnDesc
   int nWarnId ;
   LuaCheckParam( L, 1, nWarnId)
   string sWarnDesc ;
   LuaCheckParam( L, 2, sWarnDesc)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // imposto informazioni di warning
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SetWarning( nWarnId, sWarnDesc)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtAddCollisionObj( lua_State* L)
{
  // 6 parametri : nInd, nFrameId, nType, dPar1, dPar2, dPar3
   int nInd ;
   LuaCheckParam( L, 1, nInd)
   int nFrameId ;
   LuaCheckParam( L, 2, nFrameId)
   int nType ;
   LuaCheckParam( L, 3, nType)
   double dPar1 ;
   LuaCheckParam( L, 4, dPar1)
   double dPar2 ;
   LuaCheckParam( L, 5, dPar2)
   double dPar3 ;
   LuaCheckParam( L, 6, dPar3)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // assegno i dati
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimAddCollisionObj( nInd, false, nFrameId, nType, Vector3d(), dPar1, dPar2, dPar3)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtAddCollisionObjEx( lua_State* L)
{
  // 7 o 8 parametri : nInd, nFrameId, nType, vtMove, dPar1, dPar2, dPar3 [,bToolOn] 
   int nInd ;
   LuaCheckParam( L, 1, nInd)
   int nFrameId ;
   LuaCheckParam( L, 2, nFrameId)
   int nType ;
   LuaCheckParam( L, 3, nType)
   Vector3d vtMove ;
   LuaCheckParam( L, 4, vtMove)
   double dPar1 ;
   LuaCheckParam( L, 5, dPar1)
   double dPar2 ;
   LuaCheckParam( L, 6, dPar2)
   double dPar3 ;
   LuaCheckParam( L, 7, dPar3)
   bool bToolOn = false ;
   LuaGetParam( L, 8, bToolOn) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // assegno i dati
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimAddCollisionObj( nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtRemoveCollisionObj( lua_State* L)
{
  // 1 parametro : nFrameId 
   int nFrameId ;
   LuaCheckParam( L, 1, nFrameId)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // assegno i dati
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimRemoveCollisionObj( nFrameId)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtGetCollisionObj( lua_State* L)
{
  // 1 parametro : nPos 
   int nPos ;
   LuaCheckParam( L, 1, nPos)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // recupero i dati
   int nInd ;
   bool bToolOn ;
   int nFrameId ;
   int nType ;
   Vector3d vtMove ;
   double dPar1 ;
   double dPar2 ;
   double dPar3 ;
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr  &&
                m_pMchLua->m_pMchMgr->SimGetCollisionObj( nPos, nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3)) ;
  // assegno risultato
   if ( bOk) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, nInd) ;
      LuaSetParam( L, bToolOn) ;
      LuaSetParam( L, nFrameId) ;
      LuaSetParam( L, nType) ;
      LuaSetParam( L, vtMove) ;
      LuaSetParam( L, dPar1) ;
      LuaSetParam( L, dPar2) ;
      LuaSetParam( L, dPar3) ;
      return 9 ;  
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtExecCollisionCheck( lua_State* L)
{
  // 1 parametro opzionale : [nMoveType = 0]
   int nMoveType = 0 ;
   LuaGetParam( L, 1, nMoveType) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // eseguo la verifica di collisione (nessuna collisione -> true)
   int nCdInd = -1, nObjInd = -1 ;
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimExecCollisionCheck( nCdInd, nObjInd, nMoveType)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nCdInd) ;
   LuaSetParam( L, nObjInd) ;
   return 3 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtOnCollision( lua_State* L)
{
  // 2 parametri : nCdInd, nObjInd
   int nCdInd ;
   LuaCheckParam( L, 1, nCdInd)
   int nObjInd ;
   LuaCheckParam( L, 2, nObjInd)
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // eseguo gestione della collisione in simulazione
   int nErr = 0 ;
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimOnCollision(  nCdInd, nObjInd, nErr)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nErr) ;
   return 2 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSetToolForVmill( lua_State* L)
{
  // 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag , dPar1, dPar2]
   string sTool ;
   LuaGetParam( L, 1, sTool) ;
   string sHead ;
   LuaGetParam( L, 2, sHead) ;
   int nExit = 0 ;
   LuaGetParam( L, 3, nExit) ;
   INTVECTOR vVmill ;
   LuaGetParam( L, 4, vVmill) ;
   int nFlag = 0 ;
   LuaGetParam( L, 5, nFlag) ;
   double dPar1 = 0 ;
   LuaGetParam( L, 6, dPar1) ;
   double dPar2 = 0 ;
   LuaGetParam( L, 7, dPar2) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // imposto dati primo utensile per virtual milling in simulazione
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
                m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, true)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtAddToolForVmill( lua_State* L)
{
  // 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag, dPar1, dPar2]
   string sTool ;
   LuaGetParam( L, 1, sTool) ;
   string sHead ;
   LuaGetParam( L, 2, sHead) ;
   int nExit = 0 ;
   LuaGetParam( L, 3, nExit) ;
   INTVECTOR vVmill ;
   LuaGetParam( L, 4, vVmill) ;
   int nFlag = 0 ;
   LuaGetParam( L, 5, nFlag) ;
   double dPar1 = 0 ;
   LuaGetParam( L, 6, dPar1) ;
   double dPar2 = 0 ;
   LuaGetParam( L, 7, dPar2) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // imposto dati utensile aggiuntivo per virtual milling in simulazione
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
                m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, false)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtEnableToolsForVmill( lua_State* L)
{
  // 1 parametro : bEnable
   bool bEnable = false ;
   LuaGetParam( L, 1, bEnable) ;
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // imposto abilitazione utensili per virtual milling in simulazione
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimEnableToolsForVmill( bEnable)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtMoveAxes( lua_State* L)
{
  // 4, ..., 31 parametri : nMoveType, sAx1, dPos1, dStep1 [, sAx2, dPos2, dStep2] ... [, sAx10, dPos10, dStep10]
   int nMoveType = 0 ;
   LuaGetParam( L, 1, nMoveType) ;
   SAMVECTOR vAxNaEpSt ;
   for ( int i = 0 ; i < 10 ; ++ i) {
      int nInd = 2 + 3 * i ;
      string sAxN ;
      double dEndN ;
      double dStepN ;
      if ( LuaGetParam( L, nInd, sAxN)  &&  LuaGetParam( L, nInd + 1, dEndN)  &&  LuaGetParam( L, nInd + 2, dStepN))
         vAxNaEpSt.emplace_back( sAxN, dEndN, dStepN) ;
      else
         break ;
   }
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // eseguo movimento in simulazione
   int nRes = 0 ;
   if ( m_pMchLua->m_pMchMgr != nullptr)
      nRes = m_pMchLua->m_pMchMgr->SimMoveAxes( nMoveType, vAxNaEpSt) ;
  // assegno risultato
   if ( nRes == SIM_AXMV_RES_STOP)
      return luaL_error( L, "STOP") ;
   else {
      LuaSetParam( L, ( nRes == SIM_AXMV_RES_OK)) ;
      LuaSetParam( L, m_pMchLua->GetMultiProcess()) ;
   }
   return 2 ;
}

//----------------------------------------------------------------------------
int
Machine::LuaEmtSaveCmd( lua_State* L)
{
  //  parametri : nType, 
   int nType = 0 ;
   LuaGetParam( L, 1, nType) ;
   int nPar = 0 ;
   LuaGetParam( L, 2, nPar) ;
   string sPar ;
   LuaGetParam( L, 3, sPar) ;
   string sPar2 ;
   if ( nType == 4) {
      switch ( lua_type( L, 4)) {
      case LUA_TNIL :
         nPar = 0 ;
        break ;
      case LUA_TBOOLEAN :
      {  nPar = 1 ;
         bool bVal ;
         LuaGetParam( L, 4, bVal) ;
         sPar2 = ( bVal ? "1" : "0") ;
      } break ;
      case LUA_TNUMBER :
         if ( lua_isinteger( L, 4)) {
            nPar = 2 ;
            int nVal ;
            LuaGetParam( L, 4, nVal) ;
            sPar2 = ToString( nVal) ;
         }
         else {
            nPar = 3 ;
            double dVal ;
            LuaGetParam( L, 4, dVal) ;
            sPar2 = ToString( dVal, 9) ;
         }
        break ;
      case LUA_TSTRING :
      {  nPar = 4 ;
         LuaGetParam( L, 4, sPar2) ;
      } break ;
      default :
         return luaL_error( L, " Unknown Type") ;
      }
   }
   LuaClearStack( L) ;
  // verifico ci sia una macchina attiva
   if ( m_pMchLua == nullptr)
      return luaL_error( L, " Unknown Machine") ;
  // salvo il comando
   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimSaveCmd( nType, nPar, sPar, sPar2)) ;
  // assegno risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}