mux/src/cque.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <signal.h>
#include "attrs.h"
#include "command.h"
#include "interface.h"
#include "powers.h"

Include dependency graph for cque.cpp:

Go to the source code of this file.

Functions
static CLinearTimeDelta	GetProcessorUsage (void)
static int	add_to (dbref executor, int am, int attrnum)
static void	Task_RunQueueEntry (void *pEntry, int iUnused)
static bool	que_want (BQUE *entry, dbref ptarg, dbref otarg)
static void	Task_SemaphoreTimeout (void *pExpired, int iUnused)
static int	CallBack_HaltQueue (PTASK_RECORD p)
int	halt_que (dbref executor, dbref object)
void	do_halt (dbref executor, dbref caller, dbref enactor, int key, char *target)
static int	CallBack_NotifySemaphoreDrainOrAll (PTASK_RECORD p)
static int	CallBack_NotifySemaphoreFirstOrQuiet (PTASK_RECORD p)
int	nfy_que (dbref sem, int attr, int key, int count)
void	do_notify (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *what, char *count)
static BQUE *	setup_que (dbref executor, dbref caller, dbref enactor, char *command, char *args[], int nargs, char *sargs[])
void	wait_que (dbref executor, dbref caller, dbref enactor, bool bTimed, CLinearTimeAbsolute &ltaWhen, dbref sem, int attr, char *command, char *args[], int nargs, char *sargs[])
void	do_wait (dbref executor, dbref caller, dbref enactor, int key, char *event, char *cmd, char *cargs[], int ncargs)
static int	CallBack_ShowDispatches (PTASK_RECORD p)
static void	ShowPsLine (BQUE *tmp)
static int	CallBack_ShowWait (PTASK_RECORD p)
static int	CallBack_ShowSemaphore (PTASK_RECORD p)
void	do_ps (dbref executor, dbref caller, dbref enactor, int key, char *target)
static int	CallBack_Warp (PTASK_RECORD p)
void	do_queue (dbref executor, dbref caller, dbref enactor, int key, char *arg)
Variables
bool	break_called = false
static dbref	Halt_Player_Target
static dbref	Halt_Object_Target
static int	Halt_Entries
static dbref	Halt_Player_Run
static dbref	Halt_Entries_Run
static int	Notify_Key
static int	Notify_Num_Done
static int	Notify_Num_Max
static int	Notify_Sem
static int	Notify_Attr
static CLinearTimeAbsolute	Show_lsaNow
static int	Total_SystemTasks
static int	Total_RunQueueEntry
static int	Shown_RunQueueEntry
static int	Total_SemaphoreTimeout
static int	Shown_SemaphoreTimeout
static dbref	Show_Player_Target
static dbref	Show_Object_Target
static int	Show_Key
static dbref	Show_Player
static int	Show_bFirstLine
static CLinearTimeDelta	ltdWarp

---

Function Documentation

static int add_to	(	dbref	executor,
		int	am,
		int	attrnum
	)			[static]

Definition at line 62 of file cque.cpp.

References atr_add_raw_LEN(), atr_get, free_lbuf, mux_atol(), and mux_ltoa().

Referenced by CallBack_HaltQueue(), do_wait(), nfy_que(), and Task_SemaphoreTimeout().

{
    int aflags;
    dbref aowner;

    char *atr_gotten = atr_get(executor, attrnum, &aowner, &aflags);
    int num = mux_atol(atr_gotten);
    free_lbuf(atr_gotten);
    num += am;

    char buff[20];
    int nlen = 0;
    *buff = '\0';
    if (num)
    {
        nlen = mux_ltoa(num, buff);
    }
    atr_add_raw_LEN(executor, attrnum, buff, nlen);
    return num;
}

static int CallBack_HaltQueue

(

PTASK_RECORD

p

)

[static]

Definition at line 279 of file cque.cpp.

References a_Queue(), add_to(), TASK_RECORD::arg_voidptr, bque::attr, bque::executor, TASK_RECORD::fpTask, free_qentry, giveto(), Halt_Entries, Halt_Entries_Run, Halt_Object_Target, Halt_Player_Run, Halt_Player_Target, isPlayer, IU_NEXT_TASK, IU_REMOVE_TASK, MEMFREE, mudconf, NOTHING, Owner, que_want(), bque::sem, Task_RunQueueEntry(), Task_SemaphoreTimeout(), bque::text, and confdata::waitcost.

Referenced by halt_que().

{
    if (  p->fpTask == Task_RunQueueEntry
#ifdef QUERY_SLAVE
       || p->fpTask == Task_SQLTimeout
#endif // QUERY_SLAVE
       || p->fpTask == Task_SemaphoreTimeout)
    {
        // This is a @wait, timed Semaphore Task, or timed SQL Query.
        //
        BQUE *point = (BQUE *)(p->arg_voidptr);
        if (que_want(point, Halt_Player_Target, Halt_Object_Target))
        {
            // Accounting for pennies and queue quota.
            //
            dbref dbOwner = point->executor;
            if (!isPlayer(dbOwner))
            {
                dbOwner = Owner(dbOwner);
            }
            if (dbOwner != Halt_Player_Run)
            {
                if (Halt_Player_Run != NOTHING)
                {
                    giveto(Halt_Player_Run, mudconf.waitcost * Halt_Entries_Run);
                    a_Queue(Halt_Player_Run, -Halt_Entries_Run);
                }
                Halt_Player_Run = dbOwner;
                Halt_Entries_Run = 0;
            }
            Halt_Entries++;
            Halt_Entries_Run++;
            if (p->fpTask == Task_SemaphoreTimeout)
            {
                add_to(point->sem, -1, point->attr);
            }
            MEMFREE(point->text);
            point->text = NULL;
            free_qentry(point);
            return IU_REMOVE_TASK;
        }
    }
    return IU_NEXT_TASK;
}

static int CallBack_NotifySemaphoreDrainOrAll

(

PTASK_RECORD

p

)

[static]

Definition at line 435 of file cque.cpp.

References a_Queue(), TASK_RECORD::arg_voidptr, bque::attr, bque::enactor, bque::executor, TASK_RECORD::fpTask, free_qentry, CLinearTimeAbsolute::GetUTC(), giveto(), TASK_RECORD::iPriority, isPlayer, IU_NEXT_TASK, IU_REMOVE_TASK, IU_UPDATE_TASK, TASK_RECORD::ltaWhen, MEMFREE, mudconf, NFY_DRAIN, Notify_Attr, Notify_Key, Notify_Num_Done, Notify_Sem, Owner, PRIORITY_OBJECT, PRIORITY_PLAYER, bque::sem, Task_RunQueueEntry(), Task_SemaphoreTimeout(), bque::text, and confdata::waitcost.

