EgtExecutor/LUA_MachMgr.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : LUA_MachMgr.cpp       Data : 24.03.15        Versione : 1.6c8
// Contenuto : Funzioni Machining Manager per LUA.
//
//
//
// Modifiche : 24.03.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "LUA.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EMkToolConst.h"
#include "/EgtDev/Include/EMkMachiningConst.h"
#include "/EgtDev/Include/EGkGdbConst.h"
#include "/EgtDev/Include/EGkLuaAux.h"

using namespace std ;

//-------------------------------------------------------------------------------
//    Machines
//-------------------------------------------------------------------------------
static int
LuaSetCurrMachine( lua_State* L)
{
  // 1 parametro : nome della macchina
   string sMachineName ;
   LuaCheckParam( L, 1, sMachineName)
   LuaClearStack( L) ;
  // rendo corrente la macchina
   bool bOk = ExeSetCurrMachine( sMachineName) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrMachineName( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il nome della macchina
   string sMachineName ;
   bool bOk = ExeGetCurrMachineName( sMachineName) ; 
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sMachineName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrMachineDir( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il direttorio della macchina
   string sMachineDir ;
   bool bOk = ExeGetCurrMachineDir( sMachineDir) ; 
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sMachineDir) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Mach Groups
//-------------------------------------------------------------------------------
static int
LuaGetMachGroupCount( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il numero di macchinate
   int nTot = ExeGetMachGroupCount() ; 
  // restituisco il risultato
   LuaSetParam( L, nTot) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstMachGroup( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'identificativo della prima macchinata
   int nId = ExeGetFirstMachGroup() ; 
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextMachGroup( lua_State* L)
{
  // 1 parametro : identificativo di una macchinata
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero l'identificativo della successiva macchinata
   int nNextId = ExeGetNextMachGroup( nId) ; 
  // restituisco il risultato
   if ( nNextId != GDB_ID_NULL)
      LuaSetParam( L, nNextId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMachGroupNewName( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // verifico nome e se necessario lo modifico per renderlo nuovo
   bool bOk = ExeGetMachGroupNewName( sName) ;
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaAddMachGroup( lua_State* L)
{
  // 1 o 2 parametri : nome del gruppo [, nome della macchina da utilizzare]
   string sName ;
   LuaCheckParam( L, 1, sName)
   string sMachineName ;
   LuaGetParam( L, 2, sMachineName) ;
   LuaClearStack( L) ;
  // aggiungo la macchinata
   int nId = ExeAddMachGroup( sName, sMachineName) ; 
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveMachGroup( lua_State* L)
{
  // 1 parametro : identificativo del gruppo
   int nMGroupInd ;
   LuaCheckParam( L, 1, nMGroupInd)
   LuaClearStack( L) ;
  // rimuovo la macchinata
   bool bOk = ExeRemoveMachGroup( nMGroupInd) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMachGroupName( lua_State* L)
{
  // 1 parametro : identificativo del gruppo
   int nMGroupInd ;
   LuaCheckParam( L, 1, nMGroupInd)
   LuaClearStack( L) ;
  // recupero il nome della macchinata
   string sName ;
   bool bOk = ExeGetMachGroupName( nMGroupInd, sName) ; 
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMachGroupId( lua_State* L)
{
  // 1 parametro : nome del gruppo
   string sGroupName ;
   LuaCheckParam( L, 1, sGroupName)
   LuaClearStack( L) ;
  // recupero l'identificativo della macchinata
   int nId = ExeGetMachGroupId( sGroupName) ; 
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetCurrMachGroup( lua_State* L)
{
  // nessuno o 1 parametro : [identificativo del gruppo]
   int nMGroupInd ;
   if ( ! LuaGetParam( L, 1, nMGroupInd))
      nMGroupInd = ExeGetFirstMachGroup() ;
   LuaClearStack( L) ;
  // imposto il gruppo corrente
   bool bOk = ExeSetCurrMachGroup( nMGroupInd) ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetCurrMachGroup( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // imposto il gruppo corrente
   bool bOk = ExeResetCurrMachGroup() ; 
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrMachGroup( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'identificativo del gruppo corrente
   int nId = ExeGetCurrMachGroup() ; 
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Setup
//-------------------------------------------------------------------------------
static int
LuaGetCurrSetup( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'identificativo del gruppo di attrezzaggio della macchinata corrente
   int nSetupId = ExeGetCurrPhase() ;
  // restituisco il risultato
   if ( nSetupId != GDB_ID_NULL)
      LuaSetParam( L, nSetupId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Phases
//-------------------------------------------------------------------------------
static int
LuaAddPhase( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // aggiungo una nuova fase di lavorazione alla macchinata corrente
   int nPhase = ExeAddPhase() ;
  // restituisco il risultato
   if ( nPhase > 0)
      LuaSetParam( L, nPhase) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetCurrPhase( lua_State* L)
{
  // 1 o 2 parametri : nPhase [, bForced = false]
   int nPhase ;
   LuaCheckParam( L, 1, nPhase)
   bool bForced = false ;
   LuaGetParam( L, 2, bForced) ;
   LuaClearStack( L) ;
  // imposto la fase di lavorazione corrente nella macchinata corrente
   bool bOk = ExeSetCurrPhase( nPhase, bForced) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrPhase( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero la fase di lavorazione corrente nella macchinata corrente
   int nPhase = ExeGetCurrPhase() ;
  // restituisco il risultato
   LuaSetParam( L, nPhase) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveLastPhase( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // elimina l'ultima fase di lavorazione dalla macchinata corrente
   bool bOk = ExeRemoveLastPhase() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPhaseCount( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il numero totale di fasi di lavorazione nella macchinata corrente
   int nCount = ExeGetPhaseCount() ;
  // restituisco il risultato
   LuaSetParam( L, nCount) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Raw Parts & Parts
//-------------------------------------------------------------------------------
static int
LuaGetRawPartCount( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il numero di grezzi nella macchinata corrente
   int nCount = ExeGetRawPartCount() ;
  // restituisco il risultato
   LuaSetParam( L, nCount) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstRawPart( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero identificativo primo grezzo nella macchinata corrente
   int nId = ExeGetFirstRawPart() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextRawPart( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // recupero identificativo successivo grezzo nella macchinata corrente
   int nId = ExeGetNextRawPart( nRawId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}
//-------------------------------------------------------------------------------
static int
LuaAddRawPart( lua_State* L)
{
  // 5 parametri : Pto origine, dLen, dWidth, dH, Color
   Point3d ptOrig ;
   LuaCheckParam( L, 1, ptOrig)
   double dLength ;
   LuaCheckParam( L, 2, dLength)
   double dWidth ;
   LuaCheckParam( L, 3, dWidth)
   double dHeight ;
   LuaCheckParam( L, 4, dHeight)
   Color cCol ;
   LuaCheckParam( L, 5, cCol)
   LuaClearStack( L) ;
  // inserisco il grezzo nella macchinata corrente
   int nInd = ExeAddRawPart( ptOrig, dLength, dWidth, dHeight, cCol) ;
  // restituisco il risultato
   if ( nInd != GDB_ID_NULL)
      LuaSetParam( L, nInd) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaAddRawPartWithPart( lua_State* L)
{
  // 4 parametri : nPartId, nCrvId, dOverMat, Color
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   int nCrvId = GDB_ID_NULL ;
   LuaGetParam( L, 2, nCrvId) ;
   double dOverMat ;
   LuaCheckParam( L, 3, dOverMat)
   Color cCol ;
   LuaCheckParam( L, 4, cCol)
   LuaClearStack( L) ;
  // inserisco il grezzo nella macchinata corrente
   int nInd = ExeAddRawPartWithPart( nPartId, nCrvId, dOverMat, cCol) ;
  // restituisco il risultato
   if ( nInd != GDB_ID_NULL)
      LuaSetParam( L, nInd) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyRawPart( lua_State* L)
{
  // 6 parametri : nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   int nCrvId ;
   LuaCheckParam( L, 2, nCrvId)
   double dOverMat ;
   LuaCheckParam( L, 3, dOverMat)
   double dZmin ;
   LuaCheckParam( L, 4, dZmin)
   double dHeight ;
   LuaCheckParam( L, 5, dHeight)
   Color cCol ;
   LuaCheckParam( L, 6, cCol)
   LuaClearStack( L) ;
  // modifico le dimensioni del grezzo
   bool bOk = ExeModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyRawPartSize( lua_State* L)
{
  // 4 parametri : nRawId, dLength, dWidth, dHeight
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   double dLength ;
   LuaCheckParam( L, 2, dLength)
   double dWidth ;
   LuaCheckParam( L, 3, dWidth)
   double dHeight ;
   LuaCheckParam( L, 4, dHeight)
   LuaClearStack( L) ;
  // modifico le dimensioni del grezzo
   bool bOk = ExeModifyRawPartSize( nRawId, dLength, dWidth, dHeight) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyRawPartHeight( lua_State* L)
{
  // 2 parametri : nRawId, dHeight
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   double dHeight ;
   LuaCheckParam( L, 2, dHeight)
   LuaClearStack( L) ;
  // modifico lo spessore del grezzo
   bool bOk = ExeModifyRawPartHeight( nRawId, dHeight) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaKeepRawPart( lua_State* L)
{
  // 1 o 2 parametri : nRawId [, nSouPhase]
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   int nSouPhase = 0 ;
   LuaGetParam( L, 2, nSouPhase) ;
   LuaClearStack( L) ;
  // confermo il grezzo nella fase corrente della macchinata corrente
   bool bOk = ExeKeepRawPart( nRawId, nSouPhase) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaVerifyRawPartPhase( lua_State* L)
{
  // 2 parametri : nRawId, nPhase
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   int nPhase ;
   LuaCheckParam( L, 2, nPhase)
   LuaClearStack( L) ;
  // verifico che il grezzo sia valido ed appartenga alla fase di lavorazione indicata
   bool bOk = ExeVerifyRawPartPhase( nRawId, nPhase) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveRawPartFromCurrPhase( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // elimino il grezzo dalla fase corrente della macchinata corrente
   bool bOk = ExeRemoveRawPartFromCurrPhase( nRawId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveRawPart( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // elimino il grezzo dalla macchinata corrente
   bool bOk = ExeRemoveRawPart( nRawId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveRawPart( lua_State* L)
{
  // 2 parametri : nRawId, vtMove
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // traslo il grezzo
   bool bOk = ExeMoveRawPart( nRawId, vtMove) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetRawPartCenter( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // traslo il grezzo
   Point3d ptCen ;
   bool bOk = ExeGetRawPartCenter( nRawId, ptCen) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, ptCen) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSplitFlatRawPartWithMachinings( lua_State* L)
{
  // 2 parametri : nRawId, vMchId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   INTVECTOR vMchId ;
   LuaCheckParam( L, 2, vMchId)
   LuaClearStack( L) ;
  // divido il grezzo in parti in base ai tagli delle lavorazioni
   int nId = ExeSplitFlatRawPartWithMachinings( nRawId, vMchId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotateRawPart( lua_State* L)
{
  // 3 parametri : nRawId, vtAx, dAngRotDeg
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   Vector3d vtAx ;
   LuaCheckParam( L, 2, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 3, dAngRotDeg)
   LuaClearStack( L) ;
  // ruoto il grezzo
   bool bOk = ExeRotateRawPart( nRawId, vtAx, dAngRotDeg) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveToCornerRawPart( lua_State* L)
{
  // 3 parametri : nRawId, ptCorner, nFlag
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   Point3d ptCorner ;
   LuaCheckParam( L, 2, ptCorner)
   int nFlag ;
   LuaCheckParam( L, 3, nFlag)
   LuaClearStack( L) ;
  // sposto il grezzo nel corner
   bool bOk = ExeMoveToCornerRawPart( nRawId, ptCorner, nFlag) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveToCenterRawPart( lua_State* L)
{
  // 3 parametri : nRawId, ptCenter, nFlag
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   Point3d ptCenter ;
   LuaCheckParam( L, 2, ptCenter)
   int nFlag ;
   LuaCheckParam( L, 3, nFlag)
   LuaClearStack( L) ;
  // sposto il grezzo nel corner
   bool bOk = ExeMoveToCenterRawPart( nRawId, ptCenter, nFlag) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPartInRawPartCount( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // recupero il numero di pezzi nel grezzo
   int nCount = ExeGetPartInRawPartCount( nRawId) ;
  // restituisco il risultato
   LuaSetParam( L, nCount) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstPartInRawPart( lua_State* L)
{
  // 1 parametro : nRawId
   int nRawId ;
   LuaCheckParam( L, 1, nRawId)
   LuaClearStack( L) ;
  // recupero identificativo primo pezzo nel grezzo
   int nId = ExeGetFirstPartInRawPart( nRawId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextPartInRawPart( lua_State* L)
{
  // 1 parametro : nPartId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // recupero identificativo successivo pezzo nello stesso grezzo
   int nId = ExeGetNextPartInRawPart( nPartId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaAddPartToRawPart( lua_State* L)
{
  // 3 parametri : nPartId, ptPos, nRawId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   Point3d ptPos ;
   LuaCheckParam( L, 2, ptPos)
   int nRawId ;
   LuaCheckParam( L, 3, nRawId)
   LuaClearStack( L) ;
  // inserisco il grezzo nella macchinata corrente
   bool bOk = ExeAddPartToRawPart( nPartId, ptPos, nRawId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetRawPartFromPart( lua_State* L)
{
  // 1 parametro : nPartId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // cerco il grezzo della fase corrente della macchinata corrente cui appartiene il pezzo
   int nRawId = ExeGetRawPartFromPart( nPartId) ;
  // restituisco il risultato
   if ( nRawId != GDB_ID_NULL)
      LuaSetParam( L, nRawId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemovePartFromRawPart( lua_State* L)
{
  // 1 parametro : nPartId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // elimino il grezzo dalla macchinata corrente
   bool bOk = ExeRemovePartFromRawPart( nPartId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTranslatePartInRawPart( lua_State* L)
{
  // 2 parametri : nPartId, vtMove
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // traslo il pezzo nel grezzo
   bool bOk = ExeTranslatePartInRawPart( nPartId, vtMove) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotatePartInRawPart( lua_State* L)
{
  // 3 parametri : nPartId, vtAx, dAngRotDeg
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   Vector3d vtAx ;
   LuaCheckParam( L, 2, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 3, dAngRotDeg)
   LuaClearStack( L) ;
  // ruoto il pezzo nel grezzo
   bool bOk = ExeRotatePartInRawPart( nPartId, vtAx, dAngRotDeg) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Table & Fixtures
//-------------------------------------------------------------------------------
static int
LuaSetTable( lua_State* L)
{
  // 1 parametro : sTable
   string sTable ;
   LuaCheckParam( L, 1, sTable)
   LuaClearStack( L) ;
  // imposto la tavola corrente
   bool bOk = ExeSetTable( sTable) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTableName( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il nome della tavola corrente
   string sTable ;
   bool bOk = ExeGetTable( sTable) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sTable) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTableRef( lua_State* L)
{
  // 1 parametro opzionale : [nInd]
   int nInd = 1 ;
   LuaGetParam( L, 1, nInd) ;
   LuaClearStack( L) ;
  // recupero il riferimento nInd-esimo della tavola corrente
   Point3d ptPos ;
   bool bOk = ExeGetTableRef( nInd, ptPos) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, ptPos) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTableArea( lua_State* L)
{
  // 1 parametro opzionale : [nInd]
   int nInd = 1 ;
   LuaGetParam( L, 1, nInd) ;
   LuaClearStack( L) ;
  // recupero la area utile nInd-esima della tavola corrente
   BBox3d b3Area ;
   bool bOk = ExeGetTableArea( nInd, b3Area) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, b3Area) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaAddFixture( lua_State* L)
{
  // 2 o 3 o 4 parametri : sName, ptPos [, dAngRotDeg [, dMov]]
   string sName ;
   LuaCheckParam( L, 1, sName)
   Point3d ptPos ;
   LuaCheckParam( L, 2, ptPos)
   double dAngRotDeg = 0 ;
   double dMov = 0 ;
   if ( LuaGetParam( L, 3, dAngRotDeg))
      LuaGetParam( L, 4, dMov) ;
   LuaClearStack( L) ;
  // metto l'asse nella nuova posizione
   int nId = ExeAddFixture( sName, ptPos, dAngRotDeg, dMov) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaKeepFixture( lua_State* L)
{
  // 1 o 2 parametri : nFxtId [, nSouPhase]
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   int nSouPhase = 0 ;
   LuaGetParam( L, 2, nSouPhase) ;
   LuaClearStack( L) ;
  // confermo il bloccaggio nella fase corrente della macchinata corrente
   bool bOk = ExeKeepFixture( nFxtId, nSouPhase) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveFixture( lua_State* L)
{
  // 1 parametro : nFxtId
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   LuaClearStack( L) ;
  // rimuovo il bloccaggio
   bool bOk = ExeRemoveFixture( nFxtId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstFixture( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // cerco il primo bloccaggio
   int nId = ExeGetFirstFixture() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextFixture( lua_State* L)
{
  // 1 parametro : nFxtId
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   LuaClearStack( L) ;
  // cerco il successivo bloccaggio
   int nId = ExeGetNextFixture( nFxtId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveFixture( lua_State* L)
{
  // 2 parametri : nFxtId, vtMove
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // muovo il bloccaggio
   bool bOk= ExeMoveFixture( nFxtId, vtMove) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotateFixture( lua_State* L)
{
  // 2 parametri : nFxtId, dDeltaAngDeg
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   double dDeltaAngDeg ;
   LuaCheckParam( L, 2, dDeltaAngDeg)
   LuaClearStack( L) ;
  // ruoto il bloccaggio
   bool bOk= ExeRotateFixture( nFxtId, dDeltaAngDeg) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveFixtureMobile( lua_State* L)
{
  // 2 parametri : nFxtId, dDeltaMov
   int nFxtId ;
   LuaCheckParam( L, 1, nFxtId)
   double dDeltaMov ;
   LuaCheckParam( L, 2, dDeltaMov)
   LuaClearStack( L) ;
  // muovo di delta la parte mobile del bloccaggio
   bool bOk= ExeMoveFixtureMobile( nFxtId, dDeltaMov) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//     Tools database
//-------------------------------------------------------------------------------
static int
LuaTdbGetToolNewName( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // verifico nome e se necessario lo modifico per renderlo nuovo nel DB
   bool bOk = ExeTdbGetToolNewName( sName) ;
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbAddTool( lua_State* L)
{
  // 2 parametri : sName, nType
   string sName ;
   LuaCheckParam( L, 1, sName)
   int nType ;
   LuaCheckParam( L, 2, nType)
   LuaClearStack( L) ;
  // aggiungo l'utensile
   bool bOk = ExeTdbAddTool( sName, nType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbCopyTool( lua_State* L)
{
  // 2 parametri : sSource, sName
   string sSource ;
   LuaCheckParam( L, 1, sSource)
   string sName ;
   LuaCheckParam( L, 2, sName)
   LuaClearStack( L) ;
  // aggiungo l'utensile
   bool bOk = ExeTdbCopyTool( sSource, sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbRemoveTool( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // aggiungo l'utensile
   bool bOk = ExeTdbRemoveTool( sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbGetFirstTool( lua_State* L)
{
  // 1 parametro : nFamily
   int nFamily ;
   LuaCheckParam( L, 1, nFamily)
  // cerco il primo utensile della famiglia
   string sName ;
   int nType ;
   bool bOk = ExeTdbGetFirstTool( nFamily, sName, nType) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, sName) ;
      LuaSetParam( L, nType) ;
   }
   else {
      LuaSetParam( L, "") ;
      LuaSetParam( L, TT_NONE) ;
   }
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbGetNextTool( lua_State* L)
{
  // 1 parametro : nFamily
   int nFamily ;
   LuaCheckParam( L, 1, nFamily)
  // cerco il prossimo utensile della famiglia
   string sName ;
   int nType ;
   bool bOk = ExeTdbGetNextTool( nFamily, sName, nType) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, sName) ;
      LuaSetParam( L, nType) ;
   }
   else {
      LuaSetParam( L, "") ;
      LuaSetParam( L, TT_NONE) ;
   }
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbGetToolFromUUID( lua_State* L)
{
  // 1 parametro : sTuuid
   string sTuuid ;
   LuaCheckParam( L, 1, sTuuid)
   LuaClearStack( L) ;
   string sName ;
   bool bOk = ExeTdbGetToolFromUUID( sTuuid, sName) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbSetCurrTool( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // imposto l'utensile corrente
   bool bOk = ExeTdbSetCurrTool( sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbSaveCurrTool( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // salvo l'utensile corrente
   bool bOk = ExeTdbSaveCurrTool() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbIsCurrToolModified( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico se l'utensile corrente � stato modificato
   bool bOk = ExeTdbIsCurrToolModified() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbSetCurrToolParam( lua_State* L)
{
  // 2 parametri : nType, Val
   int nType ;
   LuaCheckParam( L, 1, nType)
  // leggo opportunamente il valore da assegnare
   if ( ( nType & TPA_BOOL) != 0) {
      bool bVal ;
      LuaCheckParam( L, 2, bVal)
      LuaClearStack( L) ;
      bool bOk = ExeTdbSetCurrToolParam( nType, bVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_INT) != 0) {
      int nVal ;
      LuaCheckParam( L, 2, nVal)
      LuaClearStack( L) ;
      bool bOk = ExeTdbSetCurrToolParam( nType, nVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_DOU) != 0) {
      double dVal ;
      LuaCheckParam( L, 2, dVal)
      LuaClearStack( L) ;
      bool bOk = ExeTdbSetCurrToolParam( nType, dVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_STR) != 0) {
      string sVal ;
      LuaCheckParam( L, 2, sVal)
      LuaClearStack( L) ;
      bool bOk = ExeTdbSetCurrToolParam( nType, sVal) ;
      LuaSetParam( L, bOk) ;
   }
   else
      LuaSetParam( L, false) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbGetCurrToolParam( lua_State* L)
{
  // 1 parametr : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
  // recupero il parametro dell'utensile voluto
   if ( ( nType & TPA_BOOL) != 0) {
      bool bVal ;
      bool bOk = ExeTdbGetCurrToolParam( nType, bVal) ;
      if ( bOk)
         LuaSetParam( L, bVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_INT) != 0) {
      int nVal ;
      bool bOk = ExeTdbGetCurrToolParam( nType, nVal) ;
      if ( bOk)
         LuaSetParam( L, nVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_DOU) != 0) {
      double dVal ;
      bool bOk = ExeTdbGetCurrToolParam( nType, dVal) ;
      if ( bOk)
         LuaSetParam( L, dVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_STR) != 0) {
      string sVal ;
      bool bOk = ExeTdbGetCurrToolParam( nType, sVal) ;
      if ( bOk)
         LuaSetParam( L, sVal) ;
      else
         LuaSetParam( L) ;
   }
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbReload( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // ricarico il DB utensili (eventuali modifiche dopo l'ultimo salvataggio vengono perse)
   bool bOk = ExeTdbReload() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTdbSave( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // lancio salvataggio DB utensili
   bool bOk = ExeTdbSave() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Machinings database
//-------------------------------------------------------------------------------
static int
LuaMdbGetMachiningNewName( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // verifico nome e se necessario lo modifico per renderlo nuovo nel DB
   bool bOk = ExeMdbGetMachiningNewName( sName) ;
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbAddMachining( lua_State* L)
{
  // 2 parametri : sName, nType
   string sName ;
   LuaCheckParam( L, 1, sName)
   int nType ;
   LuaCheckParam( L, 2, nType)
   LuaClearStack( L) ;
  // aggiungo la lavorazione
   bool bOk = ExeMdbAddMachining( sName, nType) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbCopyMachining( lua_State* L)
{
  // 2 parametri : sSource, sName
   string sSource ;
   LuaCheckParam( L, 1, sSource)
   string sName ;
   LuaCheckParam( L, 2, sName)
   LuaClearStack( L) ;
  // aggiungo la lavorazione
   bool bOk = ExeMdbCopyMachining( sSource, sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbRemoveMachining( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // aggiungo la lavorazione
   bool bOk = ExeMdbRemoveMachining( sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbGetFirstMachining( lua_State* L)
{
  // 1 parametro : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
  // cerco la prima lavorazione
   string sName ;
   bool bOk = ExeMdbGetFirstMachining( nType, sName) ;
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbGetNextMachining( lua_State* L)
{
  // 1 parametro : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
  // cerco la successiva lavorazione
   string sName ;
   bool bOk = ExeMdbGetNextMachining( nType, sName) ;
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbGetMachiningFromUUID( lua_State* L)
{
  // 1 parametro : sMuuid
   string sMuuid ;
   LuaCheckParam( L, 1, sMuuid)
   LuaClearStack( L) ;
   string sName ;
   bool bOk = ExeMdbGetMachiningFromUUID( sMuuid, sName) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbSetCurrMachining( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // imposto la lavorazione corrente
   bool bOk = ExeMdbSetCurrMachining( sName) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbSaveCurrMachining( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // salvo la lavorazione corrente
   bool bOk = ExeMdbSaveCurrMachining() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbIsCurrMachiningModified( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // verifico se la lavorazione corrente � stata modificata
   bool bOk = ExeMdbIsCurrMachiningModified() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbSetCurrMachiningParam( lua_State* L)
{
  // 2 parametri : nType, Val
   int nType ;
   LuaCheckParam( L, 1, nType)
  // leggo opportunamente il valore da assegnare
   if ( ( nType & TPA_BOOL) != 0) {
      bool bVal ;
      LuaCheckParam( L, 2, bVal)
      LuaClearStack( L) ;
      bool bOk = ExeMdbSetCurrMachiningParam( nType, bVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_INT) != 0) {
      int nVal ;
      LuaCheckParam( L, 2, nVal)
      LuaClearStack( L) ;
      bool bOk = ExeMdbSetCurrMachiningParam( nType, nVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_DOU) != 0) {
      double dVal ;
      LuaCheckParam( L, 2, dVal)
      LuaClearStack( L) ;
      bool bOk = ExeMdbSetCurrMachiningParam( nType, dVal) ;
      LuaSetParam( L, bOk) ;
   }
   else if ( ( nType & TPA_STR) != 0) {
      string sVal ;
      LuaCheckParam( L, 2, sVal)
      LuaClearStack( L) ;
      bool bOk = ExeMdbSetCurrMachiningParam( nType, sVal) ;
      LuaSetParam( L, bOk) ;
   }
   else
      LuaSetParam( L, false) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbGetCurrMachiningParam( lua_State* L)
{
  // 1 parametr : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
  // recupero il parametro della lavorazione nel DB
   if ( ( nType & TPA_BOOL) != 0) {
      bool bVal ;
      bool bOk = ExeMdbGetCurrMachiningParam( nType, bVal) ;
      if ( bOk)
         LuaSetParam( L, bVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_INT) != 0) {
      int nVal ;
      bool bOk = ExeMdbGetCurrMachiningParam( nType, nVal) ;
      if ( bOk)
         LuaSetParam( L, nVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_DOU) != 0) {
      double dVal ;
      bool bOk = ExeMdbGetCurrMachiningParam( nType, dVal) ;
      if ( bOk)
         LuaSetParam( L, dVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & TPA_STR) != 0) {
      string sVal ;
      bool bOk = ExeMdbGetCurrMachiningParam( nType, sVal) ;
      if ( bOk)
         LuaSetParam( L, sVal) ;
      else
         LuaSetParam( L) ;
   }
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbSetGeneralParam( lua_State* L)
{
  // 2 parametri : nType, dVal
   int nType ;
   LuaCheckParam( L, 1, nType)
   double dVal ;
   LuaCheckParam( L, 2, dVal)
   LuaClearStack( L) ;
  // lancio salvataggio
   bool bOk = ExeMdbSetGeneralParam( nType, dVal) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbGetGeneralParam( lua_State* L)
{
  // 1 parametro : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
  // lancio salvataggio
   double dVal ;
   bool bOk = ExeMdbGetGeneralParam( nType, dVal) ;
   if ( bOk)
      LuaSetParam( L, dVal) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbReload( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // ricarico il DB lavorazioni (eventuali modifiche dopo l'ultimo salvataggio vengono perse)
   bool bOk = ExeMdbReload() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMdbSave( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // lancio salvataggio
   bool bOk = ExeMdbSave() ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Operations
//-------------------------------------------------------------------------------
static int
LuaGetFirstOperation( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero la prima operazione della macchinata corrente
   int nId = ExeGetFirstOperation() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextOperation( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero la successiva operazione della macchinata corrente
   int nNextId = ExeGetNextOperation( nId) ;
  // restituisco il risultato
   if ( nNextId != GDB_ID_NULL)
      LuaSetParam( L, nNextId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLastOperation( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'ultima operazione della macchinata corrente
   int nId = ExeGetLastOperation() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPrevOperation( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero la precedente operazione della macchinata corrente
   int nNextId = ExeGetPrevOperation( nId) ;
  // restituisco il risultato
   if ( nNextId != GDB_ID_NULL)
      LuaSetParam( L, nNextId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}
//-------------------------------------------------------------------------------
static int
LuaGetFirstActiveOperation( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero la prima operazione attiva della macchinata corrente
   int nId = ExeGetFirstActiveOperation() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextActiveOperation( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero la successiva operazione attiva della macchinata corrente
   int nNextId = ExeGetNextActiveOperation( nId) ;
  // restituisco il risultato
   if ( nNextId != GDB_ID_NULL)
      LuaSetParam( L, nNextId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLastActiveOperation( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'ultima operazione attiva della macchinata corrente
   int nId = ExeGetLastActiveOperation() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPrevActiveOperation( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero la precedente operazione attiva della macchinata corrente
   int nNextId = ExeGetPrevActiveOperation( nId) ;
  // restituisco il risultato
   if ( nNextId != GDB_ID_NULL)
      LuaSetParam( L, nNextId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationType( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // restituisco il tipo dell'operazione indicata della macchinata corrente
   int nType = ExeGetOperationType( nId) ;
  // restituisco il risultato
   LuaSetParam( L, nType) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationPhase( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // restituisco la fase di appartenenza dell'operazione indicata della macchinata corrente
   int nPhase = ExeGetOperationPhase( nId) ;
  // restituisco il risultato
   LuaSetParam( L, nPhase) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationName( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // restituisco il nome dell'operazione indicata della macchinata corrente
   string sName ;
   bool bOk = ExeGetOperationName( nId, sName) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sName) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationId( lua_State* L)
{
  // 1 parametro : sName
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // restituisco l'identificativo dell'operazione nominata della macchinata corrente
   int nId = ExeGetOperationId( sName) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIsOperationEmpty( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato della operazione indicata della macchinata corrente
   bool bOk = ExeIsOperationEmpty( nId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveOperation( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // elimino l'operazione indicata della macchinata corrente
   bool bOk = ExeRemoveOperation( nId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveAllPhaseOperations( lua_State* L)
{
  // 1 parametro : nPhase
   int nPhase ;
   LuaCheckParam( L, 1, nPhase)
   LuaClearStack( L) ;
  // elimino tutte le operazioni (tranne la disposizione) della fase indicata della macchinata corrente
   bool bOk = ExeRemoveAllPhaseOperations( nPhase) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveAllOperations( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // elimino tutte le operazioni della macchinata corrente tranne la prima disposizione
   bool bOk = ExeRemoveAllOperations() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetOperationMode( lua_State* L)
{
  // 2 parametro : nId, bActive
   int nId ;
   LuaCheckParam( L, 1, nId)
   bool bActive ;
   LuaCheckParam( L, 2, bActive)
   LuaClearStack( L) ;
  // imposto l'attivazione dell'operazione
   bool bOk = ExeSetOperationMode( nId, bActive) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationMode( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero l'attivazione dell'operazione
   bool bActive ;
   bool bOk = ExeGetOperationMode( nId, bActive) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, bActive) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetAllOperationsMode( lua_State* L)
{
  // 1 parametro : bActive
   bool bActive ;
   LuaCheckParam( L, 1, bActive)
   LuaClearStack( L) ;
  // imposto l'attivazione di tutte le operazioni
   bool bOk = ExeSetAllOperationsMode( bActive) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetOperationStatus( lua_State* L)
{
  // 2 parametro : nId, bShow
   int nId ;
   LuaCheckParam( L, 1, nId)
   bool bShow ;
   LuaCheckParam( L, 2, bShow)
   LuaClearStack( L) ;
  // imposto lo stato di visualizzazione dell'operazione
   bool bOk = ExeSetOperationStatus( nId, bShow) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetOperationStatus( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato di visualizzazione dell'operazione
   bool bShow ;
   bool bOk = ExeGetOperationStatus( nId, bShow) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, bShow) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetAllOperationsStatus( lua_State* L)
{
  // 1 parametro : bShow
   bool bShow ;
   LuaCheckParam( L, 1, bShow)
   LuaClearStack( L) ;
  // imposto lo stato di visualizzazione di tutte le operazioni
   bool bOk = ExeSetAllOperationsStatus( bShow) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaChangeOperationPhase( lua_State* L)
{
  // 2 parametri : nId, nNewPhase
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nNewPhase ;
   LuaCheckParam( L, 2, nNewPhase)
   LuaClearStack( L) ;
  // cambio la fase dell'operazione e la sposto in fondo alle lavorazioni della stessa fase
   bool bOk = ExeChangeOperationPhase( nId, nNewPhase) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveOperationHome( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // elimino eventuale posizionamento finale in home dalla operazione
   bool bOk = ExeRemoveOperationHome( nId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Dispositions
//-------------------------------------------------------------------------------
static int
LuaGetPhaseDisposition( lua_State* L)
{
  // 1 parametro : nPhase
   int nPhase ;
   LuaCheckParam( L, 1, nPhase)
   LuaClearStack( L) ;
  // recupero la disposizione della fase indicata
   int nId = ExeGetPhaseDisposition( nPhase) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSpecialApplyDisposition( lua_State* L)
{
  // 1 o 2 parametri : nId [, bRecalc]
   int nId ;
   LuaCheckParam( L, 1, nId)
   bool bRecalc = false ;
   LuaGetParam( L, 1, bRecalc) ;
   LuaClearStack( L) ;
  // eseguo azione speciale su disposizione indicata
   bool bOk = ExeSpecialApplyDisposition( nId, bRecalc) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Machinings
//-------------------------------------------------------------------------------
static int
LuaAddMachining( lua_State* L)
{
  // 2 parametri : sName, sMachining
   string sName ;
   LuaCheckParam( L, 1, sName)
   string sMachining ;
   LuaCheckParam( L, 2, sMachining)
   LuaClearStack( L) ;
  // aggiungo la lavorazione
   int nId = ExeAddMachining( sName, sMachining) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCreateMachining( lua_State* L)
{
  // 3 parametri : sName, nMchType, sTool
   string sName ;
   LuaCheckParam( L, 1, sName)
   int nMchType ;
   LuaCheckParam( L, 2, nMchType)
   string sTool ;
   LuaCheckParam( L, 3, sTool)
   LuaClearStack( L) ;
  // aggiungo la lavorazione (creandola al momento)
   int nId = ExeAddMachining( sName, nMchType, sTool) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetCurrMachining( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // imposto la lavorazione come corrente
   bool bOk = ExeSetCurrMachining( nId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetCurrMachining( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // imposto la lavorazione come corrente
   bool bOk = ExeResetCurrMachining() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetMachiningParam( lua_State* L)
{
  // 2 parametri : nType, xVal
   int nType ;
   LuaCheckParam( L, 1, nType)
   bool bOk = false ;
   if ( ( nType & MPA_BOOL) != 0) {
      bool bVal ;
      LuaCheckParam( L, 2, bVal)
     // imposto il parametro alla lavorazione corrente
      bOk = ExeSetMachiningParam( nType, bVal) ;
   }
   else if ( ( nType & MPA_INT) != 0) {
      int nVal ;
      LuaCheckParam( L, 2, nVal)
     // imposto il parametro alla lavorazione corrente
      bOk = ExeSetMachiningParam( nType, nVal) ;
   }
   else if ( ( nType & MPA_DOU) != 0) {
      double dVal ;
      LuaCheckParam( L, 2, dVal)
     // imposto il parametro alla lavorazione corrente
      bOk = ExeSetMachiningParam( nType, dVal) ;
   }
   else if ( ( nType & MPA_STR) != 0) {
      string sVal ;
      LuaCheckParam( L, 2, sVal)
     // imposto il parametro alla lavorazione corrente
      bOk = ExeSetMachiningParam( nType, sVal) ;
   }
   LuaClearStack( L) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMachiningParam( lua_State* L)
{
  // 1 parametr : nType
   int nType ;
   LuaCheckParam( L, 1, nType)
   LuaClearStack( L) ;
   if ( ( nType & MPA_BOOL) != 0) {
      bool bVal ;
     // recupero il parametro dalla lavorazione corrente
      bool bOk = ExeGetMachiningParam( nType, bVal) ;
      if ( bOk)
         LuaSetParam( L, bVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & MPA_INT) != 0) {
      int nVal ;
     // recupero il parametro dalla lavorazione corrente
      bool bOk = ExeGetMachiningParam( nType, nVal) ;
      if ( bOk)
         LuaSetParam( L, nVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & MPA_DOU) != 0) {
      double dVal ;
     // recupero il parametro dalla lavorazione corrente
      bool bOk = ExeGetMachiningParam( nType, dVal) ;
      if ( bOk)
         LuaSetParam( L, dVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( ( nType & MPA_STR) != 0) {
      string sVal ;
     // recupero il parametro dalla lavorazione corrente
      bool bOk = ExeGetMachiningParam( nType, sVal) ;
      if ( bOk)
         LuaSetParam( L, sVal) ;
      else
         LuaSetParam( L) ;
   }
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetMachiningGeometry( lua_State* L)
{
  // 1 parametro : vSel
   SELVECTOR vSel ;
   LuaCheckParam( L, 1, vSel)
   LuaClearStack( L) ;
  // imposto la geometria alla lavorazione corrente
   bool bOk = ExeSetMachiningGeometry( vSel) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaPreviewMachining( lua_State* L)
{
  // 1 o nessun parametro : [bRecalc]
   bool bRecalc = false ;
   LuaGetParam( L, 1, bRecalc) ;
   LuaClearStack( L) ;
  // calcolo l'anteprima (se prevista) della lavorazione corrente
   bool bOk = ExePreviewMachining( bRecalc) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaApplyMachining( lua_State* L)
{
  // 1 o nessun parametro : [bRecalc]
   bool bRecalc = false ;
   LuaGetParam( L, 1, bRecalc) ;
   LuaClearStack( L) ;
  // calcolo la lavorazione corrente
   bool bOk = ExeApplyMachining( bRecalc) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMachiningGeometry( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero gli indici della geometria della lavorazione corrente
   SELVECTOR vSel ;
   bool bOk = ExeGetMachiningGeometry( vSel) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vSel) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIsMachiningEmpty( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero lo stato della lavorazione corrente
   bool bEmpty = ExeIsMachiningEmpty() ;
  // restituisco il risultato
   LuaSetParam( L, bEmpty) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Simulation
//-------------------------------------------------------------------------------
static int
LuaSimStart( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // avvio la simulazione
   bool bOk = ExeSimStart() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimMove( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // eseguo movimento di simulazione
   int nStatus ;
   bool bOk = ExeSimMove( nStatus) ;
  // restituisco i risultati
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nStatus) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimGetAxisInfoPos( lua_State* L)
{
  // 1 parametro : nInd
   int nInd ;
   LuaCheckParam( L, 1, nInd)
   LuaClearStack( L) ;
  // calcolo nome e posizione dell'asse
   string sToken ;
   bool bLinear ;
   double dVal ;
   bool bOk = ExeSimGetAxisInfoPos( nInd, sToken, bLinear, dVal) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, sToken) ;
      LuaSetParam( L, bLinear) ;
      LuaSetParam( L, dVal) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimGetToolInfo( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero nome e speed dell'utensile corrente
   string sName ;
   double dSpeed ;
   bool bOk = ExeSimGetToolInfo( sName, dSpeed) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, sName) ;
      LuaSetParam( L, dSpeed) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimGetMoveInfo( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero tipo e veolcit� del movimento corrente
   int nGmove ;
   double dFeed ;
   bool bOk = ExeSimGetMoveInfo( nGmove, dFeed) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, nGmove) ;
      LuaSetParam( L, dFeed) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimHome( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // porto la macchina in posizione home
   bool bOk = ExeSimHome() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimSetStep( lua_State* L)
{
  // 1 parametro : dStep
   double dStep ;
   LuaCheckParam( L, 1, dStep)
   LuaClearStack( L) ;
  // imposto lo step di riferimento per la simulazione
   bool bOk = ExeSimSetStep( dStep) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSimStop( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // termino la simulazione
   bool bOk = ExeSimStop() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Generation
//-------------------------------------------------------------------------------
static int
LuaGenerate( lua_State* L)
{
  // 1 o 2 parametro : sCncFile [, sInfo]
   string sCncFile ;
   LuaCheckParam( L, 1, sCncFile)
   string sInfo ;
   LuaGetParam( L, 2, sInfo) ;
   LuaClearStack( L) ;
  // eseguo la generazione del part-program
   bool bOk = ExeGenerate( sCncFile, sInfo) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Machine Calc
//-------------------------------------------------------------------------------
static int
LuaSetCalcTable( lua_State* L)
{
  // 1 parametro : sTable
   string sTable ;
   LuaCheckParam( L, 1, sTable)
   LuaClearStack( L) ;
  // imposto la tavola corrente per i calcoli macchina
   bool bOk = ExeSetCalcTable( sTable) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetCalcTool( lua_State* L)
{
  // 3 parametro : sTool, sHead, nExit
   string sTool ;
   LuaCheckParam( L, 1, sTool)
   string sHead ;
   LuaCheckParam( L, 2, sHead)
   int nExit ;
   LuaCheckParam( L, 3, nExit)
   LuaClearStack( L) ;
  // imposto l'utensile corrente per il calcolo
   bool bOk = ExeSetCalcTool( sTool, sHead, nExit) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetRotAxisBlock( lua_State* L)
{
  // 2 parametri : sAxis, dVal
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   double dVal ;
   LuaCheckParam( L, 2, dVal)
   LuaClearStack( L) ;
  // imposto asse da bloccare con il suo valore
   bool bOk = ExeSetRotAxisBlock( sAxis, dVal) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcTool( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'utensile corrente
   string sTool ;
   bool bOk = ExeGetCalcTool( sTool) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sTool) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcAngles( lua_State* L)
{
  // 1 o 2 parametri : vtDirT, vtDirA
   Vector3d vtDirT ;
   LuaCheckParam( L, 1, vtDirT)
   Vector3d vtDirA ;
   LuaGetParam( L, 2, vtDirA) ;
   LuaClearStack( L) ;
  // imposto la tavola corrente per il calcolo
   int  nStat ; double dAngA1 ; double dAngB1 ; double dAngA2 ; double dAngB2 ;
   bool bOk = ExeGetCalcAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, bOk) ;
      LuaSetParam( L, nStat) ;
      LuaSetParam( L, dAngA1) ;
      LuaSetParam( L, dAngB1) ;
      LuaSetParam( L, dAngA2) ;
      LuaSetParam( L, dAngB2) ;
      return 6 ;
   }
   else {
      LuaSetParam( L, bOk) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcPositions( lua_State* L)
{
  // 3 parametri : ptP, dAngA, dAngB
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   double dAngA ;
   LuaCheckParam( L, 2, dAngA)
   double dAngB ;
   LuaCheckParam( L, 3, dAngB)
   LuaClearStack( L) ;
  // imposto la tavola corrente per il calcolo
   int  nStat ; double dX ; double dY ; double dZ ;
   bool bOk = ExeGetCalcPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, bOk) ;
      LuaSetParam( L, nStat) ;
      LuaSetParam( L, dX) ;
      LuaSetParam( L, dY) ;
      LuaSetParam( L, dZ) ;
      return 5 ;
   }
   else {
      LuaSetParam( L, bOk) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcTipFromPositions( lua_State* L)
{
  // 6 parametri : dX, dY, dZ, dAngA, dAngB, bBottom
   double dX ;
   LuaCheckParam( L, 1, dX)
   double dY ;
   LuaCheckParam( L, 2, dY)
   double dZ ;
   LuaCheckParam( L, 3, dZ)
   double dAngA ;
   LuaCheckParam( L, 4, dAngA)
   double dAngB ;
   LuaCheckParam( L, 5, dAngB)
   bool bBottom ;
   LuaCheckParam( L, 6, bBottom)
   LuaClearStack( L) ;
  // calcolo il tip utensile dagli assi macchina
   Point3d ptTip ;
   bool bOk = ExeGetCalcTipFromPositions( dX, dY, dZ, dAngA, dAngB, bBottom, ptTip) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, ptTip) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcToolDirFromAngles( lua_State* L)
{
  // 2 parametri : dAngA, dAngB
   double dAngA ;
   LuaCheckParam( L, 1, dAngA)
   double dAngB ;
   LuaCheckParam( L, 2, dAngB)
   LuaClearStack( L) ;
  // Calcolo la direzione utensile dagli angoli macchina
   Vector3d vtDir ;
   bool bOk = ExeGetCalcToolDirFromAngles( dAngA, dAngB, vtDir) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vtDir) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaVerifyOutstroke( lua_State* L)
{
  // 5 parametri : dX, dY, dZ, dAngA, dAngB
   double dX ;
   LuaCheckParam( L, 1, dX)
   double dY ;
   LuaCheckParam( L, 2, dY)
   double dZ ;
   LuaCheckParam( L, 3, dZ)
   double dAngA ;
   LuaCheckParam( L, 4, dAngA)
   double dAngB ;
   LuaCheckParam( L, 5, dAngB)
   LuaClearStack( L) ;
  // imposto la tavola corrente per il calcolo
   int  nStat ;
   bool bOk = ExeVerifyOutstroke( dX, dY, dZ, dAngA, dAngB, nStat) ;
  // restituisco il risultato
   if ( bOk) {
      LuaSetParam( L, bOk) ;
      LuaSetParam( L, nStat) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, bOk) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaGetOutstrokeInfo( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero le info sull'ultima extracorsa
   string sInfo ;
   bool bOk = ExeGetOutstrokeInfo( sInfo) ;
   if ( bOk)
      LuaSetParam( L, sInfo) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
//    Machine
//-------------------------------------------------------------------------------
static int
LuaGetBaseId( lua_State* L)
{
  // 1 parametro : sBase
   string sBase ;
   LuaCheckParam( L, 1, sBase)
   LuaClearStack( L) ;
  // recupero l'identificativo della Base indicata della macchina
   int nId = ExeGetBaseId( sBase) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTableId( lua_State* L)
{
  // 1 parametro : sTable
   string sTable ;
   LuaCheckParam( L, 1, sTable)
   LuaClearStack( L) ;
  // recupero l'identificativo della Tavola indicata della macchina
   int nId = ExeGetTableId( sTable) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetAxisId( lua_State* L)
{
  // 1 parametro : sAxis
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   LuaClearStack( L) ;
  // recupero l'identificativo dell'Asse indicato della macchina
   int nId = ExeGetAxisId( sAxis) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetHeadId( lua_State* L)
{
  // 1 parametro : sHead
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   LuaClearStack( L) ;
  // recupero l'identificativo della Testa indicata della macchina
   int nId = ExeGetHeadId( sHead) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetAxisToken( lua_State* L)
{
  // 1 parametro : sAxis
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   LuaClearStack( L) ;
  // recupero il token dell'asse
   string sToken ;
   bool bOk = ExeGetAxisToken( sAxis, sToken) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sToken) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetAxisPos( lua_State* L)
{
  // 2 parametri : sAxis, dVal
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   double dVal ;
   LuaCheckParam( L, 2, dVal)
   LuaClearStack( L) ;
  // metto l'asse nella nuova posizione
   bool bOk = ExeSetAxisPos( sAxis, dVal) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetAxisPos( lua_State* L)
{
  // 1 parametro : sAxis
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   LuaClearStack( L) ;
  // recupero la posizione dell'asse
   double dVal ;
   bool bOk = ExeGetAxisPos( sAxis, &dVal) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, dVal) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetAxisHomePos( lua_State* L)
{
  // 1 parametro : sAxis
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   LuaClearStack( L) ;
  // recupero la posizione dell'asse
   double dHomeVal ;
   bool bOk = ExeGetAxisHomePos( sAxis, &dHomeVal) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, dHomeVal) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetAxisPos( lua_State* L)
{
  // 1 parametro : sAxis
   string sAxis ;
   LuaCheckParam( L, 1, sAxis)
   LuaClearStack( L) ;
  // metto l'asse nella posizione home
   bool bOk = ExeResetAxisPos( sAxis) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaLoadTool( lua_State* L)
{
  // 3 parametri : sHead, nExit, sTool
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   int nExit ;
   LuaCheckParam( L, 2, nExit)
   string sTool ;
   LuaCheckParam( L, 3, sTool)
   LuaClearStack( L) ;
  // carico l'utensile
   bool bOk = ExeLoadTool( sHead, nExit, sTool) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLoadedTool( lua_State* L)
{
  // 2 parametri : sHead, nExit
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   int nExit ;
   LuaCheckParam( L, 2, nExit)
   LuaClearStack( L) ;
  // recupero l'utensile caricato su testa e uscita indicate
   string sTool ;
   bool bOk = ExeGetLoadedTool( sHead, nExit, sTool) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sTool) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaUnloadTool( lua_State* L)
{
  // 2 parametri : sHead, nExit
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   int nExit ;
   LuaCheckParam( L, 2, nExit)
   LuaClearStack( L) ;
  // scarico l'utensile
   bool bOk = ExeUnloadTool( sHead, nExit) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetHeadSet( lua_State* L)
{
  // 1 parametro : sHead
   string sHead ;
   LuaCheckParam( L, 1, sHead)
   LuaClearStack( L) ;
  // carico l'utensile
   bool bOk = ExeResetHeadSet( sHead) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallMachMgr( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   // Machines
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachine", LuaSetCurrMachine) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachineName", LuaGetCurrMachineName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachineDir", LuaGetCurrMachineDir) ;
   // Mach Groups
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupCount", LuaGetMachGroupCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstMachGroup", LuaGetFirstMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextMachGroup", LuaGetNextMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupNewName", LuaGetMachGroupNewName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachGroup", LuaAddMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveMachGroup", LuaRemoveMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupName", LuaGetMachGroupName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupId", LuaGetMachGroupId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachGroup", LuaSetCurrMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrMachGroup", LuaResetCurrMachGroup) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachGroup", LuaGetCurrMachGroup) ;
   // Setup
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrSetup", LuaGetCurrSetup) ;
   // Phases
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddPhase", LuaAddPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrPhase", LuaSetCurrPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrPhase", LuaGetCurrPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveLastPhase", LuaRemoveLastPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPhaseCount", LuaGetPhaseCount) ;
   // Raw Parts & Parts
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartCount", LuaGetRawPartCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstRawPart", LuaGetFirstRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextRawPart", LuaGetNextRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddRawPart", LuaAddRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddRawPartWithPart", LuaAddRawPartWithPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPart", LuaModifyRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPartSize", LuaModifyRawPartSize) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPartHeight", LuaModifyRawPartHeight) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtKeepRawPart", LuaKeepRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyRawPartPhase", LuaVerifyRawPartPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveRawPartFromCurrPhase", LuaRemoveRawPartFromCurrPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveRawPart", LuaRemoveRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRotateRawPart", LuaRotateRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveToCornerRawPart", LuaMoveToCornerRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveToCenterRawPart", LuaMoveToCenterRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveRawPart", LuaMoveRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartCenter", LuaGetRawPartCenter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitFlatRawPartWithMachinings", LuaSplitFlatRawPartWithMachinings) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPartInRawPartCount", LuaGetPartInRawPartCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstPartInRawPart", LuaGetFirstPartInRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextPartInRawPart", LuaGetNextPartInRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddPartToRawPart", LuaAddPartToRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartFromPart", LuaGetRawPartFromPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemovePartFromRawPart", LuaRemovePartFromRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMovePartInRawPart", LuaTranslatePartInRawPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRotatePartInRawPart", LuaRotatePartInRawPart) ;
   // Table & Fixtures
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetTable", LuaSetTable) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableName", LuaGetTableName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableRef", LuaGetTableRef) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableArea", LuaGetTableArea) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddFixture", LuaAddFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtKeepFixture", LuaKeepFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveFixture", LuaRemoveFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstFixture", LuaGetFirstFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextFixture", LuaGetNextFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixture", LuaMoveFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRotateFixture", LuaRotateFixture) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixtureMobile", LuaMoveFixtureMobile) ;
   // Tools database
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetToolNewName", LuaTdbGetToolNewName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbAddTool", LuaTdbAddTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbCopyTool", LuaTdbCopyTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbRemoveTool", LuaTdbRemoveTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetFirstTool", LuaTdbGetFirstTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetNextTool", LuaTdbGetNextTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetToolFromUUID", LuaTdbGetToolFromUUID) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSetCurrTool", LuaTdbSetCurrTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSaveCurrTool", LuaTdbSaveCurrTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbIsCurrToolModified", LuaTdbIsCurrToolModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSetCurrToolParam", LuaTdbSetCurrToolParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolParam", LuaTdbGetCurrToolParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbReload", LuaTdbReload) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSave", LuaTdbSave) ;
   // Machinings database
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetMachiningNewName", LuaMdbGetMachiningNewName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbAddMachining", LuaMdbAddMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbCopyMachining", LuaMdbCopyMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbRemoveMachining", LuaMdbRemoveMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetFirstMachining", LuaMdbGetFirstMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetNextMachining", LuaMdbGetNextMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetMachiningFromUUID", LuaMdbGetMachiningFromUUID) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetCurrMachining", LuaMdbSetCurrMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSaveCurrMachining", LuaMdbSaveCurrMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbIsCurrMachiningModified", LuaMdbIsCurrMachiningModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetCurrMachiningParam", LuaMdbSetCurrMachiningParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetCurrMachiningParam", LuaMdbGetCurrMachiningParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetGeneralParam", LuaMdbSetGeneralParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetGeneralParam", LuaMdbGetGeneralParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbReload", LuaMdbReload) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSave", LuaMdbSave) ;
   // Operations
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstOperation", LuaGetFirstOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextOperation", LuaGetNextOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastOperation", LuaGetLastOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevOperation", LuaGetPrevOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstActiveOperation", LuaGetFirstActiveOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextActiveOperation", LuaGetNextActiveOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastActiveOperation", LuaGetLastActiveOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevActiveOperation", LuaGetPrevActiveOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationType", LuaGetOperationType) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationPhase", LuaGetOperationPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationName", LuaGetOperationName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationId", LuaGetOperationId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsOperationEmpty", LuaIsOperationEmpty) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveOperation", LuaRemoveOperation) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveAllPhaseOperations", LuaRemoveAllPhaseOperations) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveAllOperations", LuaRemoveAllOperations) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetOperationMode", LuaSetOperationMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationMode", LuaGetOperationMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetAllOperationsMode", LuaSetAllOperationsMode) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetOperationStatus", LuaSetOperationStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationStatus", LuaGetOperationStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetAllOperationsStatus", LuaSetAllOperationsStatus) ; 
   bOk = bOk && luaMgr.RegisterFunction( "EgtChangeOperationPhase", LuaChangeOperationPhase) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveOperationHome", LuaRemoveOperationHome) ;
   // Dispositions 
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPhaseDisposition", LuaGetPhaseDisposition) ; 
   bOk = bOk && luaMgr.RegisterFunction( "EgtSpecialApplyDisposition", LuaSpecialApplyDisposition) ; 
   // Machinings
   bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachining", LuaAddMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMachining", LuaCreateMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachining", LuaSetCurrMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrMachining", LuaResetCurrMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetMachiningParam", LuaSetMachiningParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetMachiningGeometry", LuaSetMachiningGeometry) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPreviewMachining", LuaPreviewMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApplyMachining", LuaApplyMachining) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningParam", LuaGetMachiningParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningGeometry", LuaGetMachiningGeometry) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsMachiningEmpty", LuaIsMachiningEmpty) ;
   // Simulation
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimStart", LuaSimStart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimMove", LuaSimMove) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimHome", LuaSimHome) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetAxisInfoPos", LuaSimGetAxisInfoPos) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetToolInfo", LuaSimGetToolInfo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetMoveInfo", LuaSimGetMoveInfo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimSetStep", LuaSimSetStep) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSimStop", LuaSimStop) ;
   // Generation
   bOk = bOk && luaMgr.RegisterFunction( "EgtGenerate", LuaGenerate) ;
   // Machine
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetBaseId", LuaGetBaseId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableId", LuaGetTableId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisId", LuaGetAxisId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadId", LuaGetHeadId) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisToken", LuaGetAxisToken) ;
   // Machine Calc
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTable", LuaSetCalcTable) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTool", LuaSetCalcTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetRotAxisBlock", LuaSetRotAxisBlock) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTool", LuaGetCalcTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcAngles", LuaGetCalcAngles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcPositions", LuaGetCalcPositions) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTipFromPositions", LuaGetCalcTipFromPositions) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcToolDirFromAngles", LuaGetCalcToolDirFromAngles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyOutstroke", LuaVerifyOutstroke) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetOutstrokeInfo", LuaGetOutstrokeInfo) ;
   // Machine Move
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetAxisPos", LuaSetAxisPos) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisPos", LuaGetAxisPos) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisHomePos", LuaGetAxisHomePos) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetAxisPos", LuaResetAxisPos) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLoadTool", LuaLoadTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLoadedTool", LuaGetLoadedTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtUnloadTool", LuaUnloadTool) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetHeadSet", LuaResetHeadSet) ;
   
   return bOk ;
}