mux/src/wiz.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "attrs.h"
#include "command.h"
#include "file_c.h"
#include "powers.h"

Include dependency graph for wiz.cpp:

Go to the source code of this file.

Functions
static void	do_teleport_single (dbref executor, dbref caller, dbref enactor, int key, dbref victim, char *to)
void	do_teleport (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *arg1, char *arg2)
void	do_force_prefixed (dbref executor, dbref caller, dbref enactor, int key, char *command, char *args[], int nargs)
void	do_force (dbref executor, dbref caller, dbref enactor, int key, char *what, char *command, char *args[], int nargs)
void	do_toad (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *toad, char *newowner)
void	do_newpassword (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *name, char *password)
void	do_boot (dbref executor, dbref caller, dbref enactor, int key, char *name)
void	do_poor (dbref executor, dbref caller, dbref enactor, int key, char *arg1)
void	do_cut (dbref executor, dbref caller, dbref enactor, int key, char *thing)
void	do_motd (dbref executor, dbref caller, dbref enactor, int key, char *message)
void	do_global (dbref executor, dbref caller, dbref enactor, int key, char *flag)
Variables
NAMETAB	enable_names []

---

Function Documentation

void do_boot	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 502 of file wiz.cpp.

References boot_by_port(), boot_off(), BOOT_PORT, BOOT_QUIET, Can_Boot, ENDLOG, God, init_match(), is_integer(), isPlayer, log_name(), log_name_and_loc(), log_text(), LOG_WIZARD, match_absolute(), match_neighbor(), match_player(), mux_atol(), Name, noisy_match_result(), NOPERM_MESSAGE, NOTHING, notify, notify_quiet, STARTLOG, tprintf(), TYPE_PLAYER, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    if (!Can_Boot(executor))
    {
        notify(executor, NOPERM_MESSAGE);
        return;
    }

    dbref victim;
    int count;
    if (key & BOOT_PORT)
    {
        if (is_integer(name, NULL))
        {
            victim = mux_atol(name);
        }
        else
        {
            notify_quiet(executor, "That's not a number!");
            return;
        }
        STARTLOG(LOG_WIZARD, "WIZ", "BOOT");
        log_text(tprintf("Port %d", victim));
        log_text(" was @booted by ");
        log_name(executor);
        ENDLOG;
    }
    else
    {
        init_match(executor, name, TYPE_PLAYER);
        match_neighbor();
        match_absolute();
        match_player();
        if ((victim = noisy_match_result()) == NOTHING)
        {
            return;
        }

        if (God(victim))
        {
            notify_quiet(executor, "You cannot boot that player!");
            return;
        }
        if (  (  !isPlayer(victim)
              && !God(executor))
           || executor == victim)
        {
            notify_quiet(executor, "You can only boot off other players!");
            return;
        }
        STARTLOG(LOG_WIZARD, "WIZ", "BOOT");
        log_name_and_loc(victim);
        log_text(" was @booted by ");
        log_name(executor);
        ENDLOG;
        notify_quiet(executor, tprintf("You booted %s off!", Name(victim)));
    }

    const char *buf;
    if (key & BOOT_QUIET)
    {
        buf = NULL;
    }
    else
    {
        buf = tprintf("%s gently shows you the door.", Name(executor));
    }

    if (key & BOOT_PORT)
    {
        count = boot_by_port(victim, God(executor), buf);
    }
    else
    {
        count = boot_off(victim, buf);
    }
    notify_quiet(executor, tprintf("%d connection%s closed.", count, (count == 1 ? "" : "s")));
}

void do_cut	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	thing
	)

Definition at line 618 of file wiz.cpp.

References Good_obj, match_controlled, NOTHING, notify_quiet, s_Next, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    dbref object = match_controlled(executor, thing);
    if (Good_obj(object))
    {
        s_Next(object, NOTHING);
        notify_quiet(executor, "Cut.");
    }
}

void do_force	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	what,
		char *	command,
		char *	args[],
		int	nargs
	)