Referenced by nfy_que().

{
    if (p->fpTask == Task_SemaphoreTimeout)
    {
        // This represents a semaphore.
        //
        BQUE *point = (BQUE *)(p->arg_voidptr);
        if (  point->sem == Notify_Sem
           && (  point->attr == Notify_Attr
              || !Notify_Attr))
        {
            Notify_Num_Done++;
            if (Notify_Key == NFY_DRAIN)
            {
                // Discard the command
                //
                giveto(point->executor, mudconf.waitcost);
                a_Queue(Owner(point->executor), -1);
                MEMFREE(point->text);
                point->text = NULL;
                free_qentry(point);
                return IU_REMOVE_TASK;
            }
            else
            {
                // Allow the command to run. The priority may have been
                // PRIORITY_SUSPEND, so we need to change it.
                //
                if (isPlayer(point->enactor))
                {
                    p->iPriority = PRIORITY_PLAYER;
                }
                else
                {
                    p->iPriority = PRIORITY_OBJECT;
                }
                p->ltaWhen.GetUTC();
                p->fpTask = Task_RunQueueEntry;
                return IU_UPDATE_TASK;
            }
        }
    }
    return IU_NEXT_TASK;
}

static int CallBack_NotifySemaphoreFirstOrQuiet

(

PTASK_RECORD

p

)

[static]

Definition at line 482 of file cque.cpp.

References TASK_RECORD::arg_voidptr, bque::attr, bque::enactor, TASK_RECORD::fpTask, CLinearTimeAbsolute::GetUTC(), TASK_RECORD::iPriority, isPlayer, IU_DONE, IU_NEXT_TASK, IU_UPDATE_TASK, TASK_RECORD::ltaWhen, NFY_NFY, Notify_Attr, Notify_Key, Notify_Num_Done, Notify_Num_Max, Notify_Sem, PRIORITY_OBJECT, PRIORITY_PLAYER, bque::sem, Task_RunQueueEntry(), and Task_SemaphoreTimeout().

Referenced by nfy_que().

{
    // If we've notified enough, exit.
    //
    if (  Notify_Key == NFY_NFY
       && Notify_Num_Done >= Notify_Num_Max)
    {
        return IU_DONE;
    }

    if (p->fpTask == Task_SemaphoreTimeout)
    {
        // This represents a semaphore.
        //
        BQUE *point = (BQUE *)(p->arg_voidptr);
        if (  point->sem == Notify_Sem
           && (  point->attr == Notify_Attr
              || !Notify_Attr))
        {
            Notify_Num_Done++;

            // Allow the command to run. The priority may have been
            // PRIORITY_SUSPEND, so we need to change it.
            //
            if (isPlayer(point->enactor))
            {
                p->iPriority = PRIORITY_PLAYER;
            }
            else
            {
                p->iPriority = PRIORITY_OBJECT;
            }
            p->ltaWhen.GetUTC();
            p->fpTask = Task_RunQueueEntry;
            return IU_UPDATE_TASK;
        }
    }
    return IU_NEXT_TASK;
}

static int CallBack_ShowDispatches

(

PTASK_RECORD

p

)

[static]

Definition at line 1106 of file cque.cpp.

References dispatch_CacheTick(), dispatch_CheckEvents(), dispatch_DatabaseDump(), dispatch_FreeListReconstruction(), dispatch_IdleCheck(), TASK_RECORD::fpTask, IU_NEXT_TASK, TASK_RECORD::ltaWhen, notify, CLinearTimeDelta::ReturnSeconds(), Show_lsaNow, Task_ProcessCommand(), and tprintf().

Referenced by do_ps().

{
    Total_SystemTasks++;
    CLinearTimeDelta ltd = p->ltaWhen - Show_lsaNow;
    if (p->fpTask == dispatch_DatabaseDump)
    {
        notify(Show_Player, tprintf("[%d]auto-@dump", ltd.ReturnSeconds()));
    }
    else if (p->fpTask == dispatch_FreeListReconstruction)
    {
        notify(Show_Player, tprintf("[%d]auto-@dbck", ltd.ReturnSeconds()));
    }
    else if (p->fpTask == dispatch_IdleCheck)
    {
        notify(Show_Player, tprintf("[%d]Check for idle players", ltd.ReturnSeconds()));
    }
    else if (p->fpTask == dispatch_CheckEvents)
    {
        notify(Show_Player, tprintf("[%d]Test for @daily time", ltd.ReturnSeconds()));
    }
#ifndef MEMORY_BASED
    else if (p->fpTask == dispatch_CacheTick)
    {
        notify(Show_Player, tprintf("[%d]Database cache tick", ltd.ReturnSeconds()));
    }
#endif
    else if (p->fpTask == Task_ProcessCommand)
    {
        notify(Show_Player, tprintf("[%d]Further command quota", ltd.ReturnSeconds()));
    }
#ifdef WIN32
    else if (p->fpTask == Task_FreeDescriptor)
    {
        notify(Show_Player, tprintf("[%d]Delayed descriptor deallocation", ltd.ReturnSeconds()));
    }
    else if (p->fpTask == Task_DeferredClose)
    {
        notify(Show_Player, tprintf("[%d]Delayed socket close", ltd.ReturnSeconds()));
    }
#endif
    else
    {
        Total_SystemTasks--;
    }
    return IU_NEXT_TASK;
}

static int CallBack_ShowSemaphore

(

PTASK_RECORD

p

)

[static]

Definition at line 1222 of file cque.cpp.

References TASK_RECORD::arg_voidptr, TASK_RECORD::fpTask, IU_NEXT_TASK, notify, PS_SUMM, que_want(), Show_bFirstLine, Show_Key, Show_Object_Target, Show_Player, Show_Player_Target, Shown_SemaphoreTimeout, ShowPsLine(), Task_SemaphoreTimeout(), and Total_SemaphoreTimeout.

Referenced by do_ps().

