static int system_timer (void *entry)
{
double timeout = 0;
int nominal_timeout;
struct system_timer *item = NULL;
item = (struct system_timer *)entry;
if (item->honors_cpu_saver && cpu_saver)
{
nominal_timeout = get_int_var(CPU_SAVER_EVERY_VAR);
timeout = nominal_timeout;
}
else
{
nominal_timeout = get_int_var(item->interval_variable);
timeout = time_to_next_interval(nominal_timeout);
}
#if 0
yell("Rescheduling system timer [%s] to go off in [%f] sec",
item->name, timeout);
#endif
add_timer(1, item->name, timeout, 1, system_timer, entry, NULL, -1);
item->callback();
item->last_event = now;
return 0;
}
/*
* This is a unified callback function that handles the processing for all
* of the system timers.
* It calculates how long until the callback should be called again:
* If CPU SAVER mode is on, then /set CPU_SAVE_EVERY seconds
* If it is off, then the next round /SET *_INTERVAL seconds
* where * is "CLOCK", "NOTIFY" or "MAIL".
* Then it calls the processing callback ("callback") to do the work.
*/
static int system_timer (void *entry)
{
double timeout = 0;
int nominal_timeout;
struct system_timer *item = NULL;
item = (struct system_timer *)entry;
if (item->honors_cpu_saver && cpu_saver)
{
nominal_timeout = get_int_var(CPU_SAVER_EVERY_VAR);
timeout = nominal_timeout;
}
else
{
nominal_timeout = get_int_var(*item->interval_variable);
timeout = time_to_next_interval(nominal_timeout);
}
add_timer(1, item->name, timeout, 1, system_timer, entry, NULL,
GENERAL_TIMER, -1, 0);
item->callback();
item->last_event = now;
return 0;
}
/*
* You call this to register a timer callback.
*
* The arguments:
* update: This should be 1 if we're updating the specified refnum
* refnum_want: The refnum requested.
* (1) User-supplied for /TIMER timers
* (2) the empty string for system timers ("dont care")
* interval: How long until the timer should fire;
* (1) for repeating timers (events != 1), the timer will
* fire with this interval.
* (2) for "snap" timers, the first fire will be the next
* time time() % interval == 0.
* events: The number of times this event should fire.
* (1) The value -1 means "repeat forever"
* (2) Timers automatically delete after they fire the
* requested number of times.
*
* Scenario 1: You want to run ircII commands (/TIMER timers)
* | callback: NULL
* | commands: some ircII commands to run when the timer goes off
* | subargs: what to use to expand $0's, etc in the 'what' variable.
*
* Scenario 2: You want to call an internal function (system timers)
* | callback: function to call when timer goes off
* | commands: argument to pass to "callback" function. Should be some
* | non-auto storage, perhaps a struct or a malloced char *
* | array. The caller is responsible for disposing of this
* | area when it is called, since the timer mechanism does not
* | know anything of the nature of the argument.
* | subargs: should be NULL, its ignored anyhow.
*
* domain: What the TIMER should bind to:
* (a) SERVER_TIMER - 'domref' refers to a server refnum.
* Each time this timer runs, set from_server to 'domref'
* and set the current window to whatever 'domref's
* current window is at that time.
* (b) WINDOW_TIME - 'domref' refers to a window refnum.
* Each time this timer runs, set current_window to
* 'domref' and set the current server to whatever
* 'domref's server is at that time.
* (c) GENERAL_TIMER - 'domref' is ignored.
* Do not save or restore from_server or current_window:
* run in whatever the context is when it goes off.
* domref: Either a server refnum, window refnum, or -1 (see 'domain')
* cancelable: A "Cancelable" timer will not fire if its context cannot be
* restored (ie, the server it is bound to is disconnected or
* deleted; or the window it is bound to is deleted). A normal
* (non-cancelable) timer will turn into a GENERAL_TIMER if its
* context cannot be restored.
* snap: A "snap" timer runs every time (time() % interval == 0).
* This is useful for things that (eg) run at the top of every
* minute (60), hour (3600), or day (86400)
*/
char *add_timer (int update, const char *refnum_want, double interval, long events, int (callback) (void *), void *commands, const char *subargs, TimerDomain domain, int domref, int cancelable, int snap)
{
Timer *ntimer, *otimer = NULL;
char * refnum_got = NULL;
Timeval right_now;
char * retval;
right_now = get_time(NULL);
/*
* We do this first, because if 'interval' is invalid, we don't
* want to do the expensive clone/create/delete operation.
* It is ineligant to check for this error here.
*/
if (update == 1 && interval == -1) /* Not changing the interval */
(void) 0; /* XXX sigh */
else if (interval < 0.01 && events == -1)
{
say("You can't infinitely repeat a timer that runs more "
"than 100 times a second.");
return NULL;
}
/*
* If we say we're updating; but the timer does not exist,
* then we're not updating. ;-)
*/
if (update)
{
if (!(otimer = get_timer(refnum_want)))
update = 0; /* Ok so we're not updating! */
}
/*
* Arrange for an appropriate Timer to be in 'ntimer'.
*/
if (update)
{
unlink_timer(otimer);
ntimer = clone_timer(otimer);
delete_timer(otimer);
}
else
{
if (create_timer_ref(refnum_want, &refnum_got) == -1)
{
say("TIMER: Refnum '%s' already exists", refnum_want);
return NULL;
}
ntimer = new_timer();
ntimer->ref = refnum_got;
}
/* Update the interval */
if (update == 1 && interval == -1)
(void) 0; /* XXX sigh - not updating interval */
else
{
ntimer->interval = double_to_timeval(interval);
if (snap)
{
double x = time_to_next_interval(interval);
ntimer->time = time_add(right_now, double_to_timeval(x));
}
else
ntimer->time = time_add(right_now, ntimer->interval);
}
/* Update the repeat events */
if (update == 1 && events == -2)
(void) 0; /* XXX sigh - not updating events */
else
ntimer->events = events;
/* Update the callback */
if (callback)
{
/* Delete the previous timer, if necessary */
if (ntimer->command)
new_free(&ntimer->command);
if (ntimer->subargs)
new_free(&ntimer->subargs);
ntimer->callback = callback;
/* Unfortunately, command is "sometimes const". */
ntimer->callback_data = commands;
ntimer->subargs = NULL;
}
else
{
ntimer->callback = NULL;
malloc_strcpy(&ntimer->command, (const char *)commands);
malloc_strcpy(&ntimer->subargs, subargs);
}
/* Update the domain refnum */
ntimer->domain = domain;
if (update == 1 && domref == -1)
(void) 0; /* XXX sigh - not updating domref */
else
ntimer->domref = domref;
/* Update the cancelable */
if (update == 1 && cancelable == -1)
(void) 0; /* XXX sigh - not updating cancelable */
else
ntimer->cancelable = cancelable;
/* Schedule up the new/updated timer! */
schedule_timer(ntimer);
retval = ntimer->ref;
return retval; /* Eliminates a specious warning from gcc */
}
