Run.cc

Go to the documentation of this file.

#include <cstdlib>
#include<iostream>
#include<fstream>
#include<regex>
#include<unordered_map>
#include<boost/program_options.hpp>

#include<diades/automata/experimental/AutFile.hh>
#include<diades/automata/experimental/DdAutFile.hh>
#include<diades/automata/experimental/DdAutFileDescriptor.hh>
#include<diades/automata/experimental/Printer.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/StateCreation.hh>
#include"../AutomataInterface.hh"

using namespace std;
using namespace Diades::Automata::Experimental;
using namespace Diades::Utils;
using namespace Diades::CmdInterface;

namespace Poptions = boost::program_options;



const string program("dd-run");

/*
 * File suffixes
 */
FileSuffixes suffixes({"aut","ddaut"});


void initialiseOptions(int argc, char * argv[],
                       Poptions::options_description & desc,
                       Poptions::variables_map & vm)
{
   desc.add_options()
      ("help,h", "produce help message")
      ("file,f", Poptions::value< string >(), "automaton file (.aut/.ddaut format)");
   Poptions::positional_options_description p;
   p.add("file", 1);
   Poptions::store(Poptions::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
   Poptions::notify(vm);
}


using Diades::Automata::Experimental::DdAutFsm;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;
using Diades::Automata::Experimental::AutFsm;
using State = AutFsm::State;
using Transition =  AutFsm::Transition;
using Path = std::vector<std::pair<State,Transition> >;
using TrIndexes = std::unordered_map<size_t,Transition>;
using StIndexes = std::unordered_map<State::NodeId,State>;     
using Params = std::vector<std::string>;

enum Command
{
   back,
   commands,
   current,
   help,
   initial,
   next,
   path,
   start,
   quit,
   undo,
   unknown
};

std::unordered_map<Command, std::string> cmds =
{
   { Command::back, "back"},
   { Command::commands, "commands"},
   { Command::current, "current"},
   { Command::help, "help"},
   { Command::initial, "initial"},
   { Command::next, "next" },
   { Command::path, "path" },   
   { Command::start, "start" },
   { Command::quit, "quit" },
   { Command::undo, "undo"},
   { Command::unknown, "unknown"}
};

std::map<std::string,Command> textTocmds =
{
   { "back",Command::back},
   { "commands",Command::commands},
   { "current",Command::current},
   { "help", Command::help },
   { "initial", Command::initial },
   { "next", Command::next },
   { "path", Command::path },
   { "start", Command::start },
   { "quit", Command::quit},
   { "undo", Command::undo },
   { "unknown", Command::unknown }
};

std::unordered_map<Command, std::string> cmdHelp =
{
   { Command::back,
     R"(back command:
'back input-transition-id': fire the input transition with the
                             id '[input-transition-id]' from the
                             current state (check the command 'current')
                            So here we move backward but we keep the path
                            updated (it is not undo, check the command 'undo'))"},
   { Command::commands,
     R"(commands command:
'command' : display the list of available commands in dd-run.
)"},
   { Command::current,
     R"(current command:
'current' : display the current state of the fsm. 
            If such a current state does not exist 
            use 'start'.
)"},
   { Command::help,
     R"(help command:
'help'     : print this message
'help cmd' : print help message for the command 'cmd'

To list the possible set of commands, use 'commands'.)"
   },
   
   { Command::initial,
     R"(initial command:
'initial'  :  display the set of initial states of the fsm.)"
   },
   { Command::next,
     R"(next command:
'next output-transition-id': fire the output transition with the
                             id '[output-transition-id]' from the
                             current state (check the command 'current'))"
   },
   { Command::path,
     R"(path command:
'path': display the current path)"
   },   
   { Command::start,
     R"(start command:
'start state-id' : set the current state of the fsm to be the one 
                   with the corresponding state-id. Erase the current
                   explored path.)"},
   { Command::quit,
     R"(quit command:
'quit' : quit dd-run.)"
   },
   { Command::undo,
     R"(undo command: 
'undo' : undo the last transition fire (back/next)
         The current path is updated.)"
   },
   { Command::unknown,
     R"(unknown command: check the command list with 'commands')"
   }
};


