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;