EgtGeneral/CmdParser.cpp

//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : CmdParser.cpp         Data : 25.11.13          Versione : 1.3a1
// Contenuto : Implementazione della classe CCmdParser.
//
//
//
// Modifiche : 19.01.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "CmdParser.h"
#include "DllMain.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EgnCmdExecutor.h"
#include "/EgtDev/Include/EgtILogger.h"
#include <iostream>

using namespace std ;

//----------------------------------------------------------------------------
ICmdParser*
CreateCmdParser( void)
{
   return static_cast<ICmdParser*> ( new CmdParser) ;
}

//----------------------------------------------------------------------------
CmdParser::CmdParser( void)
   : m_pTheExecutor( nullptr), m_nLev(0) 
{
}

//----------------------------------------------------------------------------
CmdParser::~CmdParser( void)
{
}

//----------------------------------------------------------------------------
bool
CmdParser::Init( ICmdExecutor* pCmdExec, int nLev) 
{
  // 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 ;

  // salvo il riferimento all'esecutore e mi registro
   m_pTheExecutor = pCmdExec ;
   m_pTheExecutor->SetCmdParser( this) ;

  // salvo il livello di esecuzione
   m_nLev = nLev ;

   return true ;
}

//----------------------------------------------------------------------------
bool
CmdParser::Run( const std::string& sCmdFile)
{
   bool   bOk ;
   string sOut ;
   string sLine ;
   string sCmd ;
   string sParams ;
   string sDummy ;


  // log di inizio file
   sOut = GetInitSpaces() + "--- Start : " + sCmdFile + " ---" ;
   LOG_INFO( GetEGnLogger(), sOut.c_str())

  // inizializzo lo scanner
   bOk = m_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)) {
     // elimino gli spazi all'inizio e alla fine
      Trim( sLine) ;
     // separo comando e parametri
      SplitFirst( sLine, "(", sCmd, sParams) ;
     // elimino dai parametri tutto quanto dopo ultima parentesi chiusa
      SplitLast( sParams, ")", sParams, sDummy) ;
     // 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 ;
         LOG_ERROR( GetEGnLogger(), sOut.c_str())
      }
   }

  // log di fine file
   if ( bOk) {
      sOut = GetInitSpaces() + "--- End ---" ;
      LOG_INFO( GetEGnLogger(), sOut.c_str())
   }
   else {
      sOut = GetInitSpaces() + "--- Stop : error ---" ;
      LOG_ERROR( GetEGnLogger(), sOut.c_str())
   }

   return bOk ;
}

//----------------------------------------------------------------------------
bool
CmdParser::AddVariable( const std::string& sName, int nVal)
{
   return ( m_NameMap.insert( NameMap::value_type( sName, nVal)).second) ;
}

//----------------------------------------------------------------------------
bool
CmdParser::SetVariable( const std::string& sName, int nVal)
{
   NameMap::iterator Iter ;   
   Iter = m_NameMap.find( sName) ;
   if ( Iter != m_NameMap.end()) {
      Iter->second = nVal ;
      return true ;
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
CmdParser::GetVariable( const std::string& sName, int& nVal)
{
   NameMap::const_iterator Iter ;   
   Iter = m_NameMap.find( sName) ;
   if ( Iter != m_NameMap.end()) {
      nVal = Iter->second ;
      return true ;
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
CmdParser::EraseVariable( const std::string& sName)
{
   return ( m_NameMap.erase( sName) > 0) ;
}

//----------------------------------------------------------------------------
bool
CmdParser::ExecCommand( const string& sCmd, const string& sParams)
{
   string    sCmd1 ;
   string    sCmd2 ;
   STRVECTOR vsParams ;
   STRVECTOR::iterator Iter ;


  // divido il comando e lo normalizzo
   SplitFirst( sCmd, ".", sCmd1, sCmd2) ;
   Trim( sCmd1) ;
   ToUpper( sCmd1) ;
   Trim( sCmd2) ;
   ToUpper( sCmd2) ;

  // divido i parametri
   Tokenize( sParams, ",", "(", ")", vsParams) ;
   for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++ Iter)
      Trim( (*Iter)) ;

  // output di debug
   string sOut = GetInitSpaces() + sCmd1 ;
   if ( ! sCmd2.empty())
      sOut += "." + sCmd2 ;
   sOut += "( " ;
   for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++ Iter) {
      if ( Iter != vsParams.begin())
         sOut += ", " ; 
      sOut += *Iter ;
   }
   sOut += ")" ;
   LOG_DBG_INFO( GetEGnLogger(), sOut.c_str())

  // eseguo il comando con i suoi parametri
   if ( m_pTheExecutor != nullptr)
      return m_pTheExecutor->Execute( sCmd1, sCmd2, vsParams) ;
   else
      return false ;
}

//----------------------------------------------------------------------------
const string
CmdParser::GetInitSpaces( void)
{
   string sIni ;


   for ( int i = 0 ; i < m_nLev ; ++ i)
      sIni += "   " ;

   return sIni ;
}