Definition at line 287 of file wiz.cpp.

References statedata::global_regs, match_controlled, mudstate, NOTHING, UNUSED_PARAMETER, and wait_que().

Referenced by do_force_prefixed().

{
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    dbref victim = match_controlled(executor, what);
    if (victim != NOTHING)
    {
        // Force victim to do command.
        //
        CLinearTimeAbsolute lta;
        wait_que(victim, caller, executor, false, lta, NOTHING, 0, command,
            args, nargs, mudstate.global_regs);
    }
}

void do_force_prefixed	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	command,
		char *	args[],
		int	nargs
	)

Definition at line 266 of file wiz.cpp.

References do_force(), mux_isspace, and parse_to().

{
    char *cp = parse_to(&command, ' ', 0);
    if (!command)
    {
        return;
    }
    while (mux_isspace(*command))
    {
        command++;
    }
    if (*command)
    {
        do_force(executor, caller, enactor, key, cp, command, args, nargs);
    }
}

void do_global	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	flag
	)

Definition at line 753 of file wiz.cpp.

References CF_DEQUEUE, confdata::control_flags, enable_names, ENDLOG, GLOB_DISABLE, GLOB_ENABLE, LOG_CONFIGMODS, log_name(), log_text(), mudconf, notify_quiet, PRIORITY_CF_DEQUEUE_DISABLED, PRIORITY_CF_DEQUEUE_ENABLED, Quiet, scheduler, search_nametab(), CScheduler::SetMinPriority(), STARTLOG, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    // Set or clear the indicated flag.
    //
    int flagvalue;
    if (!search_nametab(executor, enable_names, flag, &flagvalue))
    {
        notify_quiet(executor, "I don't know about that flag.");
    }
    else if (key == GLOB_ENABLE)
    {
        // Check for CF_DEQUEUE
        //
        if (flagvalue == CF_DEQUEUE)
        {
            scheduler.SetMinPriority(PRIORITY_CF_DEQUEUE_ENABLED);
        }
        mudconf.control_flags |= flagvalue;
        STARTLOG(LOG_CONFIGMODS, "CFG", "GLOBAL");
        log_name(executor);
        log_text(" enabled: ");
        log_text(flag);
        ENDLOG;
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Enabled.");
        }
    }
    else if (key == GLOB_DISABLE)
    {
        if (flagvalue == CF_DEQUEUE)
        {
            scheduler.SetMinPriority(PRIORITY_CF_DEQUEUE_DISABLED);
        }
        mudconf.control_flags &= ~flagvalue;
        STARTLOG(LOG_CONFIGMODS, "CFG", "GLOBAL");
        log_name(executor);
        log_text(" disabled: ");
        log_text(flag);
        ENDLOG;
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Disabled.");
        }
    }
    else
    {
        notify_quiet(executor, "Illegal combination of switches.");
    }
}

void do_motd	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	message
	)

Definition at line 635 of file wiz.cpp.

