call_out.c

/* (c) Copyright by Anders Chrigstroem 1993, All rights reserved */
/* Permission is granted to use this source code and any executables
 * created from this source code as part of the CD Gamedriver as long
 * as it is not used in any way whatsoever for monetary gain. */

#include <memory.h>
#include <signal.h>
#include <stdio.h>
#include <sys/time.h>
#include <math.h>

#include "config.h"
#include "lint.h"
#include "mstring.h"
#include "interpret.h"
#include "exec.h"
#include "object.h"
#include "mudstat.h"
#include "main.h"
#include "simulate.h"
#include "backend.h"
#include "call_out.h"

void init_call_out(void);
void call_out(struct timeval *);
static void run_call_out(struct object *ob);

#define SLOT(when) (((long long)((when) * TIME_RES)) & ((NUM_SLOTS) - 1))
#define FUNC_NAME(ob, cop)\
(ob->prog->inherit[cop->inherit].prog->functions[cop->fun].name)

struct call {
    struct call *next;
    struct closure *func;
    double reload;
    double when;
    long long id;
#ifdef THIS_PLAYER_IN_CALLOUT
    struct object *command_giver;
#endif
};

static struct object *call_outs[NUM_SLOTS];
static double last;

long long num_call;
long long call_out_size;
static long long call_id;

void
init_call_out()
{
    call_id = 1;
    last = 0;
#if TIME_RES * 4 >= NUM_SLOTS 
# error There must be more slots in the call_out table
#endif
}
static void
remove_ob(struct object *ob) {
    struct object **obp;

    if (ob->call_outs && !ob->callout_task)
    {
        int slot = SLOT(ob->call_outs->when);
        for (obp = &(call_outs[slot]); *obp && *obp != ob;
             obp = &(*obp)->next_call_out) ;
        if (!*obp)
            return; /* It's not on the list */
        *obp = ob->next_call_out;
        ob->next_call_out = 0;
    }
}
static void
add_ob(struct object *ob) {
    struct object **obp;

    if (ob->next_call_out)
        abort();
    if (ob->call_outs && !ob->callout_task)
    {
        int slot = SLOT(ob->call_outs->when);
        for (obp = &(call_outs[slot]); *obp &&
             (*obp)->call_outs->when < ob->call_outs->when;
             obp = &(*obp)->next_call_out) ;
        ob->next_call_out = *obp;
        *obp = ob;
    }
}    

void
call_out_swap_objects(struct object *ob1, struct object *ob2)
{
    struct call *co;
    struct task *task;
    short num_callouts;
    
    remove_ob(ob1);
    remove_ob(ob2);
    
    co = ob1->call_outs;
    task = ob1->callout_task;
    num_callouts = ob1->num_callouts;
    ob1->call_outs = ob2->call_outs;
    ob1->callout_task = ob2->callout_task;
    ob1->num_callouts = ob2->num_callouts;
    if (ob1->callout_task)
        ob1->callout_task->arg = ob1;

    ob2->call_outs = co;
    ob2->callout_task = task;
    ob2->num_callouts = num_callouts;
    if (ob2->callout_task)
        ob2->callout_task->arg = ob2;

    add_ob(ob1);
    add_ob(ob2);
}

static void
insert_call_out(struct object *ob, struct call *cop)
{
    struct call **copp;
     
    if (!ob->call_outs || cop->when < ob->call_outs->when) {
        remove_ob(ob);
        cop->next = ob->call_outs;
        ob->call_outs = cop;
        if (!ob->callout_task) {
            if (cop->when <= last)
                ob->callout_task = create_task((void (*)(void *))run_call_out, ob);
            else
                add_ob(ob);
        }
        return;
    }
    /* Insert the callout */
    for (copp = &ob->call_outs; *copp && cop->when >= (*copp)->when;
         copp = &(*copp)->next) ;
    cop->next = *copp;
    *copp = cop;

}

