// Run a trigger
static BOOL eventFireTrigger(ACTIVE_TRIGGER *psTrigger)
{
BOOL fired;
INTERP_VAL sResult;
fired = false;
psFiringTrigger = psTrigger;
// If this is a code trigger see if it fires
if (psTrigger->type == TR_CODE)
{
// Run the trigger
if (!interpRunScript(psTrigger->psContext,
IRT_TRIGGER, psTrigger->trigger, 0))
{
ASSERT( false, "eventFireTrigger: trigger %s: code failed",
eventGetTriggerID(psTrigger->psContext->psCode, psTrigger->trigger) );
return false;
}
// Get the result
sResult.type = VAL_BOOL;
if (!stackPopType(&sResult))
{
return false;
}
fired = sResult.v.bval;
}
else
{
fired = true;
}
// If it fired run the event
if (fired)
{
DB_TRIGINF(psTrigger,1);
DB_TRACE(" fired", 1);
if (!interpRunScript(psTrigger->psContext, IRT_EVENT, psTrigger->event, psTrigger->offset))
{
DB_TRACE(("******** script failed *********"), 0);
DB_TRIGINF(psTrigger,0);
ASSERT(false, "eventFireTrigger: event %s: code failed",
eventGetEventID(psTrigger->psContext->psCode, psTrigger->event));
return false;
}
}
#ifdef DEBUG
else
{
DB_TRIGINF(psTrigger,3);
}
#endif
return true;
}
/* Secure memory de-allocation */
void efree(void *s)
{
if (s != 0)
{
DB_TRACE(10, pt_format, counter++, "efree", (uintptr_t)s);
free(s);
}
}
/* Secure allocation of zeroed memory */
void *ecalloc(size_t n, size_t s)
{
void *cp;
if ((cp = calloc(n, s)) == 0)
err_reporter(n * s);
DB_TRACE(10, sz_format, counter++, "ecalloc", (uintptr_t)cp, n * s);
return(cp);
}
/* Secure memory allocation */
void *emalloc(size_t u)
{
void *cp;
if ((cp = malloc(u)) == 0)
err_reporter(u);
DB_TRACE(10, sz_format, counter++, "emalloc", (uintptr_t)cp, u);
return(cp);
}
/* Secure memory re-allocation */
void *erealloc(void *s, size_t n)
{
void *cp;
if (s == 0)
{
cp = malloc(n);
DB_TRACE(10, sz_format, counter++, "erealloc-malloc", (uintptr_t)cp, n);
}
else
{
DB_TRACE(10, pt_format, counter++, "erealloc-realloc1", (uintptr_t)s);
cp = realloc(s, n);
DB_TRACE(10, sz_format, counter++, "erealloc-realloc2", (uintptr_t)cp, n);
}
if (cp == 0)
err_reporter(n);
return(cp);
}
static void partition3(size_t n, Colour *arr)
{
if (n <= 1)
return;
size_t w = 0;
size_t r = n;
DB_TRACE(1, "\nw0 = %zu; r0 = %zu: ", w, r);
while (w < r && arr[w] == WHITE)
w++;
while (r > w && arr[r-1] == RED)
r--;
DB_TRACE(1, "w1 = %zu; r1 = %zu\n", w, r);
for (size_t i = w; i < r; i++)
{
DB_TRACE(1, "i = %2zu [1] w = %2zu, r = %2zu, c = %c", i, w, r, colour_code(arr[i]));
DB_CALL(1, trace_colours(stderr, "", arr, n, w, r, i));
if (arr[i] == RED)
{
swap(&arr[i], &arr[--r]);
DB_TRACE(1, "i = %2zu [2] w = %2zu, r = %2zu, c = %c", i, w, r, colour_code(arr[i]));
DB_CALL(1, trace_colours(stderr, "", arr, n, w, r, i));
}
if (arr[i] == WHITE)
{
swap(&arr[i], &arr[w++]);
DB_TRACE(1, "i = %2zu [3] w = %2zu, r = %2zu, c = %c", i, w, r, colour_code(arr[i]));
DB_CALL(1, trace_colours(stderr, "", arr, n, w, r, i));
}
while (r > w && arr[r-1] == RED)
r--;
while (w < r && arr[w] == WHITE)
w++;
if (i < w && w > 0)
i = w - 1;
}
}
// Change the trigger assigned to an event - to be called from script functions
BOOL eventSetTrigger(void)
{
ACTIVE_TRIGGER *psTrigger;
UDWORD event;
SDWORD trigger;
SCRIPT_CONTEXT *psContext;
if (!stackPopParams(2, VAL_EVENT, &event, VAL_TRIGGER, &trigger))
{
return false;
}
#ifdef REALLY_DEBUG_THIS
DB_TRACE(("eventSetTrigger %s %s\n",
eventGetEventID(psFiringTrigger->psContext->psCode, event),
eventGetTriggerID(psFiringTrigger->psContext->psCode, trigger)),2);
#endif
// See if this is the event that is running
psContext = psFiringTrigger->psContext;
if (psFiringTrigger->event == event)
{
psFiringTrigger->deactivated = true;
}
else
{
// Mark the old trigger in the lists
eventMarkTriggerInList(&psTrigList, psContext, event, &trigger);
eventMarkTriggerInList(&psCallbackList, psContext, event, &trigger);
eventMarkTriggerInList(&psAddedTriggers, psContext, event, &trigger);
}
// Create a new trigger if necessary
if (trigger >= 0)
{
if (!eventInitTrigger(&psTrigger, psFiringTrigger->psContext,
event, trigger, updateTime))
{
return false;
}
psTrigger->psNext = psAddedTriggers;
psAddedTriggers = psTrigger;
}
return true;
}
// Add a new object to the trigger system
// Time is the application time at which all the triggers are to be started
BOOL eventRunContext(SCRIPT_CONTEXT *psContext, UDWORD time)
{
SDWORD event;
ACTIVE_TRIGGER *psTrigger;
TRIGGER_DATA *psData;
SCRIPT_CODE *psCode;
ASSERT( psContext != NULL,
"eventNewObject: Invalid context pointer" );
// Now setup all the triggers
psContext->triggerCount = 0;
psCode = psContext->psCode;
for(event = 0; event < psCode->numEvents; event++)
{
if (psCode->pEventLinks[event] >= 0)
{
// See if this is an init event
psData = psCode->psTriggerData + psCode->pEventLinks[event];
if (psData->type == TR_INIT)
{
if (!interpRunScript(psContext, IRT_EVENT, event, 0))
{
return false;
}
}
else
{
if (!eventInitTrigger(&psTrigger, psContext, event,
psCode->pEventLinks[event], time))
{
return false;
}
eventAddTrigger(psTrigger);
DB_TRACE(("added "),2);
DB_TRIGINF(psTrigger, 2);
}
}
}
return true;
}
// Activate a callback trigger
void eventFireCallbackTrigger(TRIGGER_TYPE callback)
{
ACTIVE_TRIGGER *psPrev = NULL, *psCurr, *psNext;
TRIGGER_DATA *psTrigDat;
BOOL fired;
if (interpProcessorActive())
{
ASSERT(false, "eventFireCallbackTrigger: script interpreter is already running");
return;
}
//this can be called from eventProcessTriggers and so will wipe out all the current added ones
//psAddedTriggers = NULL;
for (psCurr = psCallbackList; psCurr && psCurr->type <= (int)callback; psCurr = psNext)
{
psNext = psCurr->psNext;
if (psCurr->type == (int)callback)
{
// see if the callback should be fired
fired = false;
if (psCurr->type != TR_PAUSE)
{
ASSERT(psCurr->trigger >= 0 && psCurr->trigger < psCurr->psContext->psCode->numTriggers,
"eventFireCallbackTrigger: invalid trigger number");
psTrigDat = psCurr->psContext->psCode->psTriggerData + psCurr->trigger;
}
else
{
psTrigDat = NULL;
}
if (psTrigDat && psTrigDat->code)
{
if (!interpRunScript(psCurr->psContext, IRT_TRIGGER, psCurr->trigger, 0))
{
ASSERT(false, "eventFireCallbackTrigger: trigger %s: code failed",
eventGetTriggerID(psCurr->psContext->psCode, psCurr->trigger));
psPrev = psCurr;
continue;
}
if (!stackPopParams(1, VAL_BOOL, &fired))
{
ASSERT(false, "eventFireCallbackTrigger: trigger %s: code failed",
eventGetTriggerID(psCurr->psContext->psCode, psCurr->trigger));
psPrev = psCurr;
continue;
}
}
else
{
fired = true;
}
// run the event
if (fired)
{
DB_TRIGINF(psCurr,1);
DB_TRACE(" fired",1);
// remove the trigger from the list
if (psPrev == NULL)
{
psCallbackList = psCallbackList->psNext;
}
else
{
psPrev->psNext = psNext;
}
psFiringTrigger = psCurr;
if (!interpRunScript(psCurr->psContext, IRT_EVENT, psCurr->event, psCurr->offset)) // this could set psCurr->deactivated
{
ASSERT(false, "eventFireCallbackTrigger: event %s: code failed",
eventGetEventID(psCurr->psContext->psCode, psCurr->event));
}
if (psCurr->deactivated)
{
// don't need to add the trigger again - just free it
eventFreeTrigger(psCurr);
}
else
{
// make sure the trigger goes back into the system
psCurr->psNext = psAddedTriggers;
psAddedTriggers = psCurr;
}
}
else
{
psPrev = psCurr;
}
}
else
{
psPrev = psCurr;
}
}
// Delete marked triggers now
eventPruneLists();
// Now add all the new triggers
for(psCurr = psAddedTriggers; psCurr; psCurr=psNext)
{
psNext = psCurr->psNext;
eventAddTrigger(psCurr);
}
//clear out after added them all
psAddedTriggers = NULL;
}