References confdata::downmotd_msg, FC_CONN_GUEST, FC_MOTD, FC_WIZMOTD, fcache_send(), confdata::fullmotd_msg, GBUF_SIZE, Guest, MOTD_ALL, MOTD_BRIEF, MOTD_DOWN, MOTD_FULL, MOTD_LIST, confdata::motd_msg, MOTD_WIZ, mudconf, notify_quiet, Quiet, tprintf(), UNUSED_PARAMETER, Wizard, and confdata::wizmotd_msg.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    bool is_brief = false;

    if (key & MOTD_BRIEF)
    {
        is_brief = true;
        key = key & ~MOTD_BRIEF;
        if (key == MOTD_ALL)
            key = MOTD_LIST;
        else if (key != MOTD_LIST)
            key |= MOTD_BRIEF;
    }
    switch (key)
    {
    case MOTD_ALL:

        strncpy(mudconf.motd_msg, message, GBUF_SIZE-1);
        mudconf.motd_msg[GBUF_SIZE-1] = '\0';
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Set: MOTD.");
        }
        break;

    case MOTD_WIZ:

        strncpy(mudconf.wizmotd_msg, message, GBUF_SIZE-1);
        mudconf.wizmotd_msg[GBUF_SIZE-1] = '\0';
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Set: Wizard MOTD.");
        }
        break;

    case MOTD_DOWN:

        strncpy(mudconf.downmotd_msg, message, GBUF_SIZE-1);
        mudconf.downmotd_msg[GBUF_SIZE-1] = '\0';
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Set: Down MOTD.");
        }
        break;

    case MOTD_FULL:

        strncpy(mudconf.fullmotd_msg, message, GBUF_SIZE-1);
        mudconf.fullmotd_msg[GBUF_SIZE-1] = '\0';
        if (!Quiet(executor))
        {
            notify_quiet(executor, "Set: Full MOTD.");
        }
        break;

    case MOTD_LIST:

        if (Wizard(executor))
        {
            if (!is_brief)
            {
                notify_quiet(executor, "----- motd file -----");
                fcache_send(executor, FC_MOTD);
                notify_quiet(executor, "----- wizmotd file -----");
                fcache_send(executor, FC_WIZMOTD);
                notify_quiet(executor, "----- motd messages -----");
            }
            notify_quiet(executor, tprintf("MOTD: %s", mudconf.motd_msg));
            notify_quiet( executor,
                          tprintf("Wizard MOTD: %s", mudconf.wizmotd_msg) );
            notify_quiet( executor,
                          tprintf("Down MOTD: %s", mudconf.downmotd_msg) );
            notify_quiet( executor,
                          tprintf("Full MOTD: %s", mudconf.fullmotd_msg) );
        }
        else
        {
            if (Guest(executor))
            {
                fcache_send(executor, FC_CONN_GUEST);
            }
            else
            {
                fcache_send(executor, FC_MOTD);
            }
            notify_quiet(executor, mudconf.motd_msg);
        }
        break;

    default:

        notify_quiet(executor, "Illegal combination of switches.");
    }
}

void do_newpassword	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	name,
		char *	password
	)

Definition at line 429 of file wiz.cpp.

References A_PASS, alloc_lbuf, atr_get, ChangePassword(), ENDLOG, free_lbuf, God, log_name(), log_text(), LOG_WIZARD, lookup_player(), Name, NOTHING, notify_quiet, ok_password(), safe_tprintf_str(), STARTLOG, and UNUSED_PARAMETER.

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

    dbref victim = lookup_player(executor, name, false);
    if (victim == NOTHING)
    {
        notify_quiet(executor, "No such player.");
        return;
    }
    const char *pmsg;
    if (  *password != '\0'
       && !ok_password(password, &pmsg))
    {
        // Can set null passwords, but not bad passwords.
        //
        notify_quiet(executor, pmsg);
        return;
    }
    if (God(victim))
    {
        bool bCan = true;
        if (God(executor))
        {
            // God can change her own password if it's missing.
            //
            int   aflags;
            dbref aowner;
            char *target = atr_get(executor, A_PASS, &aowner, &aflags);
            if (target[0] != '\0')
            {
                bCan = false;
            }
            free_lbuf(target);
        }
        else
        {
            bCan = false;
        }
        if (!bCan)
        {
            notify_quiet(executor, "You cannot change that player's password.");
            return;
        }
    }
    STARTLOG(LOG_WIZARD, "WIZ", "PASS");
    log_name(executor);
    log_text(" changed the password of ");
    log_name(victim);
    ENDLOG;

    // It's ok, do it.
    //
    ChangePassword(victim, password);
    notify_quiet(executor, "Password changed.");
    char *buf = alloc_lbuf("do_newpassword");
    char *bp = buf;
    safe_tprintf_str(buf, &bp, "Your password has been changed by %s.", Name(executor));
    notify_quiet(victim, buf);
    free_lbuf(buf);
}