void printHelpCommand(Command cmd)
{
   std::cout << cmdHelp[cmd] << "\n";
}


Command convertCommand(const std::string & cmd)
{
   auto it = textTocmds.find(cmd);
   if(it == textTocmds.end())
   {
      return Command::unknown;
   }
   return it->second;
}





size_t runAut(const std::string & fileName)
{
   AutFsm fsm;
   ifstream file(fileName.c_str());
   if(file.is_open())
   {
      auto loaded = fromAutFile(file, fsm);
      file.close();
      if(!loaded)
      {
         return printCommandLineError(Msg("Error when loading the automaton file %1%")%fileName);
      }
   }
   else
   {
      return printCommandLineError(Msg("Error when opening the automaton file %1%")%fileName);
   }
   //  interactiveAut(fsm);
   return SUCCESS;
}


void prompt(std::string & cmd)
{
   std::cout << "dd-run: ";
   cmd.clear(); 
   std::getline(std::cin, cmd);
}
        

void command(Command & cmd,
             Params & params)
{
   std::string cmdText;
   prompt(cmdText);
   cmd = Command::unknown;
   std::stringstream stream;
   stream << cmdText;
   std::string mycmd;
   stream >> mycmd;
   cmd = convertCommand(mycmd);
   params.clear();
   while(!stream.eof())
   {
      std::string param;
      stream >> param;
      if(!param.empty())
      {
         params.push_back(param);
      }
   }
}




StIndexes states;

void initialiseStates(const DdAutFsm & fsm)
{
   if (states.empty())
   {
      std::for_each(fsm.stateBegin(),fsm.stateEnd(),
                    [&](DdAutFsm::State s)
                    {
                       states[s.id()] = s;
                    });
   }
}






void printState(const DdAutFsm & fsm, const State & state,const DdAutStateManager & sManager)
{
   std::cout << "[" << state.id() << "] " << sManager.getStateProperty(fsm.getStatePropertyId(state)) << '\n';
}


void printTransition(const DdAutFsm & fsm, const Transition & transition, const DdAutEventManager & eManager, size_t index)
{
   std::cout << "  [" << index << "]:" << states[transition.source().id()] << "-->" << states[transition.target().id()] << " "
             << eManager.getEvent(fsm.getEvent(transition))
             << '\n';
}


void printOutputTransitions(const DdAutFsm & fsm,
                            const State & state,
                            const DdAutEventManager & eManager,
                            TrIndexes & transitions)
{
   transitions.clear();
   std::for_each(fsm.outputTransitionBegin(state),
                 fsm.outputTransitionEnd(state),
                 [&](const Transition & transition)
                 {
                    printTransition(fsm,transition,eManager,transitions.size());
                    transitions[transitions.size()]=transition;
                 });
}


void printInputTransitions(const DdAutFsm & fsm,
                           const State & state,
                           const DdAutEventManager & eManager,
                           TrIndexes & transitions)
{
   transitions.clear();
   std::for_each(fsm.inputTransitionBegin(state),
                 fsm.inputTransitionEnd(state),
                 [&](const DdAutFsm::Transition & transition)
                 {
                    printTransition(fsm,transition,eManager,transitions.size());
                    transitions[transitions.size()]=transition;
                 });
}


void printCurrentState(const DdAutFsm & fsm, const State & state,
                       const DdAutStateManager & sManager,
                       const DdAutEventManager & eManager,
                       TrIndexes & outputs,
                       TrIndexes & inputs)
{
   printState(fsm, state, sManager);
   std::cout << "outputs:\n";
   printOutputTransitions(fsm, state, eManager, outputs);
   std::cout << "inputs:\n";
   printInputTransitions(fsm, state, eManager, inputs);
}


