=================
hsmCommunicator.c
=================

.. code-block:: c

	/**
		hsmCommunicator.c
	
		This file automatically generated by FSMLang
	*/
	
	#include "hsmCommunicator_priv.h"
	#include <stddef.h>
	
	/* Begin Native Implementation Prolog */
	
	
	#define INIT_FSM_DATA {msg_none, { 0 }}
	
	/* End Native Implementation Prolog */
	
	
	#ifndef DBG_PRINTF
	#define DBG_PRINTF(...)
	#endif
	
	extern HSM_COMMUNICATOR_SUB_FSM_IF hsmCommunicator_establishSession_sub_fsm_if;
	extern HSM_COMMUNICATOR_SUB_FSM_IF hsmCommunicator_sendMessage_sub_fsm_if;
	
	static HSM_COMMUNICATOR_EVENT_ENUM UNINITIALIZED_stateFn(pHSM_COMMUNICATOR,HSM_COMMUNICATOR_EVENT_ENUM);
	static HSM_COMMUNICATOR_EVENT_ENUM IDLE_stateFn(pHSM_COMMUNICATOR,HSM_COMMUNICATOR_EVENT_ENUM);
	static HSM_COMMUNICATOR_EVENT_ENUM ESTABLISHING_SESSION_stateFn(pHSM_COMMUNICATOR,HSM_COMMUNICATOR_EVENT_ENUM);
	static HSM_COMMUNICATOR_EVENT_ENUM IN_SESSION_stateFn(pHSM_COMMUNICATOR,HSM_COMMUNICATOR_EVENT_ENUM);
	static HSM_COMMUNICATOR_EVENT_ENUM findAndRunSubMachine(pHSM_COMMUNICATOR,HSM_COMMUNICATOR_EVENT_ENUM);
	
	static void translateEventData(pHSM_COMMUNICATOR_DATA,pHSM_COMMUNICATOR_EVENT);
	
	static void runAppropriateEntryFunction(pHSM_COMMUNICATOR_DATA,HSM_COMMUNICATOR_STATE);
	static void runAppropriateExitFunction(pHSM_COMMUNICATOR_DATA,HSM_COMMUNICATOR_STATE);
	static const HSM_COMMUNICATOR_STATE_FN hsmCommunicator_state_fn_array[hsmCommunicator_numStates] =
	{
	    UNINITIALIZED_stateFn
	    , IDLE_stateFn
	    , ESTABLISHING_SESSION_stateFn
	    , IN_SESSION_stateFn
	};
	
	
	const pHSM_COMMUNICATOR_SUB_FSM_IF hsmCommunicator_sub_fsm_if_array[THIS(numSubMachines)] =
	{
	    &hsmCommunicator_establishSession_sub_fsm_if
	    , &hsmCommunicator_sendMessage_sub_fsm_if
	};
	
	pHSM_COMMUNICATOR_SHARED_EVENT_STR sharing_hsmCommunicator_INIT[] =
	{
	    &sendMessage_share_hsmCommunicator_INIT_str
	    , NULL
	};
	
	pHSM_COMMUNICATOR_SHARED_EVENT_STR sharing_hsmCommunicator_MESSAGE_RECEIVED[] =
	{
	    &establishSession_share_hsmCommunicator_MESSAGE_RECEIVED_str
	    , &sendMessage_share_hsmCommunicator_MESSAGE_RECEIVED_str
	    , NULL
	};
	
	HSM_COMMUNICATOR_EVENT_ENUM hsmCommunicator_pass_shared_event(pHSM_COMMUNICATOR pfsm,pHSM_COMMUNICATOR_SHARED_EVENT_STR sharer_list[])
	{
	    HSM_COMMUNICATOR_EVENT_ENUM return_event = THIS(noEvent);
	
	    for (pHSM_COMMUNICATOR_SHARED_EVENT_STR *pcurrent_sharer = sharer_list;
	            *pcurrent_sharer && return_event == THIS(noEvent);
	            pcurrent_sharer++)
	    {
	        if ((*pcurrent_sharer)->data_translation_fn)
	            (*(*pcurrent_sharer)->data_translation_fn)(&pfsm->data);
	        return_event = (*(*pcurrent_sharer)->psub_fsm_if->subFSM)((*pcurrent_sharer)->event);
	    }
	
	    return return_event;
	}
	
	#ifndef INIT_FSM_DATA
	#error INIT_FSM_DATA must be defined
	#endif
	
	HSM_COMMUNICATOR hsmCommunicator = {
	
	    INIT_FSM_DATA,
	    hsmCommunicator_UNINITIALIZED,
	    THIS(INIT),
	    &hsmCommunicator_state_fn_array,
	    &hsmCommunicator_sub_fsm_if_array,
	    hsmCommunicatorFSM
	};
	
	pHSM_COMMUNICATOR phsmCommunicator = &hsmCommunicator;
	
	void run_hsmCommunicator(pHSM_COMMUNICATOR_EVENT e)
	{
	    if (phsmCommunicator)
	    {
	        phsmCommunicator->fsm(phsmCommunicator,e);
	    }
	}
	
	
	#ifndef EVENT_IS_NOT_EXCLUDED_FROM_LOG
	#define EVENT_IS_NOT_EXCLUDED_FROM_LOG(e) ((e) == (e))
	#endif
	void hsmCommunicatorFSM(pHSM_COMMUNICATOR pfsm, pHSM_COMMUNICATOR_EVENT event)
	{
	    HSM_COMMUNICATOR_EVENT_ENUM e = event->event;
	
	    translateEventData(&pfsm->data, event);
	
	    while (e != hsmCommunicator_noEvent) {
	
	#ifdef HSM_COMMUNICATOR_DEBUG
	        if (EVENT_IS_NOT_EXCLUDED_FROM_LOG(e))
	        {
	            DBG_PRINTF("event: %s; state: %s"
	                       ,HSM_COMMUNICATOR_EVENT_NAMES[e]
	                       ,HSM_COMMUNICATOR_STATE_NAMES[pfsm->state]
	                      );
	        }
	#endif
	
	        /* This is read-only data to facilitate error reporting in action functions */
	        pfsm->event = e;
	
	        if (e < hsmCommunicator_noEvent)
	        {
	            e = ((* (*pfsm->statesArray)[pfsm->state])(pfsm,e));
	        }
	        else
	        {
	            e = findAndRunSubMachine(pfsm, e);
	        }
	
	    }
	}
	
	
	static HSM_COMMUNICATOR_EVENT_ENUM findAndRunSubMachine(pHSM_COMMUNICATOR pfsm, HSM_COMMUNICATOR_EVENT_ENUM e)
	{
	    for (HSM_COMMUNICATOR_SUB_MACHINES machineIterator = THIS(firstSubMachine);
	            machineIterator < THIS(numSubMachines);
	            machineIterator++
	        )
	    {
	        if (
	            ((*pfsm->subMachineArray)[machineIterator]->first_event <= e)
	            && ((*pfsm->subMachineArray)[machineIterator]->last_event > e)
	        )
	        {
	            return ((*(*pfsm->subMachineArray)[machineIterator]->subFSM)(e));
	        }
	    }
	
	    return THIS(noEvent);
	
	}
	
	static void runAppropriateEntryFunction(pHSM_COMMUNICATOR_DATA pdata,HSM_COMMUNICATOR_STATE s)
	{
	    switch(s)
	    {
	    case hsmCommunicator_IN_SESSION:
	        hsmCommunicator_start_session_timer(pdata);
	        break;
	    default:
	        break;
	    }
	}
	
	static void runAppropriateExitFunction(pHSM_COMMUNICATOR_DATA pdata,HSM_COMMUNICATOR_STATE s)
	{
	    switch(s)
	    {
	    case hsmCommunicator_IN_SESSION:
	        hsmCommunicator_stop_session_timer(pdata);
	        break;
	    default:
	        break;
	    }
	}
	
	static void translateEventData(pHSM_COMMUNICATOR_DATA pfsm_data, pHSM_COMMUNICATOR_EVENT pevent)
	{
	    switch(pevent->event)
	    {
	    case hsmCommunicator_MESSAGE_RECEIVED:
	        UFMN(store_message)(pfsm_data, &pevent->event_data.MESSAGE_RECEIVED_data);
	        break;
	    default:
	        break;
	    }
	
	}
	
	static HSM_COMMUNICATOR_EVENT_ENUM UNINITIALIZED_stateFn(pHSM_COMMUNICATOR pfsm,HSM_COMMUNICATOR_EVENT_ENUM e)
	{
	    HSM_COMMUNICATOR_EVENT_ENUM retVal = THIS(noEvent);
	    HSM_COMMUNICATOR_STATE new_s = hsmCommunicator_UNINITIALIZED;
	
	    switch(e)
	    {
	    case THIS(INIT):
	        retVal = UFMN(initialize)(pfsm);
	        new_s = hsmCommunicator_IDLE;
	        break;
	    default:
	        DBG_PRINTF("hsmCommunicator_noAction");
	        break;
	    }
	
	
	    if (hsmCommunicator_UNINITIALIZED != new_s)
	    {
	        UFMN(track_transitions)(pfsm, new_s);
	        runAppropriateExitFunction(&pfsm->data, hsmCommunicator_UNINITIALIZED);
	        runAppropriateEntryFunction(&pfsm->data, new_s);
	        pfsm->state = new_s;
	
	    }
	
	
	    return retVal;
	}
	
	static HSM_COMMUNICATOR_EVENT_ENUM IDLE_stateFn(pHSM_COMMUNICATOR pfsm,HSM_COMMUNICATOR_EVENT_ENUM e)
	{
	    HSM_COMMUNICATOR_EVENT_ENUM retVal = THIS(noEvent);
	    HSM_COMMUNICATOR_STATE new_s = hsmCommunicator_IDLE;
	
	    switch(e)
	    {
	    case THIS(SEND_MESSAGE):
	        retVal = UFMN(startSessionEstablishment)(pfsm);
	        new_s = hsmCommunicator_ESTABLISHING_SESSION;
	        break;
	    default:
	        DBG_PRINTF("hsmCommunicator_noAction");
	        break;
	    }
	
	
	    if (hsmCommunicator_IDLE != new_s)
	    {
	        UFMN(track_transitions)(pfsm, new_s);
	        runAppropriateExitFunction(&pfsm->data, hsmCommunicator_IDLE);
	        runAppropriateEntryFunction(&pfsm->data, new_s);
	        pfsm->state = new_s;
	
	    }
	
	
	    return retVal;
	}
	
	static HSM_COMMUNICATOR_EVENT_ENUM ESTABLISHING_SESSION_stateFn(pHSM_COMMUNICATOR pfsm,HSM_COMMUNICATOR_EVENT_ENUM e)
	{
	    HSM_COMMUNICATOR_EVENT_ENUM retVal = THIS(noEvent);
	    HSM_COMMUNICATOR_STATE new_s = hsmCommunicator_ESTABLISHING_SESSION;
	
	    switch(e)
	    {
	    case THIS(MESSAGE_RECEIVED):
	        retVal = UFMN(passMessageReceived)(pfsm);
	        break;
	    case THIS(SESSION_REJECTED):
	        retVal = UFMN(clearQueue)(pfsm);
	        new_s = hsmCommunicator_IDLE;
	        break;
	    case THIS(SESSION_ESTABLISHED):
	        retVal = UFMN(completeSessionStart)(pfsm);
	        new_s = hsmCommunicator_IN_SESSION;
	        break;
	    case THIS(SEND_MESSAGE):
	        retVal = UFMN(requestMessageTransmission)(pfsm);
	        break;
	    default:
	        DBG_PRINTF("hsmCommunicator_noAction");
	        break;
	    }
	
	
	    if (hsmCommunicator_ESTABLISHING_SESSION != new_s)
	    {
	        UFMN(track_transitions)(pfsm, new_s);
	        runAppropriateExitFunction(&pfsm->data, hsmCommunicator_ESTABLISHING_SESSION);
	        runAppropriateEntryFunction(&pfsm->data, new_s);
	        pfsm->state = new_s;
	
	    }
	
	
	    return retVal;
	}
	
	static HSM_COMMUNICATOR_EVENT_ENUM IN_SESSION_stateFn(pHSM_COMMUNICATOR pfsm,HSM_COMMUNICATOR_EVENT_ENUM e)
	{
	    HSM_COMMUNICATOR_EVENT_ENUM retVal = THIS(noEvent);
	    HSM_COMMUNICATOR_STATE new_s = hsmCommunicator_IN_SESSION;
	
	    switch(e)
	    {
	    case THIS(MESSAGE_RECEIVED):
	        retVal = UFMN(passMessageReceived)(pfsm);
	        break;
	    case THIS(SEND_MESSAGE):
	        retVal = UFMN(requestMessageTransmission)(pfsm);
	        break;
	    case THIS(SESSION_TIMEOUT):
	        DBG_PRINTF("hsmCommunicator_noAction");
	        new_s = hsmCommunicator_IDLE;
	        break;
	    default:
	        DBG_PRINTF("hsmCommunicator_noAction");
	        break;
	    }
	
	
	    if (hsmCommunicator_IN_SESSION != new_s)
	    {
	        UFMN(track_transitions)(pfsm, new_s);
	        runAppropriateExitFunction(&pfsm->data, hsmCommunicator_IN_SESSION);
	        runAppropriateEntryFunction(&pfsm->data, new_s);
	        pfsm->state = new_s;
	
	    }
	
	
	    return retVal;
	}
	
	
	HSM_COMMUNICATOR_EVENT_ENUM UFMN(initialize)(pHSM_COMMUNICATOR pfsm)
	{
	    DBG_PRINTF("%s", __func__);
	    return hsmCommunicator_pass_shared_event(pfsm, sharing_hsmCommunicator_INIT);
	}
	
	HSM_COMMUNICATOR_EVENT_ENUM UFMN(passMessageReceived)(pHSM_COMMUNICATOR pfsm)
	{
	    DBG_PRINTF("%s", __func__);
	    return hsmCommunicator_pass_shared_event(pfsm, sharing_hsmCommunicator_MESSAGE_RECEIVED);
	}
	
	
	#ifdef HSM_COMMUNICATOR_DEBUG
	char *HSM_COMMUNICATOR_EVENT_NAMES[] = {
	    "hsmCommunicator_INIT"
	    ,"hsmCommunicator_SEND_MESSAGE"
	    ,"hsmCommunicator_SESSION_ESTABLISHED"
	    ,"hsmCommunicator_SESSION_REJECTED"
	    ,"hsmCommunicator_SESSION_TIMEOUT"
	    ,"hsmCommunicator_MESSAGE_RECEIVED"
	    , "hsmCommunicator_noEvent"
	    , "hsmCommunicator_numEvents"
	    , "hsmCommunicator_establishSession_ESTABLISH_SESSION_REQUEST"
	    , "hsmCommunicator_establishSession_STEP0_RESPONSE"
	    , "hsmCommunicator_establishSession_MESSAGE_RECEIVED"
	    , "hsmCommunicator_establishSession_noEvent"
	    , "hsmCommunicator_sendMessage_INIT"
	    , "hsmCommunicator_sendMessage_MESSAGE_RECEIVED"
	    , "hsmCommunicator_sendMessage_SEND_MESSAGE"
	    , "hsmCommunicator_sendMessage_ACK"
	    , "hsmCommunicator_sendMessage_noEvent"
	};
	
	char *HSM_COMMUNICATOR_STATE_NAMES[] = {
	    "hsmCommunicator_UNINITIALIZED"
	    ,"hsmCommunicator_IDLE"
	    ,"hsmCommunicator_ESTABLISHING_SESSION"
	    ,"hsmCommunicator_IN_SESSION"
	};
	
	#endif