mux/src/predicates.cpp File Reference

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

Include dependency graph for predicates.cpp:

Go to the source code of this file.

Functions
char *DCL_CDECL	tprintf (const char *fmt,...)
void DCL_CDECL	safe_tprintf_str (char *str, char **bp, const char *fmt,...)
dbref	insert_first (dbref head, dbref thing)
dbref	remove_first (dbref head, dbref thing)
dbref	reverse_list (dbref list)
bool	member (dbref thing, dbref list)
bool	could_doit (dbref player, dbref thing, int locknum)
bool	can_see (dbref player, dbref thing, bool can_see_loc)
static bool	pay_quota (dbref who, int cost)
bool	canpayfees (dbref player, dbref who, int pennies, int quota)
bool	payfor (dbref who, int cost)
void	add_quota (dbref who, int payment)
void	giveto (dbref who, int pennies)
char *	MakeCanonicalObjectName (const char *pName, int *pnName, bool *pbValid)
char *	MakeCanonicalExitName (const char *pName, int *pnName, bool *pbValid)
bool	ValidatePlayerName (const char *pName)
bool	ok_password (const char *password, const char **pmsg)
void	handle_ears (dbref thing, bool could_hear, bool can_hear)
void	do_switch (dbref player, dbref caller, dbref enactor, int key, char *expr, char *args[], int nargs, char *cargs[], int ncargs)
void	do_if (dbref player, dbref caller, dbref enactor, int key, char *expr, char *args[], int nargs, char *cargs[], int ncargs)
void	do_addcommand (dbref player, dbref caller, dbref enactor, int key, int nargs, char *name, char *command)
void	do_listcommands (dbref player, dbref caller, dbref enactor, int key, char *name)
void	do_delcommand (dbref player, dbref caller, dbref enactor, int key, int nargs, char *name, char *command)
void	handle_prog (DESC *d, char *message)
void	do_quitprog (dbref player, dbref caller, dbref enactor, int key, char *name)
void	do_prog (dbref player, dbref caller, dbref enactor, int key, int nargs, char *name, char *command)
void	do_restart (dbref executor, dbref caller, dbref enactor, int key)
void	do_backup (dbref player, dbref caller, dbref enactor, int key)
void	do_comment (dbref player, dbref caller, dbref enactor, int key)
static dbref	promote_dflt (dbref old, dbref new0)
dbref	match_possessed (dbref player, dbref thing, char *target, dbref dflt, bool check_enter)
void	parse_range (char **name, dbref *low_bound, dbref *high_bound)
bool	parse_thing_slash (dbref player, char *thing, char **after, dbref *it)
bool	get_obj_and_lock (dbref player, char *what, dbref *it, ATTR **attr, char *errmsg, char **bufc)
bool	bCanReadAttr (dbref executor, dbref target, ATTR *tattr, bool bCheckParent)
bool	bCanSetAttr (dbref executor, dbref target, ATTR *tattr)
bool	bCanLockAttr (dbref executor, dbref target, ATTR *tattr)
dbref	where_is (dbref what)
dbref	where_room (dbref what)
bool	locatable (dbref player, dbref it, dbref enactor)
bool	nearby (dbref player, dbref thing)
bool	exit_visible (dbref exit, dbref player, int key)
bool	exit_displayable (dbref exit, dbref player, int key)
void	did_it (dbref player, dbref thing, int what, const char *def, int owhat, const char *odef, int awhat, char *args[], int nargs)
void	do_verb (dbref executor, dbref caller, dbref enactor, int key, char *victim_str, char *args[], int nargs)
void	OutOfMemory (const char *SourceFile, unsigned int LineNo)
bool	AssertionFailed (const char *SourceFile, unsigned int LineNo)

---

Function Documentation

void add_quota	(	dbref	who,
		int	payment
	)

Definition at line 276 of file predicates.cpp.

References A_RQUOTA, atr_add_raw(), atr_get, free_lbuf, mux_atol(), and mux_ltoa().

Referenced by chown_all(), destroy_obj(), do_chown(), and link_exit().

{
    dbref aowner;
    int aflags;
    char buf[20];

    char *quota = atr_get(who, A_RQUOTA, &aowner, &aflags);
    mux_ltoa(mux_atol(quota) + payment, buf);
    free_lbuf(quota);
    atr_add_raw(who, A_RQUOTA, buf);
}