void do_poor	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	arg1
	)

Definition at line 587 of file wiz.cpp.

References DO_WHOLE_DB, is_rational(), isPlayer, mux_atol(), Pennies(), s_Pennies(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(executor);
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    if (!is_rational(arg1))
    {
        return;
    }

    int amt = mux_atol(arg1);
    int curamt;
    dbref a;
    DO_WHOLE_DB(a)
    {
        if (isPlayer(a))
        {
            curamt = Pennies(a);
            if (amt < curamt)
            {
                s_Pennies(a, amt);
            }
        }
    }
}

void do_teleport	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	arg1,
		char *	arg2
	)

Definition at line 197 of file wiz.cpp.

References do_teleport_single(), Fixed, confdata::fixed_tel_msg, Good_obj, init_match(), match_everything(), mudconf, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), noisy_match_result(), notify, NOTYPE, Owner, Tel_Anywhere, and TELEPORT_LIST.

Referenced by FUNCTION().

{
    if (  (  Fixed(executor)
          || Fixed(Owner(executor)))
       && !Tel_Anywhere(executor))
    {
        notify(executor, mudconf.fixed_tel_msg);
        return;
    }

    // Get victim.
    //
    if (nargs == 1)
    {
        // Teleport executor to given destination.
        //
        do_teleport_single(executor, caller, enactor, key, executor, arg1);
    }
    else if (nargs == 2)
    {
        // Teleport 3rd part(y/ies) to given destination.
        //
        if (key & TELEPORT_LIST)
        {
            // We have a space-delimited list of victims.
            //
            char *p;
            MUX_STRTOK_STATE tts;
            mux_strtok_src(&tts, arg1);
            mux_strtok_ctl(&tts, " ");
            for (p = mux_strtok_parse(&tts); p; p = mux_strtok_parse(&tts))
            {
                init_match(executor, p, NOTYPE);
                match_everything(0);
                dbref victim = noisy_match_result();

                if (Good_obj(victim))
                {
                    do_teleport_single(executor, caller, enactor, key, victim,
                        arg2);
                }
            }
        }
        else
        {
            init_match(executor, arg1, NOTYPE);
            match_everything(0);
            dbref victim = noisy_match_result();

            if (Good_obj(victim))
            {
                do_teleport_single(executor, caller, enactor, key, victim,
                    arg2);
            }
        }
    }
}

static void do_teleport_single	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		dbref	victim,
		char *	to
	)			[static]

Definition at line 17 of file wiz.cpp.

References A_ATFAIL, A_LTPORT, A_OTFAIL, A_TFAIL, AMBIGUOUS, Controls, could_doit(), did_it(), Exits, confdata::fascist_tport, God, Good_obj, Has_contents, Has_location, Home, HOME, HUSH_ENTER, HUSH_LEAVE, init_match(), isExit, isGarbage, isRoom, Jump_ok, Location, match_everything(), match_result(), move_exit(), move_via_teleport(), mudconf, NOPERM_MESSAGE, NOTHING, notify_quiet, NOTYPE, Quiet, string_compare(), Tel_Anything, Tel_Anywhere, TELEPORT_QUIET, UNUSED_PARAMETER, and where_room().