{
    if (p->fpTask != Task_SemaphoreTimeout)
    {
        return IU_NEXT_TASK;
    }

    Total_SemaphoreTimeout++;
    BQUE *tmp = (BQUE *)(p->arg_voidptr);
    if (que_want(tmp, Show_Player_Target, Show_Object_Target))
    {
        Shown_SemaphoreTimeout++;
        if (Show_Key == PS_SUMM)
        {
            return IU_NEXT_TASK;
        }
        if (Show_bFirstLine)
        {
            notify(Show_Player, "----- Semaphore Queue -----");
            Show_bFirstLine = false;
        }
        ShowPsLine(tmp);
    }
    return IU_NEXT_TASK;
}

static int CallBack_ShowWait

(

PTASK_RECORD

p

)

[static]

Definition at line 1196 of file cque.cpp.

References TASK_RECORD::arg_voidptr, TASK_RECORD::fpTask, IU_NEXT_TASK, notify, PS_SUMM, que_want(), Show_bFirstLine, Show_Key, Show_Object_Target, Show_Player, Show_Player_Target, Shown_RunQueueEntry, ShowPsLine(), Task_RunQueueEntry(), and Total_RunQueueEntry.

Referenced by do_ps().

{
    if (p->fpTask != Task_RunQueueEntry)
    {
        return IU_NEXT_TASK;
    }

    Total_RunQueueEntry++;
    BQUE *tmp = (BQUE *)(p->arg_voidptr);
    if (que_want(tmp, Show_Player_Target, Show_Object_Target))
    {
        Shown_RunQueueEntry++;
        if (Show_Key == PS_SUMM)
        {
            return IU_NEXT_TASK;
        }
        if (Show_bFirstLine)
        {
            notify(Show_Player, "----- Wait Queue -----");
            Show_bFirstLine = false;
        }
        ShowPsLine(tmp);
    }
    return IU_NEXT_TASK;
}

static int CallBack_Warp

(

PTASK_RECORD

p

)

[static]

Definition at line 1390 of file cque.cpp.

References TASK_RECORD::arg_voidptr, TASK_RECORD::fpTask, bque::IsTimed, IU_NEXT_TASK, IU_UPDATE_TASK, TASK_RECORD::ltaWhen, ltdWarp, Task_RunQueueEntry(), Task_SemaphoreTimeout(), and bque::waittime.

Referenced by do_queue().

{
    if (  p->fpTask == Task_RunQueueEntry
#ifdef QUERY_SLAVE
       || p->fpTask == Task_SQLTimeout
#endif // QUERY_SLAVE
       || p->fpTask == Task_SemaphoreTimeout)
    {
        BQUE *point = (BQUE *)(p->arg_voidptr);
        if (point->IsTimed)
        {
            point->waittime -= ltdWarp;
            p->ltaWhen -= ltdWarp;
            return IU_UPDATE_TASK;
        }
    }
    return IU_NEXT_TASK;
}

void do_halt	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	target
	)

Definition at line 358 of file cque.cpp.

References Can_Halt, Good_obj, HALT_ALL, halt_que(), isPlayer, match_controlled, match_thing(), NOPERM_MESSAGE, NOTHING, notify, Owner, Quiet, tprintf(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref executor_targ, obj_targ;

    if ((key & HALT_ALL) && !Can_Halt(executor))
    {
        notify(executor, NOPERM_MESSAGE);
        return;
    }

    // Figure out what to halt.
    //
    if (!target || !*target)
    {
        obj_targ = NOTHING;
        if (key & HALT_ALL)
        {
            executor_targ = NOTHING;
        }
        else
        {
            executor_targ = Owner(executor);
            if (!isPlayer(executor))
            {
                obj_targ = executor;
            }
        }
    }
    else
    {
        if (Can_Halt(executor))
        {
            obj_targ = match_thing(executor, target);
        }
        else
        {
            obj_targ = match_controlled(executor, target);
        }
        if (!Good_obj(obj_targ))
        {
            return;
        }
        if (key & HALT_ALL)
        {
            notify(executor, "Can't specify a target and /all");
            return;
        }
        if (isPlayer(obj_targ))
        {
            executor_targ = obj_targ;
            obj_targ = NOTHING;
        }
        else
        {
            executor_targ = NOTHING;
        }
    }

    int numhalted = halt_que(executor_targ, obj_targ);
    if (Quiet(executor))
    {
        return;
    }
    notify(Owner(executor), tprintf("%d queue entr%s removed.", numhalted, numhalted == 1 ? "y" : "ies"));
}

void do_notify	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	what,
		char *	count
	)

Definition at line 573 of file cque.cpp.

References A_SEMAPHORE, anum_get, bCanSetAttr(), Controls, Good_obj, init_match(), Link_ok, match_everything(), mkattr(), mux_atol(), NFY_DRAIN, nfy_que(), NFY_QUIET, noisy_match_result(), NOPERM_MESSAGE, notify, notify_quiet, NOTYPE, parse_to(), Quiet, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(nargs);

    char *obj = parse_to(&what, '/', 0);
    init_match(executor, obj, NOTYPE);
    match_everything(0);

    dbref thing = noisy_match_result();
    if (!Good_obj(thing))
    {
        return;
    }
    if (!Controls(executor, thing) && !Link_ok(thing))
    {
        notify(executor, NOPERM_MESSAGE);
    }
    else
    {
        int atr = A_SEMAPHORE;
        if (  what
           && what[0] != '\0')
        {
            int i = mkattr(executor, what);
            if (0 < i)
            {
                atr = i;
                if (atr != A_SEMAPHORE)
                {
                    // Do they have permission to set this attribute?
                    //
                    ATTR *ap = (ATTR *)anum_get(atr);
                    if (!bCanSetAttr(executor, thing, ap))
                    {
                        notify_quiet(executor, NOPERM_MESSAGE);
                        return;
                    }
                }
            }
        }

        int loccount;
        if (  count
           && count[0] != '\0')
        {
            loccount = mux_atol(count);
        }
        else
        {
            loccount = 1;
        }
        if (loccount > 0)
        {
            nfy_que(thing, atr, key, loccount);
            if (  (!(Quiet(executor) || Quiet(thing)))
               && key != NFY_QUIET)
            {
                if (key == NFY_DRAIN)
                {
                    notify_quiet(executor, "Drained.");
                }
                else
                {
                    notify_quiet(executor, "Notified.");
                }
            }
        }
    }
}

void do_ps	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	target
	)

Definition at line 1279 of file cque.cpp.

