Object-Oriented Finite-State Machines

Listing 3: Derived Filter_eventhandler class

//--- Filter_eventhandler declaration ---

#include "ABS_eventhandler.h"
#include <stdio.h>

// Define list of possible states
enum Filter_states 
{
    VALID = 0, 
    WAIT_COMMENT,
    GARBAGE1, 
    GARBAGE2,
    WAIT_END_COMMENT
};

// Define list of possible events
enum Filter_events 
{
    SLASH ='/',
    ASTERISK ='*',
    NEWLINE ='\n',
    OTHER
};

// Event handlers indexes
enum Handler_indexes
{
    Ind_InternalError,            
    Ind_ignoreChar,        
    Ind_writeChar,
    Ind_writeSlash
};

// A class derived from an abstract event handler class
class Filter_EventHandler : public ABSEventHandler
{
 public :
    // Constructor
    Filter_EventHandler(int inNumberTransitions, char* inputFile, 
                        char* outputFile );

    // Destructor
    ~Filter_EventHandler( void );

    // Get a character from the input file
    int getCharacter();                

 private :
    FILE*    fi;    // Input file handle
    FILE*    fo;    // Output file handle

     // Redefinition of the abstract base class's
     // pure virtual function
    void    FillHandlersArray( void );

    // Event handlers - make some actions
    // associated with a transition
    Bool    handleInternalError( void* );
    Bool    ignoreChar( void* );
    Bool    writeChar( void* );
    Bool    writeSlash( void* );
};

//--- Filter_eventhandler definition ---

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include "Filter_eventhandler.h"

Filter_EventHandler::Filter_EventHandler(int inNumberTransitions, 
                         char* inputFile, char* outputFile )
    : ABSEventHandler(inNumberTransitions)
{
 // Call this function from the constructor
 FillHandlersArray();
  // Open input and output file -- not shown
}

Filter_EventHandler::getCharacter()
{
 // read a character from the input file and return it
 return fgetc(fi);
}

Filter_EventHandler::~Filter_EventHandler( void )
{
 // Close the files
 fclose(fi);
 fclose(fo);
}

void Filter_EventHandler::FillHandlersArray( void )
{
 functions[Ind_InternalError]
    = (FuncABSTransition)
    &Filter_EventHandler::handleInternalError;
 functions[Ind_ignoreChar]     
    = (FuncABSTransition)
    &Filter_EventHandler::ignoreChar;
 functions[Ind_writeChar]    
    = (FuncABSTransition)
    &Filter_EventHandler::writeChar;
 functions[Ind_writeSlash]    
    = (FuncABSTransition)
    &Filter_EventHandler::writeSlash;
}

Bool Filter_EventHandler::handleInternalError( void* )
{
 cout << "Handle internal error." << endl;
 return FALSE;
}

Bool Filter_EventHandler::ignoreChar( void* )
{
  // do nothing 
  return TRUE;
}

Bool Filter_EventHandler::writeChar( void* inChar )
{
 // Print a character into the output file
 fputc(*(int *) inChar, fo);
   
 return TRUE;
}

Bool Filter_EventHandler::writeSlash( void* inChar )
{
 // Print a slash and a character into the output file
 fputc(SLASH, fo);
 fputc(*(int *) inChar, fo);
   
 return TRUE;
}
//End of File