Referenced by do_teleport().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref loc;
    int   hush = 0;

    // Validate type of victim.
    //
    if (  !Good_obj(victim)
       || isRoom(victim))
    {
        notify_quiet(executor, "You can't teleport that.");
        return;
    }

    // Fail if we don't control the victim or the victim's location.
    //
    if (  !Controls(executor, victim)
       && !Controls(executor, isExit(victim) ? Exits(victim) : Location(victim))
       && !Tel_Anything(executor))
    {
        notify_quiet(executor, NOPERM_MESSAGE);
        return;
    }

    // Check for teleporting home
    //
    if (!string_compare(to, "home"))
    {
        if (isExit(victim))
        {
            notify_quiet(executor, "Bad destination.");
        }
        else
        {
            move_via_teleport(victim, HOME, enactor, 0);
        }
        return;
    }

    // Find out where to send the victim.
    //
    init_match(executor, to, NOTYPE);
    match_everything(0);
    dbref destination = match_result();

    switch (destination)
    {
    case NOTHING:

        notify_quiet(executor, "No match.");
        return;

    case AMBIGUOUS:

        notify_quiet(executor, "I don't know which destination you mean!");
        return;

    default:

        if (victim == destination)
        {
            notify_quiet(executor, "Bad destination.");
            return;
        }
    }

    // If fascist teleport is on, you must control the victim's ultimate
    // location (after LEAVEing any objects) or it must be JUMP_OK.
    //
    if (mudconf.fascist_tport)
    {
        if (isExit(victim))
        {
            loc = where_room(Home(victim));
        }
        else
        {
            loc = where_room(victim);
        }

        if (  !Good_obj(loc)
           || !isRoom(loc)
           || !( Controls(executor, loc)
              || Jump_ok(loc)
              || Tel_Anywhere(executor)))
        {
            notify_quiet(executor, NOPERM_MESSAGE);
            return;
        }
    }
    if (  isGarbage(destination)
       || (  Has_location(destination)
          && isGarbage(Location(destination))))
    {
        // @Teleporting into garbage is never permitted.
        //
        notify_quiet(executor, "Bad destination.");
        return;
    }
    else if (Has_contents(destination))
    {
        // You must control the destination, or it must be a JUMP_OK
        // room where you pass its TELEPORT lock.
        //
        if (  !(  Controls(executor, destination)
               || Jump_ok(destination)
               || Tel_Anywhere(executor))
           || !could_doit(executor, destination, A_LTPORT)
           || (  isExit(victim)
              && God(destination)
              && !God(executor)))
        {
            // Nope, report failure.
            //
            if (executor != victim)
            {
                notify_quiet(executor, NOPERM_MESSAGE);
            }
            did_it(victim, destination,
                   A_TFAIL, "You can't teleport there!",
                   A_OTFAIL, 0, A_ATFAIL, (char **)NULL, 0);
            return;
        }

        // We're OK, do the teleport.
        //
        if (key & TELEPORT_QUIET)
        {
            hush = HUSH_ENTER | HUSH_LEAVE;
        }

        if (move_via_teleport(victim, destination, enactor, hush))
        {
            if (executor != victim)
            {
                if (!Quiet(executor))
                {
                    notify_quiet(executor, "Teleported.");
                }
            }
        }
    }
    else if (isExit(destination))
    {
        if (isExit(victim))
        {
            if (executor != victim)
            {
                notify_quiet(executor, "Bad destination.");
            }
            did_it(victim, destination,
                   A_TFAIL, "You can't teleport there!",
                   A_OTFAIL, 0, A_ATFAIL, (char **)NULL, 0);
            return;
        }
        else
        {
            if (Exits(destination) == Location(victim))
            {
                move_exit(victim, destination, false, "You can't go that way.", 0);
            }
            else
            {
                notify_quiet(executor, "I can't find that exit.");
            }
        }
    }
}

void do_toad	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	toad,
		char *	newowner
	)

Definition at line 308 of file wiz.cpp.