References alloc_mbuf, CallBack_ShowDispatches(), CallBack_ShowSemaphore(), CallBack_ShowWait(), free_mbuf, CLinearTimeAbsolute::GetUTC(), isPlayer, match_controlled, NOPERM_MESSAGE, NOTHING, notify, Owner, PS_ALL, PS_BRIEF, PS_LONG, PS_SUMM, scheduler, See_Queue, Show_bFirstLine, Show_Key, Show_lsaNow, Show_Object_Target, Show_Player, Show_Player_Target, Shown_RunQueueEntry, Shown_SemaphoreTimeout, Total_RunQueueEntry, Total_SemaphoreTimeout, Total_SystemTasks, CScheduler::TraverseOrdered(), UNUSED_PARAMETER, and Wizard.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    char *bufp;
    dbref executor_targ, obj_targ;

    // Figure out what to list the queue for.
    //
    if ((key & PS_ALL) && !See_Queue(executor))
    {
        notify(executor, NOPERM_MESSAGE);
        return;
    }
    if (!target || !*target)
    {
        obj_targ = NOTHING;
        if (key & PS_ALL)
        {
            executor_targ = NOTHING;
        }
        else
        {
            executor_targ = Owner(executor);
            if (!isPlayer(executor))
            {
                obj_targ = executor;
            }
        }
    }
    else
    {
        executor_targ = Owner(executor);
        obj_targ = match_controlled(executor, target);
        if (obj_targ == NOTHING)
        {
            return;
        }
        if (key & PS_ALL)
        {
            notify(executor, "Can't specify a target and /all");
            return;
        }
        if (isPlayer(obj_targ))
        {
            executor_targ = obj_targ;
            obj_targ = NOTHING;
        }
    }
    key = key & ~PS_ALL;

    switch (key)
    {
    case PS_BRIEF:
    case PS_SUMM:
    case PS_LONG:
        break;

    default:
        notify(executor, "Illegal combination of switches.");
        return;
    }

    Show_lsaNow.GetUTC();
    Total_SystemTasks = 0;
    Total_RunQueueEntry = 0;
    Shown_RunQueueEntry = 0;
    Total_SemaphoreTimeout = 0;
    Shown_SemaphoreTimeout = 0;
    Show_Player_Target = executor_targ;
    Show_Object_Target = obj_targ;
    Show_Key = key;
    Show_Player = executor;
    Show_bFirstLine = true;
    scheduler.TraverseOrdered(CallBack_ShowWait);
    Show_bFirstLine = true;
    scheduler.TraverseOrdered(CallBack_ShowSemaphore);
#ifdef QUERY_SLAVE
    Show_bFirstLine = true;
    scheduler.TraverseOrdered(CallBack_ShowSQLQueries);
#endif // QUERY_SLAVE
    if (Wizard(executor))
    {
        notify(executor, "----- System Queue -----");
        scheduler.TraverseOrdered(CallBack_ShowDispatches);
    }

    // Display stats.
    //
    bufp = alloc_mbuf("do_ps");
#ifdef QUERY_SLAVE
    sprintf(bufp, "Totals: Wait Queue...%d/%d  Semaphores...%d/%d  SQL %d/%d",
        Shown_RunQueueEntry, Total_RunQueueEntry,
        Shown_SemaphoreTimeout, Total_SemaphoreTimeout,
        Shown_SQLTimeout, Total_SQLTimeout);
#else
    sprintf(bufp, "Totals: Wait Queue...%d/%d  Semaphores...%d/%d",
        Shown_RunQueueEntry, Total_RunQueueEntry,
        Shown_SemaphoreTimeout, Total_SemaphoreTimeout);
#endif // QUERY_SLAVE
    notify(executor, bufp);
    if (Wizard(executor))
    {
        sprintf(bufp, "        System Tasks.....%d", Total_SystemTasks);
        notify(executor, bufp);
    }
    free_mbuf(bufp);
}

void do_queue	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	arg
	)

Definition at line 1412 of file cque.cpp.

References CallBack_Warp(), CScheduler::GetMinPriority(), CLinearTimeAbsolute::GetUTC(), ltdWarp, mux_atol(), notify, PRIORITY_CF_DEQUEUE_DISABLED, PRIORITY_CF_DEQUEUE_ENABLED, QUEUE_KICK, QUEUE_WARP, Quiet, CScheduler::ReadyTasks(), CScheduler::RunTasks(), scheduler, CScheduler::SetMinPriority(), CLinearTimeDelta::SetSeconds(), tprintf(), CScheduler::TraverseUnordered(), and UNUSED_PARAMETER.

Referenced by do_timewarp().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    if (key == QUEUE_KICK)
    {
        int i = mux_atol(arg);
        int save_minPriority = scheduler.GetMinPriority();
        if (save_minPriority <= PRIORITY_CF_DEQUEUE_DISABLED)
        {
            notify(executor, "Warning: automatic dequeueing is disabled.");
            scheduler.SetMinPriority(PRIORITY_CF_DEQUEUE_ENABLED);
        }
        CLinearTimeAbsolute lsaNow;
        lsaNow.GetUTC();
        scheduler.ReadyTasks(lsaNow);
        int ncmds = scheduler.RunTasks(i);
        scheduler.SetMinPriority(save_minPriority);

        if (!Quiet(executor))
        {
            notify(executor, tprintf("%d commands processed.", ncmds));
        }
    }
    else if (key == QUEUE_WARP)
    {
        int iWarp = mux_atol(arg);
        ltdWarp.SetSeconds(iWarp);
        if (scheduler.GetMinPriority() <= PRIORITY_CF_DEQUEUE_DISABLED)
        {
            notify(executor, "Warning: automatic dequeueing is disabled.");
        }

        scheduler.TraverseUnordered(CallBack_Warp);

        if (Quiet(executor))
        {
            return;
        }
        if (iWarp > 0)
        {
            notify(executor, tprintf("WaitQ timer advanced %d seconds.", iWarp));
        }
        else if (iWarp < 0)
        {
            notify(executor, tprintf("WaitQ timer set back %d seconds.", iWarp));
        }
        else
        {
            notify(executor, "Object queue appended to player queue.");
        }
    }
}

void do_wait	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	event,
		char *	cmd,
		char *	cargs[],
		int	ncargs
	)

Definition at line 925 of file cque.cpp.

References A_SEMAPHORE, add_to(), atr_num(), atr_str(), bCanSetAttr(), Controls, CLinearTimeAbsolute::GetUTC(), statedata::global_regs, Good_obj, init_match(), is_rational(), Link_ok, match_everything(), mkattr(), mudstate, noisy_match_result(), NOPERM_MESSAGE, NOTHING, notify, notify_quiet, NOTYPE, attr::number, parse_to(), CLinearTimeDelta::SetSecondsString(), CLinearTimeAbsolute::SetSecondsString(), wait_que(), and WAIT_UNTIL.