void printInitialStates(const DdAutFsm & fsm, const DdAutStateManager & sManager, const Params & params)
{
   if(params.size() != 0)
   {
      std::cout << "error: I read initial with some parameters\n";
      printHelpCommand(Command::initial);
   }
   else
   {
      std::for_each(fsm.initialStateBegin(),fsm.initialStateEnd(),
                    [&](State s)
                    {
                       printState(fsm,s,sManager);
                    });
   }
}

State::NodeId getStateId(const std::string & param, bool & ok)
{
   std::regex regStateId("[[:digit:]]+");
   State::NodeId result = 0;
   if(std::regex_match(param,regStateId))
   {
      std::stringstream stream;
      stream << param ;
      stream >> result;
      ok = true;
   }
   else
   {
      ok = false;
   }
   return result;
}

size_t getId(const std::string & param, bool & ok)
{
   std::regex regStateId("[[:digit:]]+");
   size_t result = 0;
   if(std::regex_match(param,regStateId))
   {
      std::stringstream stream;
      stream << param ;
      stream >> result;
      ok = true;
   }
   else
   {
      ok = false;
   }
   return result;
}


void initialiseFsm(const DdAutFsm & fsm, DdAutFsm::State & newInitialState,
                   const DdAutStateManager & sManager,
                   const DdAutEventManager & eManager,
                   TrIndexes & outputs,
                   TrIndexes & inputs,
                   const Params & params)
{
   if(params.size() != 1)
   {
      std::cout << "error: here I read start with " << params.size() << " parameters (should be 1)'\n";
      printHelpCommand(Command::start);
   }
   else
   {
      initialiseStates(fsm);
      bool ok = true;
      auto stateId = getStateId(params[0],ok);
      if(ok)
      {
         auto it = states.find(stateId);
         if(it==states.end())
         {
            std::cout << "error: the state of id=" << stateId << " does not exists.\n"; 
         }
         else
         {
            newInitialState = it->second;
            printCurrentState(fsm,newInitialState,sManager,eManager,outputs, inputs);
         }
      }
      else
      {
         std::cout << "error: here I read 'start " << params[0] << "'\n";
         printHelpCommand(Command::start);
      }
   }
}

void commandNext(const DdAutFsm & fsm, 
                 Path & currentPath,
                 const DdAutStateManager & sManager,
                 const DdAutEventManager & eManager,
                 TrIndexes & outputs,
                 TrIndexes & inputs,
                 const Params & params)
{
   if(params.size() != 1)
   {
      std::cout << "error: here I read next with " << params.size() << " parameters (should be 1)'\n";
      printHelpCommand(Command::next);
   }
   else
   {
      bool ok = true;
      auto transId = getId(params[0],ok);
      
    
      if(ok)
      {
         auto it = outputs.find(transId);
         if(it==outputs.end())
         {
            std::cout << "error: the transition of id=" << transId << " does not exists.\n"; 
         }
         else
         {
            currentPath.push_back(std::make_pair(it->second.target(),it->second));
            printCurrentState(fsm,currentPath.back().first,sManager,eManager,outputs, inputs);
         }
      }
      else
      {
         std::cout << "error: here I read 'next " << params[0] << "'\n";
         printHelpCommand(Command::next);  
      }
   }
}



void commandBack(const DdAutFsm & fsm,
                 Path & currentPath,
                 const DdAutStateManager & sManager,
                 const DdAutEventManager & eManager,
                 TrIndexes & outputs,
                 TrIndexes & inputs,
                 const Params & params)
{
   if(params.size() != 1)
   {
      std::cout << "error: here I read back with " << params.size() << " parameters (should be 1)'\n";
      printHelpCommand(Command::back);     
   }
   else
   {
      bool ok = true;
      auto transId = getId(params[0],ok);
      
    
      if(ok)
      {
         auto it = inputs.find(transId);
         if(it==inputs.end())
         {
            std::cout << "error: the input transition of id=" << transId << " does not exists.\n"; 
         }
         else
         {
            currentPath.push_back(std::make_pair(it->second.source(),it->second));
            printCurrentState(fsm,currentPath.back().first,sManager,eManager,outputs, inputs);
         }
      }
      else
      {
         std::cout << "error: here I read 'back " << params[0] << "'\n";
         printHelpCommand(Command::back);
      }
   }
}