static void
free_call(struct call *cop)
{
    free_closure(cop->func);
#ifdef THIS_PLAYER_IN_CALLOUT
    if (cop->command_giver)
        free_object(cop->command_giver, "free_call");
#endif
    free((char *)cop);
    num_call--;
    call_out_size -= sizeof(struct call);
}

long long
new_call_out(struct closure *fun, double delay, double reload)
{
    struct call *cop;

    if (delay < 0)
        delay = 0;

    if (reload < 0)
        reload = -1;

    if (current_object->num_callouts >= MAX_CALL_OUT) {
        delete_all_calls(current_object);
        error("too many alarms in object\n");
    }

    cop = (struct call *)xalloc(sizeof(struct call));
    call_out_size += sizeof(struct call);

    cop->func = fun;
    INCREF(fun->ref);
    cop->reload = reload;
    cop->when = alarm_time + delay;
    
    cop->id = call_id++;
#ifdef THIS_PLAYER_IN_CALLOUT
    cop->command_giver = command_giver;
    if (command_giver)
        INCREF(command_giver->ref);
#endif
    current_object->num_callouts++;
    num_call++;
    insert_call_out(current_object, cop);
    return cop->id;
}

void
delete_call(struct object *ob, long long call_ident)
{
    struct call **copp, *cop;
    int remove_first = 0;

    if (ob->call_outs && ob->call_outs->id == call_ident) {
        remove_first = 1;
        remove_ob(ob);
    }
    for(copp = &ob->call_outs; *copp && (*copp)->id != call_ident;
        copp = &(*copp)->next) ;
    if (!*copp)
        return;
    
    cop = *copp;
    *copp = (*copp)->next;
    free_call(cop);
    ob->num_callouts--;
    if (remove_first) {
        add_ob(ob);
    }
}

void
delete_all_calls(struct object *ob)
{
    struct call *next, *cop;
    
    remove_ob(ob);
    remove_task(ob->callout_task);
    ob->callout_task = NULL;
    for(cop = ob->call_outs; cop; cop = next)
    {
        next = cop->next;
        free_call(cop);
    }
    ob->call_outs = 0;
    ob->num_callouts = 0;
    ob->next_call_out = 0;
}

/*
  0 : call id;
  1 : function;
  2 : time left;
  3 : reload time;
  4 : argument;
*/

struct vector *
get_call(struct object *ob, long long call_ident)
{
    struct vector *val;
    struct call *cop;
    
    for(cop = ob->call_outs; cop && cop->id != call_ident; cop = cop->next)
        ;
    if (!cop)
        return 0;
    
    val = allocate_array(5);
    
    val->item[0].type = T_NUMBER;
    val->item[0].u.number = cop->id;
    
    val->item[1].type = T_STRING;
    val->item[1].string_type = STRING_MSTRING;
    val->item[1].u.string = make_mstring(getclosurename(cop->func));
    
    val->item[2].type = T_FLOAT;
    val->item[2].u.real = cop->when - alarm_time;
    if (val->item[2].u.real < 0.0)
        val->item[2].u.real = 0.0;
    val->item[3].type = T_FLOAT;
    val->item[3].u.real = cop->reload;
    
    val->item[4].type = T_POINTER;
    val->item[4].u.vec = cop->func->funargs;
    INCREF(cop->func->funargs->ref);
    
    return val;
}
    
/*
  0 : call id;
  1 : function;
  2 : time left;
  3 : reload time;
  4 : argument;
*/
struct vector *
get_calls(struct object *ob)
{
    struct vector *ret;
    struct call *cop;
    int i;

    for(i = 0, cop = ob->call_outs; cop; i++, cop = cop->next)
        ;
    ret = allocate_array(i);
    
    for(i = 0, cop = ob->call_outs; cop; i++, cop = cop->next)
    {
        struct vector *val;
        
        val = allocate_array(5);

        val->item[0].type = T_NUMBER;
        val->item[0].u.number = cop->id;
        
        val->item[1].type = T_STRING;
        val->item[1].string_type = STRING_MSTRING;
        val->item[1].u.string = make_mstring(getclosurename(cop->func));
        
        val->item[2].type = T_FLOAT ;
        val->item[2].u.real = cop->when - alarm_time;
        if (val->item[2].u.real < 0.0)
            val->item[2].u.real = 0.0;
        
        val->item[3].type = T_FLOAT;
        val->item[3].u.real = cop->reload;
        
        val->item[4].type = T_POINTER;
        val->item[4].u.vec = cop->func->funargs;
        INCREF(cop->func->funargs->ref);
        
        ret->item[i].type = T_POINTER;
        ret->item[i].u.vec = val;
    }
    return ret;
}