bool AssertionFailed	(	const char *	SourceFile,
		unsigned int	LineNo
	)

Definition at line 2630 of file predicates.cpp.

References statedata::bCanRestart, statedata::bStandAlone, do_restart(), ENDLINE, CLogFile::Flush(), GOD, Log, mudstate, and CLogFile::tinyprintf().

{
    Log.tinyprintf("%s(%u): Assertion failed." ENDLINE, SourceFile, LineNo);
    Log.Flush();
    if (  !mudstate.bStandAlone
       && mudstate.bCanRestart)
    {
        do_restart(GOD, GOD, GOD, 0);
    }
    else
    {
        abort();
    }
    return false;
}

bool bCanLockAttr	(	dbref	executor,
		dbref	target,
		ATTR *	tattr
	)

Definition at line 1980 of file predicates.cpp.

References AF_CONST, AF_GOD, AF_INTERNAL, AF_IS_LOCK, AF_WIZARD, atr_get_info(), attr::flags, God, attr::number, Owner, and Wizard.

Referenced by do_lock(), and do_unlock().

{
    if (!tattr)
    {
        return false;
    }

    int mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST;
    if (!God(executor))
    {
        if (God(target))
        {
            return false;
        }
        if (Wizard(executor))
        {
            mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST|AF_GOD;
        }
        else
        {
            mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST|AF_WIZARD|AF_GOD;
        }
    }

    dbref aowner;
    int aflags;
    if (  (tattr->flags & mDeny)
       || !atr_get_info(target, tattr->number, &aowner, &aflags)
       || (aflags & mDeny))
    {
        return false;
    }
    else if (  Wizard(executor)
            || Owner(executor) == aowner)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool bCanReadAttr	(	dbref	executor,
		dbref	target,
		ATTR *	tattr,
		bool	bCheckParent
	)

Definition at line 1871 of file predicates.cpp.

References A_DESC, AF_DARK, AF_INTERNAL, AF_MDARK, AF_VISUAL, atr_get_info(), atr_pget_info(), statedata::bStandAlone, Examinable, attr::flags, God, mudconf, mudstate, nearby(), attr::number, Owner, confdata::read_rem_desc, and WizRoy.

Referenced by debug_examine(), do_decomp(), do_verb(), eval_boolexp(), exam_wildattrs(), find_wild_attrs(), FUNCTION(), get_handler(), hasattr_handler(), list_attraccess(), and look_atrs1().

{
    if (!tattr)
    {
        return false;
    }

    dbref aowner;
    int aflags;

    if (  !mudstate.bStandAlone
       && bCheckParent)
    {
        atr_pget_info(target, tattr->number, &aowner, &aflags);
    }
    else
    {
        atr_get_info(target, tattr->number, &aowner, &aflags);
    }

    int mAllow = AF_VISUAL;
    if (  (tattr->flags & mAllow)
       || (aflags & mAllow))
    {
        if (  mudstate.bStandAlone
           || tattr->number != A_DESC
           || mudconf.read_rem_desc
           || nearby(executor, target))
        {
            return true;
        }
    }
    int mDeny = 0;
    if (WizRoy(executor))
    {
        if (God(executor))
        {
            mDeny = AF_INTERNAL;
        }
        else
        {
            mDeny = AF_INTERNAL|AF_DARK;
        }
    }
    else if (  Owner(executor) == aowner
            || Examinable(executor, target))
    {
        mDeny = AF_INTERNAL|AF_DARK|AF_MDARK;
    }
    if (mDeny)
    {
        if (  (tattr->flags & mDeny)
           || (aflags & mDeny))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    return false;
}

bool bCanSetAttr	(	dbref	executor,
		dbref	target,
		ATTR *	tattr
	)

Definition at line 1935 of file predicates.cpp.

References AF_CONST, AF_GOD, AF_INTERNAL, AF_IS_LOCK, AF_LOCK, AF_WIZARD, atr_get_info(), Controls, attr::flags, God, attr::number, and Wizard.

Referenced by do_alias(), do_chown(), do_edit(), do_mvattr(), do_notify(), do_set(), do_wait(), do_wipe(), FUNCTION(), set_attr_internal(), and CGuests::WipeAttrs().

{
    if (!tattr)
    {
        return false;
    }

    int mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST;
    if (!God(executor))
    {
        if (God(target))
        {
            return false;
        }
        if (Wizard(executor))
        {
            mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST|AF_LOCK|AF_GOD;
        }
        else if (Controls(executor, target))
        {
            mDeny = AF_INTERNAL|AF_IS_LOCK|AF_CONST|AF_LOCK|AF_WIZARD|AF_GOD;
        }
        else
        {
            return false;
        }
    }

    dbref aowner;
    int aflags;
    if (  (tattr->flags & mDeny)
#ifdef FIRANMUX
       || Immutable(target)
#endif
       || (  atr_get_info(target, tattr->number, &aowner, &aflags)
          && (aflags & mDeny)))
    {
        return false;
    }
    else
    {
        return true;
    }
}

bool can_see	(	dbref	player,
		dbref	thing,
		bool	can_see_loc
	)

Definition at line 134 of file predicates.cpp.

References Connected, Dark, confdata::dark_sleepers, isExit, isPlayer, IsReal, Light, mudconf, MyopicExam, Puppet, and confdata::see_own_dark.

Referenced by look_contents().

{
    // Don't show if all the following apply: Sleeping players should not be
    // seen.  The thing is a disconnected player.  The player is not a
    // puppet.
    //
    if (  mudconf.dark_sleepers
       && isPlayer(thing)
       && !Connected(thing)
       && !Puppet(thing))
    {
        return false;
    }

    // You don't see yourself or exits.
    //
    if (  player == thing
       || isExit(thing))
    {
        return false;
    }

    // If loc is not dark, you see it if it's not dark or you control it.  If
    // loc is dark, you see it if you control it.  Seeing your own dark
    // objects is controlled by mudconf.see_own_dark.  In dark locations, you
    // also see things that are LIGHT and !DARK.
    //
    if (can_see_loc)
    {
#ifdef REALITY_LVLS
       return ((!Dark(thing) && IsReal(player, thing)) ||
#else
        return (!Dark(thing) ||
#endif /* REALITY_LVLS */
            (mudconf.see_own_dark && MyopicExam(player, thing)));
    }
    else
    {
#ifdef REALITY_LVLS
        return ((Light(thing) && !Dark(thing) && IsReal(player, thing)) ||
#else
        return ((Light(thing) && !Dark(thing)) ||
#endif /* REALITY_LVLS */
            (mudconf.see_own_dark && MyopicExam(player, thing)));
    }
}

bool canpayfees	(	dbref	player,
		dbref	who,
		int	pennies,
		int	quota
	)

Definition at line 217 of file predicates.cpp.

References Free_Money, confdata::many_coins, mudconf, notify, Owner, pay_quota(), payfor(), Pennies(), confdata::quotas, tprintf(), and Wizard.

Referenced by create_obj(), do_chown(), and link_exit().

{
    if (  !Wizard(who)
       && !Wizard(Owner(who))
       && !Free_Money(who)
       && !Free_Money(Owner(who))
       && (Pennies(Owner(who)) < pennies))
    {
        if (player == who)
        {
            notify(player, tprintf("Sorry, you don't have enough %s.",
                       mudconf.many_coins));
        }
        else
        {
            notify(player, tprintf("Sorry, that player doesn't have enough %s.",
                mudconf.many_coins));
        }
        return false;
    }
    if (mudconf.quotas)
    {
        if (!pay_quota(who, quota))
        {
            if (player == who)
            {
                notify(player, "Sorry, your building contract has run out.");
            }
            else
            {
                notify(player,
                    "Sorry, that player's building contract has run out.");
            }
            return false;
        }
    }
    payfor(who, pennies);
    return true;
}

bool could_doit	(	dbref	player,
		dbref	thing,
		int	locknum
	)

Definition at line 107 of file predicates.cpp.

References atr_get, eval_boolexp_atr(), free_lbuf, HOME, isPlayer, Key, and Pass_Locks.

Referenced by atr_match1(), check_zone_handler(), do_drop(), do_enter_internal(), do_get(), do_leave(), do_link(), do_teleport_single(), do_use(), fwdlist_load(), give_money(), give_thing(), link_exit(), look_in(), mail_check(), move_exit(), move_via_teleport(), notify_check(), open_exit(), page_check(), promote_match(), sp_ok(), test_join_access(), test_receive_access(), and test_transmit_access().

{
    if (thing == HOME)
    {
        return true;
    }

    // If nonplayer tries to get key, then no.
    //
    if (  !isPlayer(player)
       && Key(thing))
    {
        return false;
    }
    if (Pass_Locks(player))
    {
        return true;
    }

    dbref aowner;
    int   aflags;
    char *key = atr_get(thing, locknum, &aowner, &aflags);
    bool doit = eval_boolexp_atr(player, thing, thing, key);
    free_lbuf(key);
    return doit;
}

void did_it	(	dbref	player,
		dbref	thing,
		int	what,
		const char *	def,
		int	owhat,
		const char *	odef,
		int	awhat,
		char *	args[],
		int	nargs
	)

Definition at line 2261 of file predicates.cpp.

References A_CHARGES, A_RUNOUT, AF_HTML, alloc_lbuf, alloc_sbuf, atr_add_raw(), atr_pget, CMuxAlarm::bAlarmed, EV_EVAL, EV_FCHECK, EV_FIGNORE, EV_TOP, free_lbuf, free_sbuf, statedata::global_regs, Good_obj, Has_location, Html, IsReal, Location, MAX_GLOBAL_REGS, mudstate, mux_atol(), mux_exec(), mux_ltoa(), MuxAlarm, Name, NOTHING, notify, notify_except2(), notify_except2_rlevel(), notify_html, PopIntegers(), PopPointers(), PushIntegers(), PushPointers(), restore_global_regs(), safe_str, save_global_regs(), tprintf(), and wait_que().

Referenced by check_events(), do_clone(), do_drop(), do_enter_internal(), do_get(), do_kill(), do_leave(), do_teleport_single(), do_trigger(), do_use(), do_verb(), give_money(), give_thing(), look_in(), look_simple(), move_exit(), move_via_exit(), move_via_generic(), move_via_teleport(), notify_check(), process_enter_loc(), process_leave_loc(), process_preload(), send_mail(), show_a_desc(), and show_desc().

{
    if (MuxAlarm.bAlarmed)
    {
        return;
    }

    char *d, *buff, *act, *charges, *bp, *str;
    dbref loc, aowner;
    int num, aflags;

    // If we need to call exec() from within this function, we first save
    // the state of the global registers, in order to avoid munging them
    // inappropriately. Do note that the restoration to their original
    // values occurs BEFORE the execution of the @a-attribute. Therefore,
    // any changing of setq() values done in the @-attribute and @o-attribute
    // will NOT be passed on. This prevents odd behaviors that result from
    // odd @verbs and so forth (the idea is to preserve the caller's control
    // of the global register values).
    //

    bool need_pres = false;
    char **preserve = NULL;
    int *preserve_len = NULL;

    // message to player.
    //
    if (what > 0)
    {
        d = atr_pget(thing, what, &aowner, &aflags);
        if (*d)
        {
            need_pres = true;
            preserve = PushPointers(MAX_GLOBAL_REGS);
            preserve_len = PushIntegers(MAX_GLOBAL_REGS);
            save_global_regs("did_it_save", preserve, preserve_len);
            buff = bp = alloc_lbuf("did_it.1");
            str = d;
            mux_exec(buff, &bp, thing, player, player,
                EV_EVAL | EV_FIGNORE | EV_FCHECK | EV_TOP, &str, args, nargs);
            *bp = '\0';
            if (  (aflags & AF_HTML)
               && Html(player))
            {
                safe_str("\r\n", buff, &bp);
                *bp = '\0';
                notify_html(player, buff);
            }
            else
            {
                notify(player, buff);
            }
            free_lbuf(buff);
        }
        else if (def)
        {
            notify(player, def);
        }
        free_lbuf(d);
    }
    if (what < 0 && def)
    {
        notify(player, def);
    }

    // message to neighbors.
    //
    if (  owhat > 0
       && Has_location(player)
       && Good_obj(loc = Location(player)))
    {
        d = atr_pget(thing, owhat, &aowner, &aflags);
        if (*d)
        {
            if (!need_pres)
            {
                need_pres = true;
                preserve = PushPointers(MAX_GLOBAL_REGS);
                preserve_len = PushIntegers(MAX_GLOBAL_REGS);
                save_global_regs("did_it_save", preserve, preserve_len);
            }
            buff = bp = alloc_lbuf("did_it.2");
            str = d;
            mux_exec(buff, &bp, thing, player, player,
                     EV_EVAL | EV_FIGNORE | EV_FCHECK | EV_TOP, &str, args, nargs);
            *bp = '\0';
            if (*buff)
            {
#ifdef REALITY_LVLS
                notify_except2_rlevel(loc, player, player, thing, tprintf("%s %s", Name(player), buff));
#else
                notify_except2(loc, player, player, thing, tprintf("%s %s", Name(player), buff));
#endif /* REALITY_LVLS */
            }
            free_lbuf(buff);
        }
        else if (odef)
        {
#ifdef REALITY_LVLS
            notify_except2_rlevel(loc, player, player, thing, tprintf("%s %s", Name(player), odef));
#else
            notify_except2(loc, player, player, thing, tprintf("%s %s", Name(player), odef));
#endif /* REALITY_LVLS */
        }
        free_lbuf(d);
    }
    if (  owhat < 0
       && odef
       && Has_location(player)
       && Good_obj(loc = Location(player)))
    {
#ifdef REALITY_LVLS
        notify_except2_rlevel(loc, player, player, thing, tprintf("%s %s", Name(player), odef));
#else
        notify_except2(loc, player, player, thing, tprintf("%s %s", Name(player), odef));
#endif /* REALITY_LVLS */
    }

    // If we preserved the state of the global registers, restore them.
    //
    if (need_pres)
    {
        restore_global_regs("did_it_restore", preserve, preserve_len);
        PopIntegers(preserve_len, MAX_GLOBAL_REGS);
        PopPointers(preserve, MAX_GLOBAL_REGS);
    }

    // do the action attribute.
    //
#ifdef REALITY_LVLS
    if (awhat > 0 && IsReal(thing, player))
#else
    if (awhat > 0)
#endif /* REALITY_LVLS */
    {
        if (*(act = atr_pget(thing, awhat, &aowner, &aflags)))
        {
            charges = atr_pget(thing, A_CHARGES, &aowner, &aflags);
            if (*charges)
            {
                num = mux_atol(charges);
                if (num > 0)
                {
                    buff = alloc_sbuf("did_it.charges");
                    mux_ltoa(num-1, buff);
                    atr_add_raw(thing, A_CHARGES, buff);
                    free_sbuf(buff);
                }
                else if (*(buff = atr_pget(thing, A_RUNOUT, &aowner, &aflags)))
                {
                    free_lbuf(act);
                    act = buff;
                }
                else
                {
                    free_lbuf(act);
                    free_lbuf(buff);
                    free_lbuf(charges);
                    return;
                }
            }
            free_lbuf(charges);
            CLinearTimeAbsolute lta;
            wait_que(thing, player, player, false, lta, NOTHING, 0, act,
                args, nargs, mudstate.global_regs);
        }
        free_lbuf(act);
    }
}

void do_addcommand	(	dbref	player,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	name,
		char *	command
	)

Definition at line 768 of file predicates.cpp.

References CMDENT::addent, addedentry::atr, CMDENT::callseq, CMDENT::cmdname, statedata::command_htab, CS_ADDED, CS_LEADIN, CS_ONE_ARG, CMDENT::extra, hashaddLEN(), hashdeleteLEN(), hashfindLEN(), hashreplall(), CMDENT::hookmask, ISOUTOFMEMORY, MEMALLOC, mudstate, mux_strlwr(), addedentry::name, addedentry::next, NOPERM_MESSAGE, notify, attr::number, parse_attrib(), CMDENT::perms, RemoveSetOfCharacters(), See_attr, set_prefix_cmds(), StringClone(), strip_ansi(), CMDENT::switches, addedentry::thing, tprintf(), and UNUSED_PARAMETER.

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

    // Validate command name.
    //
    char *pName = NULL;
    if (1 <= nargs)
    {
        char *pStripped = strip_ansi(name);
        pName = RemoveSetOfCharacters(pStripped, "\r\n\t ");
        mux_strlwr(pName);
    }
    if (  !pName
       || pName[0] == '\0'
       || (  pName[0] == '_'
          && pName[1] == '_'))
    {
        notify(player, "That is not a valid command name.");
        return;
    }

    // Validate object/attribute.
    //
    dbref thing;
    ATTR *pattr;
    if (  !parse_attrib(player, command, &thing, &pattr)
       || !pattr)
    {
        notify(player, "No such attribute.");
        return;
    }
    if (!See_attr(player, thing, pattr))
    {
        notify(player, NOPERM_MESSAGE);
        return;
    }

    CMDENT *old = (CMDENT *)hashfindLEN(pName, strlen(pName),
        &mudstate.command_htab);

    CMDENT *cmd;
    ADDENT *add, *nextp;

    if (  old
       && (old->callseq & CS_ADDED))
    {
        // Don't allow the same (thing,atr) in the list.
        //
        for (nextp = old->addent; nextp != NULL; nextp = nextp->next)
        {
            if (  nextp->thing == thing
               && nextp->atr == pattr->number)
            {
                notify(player, tprintf("%s already added.", pName));
                return;
            }
        }

        // Otherwise, add another (thing,atr) to the list.
        //
        add = (ADDENT *)MEMALLOC(sizeof(ADDENT));
        ISOUTOFMEMORY(add);
        add->thing = thing;
        add->atr = pattr->number;
        add->name = StringClone(pName);
        add->next = old->addent;
        old->addent = add;
    }
    else
    {
        if (old)
        {
            // Delete the old built-in (which will later be added back as
            // __name).
            //
            hashdeleteLEN(pName, strlen(pName), &mudstate.command_htab);
        }

        cmd = (CMDENT *)MEMALLOC(sizeof(CMDENT));
        ISOUTOFMEMORY(cmd);
        cmd->cmdname = StringClone(pName);
        cmd->switches = NULL;
        cmd->perms = 0;
        cmd->extra = 0;
        if (  old
           && (old->callseq & CS_LEADIN))
        {
            cmd->callseq = CS_ADDED|CS_ONE_ARG|CS_LEADIN;
        }
        else
        {
            cmd->callseq = CS_ADDED|CS_ONE_ARG;
        }
        cmd->hookmask = 0;
        add = (ADDENT *)MEMALLOC(sizeof(ADDENT));
        ISOUTOFMEMORY(add);
        add->thing = thing;
        add->atr = pattr->number;
        add->name = StringClone(pName);
        add->next = NULL;
        cmd->addent = add;

        hashaddLEN(pName, strlen(pName), cmd, &mudstate.command_htab);

        if (  old
           && strcmp(pName, old->cmdname) == 0)
        {
            // We are @addcommand'ing over a built-in command by its
            // unaliased name, therefore, we want to re-target all the
            // aliases.
            //
            char *p = tprintf("__%s", pName);
            hashdeleteLEN(p, strlen(p), &mudstate.command_htab);
            hashreplall(old, cmd, &mudstate.command_htab);
            hashaddLEN(p, strlen(p), old, &mudstate.command_htab);
        }
    }

    // We reset the one letter commands here so you can overload them.
    //
    set_prefix_cmds();
    notify(player, tprintf("Command %s added.", pName));
}

void do_backup	(	dbref	player,
		dbref	caller,
		dbref	enactor,
		int	key
	)

Definition at line 1540 of file predicates.cpp.

References dump_database_internal(), DUMP_I_FLAT, DUMP_I_NORMAL, statedata::dumping, ENDLOG, confdata::indb, LOG_ALWAYS, log_name(), log_text(), mudconf, mudstate, notify, raw_broadcast(), STARTLOG, and tprintf().

{
#ifndef WIN32
    if (mudstate.dumping)
    {
        notify(player, "Dumping. Please try again later.");
    }
#endif // !WIN32

    raw_broadcast(0, "GAME: Backing up database. Please wait.");
    STARTLOG(LOG_ALWAYS, "WIZ", "BACK");
    log_text("Backup by ");
    log_name(player);
    ENDLOG;

#ifdef MEMORY_BASED
    // Invoking _backupflat.sh with an argument prompts the backup script
    // to use it as the flatfile.
    //
    dump_database_internal(DUMP_I_FLAT);
    system(tprintf("./_backupflat.sh %s.FLAT 1>&2", mudconf.indb));
#else // MEMORY_BASED
    // Invoking _backupflat.sh without an argument prompts the backup script
    // to use dbconvert itself.
    //
    dump_database_internal(DUMP_I_NORMAL);
    system(tprintf("./_backupflat.sh 1>&2"));
#endif // MEMORY_BASED
    raw_broadcast(0, "GAME: Backup finished.");
}

void do_comment	(	dbref	player,
		dbref	caller,
		dbref	enactor,
		int	key
	)

Definition at line 1576 of file predicates.cpp.

References UNUSED_PARAMETER.

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

void do_delcommand	(	dbref	player,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	name,
		char *	command
	)