void ipcTriggerTimers (void)
{
unsigned long triggerTime, now;
TIMER_PTR timer;
now = x_ipc_timeInMsecs();
LOCK_M_MUTEX;
timer = (TIMER_PTR)x_ipc_listFirst(GET_M_GLOBAL(timerList));
while (timer) {
triggerTime = timer->triggerTime;
if (timer->status == Timer_Waiting && triggerTime <= now) {
timer->status = Timer_In_Use;
/* Update timer data *before* invoking handler,
just in case triggerTimers is called recursively */
if (timer->maxTrigger != TRIGGER_FOREVER) {
timer->maxTrigger--;
if (timer->maxTrigger == 0)
timer->status = Timer_Deleted;
}
timer->triggerTime = now + timer->period;
(timer->timerFn)(timer->clientData, now, triggerTime);
now = x_ipc_timeInMsecs();
/* setting status to Timer_Waiting here ensures that the
status is only reset after the timer has really finished,
and not inside a recursive call. */
if (timer->status != Timer_Deleted) {
timer->status = Timer_Done;
}
}
timer = (TIMER_PTR)x_ipc_listNext(GET_M_GLOBAL(timerList));
}
/* Clean up any timers that were deleted from within a handler */
timer = (TIMER_PTR)x_ipc_listFirst(GET_M_GLOBAL(timerList));
while (timer) {
if (timer->status == Timer_Deleted) {
ipcDeleteTimer(timer);
} else if (timer->status == Timer_Done) {
timer->status = Timer_Waiting;
}
timer = (TIMER_PTR)x_ipc_listNext(GET_M_GLOBAL(timerList));
}
UNLOCK_M_MUTEX;
}
static FORMAT_PTR Enum_Format(Format_Parse_Ptr parser, BOOLEAN *error)
{
TokenPtr Token;
FORMAT_PTR Form, subform;
LIST_PTR format_list;
int num_formats, i, maxVal;
num_formats = 0;
Token = NextToken(parser);
if (Token->Type == COLON_TOK) {
Token = NextToken(parser);
if (Token->Type != INT_TOK) {
*error = TRUE;
ParserError(Token, parser, "an integer");
return NULL;
} else {
maxVal = Token->value.num;
}
} else {
format_list = x_ipc_listCreate();
do {
if (num_formats > 0) Token = NextToken(parser);
if (Token->Type != STR_TOK) {
*error = TRUE;
ParserError(Token, parser, "a string");
return NULL;
} else {
Form = new_n_formatter(Token->value.str);
/* More efficient for Lisp if all enum format names are upper case */
LOCK_M_MUTEX;
if (IS_LISP_MODULE()) {
upcase(Form->formatter.name);
}
UNLOCK_M_MUTEX;
x_ipc_listInsertItem((char *)Form, format_list);
num_formats++;
}
Token = NextToken(parser);
} while (Token->Type == COMMA_TOK);
UngetToken(parser, Token);
maxVal = num_formats - 1;
}
Form = new_a_formatter(EnumFMT, num_formats+2);
Form->formatter.a[1].i = maxVal;
if (num_formats > 0) {
/* Index from high to low since "format_list"
has formatters in reverse order */
subform = (FORMAT_PTR)x_ipc_listFirst(format_list);
for(i=num_formats;i>0;i--) {
Form->formatter.a[i+1].f = subform;
subform = (FORMAT_PTR)x_ipc_listNext(format_list);
}
x_ipc_listFree(&format_list);
}
return Form;
}
static int32 processBroadcast(DISPATCH_PTR dispatch, DISPATCH_HND_PTR hnd)
{
if (hnd != (DISPATCH_HND_PTR)x_ipc_listFirst(dispatch->msg->hndList)) {
dispatch = dispatchCopy(dispatch);
}
dispatch->hnd = hnd;
dispatch->des = hnd->hndOrg;
dispatch->desId = hnd->hndOrg->writeSd;
processResourceAndDeliver(dispatch);
return TRUE;
}
unsigned long ipcNextTime (void)
{
unsigned long nextTime = WAITFOREVER;
TIMER_PTR timer;
LOCK_M_MUTEX;
timer = (TIMER_PTR)x_ipc_listFirst(GET_M_GLOBAL(timerList));
while (timer) {
if (timer->triggerTime < nextTime && timer->status == Timer_Waiting) {
nextTime = timer->triggerTime;
}
timer = (TIMER_PTR)x_ipc_listNext(GET_M_GLOBAL(timerList));
}
UNLOCK_M_MUTEX;
return nextTime;
}
static void ipcDisconnectHandler (MSG_INSTANCE ref, char **moduleNamePtr)
{
CONNECT_DATA_PTR disconnectData;
LIST_PTR list;
LOCK_CM_MUTEX;
list = GET_C_GLOBAL(disconnectNotifyList);
UNLOCK_CM_MUTEX;
for (disconnectData = (CONNECT_DATA_PTR)x_ipc_listFirst(list); disconnectData;
disconnectData = (CONNECT_DATA_PTR)x_ipc_listNext(list)) {
(disconnectData->handler)(*moduleNamePtr, disconnectData->clientData);
}
x_ipcFreeData(IPC_msgInstanceName(ref), moduleNamePtr); /* ??? */
}
static DISPATCH_HND_PTR chooseMsgHandler(MSG_PTR msg)
{
int32 size;
LIST_PTR hndList;
DISPATCH_HND_PTR hnd, nextHnd, retHnd;
hndList = msg->hndList;
size = x_ipc_listLength(hndList);
hnd = (DISPATCH_HND_PTR)x_ipc_listFirst(hndList);
if (!size) {
size = 1;
hnd = NEW(DISPATCH_HND_TYPE);
hnd->sd = 0;
hnd->localId =0;
hnd->msg = NULL;
hnd->hndProc = NULL;
hnd->hndOrg = GET_S_GLOBAL(x_ipcServerModGlobal);
hnd->hndData = NULL;
hnd->msgList = NULL;
hnd->resource = resourceCreate(0, 0, msg->msgData->name, 1);
hnd->resource->capacity = 0;
hnd->hndLanguage = C_LANGUAGE;
#ifdef NMP_IPC
hnd->clientData = NO_CLIENT_DATA;
#endif
x_ipc_listInsertItem((char *)hnd, msg->hndList);
}
if (size > 1) {
retHnd = hnd;
nextHnd = (DISPATCH_HND_PTR)x_ipc_listNext(hndList);
while (nextHnd && nextHnd->hndData &&
STREQ(hnd->hndData->hndName, nextHnd->hndData->hndName)) {
if (resourceAvailableRes(nextHnd->resource))
retHnd = nextHnd;
nextHnd = (DISPATCH_HND_PTR)x_ipc_listNext(hndList);
}
hnd = !nextHnd ? retHnd : NULL;
}
return hnd;
}
static FORMAT_PTR Struct_Format(Format_Parse_Ptr parser, BOOLEAN *error)
{
FORMAT_PTR Form, subform;
LIST_PTR format_list;
int num_formats, i;
format_list = x_ipc_listCreate();
num_formats = 0;
if (parser->TokenList->Type != RBRACE_TOK) {
while (1) {
x_ipc_listInsertItem((char *)Parse(parser, TRUE, error), format_list);
num_formats++;
if (parser->TokenList->Type == COMMA_TOK) {
(void)NextToken(parser);
} else if (parser->TokenList->Type == RBRACE_TOK) {
break;
} else {
*error = TRUE;
ParserError(NextToken(parser), parser, "','");
return NULL;
}
}
}
Form = new_a_formatter(StructFMT, num_formats+1);
/* Index from high to low since "format_list"
has formatters in reverse order */
subform = (FORMAT_PTR)x_ipc_listFirst(format_list);
for(i=num_formats;i>0;i--) {
Form->formatter.a[i].f = subform;
subform = (FORMAT_PTR)x_ipc_listNext(format_list);
}
x_ipc_listFree(&format_list);
return Form;
}