long long current_call_out_id;
struct object *current_call_out_object;

int inhibitcallouts = 0;        /* Stop call-out processing. */

/*
 * last_alarm is at which slot we last executed an alarm
 */
static void
next_call_out(struct timeval *tvp)
{
    unsigned int end, slot;

    /*
     * We only want to scan 3 seconds into the future
     */
    end = SLOT(last + 3.0) + 1;
    if (end == NUM_SLOTS)
        end = 0;
    slot = SLOT(last);
    do {
        /*
         * We found an alarm...
         */
        if (call_outs[slot]) {
            /*
             * We found an alarm that was scheduled to run already
             */
            if (call_outs[slot]->call_outs->when < last) {
                tvp->tv_sec = 0;
                tvp->tv_usec = 0;
                return;
            }
            /*
             * We found an alarm that is scheduled to run within the next
             * 3 seconds
             */
            else if (call_outs[slot]->call_outs->when - last < 3.0) {
                double delay = call_outs[slot]->call_outs->when - last; 
                tvp->tv_sec = delay;
                tvp->tv_usec = (delay - tvp->tv_sec) * 1e6 + 0.5;
                return;
            }
        }
        slot = (slot + 1) & (NUM_SLOTS - 1);
    } while (slot != end);
    /* Failed to find a call_out. Do extensive search */
    tvp->tv_sec = 3; /* default to 3 seconds */
    tvp->tv_usec =0;
}

static void
run_call_out(struct object *ob)
{
    static struct call *cop, **copp;
    struct gdexception exception_frame;
    char caodesc[1024];
    struct closure *thefun;
    
    if (inhibitcallouts || !ob->call_outs ||
        ob->call_outs->when > alarm_time) {
        ob->callout_task = 0;
        add_ob(ob);
        return;
    }
    /* Get one callout */
    cop = ob->call_outs;
    ob->call_outs = cop->next;
    if (cop->reload >= 0) /* Reschedule the callout */
    {
        current_call_out_id = cop->id;
        if (cop->reload < 1e-12)
            cop->when = alarm_time;
        else
            cop->when = alarm_time - fmod(alarm_time - cop->when, cop->reload) +
                cop->reload;
        if (cop->when < alarm_time)
            cop->when = alarm_time;

        for (copp = &ob->call_outs;
             *copp && (*copp)->when < cop->when;
             copp = &(*copp)->next) ;
        cop->next = *copp;
        *copp = cop;
    }
    else
        current_call_out_id = 0;

    /* do the call */
#ifdef THIS_PLAYER_IN_CALLOUT
    if (cop->command_giver &&
        cop->command_giver->flags & O_DESTRUCTED)
    {
        free_object(cop->command_giver, "call_out");
        cop->command_giver = 0;
    }
            
            
    if (cop->command_giver &&
        cop->command_giver->flags & O_ENABLE_COMMANDS)
        command_giver = cop->command_giver;
    else if (ob->flags & O_ENABLE_COMMANDS)
        command_giver = ob;
    else
#endif
        command_giver = 0;
    if (s_flag)
        reset_mudstatus();
    eval_cost = 0;

    current_call_out_object = current_object = ob;
    INCREF(current_call_out_object->ref);
    current_interactive = 0;
    exception_frame.e_exception = exception;
    exception_frame.e_catch = 0;
    exception = &exception_frame;
            
    thefun = cop->func;
    INCREF(thefun->ref); /* keep a reference */
    if (cop->reload < 0) {
        free_call(cop);
        ob->num_callouts--;
    }
    if (thefun->funobj != ob)
        previous_ob = ob;
            
    if (setjmp(exception_frame.e_context)) {
        exception = exception_frame.e_exception;
        clear_state();
        debug_message("Error in call out.\n");
        if (current_call_out_id)
        {
            /*access_program(ob->prog->inherit[inh].prog);*/
            debug_message("Call out %s turned off in %s.\n", getclosurename(thefun),
                          current_call_out_object->name);
            delete_call(current_call_out_object, current_call_out_id);
        }
    }
    else
    {
        update_alarm_av();
        (void)call_var(0, thefun);
        exception = exception_frame.e_exception;
        pop_stack();
                
        if (s_flag)
        {
            strcpy(caodesc, "CAO:");
            strncat(caodesc, show_closure(thefun),
                    sizeof(caodesc) - 5);
            print_mudstatus(caodesc, eval_cost, 
                            get_millitime(), get_processtime());
        }
    }
    free_closure(thefun); /* and kill the extra reference */
    free_object(current_call_out_object, "call_out");
    previous_ob = 0;
    /* Reschedule the object */
    if (ob->call_outs && (ob->call_outs->when <= alarm_time ||
                          ob->call_outs->when <= last)) {
        reschedule_task(ob->callout_task);
        return;
    }
    ob->callout_task = 0;
    add_ob(ob);
}

