src/cque.c

Go to the documentation of this file.

/*
 * cque.c -- commands and functions for manipulating the command queue 
 */

#include "copyright.h"
#include "config.h"

#include <signal.h>

#include "mudconf.h"
#include "config.h"
#include "db.h"
#include "htab.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "attrs.h"
#include "flags.h"
#include "powers.h"
#include "command.h"
#include "alloc.h"
#include "functions.h"
#include "cque.h"
#include "mmdb.h"

extern int a_Queue(dbref, int);
extern void s_Queue(dbref, int);
extern int QueueMax(dbref);

static rbtree obq = NULL;

static int objqe_compare(dbref left, dbref right, void *arg)
{
        return (right - left);
}

int cque_init()
{
        obq = rb_init((void *) objqe_compare, NULL);
        return 1;
};

static OBJQE *cque_find(dbref player)
{
        OBJQE *tmp = NULL;

        if(obq == NULL) {
                cque_init();
        }

        tmp = rb_find(obq, (void *) player);

        if(!tmp && Good_obj(player)) {
                tmp = malloc(sizeof(OBJQE));
                tmp->obj = player;
                tmp->cque = NULL;
                tmp->ctail = NULL;
                tmp->next = NULL;
                tmp->queued = 0;
                tmp->wait_que = NULL;
                tmp->pending_que = NULL;
                rb_insert(obq, (void *) player, tmp);
        }

        return tmp;
}

static BQUE *cque_peek(dbref player)
{
        OBJQE *tmp;
        tmp = cque_find(player);
        return tmp->cque;
}

static BQUE *cque_deque(dbref player)
{
        OBJQE *tmp;
        BQUE *cmd;

        tmp = cque_find(player);
        if(!tmp)
                return NULL;

        dassert(tmp);

        if(!tmp->cque)
                return NULL;

        cmd = tmp->cque;
        if(!cmd->next) {
                tmp->cque = tmp->ctail = NULL;
        } else {
                tmp->cque = cmd->next;
        }
        return cmd;
}

static void cque_enqueue(dbref player, BQUE * cmd)
{
    BQUE *point, *trail;
        OBJQE *current, *blocker;
        struct timeval tv;
    OBJQE *tmp;

    cmd->next = NULL;
    
    tv.tv_sec = cmd->waittime - mudstate.now;
    tv.tv_usec = 0;

    if(cmd->sem == NOTHING) {
        /*
         * No semaphore, put on wait queue if wait value specified.
         * Otherwise put on the normal queue. 
         */

        if(cmd->waittime <= mudstate.now) {
            cmd->waittime = 0;
            tmp = cque_find(player);

            dassert(tmp);

            if(!tmp->ctail) {
                tmp->cque = tmp->ctail = cmd;
                cmd->next = NULL;
            } else {
                tmp->ctail->next = cmd;
                tmp->ctail = cmd;
                tmp->ctail->next = NULL;
            }

            if(!tmp->queued) {
                if(!mudstate.qhead) {
                    mudstate.qhead = mudstate.qtail = tmp;
                    tmp->next = NULL;
                } else {
                    mudstate.qtail->next = tmp;
                    mudstate.qtail = tmp;
                    mudstate.qtail->next = NULL;
                }
                tmp->queued = 1;
            }
        } else {
            evtimer_add(&cmd->ev, &tv);
            for(point = mudstate.qwait, trail = NULL;
                    point && point->waittime <= cmd->waittime;
                    point = point->next) {
                trail = point;
            }
            cmd->next = point;
            if(trail != NULL)
                trail->next = cmd;
            else
                mudstate.qwait = cmd;
        }
    } else {
        cmd->next = NULL;
        if(mudstate.qsemlast != NULL)
            mudstate.qsemlast->next = cmd;
        else
            mudstate.qsemfirst = cmd;
        mudstate.qsemlast = cmd;
    }
}

static void wakeup_wait_que(int fd, short event, void *arg)
{
        BQUE *pending = (BQUE *) arg;
        BQUE *point, trail;

        if(mudstate.qwait == pending) {
                mudstate.qwait = pending->next;
        } else {
                for(point = mudstate.qwait; point; point = point->next) {
                        if(point->next == pending) {
                                point->next = point->next->next;
                                break;
                        }
                }
        }
    
    pending->waittime = 0;
        cque_enqueue(pending->player, pending);
}

