Platform/Aperios1.3.2/ProcessFramework.cpp

Go to the documentation of this file.

/**
 * @file Platform/Aperios1.3.2/ProcessFramework.cpp
 * This file implements classes related to processes on the Aperios Platform.
 */
#include "ProcessFramework.h"
#include "IPEndpoint.h"

#ifdef __GNUC__
#include <apsys.h>
/**
 * This is a big hack. For gcc, we need entry points for all callback functions,
 * and it is not possible to generate them automatically. Therefore, we define
 * a pool of 100 entry points here. The array "entry" contains the addresses of
 * the entry points, "link" contains the functions that will actually be called.
 */
static void (*link[ENTRY_TABLE_MAX])(void*);

/**
 * Create 100 entry points.
 */
#define LINK(id) \
  extern "C" void link##id(void* msg) \
  { \
    link[id](msg); \
  } \
  GEN_ENTRY(link##id##Entry,link##id)

#define LROW(n) \
  LINK(n##0); LINK(n##1); LINK(n##2); LINK(n##3); LINK(n##4); LINK(n##5); LINK(n##6); LINK(n##7); LINK(n##8); LINK(n##9)

LROW(); LROW(1); LROW(2); LROW(3); LROW(4); LROW(5); LROW(6); LROW(7); LROW(8); LROW(9);

/**
 * Create and initialize "entry".
 */
#define ENTRY(id) link##id##Entry

#define EROW(n) \
  ENTRY(n##0), ENTRY(n##1), ENTRY(n##2), ENTRY(n##3), ENTRY(n##4), \
  ENTRY(n##5), ENTRY(n##6), ENTRY(n##7), ENTRY(n##8), ENTRY(n##9)

static void (*entry[ENTRY_TABLE_MAX])() =
{
  EROW(), EROW(1), EROW(2), EROW(3), EROW(4), EROW(5), EROW(6), EROW(7), EROW(8), EROW(9)
};

GEN_ENTRY(PrologueEntry,Prologue);

#endif // __GNUC__

int ProcessBase::blockMask = 0,
    ProcessBase::eventMask = 0;
ProcessBase* ProcessBase::theInstance = 0;

ObjectEntry ObjectEntryTable[ENTRY_TABLE_MAX + 1];

void ProcessBase::aperiosInit(OReasonMessage* reasonMsg)
{
  theInstance->Init(OSystemEvent(reasonMsg->reason,reasonMsg->param,reasonMsg->paramSize));
  Return();
}

void ProcessBase::aperiosStart(OReasonMessage* reasonMsg)
{
  theInstance->Start(OSystemEvent(reasonMsg->reason,reasonMsg->param,reasonMsg->paramSize));
  Return();
}

void ProcessBase::aperiosStop(OReasonMessage* reasonMsg)
{
  theInstance->Stop(OSystemEvent(reasonMsg->reason,reasonMsg->param,reasonMsg->paramSize));
  Return();
}

void ProcessBase::aperiosDestroy(OReasonMessage* reasonMsg)
{
  theInstance->Destroy(OSystemEvent(reasonMsg->reason,reasonMsg->param,reasonMsg->paramSize)); 
  Return();
}

void ProcessBase::awakeOnTimer(OReasonMessage* reasonMsg)
{
  setEventId(31);
  Exit();
}

    
void ProcessBase::antListenCont(antEnvMsg* msg)
{
  // When the message was send to the ANT-lib its continuation
  // field was set to the address of the Endpoint. So this calls
  // the listenCont funtion of the right IPEndpoint
  // cout << "ProcessBase::antListenCont " << msg << "\n";
  (static_cast<IPEndpoint*>(msg->continuation))->listenCont(msg);
  // cout << "ProcessBase::antListenCont done \n";
  Return();
}

void ProcessBase::antConnectCont(antEnvMsg* msg)
{
  //cout << "ProcessBase::antConnectCont " << msg << "\n";
  (static_cast<IPEndpoint*>(msg->continuation))->connectCont(msg);
  //cout << "ProcessBase::antConnectCont done \n";
  Return();
}

void ProcessBase::antReceiveCont(antEnvMsg* msg)
{
  //cout << "ProcessBase::antReceiveCont " << msg << "\n";
  (static_cast<IPEndpoint*>(msg->continuation))->receiveCont(msg);
  //cout << "ProcessBase::antReceiveCont done \n ";
  Return();
}  

void ProcessBase::antSendCont(antEnvMsg* msg)
{
  //cout << "ProcessBase::antSendCont " << msg << "\n";
  (static_cast<IPEndpoint*>(msg->continuation))->sendCont(msg);
  //cout << "ProcessBase::antSendCont done \n";
  Return();
}

void ProcessBase::antCloseCont(antEnvMsg* msg)
{
  //cout << "ProcessBase::antCloseCont " << msg << "\n";
  (static_cast<IPEndpoint*>(msg->continuation))->closeCont(msg);
  //cout << "ProcessBase::antCloseCont done \n";
  Return();
}

void ProcessBase::getAntInformation(int*& listenContSelector, int*& sendContSelector,
                 int*& receiveContSelector, int*& closeContSelector, 
                 int*& connectContSelector)
{
    listenContSelector = &antListenContSelector;
    sendContSelector = &antSendContSelector;
    receiveContSelector = &antReceiveContSelector;
    closeContSelector = &antCloseContSelector;
    connectContSelector = &antConnectContSelector;   
}

void ProcessBase::init()
{
  unsigned int id = 0;
  ObjectEntryTable[id].selector = id;
  ObjectEntryTable[id++].entry = (Entry) aperiosInit;
  ObjectEntryTable[id].selector = id;
  ObjectEntryTable[id++].entry = (Entry) aperiosStart;
  ObjectEntryTable[id].selector = id;
  ObjectEntryTable[id++].entry = (Entry) aperiosStop;
  ObjectEntryTable[id].selector = id;
  ObjectEntryTable[id++].entry = (Entry) aperiosDestroy;
  ObjectEntryTable[id].selector = id;
  ObjectEntryTable[id++].entry = (Entry) awakeOnTimer;

  for(ReceiverList* p = getProcess()->getFirstReceiver(); p; p = p->getNext())
    id = p->fillEntryTable(ObjectEntryTable,id);
  for(SenderList* q = getProcess()->getFirstSender(); q; q = q->getNext())
    id = q->fillEntryTable(ObjectEntryTable,id);
  ASSERT(id <= ENTRY_TABLE_MAX);

  // Entrys for IP-networking

  ObjectEntryTable[id].selector = id;
  antListenContSelector = id;
  ObjectEntryTable[id++].entry = (Entry) antListenCont;
  
  ObjectEntryTable[id].selector = id;
  antReceiveContSelector = id;
  ObjectEntryTable[id++].entry = (Entry) antReceiveCont;

  ObjectEntryTable[id].selector = id;
  antSendContSelector = id;
  ObjectEntryTable[id++].entry = (Entry) antSendCont;

  ObjectEntryTable[id].selector = id;
  antCloseContSelector = id;
  ObjectEntryTable[id++].entry = (Entry) antCloseCont;

  ObjectEntryTable[id].selector = id;
  antConnectContSelector = id;
  ObjectEntryTable[id++].entry = (Entry) antConnectCont;

  ASSERT(id <= ENTRY_TABLE_MAX);
 
#ifdef __GNUC__
  // add entry points to callback functions
  for(unsigned int i = 0; i < id; ++i)
  {
    link[i] = (void (*)(void*)) ObjectEntryTable[i].entry;
    ObjectEntryTable[i].entry = (Entry) entry[i];
  }
#endif // __GNUC__

  ObjectEntryTable[id].selector = UNDEF;
  ObjectEntryTable[id].entry = ENTRY_UNDEF;
}

void ProcessBase::nextFrame()
{
  if(theInstance->isRunning())
    theInstance->processNextFrame();
}

void ProcessBase::setBlockingId(int id,bool block)
{
  if(block)
    blockMask |= 1 << id;
  else
    blockMask &= ~(1 << id);
}

void ProcessBase::setEventId(int id)
{
  eventMask |= 1 << id;
  if(blockMask && (eventMask & blockMask) == blockMask)
  {
    blockMask = 0;
    nextFrame();
  }
}

---