void printHelp(const Params & params)
{
   if(params.empty() || (params.size() > 1))
   {
      printHelpCommand(Command::help);
   }
   else
   {
      printHelpCommand(convertCommand(params[0]));
   }
}

void commandCommands()
{
   std::cout << "List of available commands: ";
   if(!textTocmds.empty())
   {
      auto it = textTocmds.begin();
      while(it!=textTocmds.end())
      {
         if(it->second != Command::unknown)
         {
            std::cout << it->first << " ";
         }
         ++it;
      }
   }
   std::cout << '\n';
}


void commandInitial(const DdAutFsm & fsm,
                    const DdAutStateManager & sManager,
                    const Params & params)
{
   printInitialStates(fsm,sManager,params);
}


void commandStart(const DdAutFsm & fsm,
                  Path & currentPath,
                  const DdAutStateManager & sManager,
                  const DdAutEventManager & eManager,
                  TrIndexes & outputs,
                  TrIndexes & inputs,
                  const Params & params)
{
   currentPath.clear();
   currentPath.push_back(std::make_pair(State(),Transition()));
   initialiseFsm(fsm,currentPath.back().first,sManager,
                 eManager,outputs,inputs,params);  
}


void commandCurrent(const DdAutFsm & fsm,
                    Path & currentPath,
                    const DdAutStateManager & sManager,
                    const DdAutEventManager & eManager,
                    TrIndexes & outputs,
                    TrIndexes & inputs)
{
   if(currentPath.empty())
   {
      std::cout << "No current state\n";
   }
   else
   {
      printCurrentState(fsm, currentPath.back().first,
                        sManager,eManager,outputs,inputs);
   }
}


void commandHelp(const Params & params)
{
   printHelp(params);
}


void commandUndo(const DdAutFsm & fsm,
                 Path & currentPath,
                 const DdAutStateManager & sManager,
                 const DdAutEventManager & eManager,
                 TrIndexes & outputs,
                 TrIndexes & inputs,
                 const Params & params)
{
   if(!params.empty())
   {
      std::cout << "error: I read the command 'undo' with some parameters.\n";
      printHelpCommand(Command::undo);
   }
   else
   {
      if(!currentPath.empty())
      {
         currentPath.pop_back();
         if(currentPath.empty())
         {
            std::cout << "Empty path, no initial state.\n";
            outputs.clear();
            inputs.clear();
         }
         else
         {
            printCurrentState(fsm,currentPath.back().first,sManager,eManager,outputs, inputs);
         }
      }
   }
}

void commandPath(const DdAutFsm & fsm,
                 const Path & currentPath,
                 const DdAutStateManager & sManager,
                 const DdAutEventManager & eManager,
                 const Params & params)
{
   if(!params.empty())
   {
      std::cout << "error: I read 'path' with parameters.\n";
      printHelpCommand(Command::path);
   }
   else
   {
      if(currentPath.empty())
      {
         std::cout << "empty path.\n";
      }
      else
      {
         printState(fsm, currentPath.front().first,sManager);
         auto it = currentPath.begin();
         ++it;
         while (it!=currentPath.end())
         {
            auto itPrev = it;
            --itPrev;
            if (it->second.source()==itPrev->first) {
               std::cout << "\t|\n";
               std::cout << eManager.getEvent(fsm.getEvent(it->second)) << "\n";
               std::cout << "\t|\n";
               std::cout << "\tv\n";
               printState(fsm, it->first,sManager);
            }
            else
            {
               std::cout << "\t^\n";
               std::cout << "\t|\n";
               std::cout << eManager.getEvent(fsm.getEvent(it->second)) << "\n";
               std::cout << "\t|\n";
               printState(fsm, it->first,sManager);
            }
            ++it;
         }
      }
   }
}