{
    CLinearTimeAbsolute ltaWhen;
    CLinearTimeDelta    ltd;

    // If arg1 is all numeric, do simple (non-sem) timed wait.
    //
    if (is_rational(event))
    {
        if (key & WAIT_UNTIL)
        {
            ltaWhen.SetSecondsString(event);
        }
        else
        {
            ltaWhen.GetUTC();
            ltd.SetSecondsString(event);
            ltaWhen += ltd;
        }
        wait_que(executor, caller, enactor, true, ltaWhen, NOTHING, 0, cmd,
            cargs, ncargs, mudstate.global_regs);
        return;
    }

    // Semaphore wait with optional timeout.
    //
    char *what = parse_to(&event, '/', 0);
    init_match(executor, what, NOTYPE);
    match_everything(0);

    dbref thing = noisy_match_result();
    if (!Good_obj(thing))
    {
        return;
    }
    else if (!Controls(executor, thing) && !Link_ok(thing))
    {
        notify(executor, NOPERM_MESSAGE);
    }
    else
    {
        // Get timeout, default 0.
        //
        int atr = A_SEMAPHORE;
        bool bTimed = false;
        if (event && *event)
        {
            if (is_rational(event))
            {
                if (key & WAIT_UNTIL)
                {
                    ltaWhen.SetSecondsString(event);
                }
                else
                {
                    ltaWhen.GetUTC();
                    ltd.SetSecondsString(event);
                    ltaWhen += ltd;
                }
                bTimed = true;
            }
            else
            {
                ATTR *ap = atr_str(event);
                if (!ap)
                {
                    atr = mkattr(executor, event);
                    if (atr <= 0)
                    {
                        notify_quiet(executor, "Invalid attribute.");
                        return;
                    }
                    ap = atr_num(atr);
                }
                else
                {
                    atr = ap->number;
                }
                if (!bCanSetAttr(executor, thing, ap))
                {
                    notify_quiet(executor, NOPERM_MESSAGE);
                    return;
                }
            }
        }

        int num = add_to(thing, 1, atr);
        if (num <= 0)
        {
            // Thing over-notified, run the command immediately.
            //
            thing = NOTHING;
            bTimed = false;
        }
        wait_que(executor, caller, enactor, bTimed, ltaWhen, thing, atr,
            cmd, cargs, ncargs, mudstate.global_regs);
    }
}

static CLinearTimeDelta GetProcessorUsage

(

void

)

[static]

Definition at line 23 of file cque.cpp.

References CLinearTimeAbsolute::GetLocal(), mudstate, CLinearTimeDelta::Set100ns(), CLinearTimeDelta::SetTimeValueStruct(), and statedata::start_time.

Referenced by Task_RunQueueEntry().

{
    CLinearTimeDelta ltd;
#ifdef WIN32
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        FILETIME ftCreate;
        FILETIME ftExit;
        FILETIME ftKernel;
        FILETIME ftUser;
        fpGetProcessTimes(hGameProcess, &ftCreate, &ftExit, &ftKernel, &ftUser);
        ltd.Set100ns(*(INT64 *)(&ftUser));
        return ltd;
    }
#endif

#if !defined(WIN32) && defined(HAVE_GETRUSAGE)

    struct rusage usage;
    getrusage(RUSAGE_SELF, &usage);
    ltd.SetTimeValueStruct(&usage.ru_utime);
    return ltd;

#else

    // Either this Unix doesn't have getrusage or this is a
    // fall-through case for Win32.
    //
    CLinearTimeAbsolute ltaNow;
    ltaNow.GetLocal();
    ltd = ltaNow - mudstate.start_time;
    return ltd;

#endif
}

int halt_que	(	dbref	executor,
		dbref	object
	)

Definition at line 334 of file cque.cpp.

References a_Queue(), CallBack_HaltQueue(), giveto(), Halt_Entries, Halt_Entries_Run, Halt_Object_Target, Halt_Player_Run, Halt_Player_Target, mudconf, NOTHING, scheduler, CScheduler::TraverseUnordered(), and confdata::waitcost.

Referenced by announce_disconnect(), check_dead_refs(), destroy_bad_obj(), destroy_obj(), destroy_player(), do_chown(), do_command(), do_halt(), do_kill(), setup_que(), and Task_RunQueueEntry().

{
    Halt_Player_Target = executor;
    Halt_Object_Target = object;
    Halt_Entries       = 0;
    Halt_Player_Run    = NOTHING;
    Halt_Entries_Run   = 0;

    // Process @wait, timed semaphores, and untimed semaphores.
    //
    scheduler.TraverseUnordered(CallBack_HaltQueue);

    if (Halt_Player_Run != NOTHING)
    {
        giveto(Halt_Player_Run, mudconf.waitcost * Halt_Entries_Run);
        a_Queue(Halt_Player_Run, -Halt_Entries_Run);
        Halt_Player_Run = NOTHING;
    }
    return Halt_Entries;
}

int nfy_que	(	dbref	sem,
		int	attr,
		int	key,
		int	count
	)

Definition at line 525 of file cque.cpp.

References add_to(), atr_clr(), atr_get, CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), free_lbuf, mux_atol(), NFY_NFY, NFY_QUIET, Notify_Attr, Notify_Key, Notify_Num_Done, Notify_Num_Max, Notify_Sem, scheduler, CScheduler::TraverseOrdered(), and CScheduler::TraverseUnordered().

Referenced by destroy_bad_obj(), destroy_obj(), and do_notify().

{
    int cSemaphore = 1;
    if (attr)
    {
        int   aflags;
        dbref aowner;
        char *str = atr_get(sem, attr, &aowner, &aflags);
        cSemaphore = mux_atol(str);
        free_lbuf(str);
    }

    Notify_Num_Done = 0;
    if (cSemaphore > 0)
    {
        Notify_Key     = key;
        Notify_Sem     = sem;
        Notify_Attr    = attr;
        Notify_Num_Max = count;
        if (  key == NFY_NFY
           || key == NFY_QUIET)
        {
            scheduler.TraverseOrdered(CallBack_NotifySemaphoreFirstOrQuiet);
        }
        else
        {
            scheduler.TraverseUnordered(CallBack_NotifySemaphoreDrainOrAll);
        }
    }

    // Update the sem waiters count.
    //
    if (key == NFY_NFY)
    {
        add_to(sem, -count, attr);
    }
    else
    {
        atr_clr(sem, attr);
    }

    return Notify_Num_Done;
}