void
call_out(struct timeval *tvp)
{
    struct object *ob;
    double last_end;
    int end = 0;
    
    if (inhibitcallouts) {
        if (tvp) {
            tvp->tv_sec = 3;
            tvp->tv_usec = 0;
        }
        return;
    }

    while (!end)
    {
        int slot, slot_end;
        
        if (last > alarm_time)
            break;
        last_end = last + 2.0;
        if (last_end > alarm_time) {
            last_end = alarm_time; /* last lap */
            end = 1;
        }
        slot = SLOT(last);
        slot_end = (SLOT(last_end) + 1) & (NUM_SLOTS - 1);
        for (; slot != slot_end; slot = ((slot + 1) & (NUM_SLOTS - 1)))
            while(call_outs[slot] &&
                  call_outs[slot]->call_outs->when <= last_end)
            {
                /* Extract the object and the callout */
                ob = call_outs[slot];
                call_outs[slot] = ob->next_call_out;
                ob->next_call_out = 0;
                ob->callout_task = create_task((void (*)(void *))run_call_out, ob);
            }
        last = last_end;
    }
    if (tvp)
       next_call_out(tvp);
}

int
dump_callouts(FILE *f)
{
    int count;
    struct object *ob;
    struct call *c;
#ifdef THIS_PLAYER_IN_CALLOUT
    char *giver;
#else
#define giver "(void)"
#endif
    
    count = 0;
    ob = obj_list;
    do {
        for (c = ob->call_outs; c; c = c->next)
        {
#ifdef THIS_PLAYER_IN_CALLOUT
            if (!c->command_giver ||
                c->command_giver->flags & O_DESTRUCTED)
            {
                giver = "(void)";
            } else {
                giver = c->command_giver->name;
            }
#endif
            fprintf(f,
                    "%s %s %9.6f %9.6f %s\n",
                    ob->name,
                    show_closure(c->func),
                    c->when - alarm_time,
                    c->reload,
                    giver);
            
            count++;
        }
    } while ((ob = ob->next_all) != obj_list);
    
    return count;
}

#ifdef DEBUG
void
count_ref_from_call_outs()
{
    struct object *ob;
    struct call *cop;
    
#ifdef THIS_PLAYER_IN_CALLOUT
    ob = obj_list;
    do {
        for(cop = ob->call_outs; cop; cop = cop->next)
        {
            if (cop->command_giver)
                cop->command_giver->extra_ref++;
        }
    } while ((ob = ob->next_all) != obj_list);
    
#endif
}
#endif