//--------------------------------------------------------------
// Name: transitionToState()
// Class: CloseInOnEnemyWhileFiringWeapon
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void CloseInOnEnemyWhileFiringWeapon::transitionToState( CIWFStates_t state )
{
switch( state )
{
case CIWF_APPROACH_SETUP_APPROACH:
setupStateSetupApproach();
setInternalState( state , "CIWF_APPROACH_SETUP_APPROACH" );
break;
case CIWF_APPROACH_FIRE:
setupStateApproachFire();
setInternalState( state , "CIWF_APPROACH_FIRE" );
break;
case CIWF_APPROACH_FIRE_PAUSE:
setupStateApproachFirePause();
setInternalState( state , "CIWF_APPROACH_FIRE_PAUSE" );
break;
case CIWF_SUCCESS:
setInternalState( state , "CIWF_SUCCESS" );
break;
case CIWF_FAILED:
setInternalState( state , "CIWF_FAILED" );
break;
}
}
//----------------------------------------------------------------------------
void ctkExampleDicomAppLogic::onCancelProgress()
{
//release all resources
onReleaseResources();
//update state
setInternalState(ctkDicomAppHosting::IDLE);
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::IDLE);
}
//----------------------------------------------------------------------------
void ctkExampleDicomAppLogic::onExitHostedApp()
{
//useless move, but correct:
setInternalState(ctkDicomAppHosting::EXIT);
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::EXIT);
qDebug() << "Exiting";
//die
qApp->exit(0);
}
object_ptr<ContentWidget> Memento::createWidget(
QWidget *parent,
not_null<Controller*> controller,
const QRect &geometry) {
auto result = object_ptr<Widget>(
parent,
controller);
result->setInternalState(geometry, this);
return std::move(result);
}
//----------------------------------------------------------------------------
void ctkExampleDicomAppLogic::onSuspendProgress()
{
//release resources it can reclame later to resume work
ui.LoadDataButton->setEnabled(false);
//notify state changed
setInternalState(ctkDicomAppHosting::SUSPENDED);
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::SUSPENDED);
//we're rolling
//do something else normally, but this is an example
}
//----------------------------------------------------------------------------
void ctkExampleDicomAppLogic::onStartProgress()
{
setInternalState(ctkDicomAppHosting::INPROGRESS);
// we need to create the button before we receive data from
// the host, which happens immediately after calling
// getHostInterface()->notifyStateChanged
do_something();
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::INPROGRESS);
}
//----------------------------------------------------------------------------
void ctkExampleDicomAppLogic::onResumeProgress()
{
//reclame all resources.
//notify state changed
setInternalState(ctkDicomAppHosting::INPROGRESS);
getHostInterface()->notifyStateChanged(ctkDicomAppHosting::INPROGRESS);
//we're rolling
//do something else normally, but this is an example
ui.LoadDataButton->setEnabled(true);
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: StationaryFireCombat
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::transitionToState( StationaryFireStates_t state )
{
switch ( state )
{
case STATIONARY_FIRE_AIM:
setupStateAim();
setInternalState( state , "STATIONARY_FIRE_AIM" );
break;
case STATIONARY_FIRE_PRE_FIRE:
setupStatePreFire();
setInternalState( state , "STATIONARY_FIRE_PRE_FIRE" );
break;
case STATIONARY_FIRE_ATTACK:
setupStateAttack();
setInternalState( state , "STATIONARY_FIRE_ATTACK" );
break;
case STATIONARY_FIRE_POST_FIRE:
setupStatePostFire();
setInternalState( state , "STATIONARY_FIRE_POST_FIRE" );
break;
case STATIONARY_FIRE_SUCCESS:
setInternalState( state , "STATIONARY_FIRE_SUCCESS" );
break;
case STATIONARY_FIRE_FAILED:
setInternalState( state , "SUPPRESSION_FIRE_FAILED" );
break;
}
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: TorsoAimAndFireWeapon
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void TorsoAimAndFireWeapon::transitionToState( TorsoAimAndFireStates_t state )
{
switch ( state )
{
case TORSO_AIM_AND_FIRE_AIM:
setupStateAim();
setInternalState( state , "TORSO_AIM_AND_FIRE_AIM" );
break;
case TORSO_AIM_AND_FIRE_PRE_FIRE:
setupStatePreFire();
setInternalState( state , "TORSO_AIM_AND_FIRE_PRE_FIRE" );
break;
case TORSO_AIM_AND_FIRE_ATTACK:
setupStateAttack();
setInternalState( state , "TORSO_AIM_AND_FIRE_ATTACK" );
break;
case TORSO_AIM_AND_FIRE_POST_FIRE:
setupStatePostFire();
setInternalState( state , "TORSO_AIM_AND_FIRE_POST_FIRE" );
break;
case TORSO_AIM_AND_FIRE_SUCCESS:
setInternalState( state , "TORSO_AIM_AND_FIRE_SUCCESS" );
break;
case TORSO_AIM_AND_FIRE_FAILED:
setInternalState( state , "TORSO_AIM_AND_FIRE_FAILED" );
break;
}
}
void WatchEntity::transitionToState( watchEntityStates_t state )
{
switch ( state )
{
case WATCH_HOLD:
setupStateHold();
setInternalState( state , "WATCH_HOLD" );
break;
case WATCH_ROTATE:
setupStateRotate();
setInternalState( state , "WATCH_ROTATE" );
break;
case WATCH_SUCCESS:
setInternalState( state , "WATCH_SUCCESS" );
break;
case WATCH_FAILED:
setInternalState( state , "WATCH_FAILED" );
break;
}
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: GotoCurrentHelperNode
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void GotoCurrentHelperNode::transitionToState( GotoHelperNodeStates_t state )
{
switch ( state )
{
case GOTO_HNODE_FIND_NODE:
setupStateFindNode();
setInternalState( state , "GOTO_HNODE_FIND_NODE" );
break;
case GOTO_HNODE_MOVE_TO_NODE:
setupStateMoveToNode();
setInternalState( state , "GOTO_HNODE_MOVE_TO_NODE" );
break;
case GOTO_HNODE_SUCCESS:
setInternalState( state , "GOTO_HNODE_SUCCESS" );
break;
case GOTO_HNODE_FAILED:
setInternalState( state , "GOTO_HNODE_FAILED" );
break;
}
}
EDMA_Status EDMA_mapBaseAddress(void **pvirtAddr)
{
Int sharedMemId = -1;
if (NULL == state) {
#ifdef xdc_target__os_Linux
state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
state = &myState;
setInternalState(state);
sharedMemId = 0;
#endif
state->sharedMemId = sharedMemId;
}
*pvirtAddr = (void **)(state->edma).edmaAddressSpace;
return (EDMA_OK);
}
static void getInternalState()
{
#ifdef xdc_target__os_Linux
Int sharedMemId = -1;
_resmanInternalState = (IRESMAN_HDVICP_InternalState *)SHM_getObj(gate,
sizeof(IRESMAN_HDVICP_InternalState), _HDVICP_LOCKID,
&setInternalState, &sharedMemId);
_resmanInternalState->sharedMemId = sharedMemId;
#else
__FAR__ static IRESMAN_HDVICP_InternalState _HDVICP_internalState;
_resmanInternalState = (IRESMAN_HDVICP_InternalState *)
&_HDVICP_internalState;
setInternalState(_resmanInternalState);
_resmanInternalState->sharedMemId = 0;
#endif
}
int EDMA_init(void)
{
Int sharedMemId;
#ifdef xdc_target__os_Linux
state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
state = &myState;
setInternalState(state);
sharedMemId = 0;
#endif
state->refCount++;
if (NULL != state) {
state->sharedMemId = sharedMemId;
}
return (1);
}
static void getInternalState()
{
Int sharedMemId = -1;
#ifdef xdc_target__os_Linux
rmanInternalState = (RMAN_InternalState *)SHM_getObj(gate,
sizeof(RMAN_InternalState) + (ti_sdo_fc_rman_RMAN_MAXALGS *
sizeof(RMAN_VtableEntry)), (key_t)_RMAN_LOCKID,
&setInternalState, &sharedMemId);
algresVTable = (RMAN_VtableEntry *)((unsigned int)rmanInternalState +
(unsigned int) (rmanInternalState->info.vTableOffset));
#else
rmanInternalState = (RMAN_InternalState *)
&_RMAN_internalState;
algresVTable = (RMAN_VtableEntry *)(malloc(ti_sdo_fc_rman_RMAN_MAXALGS *
sizeof(RMAN_VtableEntry)));
setInternalState(rmanInternalState);
sharedMemId = 0;
#endif
rmanInternalState->info.sharedMemId = sharedMemId;
rmanInternalState->info.refCount++;
}
EDMA_Status EDMA_getResource(int devId, int *tcc, int *channel, int *param,
int nParams)
{
EDMA_Status status = EDMA_ENOCHANNEL;
Bool found = FALSE;
Int j = 0;
Int temp = -1;
Int sharedMemId;
if (NULL == state) {
#ifdef xdc_target__os_Linux
state = ( EDMA_State *)SHM_getObj(EXAMPLE_gate, sizeof(EDMA_State),
EDMA_LOCKID, &setInternalState, &sharedMemId);
#else
state = (EDMA_State *)&myState;
setInternalState(state);
sharedMemId = 0;
#endif
state->sharedMemId = sharedMemId;
}
switch (devId) {
case EDMA_EDMAANY:
while (state->symIndex < 64) {
if ((state->edmaArr[state->symIndex] == 0) &&
(state->paramArr[state->symIndex] == 0) &&
(state->tccArr[state->symIndex] == 0)) {
*channel = state->symIndex;
*param = state->symIndex;
*tcc = state->symIndex;
state->edmaArr[state->symIndex] = 1;
state->paramArr[state->symIndex] = 1;
state->tccArr[state->symIndex] = 1;
status = EDMA_OK;
state->symIndex++;
break;
}
else {
state->symIndex++;
}
}
break;
case EDMA_QDMAANY:
while (state->tccQdmaIndex != state->symIndex) {
if (*tcc != EDMA_TCCANY) {
temp = state->tccQdmaIndex;
state->tccQdmaIndex = *tcc;
}
if (state->tccArr[state->tccQdmaIndex] == 0) {
while ((state->qdmaIndex < 8) &&
(state->qdmaArr[state->qdmaIndex] == 1)) {
state->qdmaIndex++;
}
while ((state->paramAnyIndex < 512) && (state->paramArr[state->paramAnyIndex] == 1)){
state->paramAnyIndex++;
}
if ((1 == state->qdmaArr[state->qdmaIndex]) ||
(1 == state->paramArr[state->paramAnyIndex])) {
break;
}
*channel = EDMA_QDMA0 + state->qdmaIndex;
*param = state->paramAnyIndex;
*tcc = state->tccQdmaIndex;
state->qdmaArr[state->qdmaIndex] = 1;
state->paramArr[state->paramAnyIndex] = 1;
state->tccArr[state->tccQdmaIndex] = 1;
state->qdmaIndex++;
state->tccQdmaIndex--;
state->paramAnyIndex++;
status = EDMA_OK;
if (temp != -1) {
state->tccQdmaIndex = temp;
}
break;
}
else {
if (*tcc != EDMA_TCCANY) {
break;
}
state->tccQdmaIndex--;
}
}
if (temp != -1) {
state->tccQdmaIndex = temp;
}
break;
case EDMA_PARAMANY:
while ((state->paramAnyIndex < 512) && (state->paramArr[state->paramAnyIndex] == 1)) {
state->paramAnyIndex++;
}
if (state->paramAnyIndex + nParams < 512) {
for (j = 0; j < nParams; j++) {
state->paramArr[state->paramAnyIndex+j] = 1;
}
*param = state->paramAnyIndex;
state->paramAnyIndex += nParams;
status = EDMA_OK;
break;
}
break;
default:
if (devId < 64) {
/* Requested and EDMA channel */
if ((state->edmaArr[devId] == 0) &&
(state->paramArr[devId] == 0) &&
(state->tccArr[devId] == 0)) {
*channel = devId;
*param = devId;
*tcc = devId;
state->edmaArr[devId] = 1;
state->paramArr[devId] = 1;
state->tccArr[devId] = 1;
status = EDMA_OK;
break;
}
}
else if (devId < 512) {
/* Requested a PARAM channel */
for (j = 0; j < nParams; j++) {
if (state->paramArr[devId+j] == 0) {
found = TRUE;
state->paramArr[devId + j] = 1;
}
else {
found = FALSE;
break;
}
}
if (found) {
*param = devId;
status = EDMA_OK;
}
}
else if (devId <= EDMA_QDMA7) {
if (state->qdmaArr[devId-EDMA_QDMA0] == 0) {
state->qdmaArr[devId-EDMA_QDMA0] = 1;
*channel = devId-EDMA_QDMA0;
}
while (state->tccQdmaIndex != state->symIndex) {
if (state->tccArr[state->tccQdmaIndex] == 0) {
while ((state->paramAnyIndex < 512) &&
(state->paramArr[state->paramAnyIndex] == 1)) {
state->paramAnyIndex++;
}
if (1 == state->paramArr[state->paramAnyIndex]) {
break;
}
*param = state->paramAnyIndex;
*tcc = state->tccQdmaIndex;
state->paramArr[state->paramAnyIndex] = 1;
state->tccArr[state->tccQdmaIndex] = 1;
state->tccQdmaIndex--;
state->paramAnyIndex++;
status = EDMA_OK;
break;
}
else {
state->tccQdmaIndex--;
}
}
}
}
return (status);
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: Work
//
// Description: Transitions Internal State
//
// Parameters: workStates_t state
//
// Returns: None
//--------------------------------------------------------------
void Work::transitionToState ( workStates_t state )
{
switch ( state )
{
case WORK_FIND_NODE:
setupStateFindNode();
setInternalState( state , "WORK_FIND_NODE" );
break;
case WORK_MOVE_TO_NODE:
setupStateMoveToNode();
setInternalState( state , "WORK_MOVE_TO_NODE" );
break;
case WORK_AT_NODE:
setupStateAtNode();
setInternalState( state , "WORK_AT_NODE" );
break;
case WORK_ANIMATE_WAIT_ON_TIME:
setupStateAnimateWaitOnTime();
setInternalState( state , "WORK_ANIMATE_WAIT_ON_TIME" );
break;
case WORK_ANIMATE_WAIT_ON_ANIM:
setupStateAnimateWaitOnAnim();
setInternalState( state , "WORK_ANIMATE_WAIT_ON_ANIM" );
break;
case WORK_ANIMATE_WAIT_ON_SIGNAL:
setupStateAnimateWaitOnSignal();
setInternalState( state , "WORK_ANIMATE_WAIT_ON_SIGNAL" );
break;
case WORK_ANIMATE_CONSTANT:
setupStateAnimateConstant();
setInternalState( state , "WORK_ANIMATE_CONSTANT" );
break;
case WORK_ANIMATE_LIST_WAIT_ON_TIME:
setupStateAnimateListWaitOnTime();
setInternalState( state , "WORK_ANIMATE_LIST_WAIT_ON_TIME" );
break;
case WORK_ANIMATE_LIST_WAIT_ON_ANIM:
setupStateAnimateListWaitOnAnim();
setInternalState( state , "WORK_ANIMATE_LIST_WAIT_ON_ANIM" );
break;
case WORK_ANIMATE_LIST_WAIT_ON_SIGNAL:
setupStateAnimateListWaitOnSignal();
setInternalState( state , "WORK_ANIMATE_LIST_WAIT_ON_SIGNAL" );
break;
case WORK_SELECT_ANIM_MODE:
setInternalState( state, "WORK_SELECT_ANIM_MODE," );
break;
case WORK_SUCCESSFUL:
setInternalState( state , "WORK_SUCCESSFUL" );
break;
case WORK_FAILED:
setInternalState( state , "WORK_FAILED" );
break;
}
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::transitionToState( corridorCombatStates_t state )
{
switch ( state )
{
case CORRIDORCOMBAT_WRW_FINDNODE:
setupStateFindNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_FINDNODE" );
break;
case CORRIDORCOMBAT_WRW_MOVETONODE:
setupStateMoveToNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_MOVETONODE" );
break;
case CORRIDORCOMBAT_WRW_BACKPEDAL:
setupStateBackPedal();
setInternalState( state , "CORRIDORCOMBAT_WRW_BACKPEDAL" );
break;
case CORRIDORCOMBAT_WRW_FINDBETTERNODE:
setupStateFindBetterNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_FINDBETTERNODE" );
break;
case CORRIDORCOMBAT_WRW_MOVETOBETTERNODE:
setupStateMoveToBetterNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_MOVETOBETTERNODE" );
break;
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK:
setupStateChangePostureDuck();
setInternalState( state , "CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK" );
break;
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND:
setupStateChangePostureStand();
setInternalState( state , "CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND" );
break;
case CORRIDORCOMBAT_WRW_DUCKED:
setupStateDucked();
setInternalState( state , "CORRIDORCOMBAT_WRW_DUCKED" );
break;
case CORRIDORCOMBAT_WRW_DUCKED_FIRING:
setupStateFireDucked();
setInternalState( state , "CORRIDORCOMBAT_WRW_DUCKED_FIRING" );
break;
case CORRIDORCOMBAT_WRW_STAND:
setupStateStanding();
setInternalState( state , "CORRIDORCOMBAT_WRW_STAND" );
break;
case CORRIDORCOMBAT_WRW_STAND_FIRING:
setupStateFireStanding();
setInternalState( state , "CORRIDORCOMBAT_WRW_STAND_FIRING" );
break;
case CORRIDORCOMBAT_WRW_HOLD_POSITION:
setupStateHoldPosition();
setInternalState( state , "CORRIDORCOMBAT_WRW_HOLD_POSITION" );
break;
case CORRIDORCOMBAT_WRW_SUCCESS:
setInternalState( state , "CORRIDORCOMBAT_WRW_SUCCESS" );
break;
case CORRIDORCOMBAT_WRW_FAILED:
setInternalState( state , "CORRIDORCOMBAT_WRW_FAILED" );
break;
}
}
/*
* ======== RMP_create ========
*/
RMP_Handle RMP_create(RMP_Attrs *attrs)
{
RMP_Obj *handle = NULL;
Int shmId = -1;
unsigned int shmSize = 0;
Void * addr = NULL;
RMM_Attrs rmmAttrs;
static Int shmCount = 0;
/* Create a shared memory object RMP_Obj using the key and the lock
Size of this will depend numResources and RMM_Obj etc */
Assert_isTrue(shmCount < RMMP_MAXINSTANCES, (Assert_Id)NULL);
shmSize = sizeof(RMP_Obj) + sizeof(RMM_Obj) + sizeof(UInt32);
shmSize = ALIGN32(shmSize);
shmSize += (attrs->maxFreeListBlocks * sizeof(RMM_Header));
shmSize = ALIGN32(shmSize);
#ifdef xdc_target__os_Linux
addr = SHM_getObj((GateProcess_Handle_upCast)(attrs->gate), shmSize,
(key_t)attrs->key, (SHM_InitFxn)&setInternalState, &shmId);
#else
addr = (void *)malloc(shmSize);
if (NULL != addr) {
setInternalState(addr);
shmId = 0;
}
#endif
if (shmId != -1) {
handle = (RMP_Obj *)addr;
if (0 == handle->refCount) {
/* RMM_create has to happen */
rmmAttrs.segid = shmCount; /* Use shmCount as segId */
rmmAttrs.base = attrs->base;
rmmAttrs.length = attrs->length;
rmmAttrs.maxFreeListBlocks = attrs->maxFreeListBlocks;
/* My alloc fxn will use the sharedMem address to increment an
offset pointer */
rmmAttrs.allocFxn = shmAlloc;
rmmAttrs.freeFxn = shmFree;
/* Store the shmCount in the SHM_Obj part of the handle */
handle->shmCount = shmCount;
shmCount++;
}
/* Successful acquisition of shared Mem object, so store in array
for use by allocFxn */
shmAddrs[handle->shmCount] = (unsigned int)addr;
shmIndex[handle->shmCount] = sizeof(RMP_Obj); /* Change this to work for
the allocFxn */
if (handle->refCount == 0) {
/* Whatever the RMM_create returns, store that as an offset from
shmBase */
handle->rmmOffset = OFFSET(handle, RMM_create(&rmmAttrs));
}
handle->refCount++;
/* Store the sharedMemId in the RMP_Obj */
handle->sharedMemId = shmId;
}
return (handle);
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::transitionToState( generalCombatStates_t state )
{
switch ( state )
{
case GC_WRW_CHANGE_POSTURE_TO_ADVANCE:
setupStateChangePostureToAdvance();
setInternalState( state , "GC_WRW_CHANGE_POSTURE_TO_ADVANCE" );
break;
case GC_WRW_CHANGE_POSTURE_TO_RETREAT:
setupStateChangePostureToRetreat();
setInternalState( state , "GC_WRW_CHANGE_POSTURE_TO_RETREAT" );
break;
case GC_WRW_ADVANCE:
setupStateAdvance();
setInternalState( state , "GC_WRW_ADVANCE" );
break;
case GC_WRW_ADVANCE_FIRING:
setupStateAdvanceFiring();
setInternalState( state , "GC_WRW_ADVANCE_FIRING" );
break;
case GC_WRW_RETREAT:
setupStateRetreat();
setInternalState( state , "GC_WRW_RETREAT" );
break;
case GC_WRW_RETREAT_FIRING:
setupStateRetreatFiring();
setInternalState( state , "GC_WRW_RETREAT_FIRING" );
break;
case GC_WRW_STRAFE:
setupStateStrafe();
setInternalState( state , "GC_WRW_STRAFE" );
break;
case GC_WRW_CHANGE_POSTURE_DUCK:
setupStateChangePostureDuck();
setInternalState( state , "GC_WRW_CHANGE_POSTURE_DUCK" );
break;
case GC_WRW_DUCKED:
setupStateDucked();
setInternalState( state , "GC_WRW_DUCKED" );
break;
case GC_WRW_DUCKED_FIRING:
setupStateDuckedFiring();
setInternalState( state , "GC_WRW_DUCKED_FIRING" );
break;
case GC_WRW_CHANGE_POSTURE_STAND:
setupStateChangePostureStand();
setInternalState( state , "GC_WRW_CHANGE_POSTURE_STAND" );
break;
case GC_WRW_STAND:
setupStateStand();
setInternalState( state , "GC_WRW_STAND" );
break;
case GC_WRW_STAND_FIRING:
setupStateStandFiring();
setInternalState( state , "GC_WRW_STAND_FIRING" );
break;
case GC_WRW_FAILED:
setInternalState( state , "GC_WRW_FAILED" );
break;
}
}
/*
* ======== SMGRMP_create ========
*/
SMGRMP_Handle SMGRMP_create(SMGRMP_Attrs *attrs)
{
SMGRMP_Obj *handle;
Int shmId = -1;
unsigned int shmSize = 0;
Void * addr;
SMGR_Attrs smgrAttrs;
/* Create a shared memory object SMGRMP_Obj using the key and the lock
Size of this will depend numResources and SMGR_Obj etc */
GT_assert(CURTRACE, shmCount < SMGRMP_MAXINSTANCES);
shmSize = sizeof(SMGRMP_Obj) + sizeof(SMGR_Obj) + sizeof(UInt32);
shmSize = ALIGN32(shmSize);
shmSize += (sizeof(SMGR_Counter) * attrs->numResources);
shmSize = ALIGN32(shmSize);
#ifdef xdc_target__os_Linux
addr = SHM_getObj(attrs->lock, shmSize, (key_t)attrs->key,
(SHM_InitFxn)&setInternalState, &shmId);
#else
addr = (void *)malloc(shmSize);
setInternalState(addr);
shmId = 0;
#endif
if (shmId != -1) {
handle = (SMGRMP_Obj *)addr;
/* This will return a unique object for each key, and the same object
for different processes */
if (0 == handle->refCount) {
/* SMGR_create has to happen */
smgrAttrs.segid = shmCount; /* Use shmCount as segId */
smgrAttrs.numResources = attrs->numResources;
smgrAttrs.numScratchGroups = attrs->numScratchGroups;
smgrAttrs.allocFxn = shmAlloc;
smgrAttrs.freeFxn = shmFree;
/* Store the shmCount in the SHM_Obj part of the handle */
handle->shmCount = shmCount;
shmCount++;
shmTotal++;
}
/* Successful acquisition of shared Mem object, so store in array
for use by alloc/free functions */
shmAddrs[handle->shmCount] = (unsigned int)addr;
shmIndex[handle->shmCount] = sizeof(SMGRMP_Obj); /* Change this to
work for the alloFxn
*/
if (handle->refCount == 0) {
/* Whatever the SMGR_create returns, store that as an offset from
shmBase */
handle->smgrOffset = OFFSET(handle, SMGR_create(&smgrAttrs));
}
handle->refCount++;
/* Store the sharedMemId in the SMGRMP_Obj */
handle->sharedMemId = shmId;
return (handle);
}
else {
return (NULL);
}
}