static bool que_want	(	BQUE *	entry,
		dbref	ptarg,
		dbref	otarg
	)			[static]

Definition at line 240 of file cque.cpp.

References bque::executor, NOTHING, and Owner.

Referenced by CallBack_HaltQueue(), CallBack_ShowSemaphore(), and CallBack_ShowWait().

{
    if (  ptarg != NOTHING
       && ptarg != Owner(entry->executor))
    {
        return false;
    }
    return (  otarg == NOTHING
           || otarg == entry->executor);
}

static BQUE* setup_que	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		char *	command,
		char *	args[],
		int	nargs,
		char *	sargs[]
	)			[static]

Definition at line 656 of file cque.cpp.

References a_Queue(), alloc_qentry, bque::attr, bque::caller, bque::comm, bque::enactor, bque::env, bque::executor, halt_que(), Halted, ISOUTOFMEMORY, bque::IsTimed, confdata::machinecost, MAX_GLOBAL_REGS, MEMALLOC, mudconf, bque::nargs, NOTHING, notify, NUM_ENV_VARS, Owner, payfor(), QueueMax(), RandomINT32(), s_Halted, bque::scr, bque::sem, bque::text, and confdata::waitcost.

Referenced by wait_que().

{
    int a;
    BQUE *tmp;

    // Can we run commands at all?
    //
    if (Halted(executor))
        return NULL;

    // Make sure executor can afford to do it.
    //
    a = mudconf.waitcost;
    if (mudconf.machinecost && RandomINT32(0, mudconf.machinecost-1) == 0)
    {
        a++;
    }
    if (!payfor(executor, a))
    {
        notify(Owner(executor), "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(executor));
    if (a_Queue(Owner(executor), 1) > a)
    {
        a_Queue(Owner(executor), -1);

        notify(Owner(executor),
            "Run away objects: too many commands queued.  Halted.");
        halt_que(Owner(executor), NOTHING);

        // Halt also means no command execution allowed.
        //
        s_Halted(executor);
        return NULL;
    }

    // We passed all the tests.
    //

    // Calculate the length of the save string.
    //
    unsigned int tlen = 0;
    static unsigned int nCommand;
    static unsigned int nLenEnv[NUM_ENV_VARS];
    static unsigned int nLenRegs[MAX_GLOBAL_REGS];

    if (command)
    {
        nCommand = strlen(command) + 1;
        tlen = nCommand;
    }
    if (nargs > NUM_ENV_VARS)
    {
        nargs = NUM_ENV_VARS;
    }
    for (a = 0; a < nargs; a++)
    {
        if (args[a])
        {
            nLenEnv[a] = strlen(args[a]) + 1;
            tlen += nLenEnv[a];
        }
    }
    if (sargs)
    {
        for (a = 0; a < MAX_GLOBAL_REGS; a++)
        {
            if (sargs[a])
            {
                nLenRegs[a] = strlen(sargs[a]) + 1;
                tlen += nLenRegs[a];
            }
        }
    }

    // Create the qeue entry and load the save string.
    //
    tmp = alloc_qentry("setup_que.qblock");
    tmp->comm = NULL;

    char *tptr = tmp->text = (char *)MEMALLOC(tlen);
    ISOUTOFMEMORY(tptr);

    if (command)
    {
        memcpy(tptr, command, nCommand);
        tmp->comm = tptr;
        tptr += nCommand;
    }
    for (a = 0; a < nargs; a++)
    {
        if (args[a])
        {
            memcpy(tptr, args[a], nLenEnv[a]);
            tmp->env[a] = tptr;
            tptr += nLenEnv[a];
        }
        else
        {
            tmp->env[a] = NULL;
        }
    }
    for ( ; a < NUM_ENV_VARS; a++)
    {
        tmp->env[a] = NULL;
    }
    for (a = 0; a < MAX_GLOBAL_REGS; a++)
    {
        tmp->scr[a] = NULL;
    }
    if (sargs)
    {
        for (a = 0; a < MAX_GLOBAL_REGS; a++)
        {
            if (sargs[a])
            {
                memcpy(tptr, sargs[a], nLenRegs[a]);
                tmp->scr[a] = tptr;
                tptr += nLenRegs[a];
            }
        }
    }

    // Load the rest of the queue block.
    //
    tmp->executor = executor;
    tmp->IsTimed = false;
    tmp->sem = NOTHING;
    tmp->attr = 0;
    tmp->enactor = enactor;
    tmp->caller = caller;
    tmp->nargs = nargs;
    return tmp;
}

static void ShowPsLine

(

BQUE *

tmp

)

[static]

Definition at line 1153 of file cque.cpp.

References bque::comm, bque::enactor, bque::env, bque::executor, free_lbuf, Good_obj, bque::IsTimed, bque::nargs, notify, PS_LONG, CLinearTimeDelta::ReturnSeconds(), safe_chr, safe_str, bque::sem, Show_lsaNow, tprintf(), unparse_object(), and bque::waittime.

Referenced by CallBack_ShowSemaphore(), and CallBack_ShowWait().

{
    char *bufp = unparse_object(Show_Player, tmp->executor, false);
    if (tmp->IsTimed && (Good_obj(tmp->sem)))
    {
        CLinearTimeDelta ltd = tmp->waittime - Show_lsaNow;
        notify(Show_Player, tprintf("[#%d/%d]%s:%s", tmp->sem, ltd.ReturnSeconds(), bufp, tmp->comm));
    }
    else if (tmp->IsTimed)
    {
        CLinearTimeDelta ltd = tmp->waittime - Show_lsaNow;
        notify(Show_Player, tprintf("[%d]%s:%s", ltd.ReturnSeconds(), bufp, tmp->comm));
    }
    else if (Good_obj(tmp->sem))
    {
        notify(Show_Player, tprintf("[#%d]%s:%s", tmp->sem, bufp, tmp->comm));
    }
    else
    {
        notify(Show_Player, tprintf("%s:%s", bufp, tmp->comm));
    }
    char *bp = bufp;
    if (Show_Key == PS_LONG)
    {
        for (int i = 0; i < tmp->nargs; i++)
        {
            if (tmp->env[i] != NULL)
            {
                safe_str("; Arg", bufp, &bp);
                safe_chr((char)(i + '0'), bufp, &bp);
                safe_str("='", bufp, &bp);
                safe_str(tmp->env[i], bufp, &bp);
                safe_chr('\'', bufp, &bp);
            }
        }
        *bp = '\0';
        bp = unparse_object(Show_Player, tmp->enactor, false);
        notify(Show_Player, tprintf("   Enactor: %s%s", bp, bufp));
        free_lbuf(bp);
    }
    free_lbuf(bufp);
}

static void Task_RunQueueEntry	(	void *	pEntry,
		int	iUnused
	)			[static]

Definition at line 86 of file cque.cpp.

References a_Queue(), alloc_lbuf, CMuxAlarm::bAlarmed, break_called, bque::caller, CMuxAlarm::Clear(), bque::comm, object::cpu_time_used, statedata::curr_enactor, statedata::curr_executor, db, bque::enactor, ENDLOG, bque::env, bque::executor, FLAG_WORD1, Flags, free_lbuf, GetProcessorUsage(), CLinearTimeAbsolute::GetUTC(), giveto(), statedata::glob_reg_len, statedata::global_regs, Going, Good_obj, HALT, halt_que(), Halted, statedata::inpipe, log_name_and_loc(), LOG_PROBLEMS, log_text(), confdata::max_cmdsecs, MAX_GLOBAL_REGS, mudconf, mudstate, mux_assert, MuxAlarm, bque::nargs, NOTHING, notify, confdata::ntfy_nest_lim, Owner, parse_to(), statedata::pipe_nest_lev, statedata::pout, statedata::poutbufc, statedata::poutnew, statedata::poutobj, process_command(), CLinearTimeDelta::ReturnSecondsString(), confdata::rpt_cmdsecs, s_Flags, bque::scr, CMuxAlarm::Set(), STARTLOG, UNUSED_PARAMETER, and confdata::waitcost.

Referenced by CallBack_HaltQueue(), CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), CallBack_ShowWait(), CallBack_Warp(), Task_SemaphoreTimeout(), and wait_que().

{
    UNUSED_PARAMETER(iUnused);

    BQUE *point = (BQUE *)pEntry;
    dbref executor = point->executor;

    if (  Good_obj(executor)
       && !Going(executor))
    {
        giveto(executor, mudconf.waitcost);
        mudstate.curr_enactor = point->enactor;
        mudstate.curr_executor = executor;
        a_Queue(Owner(executor), -1);
        point->executor = NOTHING;
        if (!Halted(executor))
        {
            // Load scratch args.
            //
            for (int i = 0; i < MAX_GLOBAL_REGS; i++)
            {
                if (point->scr[i])
                {
                    int n = strlen(point->scr[i]);
                    memcpy(mudstate.global_regs[i], point->scr[i], n+1);
                    mudstate.glob_reg_len[i] = n;
                }
                else
                {
                    mudstate.global_regs[i][0] = '\0';
                    mudstate.glob_reg_len[i] = 0;
                }
            }

            char *command = point->comm;

            mux_assert(!mudstate.inpipe);
            mux_assert(mudstate.pipe_nest_lev == 0);
            mux_assert(mudstate.poutobj == NOTHING);
            mux_assert(!mudstate.pout);

            break_called = false;
            while (  command
                  && !break_called)
            {
                mux_assert(!mudstate.poutnew);
                mux_assert(!mudstate.poutbufc);

                char *cp = parse_to(&command, ';', 0);

                if (  cp
                   && *cp)
                {
                    // Will command be piped?
                    //
                    if (  command
                       && *command == '|'
                       && mudstate.pipe_nest_lev < mudconf.ntfy_nest_lim)
                    {
                        command++;
                        mudstate.pipe_nest_lev++;
                        mudstate.inpipe = true;

                        mudstate.poutnew  = alloc_lbuf("process_command.pipe");
                        mudstate.poutbufc = mudstate.poutnew;
                        mudstate.poutobj  = executor;
                    }
                    else
                    {
                        mudstate.inpipe = false;
                        mudstate.poutobj = NOTHING;
                    }

                    CLinearTimeAbsolute ltaBegin;
                    ltaBegin.GetUTC();
                    MuxAlarm.Set(mudconf.max_cmdsecs);
                    CLinearTimeDelta ltdUsageBegin = GetProcessorUsage();

                    char *log_cmdbuf = process_command(executor, point->caller,
                        point->enactor, false, cp, point->env, point->nargs);

                    CLinearTimeAbsolute ltaEnd;
                    ltaEnd.GetUTC();
                    if (MuxAlarm.bAlarmed)
                    {
                        notify(executor, "GAME: Expensive activity abbreviated.");
                        s_Flags(point->enactor, FLAG_WORD1, Flags(point->enactor) | HALT);
                        s_Flags(point->executor, FLAG_WORD1, Flags(point->executor) | HALT);
                        halt_que(point->enactor, NOTHING);
                        halt_que(executor, NOTHING);
                    }
                    MuxAlarm.Clear();

                    CLinearTimeDelta ltdUsageEnd = GetProcessorUsage();
                    CLinearTimeDelta ltd = ltdUsageEnd - ltdUsageBegin;
                    db[executor].cpu_time_used += ltd;

                    ltd = ltaEnd - ltaBegin;
                    if (ltd > mudconf.rpt_cmdsecs)
                    {
                        STARTLOG(LOG_PROBLEMS, "CMD", "CPU");
                        log_name_and_loc(executor);
                        char *logbuf = alloc_lbuf("do_top.LOG.cpu");
                        sprintf(logbuf, " queued command taking %s secs (enactor #%d): ",
                            ltd.ReturnSecondsString(4), point->enactor);
                        log_text(logbuf);
                        free_lbuf(logbuf);
                        log_text(log_cmdbuf);
                        ENDLOG;
                    }
                }

                // Transition %| value.
                //
                if (mudstate.pout)
                {
                    free_lbuf(mudstate.pout);
                    mudstate.pout = NULL;
                }
                if (mudstate.poutnew)
                {
                    *mudstate.poutbufc = '\0';
                    mudstate.pout = mudstate.poutnew;
                    mudstate.poutnew  = NULL;
                    mudstate.poutbufc = NULL;
                }
            }

            // Clean up %| value.
            //
            if (mudstate.pout)
            {
                free_lbuf(mudstate.pout);
                mudstate.pout = NULL;
            }
            mudstate.pipe_nest_lev = 0;
            mudstate.inpipe = false;
            mudstate.poutobj = NOTHING;
        }
    }
    MEMFREE(point->text);
    point->text = NULL;
    free_qentry(point);

    for (int i = 0; i < MAX_GLOBAL_REGS; i++)
    {
        mudstate.global_regs[i][0] = '\0';
        mudstate.glob_reg_len[i] = 0;
    }
}

static void Task_SemaphoreTimeout	(	void *	pExpired,
		int	iUnused
	)			[static]

Definition at line 251 of file cque.cpp.

References add_to(), bque::attr, NOTHING, bque::sem, Task_RunQueueEntry(), and UNUSED_PARAMETER.

Referenced by CallBack_HaltQueue(), CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), CallBack_ShowSemaphore(), CallBack_Warp(), and wait_que().