References A_ALIAS, alloc_mbuf, atr_pget, boot_off(), chown_all(), CHOWN_NOZONE, delete_player_name(), ENDLOG, FLAG_WORD1, FLAG_WORD2, FLAG_WORD3, free_lbuf, free_mbuf, Good_obj, HALT, init_match(), isPlayer, Location, log_name(), log_name_and_loc(), log_text(), LOG_WIZARD, match_absolute(), match_neighbor(), match_player(), mudconf, Name, No_Destroy, noisy_match_result(), NOTHING, notify_except2(), notify_quiet, ReleaseAllResources(), s_Flags, s_Name(), s_Owner, s_Pennies(), s_Zone, STARTLOG, TOAD_NO_CHOWN, confdata::toad_recipient, tprintf(), TYPE_PLAYER, TYPE_THING, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref victim, recipient, loc, aowner;
    char *buf;
    int count, aflags;

    init_match(executor, toad, TYPE_PLAYER);
    match_neighbor();
    match_absolute();
    match_player();
    if (!Good_obj(victim = noisy_match_result()))
    {
        return;
    }

    if (!isPlayer(victim))
    {
        notify_quiet(executor, "Try @destroy instead.");
        return;
    }
    if (No_Destroy(victim))
    {
        notify_quiet(executor, "You can't toad that player.");
        return;
    }
    if (  nargs == 2
       && *newowner )
    {
        init_match(executor, newowner, TYPE_PLAYER);
        match_neighbor();
        match_absolute();
        match_player();
        if ((recipient = noisy_match_result()) == NOTHING)
        {
            return;
        }
    }
    else
    {
        if (mudconf.toad_recipient == NOTHING)
        {
            recipient = executor;
        }
        else
        {
            recipient = mudconf.toad_recipient;
        }
    }

    STARTLOG(LOG_WIZARD, "WIZ", "TOAD");
    log_name_and_loc(victim);
    log_text(" was @toaded by ");
    log_name(executor);
    ENDLOG;

    // Clear everything out.
    //
    if (key & TOAD_NO_CHOWN)
    {
        count = -1;
    }
    else
    {
        // You get it.
        //
        count = chown_all(victim, recipient, executor, CHOWN_NOZONE);
        s_Owner(victim, recipient);
        s_Zone(victim, NOTHING);
    }
    s_Flags(victim, FLAG_WORD1, TYPE_THING | HALT);
    s_Flags(victim, FLAG_WORD2, 0);
    s_Flags(victim, FLAG_WORD3, 0);
    s_Pennies(victim, 1);

    // Notify people.
    //
    loc = Location(victim);
    buf = alloc_mbuf("do_toad");
    const char *pVictimName = Name(victim);
    sprintf(buf, "%s has been turned into a slimy toad!", pVictimName);
    notify_except2(loc, executor, victim, executor, buf);
    sprintf(buf, "You toaded %s! (%d objects @chowned)", pVictimName, count + 1);
    notify_quiet(executor, buf);

    // Zap the name from the name hash table.
    //
    sprintf(buf, "a slimy toad named %s", pVictimName);
    delete_player_name(victim, pVictimName);
    s_Name(victim, buf);
    free_mbuf(buf);

    // Zap the alias, too.
    //
    buf = atr_pget(victim, A_ALIAS, &aowner, &aflags);
    delete_player_name(victim, buf);
    free_lbuf(buf);

    // Boot off.
    //
    count = boot_off(victim, "You have been turned into a slimy toad!");

    // Release comsys and @mail resources.
    //
    ReleaseAllResources(victim);

    buf = tprintf("%d connection%s closed.", count, (count == 1 ? "" : "s"));
    notify_quiet(executor, buf);
}

---

Variable Documentation

NAMETAB enable_names[]

Initial value:

{
    {"building",        1,  CA_PUBLIC,  CF_BUILD},
    {"checkpointing",   2,  CA_PUBLIC,  CF_CHECKPOINT},
    {"cleaning",        2,  CA_PUBLIC,  CF_DBCHECK},
    {"dequeueing",      1,  CA_PUBLIC,  CF_DEQUEUE},


 
    {"idlechecking",    2,  CA_PUBLIC,  CF_IDLECHECK},
    {"interpret",       2,  CA_PUBLIC,  CF_INTERP},
    {"logins",          3,  CA_PUBLIC,  CF_LOGIN},
    {"guests",          2,  CA_PUBLIC,  CF_GUEST},
    {"eventchecking",   2,  CA_PUBLIC,  CF_EVENTCHECK},
    { NULL,             0,  0,          0}
}

Definition at line 736 of file wiz.cpp.

Referenced by do_global(), and do_list().

---