diff --git a/CmdParser.cpp b/CmdParser.cpp
index fceaa2e..2a13e28 100644
--- a/CmdParser.cpp
+++ b/CmdParser.cpp
@@ -16,6 +16,8 @@
 #include "CmdParser.h"
 #include "DllMain.h"
 #include "/EgtDev/Include/EgnStringUtils.h"
+#include "/EgtDev/Include/EGnFileUtils.h"
+#include "/EgtDev/Include/EGnFileCompare.h"
 #include "/EgtDev/Include/EgnCmdExecutor.h"
 #include "/EgtDev/Include/EgtILogger.h"
 #include <iostream>
@@ -31,7 +33,7 @@ CreateCmdParser( void)
 
 //----------------------------------------------------------------------------
 CmdParser::CmdParser( void)
-   : m_pTheExecutor( nullptr), m_nLev(0) 
+   : m_pTheExecutor( nullptr), m_nLev( 0) 
 {
 }
 
@@ -42,12 +44,8 @@ CmdParser::~CmdParser( void)
 
 //----------------------------------------------------------------------------
 bool
-CmdParser::Init( ICmdExecutor* pCmdExec, int nLev) 
+CmdParser::Init( ICmdExecutor* pCmdExec) 
 {
-  // pulisco e imposto dimensioni mappa dei nomi di variabili
-   m_NameMap.clear() ;
-   m_NameMap.rehash( 100) ;
-
   // verifico la validità dell'esecutore
    if ( pCmdExec == nullptr)
       return false ;
@@ -56,15 +54,18 @@ CmdParser::Init( ICmdExecutor* pCmdExec, int nLev)
    m_pTheExecutor = pCmdExec ;
    m_pTheExecutor->SetCmdParser( this) ;
 
-  // salvo il livello di esecuzione
-   m_nLev = nLev ;
+  // reimposto le variabili
+   ResetAllVariables() ;
+
+  // imposto il livello di esecuzione iniziale
+   m_nLev = 0 ;
 
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CmdParser::Run( const std::string& sCmdFile)
+CmdParser::Run( const std::string& sCmdFile, bool bIsolated)
 {
    bool   bOk ;
    string sOut ;
@@ -72,21 +73,27 @@ CmdParser::Run( const std::string& sCmdFile)
    string sCmd ;
    string sParams ;
    string sDummy ;
+   NameMap CurrNameMap ;
+   CmdScanner TheScanner ;
 
 
+  // se richiesta esecuzione isolata, faccio una copia dello stato delle variabili
+   if ( bIsolated)
+      CurrNameMap = m_NameMap ;
+
   // log di inizio file
    sOut = GetInitSpaces() + "--- Start : " + sCmdFile + " ---" ;
    LOG_INFO( GetEGnLogger(), sOut.c_str())
 
   // inizializzo lo scanner
-   bOk = m_TheScanner.Init( sCmdFile) ;
+   bOk = TheScanner.Init( sCmdFile) ;
    if ( ! bOk) {
       sOut = GetInitSpaces() + "Error opening command file" ;
       LOG_ERROR( GetEGnLogger(), sOut.c_str())
    }
 
   // interpretazione dei comandi del file
-   while ( bOk  &&  m_TheScanner.GetLine( sLine)) {
+   while ( bOk  &&  TheScanner.GetLine( sLine)) {
      // elimino gli spazi all'inizio e alla fine
       Trim( sLine) ;
      // separo comando e parametri
@@ -96,7 +103,7 @@ CmdParser::Run( const std::string& sCmdFile)
      // deve esserci un comando e deve essere eseguito correttamente
       if ( sCmd.empty()  ||  ! ExecCommand( sCmd, sParams)) {
          bOk = false ;
-         sOut = GetInitSpaces() + "Error on line (" + ToString( m_TheScanner.GetCurrLineNbr()) + ") : " + sLine ;
+         sOut = GetInitSpaces() + "Error on line (" + ToString( TheScanner.GetCurrLineNbr()) + ") : " + sLine ;
          LOG_ERROR( GetEGnLogger(), sOut.c_str())
       }
    }
@@ -111,6 +118,44 @@ CmdParser::Run( const std::string& sCmdFile)
       LOG_ERROR( GetEGnLogger(), sOut.c_str())
    }
 
+  // se richiesta esecuzione isolata, ripristino lo stato originale delle variabili
+   if ( bIsolated)
+      m_NameMap = CurrNameMap ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::ExecLine( const string& sCmdLine, bool bIsolated) 
+{
+   NameMap CurrNameMap ;
+
+
+  // se richiesta esecuzione isolata, faccio una copia dello stato delle variabili
+   if ( bIsolated)
+      CurrNameMap = m_NameMap ;
+  // elimino gli spazi all'inizio e alla fine
+   string sLine = sCmdLine ;
+   Trim( sLine) ;
+  // separo comando e parametri
+   string sCmd, sParams ;
+   SplitFirst( sLine, "(", sCmd, sParams) ;
+  // elimino dai parametri tutto quanto dopo ultima parentesi chiusa
+   string sDummy ;
+   SplitLast( sParams, ")", sParams, sDummy) ;
+  // deve esserci un comando e deve essere eseguito correttamente
+   bool bOk = true ;
+   if ( sCmd.empty()  ||  ! ExecCommand( sCmd, sParams)) {
+      bOk = false ;
+      string sOut = GetInitSpaces() + "Error on line : " + sCmdLine ;
+      LOG_ERROR( GetEGnLogger(), sOut.c_str())
+   }
+
+  // se richiesta esecuzione isolata, ripristino lo stato originale delle variabili
+   if ( bIsolated)
+      m_NameMap = CurrNameMap ;
+
    return bOk ;
 }
 
@@ -151,11 +196,38 @@ CmdParser::GetVariable( const std::string& sName, int& nVal)
 
 //----------------------------------------------------------------------------
 bool
-CmdParser::EraseVariable( const std::string& sName)
+CmdParser::RemoveVariable( const std::string& sName)
 {
    return ( m_NameMap.erase( sName) > 0) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CmdParser::ResetAllVariables( void)
+{
+  // pulisco e imposto dimensioni mappa dei nomi di variabili
+   m_NameMap.clear() ;
+   m_NameMap.rehash( 100) ;
+  // installo variabili standard
+   if ( m_pTheExecutor != nullptr)
+      return m_pTheExecutor->AddStandardVariables() ;
+   else
+      return true ;
+}
+
+//----------------------------------------------------------------------------
+const string
+CmdParser::GetInitSpaces( void)
+{
+   string sIni ;
+
+
+   for ( int i = 0 ; i < m_nLev ; ++ i)
+      sIni += "   " ;
+
+   return sIni ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CmdParser::ExecCommand( const string& sCmd, const string& sParams)
@@ -192,21 +264,205 @@ CmdParser::ExecCommand( const string& sCmd, const string& sParams)
    LOG_DBG_INFO( GetEGnLogger(), sOut.c_str())
 
   // eseguo il comando con i suoi parametri
-   if ( m_pTheExecutor != nullptr)
+   if ( sCmd1 == "COUNTER")
+      return ExecuteCounter( sCmd2, vsParams) ;
+   else if ( sCmd1 == "DIR")
+      return ExecuteDir( sCmd2, vsParams) ;
+   else if ( sCmd1 == "FILE")
+      return ExecuteFile( sCmd2, vsParams) ;
+   else if ( sCmd1 == "PAUSE")
+      return ExecutePause( sCmd2, vsParams) ;
+   else if ( sCmd1 == "RESET")
+      return ExecuteReset( sCmd2, vsParams) ;
+   else if ( sCmd1 == "RUN")
+      return ExecuteRun( sCmd2, vsParams) ;
+   else if ( sCmd1 == "SET")
+      return ExecuteSet( sCmd2, vsParams) ;
+   else if ( m_pTheExecutor != nullptr)
       return m_pTheExecutor->Execute( sCmd1, sCmd2, vsParams) ;
    else
       return false ;
 }
 
 //----------------------------------------------------------------------------
-const string
-CmdParser::GetInitSpaces( void)
+bool
+CmdParser::ExecuteCounter( const string& sCmd2, const STRVECTOR& vsParams) 
 {
-   string sIni ;
+  // avvio il counter
+   if ( sCmd2 == "START") {
+      m_Counter.Start() ;
+      return true ;
+   }
+  // fermo il counter ed emetto i risultati
+   else if ( sCmd2 == "STOP") {
+      m_Counter.Stop() ;
+      string sOut = "   " + ( ( vsParams.size() >= 1) ? vsParams[0] : "ExecTime =") ; 
+      sOut += " " + ToString( m_Counter.GetTime(), 2) + " ms" ; 
+      LOG_INFO( GetEGnLogger(), sOut.c_str())
+      return true ;
+   }
 
-
-   for ( int i = 0 ; i < m_nLev ; ++ i)
-      sIni += "   " ;
-
-   return sIni ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CmdParser::ExecuteDir( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+  // analisi ed esecuzione dei comandi
+   if ( sCmd2 == "EMPTY") {
+
+     // 1 parametro : nome direttorio da svuotare
+      if ( vsParams.size() != 1)
+         return false ;
+
+     // svuoto il direttorio
+      EmptyDirectory( vsParams[0]) ;
+
+      return true ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CmdParser::ExecuteFile( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+  // cancellazione file
+   if ( sCmd2 == "DEL") {
+     // 1 parametro : file
+      if ( vsParams.size() != 1)
+         return false ;
+
+     // eseguo la cancellazione
+      EraseFile( vsParams[0]) ;
+
+      return true ;
+   }
+
+  // confronto tra file
+   else if ( sCmd2 == "CMP") {
+
+     // 4 parametri : file1, file2, inizio commento, file diff
+      if ( vsParams.size() != 4)
+         return false ;
+
+     // eseguo il confronto
+      TextFileCompare( vsParams[0], vsParams[1], vsParams[2], vsParams[3]) ;
+
+      return true ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::ExecutePause( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+   if ( sCmd2.empty()) {
+      const int MIN_TIME = 0 ;
+      const int MAX_TIME = 10000 ;
+
+     // 1 parametro : durata della pausa in ms
+      if ( vsParams.size() != 1)
+         return false ;
+     // tempo di attesa
+      int nTime ;
+      if ( ! FromString( vsParams[0], nTime))
+         return false ;
+      if ( nTime < MIN_TIME)
+         nTime = MIN_TIME ;
+      else if ( nTime > MAX_TIME)
+         nTime = MAX_TIME ;
+     // eseguo
+      Sleep( nTime) ;
+
+      return true ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::ExecuteReset( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+  // ripristino dell'ambiente di esecuzione
+   if ( sCmd2 == "ALL") {
+      return ResetAllVariables() ;
+   }
+  // cancellazione di un identificativo
+   else if ( sCmd2.empty()) {
+     // 1 parametro ( Nome/i)
+      if ( vsParams.size() != 1)
+         return false ;
+     // recupero lista nomi
+      STRVECTOR vsNames ;
+      if ( ! GetNamesParam( vsParams[0], vsNames))
+         return false ;
+     // eseguo cancellazioni
+      STRVECTOR::iterator Iter ;
+      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter)
+         RemoveVariable( *Iter) ;
+      return true ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::ExecuteRun( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+   if ( sCmd2.empty()) {
+     // 1 parametro : nome file di script da eseguire
+      if ( vsParams.size() != 1)
+         return false ;
+     // esecuzione comando
+      ++ m_nLev ;
+      bool bOk = Run( vsParams[0]) ;
+      -- m_nLev ;
+      return bOk ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::ExecuteSet( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+   if ( sCmd2.empty()) {
+     // 2 parametri ( Nome, Valore)
+      if ( vsParams.size() != 2)
+         return false ;
+     // recupero il valore
+      int nVal ;
+      if ( ! FromString( vsParams[1], nVal))
+         return false ;
+     // eseguo
+      if ( SetVariable( vsParams[0], nVal))
+         return true ;
+      else
+         return AddVariable( vsParams[0], nVal) ;
+   }
+
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CmdParser::GetNamesParam( const std::string& sParam, STRVECTOR& vsNames)
+{
+   STRVECTOR::iterator Iter ;
+
+
+  // divido in parti
+   Tokenize( sParam, ",", vsNames) ;
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter)
+      Trim( (*Iter), " \t\r\n()") ;
+
+   return true ;
 }
diff --git a/CmdParser.h b/CmdParser.h
index 98e83ce..7904134 100644
--- a/CmdParser.h
+++ b/CmdParser.h
@@ -13,31 +13,47 @@
 
 #pragma once
 
-#include "/EgtDev/Include/EgnCmdParser.h"
 #include "CmdScanner.h"
+#include "/EgtDev/Include/EgtPerfCounter.h"
+#include "/EgtDev/Include/EgnStringBase.h"
+#include "/EgtDev/Include/EgnCmdParser.h"
 #include <unordered_map>
 
 //----------------------------------------------------------------------------
 class CmdParser : public ICmdParser
 {
+   public :                 // ICmdParser
+      virtual ~CmdParser( void) ;
+      virtual bool Init( ICmdExecutor* pCmdExec) ;
+      virtual bool Run( const std::string& sCmdFile, bool bIsolated = true) ;
+      virtual bool ExecLine( const std::string& sCmdLine, bool bIsolated = false) ; 
+      virtual bool AddVariable( const std::string& sName, int nVal) ;
+      virtual bool SetVariable( const std::string& sName, int nVal) ;
+      virtual bool GetVariable( const std::string& sName, int& nVal) ;
+      virtual bool RemoveVariable( const std::string& sName) ;
+
    public :
       CmdParser( void) ;
-      ~CmdParser( void) ;
-      bool Init( ICmdExecutor* pCmdExec, int nLev = 0) ;
-      bool Run( const std::string& sCmdFile) ;
-      bool AddVariable( const std::string& sName, int nVal) ;
-      bool SetVariable( const std::string& sName, int nVal) ;
-      bool GetVariable( const std::string& sName, int& nVal) ;
-      bool EraseVariable( const std::string& sName) ;
 
    private :
-      bool ExecCommand( const std::string& sCmd, const std::string& sParams) ;
+      bool ResetAllVariables( void) ;
       const std::string GetInitSpaces( void) ;
+      bool ExecCommand( const std::string& sCmd, const std::string& sParams) ;
+      bool ExecuteCounter( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteDir( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteFile( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecutePause( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteReset( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteRun( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteSet( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool GetNamesParam( const std::string& sParam, STRVECTOR& vsNames) ;
 
    private :
-      CmdScanner    m_TheScanner ;
-      ICmdExecutor* m_pTheExecutor ;
       typedef std::unordered_map<std::string, int> NameMap ;
+
+   private :
+      ICmdExecutor* m_pTheExecutor ;
       NameMap       m_NameMap ;
       int           m_nLev ;
+      PerformanceCounter m_Counter ;
 } ;
diff --git a/EgtGeneral.rc b/EgtGeneral.rc
index 78ba1b3..dc23dee 100644
Binary files a/EgtGeneral.rc and b/EgtGeneral.rc differ
diff --git a/StringUtils.cpp b/StringUtils.cpp
index 3be5f76..4072aca 100644
--- a/StringUtils.cpp
+++ b/StringUtils.cpp
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2013-2014
 //----------------------------------------------------------------------------
-// File : StringUtils.cpp       Data : 19.01.14          Versione : 1.5a6
+// File : StringUtils.cpp       Data : 17.03.14          Versione : 1.5c2
 // Contenuto : Implementazione delle funzioni di utilità per le stringhe.
 //
 //
@@ -9,12 +9,14 @@
 // Modifiche : 20.01.13 DS Creazione modulo.
 //             02.12.13 DS Agg. FromString per Vector3d, Point3d e Point3d+W.
 //             19.01.14 DS Tokenize con Atom ora funziona su più livelli.
+//             17.03.14 DS Agg. CurrDateTime.
 //
 //----------------------------------------------------------------------------
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "/EgtDEv/Include/EgnStringUtils.h"
+#include <time.h>
 
 using namespace std ;
 
@@ -287,3 +289,23 @@ ReplaceString( std::string& sString, const std::string& sOld, const std::string&
 
    return nSubs ;
 }
+
+//----------------------------------------------------------------------------
+const string
+CurrDateTime( void)
+{
+   time_t nClock ;
+   tm newTime ;
+
+   time( &nClock) ;
+   localtime_s( &newTime, &nClock) ;
+         
+   char strDate[10] = { '\0'} ;
+   char strTime[10] = { '\0'} ;
+
+   _strdate_s( strDate) ;
+   _strtime_s( strTime) ;
+
+   string sDT = strDate + string( " ") + strTime ;
+   return sDT ;
+}