static int dump_bqe(struct mmdb_t *mmdb, BQUE *bqe) {
    if(bqe == NULL) {
        mmdb_write_uint32(mmdb, 0);
        return 1;
    }
    mmdb_write_uint32(mmdb, 1);
    mmdb_write_uint32(mmdb, bqe->player);
    mmdb_write_uint32(mmdb, bqe->cause);
    mmdb_write_uint32(mmdb, bqe->sem);
    mmdb_write_uint32(mmdb, bqe->waittime-mudstate.now);
    mmdb_write_uint32(mmdb, bqe->attr);
    mmdb_write_string(mmdb, bqe->text);
    mmdb_write_string(mmdb, bqe->comm);
    mmdb_write_uint32(mmdb, NUM_ENV_VARS);
    for(int i = 0; i < NUM_ENV_VARS; i++) {
        mmdb_write_string(mmdb, bqe->env[i]);
    }
    mmdb_write_uint32(mmdb, NUM_ENV_VARS);
    for(int i = 0; i < NUM_ENV_VARS; i++) {
        mmdb_write_string(mmdb, bqe->scr[i]);
    }
    mmdb_write_uint32(mmdb, bqe->nargs);
    dump_bqe(mmdb, bqe->next);
    return 1;
}

static int dump_objqe(void *key, void *data, int depth, void *arg) {
    struct mmdb_t *mmdb = (struct mmdb_t *)arg;
    OBJQE *coq = (OBJQE *)data;
    mmdb_write_uint32(mmdb, coq->obj);
    dump_bqe(mmdb, coq->cque);
    return 1;
}
    

void cque_dump_restart(struct mmdb_t *mmdb) {
    if(obq == NULL) {
        cque_init();
    }
    mmdb_write_uint32(mmdb, rb_size(obq));
    if(rb_size(obq) > 0) {
        rb_walk(obq, WALK_INORDER, dump_objqe, mmdb);
    }
    dump_bqe(mmdb, mudstate.qwait);
    dump_bqe(mmdb, mudstate.qsemfirst);
}

static void load_bqe(struct mmdb_t *mmdb) {
    int exists, count;
    struct timeval tv;
    BQUE *tmp;
    exists = mmdb_read_uint32(mmdb);
    if(!exists)
        return;
    tmp = malloc(sizeof(BQUE));
    memset(tmp, 0, sizeof(BQUE));
    
    evtimer_set(&tmp->ev, wakeup_wait_que, tmp);

    tmp->player = mmdb_read_uint32(mmdb);
    tmp->cause = mmdb_read_uint32(mmdb);
    tmp->sem = mmdb_read_uint32(mmdb);
    tmp->waittime = mudstate.now + mmdb_read_uint32(mmdb);
    tmp->attr = mmdb_read_uint32(mmdb);
    tmp->text = mmdb_read_string(mmdb);
    tmp->comm = mmdb_read_string(mmdb);
    count = mmdb_read_uint32(mmdb);
    if(count != NUM_ENV_VARS)
        printk("brain damage, count(%d) != NUM_ENV_VARS(%d)", count, NUM_ENV_VARS);
    for(int i = 0; i < count; i++) {
        if(i < NUM_ENV_VARS)
            tmp->env[i] = mmdb_read_string(mmdb);
        else 
            free(mmdb_read_string(mmdb));
    }
    count = mmdb_read_uint32(mmdb);
    if(count != NUM_ENV_VARS)
        printk("brain damage, count(%d) != NUM_ENV_VARS(%d)", count, NUM_ENV_VARS);
    for(int i = 0; i < count; i++) {
        if(i < NUM_ENV_VARS)
            tmp->scr[i] = mmdb_read_string(mmdb);
        else 
            free(mmdb_read_string(mmdb));
    }
    tmp->nargs = mmdb_read_uint32(mmdb);
    cque_enqueue(tmp->player, tmp);
    load_bqe(mmdb);
}

static void load_objqe(struct mmdb_t *mmdb) {
    int object;
    OBJQE *coq;
    object = mmdb_read_uint32(mmdb);
    coq = cque_find(object);
    load_bqe(mmdb);
}
    
    
void cque_load_restart(struct mmdb_t *mmdb) {
    int count;
    count = mmdb_read_uint32(mmdb);
    for(int i = 0; i < count; i++) {
        load_objqe(mmdb);
    }
    load_bqe(mmdb); // wait q
    load_bqe(mmdb); // sem q
}

