/* Add a keyword to the list of possible values of a keyword parameter for the current element */ void addkeyword(M_NOPAR) { int length ; PARAMETER *par ; PTYPE *kw ; /* Check if duplicate keyword for this parameter */ for (kw = newpar->ptypep ; kw ; kw = kw->nextptr) if (w_strcmp(kw->keyword, name) == 0) { warning3("Warning: Repeated keyword %s in parameter %s of %s", name, newpar->paramname, thisrule) ; return ; } /* Check if duplicate keyword within parameters of this element */ for (par = plist ; par != newpar ; par = par->next) for (kw = par->ptypep ; kw ; kw = kw->nextptr) { if (w_strcmp(kw->keyword, name) == 0) warning4("Keyword %s used in parameters %s and %s of %s", name, par->paramname, newpar->paramname, thisrule) ; if (! kw->next) break ; } *nextptype = (PTYPE *) m_malloc(sizeof(PTYPE), "ptype") ; if (newpar->kwlist) thisptype->next = ptypelen + 1 ; else { newpar->kwlist = ptypelen + 1 ; newpar->ptypep = *nextptype ; } thisptype = *nextptype ; thisptype->next = M_NULLVAL ; thisptype->nextptr = NULL ; nextptype = &(thisptype->nextptr) ; length = w_strlen(name) + 1 ; thisptype->keyword = (M_WCHAR *) m_malloc(length, "keyword") ; w_strcpy(thisptype->keyword, name) ; kwlen += length ; ptypelen++ ; }
void IntervalTimerTick(int sig, self_code_info_t *info, self_sig_context_t *scp) { // A Mac OS X application, ApplicationEnhancer, causes the VM to receive nested // SIGALRM/SIGVTALRM signals. // We don't know why this is happening, since our call to sigaction (where // the SIGALRM/SIGVTALRM handlers are installed) specified that we don't want // recursive timer signals. // As a workaround to this funny behaviour induced by ApplicationEnhancer, we // check if we're in a recursive SIGALRM/SIGVTALRM handler. If we receive a // recursive SIGALRM/SIGVTALRM signal, then we immediately return from the // signal handler. This is OK since it's not a catastrophe if we ignore a // timer signal. -mabdelmalek 10/02 // Now we are getting SIGIO's while in the SIGVTALRM handler, maybe // caused by ApplicationEnhancer--argh! -- dmu 6/03 if (InterruptedContext::the_interrupted_context->forwarded_to_self_thread(sig)) return; if (SignalInterface::currentNonTimerSignal || SignalInterface::currentTimerSignal) { static bool haveWarned = false; if (!haveWarned) { # if TARGET_OS_VERSION == LINUX_VERSION warning3("IntervalTimerTick: signal_handler cannot nest (only one interrupted context).\n" "Received timer sig %d while in sig %d or timer sig %d.\n" "MacOSX ApplicationEnhancer causes apps to get signals that should be blocked.", sig, SignalInterface::currentNonTimerSignal, SignalInterface::currentTimerSignal); # else warning6("IntervalTimerTick: signal_handler cannot nest (only one interrupted context).\n" "Received timer sig %d (sig%s) while in sig %d (sig%s) or timer sig %d (sig%s).\n" "MacOSX ApplicationEnhancer causes apps to get signals that should be blocked.", sig, sys_signame[sig], SignalInterface::currentNonTimerSignal, sys_signame[SignalInterface::currentNonTimerSignal], SignalInterface::currentTimerSignal, sys_signame[SignalInterface::currentTimerSignal]); # endif haveWarned = true; } return; } SignalInterface::currentTimerSignal = sig; // this is called at every tick of our timer if (processSemaphore || IntervalTimer::dont_use_any_timer) { // We're in a critical region, so return from the timer interrupt // without overwriting InterruptedContext::the_interrupted_context. // The check for dont_use_any_timer is for better debugging with gdb. SignalInterface::currentTimerSignal = 0; return; } # if TARGET_OS_VERSION != MACOSX_VERSION // The following assertion fails on Mac OS X when ApplicationEnhancer is running. // Since it's not critical that we execute on a signal stack, we can skip // the assertion. -mabdelmalek 10/02 assert(SignalInterface::is_on_signal_stack(), "should be on interrupt stack"); # endif assert(!IntervalTimer::dont_use_any_timer, "should not have timer interrupts"); InterruptedContext::the_interrupted_context->set(scp); IntervalTimer* t = sig == SIGALRM ? IntervalTimer::Real_timer() : IntervalTimer:: CPU_timer(); t->do_async_tasks(); if ( PendingSelfSignals::keyboard_signals() != 0 ) preemptor(); InterruptedContext::the_interrupted_context->invalidate(); SignalInterface::currentTimerSignal = 0; if (IntervalTimer::dont_use_any_timer && sig == SIGVTALRM) IntervalTimerTick(SIGALRM, info, scp); // simulate real timer }