{
    UNUSED_PARAMETER(iUnused);

    // A semaphore has timed out.
    //
    BQUE *point = (BQUE *)pExpired;
    add_to(point->sem, -1, point->attr);
    point->sem = NOTHING;
    Task_RunQueueEntry(point, 0);
}

void wait_que	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		bool	bTimed,
		CLinearTimeAbsolute &	ltaWhen,
		dbref	sem,
		int	attr,
		char *	command,
		char *	args[],
		int	nargs,
		char *	sargs[]
	)

Definition at line 801 of file cque.cpp.

References bque::attr, CF_INTERP, confdata::control_flags, CScheduler::DeferImmediateTask(), CScheduler::DeferTask(), bque::enactor, isPlayer, bque::IsTimed, mudconf, NOTHING, PRIORITY_OBJECT, PRIORITY_PLAYER, PRIORITY_SUSPEND, scheduler, bque::sem, setup_que(), Task_RunQueueEntry(), Task_SemaphoreTimeout(), and bque::waittime.

Referenced by announce_connect(), announce_disconnect(), atr_match1(), bind_and_queue(), did_it(), do_dolist(), do_force(), do_if(), do_switch(), do_wait(), handle_prog(), and process_cmdent().

{
    if (!(mudconf.control_flags & CF_INTERP))
    {
        return;
    }

    BQUE *tmp = setup_que(executor, caller, enactor, command, args, nargs, sargs);
    if (!tmp)
    {
        return;
    }

    int iPriority;
    if (isPlayer(tmp->enactor))
    {
        iPriority = PRIORITY_PLAYER;
    }
    else
    {
        iPriority = PRIORITY_OBJECT;
    }

    tmp->IsTimed = bTimed;
    tmp->waittime = ltaWhen;
    tmp->sem = sem;
    tmp->attr = attr;

    if (sem == NOTHING)
    {
        // Not a semaphore, so let it run it immediately or put it on
        // the wait queue.
        //
        if (tmp->IsTimed)
        {
            scheduler.DeferTask(tmp->waittime, iPriority, Task_RunQueueEntry, tmp, 0);
        }
        else
        {
            scheduler.DeferImmediateTask(iPriority, Task_RunQueueEntry, tmp, 0);
        }
    }
    else
    {
        if (!tmp->IsTimed)
        {
            // In this case, the timeout task below will never run,
            // but it allows us to manage all semaphores together in
            // the same data structure.
            //
            iPriority = PRIORITY_SUSPEND;
        }
        scheduler.DeferTask(tmp->waittime, iPriority, Task_SemaphoreTimeout, tmp, 0);
    }
}