#if 0
void cque_dump_restart(FILE *f) {
    OBJQE *coq;
    BQUE *bqe;
    if(!mudstate.qhead) {
        fprintf(f, "%d\n", 0);
        return;
    }
    for(coq = mudstate.qhead; coq != NULL; coq = coq->next) {
        fprintf("%d\n", coq->obj);
        for(bqe = coq->cque; bqe != NULL; bqe = bqe->next) {
            fprintf(f, "1\n");
            fprintf(f, "%d\n%d\n%d\n", bqe->player, bqe->cause, bqe->sem);
            fprintf(f, "%d\n%d\n", bqe->waittime - mudstate.now, bqe->attr);
            fprintf(f, "");
        }
    }
#endif
    
/*
 * ---------------------------------------------------------------------------
 * * add_to: Adjust an object's queue or semaphore count.
 */

static int add_to(dbref player, int am, int attrnum)
{
        int num, aflags;
        dbref aowner;
        char buff[20];
        char *atr_gotten;

        num = atoi(atr_gotten = atr_get(player, attrnum, &aowner, &aflags));
        free_lbuf(atr_gotten);
        num += am;
        if(num)
                sprintf(buff, "%d", num);
        else
                *buff = '\0';
        atr_add_raw(player, attrnum, buff);
        return (num);
}

/*
 * ---------------------------------------------------------------------------
 * * que_want: Do we want this queue entry?
 */

static int que_want(BQUE * entry, dbref ptarg, dbref otarg)
{
        if((ptarg != NOTHING) && (ptarg != Owner(entry->player)))
                return 0;
        if((otarg != NOTHING) && (otarg != entry->player))
                return 0;
        return 1;
}

/*
 * ---------------------------------------------------------------------------
 * * halt_que: Remove all queued commands from a certain player
 */

int halt_que(dbref player, dbref object)
{
        BQUE *trail, *point, *next;
        OBJQE *pque;

        int numhalted;

        numhalted = 0;

        /* Player's que */
        // XXX: nuke queu

        pque = cque_find(player);
        if(pque && pque->cque) {
                while ((point = cque_deque(player)) != NULL) {
                        free(point->text);
                        point->text = NULL;
                        free_qentry(point);
                        point = NULL;
                        numhalted++;
                }
        }
        pque = cque_find(object);
        if(pque && pque->cque) {
                while ((point = cque_deque(object)) != NULL) {
                        free(point->text);
                        point->text = NULL;
                        free_qentry(point);
                        point = NULL;
                        numhalted++;
                }
        }

        /*
         * Wait queue 
         */

        for(point = mudstate.qwait, trail = NULL; point; point = next)
                if(que_want(point, player, object)) {
                        numhalted++;
                        if(trail)
                                trail->next = next = point->next;
                        else
                                mudstate.qwait = next = point->next;
                        if(evtimer_pending(&point->ev, NULL))
                                evtimer_del(&point->ev);
                        free(point->text);
                        free_qentry(point);
                } else
                        next = (trail = point)->next;

        /*
         * Semaphore queue 
         */

        for(point = mudstate.qsemfirst, trail = NULL; point; point = next)
                if(que_want(point, player, object)) {
                        numhalted++;
                        if(trail)
                                trail->next = next = point->next;
                        else
                                mudstate.qsemfirst = next = point->next;
                        if(point == mudstate.qsemlast)
                                mudstate.qsemlast = trail;
                        add_to(point->sem, -1, point->attr);
                        free(point->text);
                        free_qentry(point);
                } else
                        next = (trail = point)->next;

        if(player == NOTHING)
                player = Owner(object);
        giveto(player, (mudconf.waitcost * numhalted));
        if(object == NOTHING)
                s_Queue(player, 0);
        else
                a_Queue(player, -numhalted);
        return numhalted;
}

/*
 * ---------------------------------------------------------------------------
 * * do_halt: Command interface to halt_que.
 */

void do_halt(dbref player, dbref cause, int key, char *target)
{
        dbref player_targ, obj_targ;
        int numhalted;

        if((key & HALT_ALL) && !(Can_Halt(player))) {
                notify(player, "Permission denied.");
                return;
        }
        /*
         * Figure out what to halt 
         */

        if(!target || !*target) {
                obj_targ = NOTHING;
                if(key & HALT_ALL) {
                        player_targ = NOTHING;
                } else {
                        player_targ = Owner(player);
                        if(Typeof(player) != TYPE_PLAYER)
                                obj_targ = player;
                }
        } else {
                if(Can_Halt(player))
                        obj_targ = match_thing(player, target);
                else
                        obj_targ = match_controlled(player, target);

                if(obj_targ == NOTHING)
                        return;
                if(key & HALT_ALL) {
                        notify(player, "Can't specify a target and /all");
                        return;
                }
                if(Typeof(obj_targ) == TYPE_PLAYER) {
                        player_targ = obj_targ;
                        obj_targ = NOTHING;
                } else {
                        player_targ = NOTHING;
                }
        }

        numhalted = halt_que(player_targ, obj_targ);
        if(Quiet(player))
                return;
        if(numhalted == 1)
                notify(Owner(player), "1 queue entries removed.");
        else
                notify_printf(Owner(player), "%d queue entries removed.", numhalted);
}

/*
 * ---------------------------------------------------------------------------
 * * nfy_que: Notify commands from the queue and perform or discard them.
 */

int nfy_que(dbref sem, int attr, int key, int count)
{
        BQUE *point, *trail, *next;
        int num, aflags;
        dbref aowner;
        char *str;

        if(attr) {
                str = atr_get(sem, attr, &aowner, &aflags);
                num = atoi(str);
                free_lbuf(str);
        } else {
                num = 1;
        }

        if(num > 0) {
                num = 0;
                for(point = mudstate.qsemfirst, trail = NULL; point; point = next) {
                        if((point->sem == sem) && ((point->attr == attr) || !attr)) {
                                num++;
                                if(trail)
                                        trail->next = next = point->next;
                                else
                                        mudstate.qsemfirst = next = point->next;
                                if(point == mudstate.qsemlast)
                                        mudstate.qsemlast = trail;

                                /*
                                 * Either run or discard the command 
                                 */

                                if(key != NFY_DRAIN) {
                    point->sem = NOTHING;
                    point->waittime = 0;
                                        cque_enqueue(point->player, point);
                                } else {
                                        giveto(point->player, mudconf.waitcost);
                                        a_Queue(Owner(point->player), -1);
                                        free(point->text);
                                        free_qentry(point);
                                }
                        } else {
                                next = (trail = point)->next;
                        }

                        /*
                         * If we've notified enough, exit 
                         */

                        if((key == NFY_NFY) && (num >= count))
                                next = NULL;
                }
        } else {
                num = 0;
        }

        /*
         * Update the sem waiters count 
         */

        if(key == NFY_NFY)
                add_to(sem, -count, attr);
        else
                atr_clr(sem, attr);

        return num;
}

/*
 * ---------------------------------------------------------------------------
 * * do_notify: Command interface to nfy_que
 */

void do_notify(dbref player, dbref cause, int key, char *what, char *count)
{
        dbref thing, aowner;
        int loccount, attr = -1, aflags;
        ATTR *ap;
        char *obj;

        obj = parse_to(&what, '/', 0);
        init_match(player, obj, NOTYPE);
        match_everything(0);

        if((thing = noisy_match_result()) < 0) {
                notify(player, "No match.");
        } else if(!controls(player, thing) && !Link_ok(thing)) {
                notify(player, "Permission denied.");
        } else {
                if(!what || !*what) {
                        ap = NULL;
                } else {
                        ap = atr_str(what);
                }

                if(!ap) {
                        attr = A_SEMAPHORE;
                } else {
                        /* Do they have permission to set this attribute? */
                        atr_pget_info(thing, ap->number, &aowner, &aflags);
                        if(Set_attr(player, thing, ap, aflags)) {
                                attr = ap->number;
                        } else {
                                notify_quiet(player, "Permission denied.");
                                return;
                        }
                }

                if(count && *count)
                        loccount = atoi(count);
                else
                        loccount = 1;
                if(loccount > 0) {
                        nfy_que(thing, attr, key, loccount);
                        if(!(Quiet(player) || Quiet(thing))) {
                                if(key == NFY_DRAIN)
                                        notify_quiet(player, "Drained.");
                                else
                                        notify_quiet(player, "Notified.");
                        }
                }
        }
}

/*
 * ---------------------------------------------------------------------------
 * * setup_que: Set up a queue entry.
 */

static BQUE *setup_que(dbref player, dbref cause, char *command, char *args[],
                                           int nargs, char *sargs[])
{
        int a, tlen;
        BQUE *tmp;
        char *tptr;

        /*
         * Can we run commands at all? 
         */

        if(Halted(player))
                return NULL;

        /*
         * make sure player can afford to do it 
         */

        a = mudconf.waitcost;
        if(mudconf.machinecost && ((random() % mudconf.machinecost) == 0))
                a++;
        if(!payfor(player, a)) {
                notify(Owner(player), "Not enough money to queue command.");
                return NULL;
        }
        /*
         * Wizards and their objs may queue up to db_top+1 cmds. Players are
         * * * * * * * limited to QUEUE_QUOTA. -mnp 
         */

        a = QueueMax(Owner(player));
        if(a_Queue(Owner(player), 1) > a) {
                notify(Owner(player),
                           "Run away objects: too many commands queued.  Halted.");
                halt_que(Owner(player), NOTHING);

                /*
                 * halt also means no command execution allowed 
                 */
                s_Halted(player);
                return NULL;
        }
        /*
         * We passed all the tests 
         */

        /*
         * Calculate the length of the save string 
         */

        tlen = 0;
        if(command)
                tlen = strlen(command) + 1;
        if(nargs > NUM_ENV_VARS)
                nargs = NUM_ENV_VARS;
        for(a = 0; a < nargs; a++) {
                if(args[a])
                        tlen += (strlen(args[a]) + 1);
        }
        if(sargs) {
                for(a = 0; a < NUM_ENV_VARS; a++) {
                        if(sargs[a])
                                tlen += (strlen(sargs[a]) + 1);
                }
        }
        /*
         * Create the qeue entry and load the save string 
         */

        tmp = malloc(sizeof(BQUE));
    memset(tmp, 0, sizeof(BQUE));
    tmp->comm = NULL;
        for(a = 0; a < NUM_ENV_VARS; a++) {
                tmp->env[a] = NULL;
        }
        for(a = 0; a < MAX_GLOBAL_REGS; a++) {
                tmp->scr[a] = NULL;
        }

        tptr = tmp->text = (char *) malloc(tlen);
        if(command) {
                StringCopy(tptr, command);
                tmp->comm = tptr;
                tptr += (strlen(command) + 1);
        }
        for(a = 0; a < nargs; a++) {
                if(args[a]) {
                        StringCopy(tptr, args[a]);
                        tmp->env[a] = tptr;
                        tptr += (strlen(args[a]) + 1);
                }
        }
        if(sargs) {
                for(a = 0; a < MAX_GLOBAL_REGS; a++) {
                        if(sargs[a]) {
                                StringCopy(tptr, sargs[a]);
                                tmp->scr[a] = tptr;
                                tptr += (strlen(sargs[a]) + 1);
                        }
                }
        }
        /*
         * Load the rest of the queue block 
         */

        evtimer_set(&tmp->ev, wakeup_wait_que, tmp);

        tmp->player = player;
        tmp->waittime = 0;
        tmp->next = NULL;
        tmp->sem = NOTHING;
        tmp->attr = 0;
        tmp->cause = cause;
        tmp->nargs = nargs;
        return tmp;
}

/*
 * ---------------------------------------------------------------------------
 * * wait_que: Add commands to the wait or semaphore queues.
 */

void wait_que(dbref player, dbref cause, int wait, dbref sem, int attr,
                          char *command, char *args[], int nargs, char *sargs[])
{
        BQUE *cmd;
        if(mudconf.control_flags & CF_INTERP)
                cmd = setup_que(player, cause, command, args, nargs, sargs);
        else
                cmd = NULL;

        if(cmd == NULL) {
                return;
        }

    if(wait > 0) {
        cmd->waittime = mudstate.now + wait;
    } else {
        cmd->waittime = 0;
    }

    cmd->sem = sem;
    cmd->attr = attr;

    cque_enqueue(player, cmd);
}


/*
 * ---------------------------------------------------------------------------
 * * do_wait: Command interface to wait_que
 */

void do_wait(dbref player, dbref cause, int key, char *event, char *cmd,
                         char *cargs[], int ncargs)
{
        dbref thing, aowner;
        int howlong, num, attr, aflags;
        char *what;
        ATTR *ap;

        /*
         * If arg1 is all numeric, do simple (non-sem) timed wait. 
         */

        if(is_number(event)) {
                howlong = atoi(event);
                wait_que(player, cause, howlong, NOTHING, 0, cmd, cargs, ncargs,
                                 mudstate.global_regs);
                return;
        }
        /*
         * Semaphore wait with optional timeout 
         */

        what = parse_to(&event, '/', 0);
        init_match(player, what, NOTYPE);
        match_everything(0);

        thing = noisy_match_result();
        if(!Good_obj(thing)) {
                notify(player, "No match.");
        } else if(!controls(player, thing) && !Link_ok(thing)) {
                notify(player, "Permission denied.");
        } else {

                /*
                 * Get timeout, default 0 
                 */

                if(event && *event && is_number(event)) {
                        attr = A_SEMAPHORE;
                        howlong = atoi(event);
                } else {
                        attr = A_SEMAPHORE;
                        howlong = 0;
                }

                if(event && *event && !is_number(event)) {
                        ap = atr_str(event);
                        if(!ap) {
                                attr = mkattr(event);
                                if(attr <= 0) {
                                        notify_quiet(player, "Invalid attribute.");
                                        return;
                                }
                                ap = atr_num(attr);
                        }
                        atr_pget_info(thing, ap->number, &aowner, &aflags);
                        if(attr && Set_attr(player, thing, ap, aflags)) {
                                attr = ap->number;
                                howlong = 0;
                        } else {
                                notify_quiet(player, "Permission denied.");
                                return;
                        }
                }

                num = add_to(thing, 1, attr);
                if(num <= 0) {

                        /*
                         * thing over-notified, run the command immediately 
                         */

                        thing = NOTHING;
                        howlong = 0;
                }
                wait_que(player, cause, howlong, thing, attr, cmd, cargs, ncargs,
                                 mudstate.global_regs);
        }
}

/*
 * ---------------------------------------------------------------------------
 * * do_second: Check the wait and semaphore queues for commands to remove.
 */

void do_second(void)
{
        BQUE *trail, *point, *next;
        char *cmdsave;

        /*
         * move contents of low priority queue onto end of normal one this
         * helps to keep objects from getting out of control since
         * its affects on other objects happen only after one
         * second  this should allow @halt to be type before
         * getting blown away  by scrolling text 
         */

        if((mudconf.control_flags & CF_DEQUEUE) == 0)
                return;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_second >";

        /*
         * Note: the point->waittime test would be 0 except the command is
         * being put in the low priority queue to be done in one
         * second anyways 
         */

        /*
         * Check the semaphore queue for expired timed-waits 
         */

        for(point = mudstate.qsemfirst, trail = NULL; point; point = next) {
                if(point->waittime == 0) {
                        next = (trail = point)->next;
                        continue;                       /*
                                                                 * Skip if not timed-wait 
                                                                 */
                }
                if(point->waittime <= mudstate.now) {
                        if(trail != NULL)
                                trail->next = next = point->next;
                        else
                                mudstate.qsemfirst = next = point->next;
                        if(point == mudstate.qsemlast)
                                mudstate.qsemlast = trail;
                        add_to(point->sem, -1, point->attr);
                        point->sem = NOTHING;
            point->waittime = 0;
                        printk("promoting, %d/%s", point->player, point->comm);
                        cque_enqueue(point->player, point);
                } else
                        next = (trail = point)->next;
        }
        mudstate.debug_cmd = cmdsave;
        return;
}

/*
 * ---------------------------------------------------------------------------
 * * do_top: Execute the command at the top of the queue
 */

int do_top(int ncmds)
{
        BQUE *tmp, *walk;
        OBJQE *current_object;
        dbref object, player, last_player;
        int count, i;
        char *command, *cp, *cmdsave;

        if((mudconf.control_flags & CF_DEQUEUE) == 0)
                return 0;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_top >";

        if(!mudstate.qhead)
                return 0;

        current_object = mudstate.qhead;
        count = 0;

        while (count < ncmds && mudstate.qhead) {
                if(!mudstate.qhead)
                        break;

                object = mudstate.qhead->obj;
                tmp = cque_deque(object);

                if(!mudstate.qhead->cque) {
                        mudstate.qhead->queued = 0;
                        mudstate.qhead = mudstate.qhead->next;
                        if(mudstate.qhead == NULL)
                                mudstate.qtail = NULL;
                } else {
                        mudstate.qtail->next = mudstate.qhead;
                        mudstate.qtail = mudstate.qtail->next;
                        mudstate.qhead = mudstate.qhead->next;
                        mudstate.qtail->next = NULL;
                }
                if(!tmp)
                        continue;

                dassert(tmp);
                count++;
                if((object >= 0) && !Going(object)) {
                        giveto(object, mudconf.waitcost);
                        mudstate.curr_enactor = tmp->cause;
                        mudstate.curr_player = object;
                        a_Queue(Owner(object), -1);
                        if(!Halted(object)) {
                                for(i = 0; i < MAX_GLOBAL_REGS; i++) {
                                        if(tmp->scr[i]) {
                                                StringCopy(mudstate.global_regs[i], tmp->scr[i]);
                                        } else {
                                                *mudstate.global_regs[i] = '\0';
                                        }
                                }

                                command = tmp->comm;

                                if(command) {
                                        if(isPlayer(object) && Connected(object))
                                                choke_player(object);
                                        while (command) {
                                                cp = parse_to(&command, ';', 0);
                                                if(cp && *cp) {
                                                        while (command && (*command == '|')) {
                                                                command++;
                                                                mudstate.inpipe = 1;
                                                                mudstate.poutnew =
                                                                        alloc_lbuf("process_command.pipe");
                                                                mudstate.poutbufc = mudstate.poutnew;
                                                                mudstate.poutobj = object;
                                                                process_command(object, tmp->cause, 0, cp,
                                                                                                tmp->env, tmp->nargs);
                                                                if(mudstate.pout) {
                                                                        free_lbuf(mudstate.pout);
                                                                        mudstate.pout = NULL;
                                                                }

                                                                *mudstate.poutbufc = '\0';
                                                                mudstate.pout = mudstate.poutnew;
                                                                cp = parse_to(&command, ';', 0);
                                                        }
                                                        mudstate.inpipe = 0;
                                                        process_command(object, tmp->cause, 0,
                                                                                        cp, tmp->env, tmp->nargs);
                                                        if(mudstate.pout) {
                                                                free_lbuf(mudstate.pout);
                                                                mudstate.pout = NULL;
                                                        }
                                                }
                                        }
                                        if(isPlayer(object) && Connected(object))
                                                release_player(object);
                                }
                        }
                }
                free(tmp->text);
                free_qentry(tmp);
        }

        for(i = 0; i < MAX_GLOBAL_REGS; i++)
                *mudstate.global_regs[i] = '\0';
        mudstate.debug_cmd = cmdsave;
        return count;
}

/*
 * ---------------------------------------------------------------------------
 * * do_ps: tell player what commands they have pending in the queue
 */

static void show_que(dbref player, int key, BQUE * queue, int *qent,
                                         const char *header)
{
        BQUE *tmp;
        char *bp, *bufp;
        int i;

        for(tmp = queue; tmp; tmp = tmp->next) {
                (*qent)++;
                if(key == PS_SUMM)
                        continue;
                if(*qent == 1)
                        notify_printf(player, "----- %s Queue -----", header);

                bufp = unparse_object(player, tmp->player, 0);
                if ( !(key & PS_ALL) )
                        if((player != Owner(tmp->player))) 
                                continue;
                if((tmp->waittime > 0) && (Good_obj(tmp->sem)))
                        notify_printf(player, "[#%d/%d]%s:%s", tmp->sem,
                                                  tmp->waittime-mudstate.now, bufp, tmp->comm);
                else if(tmp->waittime > 0)
                        notify_printf(player, "[%d]%s:%s", tmp->waittime-mudstate.now,
                                                  bufp, tmp->comm);
                else if(Good_obj(tmp->sem))
                        notify_printf(player, "[#%d]%s:%s", tmp->sem, bufp, tmp->comm);
                else
                        notify_printf(player, "%s:%s", bufp, tmp->comm);

                bp = bufp;
                if(key == PS_LONG) {
                        for(i = 0; i < (tmp->nargs); i++) {
                                if(tmp->env[i] != NULL) {
                                        safe_str((char *) "; Arg", bufp, &bp);
                                        safe_chr(i + '0', bufp, &bp);
                                        safe_str((char *) "='", bufp, &bp);
                                        safe_str(tmp->env[i], bufp, &bp);
                                        safe_chr('\'', bufp, &bp);
                                }
                        }
                        *bp = '\0';
                        bp = unparse_object(player, tmp->cause, 0);
                        notify_printf(player, "   Enactor: %s%s", bp, bufp);
                        free_lbuf(bp);
                }
                free_lbuf(bufp);
        }
        return;
}

void do_ps(dbref player, dbref cause, int key, char *target)
{
        char *bufp;
        dbref player_targ, obj_targ;
        int pqent, pqtot, pqdel, oqent, oqtot, oqdel, wqent, wqtot, sqent,
                sqtot, i;
        OBJQE *objq;
        int tempkey;

        /*
         * Figure out what to list the queue for 
         */

        if((key & PS_ALL) && !(See_Queue(player))) {
                notify(player, "Permission denied.");
                return;
        }
        if(!target || !*target) {
                obj_targ = NOTHING;
                if(key & PS_ALL) {
                        player_targ = NOTHING;
                } else {
                        player_targ = Owner(player);
                        if(Typeof(player) != TYPE_PLAYER)
                                obj_targ = player;
                }
        } else {
                player_targ = Owner(player);
                obj_targ = match_controlled(player, target);
                if(obj_targ == NOTHING)
                        return;
                if(key & PS_ALL) {
                        notify(player, "Can't specify a target and /all");
                        return;
                }
                if(Typeof(obj_targ) == TYPE_PLAYER) {
                        player_targ = obj_targ;
                        obj_targ = NOTHING;
                }
        }
        tempkey = key;
        key = key & ~PS_ALL;
        switch (key) {
        case PS_BRIEF:
        case PS_SUMM:
        case PS_LONG:
                break;
        default:
                notify(player, "Illegal combination of switches.");
                return;
        }

        /*
         * Go do it 
         */
        pqtot = 0;
        if(player_targ == NOTHING) {
                objq = mudstate.qhead;
                while (objq && (objq = objq->next) != NULL) {
                        pqent = 0;
                        show_que(player, tempkey, objq->cque, &pqent, "PLAYAH");
                        pqtot += pqent;
                }
        } else {
                pqent = 0;
                objq = cque_find(player_targ);
                if(objq) {
                        show_que(player, tempkey, objq->cque, &pqent, "PLAYAH");
                }
        }

        wqent = 0;
        sqent = 0;
        wqtot = 0;
        sqtot = 0;
        show_que(player, tempkey, mudstate.qwait, &wqent, "Wait");
        show_que(player, tempkey, mudstate.qsemfirst, &sqent, "Semaphore");

        /*
         * Display stats 
         */

        if(See_Queue(player))
                notify_printf(player,
                                          "Totals: Player...%d/%d  Wait...%d/%d  Semaphore...%d/%d",
                                          pqent, pqtot, wqent, wqtot, sqent, sqtot);
        else
                notify_printf(player,
                                          "Totals: Player...%d/%d  Wait...%d/%d  Semaphore...%d/%d",
                                          pqent, pqtot, wqent, wqtot, sqent, sqtot);
}

/*
 * ---------------------------------------------------------------------------
 * * do_queue: Queue management
 */

void do_queue(dbref player, dbref cause, int key, char *arg)
{
        BQUE *point;
        int i, ncmds, was_disabled;

        dprintk("WTF?");
        was_disabled = 0;
        if(key == QUEUE_KICK) {
                i = atoi(arg);
                if((mudconf.control_flags & CF_DEQUEUE) == 0) {
                        was_disabled = 1;
                        mudconf.control_flags |= CF_DEQUEUE;
                        notify(player, "Warning: automatic dequeueing is disabled.");
                }
                ncmds = do_top(i);
                if(was_disabled)
                        mudconf.control_flags &= ~CF_DEQUEUE;
                if(!Quiet(player))
                        notify_printf(player, "%d commands processed.", ncmds);
        } else if(key == QUEUE_WARP) {
                i = atoi(arg);
                if((mudconf.control_flags & CF_DEQUEUE) == 0) {
                        was_disabled = 1;
                        mudconf.control_flags |= CF_DEQUEUE;
                        notify(player, "Warning: automatic dequeueing is disabled.");
                }

                /*
                 * Handle the semaphore queue 
                 */

                for(point = mudstate.qsemfirst; point; point = point->next) {
                        if(point->waittime > 0) {
                                point->waittime -= i;
                                if(point->waittime <= 0)
                                        point->waittime = -1;
                        }
                }

                do_second();
                if(was_disabled)
                        mudconf.control_flags &= ~CF_DEQUEUE;
                if(Quiet(player))
                        return;
                if(i > 0)
                        notify_printf(player, "WaitQ timer advanced %d seconds.", i);
                else if(i < 0)
                        notify_printf(player, "WaitQ timer set back %d seconds.", i);
                else
                        notify(player, "Object queue appended to player queue.");

        }
}

---