main.cpp

Go to the documentation of this file.

//
// Date:      20 August   2005   
//
// Copyright (c) Sergey Satskiy 2003 - 2005
//               <sergesatsky@yahoo.com>
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//


#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

#include <boost/algorithm/string/trim.hpp>
using namespace boost;
using namespace boost::algorithm;


#include "fsm.h"
using namespace FSM;

#include "MachineGrammar.h"



bool IsCinGood( void );
bool IsCinGood( void )
{
    if ( !cin.good() )
    {
        cin.clear();
        cin.ignore();
        cout << "Bad input." << endl;
        return false;
    }
    return true;
}




int  main( int  argc, char **  argv )
{
    if ( argc > 2 )
    {
        cout << "Usage: " << argv[ 0 ] << " [MachineDescriptionFile]" << endl;
        return 1;
    }

    string      MachineFileName( "machine" );           // Default file name is 'machine'
    if ( argc == 2 )
    {
        MachineFileName = string( argv[ 1 ] );
    }

    ifstream    Description( MachineFileName.c_str() ); // Input file
    if ( !Description )
    {
        cout << "Cannot open '" << MachineFileName << "' file." << endl;
        return 2;
    }
    

    char                                    Buffer[ 1024 ];     // Single line buffer
    string                                  StartState;         // Found start state
    SStatesListProxy< string >              StatesProxy;        // List of states
    SStateMachineProxy< string, string >    MachineProxy;       // Machine proxy

    vector< string >                        Transitions;        // List of transitions
        // Three grammars for each type of input file lines
    SStartStateGrammar                      StartStateGrammar( StartState );
    SStatesGrammar                          StatesGrammar( StatesProxy );
    SEventsGrammar                          EventsGrammar( Transitions );
        // Line parsing result object
    parse_info< const char * >              Info;
    

    try
    {
            // Cycle around all lines in he input file
            // Note: the algorithm is not the optimal on purpose. Just to make it
            //       easier to read
        while ( Description.getline( Buffer, sizeof( Buffer ) ) )
        {
            string      SingleLine( Buffer );
            
            trim( SingleLine );
                // Empty or remark lines must be skipped
            if ( SingleLine.empty() || SingleLine[ 0 ] == '#' )
            {
                continue;
            }

            if ( StartState.empty() )       // Start state has not been found yet
            {
                Info = parse( SingleLine.c_str(), StartStateGrammar, space_p );
                if ( !Info.full )
                {
                    cout << "Error. Stopped at: '" << Info.stop << endl;
                    break;
                }
                continue;
            }    

            if ( StatesProxy.GetStates().empty() )  // States list has not been found yet
            {
                Info = parse( SingleLine.c_str(), StatesGrammar, space_p );
                if ( !Info.full )
                {
                    cout << "Error. Stopped at: '" << Info.stop << endl;
                    break;
                }
                MachineProxy << StatesProxy;
                continue;
            }
        
                // There should be transitions further
            Transitions.clear();
            Info = parse( SingleLine.c_str(), EventsGrammar, space_p );
            if ( !Info.full )
            {
                cout << "Error. Stopped at: '" << Info.stop << endl;
                break;
            }

            vector< string >::const_iterator        Current( Transitions.begin() );
            STransitionsProxy< string, string >     TransitionsProxy( *Current );
        
            for ( ++Current; Current != Transitions.end(); ++Current )
            {
                if ( *Current == "NONE" )
                {
                    TransitionsProxy << NONE;
                    continue;
                }
                if ( *Current == "EXCEPTION" )
                {
                    TransitionsProxy << EXCEPTION;
                    continue;
                }
                TransitionsProxy << *Current;
            }
            MachineProxy << TransitionsProxy;

        }
        Description.close();
    }
    catch ( exception &  Exception )
    {
        cout << Exception.what() << endl;
        return 3;
    }
    catch ( ... )
    {
        cout << "Unknown exception." << endl;
        return 3;
    }


    
        // Construct the machine using the collected information
    SStateMachine< string, string >     TheMachine( StartState, MachineProxy );
    
    cout << "State machine start state: '" << TheMachine << "'" << endl;
    for ( ; ; )
    {
        string      Event;      
        do
        {
            cout << "Enter event name (Ctrl-C to exit): ";
            cin >> Event;
        }
        while ( !IsCinGood() );
        trim( Event );
        
        try
        {
            TheMachine << Event;        // Process the event
        }
        catch ( exception &  Exception )
        {
            cout << Exception.what() << endl;
        }
        cout << "Current state machine state: '" << TheMachine << "'" << endl;
    }

    return 0;
}

---