---

Variable Documentation

bool break_called = false

Definition at line 21 of file cque.cpp.

Referenced by do_break(), and Task_RunQueueEntry().

int Halt_Entries [static]

Definition at line 275 of file cque.cpp.

Referenced by CallBack_HaltQueue(), and halt_que().

dbref Halt_Entries_Run [static]

Definition at line 277 of file cque.cpp.

Referenced by CallBack_HaltQueue(), and halt_que().

dbref Halt_Object_Target [static]

Definition at line 274 of file cque.cpp.

Referenced by CallBack_HaltQueue(), and halt_que().

dbref Halt_Player_Run [static]

Definition at line 276 of file cque.cpp.

Referenced by CallBack_HaltQueue(), and halt_que().

dbref Halt_Player_Target [static]

Definition at line 273 of file cque.cpp.

Referenced by CallBack_HaltQueue(), and halt_que().

CLinearTimeDelta ltdWarp [static]

Definition at line 1389 of file cque.cpp.

Referenced by CallBack_Warp(), and do_queue().

int Notify_Attr [static]

Definition at line 431 of file cque.cpp.

Referenced by CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), and nfy_que().

int Notify_Key [static]

Definition at line 427 of file cque.cpp.

Referenced by CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), and nfy_que().

int Notify_Num_Done [static]

Definition at line 428 of file cque.cpp.

Referenced by CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), and nfy_que().

int Notify_Num_Max [static]

Definition at line 429 of file cque.cpp.

Referenced by CallBack_NotifySemaphoreFirstOrQuiet(), and nfy_que().

int Notify_Sem [static]

Definition at line 430 of file cque.cpp.

Referenced by CallBack_NotifySemaphoreDrainOrAll(), CallBack_NotifySemaphoreFirstOrQuiet(), and nfy_que().

int Show_bFirstLine [static]

Definition at line 1099 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), CallBack_ShowWait(), and do_ps().

int Show_Key [static]

Definition at line 1097 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), CallBack_ShowWait(), and do_ps().

CLinearTimeAbsolute Show_lsaNow [static]

Definition at line 1089 of file cque.cpp.

Referenced by CallBack_ShowDispatches(), do_ps(), and ShowPsLine().

dbref Show_Object_Target [static]

Definition at line 1096 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), CallBack_ShowWait(), and do_ps().

dbref Show_Player [static]

Definition at line 1098 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), CallBack_ShowWait(), and do_ps().

dbref Show_Player_Target [static]

Definition at line 1095 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), CallBack_ShowWait(), and do_ps().

int Shown_RunQueueEntry [static]

Definition at line 1092 of file cque.cpp.

Referenced by CallBack_ShowWait(), and do_ps().

int Shown_SemaphoreTimeout [static]

Definition at line 1094 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), and do_ps().

int Total_RunQueueEntry [static]

Definition at line 1091 of file cque.cpp.

Referenced by CallBack_ShowWait(), and do_ps().

int Total_SemaphoreTimeout [static]

Definition at line 1093 of file cque.cpp.

Referenced by CallBack_ShowSemaphore(), and do_ps().

int Total_SystemTasks [static]

Definition at line 1090 of file cque.cpp.

Referenced by do_ps().

---