void commandUnknown()
{
   std::cout << "Unknown command: use 'commands' to print the list of commands.\n";
}

size_t interactiveDdAut(const DdAutFsm & fsm,
                        const DdAutStateManager & sManager,
                        const DdAutEventManager & eManager)
{
   Command cmd = Command::unknown;
   Params  params;
   Path currentPath;
   TrIndexes outputs;
   TrIndexes inputs;
   do
   {
      command(cmd, params);
      switch(cmd)
      {
         case Command::back:
         {
            commandBack(fsm, currentPath,
                        sManager, eManager,
                        outputs, inputs,
                        params);
            break;
         }
         case Command::current:
         {
            commandCurrent(fsm, currentPath,
                           sManager,eManager,
                           outputs,inputs);
            break;
         }
         case Command::help:
         {
            commandHelp(params);
            break;
         }
         case Command::commands:
         {
            commandCommands();
            break;
         }
         case Command::initial:
         {
            commandInitial(fsm,sManager,params);
            break;
         }
         case Command::next:
         {
            commandNext(fsm,currentPath,
                        sManager, eManager,
                        outputs, inputs,
                        params);
            break;
         }
         case Command::path:
         {
            commandPath(fsm, currentPath,
                        sManager, eManager,
                        params);
            break;
         }
         case Command::start:
         {
            commandStart(fsm, currentPath,
                         sManager, eManager,
                         outputs, inputs,
                         params);
            break;
         }
         case Command::quit:
         {
            break;
         }
         case Command::undo:
         {
            commandUndo(fsm,currentPath,sManager,eManager,outputs,inputs,params);
            break;
         }
         case Command::unknown:
         {
            commandUnknown();
            break;
         }
      }
   }
   while(cmd!=Command::quit);
  
   return SUCCESS;
}




size_t runDdaut(const std::string & fileName)
{
   DdAutFileDescriptor descriptor;
   DdAutEventManager eManager;
   DdAutStateManager sManager;
 
   ifstream file(fileName.c_str());
   if(file.is_open())
   {
      auto loaded = descriptor.readStream(file);                
      file.close();
      if(!loaded)
      {
         return printCommandLineError(Msg("Error when loading the 'ddaut' automaton file %1%")%fileName);
      }
   }
   else
   {
      return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%")%fileName);
   }
   DdAutFsm fsm;
   bool result =        fsmFromDescriptor(descriptor,fsm, sManager, eManager);
   if(!result)
   {
      return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite State Machine")%fileName);
   }
   std::cout << "Diades automaton explorer, LAAS-CNRS, Univ. Toulouse, France\n";
   std::cout << "\nIf you don't know how to use it, type 'help' unless you just\n want to quit then type 'quit'.\n";
   return interactiveDdAut(fsm,sManager,eManager);
}


size_t runFsm(const std::string & fileName)
{
  
   if (suffixes.match(fileName, "aut")) {
      return runAut(fileName);
   }
   else
   {
      if(suffixes.match(fileName, "ddaut"))
      {
         return runDdaut(fileName);
      }
      else
      {
         return printCommandLineError(Msg("Expecting a file with a name ending with .aut, but I read %1%") % fileName);
      }
   }
   return ERROR_UNHANDLED_EXCEPTION;
}





int main(int argc, char** argv)
{   
   std::string fileName, output;
   try
   {
      Poptions::options_description desc("Options");
      Poptions::variables_map vm;
      initialiseOptions(argc, argv, desc, vm);
      if(vm.count("help"))
      {
         return printUsage(program,desc);
      }
      if(vm.count("file"))
      {
         fileName = vm["file"].as<std::string>();
      }
   }
   catch(Poptions::required_option & e) 
   { 
      return printCommandLineError(e.what()); 
   } 
   catch(Poptions::error & e) 
   { 
      return printCommandLineError(e.what());
   } 
   return runFsm(fileName);
}